Implement Windows SysMenu handling

Sine Striker

2024-05-07 e0b59294fc9e9dc8198b8c504860353b6bec0124

 src/core/contexts/win32windowcontext.cpp

@@ -6,13 +6,16 @@

#include <optional>

#include <QtCore/QAbstractEventDispatcher>
#include <QtCore/QDateTime>
#include <QtCore/QHash>
#include <QtCore/QScopeGuard>
#include <QtCore/QTimer>
#include <QtCore/QDateTime>
#include <QtGui/QGuiApplication>
#include <QtGui/QPainter>
#include <QtGui/QPalette>

#include <QtGui/qpa/qwindowsysteminterface.h>

#include <QtGui/private/qhighdpiscaling_p.h>
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
@@ -29,6 +32,304 @@

#include "qwkglobal_p.h"
#include "qwkwindowsextra_p.h"

static QHash<int, const wchar_t *> xmsgHash = //
    {
  //
        {0,    L"WM_NULL"                  },
        {1,    L"WM_CREATE"                },
        {2,    L"WM_DESTROY"               },
        {3,    L"WM_MOVE"                  },
        {5,    L"WM_SIZE"                  },
        {6,    L"WM_ACTIVATE"              },
        {7,    L"WM_SETFOCUS"              },
        {8,    L"WM_KILLFOCUS"             },
        {10,   L"WM_ENABLE"                },
        {11,   L"WM_SETREDRAW"             },
        {12,   L"WM_SETTEXT"               },
        {13,   L"WM_GETTEXT"               },
        {14,   L"WM_GETTEXTLENGTH"         },
        {15,   L"WM_PAINT"                 },
        {16,   L"WM_CLOSE"                 },
        {17,   L"WM_QUERYENDSESSION"       },
        {18,   L"WM_QUIT"                  },
        {19,   L"WM_QUERYOPEN"             },
        {20,   L"WM_ERASEBKGND"            },
        {21,   L"WM_SYSCOLORCHANGE"        },
        {22,   L"WM_ENDSESSION"            },
        {24,   L"WM_SHOWWINDOW"            },
        {25,   L"WM_CTLCOLOR"              },
        {26,   L"WM_WININICHANGE"          },
        {27,   L"WM_DEVMODECHANGE"         },
        {28,   L"WM_ACTIVATEAPP"           },
        {29,   L"WM_FONTCHANGE"            },
        {30,   L"WM_TIMECHANGE"            },
        {31,   L"WM_CANCELMODE"            },
        {32,   L"WM_SETCURSOR"             },
        {33,   L"WM_MOUSEACTIVATE"         },
        {34,   L"WM_CHILDACTIVATE"         },
        {35,   L"WM_QUEUESYNC"             },
        {36,   L"WM_GETMINMAXINFO"         },
        {38,   L"WM_PAINTICON"             },
        {39,   L"WM_ICONERASEBKGND"        },
        {40,   L"WM_NEXTDLGCTL"            },
        {42,   L"WM_SPOOLERSTATUS"         },
        {43,   L"WM_DRAWITEM"              },
        {44,   L"WM_MEASUREITEM"           },
        {45,   L"WM_DELETEITEM"            },
        {46,   L"WM_VKEYTOITEM"            },
        {47,   L"WM_CHARTOITEM"            },
        {48,   L"WM_SETFONT"               },
        {49,   L"WM_GETFONT"               },
        {50,   L"WM_SETHOTKEY"             },
        {51,   L"WM_GETHOTKEY"             },
        {55,   L"WM_QUERYDRAGICON"         },
        {57,   L"WM_COMPAREITEM"           },
        {61,   L"WM_GETOBJECT"             },
        {65,   L"WM_COMPACTING"            },
        {68,   L"WM_COMMNOTIFY"            },
        {70,   L"WM_WINDOWPOSCHANGING"     },
        {71,   L"WM_WINDOWPOSCHANGED"      },
        {72,   L"WM_POWER"                 },
        {73,   L"WM_COPYGLOBALDATA"        },
        {74,   L"WM_COPYDATA"              },
        {75,   L"WM_CANCELJOURNAL"         },
        {78,   L"WM_NOTIFY"                },
        {80,   L"WM_INPUTLANGCHANGEREQUEST"},
        {81,   L"WM_INPUTLANGCHANGE"       },
        {82,   L"WM_TCARD"                 },
        {83,   L"WM_HELP"                  },
        {84,   L"WM_USERCHANGED"           },
        {85,   L"WM_NOTIFYFORMAT"          },
        {123,  L"WM_CONTEXTMENU"           },
        {124,  L"WM_STYLECHANGING"         },
        {125,  L"WM_STYLECHANGED"          },
        {126,  L"WM_DISPLAYCHANGE"         },
        {127,  L"WM_GETICON"               },
        {128,  L"WM_SETICON"               },
        {129,  L"WM_NCCREATE"              },
        {130,  L"WM_NCDESTROY"             },
        {131,  L"WM_NCCALCSIZE"            },
        {132,  L"WM_NCHITTEST"             },
        {133,  L"WM_NCPAINT"               },
        {134,  L"WM_NCACTIVATE"            },
        {135,  L"WM_GETDLGCODE"            },
        {136,  L"WM_SYNCPAINT"             },
        {160,  L"WM_NCMOUSEMOVE"           },
        {161,  L"WM_NCLBUTTONDOWN"         },
        {162,  L"WM_NCLBUTTONUP"           },
        {163,  L"WM_NCLBUTTONDBLCLK"       },
        {164,  L"WM_NCRBUTTONDOWN"         },
        {165,  L"WM_NCRBUTTONUP"           },
        {166,  L"WM_NCRBUTTONDBLCLK"       },
        {167,  L"WM_NCMBUTTONDOWN"         },
        {168,  L"WM_NCMBUTTONUP"           },
        {169,  L"WM_NCMBUTTONDBLCLK"       },
        {171,  L"WM_NCXBUTTONDOWN"         },
        {172,  L"WM_NCXBUTTONUP"           },
        {173,  L"WM_NCXBUTTONDBLCLK"       },
        {176,  L"EM_GETSEL"                },
        {177,  L"EM_SETSEL"                },
        {178,  L"EM_GETRECT"               },
        {179,  L"EM_SETRECT"               },
        {180,  L"EM_SETRECTNP"             },
        {181,  L"EM_SCROLL"                },
        {182,  L"EM_LINESCROLL"            },
        {183,  L"EM_SCROLLCARET"           },
        {185,  L"EM_GETMODIFY"             },
        {187,  L"EM_SETMODIFY"             },
        {188,  L"EM_GETLINECOUNT"          },
        {189,  L"EM_LINEINDEX"             },
        {190,  L"EM_SETHANDLE"             },
        {191,  L"EM_GETHANDLE"             },
        {192,  L"EM_GETTHUMB"              },
        {193,  L"EM_LINELENGTH"            },
        {194,  L"EM_REPLACESEL"            },
        {195,  L"EM_SETFONT"               },
        {196,  L"EM_GETLINE"               },
        {197,  L"EM_LIMITTEXT"             },
        {197,  L"EM_SETLIMITTEXT"          },
        {198,  L"EM_CANUNDO"               },
        {199,  L"EM_UNDO"                  },
        {200,  L"EM_FMTLINES"              },
        {201,  L"EM_LINEFROMCHAR"          },
        {202,  L"EM_SETWORDBREAK"          },
        {203,  L"EM_SETTABSTOPS"           },
        {204,  L"EM_SETPASSWORDCHAR"       },
        {205,  L"EM_EMPTYUNDOBUFFER"       },
        {206,  L"EM_GETFIRSTVISIBLELINE"   },
        {207,  L"EM_SETREADONLY"           },
        {209,  L"EM_SETWORDBREAKPROC"      },
        {209,  L"EM_GETWORDBREAKPROC"      },
        {210,  L"EM_GETPASSWORDCHAR"       },
        {211,  L"EM_SETMARGINS"            },
        {212,  L"EM_GETMARGINS"            },
        {213,  L"EM_GETLIMITTEXT"          },
        {214,  L"EM_POSFROMCHAR"           },
        {215,  L"EM_CHARFROMPOS"           },
        {216,  L"EM_SETIMESTATUS"          },
        {217,  L"EM_GETIMESTATUS"          },
        {224,  L"SBM_SETPOS"               },
        {225,  L"SBM_GETPOS"               },
        {226,  L"SBM_SETRANGE"             },
        {227,  L"SBM_GETRANGE"             },
        {228,  L"SBM_ENABLE_ARROWS"        },
        {230,  L"SBM_SETRANGEREDRAW"       },
        {233,  L"SBM_SETSCROLLINFO"        },
        {234,  L"SBM_GETSCROLLINFO"        },
        {235,  L"SBM_GETSCROLLBARINFO"     },
        {240,  L"BM_GETCHECK"              },
        {241,  L"BM_SETCHECK"              },
        {242,  L"BM_GETSTATE"              },
        {243,  L"BM_SETSTATE"              },
        {244,  L"BM_SETSTYLE"              },
        {245,  L"BM_CLICK"                 },
        {246,  L"BM_GETIMAGE"              },
        {247,  L"BM_SETIMAGE"              },
        {248,  L"BM_SETDONTCLICK"          },
        {255,  L"WM_INPUT"                 },
        {256,  L"WM_KEYDOWN"               },
        {256,  L"WM_KEYFIRST"              },
        {257,  L"WM_KEYUP"                 },
        {258,  L"WM_CHAR"                  },
        {259,  L"WM_DEADCHAR"              },
        {260,  L"WM_SYSKEYDOWN"            },
        {261,  L"WM_SYSKEYUP"              },
        {262,  L"WM_SYSCHAR"               },
        {263,  L"WM_SYSDEADCHAR"           },
        {264,  L"WM_KEYLAST"               },
        {265,  L"WM_UNICHAR"               },
        {265,  L"WM_WNT_CONVERTREQUESTEX"  },
        {266,  L"WM_CONVERTREQUEST"        },
        {267,  L"WM_CONVERTRESULT"         },
        {268,  L"WM_INTERIM"               },
        {269,  L"WM_IME_STARTCOMPOSITION"  },
        {270,  L"WM_IME_ENDCOMPOSITION"    },
        {271,  L"WM_IME_COMPOSITION"       },
        {271,  L"WM_IME_KEYLAST"           },
        {272,  L"WM_INITDIALOG"            },
        {273,  L"WM_COMMAND"               },
        {274,  L"WM_SYSCOMMAND"            },
        {275,  L"WM_TIMER"                 },
        {276,  L"WM_HSCROLL"               },
        {277,  L"WM_VSCROLL"               },
        {278,  L"WM_INITMENU"              },
        {279,  L"WM_INITMENUPOPUP"         },
        {280,  L"WM_SYSTIMER"              },
        {287,  L"WM_MENUSELECT"            },
        {288,  L"WM_MENUCHAR"              },
        {289,  L"WM_ENTERIDLE"             },
        {290,  L"WM_MENURBUTTONUP"         },
        {291,  L"WM_MENUDRAG"              },
        {292,  L"WM_MENUGETOBJECT"         },
        {293,  L"WM_UNINITMENUPOPUP"       },
        {294,  L"WM_MENUCOMMAND"           },
        {295,  L"WM_CHANGEUISTATE"         },
        {296,  L"WM_UPDATEUISTATE"         },
        {297,  L"WM_QUERYUISTATE"          },
        {306,  L"WM_CTLCOLORMSGBOX"        },
        {307,  L"WM_CTLCOLOREDIT"          },
        {308,  L"WM_CTLCOLORLISTBOX"       },
        {309,  L"WM_CTLCOLORBTN"           },
        {310,  L"WM_CTLCOLORDLG"           },
        {311,  L"WM_CTLCOLORSCROLLBAR"     },
        {312,  L"WM_CTLCOLORSTATIC"        },
        {512,  L"WM_MOUSEFIRST"            },
        {512,  L"WM_MOUSEMOVE"             },
        {513,  L"WM_LBUTTONDOWN"           },
        {514,  L"WM_LBUTTONUP"             },
        {515,  L"WM_LBUTTONDBLCLK"         },
        {516,  L"WM_RBUTTONDOWN"           },
        {517,  L"WM_RBUTTONUP"             },
        {518,  L"WM_RBUTTONDBLCLK"         },
        {519,  L"WM_MBUTTONDOWN"           },
        {520,  L"WM_MBUTTONUP"             },
        {521,  L"WM_MBUTTONDBLCLK"         },
        {521,  L"WM_MOUSELAST"             },
        {522,  L"WM_MOUSEWHEEL"            },
        {523,  L"WM_XBUTTONDOWN"           },
        {524,  L"WM_XBUTTONUP"             },
        {525,  L"WM_XBUTTONDBLCLK"         },
        {528,  L"WM_PARENTNOTIFY"          },
        {529,  L"WM_ENTERMENULOOP"         },
        {530,  L"WM_EXITMENULOOP"          },
        {531,  L"WM_NEXTMENU"              },
        {532,  L"WM_SIZING"                },
        {533,  L"WM_CAPTURECHANGED"        },
        {534,  L"WM_MOVING"                },
        {536,  L"WM_POWERBROADCAST"        },
        {537,  L"WM_DEVICECHANGE"          },
        {544,  L"WM_MDICREATE"             },
        {545,  L"WM_MDIDESTROY"            },
        {546,  L"WM_MDIACTIVATE"           },
        {547,  L"WM_MDIRESTORE"            },
        {548,  L"WM_MDINEXT"               },
        {549,  L"WM_MDIMAXIMIZE"           },
        {550,  L"WM_MDITILE"               },
        {551,  L"WM_MDICASCADE"            },
        {552,  L"WM_MDIICONARRANGE"        },
        {553,  L"WM_MDIGETACTIVE"          },
        {560,  L"WM_MDISETMENU"            },
        {561,  L"WM_ENTERSIZEMOVE"         },
        {562,  L"WM_EXITSIZEMOVE"          },
        {563,  L"WM_DROPFILES"             },
        {564,  L"WM_MDIREFRESHMENU"        },
        {640,  L"WM_IME_REPORT"            },
        {641,  L"WM_IME_SETCONTEXT"        },
        {642,  L"WM_IME_NOTIFY"            },
        {643,  L"WM_IME_CONTROL"           },
        {644,  L"WM_IME_COMPOSITIONFULL"   },
        {645,  L"WM_IME_SELECT"            },
        {646,  L"WM_IME_CHAR"              },
        {648,  L"WM_IME_REQUEST"           },
        {656,  L"WM_IMEKEYDOWN"            },
        {656,  L"WM_IME_KEYDOWN"           },
        {657,  L"WM_IMEKEYUP"              },
        {657,  L"WM_IME_KEYUP"             },
        {672,  L"WM_NCMOUSEHOVER"          },
        {673,  L"WM_MOUSEHOVER"            },
        {674,  L"WM_NCMOUSELEAVE"          },
        {675,  L"WM_MOUSELEAVE"            },
        {768,  L"WM_CUT"                   },
        {769,  L"WM_COPY"                  },
        {770,  L"WM_PASTE"                 },
        {771,  L"WM_CLEAR"                 },
        {772,  L"WM_UNDO"                  },
        {773,  L"WM_RENDERFORMAT"          },
        {774,  L"WM_RENDERALLFORMATS"      },
        {775,  L"WM_DESTROYCLIPBOARD"      },
        {776,  L"WM_DRAWCLIPBOARD"         },
        {777,  L"WM_PAINTCLIPBOARD"        },
        {778,  L"WM_VSCROLLCLIPBOARD"      },
        {779,  L"WM_SIZECLIPBOARD"         },
        {780,  L"WM_ASKCBFORMATNAME"       },
        {781,  L"WM_CHANGECBCHAIN"         },
        {782,  L"WM_HSCROLLCLIPBOARD"      },
        {783,  L"WM_QUERYNEWPALETTE"       },
        {784,  L"WM_PALETTEISCHANGING"     },
        {785,  L"WM_PALETTECHANGED"        },
        {786,  L"WM_HOTKEY"                },
        {791,  L"WM_PRINT"                 },
        {792,  L"WM_PRINTCLIENT"           },
        {793,  L"WM_APPCOMMAND"            },
        {856,  L"WM_HANDHELDFIRST"         },
        {863,  L"WM_HANDHELDLAST"          },
        {864,  L"WM_AFXFIRST"              },
        {895,  L"WM_AFXLAST"               },
        {896,  L"WM_PENWINFIRST"           },
        {897,  L"WM_RCRESULT"              },
        {898,  L"WM_HOOKRCRESULT"          },
        {899,  L"WM_GLOBALRCCHANGE"        },
        {899,  L"WM_PENMISCINFO"           },
        {900,  L"WM_SKB"                   },
        {901,  L"WM_HEDITCTL"              },
        {901,  L"WM_PENCTL"                },
        {902,  L"WM_PENMISC"               },
        {903,  L"WM_CTLINIT"               },
        {904,  L"WM_PENEVENT"              },
        {911,  L"WM_PENWINLAST"            },
        {1024, L"WM_USER"                  },
};

