0

MFCに似た独自のc ++フレームワークを構築しました.WM_CREATEメッセージを受信したときに子ウィンドウを作成できますが、編集ボックスを処理できません.Ivan Shcherbakovの投稿からアイデアを得ました.呼び出し後にWM_CREATEMYWINDOWメッセージを投稿します. OnCreate、およびメッセージが受信されたときに OnCreateMyWindow 関数で何かを作成します。もちろん、それは機能します。しかし、この問題を解決する理由と方法を知りたいです。

私の CWnd は CMyWindow です。新しいウィンドウの HWND と CMyWindow* を保持する CBT フックを作成し、HWND-WINDOW マップに WindowManager として追加します。メッセージ ループ コールバック関数 MyWndProc は、hWnd パラメーターによって WindowManger から CMyWindow* を取得しました。次に、CMyWindow のメッセージ関数 OnCreate、OnSize、OnMove などを呼び出します。CWnd クラスと同様です。

CMyWindow はうまく機能しているようです。すべてのメッセージを保持し、応答に対して何かを実行できますが、WM_CREATE のときに編集ボックスを作成することはできません。WM_CREATE のときに任意のスタイルで新しいウィンドウを作成するためです。

vs2010、win7でビルドしました。

MyWindow.h の WindowManager (HWND-WINDOW マップ)

#define WM_CREATEMYWINDOW WM_USER + 123

//the CWindowManager is a map of HWND-CMyWindow
class CMyWindow;
//define the HWND-CMyWindow map
typedef map <HWND, CMyWindow*> CWindowMap;
typedef pair<HWND, CMyWindow*> WindowPair;
typedef map <HWND, CMyWindow*>::iterator WndIterator;
typedef pair<WndIterator, bool> IterBool;

class CWindowManager : private CWindowMap
{
private:
    CWindowManager(void);
    ~CWindowManager(void);
public:
    bool Add(CMyWindow* pwnd);  //add a window to map
    bool Remove(HWND hwnd);     //remove a window by hwnd
    void Clear();               //remove all items
    CMyWindow* Find(HWND hwnd); //find the window by hwnd

public:
    //get CWindowManager instance as singleton pattern
    static CWindowManager * GetInstance();
};

CMyWindow クラスは MFC の CWnd と似ています

class CMyWindow
{
public:
    CMyWindow(void);
    ~CMyWindow(void);

    inline HWND GetSafeHwnd();  //get HWND
    //Create a window
    bool Create( HINSTANCE hInstance,
                TCHAR * szWindowName,
                       DWORD dwStyle,
                          RECT& rect,
                     HWND hParentWnd,
                         HMENU hMenu,
                     LPVOID lpParam);
    //add the window to WindowManager
    void Attach(HWND hwnd);
    //remove the window from WindowManager
    void Dettach();

    //process the WM_CREATE message
    virtual int OnCreate(LPCREATESTRUCT ps);
    /*
        other message function
    */
    //process the WM_CREATEMYWINDOW message
    virtual void OnCreateMyWindow();
protected:
    HWND _hwnd;
    HINSTANCE _hInst;
};

MyWindow.cpp の WindowManager と CBT-HOOK 部分

#include "StdAfx.h"
#include "LockEx.h"
#include "MyWindow.h"

//window class name
static TCHAR * _MY_WINDOW_CLASS_NAME_ = L"MYWINDOWCLASS";

//window-proc
LRESULT CALLBACK MyWindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

///an Mutex-Lock class for keep current hwnd of new window, but you can ignore it when using single thread to crate window
static CLockEx   gLockInitWnd;
///keep current hwnd of new window
static CMyWindow * gpInitWnd = 0;
///an hook to create new window
static HHOOK ghook = 0;


///set gpInitWnd when create a new window
static void SetInitWnd(CMyWindow * pWnd)
{
    CLockEx::Scoped lock(gLockInitWnd);

    gpInitWnd = pWnd;
}

///clear gpInitWnd after new window created
static void UnsetInitWnd()
{
    CLockEx::Scoped lock(gLockInitWnd);

    gpInitWnd = 0;
}

///get the HWND of new window that is creating
static CMyWindow * GetInitPwnd()
{
    CLockEx::Scoped lock(gLockInitWnd);

    return gpInitWnd;
}

//CBT-Proc for SetWindowsHookEx
static LRESULT CALLBACK MyCBTProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    if (nCode == HCBT_CREATEWND) {
        //get the new window from gpInitWnd
        CMyWindow * pwnd = GetInitPwnd();

        if (pwnd) {
            //first time call this proc
            //add this window to WindowManager
            pwnd->Attach((HWND)wParam);
            return (0);
        } else {
            //sencond time call this proc
            CREATESTRUCT * cs = ((CBT_CREATEWND *)lParam)->lpcs;
            if (!(cs->style & WS_CHILD)) {
                //we can do something here
                return (0);
            } else {
                return (1); //error, destroy the window
                            //or, maybe, CallNextHookEx
            }
        }
    } else
        return CallNextHookEx(ghook, nCode, wParam, lParam);
}

