CreateWindowEx failing

Question

I'm following the NeHe gamedev tutorials (while altering them to be OO) and I've run into a problem with the CreateWindowEx demo (http://nehe.gamedev.net/tutorial/creating_an_opengl_window_(win32)/13001/).

I'm trying to pass the WndProc a pointer to my Window object via the lpParam (as detailed here: http://web.archive.org/web/20051125022758/www.rpi.edu/~pudeyo/articles/wndproc/) but if I attempt to do so, CreateWindowEx fails with GetLastError returning 1400 - ERROR_INVALID_WINDOW_HANDLE.

I'm a complete beginner at the windows API and have exhausted every method I know of resolving this, please could you point out my mistake here? Relevant code below:

LRESULT CALLBACK cog::WindowProc(HWND window, UINT msg, WPARAM wParam, LPARAM lParam) {
    // Member method as windowproc: http://web.archive.org/web/20051125022758/www.rpi.edu/~pudeyo/articles/wndproc/

    if(msg == WM_NCCREATE) {
        LPCREATESTRUCT cs = (LPCREATESTRUCT)lParam;
        SetWindowLong(window, GWL_USERDATA, (long)cs->lpCreateParams);
    }

    cog::Window* w = (cog::Window*)GetWindowLong(window, GWL_USERDATA);
    if(w) {
        return w->windowProc(msg, wParam, lParam);

    } else {
        return DefWindowProc(window, msg, wParam, lParam);
    }
}

cog::Window::Window(int width, int height, int bits, bool fullscreen) :
fullscreen(fullscreen), appInstance(GetModuleHandle(NULL)), active(FALSE) {

    // Generate a rectangle corresponding to the window size
    RECT winRect = {0, 0, width, height};

    WNDCLASS winClass;
     winClass.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;   // Redraw On Size, And Own DC For Window.
    winClass.lpfnWndProc    = (WNDPROC) cog::WindowProc;            // WndProc Handles Messages
    winClass.cbClsExtra     = 0;                                    // No Extra Window Data
    winClass.cbWndExtra     = sizeof(this);                         // Window Data - pointer to Window object
    winClass.hInstance      = this->appInstance;                    // Set The Instance
    winClass.hIcon          = LoadIcon(NULL, IDI_WINLOGO);          // Load The Default Icon
    winClass.hCursor        = LoadCursor(NULL, IDC_ARROW);          // Load The Arrow Pointer
    winClass.hbrBackground  = NULL;                                 // No Background Required For GL
    winClass.lpszMenuName   = NULL;                                 // We Don't Want A Menu
    winClass.lpszClassName  = TEXT("OpenGL");   

    if(!RegisterClass(&winClass)) {
        throw cog::WindowException(std::string("Failed to register class"));
    }

    if(this->fullscreen) {
        DEVMODE screenSettings;
        memset(&screenSettings, 0, sizeof(DEVMODE));

        screenSettings.dmSize = sizeof(DEVMODE);
        screenSettings.dmPelsWidth = width;
        screenSettings.dmPelsHeight = height;
        screenSettings.dmBitsPerPel = bits;
        screenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

        if(DISP_CHANGE_SUCCESSFUL != ChangeDisplaySettings(&screenSettings, CDS_FULLSCREEN)) {
            if(MessageBox(NULL, "Cannot start in full screen mode - start in windowed mode instead?", "OpenGL", MB_YESNO | MB_ICONEXCLAMATION)) {
                this->fullscreen = FALSE;

            } else {
                throw cog::WindowException(std::string("Refused to launch program in windowed mode"));

            }
        }
    }

    DWORD winExStyle;
    DWORD winStyle;
    if(fullscreen) {
        winExStyle = WS_EX_APPWINDOW;
        winStyle = WS_POPUP;
        ShowCursor(FALSE);

    } else {
        winExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
        winStyle = WS_OVERLAPPEDWINDOW;
    }

    AdjustWindowRectEx(&winRect, winStyle, FALSE, winExStyle);

    /*
     * !! BLOWS UP AT THIS CALL - WindowException triggered
     */
    if(!(this->window = CreateWindowEx(
    winExStyle,
    TEXT("OpenGL"),
    TEXT("OpenGL Testing"),
    winStyle,
    0, 0,
    winRect.right - winRect.left,
    winRect.bottom - winRect.top,
    NULL,
    NULL,
    this->appInstance,
    this))) {
        throw cog::WindowException(std::string("Failed to create window"));
    }

    // ... cut here ...
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE lPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
    MSG msg;
    cog::Window* w = NULL;

    try {
        w = new cog::Window(100, 100, 16, TRUE);

        // ... cut here ...

    } catch(cog::Exception e) {
        MessageBox(NULL, e.what(), "Exception Raised", MB_OK | MB_ICONEXCLAMATION);
    }

    if(w) {
        delete w;
    }
}

The member windowProc:

LRESULT CALLBACK cog::Window::windowProc(UINT msg, WPARAM wParam, LPARAM lParam) {
    switch(msg) {
    case WM_ACTIVATE:
        if(HIWORD(wParam)) {
            this->active = FALSE;

        } else {
            this->active = TRUE;
        }

        return 0;;

    case WM_SYSCOMMAND:
        switch(wParam) {
        case SC_SCREENSAVE:
        case SC_MONITORPOWER:
            return 0;
        }

        break;

    case WM_CLOSE:
        PostQuitMessage(0);
        return 0;

    case WM_KEYDOWN:
        this->keys[wParam] = TRUE;
        break;

    case WM_KEYUP:
        this->keys[wParam] = FALSE;
        break;

    case WM_SIZE:
        this->resize(LOWORD(lParam), HIWORD(lParam));
        return 0;

    default:
        break;
    }

    return DefWindowProc(this->window, msg, wParam, lParam);
}

Answer 1

Could the fact that you're requesting fullscreen be causing a problem? w = new cog::Window(100, 100, 16, TRUE);

If it helps, this works in my code base:

HWND impl::window_impl::create_window_(
    window_impl* window // associated window object
) {
    auto const INSTANCE = ::GetModuleHandleW(L"");

    WNDCLASSEXW const wc = {
        sizeof(WNDCLASSEXW),
        CS_OWNDC | CS_HREDRAW | CS_VREDRAW,
        window_impl::top_level_wnd_proc_,
        0,
        0,
        INSTANCE,
        nullptr,
        ::LoadCursorW(nullptr, MAKEINTRESOURCE(IDC_ARROW)),
        nullptr,
        nullptr,
        CLASS_NAME,
        nullptr
    };

    ::RegisterClassExW(&wc); // ignore return value

    auto const result = ::CreateWindowExW(
        0,
        CLASS_NAME,
        L"window",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        CW_USEDEFAULT, CW_USEDEFAULT,
        (HWND)nullptr ,
        (HMENU)nullptr,
        INSTANCE,
        window
    );

    return result;
}

[edit] I think your call to CreateWindowExW has the params in the wrong order -- specifically the instance paramater. Do you compile with STRICT on? It should detect this kind of problem.

[edit] Not directly related, but your implementation won't work when compiled as 64bit code, and it doesn't check for possible errors -- you should use something like:

//--------------------------------------------------------------------------
//! Get the userdata for the window given by @c hwnd (our window object).
//! @throw bklib::platform::windows_exception
//--------------------------------------------------------------------------
impl::window_impl* get_window_ptr(HWND hwnd) {
    ::SetLastError(0);
    auto const result = ::GetWindowLongPtrW(hwnd, GWLP_USERDATA);

    if (result == 0) {
        auto const e = ::GetLastError();
        if (e) {
            BOOST_THROW_EXCEPTION(bklib::platform::windows_exception()
                << bklib::platform::windows_error_code(e)
            );
        }
    }

    return reinterpret_cast<impl::window_impl*>(result);
}

//--------------------------------------------------------------------------
//! Set the userdata for the window given by @c hwnd to be our
//! window object.
//! @throw bklib::platform::windows_exception
//--------------------------------------------------------------------------
void set_window_ptr(HWND hwnd, impl::window_impl* ptr) {
    ::SetLastError(0);
    auto const result = ::SetWindowLongPtrW(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(ptr));

    if (result == 0) {
        auto const e = ::GetLastError();
        if (e) {
            BOOST_THROW_EXCEPTION(bklib::platform::windows_exception()
                << bklib::platform::windows_error_code(e)
            );
        }
    }
}

[edit] More code in case it helps

//------------------------------------------------------------------------------
//! Top level window procedure which forwards messages to the appropriate
//! impl::window_impl instance.
//! @throw noexcept
//!     Swallows all exceptions at the API boundary.
//------------------------------------------------------------------------------
LRESULT CALLBACK impl::window_impl::top_level_wnd_proc_(
    HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam
) try {
    // set the instance pointer for the window given by hwnd if it was just created
    if (msg == WM_NCCREATE) {
        auto const cs =
            reinterpret_cast<CREATESTRUCTW const*>(lParam);
        auto const window_ptr =
            reinterpret_cast<window_impl*>(cs->lpCreateParams);

        set_window_ptr(hwnd, window_ptr);
    }

    // the window object to forward the message to
    auto const window = get_window_ptr(hwnd);

    if (window) {
        return window->window_proc_(hwnd, msg, wParam, lParam);
    } else {
        // it's possible we will receive some messages beofre WM_NCCREATE;
        // use the default handler
        return ::DefWindowProcW(hwnd, msg, wParam, lParam);
    }
} catch (std::exception&) {
    ::PostQuitMessage(-1);
    return 0;
} catch (...) {
    ::PostQuitMessage(-1);
    return 0;
}

//------------------------------------------------------------------------------
//! Called by the top level window proc. Dispatches messages to their
//! appropriate handler function.
//------------------------------------------------------------------------------
LRESULT impl::window_impl::window_proc_(
    HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam
) {
    return ::DefWindowProcW(hwnd, msg, wParam, lParam);
}

//------------------------------------------------------------------------------
void impl::window_impl::create() {
    handle_ = create_window_(this);
}

//------------------------------------------------------------------------------
void impl::window_impl::show(bool visible) {
    ::ShowWindow(handle_, SW_SHOWDEFAULT);
    ::InvalidateRect(handle_, nullptr, FALSE);
    ::UpdateWindow(handle_);
}