UIThread.h

Go to the documentation of this file.

/*  UIThread.h - User interface wrappers (TODO::)
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_UIThread_h
#define OW32_UIThread_h

#include <OW32/OW32Libs.h>
#include <OW32/windows.h>
#include <OW32/Thread.h>
#include <tchar.h>

namespace OW32
{

// eek: lifted from ATL oh well!
#if defined(_M_IX86)
#pragma pack(push,1)
struct _WndProcThunk
{
    DWORD   m_mov;          // mov dword ptr [esp+0x4], pThis (esp+0x4 is hWnd)
    DWORD   m_this;         //
    BYTE    m_jmp;          // jmp WndProc
    DWORD   m_relproc;      // relative jmp
};
#pragma pack(pop)
#endif

extern DWORD g_TLSCreateWindowData; /* = TLS_OUT_OF_INDEXES; */

class OW32_LIB_EXPORT CWindow;

#ifdef _MSC_VER
#pragma warning(disable: 4311 4312) // Doesn't work on Win64 anyway...
class CWndProcThunk
{
public:
    _WndProcThunk thunk;

    CWindow* GetWindow() { return reinterpret_cast<CWindow*>(thunk.m_this); }
    WNDPROC GetWndProc() { return (WNDPROC)&thunk; }

    void Init(WNDPROC proc, void* pThis)
    {
        thunk.m_mov = 0x042444C7;  //C7 44 24 0C
        thunk.m_this = (DWORD)pThis;
        thunk.m_jmp = 0xe9;
        thunk.m_relproc = (int)proc - ((int)this+sizeof(_WndProcThunk));
        // write block from data cache and
        //  flush from instruction cache
        FlushInstructionCache(GetCurrentProcess(), &thunk, sizeof(thunk));

        if (g_TLSCreateWindowData == TLS_OUT_OF_INDEXES)
            g_TLSCreateWindowData = TlsAlloc();

        TlsSetValue(g_TLSCreateWindowData, this);
    }
};
#pragma warning(default: 4311 4312) // Doesn't work on Win64 anyway...
#endif

#define BEGIN_MESSAGE_MAP(BaseClass) \
    virtual LRESULT OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled) \
    { \
        typedef BaseClass _BaseClass; \
        uMsg; wParam; lParam; bHandled = TRUE; \

#define MESSAGE_HANDLER(msg, func) \
    if (uMsg == msg) { \
        return (func)(wParam, lParam); \
    }

#define MESSAGE_HANDLER0(msg, func) \
    if (uMsg == msg) { \
        (func)(); \
        return 0L; \
    }

#define MESSAGE_HANDLER1(msg, func) \
    if (uMsg == msg) { \
        (func)(wParam); \
        return 0L; \
    }

#define MESSAGE_HANDLER2(msg, func) \
    if (uMsg == msg) { \
        (func)(lParam); \
        return 0L; \
    }

#define MESSAGE_HANDLER3(msg, func) \
    if (uMsg == msg) { \
        return (func)(msg, wParam, lParam); \
    }

#define MESSAGE_RANGE_HANDLER(msgFirst, msgLast, func) \
    if (uMsg >= msgFirst && uMsg <= msgLast) {  \
        LRESULT res = (func)(uMsg, wParam, lParam, bHandled); \
        if (bHandled) return res; \
    }

#define COMMAND_ID_HANDLER0(id, func) \
    if (uMsg == WM_COMMAND && LOWORD(wParam) == id) { \
        (func)(); \
        return TRUE; \
    }

#define COMMAND_CODE_ID_HANDLER0(code, id, func) \
    if (uMsg == WM_COMMAND && HIWORD(wParam) == code && LOWORD(wParam) == id) { \
        (func)(); \
        return TRUE; \
    }

#define COMMAND_CODE_HANDLER(code, func) \
    if (uMsg == WM_COMMAND && HIWORD(wParam) == code) { \
        LRESULT res = (func)(id, HIWORD(wParam), (HWND)lParam, bHandled); \
        if (bHandled) return res; \
    }

#define COMMAND_ID_HANDLER(id, func) \
    if (uMsg == WM_COMMAND && LOWORD(wParam) == id) { \
        LRESULT res = (func)(LOWORD(wParam), HIWORD(wParam), (HWND)lParam, bHandled); \
        if (bHandled) return res; \
    }

#define COMMAND_HANDLER(func) \
    if (uMsg == WM_COMMAND) { \
        LRESULT res = (func)((int)LOWORD(wParam), (HWND)lParam, (UINT)HIWORD(wParam)); \
        return 0L; \
    }

#define ON_SIZE() \
    if (uMsg == WM_SIZE) { \
        OnSize((int)LOWORD(lParam), (int)HIWORD(lParam), (UINT)wParam); \
        return 0L; \
    }

#define ON_CREATE() \
    if (uMsg == WM_CREATE) { \
        return OnCreate((LPCREATESTRUCT)lParam) ? 0L : -1L; \
    }

#define ON_LBUTTONUP() \
    if (uMsg == WM_LBUTTONUP) { \
        OnLButtonUp(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (UINT)wParam); \
        return 0L; \
    }

#define ON_LBUTTONDOWN() \
    if (uMsg == WM_LBUTTONDOWN) { \
        OnLButtonDown(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (UINT)wParam); \
        return 0L; \
    }

#define ON_RBUTTONUP() \
    if (uMsg == WM_LBUTTONUP) { \
        OnLButtonUp(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (UINT)wParam); \
        return 0L; \
    }

#define ON_RBUTTONDOWN() \
    if (uMsg == WM_LBUTTONDOWN) { \
        OnLButtonDown(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (UINT)wParam); \
        return 0L; \
    }

#define ON_MOUSEMOVE() \
    if (uMsg == WM_MOUSEMOVE) { \
        OnMouseMove(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam), (UINT)wParam); \
        return 0L; \
    }