//Create a WH_CBT Hook
static bool HookCrate()
{
   HANDLE hThread = GetCurrentThread();
   DWORD dwThreadId = GetThreadId(hThread);
   if (hThread) {
        ghook = SetWindowsHookEx(
            WH_CBT,
            MyCBTProc,    //set the CBT proc
            0,
            dwThreadId);
        if (!ghook)
            return false;
   }

   return (0);
}

//Destroy WH_CBT Hook
static void HookDestroy()
{
   if (ghook) {
        UnhookWindowsHookEx(ghook);
        ghook = 0;
   }
}

///////////////////////////////////////////////
//this is a vector for keep all CMyWindow*
CWindowManager::CWindowManager(void)
{
}

CWindowManager::~CWindowManager(void)
{
    clear();
}

//insert new window
bool CWindowManager::Add(CMyWindow* pwnd)
{
    IterBool ib = insert(WindowPair(pwnd->GetSafeHwnd(), pwnd));
    return ib.second;
}

//remove a window by hwnd
bool CWindowManager::Remove(HWND hwnd)
{
    WndIterator wi = find(hwnd);

    if (wi == end( )) {
        return false;
    } else {
        erase(wi);
        return true;
    }
}

//find a window by hwnd
CMyWindow* CWindowManager::Find(HWND hwnd)
{
    WndIterator wi = find(hwnd);

    if (wi == end( )) {
        return (0);
    } else {
        return wi->second;
    }
}

//remove all items
void CWindowManager::Clear()
{
    clear();
}

//get instance as singleton pattern.
CWindowManager * CWindowManager::GetInstance()
{
    static CWindowManager wm;
    return &wm;
}

ウィンドウ クラスを登録し、WndProc を MyWIndowProc に設定します。

ATOM RegisteWindowClass(HINSTANCE hInstance, TCHAR * szClassName)
{
    WNDCLASSEX wcex;

    wcex.cbSize = sizeof(WNDCLASSEX);

    wcex.style      = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = MyWindowProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = 0;
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName   = 0;
    wcex.lpszClassName  = szClassName;
    wcex.hIconSm        = 0;    
    return RegisterClassEx(&wcex);
}

CMyWindow クラス、WM_CREATE と WM_CREATEMYWINDOW メッセージでの私のトラブルに注意してください

CMyWindow::CMyWindow(void)
    : _hwnd(0)
    , _hInst(0)
{
}


CMyWindow::~CMyWindow(void)
{
}

inline HWND CMyWindow::GetSafeHwnd()
{
    return _hwnd;
}

//Craete a window
bool CMyWindow::Create( HINSTANCE hInstance,
                        TCHAR * szWindowName,
                        DWORD dwStyle,
                        RECT& rect,
                        HWND hParentWnd,
                        HMENU hMenu,
                        LPVOID lpParam)
{
    //get safe instance
    HINSTANCE hInst = hInstance;
    if (!hInstance)
        if (!hParentWnd)
            return false;
        else
            hInst = (HINSTANCE) GetWindowLong(hParentWnd, GWL_HINSTANCE);
    if (!hInst)
        return false;

    //register window class
    if (!RegisteWindowClass(hInst, _MY_WINDOW_CLASS_NAME_)) {
        DWORD dwErr = GetLastError();
        if (dwErr != ERROR_CLASS_ALREADY_EXISTS) //0x00000582
            return false;
    }

    //claim i am creating 
    SetInitWnd(this);
    //create CBT hook, then this window will add to WindowManager
    HookCrate();
    //create window
    HWND hwnd = CreateWindow(
                    _MY_WINDOW_CLASS_NAME_,
                    szWindowName,
                    dwStyle,
                    rect.left, rect.right, rect.right - rect.left, rect.bottom - rect.top,
                    hParentWnd,
                    hMenu,
                    hInstance,
                    lpParam);
    //destroy CBT hook
    HookDestroy();

    if (!hwnd)
        return false;

    _hwnd = hwnd;
    _hInst = hInst;

    //show window
    ShowWindow(_hwnd, SW_SHOW);
    UpdateWindow(_hwnd);
    return true;    
}

//add the this window to WindowManager
void CMyWindow::Attach(HWND hwnd)
{
    _hwnd = hwnd;
    CWindowManager::GetInstance()->Add(this);

    UnsetInitWnd();
}

//remove the this window to WindowManager
void CMyWindow::Dettach()
{
    CWindowManager::GetInstance()->Remove(_hwnd);
    _hwnd = 0;
}



int CMyWindow::OnCreate(LPCREATESTRUCT ps)
{
    return (0);
}

void CMyWindow::OnCreateMyWindow()
{
}