namespace QWK {

@@ -153,7 +454,7 @@
        [[maybe_unused]] const auto &cleaner =
            qScopeGuard([windowThreadProcessId, currentThreadId]() {
                ::AttachThreadInput(windowThreadProcessId, currentThreadId, FALSE); //
            });
            }); // TODO: Remove it

        ::BringWindowToTop(hwnd);
        // Activate the window too. This will force us to the virtual desktop this
@@ -230,14 +531,15 @@
        apis.ptimeEndPeriod(ms_granularity);
    }

    static void showSystemMenu2(HWND hWnd, const POINT &pos, const bool selectFirstEntry,
                                const bool fixedSize) {
    // Returns false if the menu is canceled
    static bool showSystemMenu_sys(HWND hWnd, const POINT &pos, const bool selectFirstEntry,
                                   const bool fixedSize) {
        HMENU hMenu = ::GetSystemMenu(hWnd, FALSE);
        if (!hMenu) {
            // The corresponding window doesn't have a system menu, most likely due to the
            // lack of the "WS_SYSMENU" window style. This situation should not be treated
            // as an error so just ignore it and return early.
            return;
            return true;
        }

        const bool maxOrFull = IsMaximized(hWnd) || isFullScreen(hWnd);
@@ -281,7 +583,8 @@
        // Popup the system menu at the required position.
        const auto result = ::TrackPopupMenu(
            hMenu,
            (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN)),
            (TPM_RETURNCMD | (QGuiApplication::isRightToLeft() ? TPM_RIGHTALIGN : TPM_LEFTALIGN) |
             TPM_RIGHTBUTTON),
            pos.x, pos.y, 0, hWnd, nullptr);

        // Unhighlight the first menu item after the popup menu is closed, otherwise it will keep
@@ -290,11 +593,12 @@

        if (!result) {
            // The user canceled the menu, no need to continue.
            return;
            return false;
        }

        // Send the command that the user chooses to the corresponding window.
        ::PostMessageW(hWnd, WM_SYSCOMMAND, result, 0);
        return true;
    }

    static inline Win32WindowContext::WindowPart getHitWindowPart(int hitTestResult) {
@@ -359,6 +663,107 @@
        return true;
    }

    static inline constexpr bool isNonClientMessage(const UINT message) {
        if (((message >= WM_NCCREATE) && (message <= WM_NCACTIVATE)) ||
            ((message >= WM_NCMOUSEMOVE) && (message <= WM_NCMBUTTONDBLCLK)) ||
            ((message >= WM_NCXBUTTONDOWN) && (message <= WM_NCXBUTTONDBLCLK))
#if (WINVER >= _WIN32_WINNT_WIN8)
            || ((message >= WM_NCPOINTERUPDATE) && (message <= WM_NCPOINTERUP))
#endif
            || ((message == WM_NCMOUSEHOVER) || (message == WM_NCMOUSELEAVE))) {
            return true;
        } else {
            return false;
        }
    }

    static MSG createMessageBlock(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
        MSG msg;
        msg.hwnd = hWnd;       // re-create MSG structure
        msg.message = message; // time and pt fields ignored
        msg.wParam = wParam;
        msg.lParam = lParam;

        const DWORD dwScreenPos = ::GetMessagePos();
        msg.pt.x = GET_X_LPARAM(dwScreenPos);
        msg.pt.y = GET_Y_LPARAM(dwScreenPos);
        if (!isNonClientMessage(message)) {
            ::ScreenToClient(hWnd, &msg.pt);
        }
        return msg;
    }

    static inline constexpr bool isInputMessage(UINT m) {
        switch (m) {
            case WM_IME_STARTCOMPOSITION:
            case WM_IME_ENDCOMPOSITION:
            case WM_IME_COMPOSITION:
            case WM_INPUT:
            case WM_TOUCH:
            case WM_MOUSEHOVER:
            case WM_MOUSELEAVE:
            case WM_NCMOUSEHOVER:
            case WM_NCMOUSELEAVE:
            case WM_SIZING:
            case WM_MOVING:
            case WM_SYSCOMMAND:
            case WM_COMMAND:
            case WM_DWMNCRENDERINGCHANGED:
            case WM_PAINT:
                return true;
            default:
                break;
        }
        return (m >= WM_MOUSEFIRST && m <= WM_MOUSELAST) ||
               (m >= WM_NCMOUSEMOVE && m <= WM_NCXBUTTONDBLCLK) ||
               (m >= WM_KEYFIRST && m <= WM_KEYLAST);
    }

    static inline QByteArray nativeEventType() {
        return QByteArrayLiteral("windows_generic_MSG");
    }

    // Send to QAbstractEventDispatcher
    bool filterNativeEvent(MSG *msg, LRESULT *result) {
        auto dispatcher = QAbstractEventDispatcher::instance();
        QT_NATIVE_EVENT_RESULT_TYPE filterResult = *result;
        if (dispatcher && dispatcher->filterNativeEvent(nativeEventType(), msg, &filterResult)) {
            *result = LRESULT(filterResult);
            return true;
        }
        return false;
    }

    // Send to QWindowSystemInterface
    bool filterNativeEvent(QWindow *window, MSG *msg, LRESULT *result) {
        QT_NATIVE_EVENT_RESULT_TYPE filterResult = *result;
        if (QWindowSystemInterface::handleNativeEvent(window, nativeEventType(), msg,
                                                      &filterResult)) {
            *result = LRESULT(filterResult);
            return true;
        }
        return false;
    }

    static inline bool forwardFilteredEvent(QWindow *window, HWND hWnd, UINT message, WPARAM wParam,
                                            LPARAM lParam, LRESULT *result) {
        MSG msg = createMessageBlock(hWnd, message, wParam, lParam);

        // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1025
        // Do exact the same as what Qt Windows plugin does.

        // Run the native event filters. QTBUG-67095: Exclude input messages which are sent
        // by QEventDispatcherWin32::processEvents()
        if (!isInputMessage(msg.message) && filterNativeEvent(&msg, result))
            return true;

        auto platformWindow = window->handle();
        if (platformWindow && filterNativeEvent(platformWindow->window(), &msg, result))
            return true;

        return false;
    }

    // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1556
    // In QWindowsContext::windowsProc(), the messages will be passed to all global native event
    // filters, but because we have already filtered the messages in the hook WndProc function for
