title: CreateWindowEx failing
body: <p>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/).</p>
  
  <p>I'm trying to pass the WndProc a pointer to my Window object via the lpParam (as detailed here: <a href="http://web.archive.org/web/20051125022758/www.rpi.edu/~pudeyo/articles/wndproc/" rel="nofollow">http://web.archive.org/web/20051125022758/www.rpi.edu/~pudeyo/articles/wndproc/</a>) but if I attempt to do so, CreateWindowEx fails with GetLastError returning 1400 - ERROR_INVALID_WINDOW_HANDLE.</p>
  
  <p>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:</p>
  
  <pre><code>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-&gt;lpCreateParams);
      }
  
      cog::Window* w = (cog::Window*)GetWindowLong(window, GWL_USERDATA);
      if(w) {
          return w-&gt;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-&gt;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(&amp;winClass)) {
          throw cog::WindowException(std::string("Failed to register class"));
      }
  
      if(this-&gt;fullscreen) {
          DEVMODE screenSettings;
          memset(&amp;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(&amp;screenSettings, CDS_FULLSCREEN)) {
              if(MessageBox(NULL, "Cannot start in full screen mode - start in windowed mode instead?", "OpenGL", MB_YESNO | MB_ICONEXCLAMATION)) {
                  this-&gt;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(&amp;winRect, winStyle, FALSE, winExStyle);
  
      /*
       * !! BLOWS UP AT THIS CALL - WindowException triggered
       */
      if(!(this-&gt;window = CreateWindowEx(
      winExStyle,
      TEXT("OpenGL"),
      TEXT("OpenGL Testing"),
      winStyle,
      0, 0,
      winRect.right - winRect.left,
      winRect.bottom - winRect.top,
      NULL,
      NULL,
      this-&gt;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;
      }
  }
  </code></pre>
  
  <p>The member windowProc:</p>
  
  <pre><code>LRESULT CALLBACK cog::Window::windowProc(UINT msg, WPARAM wParam, LPARAM lParam) {
      switch(msg) {
      case WM_ACTIVATE:
          if(HIWORD(wParam)) {
              this-&gt;active = FALSE;
  
          } else {
              this-&gt;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-&gt;keys[wParam] = TRUE;
          break;
  
      case WM_KEYUP:
          this-&gt;keys[wParam] = FALSE;
          break;
  
      case WM_SIZE:
          this-&gt;resize(LOWORD(lParam), HIWORD(lParam));
          return 0;
  
      default:
          break;
      }
  
      return DefWindowProc(this-&gt;window, msg, wParam, lParam);
  }
  </code></pre>