//the WndProc callback function
LRESULT CALLBACK MyWindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    //Get the CMyWindow instance from WindowManager by hWnd
    CMyWindow * pwnd = CWindowManager::GetInstance()->Find(hWnd);
    //can not find thi window in WindowManager
    if (!pwnd) return DefWindowProc(hWnd, message, wParam, lParam);

    switch (message)
    {
    case WM_CREATE:
        {
            //perform the OnCreate function, just like MFC's OnCreate
            int r = pwnd->OnCreate(reinterpret_cast<LPCREATESTRUCT>(lParam));
            if (r)  //some error occurred, will destory the window
                return (r);
            //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            //I can not create any edit box in OnCreate function,
            //I must do it leater, when the window was created and
            //WM_CREATEMYWINDOW was received
            ::PostMessage(hWnd, WM_CREATEMYWINDOW, 0, 0);
        }
        break;
    /*
    case WM_.....
        other message
    case WM_.....
    */
    case WM_DESTROY:
        ::PostQuitMessage(0);
        break;
    case WM_CREATEMYWINDOW:
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //I can not create any edit box in OnCreate function,
        //I must do it when WM_CREATEMYWINDOW was received
        pwnd->OnCreateMyWindow();
        break;
    }

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

ここで、クラス CMyWindow を継承して 2 つのウィンドウを作成します。最初のウィンドウは、編集ボックスを備えた 2 番目のウィンドウを作成します。

class CMyWnd2 : public CMyWindow
{
public:
    CMyWnd2(void) : _hCmdEdit(0) {}
    ~CMyWnd2(void){}

protected:
    HWND _hCmdEdit;

    //create edit box
    virtual void OnCreateMyWindow();
};


class CMyWnd1 : public CMyWindow
{
public:
    CMyWnd1(void) {}
    ~CMyWnd1(void){}

protected:
    virtual int OnCreate(LPCREATESTRUCT ps);

    //create window2
    virtual void OnCreateMyWindow();

    CMyWnd2 _wnd2;
};

int CMyWnd1::OnCreate(LPCREATESTRUCT /*ps*/)
{
    //Can create window2, but can not crate window2's edit-boxs
    return (0);
}

//create window2 with edit box
void CMyWnd1::OnCreateMyWindow()
{
    RECT rect = {0, 0, 400, 300};

    _wnd2.Create(this->_hInst,
        0,
        WS_VISIBLE | WS_POPUP,
        rect,
        _hwnd,
        0,
        0);
}


//create edit box
void CMyWnd2::OnCreateMyWindow()
{
    RECT rect;
    GetClientRect(_hwnd, &rect);
    _hCmdEdit = CreateWindowEx(
                            WS_EX_STATICEDGE,
                            L"EDIT",
                            NULL,
                            WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL, 
                            0,
                            rect.bottom - 80,
                            rect.right - rect.left,
                            80,
                            _hwnd,
                            (HMENU) 100,
                            (HINSTANCE) GetWindowLong(_hwnd, GWL_HINSTANCE),
                            NULL);
}

最後に、WinMain 関数は CMyWnd1 のインスタンスを作成します

CMyWnd1 mainwnd;
RECT rect;
rect.left = rect.top = 0, rect.right = 500, rect.bottom = 400;
mainwnd.Create(hInstance,
    L"MyWindow",
    WS_OVERLAPPEDWINDOW,
    rect,
    0,
    0,
    0);

while (GetMessage(&msg, NULL, 0, 0))
{
    if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
}

ここには私が見逃したものがあるに違いありません。この問題を解決するのに役立つ人はいますか?

4

2 に答える 2

1

WM_CREATEメッセージはCreateWindow()返品前に送信されますのでご注意ください。これは、ウィンドウ ハンドル メンバー_hwnd(注: _ および __ で始まる識別子は使用されません。これらはコンパイラ拡張機能のために予約されています) がまだ初期化されておらず、0 が含まれていることを意味します。したがって、CreateWindow()子ウィンドウを作成するには有効なウィンドウ ハンドルを渡す必要があるため、後続の呼び出しは失敗します (スタイルがありWS_CHILDます）。ただし、ポップアップ ウィンドウ (WS_POPUPスタイル) では許可されます。それがおそらく Wnd2 が作成される理由ですが、編集ボックスは作成されません。

于 2012-08-28T21:55:18.247 に答える
0

わかりました。CBThookコールバック関数でばかげた間違いが発生しました。この関数が2回目に呼び出されたときに、WS_CHILDスタイルのウィンドウの作成要求を拒否しました。ゼロを返すだけです!! コメントのエラーを参照してください。今それは動作します！Rostのヒントに感謝します。

static LRESULT CALLBACK MyCBTProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    if (nCode == HCBT_CREATEWND) {
        //get the new window from gpInitWnd
        CMyWindow * pwnd = GetInitPwnd();

        if (pwnd) {
            //first time call this proc
            //add this window to WindowManager
            pwnd->Attach((HWND)wParam);
            return (0);
        } else {
            //sencond time call this proc
            return (0);

            ////
            /// below was my stupid code, 
            ////

            /*CREATESTRUCT * cs = ((CBT_CREATEWND *)lParam)->lpcs;
            if (!(cs->style & WS_CHILD)) {
                //we can do something here
                return (0);
            } else {
                return (1); //error, destroy the window
                            //or, maybe, CallNextHookEx
            }*/
        }
    } else
        return CallNextHookEx(ghook, nCode, wParam, lParam);
}
于 2012-08-29T16:13:56.243 に答える