TnbDummyWindow.h

[詳解]

#pragma once
#include "TnbSync.h"
#include "TnbSimpleMap.h"
#include "TnbStr.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 // HWNDとリスナーのMAP
 _SELECTANY CSimpleMapT<LPVOID, LPVOID>* s_pmapDmyWndHwndProc = NULL; 
 _SELECTANY CSyncSection* s_psyncDmyWnd = NULL; 
 
 #ifndef WS_OVERLAPPEDWINDOW
  #define WS_OVERLAPPEDWINDOW (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)
 #endif
#endif
 
 
 
class CDummyWindow : CCopyImpossible
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
        virtual bool OnWindowMessage(LRESULT& _result, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) = 0;
    };
 
 
    //----
 
 
    CDummyWindow(void) : m_hWnd(NULL)
    {
        m_brush = static_cast<HBRUSH>(::GetStockObject(NULL_BRUSH));
    }
 
    ~CDummyWindow(void)
    {
        Destroy();
    }
 
    operator HWND(void) const
    {
        return m_hWnd;
    }
 
    HWND GetSafeHwnd(void) const
    {
        return m_hWnd;
    }
 
    bool IsWindow(void) const
    {
        return !! ::IsWindow(m_hWnd);
    }
 
    void Destroy(void)
    {
        if ( m_hWnd != NULL )
        {
            ::DestroyWindow(m_hWnd);
            m_hWnd = NULL;
        }
        m_UnregisterClass();
        m_className.Empty();
    }
 
    void SetBrush(HBRUSH b)
    {
        m_brush = b;
    }
 
    bool Create(CDummyWindow::IListener* I, LPCTSTR lpszTitle = NULL, LPCTSTR lpszClassName = NULL, DWORD dwStyle = WS_OVERLAPPEDWINDOW, HMENU hMenu = NULL, HWND hParent = NULL)
    {
        if ( I != NULL )
        {
            m_CreateSub();
            if ( lpszTitle == NULL )
            {
                lpszTitle = _T("");
            }
            m_className = lpszClassName;
            if ( m_className.IsEmpty() )
            {
                m_className.Format(_T("TnbLib:%d:%d"), ::GetCurrentProcessId(), this);
            }
            m_RegisterClass();
            HINSTANCE hInst = GetInstanceHandleByTnb(EI_Process);
            m_hWnd = ::CreateWindow(m_className, lpszTitle, dwStyle, 100, 0, 100, 0, hParent, hMenu, hInst, NULL);
            if ( m_hWnd != NULL )
            {
                (*s_pmapDmyWndHwndProc)[m_hWnd] = I;
                return true;
            }
        }
        return false;
    }
 
    bool CreateByTemplate(CDummyWindow::IListener* I, UINT templateId, HWND hParent = NULL)
    {
        if ( I != NULL )
        {
            m_CreateSub();
            HINSTANCE hInst = GetInstanceHandleByTnb(EI_Process);
            HANDLE h = ::GetCurrentThread();
            (*s_pmapDmyWndHwndProc)[h] = I; //仮キー
            m_hWnd = ::CreateDialog(hInst, MAKEINTRESOURCE(templateId), hParent, ms_DlgProc);
            if ( m_hWnd != NULL )
            {
                (*s_pmapDmyWndHwndProc)[m_hWnd] = I;
                s_pmapDmyWndHwndProc->RemoveKey(h); //仮キー削除
                return true;
            }
        }
        return false;
    }
 
    DWORD GetStyle(void) const
    {
        return ::GetWindowLong(m_hWnd, GWL_STYLE);
    }
 
    DWORD GetStyleEx(void) const
    {
        return ::GetWindowLong(m_hWnd, GWL_EXSTYLE);
    }
 
    bool ModifyStyle(DWORD dwRemove, DWORD dwAdd, UINT nFlags = 0)
    {
        return m_ModifyStyle(GWL_STYLE, dwRemove, dwAdd, nFlags);
    }
 
    bool ModifyStyleEx(DWORD dwRemove, DWORD dwAdd, UINT nFlags = 0)
    {
        return m_ModifyStyle(GWL_EXSTYLE, dwRemove, dwAdd, nFlags);
    }
 
private:
 
#if 0
    //Unhook処理用サブクラス
    class CReject
    {
    public: 
        ~CReject(void)
        {
            if ( s_pmapDmyWndHwndProc != NULL )
            {
                s_pmapDmyWndHwndProc->RemoveAll();
                delete s_pmapDmyWndHwndProc;
                s_pmapDmyWndHwndProc = NULL;
            }
            if ( s_psyncDmyWnd != NULL )
            {
                delete s_psyncDmyWnd;
                s_psyncDmyWnd = NULL;
            }
        }
    };