#define ON_PAINT() \
    if (uMsg == WM_PAINT) { \
        OnPaint(); \
        return 0L; \
    }

#define ON_DESTROY() \
    if (uMsg == WM_DESTROY) { \
        OnDestroy(); \
        return 0L; \
    }

#define END_MESSAGE_MAP() \
        LRESULT res = _BaseClass::OnMessage(uMsg, wParam, lParam, bHandled); \
        if (bHandled) return res; \
        bHandled = FALSE; \
        return 0; \
    }

#define NOTIFY_HANDLER_CODE_ID0(ncode, id, func) \
    if (uMsg == WM_NOTIFY && (int)wParam == id && ((LPNMHDR)lParam)->code == ncode) { \
        (func)(); \
        return 0; \
    }
    
#define DECLARE_EMPTY_MESSAGE_MAP() \
    virtual LRESULT OnMessage(UINT, WPARAM, LPARAM, BOOL& bHandled) { \
        bHandled = FALSE; \
        return 0; \
    }

class OW32_LIB_EXPORT CWndClass : public WNDCLASS
{
public:
    ATOM m_Atom;

/* TODO?:   ~CWndClass()
    {
        UnregisterWindowClass(
    }*/

    CWndClass()
    {
        ZeroMemory(this, sizeof(*this));
    }
};

class OW32_LIB_EXPORT CWndClassEx : public WNDCLASSEX
{
public:
    ATOM m_Atom;

    CWndClassEx()
    {
        ZeroMemory(this, sizeof(*this));
        cbSize = sizeof(WNDCLASSEX); 
    }
};

class OW32_LIB_EXPORT CWindow
{
protected:
    HWND m_hWnd;
    CWndProcThunk m_thunk;

public:
    CWindow() :
        m_hWnd(NULL)
    {
        m_thunk.Init((WNDPROC)WndProc, this);
    }

