winnativewindow.cpp

#include "WinNativeWindow.h"

#include <dwmapi.h>
#include <stdexcept>


HWND WinNativeWindow::childWindow = nullptr;
QWidget* WinNativeWindow::childWidget = nullptr;

WinNativeWindow::WinNativeWindow(const int x, const int y, const int width, const int height)
    : hWnd(nullptr)
{

	//The native window technically has a background color. You can set it here
    HBRUSH windowBackground = CreateSolidBrush(RGB(255, 255, 255));

    HINSTANCE hInstance = GetModuleHandle(nullptr);
    WNDCLASSEX wcx = { 0 };

    wcx.cbSize = sizeof(WNDCLASSEX);
    wcx.style = CS_HREDRAW | CS_VREDRAW;
    wcx.hInstance = hInstance;
    wcx.lpfnWndProc = WndProc;
    wcx.cbClsExtra = 0;
    wcx.cbWndExtra = 0;
    wcx.lpszClassName = L"WindowClass";
    wcx.hbrBackground = windowBackground;
    wcx.hCursor = LoadCursor(hInstance, IDC_ARROW);


    RegisterClassEx(&wcx);
    if (FAILED(RegisterClassEx(&wcx)))
    {
        throw std::runtime_error("Couldn't register window class");
    }

    //Create a native window with the appropriate style
    hWnd = CreateWindow(L"WindowClass", L"WindowTitle", aero_borderless, x, y, width, height, 0, 0, hInstance, nullptr);
    if (!hWnd)
    {
        throw std::runtime_error("couldn't create window because of reasons");
    }


    SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));

    //This code may be required for aero shadows on some versions of Windows
       //const MARGINS aero_shadow_on = { 1, 1, 1, 1 };
       //DwmExtendFrameIntoClientArea(hWnd, &aero_shadow_on);

    SetWindowPos(hWnd, 0, 0, 0, 0, 0, SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE);

}

WinNativeWindow::~WinNativeWindow()
{
    //Hide the window & send the destroy message
    ShowWindow(hWnd, SW_HIDE);
    DestroyWindow(hWnd);
}


LRESULT CALLBACK WinNativeWindow::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    WinNativeWindow *window = reinterpret_cast<WinNativeWindow*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));

    if (!window)
    {
        return DefWindowProc(hWnd, message, wParam, lParam);
    }

    switch (message)
    {
        // ALT + SPACE or F10 system menu
        case WM_SYSCOMMAND:
        {
            if (wParam == SC_KEYMENU)
            {
                RECT winrect;
                GetWindowRect(hWnd, &winrect);
                TrackPopupMenu(GetSystemMenu(hWnd, false), TPM_TOPALIGN | TPM_LEFTALIGN, winrect.left + 5, winrect.top + 5, 0, hWnd, NULL);
                break;
            }
            else
            {
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        case WM_NCCALCSIZE:
        {
            //this kills the window frame and title bar we added with
            //WS_THICKFRAME and WS_CAPTION
            return 0;
        }

        //If the parent window gets any close messages, send them over to QWinWidget and don't actually close here
        case WM_CLOSE:
        {
            if (childWindow)
            {
                SendMessage(childWindow, WM_CLOSE, 0, 0);
                return 0;
            }
            break;
        }
        case WM_DESTROY:
        {
            PostQuitMessage(0);
            break;
        }

        case WM_NCHITTEST:
        {

            const LONG borderWidth = 8 * childWidget->window()->devicePixelRatio(); //This value can be arbitrarily large as only intentionally-HTTRANSPARENT'd messages arrive here
            RECT winrect;
            GetWindowRect(hWnd, &winrect);
            long x = GET_X_LPARAM(lParam);
            long y = GET_Y_LPARAM(lParam);

            //bottom left corner
            if (x >= winrect.left && x < winrect.left + borderWidth &&
                y < winrect.bottom && y >= winrect.bottom - borderWidth)
            {
                return HTBOTTOMLEFT;
            }
            //bottom right corner
            if (x < winrect.right && x >= winrect.right - borderWidth &&
                y < winrect.bottom && y >= winrect.bottom - borderWidth)
            {
                return HTBOTTOMRIGHT;
            }
            //top left corner
            if (x >= winrect.left && x < winrect.left + borderWidth &&
                y >= winrect.top && y < winrect.top + borderWidth)
            {
                return HTTOPLEFT;
            }
            //top right corner
            if (x < winrect.right && x >= winrect.right - borderWidth &&
                y >= winrect.top && y < winrect.top + borderWidth)
            {
                return HTTOPRIGHT;
            }
            //left border
            if (x >= winrect.left && x < winrect.left + borderWidth)
            {
                return HTLEFT;
            }
            //right border
            if (x < winrect.right && x >= winrect.right - borderWidth)
            {
                return HTRIGHT;
            }
            //bottom border
            if (y < winrect.bottom && y >= winrect.bottom - borderWidth)
            {
                return HTBOTTOM;
            }
            //top border
            if (y >= winrect.top && y < winrect.top + borderWidth)
            {
                return HTTOP;
            }

            //If it wasn't a border but we still got the message, return HTCAPTION to allow click-dragging the window
            return HTCAPTION;

            break;
        }

		//When this native window changes size, it needs to manually resize the QWinWidget child
        case WM_SIZE:
        {
            RECT winrect;
            GetClientRect(hWnd, &winrect);

            WINDOWPLACEMENT wp;
            wp.length = sizeof(WINDOWPLACEMENT);
            GetWindowPlacement(hWnd, &wp);
            if (childWidget)
            {
                if (wp.showCmd == SW_MAXIMIZE)
                {
                    childWidget->setGeometry(8, 8 //Maximized window draw 8 pixels off screen
                        , winrect.right / childWidget->window()->devicePixelRatio() - 16
                        , winrect.bottom / childWidget->window()->devicePixelRatio() - 16);
                }
                else
                {
                    childWidget->setGeometry(0, 0 
                        , winrect.right / childWidget->window()->devicePixelRatio()
                        , winrect.bottom / childWidget->window()->devicePixelRatio());
                }
            }

            break;
        }

        case WM_GETMINMAXINFO:
        {
            MINMAXINFO* minMaxInfo = (MINMAXINFO*)lParam;
            if (window->minimumSize.required) {
                minMaxInfo->ptMinTrackSize.x = window->getMinimumWidth();;
                minMaxInfo->ptMinTrackSize.y = window->getMinimumHeight();
            }

            if (window->maximumSize.required) {
                minMaxInfo->ptMaxTrackSize.x = window->getMaximumWidth();
                minMaxInfo->ptMaxTrackSize.y = window->getMaximumHeight();
            }
            return 0;
        }

    }

    return DefWindowProc(hWnd, message, wParam, lParam);
}

void WinNativeWindow::setGeometry(const int x, const int y, const int width, const int height)
{
    MoveWindow(hWnd, x, y, width, height, 1);
}

void WinNativeWindow::setMinimumSize(const int width, const int height)
{
    this->minimumSize.required = true;
    this->minimumSize.width = width;
    this->minimumSize.height = height;
}

int WinNativeWindow::getMinimumWidth()
{
    return minimumSize.width;
}

int WinNativeWindow::getMinimumHeight()
{
    return minimumSize.height;
}


void WinNativeWindow::setMaximumSize(const int width, const int height)
{
    this->maximumSize.required = true;
    this->maximumSize.width = width;
    this->maximumSize.height = height;
}

int WinNativeWindow::getMaximumWidth()
{
    return maximumSize.width;
}

int WinNativeWindow::getMaximumHeight()
{
    return maximumSize.height;
}