WindowModal.h

#ifndef NEO_WINDOWMODAL_H
#define NEO_WINDOWMODAL_H

namespace neo
{

class WindowModal : public Window
{
public:
    WindowModal();

    int DoModal(bool blockEntireThread = true);
    void EndModal(int result);
    bool IsModal() { return modalLoopRunning; }

    static const int MODAL_ERROR = -1;
private:
    virtual void ProcessMessage(MSG* msg);

    static BOOL CALLBACK CountEnabledWindows(HWND hwnd, LPARAM pBuffer);
    static BOOL CALLBACK ListEnabledWindows(HWND hwnd, LPARAM pBuffer);

    // helper class if the entire thread should be blocked
    class HwndBuffer
    {
    public:
        HwndBuffer(HWND pMyWindow)
            : myWindow(pMyWindow)
            , filled(0)
        {
            count = 0;
            hwnds = 0;
        }
        ~HwndBuffer()
        {
            delete [] hwnds;
        }

        void EnableWindows(BOOL enable)
        {
            for(int i = 0; i < count; ++i)
                EnableWindow(hwnds[i], enable);
        }

        HWND myWindow; // handle of this instance, which should be excluded from enumeration
        HWND* hwnds;
        int filled;    // counter for the enumeration
        int count;     // size of hwnds
    };

    bool modalLoopRunning;
    int modalResult;
};

//-----------------------------------------------------------------------------

inline WindowModal::WindowModal()
{
    modalLoopRunning = false;
    modalResult = MODAL_ERROR;
}

inline int WindowModal::DoModal(bool blockEntireThread)
{
    // don't start modal loop on the same window twice
    assert(!modalLoopRunning && GetHandle());
    if(modalLoopRunning || GetHandle() == 0)
        return MODAL_ERROR;

    HWND parent = reinterpret_cast<HWND>(GetWindowLongPtr(GetHandle(), GWLP_HWNDPARENT));

    // disable some windows
    HwndBuffer windowsToDisable(GetHandle());
    if(blockEntireThread)
    {
        // make a list of all windows we want to disable during modal message loop
        EnumThreadWindows(GetCurrentThreadId(), CountEnabledWindows, (LPARAM)&windowsToDisable);
        windowsToDisable.hwnds = new HWND[windowsToDisable.count];
        EnumThreadWindows(GetCurrentThreadId(), ListEnabledWindows, (LPARAM)&windowsToDisable);
        windowsToDisable.EnableWindows(FALSE);
    }
    else
        EnableWindow(parent, FALSE);

    ShowWindow(GetHandle(), SW_SHOW);

    // modal message loop
    modalLoopRunning = true;
    while(modalLoopRunning)
    {
        MSG msg;
        WaitMessage();
        while(modalLoopRunning && PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
        {
            if(msg.message == WM_QUIT)
            {
                EndModal(-1);
                PostQuitMessage((int)msg.wParam); // re-post
                continue;
            }
            // virtual
            ProcessMessage(&msg);
        }
    }

    // restore everything
    if(blockEntireThread)
        windowsToDisable.EnableWindows(TRUE);
    else
        EnableWindow(parent, TRUE);
    // we need this if multiple modal loops are active (creating WindowModal inside another WindowModal)
    BringWindowToTop(parent);
    // hide after the parent is restored, otherwise the Z-Order goes wild
    ShowWindow(GetHandle(), SW_HIDE);

    return modalResult;
}

inline void WindowModal::EndModal(int result)
{
    modalLoopRunning = false;
    modalResult = result;
}

inline void WindowModal::ProcessMessage(MSG* msg)
{
    // behave like a dialog
    if(!IsDialogMessage(GetHandle(), msg))
    {
        TranslateMessage(msg);
        DispatchMessage(msg);
    }
}

inline BOOL CALLBACK WindowModal::CountEnabledWindows(HWND hwnd, LPARAM pBuffer)
{
    HwndBuffer* buffer = (HwndBuffer*)pBuffer;
    if(buffer && buffer->myWindow != hwnd && (GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD) == 0 && IsWindowEnabled(hwnd))
        ++buffer->count;
    return TRUE;
}

inline BOOL CALLBACK WindowModal::ListEnabledWindows(HWND hwnd, LPARAM pBuffer)
{
    HwndBuffer* buffer = (HwndBuffer*)pBuffer;
    if(buffer && buffer->myWindow != hwnd && (GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD) == 0 && IsWindowEnabled(hwnd))
        buffer->hwnds[buffer->filled++] = hwnd;
    return TRUE;
}

} // namespace neo

#endif