    DECLARE_EMPTY_MESSAGE_MAP()
    virtual LRESULT DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) {
        return ::DefWindowProc(m_hWnd, message, wParam, lParam);
    }
    static LRESULT CALLBACK InitialWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
    static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
    static CWindow* CWindowFromHWND(HWND hWnd);
    
    virtual BOOL Create(LPCTSTR lpClassName, LPCTSTR lpWindowName = NULL, DWORD dwStyle = 0,
        int x = CW_USEDEFAULT, int y = CW_USEDEFAULT, 
        int nWidth = CW_USEDEFAULT, int nHeight = CW_USEDEFAULT,
        HWND hWndParent = NULL, HMENU hMenu = NULL, HINSTANCE hInstance = NULL,
        LPVOID lpParam = NULL)
    {
        lpParam;
        m_hWnd = ::CreateWindow(lpClassName, lpWindowName, dwStyle, x, y, nWidth,
            nHeight, hWndParent, hMenu, hInstance, (LPVOID)this);
        return m_hWnd ? TRUE : FALSE;
    }

    BOOL Show(int nCmdShow)
    {
        return ::ShowWindow(m_hWnd, nCmdShow);
    }

    BOOL Update() { return UpdateWindow(m_hWnd); }

    static ATOM RegisterClass(LPCTSTR lpszClassName, HINSTANCE hInstance = NULL);
    static ATOM RegisterClass(CWndClass* pWndClass); // overrides WNDProc
    static ATOM RegisterClass(CWndClassEx* pWndClassEx); // overrides WNDProc

    operator HWND() const { return m_hWnd; }

    LRESULT SendMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0) {
        return ::SendMessage(m_hWnd, message, wParam, lParam);
    }

    LRESULT PostMessage(UINT message, WPARAM wParam = 0, LPARAM lParam = 0) {
        return ::PostMessage(m_hWnd, message, wParam, lParam);
    }

    static LRESULT SendMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
        return ::SendMessage(hWnd, message, wParam, lParam);
    }

    static LRESULT PostMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
        return ::PostMessage(hWnd, message, wParam, lParam);
    }

    int MessageBox(LPCTSTR lpszText, LPCTSTR lpszCaption = NULL, UINT uMsg = MB_OK) {
        return ::MessageBox(m_hWnd, lpszText, lpszCaption, uMsg);
    }

    BOOL LockWindowUpdate() { return ::LockWindowUpdate(m_hWnd); }
    BOOL UnlockWindowUpdate() { return ::LockWindowUpdate(m_hWnd); }
    BOOL DestroyWindow() { return ::DestroyWindow(m_hWnd); }

    BOOL SetWindowText(LPCTSTR lpszText) { return ::SetWindowText(m_hWnd, lpszText); }
    int GetWindowText(LPTSTR lpszText, int nMaxCount) { return ::GetWindowText(m_hWnd, lpszText, nMaxCount); }

    HMENU GetMenu() { return ::GetMenu(m_hWnd); }
    BOOL SetMenu(HMENU hMenu) { return ::SetMenu(m_hWnd, hMenu); }

    BOOL GetClientRect(LPRECT lpRect) { return ::GetClientRect(m_hWnd, lpRect); }
    BOOL InvalidateRect(const RECT* lpRect, BOOL bErase) { return ::InvalidateRect(m_hWnd, lpRect, bErase); }

    HDC BeginPaint(LPPAINTSTRUCT lpPaint) { return ::BeginPaint(m_hWnd, lpPaint); }
    BOOL EndPaint(LPPAINTSTRUCT lpPaint) { return ::EndPaint(m_hWnd, lpPaint); }

    BOOL ClientToScreen(LPPOINT lpPoint) { return ::ClientToScreen(m_hWnd, lpPoint); }
    BOOL ScreenToClient(LPPOINT lpPoint) { return ::ScreenToClient(m_hWnd, lpPoint); }

    BOOL ClientToScreen(LPRECT lpRect) { 
        POINT pt1 = { lpRect->left, lpRect->top }, pt2 = { lpRect->right, lpRect->bottom };
        if (!(ClientToScreen(&pt1) && ClientToScreen(&pt2)))
            return FALSE;
        lpRect->left = pt1.x; lpRect->top = pt1.y;
        lpRect->right = pt2.x; lpRect->bottom = pt2.y;
        return TRUE;
    }

    BOOL ScreenToClient(LPRECT lpRect) { 
        POINT pt1 = { lpRect->left, lpRect->top }, pt2 = { lpRect->right, lpRect->bottom };
        if (!(ScreenToClient(&pt1) && ScreenToClient(&pt2)))
            return FALSE;
        lpRect->left = pt1.x; lpRect->top = pt1.y;
        lpRect->right = pt2.x; lpRect->bottom = pt2.y;
        return TRUE;
    }

    BOOL MoveWindow(int x, int y, int nWidth, int nHeight, BOOL bRepaint = TRUE) {
        return ::MoveWindow(m_hWnd, x, y, nWidth, nHeight, bRepaint);
    }

    BOOL MoveWindow(const RECT* lpRect, BOOL bRepaint = TRUE) {
        return MoveWindow(lpRect->left, lpRect->top, lpRect->right-lpRect->left+1, lpRect->bottom-lpRect->top+1, bRepaint);
    }

    BOOL SetWindowPos(int x, int y, int cx = 0, int cy = 0, HWND hwndInsertAfter = NULL, 
                      UINT uFlags = SWP_NOZORDER | SWP_NOSIZE)
    {
        return ::SetWindowPos(m_hWnd, hwndInsertAfter, x, y, cx, cy, uFlags);
    }

    // TODO: etc for SetWindowPos
};

