]> git.saurik.com Git - wxWidgets.git/blobdiff - src/msw/glcanvas.cpp
I forgot to commit this one.
[wxWidgets.git] / src / msw / glcanvas.cpp
index 360e36c8765312d1975efd2480b94aab43c9f9ba..0f4ee4b78b43626c96b7fedc86100bd504ccb05a 100644 (file)
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
-// Name:        glcanvas.cpp
-// Purpose:     wxGLCanvas, for using OpenGL with wxWindows under MS Windows
+// Name:        src/msw/glcanvas.cpp
+// Purpose:     wxGLCanvas, for using OpenGL with wxWidgets under MS Windows
 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:    wxWindows licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 
-#ifdef __GNUG__
-#pragma implementation "glcanvas.h"
-#endif
-
 #include "wx/wxprec.h"
 
 #if defined(__BORLANDC__)
 #include "wx/wxprec.h"
 
 #if defined(__BORLANDC__)
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #endif
 
-#include <wx/setup.h>
-
 #if wxUSE_GLCANVAS
 
 #ifndef WX_PRECOMP
 #if wxUSE_GLCANVAS
 
 #ifndef WX_PRECOMP
-#include <wx/frame.h>
+    #include "wx/frame.h"
+    #include "wx/settings.h"
+    #include "wx/intl.h"
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/module.h"
 #endif
 
 #endif
 
-#include <wx/msw/private.h>
-#include <wx/settings.h>
-#include <wx/log.h>
+#include "wx/msw/private.h"
 
 
-#include <wx/glcanvas.h>
+// DLL options compatibility check:
+#include "wx/build.h"
+WX_CHECK_BUILD_OPTIONS("wxGL")
 
 
-wxChar wxGLCanvasClassName[]        = wxT("wxGLCanvasClass");
+#include "wx/glcanvas.h"
+
+#if GL_EXT_vertex_array
+    #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) name
+#else
+    #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) WXUNUSED(name)
+#endif
+
+/*
+  The following two compiler directives are specific to the Microsoft Visual
+  C++ family of compilers
+
+  Fundementally what they do is instruct the linker to use these two libraries
+  for the resolution of symbols. In essence, this is the equivalent of adding
+  these two libraries to either the Makefile or project file.
+
+  This is NOT a recommended technique, and certainly is unlikely to be used
+  anywhere else in wxWidgets given it is so specific to not only wxMSW, but
+  also the VC compiler. However, in the case of opengl support, it's an
+  applicable technique as opengl is optional in setup.h This code (wrapped by
+  wxUSE_GLCANVAS), now allows opengl support to be added purely by modifying
+  setup.h rather than by having to modify either the project or DSP fle.
+
+  See MSDN for further information on the exact usage of these commands.
+*/
+#ifdef _MSC_VER
+#  pragma comment( lib, "opengl32" )
+#  pragma comment( lib, "glu32" )
+#endif
+
+
+static const wxChar *wxGLCanvasClassName = wxT("wxGLCanvasClass");
+static const wxChar *wxGLCanvasClassNameNoRedraw = wxT("wxGLCanvasClassNR");
 
 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
                                    WPARAM wParam, LPARAM lParam);
 
 
 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
                                    WPARAM wParam, LPARAM lParam);
 
+// ----------------------------------------------------------------------------
+// wxGLModule is responsible for unregistering wxGLCanvasClass Windows class
+// ----------------------------------------------------------------------------
+
+class wxGLModule : public wxModule
+{
+public:
+    bool OnInit() { return true; }
+    void OnExit() { UnregisterClasses(); }
+
+    // register the GL classes if not done yet, return true if ok, false if
+    // registration failed
+    static bool RegisterClasses();
+
+    // unregister the classes, done automatically on program termination
+    static void UnregisterClasses();
+
+private:
+    // wxGLCanvas is only used from the main thread so this is MT-ok
+    static bool ms_registeredGLClasses;
+
+    DECLARE_DYNAMIC_CLASS(wxGLModule)
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxGLModule, wxModule)
+
+bool wxGLModule::ms_registeredGLClasses = false;
+
+/* static */
+bool wxGLModule::RegisterClasses()
+{
+    if (ms_registeredGLClasses)
+        return true;
+
+    // We have to register a special window class because we need the CS_OWNDC
+    // style for GLCanvas.
+
+  /*
+  From Angel Popov <jumpo@bitex.com>
+
+  Here are two snips from a dicussion in the OpenGL Gamedev list that explains
+  how this problem can be fixed:
+
+  "There are 5 common DCs available in Win95. These are aquired when you call
+  GetDC or GetDCEx from a window that does _not_ have the OWNDC flag.
+  OWNDC flagged windows do not get their DC from the common DC pool, the issue
+  is they require 800 bytes each from the limited 64Kb local heap for GDI."
+
+  "The deal is, if you hold onto one of the 5 shared DC's too long (as GL apps
+  do), Win95 will actually "steal" it from you.  MakeCurrent fails,
+  apparently, because Windows re-assigns the HDC to a different window.  The
+  only way to prevent this, the only reliable means, is to set CS_OWNDC."
+  */
+
+    WNDCLASS wndclass;
+
+    // the fields which are common to all classes
+    wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
+    wndclass.cbClsExtra    = 0;
+    wndclass.cbWndExtra    = sizeof( DWORD ); // VZ: what is this DWORD used for?
+    wndclass.hInstance     = wxhInstance;
+    wndclass.hIcon         = (HICON) NULL;
+    wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
+    wndclass.lpszMenuName  = NULL;
+
+    // Register the GLCanvas class name
+    wndclass.hbrBackground = (HBRUSH)NULL;
+    wndclass.lpszClassName = wxGLCanvasClassName;
+    wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
+
+    if ( !::RegisterClass(&wndclass) )
+    {
+        wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
+        return false;
+    }
+
+    // Register the GLCanvas class name for windows which don't do full repaint
+    // on resize
+    wndclass.lpszClassName = wxGLCanvasClassNameNoRedraw;
+    wndclass.style        &= ~(CS_HREDRAW | CS_VREDRAW);
+
+    if ( !::RegisterClass(&wndclass) )
+    {
+        wxLogLastError(wxT("RegisterClass(wxGLCanvasClassNameNoRedraw)"));
+
+        ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
+
+        return false;
+    }
+
+    ms_registeredGLClasses = true;
+
+    return true;
+}
+
+/* static */
+void wxGLModule::UnregisterClasses()
+{
+    // we need to unregister the classes in case we're in a DLL which is
+    // unloaded and then loaded again because if we don't, the registration is
+    // going to fail in wxGLCanvas::Create() the next time we're loaded
+    if ( ms_registeredGLClasses )
+    {
+        ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
+        ::UnregisterClass(wxGLCanvasClassNameNoRedraw, wxhInstance);
+
+        ms_registeredGLClasses = false;
+    }
+}
+
 /*
  * GLContext implementation
  */
 
 /*
  * GLContext implementation
  */
 