@@ -378,17 +783,38 @@
                return false;
            }

            // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1546
            // Qt needs to refer to the WM_NCCALCSIZE message data that hasn't been processed, so we
            // have to process it after Qt acquires the initial data.
            auto msg = static_cast<const MSG *>(message);
            if (msg->message == WM_NCCALCSIZE && lastMessageContext) {
                LRESULT res;
                if (lastMessageContext->nonClientCalcSizeHandler(msg->hwnd, msg->message,
                                                                 msg->wParam, msg->lParam, &res)) {
                    *result = decltype(*result)(res);
                    return true;
            switch (msg->message) {
                case WM_NCCALCSIZE: {
                    // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/plugins/platforms/windows/qwindowscontext.cpp#L1546
                    // Qt needs to refer to the WM_NCCALCSIZE message data that hasn't been
                    // processed, so we have to process it after Qt acquires the initial data.
                    if (lastMessageContext) {
                        LRESULT res;
                        if (lastMessageContext->nonClientCalcSizeHandler(
                                msg->hwnd, msg->message, msg->wParam, msg->lParam, &res)) {
                            *result = decltype(*result)(res);
                            return true;
                        }
                    }
                    break;
                }

                    // case WM_NCHITTEST: {
                    //     // The child window must return HTTRANSPARENT when processing
                    //     WM_NCHITTEST for
                    //     // the parent window to receive WM_NCHITTEST.
                    //     if (!lastMessageContext) {
                    //         auto rootHWnd = ::GetAncestor(msg->hwnd, GA_ROOT);
                    //         if (rootHWnd != msg->hwnd) {
                    //             if (auto ctx = g_wndProcHash->value(rootHWnd)) {
                    //                 *result = HTTRANSPARENT;
                    //                 return true;
                    //             }
                    //         }
                    //     }
                    //     break;
                    // }
            }
            return false;
        }
@@ -477,18 +903,24 @@
            return ::DefWindowProcW(hWnd, message, wParam, lParam);
        }

        WindowsNativeEventFilter::lastMessageContext = ctx;
        const auto &contextCleaner = qScopeGuard([]() {
            WindowsNativeEventFilter::lastMessageContext = nullptr; //
        });

        // Since Qt does the necessary processing of the WM_NCCALCSIZE message, we need to
        // forward it right away and process it in our native event filter.
        if (message == WM_NCCALCSIZE) {
            WindowsNativeEventFilter::lastMessageContext = ctx;
            LRESULT result = ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
            WindowsNativeEventFilter::lastMessageContext = nullptr;
            return result;
            return ::CallWindowProcW(g_qtWindowProc, hWnd, message, wParam, lParam);
        }

        // Try hooked procedure and save result
        LRESULT result;
        if (ctx->windowProc(hWnd, message, wParam, lParam, &result)) {
            // Forward the event to user-defined native event filters, there may be some messages
            // that need to be processed by the user.
            std::ignore =
                forwardFilteredEvent(ctx->window(), hWnd, message, wParam, lParam, &result);
            return result;
        }