class OW32_LIB_EXPORT CMDIChildWindow : public CWindow
{
public:
    virtual LRESULT DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) {
        return ::DefMDIChildProc(m_hWnd, message, wParam, lParam);
    }
};

class OW32_LIB_EXPORT CMDIFrameWindow : public CWindow
{
public:
    HWND m_hMDIClientWnd;

    CMDIFrameWindow() :
        m_hMDIClientWnd(NULL)
    {
    }

    void MDIActivate(HWND hWndChild) {
        (void)::SendMessage(m_hMDIClientWnd, WM_MDIACTIVATE, (WPARAM)hWndChild, (LPARAM)0L);
    }

    BOOL MDICascade(UINT uFlag = 0) {
        return (BOOL)::SendMessage(m_hMDIClientWnd, WM_MDICASCADE, (WPARAM)uFlag, (LPARAM)0L);
    }

    HWND MDIGetActive(LPBOOL lpMaximisedState = NULL) {
        return (HWND)::SendMessage(m_hMDIClientWnd, WM_MDIGETACTIVE, (WPARAM)0, (LPARAM)lpMaximisedState);
    }

    void MDIIconArrange() {
        (void)::SendMessage(m_hMDIClientWnd, WM_MDIICONARRANGE, (WPARAM)0, (LPARAM)0L);
    }

    void MDIMaximize(HWND hWndChild) {
        (void)::SendMessage(m_hMDIClientWnd, WM_MDIMAXIMIZE, (WPARAM)hWndChild, (LPARAM)0L);
    }

    void MDINext(HWND hWndChild = NULL) {
        (void)::SendMessage(m_hMDIClientWnd, WM_MDINEXT, (WPARAM)hWndChild, (LPARAM)0);
    }

    void MDIPrev(HWND hWndChild = NULL) {
        (void)::SendMessage(m_hMDIClientWnd, WM_MDINEXT, (WPARAM)hWndChild, (LPARAM)1);
    }

    HMENU MDIRefreshMenu() {
        return (HMENU)::SendMessage(m_hMDIClientWnd, WM_MDIREFRESHMENU, (WPARAM)0, (LPARAM)0L);
    }

    void MDIRestore(HWND hWndChild) {
        (void)::SendMessage(m_hMDIClientWnd, WM_MDIRESTORE, (WPARAM)hWndChild, (LPARAM)0L);
    }

    HMENU MDISetMenu(HMENU hMenuFrame = NULL, HMENU hMenuWindow = NULL) {
        return (HMENU)::SendMessage(m_hMDIClientWnd, WM_MDISETMENU, (WPARAM)hMenuFrame, (LPARAM)hMenuWindow);
    }


    BOOL MDITile(UINT uFlag = MDITILE_VERTICAL) {
        return (BOOL)::SendMessage(m_hMDIClientWnd, WM_MDITILE, (WPARAM)uFlag, (LPARAM)0L);
    }

    virtual LRESULT DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam) {
        if (m_hMDIClientWnd)
            return ::DefFrameProc(m_hWnd, m_hMDIClientWnd, message, wParam, lParam);
        else
            return ::DefWindowProc(m_hWnd, message, wParam, lParam);
    }
};

class OW32_LIB_EXPORT CUIThread : public CThread
{
public:
    CUIThread(bool bAutoDelete=false) :
      CThread(bAutoDelete) {}

    // Overrides of CThread that implement base UI functionality
    virtual unsigned Run(); 
};

} // namespace OW32

#endif // OW32_UIThread_h

---