-wxGLContext::wxGLContext(bool isRGB, wxGLCanvas *win, const wxPalette& palette)
+wxGLContext::wxGLContext(bool WXUNUSED(isRGB), wxGLCanvas *win, const wxPalette& WXUNUSED(palette))
 {
   m_window = win;
 
   m_hDC = win->GetHDC();
 
   m_glContext = wglCreateContext((HDC) m_hDC);
 {
   m_window = win;
 
   m_hDC = win->GetHDC();
 
   m_glContext = wglCreateContext((HDC) m_hDC);
-  wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
+  wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
 
   wglMakeCurrent((HDC) m_hDC, m_glContext);
 }
 
 wxGLContext::wxGLContext(
 
   wglMakeCurrent((HDC) m_hDC, m_glContext);
 }
 
 wxGLContext::wxGLContext(
-               bool isRGB, wxGLCanvas *win,
-               const wxPalette& palette,
+               bool WXUNUSED(isRGB), wxGLCanvas *win,
+               const wxPalette& WXUNUSED(palette),
                const wxGLContext *other  /* for sharing display lists */
              )
 {
                const wxGLContext *other  /* for sharing display lists */
              )
 {
@@ -65,7 +206,7 @@ wxGLContext::wxGLContext(
   m_hDC = win->GetHDC();
 
   m_glContext = wglCreateContext((HDC) m_hDC);
   m_hDC = win->GetHDC();
 
   m_glContext = wglCreateContext((HDC) m_hDC);
-  wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGl context") );
+  wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
 
   if( other != 0 )
     wglShareLists( other->m_glContext, m_glContext );
 
   if( other != 0 )
     wglShareLists( other->m_glContext, m_glContext );
@@ -97,26 +238,18 @@ void wxGLContext::SetCurrent()
   {
     wglMakeCurrent((HDC) m_hDC, m_glContext);
   }
   {
     wglMakeCurrent((HDC) m_hDC, m_glContext);
   }
-
-  /*
-  setupPixelFormat(hDC);
-  setupPalette(hDC);
-  */
 }
 
 }
 
-void wxGLContext::SetColour(const char *colour)
+void wxGLContext::SetColour(const wxChar *colour)
 {
 {
-  float r = 0.0;
-  float g = 0.0;
-  float b = 0.0;
-  wxColour *col = wxTheColourDatabase->FindColour(colour);
-  if (col)
-  {
-    r = (float)(col->Red()/256.0);
-    g = (float)(col->Green()/256.0);
-    b = (float)(col->Blue()/256.0);
-    glColor3f( r, g, b);
-  }
+    wxColour col = wxTheColourDatabase->Find(colour);
+    if (col.Ok())
+    {
+        float r = (float)(col.Red()/256.0);
+        float g = (float)(col.Green()/256.0);
+        float b = (float)(col.Blue()/256.0);
+        glColor3f( r, g, b);
+    }
 }
 
 
 }
 
 
@@ -124,9 +257,9 @@ void wxGLContext::SetColour(const char *colour)
  * wxGLCanvas implementation
  */
 
  * wxGLCanvas implementation
  */
 
-IMPLEMENT_CLASS(wxGLCanvas, wxScrolledWindow)
+IMPLEMENT_CLASS(wxGLCanvas, wxWindow)
 
 
-BEGIN_EVENT_TABLE(wxGLCanvas, wxScrolledWindow)
+BEGIN_EVENT_TABLE(wxGLCanvas, wxWindow)
     EVT_SIZE(wxGLCanvas::OnSize)
     EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
     EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
     EVT_SIZE(wxGLCanvas::OnSize)
     EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
     EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
@@ -134,7 +267,7 @@ END_EVENT_TABLE()
 
 wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
     const wxPoint& pos, const wxSize& size, long style, const wxString& name,
 
 wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
     const wxPoint& pos, const wxSize& size, long style, const wxString& name,
-    int *attribList, const wxPalette& palette) : wxScrolledWindow()
+    int *attribList, const wxPalette& palette) : wxWindow()
 {
   m_glContext = (wxGLContext*) NULL;
 
 {
   m_glContext = (wxGLContext*) NULL;
 
@@ -142,8 +275,7 @@ wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
 
   if ( ret )
   {
 
   if ( ret )
   {
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
   }
 
   m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
   }
 
   m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
@@ -151,14 +283,14 @@ wxGLCanvas::wxGLCanvas(wxWindow *parent, wxWindowID id,
   SetupPixelFormat(attribList);
   SetupPalette(palette);
 
   SetupPixelFormat(attribList);
   SetupPalette(palette);
 
-  m_glContext = new wxGLContext(TRUE, this, palette);
+  m_glContext = new wxGLContext(true, this, palette);
 }
 
 wxGLCanvas::wxGLCanvas( wxWindow *parent,
               const wxGLContext *shared, wxWindowID id,
               const wxPoint& pos, const wxSize& size, long style, const wxString& name,
               int *attribList, const wxPalette& palette )
 }
 
 wxGLCanvas::wxGLCanvas( wxWindow *parent,
               const wxGLContext *shared, wxWindowID id,
               const wxPoint& pos, const wxSize& size, long style, const wxString& name,
               int *attribList, const wxPalette& palette )
-  : wxScrolledWindow()
+  : wxWindow()
 {
   m_glContext = (wxGLContext*) NULL;
 
 {
   m_glContext = (wxGLContext*) NULL;
 
@@ -166,8 +298,7 @@ wxGLCanvas::wxGLCanvas( wxWindow *parent,
 
   if ( ret )
   {
 
   if ( ret )
   {
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
   }
 
   m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
   }
 
   m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
@@ -175,7 +306,7 @@ wxGLCanvas::wxGLCanvas( wxWindow *parent,
   SetupPixelFormat(attribList);
   SetupPalette(palette);
 
   SetupPixelFormat(attribList);
   SetupPalette(palette);
 
-  m_glContext = new wxGLContext(TRUE, this, palette, shared );
+  m_glContext = new wxGLContext(true, this, palette, shared );
 }
 
 // Not very useful for wxMSW, but this is to be wxGTK compliant
 }
 
 // Not very useful for wxMSW, but this is to be wxGTK compliant
@@ -183,7 +314,7 @@ wxGLCanvas::wxGLCanvas( wxWindow *parent,
 wxGLCanvas::wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID id,
                         const wxPoint& pos, const wxSize& size, long style, const wxString& name,
                         int *attribList, const wxPalette& palette ):
 wxGLCanvas::wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID id,
                         const wxPoint& pos, const wxSize& size, long style, const wxString& name,
                         int *attribList, const wxPalette& palette ):
-  wxScrolledWindow()
+  wxWindow()
 {
   m_glContext = (wxGLContext*) NULL;
 
 {
   m_glContext = (wxGLContext*) NULL;
 
@@ -191,8 +322,7 @@ wxGLCanvas::wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID i
 
   if ( ret )
   {
 
   if ( ret )
   {
-    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
-    SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
+    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
   }
 
   m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
   }
 
   m_hDC = (WXHDC) ::GetDC((HWND) GetHWND());
@@ -202,168 +332,63 @@ wxGLCanvas::wxGLCanvas( wxWindow *parent, const wxGLCanvas *shared, wxWindowID i
 
   wxGLContext *sharedContext=0;
   if (shared) sharedContext=shared->GetContext();
 
   wxGLContext *sharedContext=0;
   if (shared) sharedContext=shared->GetContext();
-  m_glContext = new wxGLContext(TRUE, this, palette, sharedContext );
+  m_glContext = new wxGLContext(true, this, palette, sharedContext );
 }
 
 wxGLCanvas::~wxGLCanvas()
 {
 }
 
 wxGLCanvas::~wxGLCanvas()
 {
-  if (m_glContext)
-    delete m_glContext;
+  delete m_glContext;
 
   ::ReleaseDC((HWND) GetHWND(), (HDC) m_hDC);
 }
 
 
   ::ReleaseDC((HWND) GetHWND(), (HDC) m_hDC);
 }
 
-// Replaces wxWindow::Create functionality, since we need to use a different window class
-bool wxGLCanvas::Create(wxWindow *parent, wxWindowID id,
-              const wxPoint& pos, const wxSize& size, long style, const wxString& name)
+// Replaces wxWindow::Create functionality, since we need to use a different
+// window class
+bool wxGLCanvas::Create(wxWindow *parent,
+                        wxWindowID id,
+                        const wxPoint& pos,
+                        const wxSize& size,
+                        long style,
+                        const wxString& name)
 {
 {
-  /*
-  Suggestion from Kelly Brock <kbrock@8cs.com> (not yet implemented):
-
-  OpenGL corruption fix is simple assuming it doesn't screw anything else
-  up.  Add the following line to the top of the create function:
-       wxSize parentSize = GetClientSize();
-
-  All locations within the function that use 'size' are changed to
-  'parentSize'.
-  The above corrects the initial display corruption with the GeForce and
-  TNT2, not sure about other NVidia cards yet.
-  */
-
-  static bool registeredGLCanvasClass = FALSE;
+    wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
 
 
-  // We have to register a special window class because we need
-  // the CS_OWNDC style for GLCanvas.
-
-  /*
-  From Angel Popov <jumpo@bitex.com>
-
-  Here are two snips from a dicussion in the OpenGL Gamedev list that explains
-  how this problem can be fixed:
-
-  "There are 5 common DCs available in Win95. These are aquired when you call
-  GetDC or GetDCEx from a window that does _not_ have the OWNDC flag.
-  OWNDC flagged windows do not get their DC from the common DC pool, the issue
-  is they require 800 bytes each from the limited 64Kb local heap for GDI."
-
-  "The deal is, if you hold onto one of the 5 shared DC's too long (as GL apps
-  do), Win95 will actually "steal" it from you.  MakeCurrent fails,
-  apparently, because Windows re-assigns the HDC to a different window.  The
-  only way to prevent this, the only reliable means, is to set CS_OWNDC."
-  */
-
-  if (!registeredGLCanvasClass)
-  {
-    WNDCLASS wndclass;
-
-    static const long styleNormal = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
-
-    // the fields which are common to all classes
-    wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
-    wndclass.cbClsExtra    = 0;
-    wndclass.cbWndExtra    = sizeof( DWORD ); // VZ: what is this DWORD used for?
-    wndclass.hInstance     = wxhInstance;
-    wndclass.hIcon         = (HICON) NULL;
-    wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
-    wndclass.lpszMenuName  = NULL;
-
-    // Register the GLCanvas class name
-    wndclass.hbrBackground = (HBRUSH)NULL;
-    wndclass.lpszClassName = wxGLCanvasClassName;
-    wndclass.style         = styleNormal;
-
-    if ( !RegisterClass(&wndclass) )
+    if ( !wxGLModule::RegisterClasses() )
     {
     {
-      wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
-      return FALSE;
-    }
-
-    registeredGLCanvasClass = TRUE;
-  }
-
-  wxCHECK_MSG( parent, FALSE, wxT("can't create wxWindow without parent") );
-
-  if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
-    return FALSE;
-
-  parent->AddChild(this);
-
-  DWORD msflags = 0;
-  if ( style & wxBORDER )
-    msflags |= WS_BORDER;
-  if ( style & wxTHICK_FRAME )
-    msflags |= WS_THICKFRAME;
+        wxLogError(_("Failed to register OpenGL window class."));
 
 
-  /*
-  A general rule with OpenGL and Win32 is that any window that will have a
-  HGLRC built for it must have two flags:  WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
-  You can find references about this within the knowledge base and most OpenGL
-  books that contain the wgl function descriptions.
-  */
+        return false;
+    }
 
 
-  msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS;
-  //  if ( style & wxCLIP_CHILDREN )
-  //    msflags |= WS_CLIPCHILDREN;
-  msflags |= WS_CLIPCHILDREN;
+    if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
+        return false;
 
 
-  bool want3D;
-  WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
+    parent->AddChild(this);
 
 
-  // Even with extended styles, need to combine with WS_BORDER
-  // for them to look right.
-  if ( want3D || (m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER ) ||
-       (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
-  {
-    msflags |= WS_BORDER;
-  }
+    DWORD msflags = 0;
 
 
-  // calculate the value to return from WM_GETDLGCODE handler
-  if ( GetWindowStyleFlag() & wxWANTS_CHARS )
-  {
-    // want everything: i.e. all keys and WM_CHAR message
-    m_lDlgCode = DLGC_WANTARROWS | DLGC_WANTCHARS |
-                 DLGC_WANTTAB | DLGC_WANTMESSAGE;
-  }
+    /*
+       A general rule with OpenGL and Win32 is that any window that will have a
+       HGLRC built for it must have two flags:  WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
+       You can find references about this within the knowledge base and most OpenGL
+       books that contain the wgl function descriptions.
+     */
 
 
-  MSWCreate(m_windowId, parent, wxGLCanvasClassName, this, NULL,
-            pos.x, pos.y,
-            WidthDefault(size.x), HeightDefault(size.y),
-            msflags, NULL, exStyle);
+    WXDWORD exStyle = 0;
+    msflags |= WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
+    msflags |= MSWGetStyle(style, & exStyle) ;
 
 
-  return TRUE;
+    return MSWCreate(wxGLCanvasClassName, NULL, pos, size, msflags, exStyle);
 }
 
 }
 
-void wxGLCanvas::SetupPixelFormat(int *attribList) // (HDC hDC)
+static void AdjustPFDForAttributes(PIXELFORMATDESCRIPTOR& pfd, int *attribList)
 {
 {
-  int pixelFormat;
-  PIXELFORMATDESCRIPTOR pfd = {
-               sizeof(PIXELFORMATDESCRIPTOR),  /* size */
-               1,                              /* version */
-               PFD_SUPPORT_OPENGL |
-               PFD_DRAW_TO_WINDOW |
-               PFD_DOUBLEBUFFER,               /* support double-buffering */
-               PFD_TYPE_RGBA,                  /* color type */
-               16,                             /* prefered color depth */
-               0, 0, 0, 0, 0, 0,               /* color bits (ignored) */
-               0,                              /* no alpha buffer */
-               0,                              /* alpha bits (ignored) */
-               0,                              /* no accumulation buffer */
-               0, 0, 0, 0,                     /* accum bits (ignored) */
-               16,                             /* depth buffer */
-               0,                              /* no stencil buffer */
-               0,                              /* no auxiliary buffers */
-               PFD_MAIN_PLANE,                 /* main layer */
-               0,                              /* reserved */
-               0, 0, 0,                        /* no layer, visible, damage masks */
-       };
-
   if (attribList) {
     pfd.dwFlags &= ~PFD_DOUBLEBUFFER;
     pfd.iPixelType = PFD_TYPE_COLORINDEX;
     pfd.cColorBits = 0;
     int arg=0;
   if (attribList) {
     pfd.dwFlags &= ~PFD_DOUBLEBUFFER;
     pfd.iPixelType = PFD_TYPE_COLORINDEX;
     pfd.cColorBits = 0;
     int arg=0;
-       
+
     while( (attribList[arg]!=0) )
     {
       switch( attribList[arg++] )
     while( (attribList[arg]!=0) )
     {
       switch( attribList[arg++] )
@@ -372,16 +397,16 @@ void wxGLCanvas::SetupPixelFormat(int *attribList) // (HDC hDC)
           pfd.iPixelType = PFD_TYPE_RGBA;
           break;
         case WX_GL_BUFFER_SIZE:
           pfd.iPixelType = PFD_TYPE_RGBA;
           break;
         case WX_GL_BUFFER_SIZE:
-          pfd.cColorBits = attribList[arg++];
+          pfd.cColorBits = (BYTE)attribList[arg++];
           break;
         case WX_GL_LEVEL:
           // this member looks like it may be obsolete
           if (attribList[arg] > 0) {
           break;
         case WX_GL_LEVEL:
           // this member looks like it may be obsolete
           if (attribList[arg] > 0) {
-            pfd.iLayerType = PFD_OVERLAY_PLANE;
+            pfd.iLayerType = (BYTE)PFD_OVERLAY_PLANE;
           } else if (attribList[arg] < 0) {
           } else if (attribList[arg] < 0) {
-            pfd.iLayerType = PFD_UNDERLAY_PLANE;
+            pfd.iLayerType = (BYTE)PFD_UNDERLAY_PLANE;
           } else {
           } else {
-            pfd.iLayerType = PFD_MAIN_PLANE;
+            pfd.iLayerType = (BYTE)PFD_MAIN_PLANE;
           }
           arg++;
           break;
           }
           arg++;
           break;
@@ -392,55 +417,79 @@ void wxGLCanvas::SetupPixelFormat(int *attribList) // (HDC hDC)
           pfd.dwFlags |= PFD_STEREO;
           break;
         case WX_GL_AUX_BUFFERS:
           pfd.dwFlags |= PFD_STEREO;
           break;
         case WX_GL_AUX_BUFFERS:
-          pfd.cAuxBuffers = attribList[arg++];
+          pfd.cAuxBuffers = (BYTE)attribList[arg++];
           break;
         case WX_GL_MIN_RED:
           break;
         case WX_GL_MIN_RED:
-          pfd.cColorBits += (pfd.cRedBits = attribList[arg++]);
+          pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cRedBits = (BYTE)attribList[arg++]));
           break;
         case WX_GL_MIN_GREEN:
           break;
         case WX_GL_MIN_GREEN:
-          pfd.cColorBits += (pfd.cGreenBits = attribList[arg++]);
+          pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cGreenBits = (BYTE)attribList[arg++]));
           break;
         case WX_GL_MIN_BLUE:
           break;
         case WX_GL_MIN_BLUE:
-          pfd.cColorBits += (pfd.cBlueBits = attribList[arg++]);
+          pfd.cColorBits = (BYTE)(pfd.cColorBits + (pfd.cBlueBits = (BYTE)attribList[arg++]));
           break;
         case WX_GL_MIN_ALPHA:
           // doesn't count in cColorBits
           break;
         case WX_GL_MIN_ALPHA:
           // doesn't count in cColorBits
-          pfd.cAlphaBits = attribList[arg++];
+          pfd.cAlphaBits = (BYTE)attribList[arg++];
           break;
           break;
-        case WX_GL_DEPTH_SIZE: 
-          pfd.cDepthBits = attribList[arg++];
+        case WX_GL_DEPTH_SIZE:
+          pfd.cDepthBits = (BYTE)attribList[arg++];
           break;
           break;
-        case WX_GL_STENCIL_SIZE: 
-          pfd.cStencilBits = attribList[arg++];
+        case WX_GL_STENCIL_SIZE:
+          pfd.cStencilBits = (BYTE)attribList[arg++];
           break;
         case WX_GL_MIN_ACCUM_RED:
           break;
         case WX_GL_MIN_ACCUM_RED:
-          pfd.cAccumBits += (pfd.cAccumRedBits = attribList[arg++]);
+          pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumRedBits = (BYTE)attribList[arg++]));
           break;
         case WX_GL_MIN_ACCUM_GREEN:
           break;
         case WX_GL_MIN_ACCUM_GREEN:
-          pfd.cAccumBits += (pfd.cAccumGreenBits = attribList[arg++]);
+          pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumGreenBits = (BYTE)attribList[arg++]));
           break;
         case WX_GL_MIN_ACCUM_BLUE:
           break;
         case WX_GL_MIN_ACCUM_BLUE:
-          pfd.cAccumBits += (pfd.cAccumBlueBits = attribList[arg++]);
+          pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumBlueBits = (BYTE)attribList[arg++]));
           break;
         case WX_GL_MIN_ACCUM_ALPHA:
           break;
         case WX_GL_MIN_ACCUM_ALPHA:
-          pfd.cAccumBits += (pfd.cAccumAlphaBits = attribList[arg++]);
+          pfd.cAccumBits = (BYTE)(pfd.cAccumBits + (pfd.cAccumAlphaBits = (BYTE)attribList[arg++]));
           break;
         default:
           break;
       }
     }
   }
           break;
         default:
           break;
       }
     }
   }
