win32_chrome.cpp

#include "win32_chrome.hpp"

namespace Win32Chrome {
    Win32Chrome::Win32Chrome(HWND handle, Callbacks callbacks, bool maximizable = true, bool minimizable = true
    ) : m_handle(handle), m_callbacks(callbacks), m_minimizable(minimizable), m_maximizable(maximizable) {
        SetProp(handle, LPSTRING, reinterpret_cast<HANDLE>(this));

        LONG style = GetWindowLong(handle, GWL_STYLE);
        m_originalStyle = style;

        style |= WS_THICKFRAME | WS_SYSMENU | WS_VISIBLE;

        if (minimizable) {
            style |= WS_MINIMIZEBOX;
        }
        if (maximizable) {
            style |= WS_MAXIMIZEBOX;
        }
        SetWindowLong(handle, GWL_STYLE, style);

        m_originalProc = (WNDPROC)SetWindowLongPtr(handle, GWLP_WNDPROC, (LONG_PTR)wndProc);

        SetWindowPos(handle, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
    }

    const bool Win32Chrome::isMaximizable() {
        return m_maximizable;
    }

    const bool Win32Chrome::isMinimizable() {
        return m_minimizable;
    }

    void Win32Chrome::restore() {
        SetWindowLong(m_handle, GWL_STYLE, m_originalStyle);
        SetWindowLongPtr(m_handle, GWLP_WNDPROC, (LONG_PTR)m_originalProc);
        SetWindowPos(m_handle, nullptr, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
        RemoveProp(m_handle, LPSTRING);
    }

    LRESULT Win32Chrome::wndProc(HWND handle, UINT message, WPARAM w_param, LPARAM l_param) {
        auto* instance = reinterpret_cast<Win32Chrome *>(GetProp(handle, LPSTRING));

        if (!instance) {
            return DefWindowProc(handle, message, w_param, l_param);
        }

        switch (message) {
            case WM_NCCALCSIZE: {
                BOOL const isMaximized = IsZoomed(handle);
                if (!w_param) {
                    return DefWindowProc(handle, message, w_param, l_param);
                }
                UINT dpi = GetDpiForWindow(handle);

                int frame_x = GetSystemMetricsForDpi(SM_CXFRAME, dpi);
                int frame_y = GetSystemMetricsForDpi(SM_CYFRAME, dpi);
                int padding = GetSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);

                NCCALCSIZE_PARAMS* params = (NCCALCSIZE_PARAMS *)l_param;
                RECT* rcr = params->rgrc;

                rcr->right -= frame_x + padding;
                rcr->left += frame_x + padding;
                rcr->bottom -= frame_y + padding;

                if (isMaximized) {
                    rcr->top += frame_y + padding;
                }

                return 0;
            }
            case WM_CREATE: {
                SetWindowPos(handle, nullptr, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
                break;
            }

            case WM_NCHITTEST: {
                BOOL const isMaximized = IsZoomed(handle);
                LRESULT hit = DefWindowProc(handle, message, w_param, l_param);
                switch (hit) {
                    case HTNOWHERE:
                    case HTRIGHT:
                    case HTLEFT:
                    case HTTOPLEFT:
                    case HTTOP:
                    case HTTOPRIGHT:
                    case HTBOTTOMRIGHT:
                    case HTBOTTOM:
                    case HTBOTTOMLEFT: {
                        return hit;
                    }
                }

                POINT cursor_point = {0};
                cursor_point.x = GET_X_PARAM(l_param);
                cursor_point.y = GET_Y_PARAM(l_param);
                ScreenToClient(handle, &cursor_point);

                ControlRects controls = instance->m_callbacks.TitlebarControlsBoundingBox();
                if (isInsideBoundingBox(controls.Close, cursor_point.x, cursor_point.y)) {
                    return HTCLOSE;
                }
                if (isInsideBoundingBox(controls.Maximize, cursor_point.x, cursor_point.y) && instance->
                    isMaximizable()) {
                    return HTMAXBUTTON;
                }
                if (isInsideBoundingBox(controls.Minimize, cursor_point.x, cursor_point.y) && instance->
                    isMinimizable()) {
                    return HTMINBUTTON;
                }

                UINT dpi = GetDpiForWindow(handle);
                int frame_y = GetSystemMetricsForDpi(SM_CYFRAME, dpi);
                int padding = GetSystemMetricsForDpi(SM_CXPADDEDBORDER, dpi);

                if (!isMaximized && cursor_point.y > 0 && cursor_point.y < frame_y + padding) {
                    return HTTOP;
                }

                if (cursor_point.y < instance->m_callbacks.TitlebarBoundingBox().h && !instance->m_callbacks.
                    TitlebarControlHittest(cursor_point.x, cursor_point.y)) {
                    return HTCAPTION;
                }

                return HTCLIENT;
            }
            case WM_NCLBUTTONDOWN: {
                POINT cursor_point = {0};
                cursor_point.x = GET_X_PARAM(l_param);
                cursor_point.y = GET_Y_PARAM(l_param);
                ScreenToClient(handle, &cursor_point);
                ControlRects controls = instance->m_callbacks.TitlebarControlsBoundingBox();
                bool onButton = isInsideBoundingBox(controls.Close, cursor_point.x, cursor_point.y) ||
                                isInsideBoundingBox(controls.Maximize, cursor_point.x, cursor_point.y) ||
                                isInsideBoundingBox(controls.Minimize, cursor_point.x, cursor_point.y);
                if (onButton) {
                    return 0;
                }
                return CallWindowProc(instance->m_originalProc, handle, message, w_param, l_param);
            }

            case WM_NCLBUTTONUP: {
                POINT cursor_point = {0};
                cursor_point.x = GET_X_PARAM(l_param);
                cursor_point.y = GET_Y_PARAM(l_param);
                ScreenToClient(handle, &cursor_point);
                ControlRects controls = instance->m_callbacks.TitlebarControlsBoundingBox();
                if (isInsideBoundingBox(controls.Close, cursor_point.x, cursor_point.y)) {
                    PostMessageW(handle, WM_CLOSE, 0, 0);
                    return 0;
                }
                if (isInsideBoundingBox(controls.Minimize, cursor_point.x, cursor_point.y) && instance->
                    isMinimizable()) {
                    ShowWindow(handle, SW_MINIMIZE);
                    return 0;
                }
                if (isInsideBoundingBox(controls.Maximize, cursor_point.x, cursor_point.y) && instance->
                    isMaximizable()) {
                    BOOL const isMaximized = IsZoomed(handle);
                    int mode = isMaximized ? SW_NORMAL : SW_MAXIMIZE;
                    ShowWindow(handle, mode);
                    return 0;
                }
                return CallWindowProc(instance->m_originalProc, handle, message, w_param, l_param);
            }

            case WM_NCRBUTTONUP: {
                if (w_param == HTCAPTION) {
                    BOOL const isMaximized = IsZoomed(handle);
                    MENUITEMINFO info = {
                        .cbSize = sizeof(info),
                        .fMask = MIIM_STATE
                    };

                    HMENU const sys_menu = GetSystemMenu(handle, false);
                    setMenuItemState(sys_menu, &info, SC_RESTORE, isMaximized);
                    setMenuItemState(sys_menu, &info, SC_MOVE, !isMaximized);
                    setMenuItemState(sys_menu, &info, SC_SIZE, !isMaximized);
                    setMenuItemState(sys_menu, &info, SC_MINIMIZE, true);
                    instance->setMenuItemState(sys_menu, &info, SC_MAXIMIZE, !isMaximized);
                    instance->setMenuItemState(sys_menu, &info, SC_CLOSE, true);

                    BOOL const result = TrackPopupMenu(sys_menu, TPM_RETURNCMD, GET_X_PARAM(l_param),
                                                       GET_Y_PARAM(l_param),
                                                       0, handle, nullptr);
                    if (result != 0) {
                        PostMessage(handle, WM_SYSCOMMAND, result, 0);
                    }
                }
                return CallWindowProc(instance->m_originalProc, handle, message, w_param, l_param);
            }
            case WM_DESTROY: {
                return CallWindowProc(instance->m_originalProc, handle, message, w_param, l_param);
            }
        }

        return CallWindowProc(instance->m_originalProc, handle, message, w_param, l_param);
    }

    bool Win32Chrome::isInsideBoundingBox(Rect rect, int x, int y) {
        return (x >= rect.x && x < (rect.x + rect.w)) &&
               (y >= rect.y && y < (rect.y + rect.h));
    }

    void Win32Chrome::setMenuItemState(HMENU menu, MENUITEMINFO* menuiteminfo, UINT item, bool enabled) {
        menuiteminfo->fState = enabled ? MF_ENABLED : MF_DISABLED;
        SetMenuItemInfo(menu, item, false, menuiteminfo);
    }
}