#endif
    void m_CreateSub(void)
    {
        if ( s_pmapDmyWndHwndProc == NULL )
        {
//          static CReject s_cReje;
            s_pmapDmyWndHwndProc = new CSimpleMapT<LPVOID, LPVOID>;
            s_psyncDmyWnd = new CSyncSection;
        }
        Destroy();
    }
    bool m_ModifyStyle(int nStyleOffset, DWORD dwRemove, DWORD dwAdd, UINT nFlags)
    {
        DWORD dwStyle = ::GetWindowLong(m_hWnd, nStyleOffset);
        DWORD dwNewStyle = (dwStyle & ~dwRemove) | dwAdd;
        if ( dwStyle == dwNewStyle )
        {
            return false;
        }
        ::SetWindowLong(m_hWnd, nStyleOffset, dwNewStyle);
        if ( nFlags != 0 )
        {
            ::SetWindowPos(m_hWnd, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | nFlags);
        }
        return true;
    }
    static bool CALLBACK ms_CmnProc(LRESULT& _result, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        if ( s_pmapDmyWndHwndProc == NULL )
        {
            return false;
        }
        s_psyncDmyWnd->Lock();
        IListener* I = NULL;
        if ( s_pmapDmyWndHwndProc->HasKey(hWnd) )
        {
            LPVOID P = (*s_pmapDmyWndHwndProc)[hWnd];
            I = static_cast<IListener*>(P);
        }
        else
        {
            HANDLE h = ::GetCurrentThread();
            if ( s_pmapDmyWndHwndProc->HasKey(h) )
            {
                LPVOID P = (*s_pmapDmyWndHwndProc)[h];
                I = static_cast<IListener*>(P);
            }
        }
        bool r = false;
        if ( I != NULL )
        {
            r = I->OnWindowMessage(_result, hWnd, uMsg, wParam, lParam);
        }
        if ( uMsg == WM_DESTROY )
        {
            s_pmapDmyWndHwndProc->RemoveKey(hWnd);
            if ( s_pmapDmyWndHwndProc->GetSize() == 0 )
            {
                if ( s_pmapDmyWndHwndProc != NULL )
                {
                    delete s_pmapDmyWndHwndProc;
                    s_pmapDmyWndHwndProc = NULL;
                }
                if ( s_psyncDmyWnd != NULL )
                {
                    s_psyncDmyWnd->Unlock();
                    delete s_psyncDmyWnd;
                    s_psyncDmyWnd = NULL;
                }
            }
        }
        if ( s_psyncDmyWnd != NULL )
        {
            s_psyncDmyWnd->Unlock();
        }
        return r;
    }
    static LRESULT CALLBACK ms_WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        LRESULT r;
        if ( ms_CmnProc(r, hWnd, uMsg, wParam, lParam) )
        {
            return r;
        }
        return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    static INT_PTR CALLBACK ms_DlgProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        LRESULT r;
        if ( ms_CmnProc(r, hWnd, uMsg, wParam, lParam) )
        {
            switch ( uMsg )
            {
            case WM_CHARTOITEM:
            case WM_COMPAREITEM:
            case WM_CTLCOLORBTN:
            case WM_CTLCOLORDLG:
            case WM_CTLCOLOREDIT:
            case WM_CTLCOLORLISTBOX:
            case WM_CTLCOLORSCROLLBAR:
            case WM_CTLCOLORSTATIC:
            case WM_CTLCOLORMSGBOX:
            case WM_INITDIALOG:
            case WM_QUERYDRAGICON:
            case WM_VKEYTOITEM:
                return r; // WM_CTLCOLOR〜 系などは DWL_MSGRESULT を使わず、戻り値で返す。
            }
            #ifdef DWL_MSGRESULT
                ::SetWindowLong(hWnd, DWL_MSGRESULT, r);
            #else
                ::SetWindowLongPtr(hWnd, DWLP_MSGRESULT, r);
            #endif
            return TRUE;
        }
        return FALSE;
    }
    ATOM m_RegisterClass(void)
    {
        #ifndef _WIN32_WCE
            WNDCLASSEX wc   = { sizeof(WNDCLASSEX) };
        #else
            WNDCLASS wc     = { sizeof(WNDCLASS) };
        #endif
        wc.style            = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc      = ms_WndProc;
        wc.hInstance        = GetInstanceHandleByTnb(EI_Process);
        wc.hbrBackground    = m_brush;
        wc.lpszClassName    = m_className;
        #ifndef _WIN32_WCE
            return ::RegisterClassEx(&wc);
        #else
            return ::RegisterClass(&wc);
        #endif
    }
    void m_UnregisterClass(void)
    {
        if ( ! m_className.IsEmpty() )
        {
            ::UnregisterClass(m_className, GetInstanceHandleByTnb(EI_Process));
            m_className.Empty();
        }
    }
    HWND    m_hWnd;         
    CStr    m_className;    
    HBRUSH  m_brush;        
};
 
 
 
 
};