-  pixelFormat = ChoosePixelFormat((HDC) m_hDC, &pfd);
+}
+
+void wxGLCanvas::SetupPixelFormat(int *attribList) // (HDC hDC)
+{
+  PIXELFORMATDESCRIPTOR pfd = {
+        sizeof(PIXELFORMATDESCRIPTOR),    /* size */
+        1,                /* version */
+        PFD_SUPPORT_OPENGL |
+        PFD_DRAW_TO_WINDOW |
+        PFD_DOUBLEBUFFER,        /* support double-buffering */
+        PFD_TYPE_RGBA,            /* color type */
+        16,                /* preferred color depth */
+        0, 0, 0, 0, 0, 0,        /* color bits (ignored) */
+        0,                /* no alpha buffer */
+        0,                /* alpha bits (ignored) */
+        0,                /* no accumulation buffer */
+        0, 0, 0, 0,            /* accum bits (ignored) */
+        16,                /* depth buffer */
+        0,                /* no stencil buffer */
+        0,                /* no auxiliary buffers */
+        PFD_MAIN_PLANE,            /* main layer */
+        0,                /* reserved */
+        0, 0, 0,            /* no layer, visible, damage masks */
+    };
+
+  AdjustPFDForAttributes(pfd, attribList);
+
+  int pixelFormat = ChoosePixelFormat((HDC) m_hDC, &pfd);
   if (pixelFormat == 0) {
   if (pixelFormat == 0) {
-    MessageBox(WindowFromDC((HDC) m_hDC), wxT("ChoosePixelFormat failed."), wxT("Error"),
-               MB_ICONERROR | MB_OK);
-    exit(1);
+    wxLogLastError(_T("ChoosePixelFormat"));
   }
   }
-
-  if (SetPixelFormat((HDC) m_hDC, pixelFormat, &pfd) != TRUE) {
-    MessageBox(WindowFromDC((HDC) m_hDC), wxT("SetPixelFormat failed."), wxT("Error"),
-               MB_ICONERROR | MB_OK);
-    exit(1);
+  else {
+    if ( !::SetPixelFormat((HDC) m_hDC, pixelFormat, &pfd) ) {
+      wxLogLastError(_T("SetPixelFormat"));
+    }
   }
 }
 
   }
 }
 