@@ -497,18 +929,10 @@
    }

    static inline void addManagedWindow(QWindow *window, HWND hWnd, Win32WindowContext *ctx) {
        const auto margins = [hWnd]() -> QMargins {
            const auto titleBarHeight = int(getTitleBarHeight(hWnd));
            if (isSystemBorderEnabled()) {
                return {0, -titleBarHeight, 0, 0};
            } else {
                const auto frameSize = int(getResizeBorderThickness(hWnd));
                return {-frameSize, -titleBarHeight, -frameSize, -frameSize};
            }
        }();

        // Inform Qt we want and have set custom margins
        setInternalWindowFrameMargins(window, margins);
        if (isSystemBorderEnabled()) {
            // Inform Qt we want and have set custom margins
            setInternalWindowFrameMargins(window, QMargins(0, -int(getTitleBarHeight(hWnd)), 0, 0));
        }

        // Store original window proc
        if (!g_qtWindowProc) {
@@ -536,7 +960,9 @@
        }
    }

    Win32WindowContext::Win32WindowContext() : AbstractWindowContext() {
    Win32WindowContext::Win32WindowContext()
        : AbstractWindowContext(), lastHitTestResult(WindowPart::Outside),
          lastHitTestResultRaw(HTNOWHERE), mouseLeaveBlocked(false), iconButtonClickTime(0) {
    }

    Win32WindowContext::~Win32WindowContext() {
@@ -571,8 +997,8 @@
#else
                const QPoint nativeGlobalPos = QHighDpi::toNativePixels(pos, m_windowHandle);
#endif
                showSystemMenu2(hWnd, qpoint2point(nativeGlobalPos), false,
                                m_delegate->isHostSizeFixed(m_host));
                std::ignore = showSystemMenu_sys(hWnd, qpoint2point(nativeGlobalPos), false,
                                                 m_delegate->isHostSizeFixed(m_host));
                return;
            }

@@ -631,7 +1057,7 @@
            }

            case DrawWindows10BorderHook2: {
                if (!m_windowHandle)
                if (!m_windowId)
                    return;

                // https://github.com/microsoft/terminal/blob/71a6f26e6ece656084e87de1a528c4a8072eeabd/src/cascadia/WindowsTerminal/NonClientIslandWindow.cpp#L1025
@@ -663,7 +1089,7 @@

    QVariant Win32WindowContext::windowAttribute(const QString &key) const {
        if (key == QStringLiteral("window-rect")) {
            if (!m_windowHandle)
            if (!m_windowId)
                return {};

            RECT frame{};
@@ -686,21 +1112,30 @@
        }

        if (key == QStringLiteral("border-thickness")) {
            return m_windowHandle
            return m_windowId
                       ? int(getWindowFrameBorderThickness(reinterpret_cast<HWND>(m_windowId)))
                       : 0;
        }

        return AbstractWindowContext::windowAttribute(key);
    }

    void Win32WindowContext::winIdChanged(WId winId, WId oldWinId) {
        // Reset the context data
        mouseLeaveBlocked = false;
        lastHitTestResult = WindowPart::Outside;
        lastHitTestResultRaw = HTNOWHERE;

        if (!isSystemBorderEnabled()) {
            m_delegate->setWindowFlags(m_host, m_delegate->getWindowFlags(m_host) |
                                                   Qt::FramelessWindowHint);
        }

        // If the original window id is valid, remove all resources related
        if (oldWinId) {
            removeManagedWindow(reinterpret_cast<HWND>(oldWinId));
        }

        if (!m_windowHandle || ! winId) {
        if (!winId) {
            return;
        }

@@ -735,15 +1170,11 @@
                                        LRESULT *result) {
        *result = FALSE;

        if (message == WM_DESTROY) {
            qDebug() << "WM_DESTROY";
        }

        // We should skip these messages otherwise we will get crashes.
        // NOTE: WM_QUIT won't be posted to the WindowProc function.
        switch (message) {
            case WM_CLOSE:
            case WM_DESTROY:
            case WM_CLOSE:
            case WM_NCDESTROY:
            // Undocumented messages:
            case WM_UAHDESTROYWINDOW:
@@ -757,19 +1188,8 @@
            return false;
        }

        switch (message) {
            case WM_NCMOUSELEAVE:
                qDebug() << "WM_NCMOUSELEAVE" << mouseLeaveBlocked;
                break;
            case WM_MOUSEHOVER:
                qDebug() << "WM_MOUSEHOVER" << mouseLeaveBlocked;
                break;
            case WM_NCMOUSEHOVER:
                qDebug() << "WM_NCMOUSEHOVER" << mouseLeaveBlocked;
                break;
            default:
                break;
        }
        // qDebug().noquote() << QString::fromWCharArray(xmsgHash.value(message, L"")) << Qt::hex
        //                    << message;

        // Test snap layout
        if (snapLayoutHandler(hWnd, message, wParam, lParam, result)) {
@@ -788,13 +1208,9 @@

        // Forward to native event filter subscribers
        if (!m_nativeEventFilters.isEmpty()) {
            MSG msg;
            msg.hwnd = hWnd;
            msg.message = message;
            msg.wParam = wParam;
            msg.lParam = lParam;
            MSG msg = createMessageBlock(hWnd, message, wParam, lParam);
            QT_NATIVE_EVENT_RESULT_TYPE res = 0;
            if (nativeDispatch(QByteArrayLiteral("windows_generic_MSG"), &msg, &res)) {
            if (nativeDispatch(nativeEventType(), &msg, &res)) {
                *result = LRESULT(res);
                return true;
            }
@@ -1156,8 +1572,6 @@
                    }
                }
                mouseLeaveBlocked = false;
                
                qDebug() << "WM_MOUSELEAVE";
                break;
            }

@@ -1166,7 +1580,6 @@
                // we unset `mouseLeaveBlocked` mark and pretend as if Qt has received
                // WM_MOUSELEAVE.
                if (lastHitTestResult != WindowPart::ChromeButton && mouseLeaveBlocked) {
                    qDebug() << lastHitTestResult << "Track";
                    mouseLeaveBlocked = false;
                    requestForMouseLeaveMessage(hWnd, false);
                }
@@ -1192,9 +1605,8 @@
    case WM_NCPOINTERUP:
#endif
            case WM_NCMOUSEHOVER: {
                const WindowPart currentWindowPart = lastHitTestResult;
                if (message == WM_NCMOUSEMOVE) {
                    if (currentWindowPart != WindowPart::ChromeButton) {
                    if (lastHitTestResult != WindowPart::ChromeButton) {
                        // https://github.com/qt/qtbase/blob/e26a87f1ecc40bc8c6aa5b889fce67410a57a702/src/widgets/kernel/qwidgetwindow.cpp#L472
                        // When the mouse press event arrives, QWidgetWindow will implicitly grab
                        // the top widget right under the mouse, and set `qt_button_down` to this
@@ -1243,29 +1655,38 @@
                        // the above problems would not arise.

                        m_delegate->resetQtGrabbedControl(m_host);

                        // If the mouse moves from chrome buttons to other non-client areas, a
                        // WM_MOUSELEAVE message should be sent.
                        if (mouseLeaveBlocked) {
                            emulateClientAreaMessage(hWnd, message, wParam, lParam,
                                                     WM_NCMOUSELEAVE);
                        }
                    }

                    // We need to make sure we get the right hit-test result when a WM_NCMOUSELEAVE
                    // comes, so we reset it when we receive a WM_NCMOUSEMOVE.

                    // If the mouse is entering the client area, there must be a WM_NCHITTEST
                    // setting it to `Client` before the WM_NCMOUSELEAVE comes; if the mouse is
                    // leaving the window, current window part remains as `Outside`.
                    // lastHitTestResult = WindowPart::Outside;
                }

                if (currentWindowPart == WindowPart::ChromeButton) {
                    emulateClientAreaMessage(hWnd, message, wParam, lParam);
                if (lastHitTestResult == WindowPart::ChromeButton) {
                    if (message == WM_NCMOUSEMOVE) {
                        // ### FIXME FIXME FIXME
                        // ### FIXME: Calling DefWindowProc() here is really dangerous, investigate
                        // how to avoid doing this.
                        // ### FIXME FIXME FIXME
                        *result = ::DefWindowProcW(hWnd, WM_NCMOUSEMOVE, wParam, lParam);
                    } else if (lastHitTestResultRaw == HTSYSMENU) {
                        if (message == WM_NCLBUTTONDOWN) {
                            // A message of WM_SYSCOMMAND with SC_MOUSEMENU will be sent by Windows,
                            // and the current control flow will be blocked by the menu while
                            // Windows will create and execute a new event loop until the menu
                            // returns
                            iconButtonClickTime = ::GetTickCount64();
                            *result = ::DefWindowProcW(hWnd, message, wParam, lParam);
                            iconButtonClickTime = 0;
                        } else if (message == WM_NCLBUTTONDBLCLK) {
                            // A message of WM_SYSCOMMAND with SC_CLOSE will be sent by Windows
                            *result = ::DefWindowProcW(hWnd, message, wParam, lParam);
                        } else {
                            *result = FALSE;
                        }
                    } else {
                        // According to MSDN, we should return non-zero for X button messages to
                        // indicate we have handled these messages (due to historical reasons), for
@@ -1275,6 +1696,7 @@
                                 ? TRUE
                                 : FALSE);
                    }
                    emulateClientAreaMessage(hWnd, message, wParam, lParam);
                    return true;
                }
                break;
@@ -1287,7 +1709,7 @@
                    // pressing area as HTCLIENT which maybe because of our former retransmission of
                    // WM_NCLBUTTONDOWN, as a result, a WM_NCMOUSELEAVE will come immediately and a
                    // lot of WM_MOUSEMOVE will come if we move the mouse, we should track the mouse
                    // in advance.
                    // in advance. (May be redundant?)
                    if (mouseLeaveBlocked) {
                        mouseLeaveBlocked = false;
                        requestForMouseLeaveMessage(hWnd, false);
@@ -1403,7 +1825,8 @@
                // color, our homemade top border can almost have exactly the same
                // appearance with the system's one.
                [[maybe_unused]] const auto &hitTestRecorder = qScopeGuard([this, result]() {
                    lastHitTestResult = getHitWindowPart(int(*result)); //
                    lastHitTestResultRaw = int(*result);
                    lastHitTestResult = getHitWindowPart(lastHitTestResultRaw);
                });

                POINT nativeGlobalPos{GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
@@ -1952,6 +2375,7 @@
        bool shouldShowSystemMenu = false;
        bool broughtByKeyboard = false;
        POINT nativeGlobalPos{};

        switch (message) {
            case WM_RBUTTONUP: {
                const POINT nativeLocalPos = getNativePosFromMouse();
@@ -1973,10 +2397,20 @@
            }
            case WM_SYSCOMMAND: {
                const WPARAM filteredWParam = (wParam & 0xFFF0);
                if ((filteredWParam == SC_KEYMENU) && (lParam == VK_SPACE)) {
                    shouldShowSystemMenu = true;
                    broughtByKeyboard = true;
                    nativeGlobalPos = getNativeGlobalPosFromKeyboard();
                switch (filteredWParam) {
                    case SC_MOUSEMENU:
                        shouldShowSystemMenu = true;
                        nativeGlobalPos = getNativeGlobalPosFromKeyboard();
                        break;
                    case SC_KEYMENU:
                        if (lParam == VK_SPACE) {
                            shouldShowSystemMenu = true;
                            broughtByKeyboard = true;
                            nativeGlobalPos = getNativeGlobalPosFromKeyboard();
                        }
                        break;
                    default:
                        break;
                }
                break;
            }
@@ -1995,8 +2429,26 @@
                break;
        }
        if (shouldShowSystemMenu) {
            showSystemMenu2(hWnd, nativeGlobalPos, broughtByKeyboard,
                            m_delegate->isHostSizeFixed(m_host));
            bool res = showSystemMenu_sys(hWnd, nativeGlobalPos, broughtByKeyboard,
                                          m_delegate->isHostSizeFixed(m_host));

            // Check time
            static uint32_t doubleClickTime = ::GetDoubleClickTime();
            if (!res && iconButtonClickTime != 0 &&
                ::GetTickCount64() - iconButtonClickTime <= doubleClickTime) {
                POINT nativeGlobalPos;
                ::GetCursorPos(&nativeGlobalPos);
                POINT nativeLocalPos = nativeGlobalPos;
                ::ScreenToClient(hWnd, &nativeLocalPos);
                QPoint qtScenePos =
                    QHighDpi::fromNativeLocalPosition(point2qpoint(nativeLocalPos), m_windowHandle);
                WindowAgentBase::SystemButton sysButtonType = WindowAgentBase::Unknown;
                if (isInSystemButtons(qtScenePos, &sysButtonType) &&
                    sysButtonType == WindowAgentBase::WindowIcon) {
                    ::PostMessageW(hWnd, WM_SYSCOMMAND, SC_CLOSE, 0);
                }
            }

            // QPA's internal code will handle system menu events separately, and its
            // behavior is not what we would want to see because it doesn't know our
            // window doesn't have any window frame now, so return early here to avoid