我自己的C ++框架（类似MFC），我可以创建子窗口，但是当WM_CREATE创建编辑框时

Question

我构建了自己的类似于MFC的c ++框架，我可以在收到WM_CREATE消息时创建子窗口，但是我无法处理编辑框，我从Ivan Shcherbakov's post得到了这个想法，我发布了调用OnCreate后的WM_CREATEMYWINDOW消息，并在收到消息时在OnCreateMyWindow函数中创建一些东西，当然，它可以正常工作。但我想知道为什么以及如何解决这个问题。

我的CWnd是CMyWindow，我创建了一个CBT-hook来保存新窗口的HWND和CMyWindow *，然后添加到一个HWND-WINDOW映射作为WindowManager，消息循环回调函数MyWndProc，从WindowManger获取CMyWindow * hWnd参数，然后调用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;
};

WindowManager和CBT-HOOK部分在MyWindow.cpp

中

#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个窗口，第一个窗口将创建带编辑框的第二个窗口

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);
    }
}

这里必须有我错过的东西，任何人都可以帮我解决这个问题吗？

Answer 1

请注意WM_CREATE消息是在CreateWindow()返回之前发送的。这意味着窗口句柄成员_hwnd（注意：不应使用以_和__开头的标识符，它们是为编译器扩展保留的）尚未初始化且包含0.因此后续的CreateWindow()调用失败，因为您必须传递有效的窗口句柄才能创建子窗口（具有WS_CHILD样式）。但它允许弹出窗口（WS_POPUP样式）。这很可能就是创建Wnd2的原因，但编辑框不是。

Answer 2

我明白了，在CBThook回调函数中发生了一个愚蠢的错误，当第二次调用此函数时，我拒绝了具有WS_CHILD样式的窗口的创建请求。它只需要返回零!!请在评论中查看错误。现在它的作品！谢谢Rost's提示。

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);
}