@@ -456,7 +505,7 @@ void wxGLCanvas::SetupPalette(const wxPalette& palette)
     }
     else
     {
     }
     else
     {
-         return;
+      return;
     }
 
     m_palette = palette;
     }
 
     m_palette = palette;
@@ -468,8 +517,8 @@ void wxGLCanvas::SetupPalette(const wxPalette& palette)
 
     if (m_palette.Ok())
     {
 
     if (m_palette.Ok())
     {
-        SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
-        RealizePalette((HDC) m_hDC);
+        ::SelectPalette((HDC) m_hDC, (HPALETTE) m_palette.GetHPALETTE(), FALSE);
+        ::RealizePalette((HDC) m_hDC);
     }
 }
 
     }
 }
 
@@ -486,24 +535,24 @@ wxPalette wxGLCanvas::CreateDefaultPalette()
     LOGPALETTE* pPal =
      (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
     pPal->palVersion = 0x300;
     LOGPALETTE* pPal =
      (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
     pPal->palVersion = 0x300;
-    pPal->palNumEntries = paletteSize;
+    pPal->palNumEntries = (WORD)paletteSize;
 
     /* build a simple RGB color palette */
     {
 
     /* build a simple RGB color palette */
     {
-       int redMask = (1 << pfd.cRedBits) - 1;
-       int greenMask = (1 << pfd.cGreenBits) - 1;
-       int blueMask = (1 << pfd.cBlueBits) - 1;
-       int i;
-
-       for (i=0; i<paletteSize; ++i) {
-           pPal->palPalEntry[i].peRed =
-                   (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
-           pPal->palPalEntry[i].peGreen =
-                   (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
-           pPal->palPalEntry[i].peBlue =
-                   (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
-           pPal->palPalEntry[i].peFlags = 0;
-       }
+    int redMask = (1 << pfd.cRedBits) - 1;
+    int greenMask = (1 << pfd.cGreenBits) - 1;
+    int blueMask = (1 << pfd.cBlueBits) - 1;
+    int i;
+
+    for (i=0; i<paletteSize; ++i) {
+        pPal->palPalEntry[i].peRed =
+            (BYTE)((((i >> pfd.cRedShift) & redMask) * 255) / redMask);
+        pPal->palPalEntry[i].peGreen =
+            (BYTE)((((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask);
+        pPal->palPalEntry[i].peBlue =
+            (BYTE)((((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask);
+        pPal->palPalEntry[i].peFlags = 0;
+    }
     }
 
     HPALETTE hPalette = CreatePalette(pPal);
     }
 
     HPALETTE hPalette = CreatePalette(pPal);
@@ -521,32 +570,25 @@ void wxGLCanvas::SwapBuffers()
     m_glContext->SwapBuffers();
 }
 
     m_glContext->SwapBuffers();
 }
 
-void wxGLCanvas::OnSize(wxSizeEvent& event)
+void wxGLCanvas::OnSize(wxSizeEvent& WXUNUSED(event))
 {
 {
-  int width, height;
-  GetClientSize(& width, & height);
-
-  if (m_glContext)
-  {
-    m_glContext->SetCurrent();
-
-    glViewport(0, 0, (GLint)width, (GLint)height);
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-    glFrustum( -1.0, 1.0, -1.0, 1.0, 5.0, 15.0 );
-    glMatrixMode(GL_MODELVIEW);
-  }
 }
 
 void wxGLCanvas::SetCurrent()
 {
 }
 
 void wxGLCanvas::SetCurrent()
 {
+  // although on MSW it works even if the window is still hidden, it doesn't
+  // under wxGTK and documentation mentions that SetCurrent() can only be
+  // called for a shown window, so check it
+  wxASSERT_MSG( GetParent()->IsShown(),
+                    _T("can't make hidden GL canvas current") );
+
   if (m_glContext)
   {
     m_glContext->SetCurrent();
   }
 }
 
   if (m_glContext)
   {
     m_glContext->SetCurrent();
   }
 }
 
-void wxGLCanvas::SetColour(const char *colour)
+void wxGLCanvas::SetColour(const wxChar *colour)
 {
   if (m_glContext)
     m_glContext->SetColour(colour);
 {
   if (m_glContext)
     m_glContext->SetColour(colour);
@@ -562,10 +604,10 @@ void wxGLCanvas::OnQueryNewPalette(wxQueryNewPaletteEvent& event)
     ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
     ::RealizePalette((HDC) GetHDC());
     Refresh();
     ::SelectPalette((HDC) GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
     ::RealizePalette((HDC) GetHDC());
     Refresh();
-    event.SetPaletteRealized(TRUE);
+    event.SetPaletteRealized(true);
   }
   else
   }
   else
-    event.SetPaletteRealized(FALSE);
+    event.SetPaletteRealized(false);
 }
 
 // I think this doesn't have to be propagated to child windows.
 }
 
 // I think this doesn't have to be propagated to child windows.
@@ -585,15 +627,17 @@ void wxGLCanvas::OnPaletteChanged(wxPaletteChangedEvent& event)
 /* Give extensions proper function names. */
 
 /* EXT_vertex_array */
 /* Give extensions proper function names. */
 
 /* EXT_vertex_array */
-void glArrayElementEXT(GLint i)
+void glArrayElementEXT(GLint WXUNUSED(i))
 {
 }
 
 {
 }
 
-void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glColorPointerEXT(GLint WXUNUSED(size), GLenum WXUNUSED(type), GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLvoid *WXUNUSED(pointer))
 {
 }
 
 {
 }
 
-void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
+void glDrawArraysEXT(GLenum  WXUNUSED_WITHOUT_GL_EXT_vertex_array(mode),
+                     GLint   WXUNUSED_WITHOUT_GL_EXT_vertex_array(first),
+                     GLsizei WXUNUSED_WITHOUT_GL_EXT_vertex_array(count))
 {
 #ifdef GL_EXT_vertex_array
     static PFNGLDRAWARRAYSEXTPROC proc = 0;
 {
 #ifdef GL_EXT_vertex_array
     static PFNGLDRAWARRAYSEXTPROC proc = 0;
@@ -608,19 +652,22 @@ void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
 #endif
 }
 
 #endif
 }
 
-void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer)
+void glEdgeFlagPointerEXT(GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLboolean *WXUNUSED(pointer))
 {
 }
 
 {
 }
 
-void glGetPointervEXT(GLenum pname, GLvoid* *params)
+void glGetPointervEXT(GLenum WXUNUSED(pname), GLvoid* *WXUNUSED(params))
 {
 }
 
 {
 }
 
-void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glIndexPointerEXT(GLenum WXUNUSED(type), GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLvoid *WXUNUSED(pointer))
 {
 }
 
 {
 }
 
-void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glNormalPointerEXT(GLenum        WXUNUSED_WITHOUT_GL_EXT_vertex_array(type),
+                        GLsizei       WXUNUSED_WITHOUT_GL_EXT_vertex_array(stride),
+                        GLsizei       WXUNUSED_WITHOUT_GL_EXT_vertex_array(count),
+                        const GLvoid *WXUNUSED_WITHOUT_GL_EXT_vertex_array(pointer))
 {
 #ifdef GL_EXT_vertex_array
   static PFNGLNORMALPOINTEREXTPROC proc = 0;
 {
 #ifdef GL_EXT_vertex_array
   static PFNGLNORMALPOINTEREXTPROC proc = 0;
@@ -635,11 +682,15 @@ void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid
 #endif
 }
 
 #endif
 }
 
-void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glTexCoordPointerEXT(GLint WXUNUSED(size), GLenum WXUNUSED(type), GLsizei WXUNUSED(stride), GLsizei WXUNUSED(count), const GLvoid *WXUNUSED(pointer))
 {
 }
 
 {
 }
 
-void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer)
+void glVertexPointerEXT(GLint         WXUNUSED_WITHOUT_GL_EXT_vertex_array(size),
+                        GLenum        WXUNUSED_WITHOUT_GL_EXT_vertex_array(type),
+                        GLsizei       WXUNUSED_WITHOUT_GL_EXT_vertex_array(stride),
+                        GLsizei       WXUNUSED_WITHOUT_GL_EXT_vertex_array(count),
+                        const GLvoid *WXUNUSED_WITHOUT_GL_EXT_vertex_array(pointer))
 {
 #ifdef GL_EXT_vertex_array
   static PFNGLVERTEXPOINTEREXTPROC proc = 0;
 {
 #ifdef GL_EXT_vertex_array
   static PFNGLVERTEXPOINTEREXTPROC proc = 0;
@@ -654,33 +705,33 @@ void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count,
 }
 
 /* EXT_color_subtable */
 }
 
 /* EXT_color_subtable */
-void glColorSubtableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table)
+void glColorSubtableEXT(GLenum WXUNUSED(target), GLsizei WXUNUSED(start), GLsizei WXUNUSED(count), GLenum WXUNUSED(format), GLenum WXUNUSED(type), const GLvoid *WXUNUSED(table))
 {
 }
 
 /* EXT_color_table */
 {
 }
 
 /* EXT_color_table */
-void glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
+void glColorTableEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(internalformat), GLsizei WXUNUSED(width), GLenum WXUNUSED(format), GLenum WXUNUSED(type), const GLvoid *WXUNUSED(table))
 {
 }
 
 {
 }
 
-void glCopyColorTableEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+void glCopyColorTableEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(internalformat), GLint WXUNUSED(x), GLint WXUNUSED(y), GLsizei WXUNUSED(width))
 {
 }
 
 {
 }
 
-void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid *table)
+void glGetColorTableEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(format), GLenum WXUNUSED(type), GLvoid *WXUNUSED(table))
 {
 }
 
 {
 }
 
-void glGetColorTableParamaterfvEXT(GLenum target, GLenum pname, GLfloat *params)
+void glGetColorTableParamaterfvEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(pname), GLfloat *WXUNUSED(params))
 {
 }
 
 {
 }
 
-void glGetColorTavleParameterivEXT(GLenum target, GLenum pname, GLint *params)
+void glGetColorTavleParameterivEXT(GLenum WXUNUSED(target), GLenum WXUNUSED(pname), GLint *WXUNUSED(params))
 {
 }
 
 /* SGI_compiled_vertex_array */
 {
 }
 
 /* SGI_compiled_vertex_array */
-void glLockArraysSGI(GLint first, GLsizei count)
+void glLockArraysSGI(GLint WXUNUSED(first), GLsizei WXUNUSED(count))
 {
 }
 
 {
 }
 
@@ -690,26 +741,74 @@ void glUnlockArraysSGI()
 
 
 /* SGI_cull_vertex */
 
 
 /* SGI_cull_vertex */
-void glCullParameterdvSGI(GLenum pname, GLdouble* params)
+void glCullParameterdvSGI(GLenum WXUNUSED(pname), GLdouble* WXUNUSED(params))
 {
 }
 
 {
 }
 
-void glCullParameterfvSGI(GLenum pname, GLfloat* params)
+void glCullParameterfvSGI(GLenum WXUNUSED(pname), GLfloat* WXUNUSED(params))
 {
 }
 
 /* SGI_index_func */
 {
 }
 
 /* SGI_index_func */
-void glIndexFuncSGI(GLenum func, GLclampf ref)
+void glIndexFuncSGI(GLenum WXUNUSED(func), GLclampf WXUNUSED(ref))
 {
 }
 
 /* SGI_index_material */
 {
 }
 
 /* SGI_index_material */
-void glIndexMaterialSGI(GLenum face, GLenum mode)
+void glIndexMaterialSGI(GLenum WXUNUSED(face), GLenum WXUNUSED(mode))
 {
 }
 
 /* WIN_swap_hint */
 {
 }
 
 /* WIN_swap_hint */
-void glAddSwapHintRectWin(GLint x, GLint y, GLsizei width, GLsizei height)
+void glAddSwapHintRectWin(GLint WXUNUSED(x), GLint WXUNUSED(y), GLsizei WXUNUSED(width), GLsizei WXUNUSED(height))
+{
+}
+
+
+//---------------------------------------------------------------------------
+// wxGLApp
+//---------------------------------------------------------------------------
+
+IMPLEMENT_CLASS(wxGLApp, wxApp)
+
+bool wxGLApp::InitGLVisual(int *attribList)
+{
+  int pixelFormat;
+  PIXELFORMATDESCRIPTOR pfd = {
+        sizeof(PIXELFORMATDESCRIPTOR),    /* size */
+        1,                /* version */
+        PFD_SUPPORT_OPENGL |
+        PFD_DRAW_TO_WINDOW |
+        PFD_DOUBLEBUFFER,        /* support double-buffering */
+        PFD_TYPE_RGBA,            /* color type */
+        16,                /* preferred color depth */
+        0, 0, 0, 0, 0, 0,        /* color bits (ignored) */
+        0,                /* no alpha buffer */
+        0,                /* alpha bits (ignored) */
+        0,                /* no accumulation buffer */
+        0, 0, 0, 0,            /* accum bits (ignored) */
+        16,                /* depth buffer */
+        0,                /* no stencil buffer */
+        0,                /* no auxiliary buffers */
+        PFD_MAIN_PLANE,            /* main layer */
+        0,                /* reserved */
+        0, 0, 0,            /* no layer, visible, damage masks */
+    };
+
+  AdjustPFDForAttributes(pfd, attribList);
+
+  // use DC for whole (root) screen, since no windows have yet been created
+  pixelFormat = ChoosePixelFormat(ScreenHDC(), &pfd);
+
+  if (pixelFormat == 0) {
+    wxLogError(_("Failed to initialize OpenGL"));
+    return false;
+  }
+
+  return true;
+}
+
+wxGLApp::~wxGLApp()
 {
 }
 
 {
 }