src/msw/glcanvas.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/glcanvas.cpp
   3 // Purpose:     wxGLCanvas, for using OpenGL with wxWidgets under MS Windows
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #if defined(__BORLANDC__)
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_GLCANVAS
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/intl.h"
  30     #include "wx/log.h"
  31     #include "wx/app.h"
  32     #include "wx/module.h"
  33 #endif
  34
  35 #include "wx/msw/private.h"
  36
  37 #include "wx/glcanvas.h"
  38
  39 // from src/msw/window.cpp
  40 LRESULT WXDLLEXPORT APIENTRY _EXPORT wxWndProc(HWND hWnd, UINT message,
  41                                    WPARAM wParam, LPARAM lParam);
  42
  43 #ifdef GL_EXT_vertex_array
  44     #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) name
  45 #else
  46     #define WXUNUSED_WITHOUT_GL_EXT_vertex_array(name) WXUNUSED(name)
  47 #endif
  48
  49 // ----------------------------------------------------------------------------
  50 // libraries
  51 // ----------------------------------------------------------------------------
  52
  53 /*
  54   The following two compiler directives are specific to the Microsoft Visual
  55   C++ family of compilers
  56
  57   Fundementally what they do is instruct the linker to use these two libraries
  58   for the resolution of symbols. In essence, this is the equivalent of adding
  59   these two libraries to either the Makefile or project file.
  60
  61   This is NOT a recommended technique, and certainly is unlikely to be used
  62   anywhere else in wxWidgets given it is so specific to not only wxMSW, but
  63   also the VC compiler. However, in the case of opengl support, it's an
  64   applicable technique as opengl is optional in setup.h This code (wrapped by
  65   wxUSE_GLCANVAS), now allows opengl support to be added purely by modifying
  66   setup.h rather than by having to modify either the project or DSP fle.
  67
  68   See MSDN for further information on the exact usage of these commands.
  69 */
  70 #ifdef _MSC_VER
  71 #  pragma comment( lib, "opengl32" )
  72 #  pragma comment( lib, "glu32" )
  73 #endif
  74
  75 // ----------------------------------------------------------------------------
  76 // constants
  77 // ----------------------------------------------------------------------------
  78
  79 static const wxChar *wxGLCanvasClassName = wxT("wxGLCanvasClass");
  80 static const wxChar *wxGLCanvasClassNameNoRedraw = wxT("wxGLCanvasClassNR");
  81
  82 // ============================================================================
  83 // implementation
  84 // ============================================================================
  85
  86 // ----------------------------------------------------------------------------
  87 // wxGLModule is responsible for unregistering wxGLCanvasClass Windows class
  88 // ----------------------------------------------------------------------------
  89
  90 class wxGLModule : public wxModule
  91 {
  92 public:
  93     bool OnInit() { return true; }
  94     void OnExit() { UnregisterClasses(); }
  95
  96     // register the GL classes if not done yet, return true if ok, false if
  97     // registration failed
  98     static bool RegisterClasses();
  99
 100     // unregister the classes, done automatically on program termination
 101     static void UnregisterClasses();
 102
 103 private:
 104     // wxGLCanvas is only used from the main thread so this is MT-ok
 105     static bool ms_registeredGLClasses;
 106
 107     DECLARE_DYNAMIC_CLASS(wxGLModule)
 108 };
 109
 110 IMPLEMENT_DYNAMIC_CLASS(wxGLModule, wxModule)
 111
 112 bool wxGLModule::ms_registeredGLClasses = false;
 113
 114 /* static */
 115 bool wxGLModule::RegisterClasses()
 116 {
 117     if ( ms_registeredGLClasses )
 118         return true;
 119
 120     // We have to register a special window class because we need the CS_OWNDC
 121     // style for GLCanvas: some OpenGL drivers are buggy and don't work with
 122     // windows without this style
 123     WNDCLASS wndclass;
 124
 125     // the fields which are common to all classes
 126     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 127     wndclass.cbClsExtra    = 0;
 128     wndclass.cbWndExtra    = sizeof( DWORD ); // VZ: what is this DWORD used for?
 129     wndclass.hInstance     = wxhInstance;
 130     wndclass.hIcon         = (HICON) NULL;
 131     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 132     wndclass.lpszMenuName  = NULL;
 133
 134     // Register the GLCanvas class name
 135     wndclass.hbrBackground = (HBRUSH)NULL;
 136     wndclass.lpszClassName = wxGLCanvasClassName;
 137     wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
 138
 139     if ( !::RegisterClass(&wndclass) )
 140     {
 141         wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
 142         return false;
 143     }
 144
 145     // Register the GLCanvas class name for windows which don't do full repaint
 146     // on resize
 147     wndclass.lpszClassName = wxGLCanvasClassNameNoRedraw;
 148     wndclass.style        &= ~(CS_HREDRAW | CS_VREDRAW);
 149
 150     if ( !::RegisterClass(&wndclass) )
 151     {
 152         wxLogLastError(wxT("RegisterClass(wxGLCanvasClassNameNoRedraw)"));
 153
 154         ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
 155
 156         return false;
 157     }
 158
 159     ms_registeredGLClasses = true;
 160
 161     return true;
 162 }
 163
 164 /* static */
 165 void wxGLModule::UnregisterClasses()
 166 {
 167     // we need to unregister the classes in case we're in a DLL which is
 168     // unloaded and then loaded again because if we don't, the registration is
 169     // going to fail in wxGLCanvas::Create() the next time we're loaded
 170     if ( ms_registeredGLClasses )
 171     {
 172         ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
 173         ::UnregisterClass(wxGLCanvasClassNameNoRedraw, wxhInstance);
 174
 175         ms_registeredGLClasses = false;
 176     }
 177 }
 178
 179 // ----------------------------------------------------------------------------
 180 // wxGLContext
 181 // ----------------------------------------------------------------------------
 182
 183 IMPLEMENT_CLASS(wxGLContext, wxObject)
 184
 185 wxGLContext::wxGLContext(wxGLCanvas *win, const wxGLContext* other)
 186 {
 187     m_glContext = wglCreateContext(win->GetHDC());
 188     wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
 189
 190     if ( other )
 191     {
 192         if ( !wglShareLists(other->m_glContext, m_glContext) )
 193             wxLogLastError(_T("wglShareLists"));
 194     }
 195 }
 196
 197 wxGLContext::~wxGLContext()
 198 {
 199     // note that it's ok to delete the context even if it's the current one
 200     wglDeleteContext(m_glContext);
 201 }
 202
 203 bool wxGLContext::SetCurrent(const wxGLCanvas& win) const
 204 {
 205     if ( !wglMakeCurrent(win.GetHDC(), m_glContext) )
 206     {
 207         wxLogLastError(_T("wglMakeCurrent"));
 208         return false;
 209     }
 210     return true;
 211 }
 212
 213 // ============================================================================
 214 // wxGLCanvas
 215 // ============================================================================
 216
 217 IMPLEMENT_CLASS(wxGLCanvas, wxWindow)
 218
 219 BEGIN_EVENT_TABLE(wxGLCanvas, wxWindow)
 220     EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
 221     EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
 222 END_EVENT_TABLE()
 223
 224 // ----------------------------------------------------------------------------
 225 // wxGLCanvas construction
 226 // ----------------------------------------------------------------------------
 227
 228 void wxGLCanvas::Init()
 229 {
 230 #if WXWIN_COMPATIBILITY_2_8
 231     m_glContext = NULL;
 232 #endif
 233     m_hDC = NULL;
 234 }
 235
 236 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 237                        wxWindowID id,
 238                        const int *attribList,
 239                        const wxPoint& pos,
 240                        const wxSize& size,
 241                        long style,
 242                        const wxString& name,
 243                        const wxPalette& palette)
 244 {
 245     Init();
 246
 247     (void)Create(parent, id, pos, size, style, name, attribList, palette);
 248 }
 249
 250 wxGLCanvas::~wxGLCanvas()
 251 {
 252     ::ReleaseDC(GetHwnd(), m_hDC);
 253 }
 254
 255 // Replaces wxWindow::Create functionality, since we need to use a different
 256 // window class
 257 bool wxGLCanvas::Create(wxWindow *parent,
 258                         wxWindowID id,
 259                         const wxPoint& pos,
 260                         const wxSize& size,
 261                         long style,
 262                         const wxString& name,
 263                         const int *attribList,
 264                         const wxPalette& palette)
 265 {
 266     wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
 267
 268     if ( !wxGLModule::RegisterClasses() )
 269     {
 270         wxLogError(_("Failed to register OpenGL window class."));
 271
 272         return false;
 273     }
 274
 275     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 276         return false;
 277
 278     parent->AddChild(this);
 279
 280     /*
 281        A general rule with OpenGL and Win32 is that any window that will have a
 282        HGLRC built for it must have two flags:  WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
 283        You can find references about this within the knowledge base and most OpenGL
 284        books that contain the wgl function descriptions.
 285      */
 286     WXDWORD exStyle = 0;
 287     DWORD msflags = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
 288     msflags |= MSWGetStyle(style, &exStyle);
 289
 290     if ( !MSWCreate(wxGLCanvasClassName, NULL, pos, size, msflags, exStyle) )
 291         return false;
 292
 293     m_hDC = ::GetDC(GetHwnd());
 294     if ( !m_hDC )
 295         return false;
 296
 297     if ( !DoSetup(attribList) )
 298         return false;
 299
 300 #if wxUSE_PALETTE
 301     if ( !SetupPalette(palette) )
 302         return false;
 303 #else // !wxUSE_PALETTE
 304     wxUnusedVar(palette);
 305 #endif // wxUSE_PALETTE/!wxUSE_PALETTE
 306
 307     return true;
 308 }
 309
 310 // ----------------------------------------------------------------------------
 311 // operations
 312 // ----------------------------------------------------------------------------
 313
 314 bool wxGLCanvas::SwapBuffers()
 315 {
 316     if ( !::SwapBuffers(m_hDC) )
 317     {
 318         wxLogLastError(_T("SwapBuffers"));
 319         return false;
 320     }
 321
 322     return true;
 323 }
 324
 325 // ----------------------------------------------------------------------------
 326 // pixel format stuff
 327 // ----------------------------------------------------------------------------
 328
 329 static void
 330 AdjustPFDForAttributes(PIXELFORMATDESCRIPTOR& pfd, const int *attribList)
 331 {
 332     if ( !attribList )
 333         return;
 334
 335     // remove default attributes
 336     pfd.dwFlags &= ~PFD_DOUBLEBUFFER;
 337     pfd.iPixelType = PFD_TYPE_COLORINDEX;
 338
 339     for ( int arg = 0; attribList[arg]; )
 340     {
 341         switch ( attribList[arg++] )
 342         {
 343             case WX_GL_RGBA:
 344                 pfd.iPixelType = PFD_TYPE_RGBA;
 345                 break;
 346
 347             case WX_GL_BUFFER_SIZE:
 348                 pfd.cColorBits = attribList[arg++];
 349                 break;
 350
 351             case WX_GL_LEVEL:
 352                 // this member looks like it may be obsolete
 353                 if ( attribList[arg] > 0 )
 354                     pfd.iLayerType = PFD_OVERLAY_PLANE;
 355                 else if ( attribList[arg] < 0 )
 356                     pfd.iLayerType = (BYTE)PFD_UNDERLAY_PLANE;
 357                 else
 358                     pfd.iLayerType = PFD_MAIN_PLANE;
 359                 arg++;
 360                 break;
 361
 362             case WX_GL_DOUBLEBUFFER:
 363                 pfd.dwFlags |= PFD_DOUBLEBUFFER;
 364                 break;
 365
 366             case WX_GL_STEREO:
 367                 pfd.dwFlags |= PFD_STEREO;
 368                 break;
 369
 370             case WX_GL_AUX_BUFFERS:
 371                 pfd.cAuxBuffers = attribList[arg++];
 372                 break;
 373
 374             case WX_GL_MIN_RED:
 375                 pfd.cColorBits += (pfd.cRedBits = attribList[arg++]);
 376                 break;
 377
 378             case WX_GL_MIN_GREEN:
 379                 pfd.cColorBits += (pfd.cGreenBits = attribList[arg++]);
 380                 break;
 381
 382             case WX_GL_MIN_BLUE:
 383                 pfd.cColorBits += (pfd.cBlueBits = attribList[arg++]);
 384                 break;
 385
 386             case WX_GL_MIN_ALPHA:
 387                 // doesn't count in cColorBits
 388                 pfd.cAlphaBits = attribList[arg++];
 389                 break;
 390
 391             case WX_GL_DEPTH_SIZE:
 392                 pfd.cDepthBits = attribList[arg++];
 393                 break;
 394
 395             case WX_GL_STENCIL_SIZE:
 396                 pfd.cStencilBits = attribList[arg++];
 397                 break;
 398
 399             case WX_GL_MIN_ACCUM_RED:
 400                 pfd.cAccumBits += (pfd.cAccumRedBits = attribList[arg++]);
 401                 break;
 402
 403             case WX_GL_MIN_ACCUM_GREEN:
 404                 pfd.cAccumBits += (pfd.cAccumGreenBits = attribList[arg++]);
 405                 break;
 406
 407             case WX_GL_MIN_ACCUM_BLUE:
 408                 pfd.cAccumBits += (pfd.cAccumBlueBits = attribList[arg++]);
 409                 break;
 410
 411             case WX_GL_MIN_ACCUM_ALPHA:
 412                 pfd.cAccumBits += (pfd.cAccumAlphaBits = attribList[arg++]);
 413                 break;
 414         }
 415     }
 416 }
 417
 418 /* static */
 419 int
 420 wxGLCanvas::ChooseMatchingPixelFormat(HDC hdc,
 421                                       const int *attribList,
 422                                       PIXELFORMATDESCRIPTOR *ppfd)
 423 {
 424     // default neutral pixel format
 425     PIXELFORMATDESCRIPTOR pfd =
 426     {
 427         sizeof(PIXELFORMATDESCRIPTOR),  // size
 428         1,                              // version
 429         PFD_SUPPORT_OPENGL |
 430         PFD_DRAW_TO_WINDOW |
 431         PFD_DOUBLEBUFFER,               // use double-buffering by default
 432         PFD_TYPE_RGBA,                  // default pixel type
 433         0,                              // preferred color depth (don't care)
 434         0, 0, 0, 0, 0, 0,               // color bits and shift bits (ignored)
 435         0, 0,                           // alpha bits and shift (ignored)
 436         0,                              // accumulation total bits
 437         0, 0, 0, 0,                     // accumulator RGBA bits (not used)
 438         16,                             // depth buffer
 439         0,                              // no stencil buffer
 440         0,                              // no auxiliary buffers
 441         PFD_MAIN_PLANE,                 // main layer
 442         0,                              // reserved
 443         0, 0, 0,                        // no layer, visible, damage masks
 444     };
 445
 446     if ( !ppfd )
 447         ppfd = &pfd;
 448     else
 449         *ppfd = pfd;
 450
 451     AdjustPFDForAttributes(*ppfd, attribList);
 452
 453     return ::ChoosePixelFormat(hdc, ppfd);
 454 }
 455
 456 /* static */
 457 bool wxGLCanvasBase::IsDisplaySupported(const int *attribList)
 458 {
 459     // We need a device context to test the pixel format, so get one
 460     // for the root window.
 461     return wxGLCanvas::ChooseMatchingPixelFormat(ScreenHDC(), attribList) > 0;
 462 }
 463
 464 bool wxGLCanvas::DoSetup(const int *attribList)
 465 {
 466     PIXELFORMATDESCRIPTOR pfd;
 467     const int pixelFormat = ChooseMatchingPixelFormat(m_hDC, attribList, &pfd);
 468     if ( !pixelFormat )
 469     {
 470         wxLogLastError(_T("ChoosePixelFormat"));
 471         return false;
 472     }
 473
 474     if ( !::SetPixelFormat(m_hDC, pixelFormat, &pfd) )
 475     {
 476         wxLogLastError(_T("SetPixelFormat"));
 477         return false;
 478     }
 479
 480     return true;
 481 }
 482
 483 // ----------------------------------------------------------------------------
 484 // palette stuff
 485 // ----------------------------------------------------------------------------
 486
 487 #if wxUSE_PALETTE
 488
 489 bool wxGLCanvas::SetupPalette(const wxPalette& palette)
 490 {
 491     const int pixelFormat = ::GetPixelFormat(m_hDC);
 492     if ( !pixelFormat )
 493     {
 494         wxLogLastError(_T("GetPixelFormat"));
 495         return false;
 496     }
 497
 498     PIXELFORMATDESCRIPTOR pfd;
 499     if ( !::DescribePixelFormat(m_hDC, pixelFormat, sizeof(pfd), &pfd) )
 500     {
 501         wxLogLastError(_T("DescribePixelFormat"));
 502         return false;
 503     }
 504
 505     if ( !(pfd.dwFlags & PFD_NEED_PALETTE) )
 506         return true;
 507
 508     m_palette = palette;
 509
 510     if ( !m_palette.Ok() )
 511     {
 512         m_palette = CreateDefaultPalette();
 513         if ( !m_palette.Ok() )
 514             return false;
 515     }
 516
 517     if ( !::SelectPalette(m_hDC, GetHpaletteOf(m_palette), FALSE) )
 518     {
 519         wxLogLastError(_T("SelectPalette"));
 520         return false;
 521     }
 522
 523     if ( ::RealizePalette(m_hDC) == GDI_ERROR )
 524     {
 525         wxLogLastError(_T("RealizePalette"));
 526         return false;
 527     }
 528
 529     return true;
 530 }
 531
 532 wxPalette wxGLCanvas::CreateDefaultPalette()
 533 {
 534     PIXELFORMATDESCRIPTOR pfd;
 535     int paletteSize;
 536     int pixelFormat = GetPixelFormat(m_hDC);
 537
 538     DescribePixelFormat(m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
 539
 540     paletteSize = 1 << pfd.cColorBits;
 541
 542     LOGPALETTE* pPal =
 543      (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
 544     pPal->palVersion = 0x300;
 545     pPal->palNumEntries = (WORD)paletteSize;
 546
 547     /* build a simple RGB color palette */
 548     {
 549     int redMask = (1 << pfd.cRedBits) - 1;
 550     int greenMask = (1 << pfd.cGreenBits) - 1;
 551     int blueMask = (1 << pfd.cBlueBits) - 1;
 552     int i;
 553
 554     for (i=0; i<paletteSize; ++i) {
 555         pPal->palPalEntry[i].peRed =
 556             (BYTE)((((i >> pfd.cRedShift) & redMask) * 255) / redMask);
 557         pPal->palPalEntry[i].peGreen =
 558             (BYTE)((((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask);
 559         pPal->palPalEntry[i].peBlue =
 560             (BYTE)((((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask);
 561         pPal->palPalEntry[i].peFlags = 0;
 562     }
 563     }
 564
 565     HPALETTE hPalette = CreatePalette(pPal);
 566     free(pPal);
 567
 568     wxPalette palette;
 569     palette.SetHPALETTE((WXHPALETTE) hPalette);
 570
 571     return palette;
 572 }
 573
 574 void wxGLCanvas::OnQueryNewPalette(wxQueryNewPaletteEvent& event)
 575 {
 576   /* realize palette if this is the current window */
 577   if ( GetPalette()->Ok() ) {
 578     ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
 579     ::SelectPalette(GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
 580     ::RealizePalette(GetHDC());
 581     Refresh();
 582     event.SetPaletteRealized(true);
 583   }
 584   else
 585     event.SetPaletteRealized(false);
 586 }
 587
 588 void wxGLCanvas::OnPaletteChanged(wxPaletteChangedEvent& event)
 589 {
 590   /* realize palette if this is *not* the current window */
 591   if ( GetPalette() &&
 592        GetPalette()->Ok() && (this != event.GetChangedWindow()) )
 593   {
 594     ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
 595     ::SelectPalette(GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
 596     ::RealizePalette(GetHDC());
 597     Refresh();
 598   }
 599 }
 600
 601 #endif // wxUSE_PALETTE
 602
 603 // ----------------------------------------------------------------------------
 604 // deprecated wxGLCanvas methods using implicit wxGLContext
 605 // ----------------------------------------------------------------------------
 606
 607 // deprecated constructors creating an implicit m_glContext
 608 #if WXWIN_COMPATIBILITY_2_8
 609
 610 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 611                        wxWindowID id,
 612                        const wxPoint& pos,
 613                        const wxSize& size,
 614                        long style,
 615                        const wxString& name,
 616                        const int *attribList,
 617                        const wxPalette& palette)
 618 {
 619     Init();
 620
 621     if ( Create(parent, id, pos, size, style, name, attribList, palette) )
 622         m_glContext = new wxGLContext(this);
 623 }
 624
 625 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 626                        const wxGLContext *shared,
 627                        wxWindowID id,
 628                        const wxPoint& pos,
 629                        const wxSize& size,
 630                        long style,
 631                        const wxString& name,
 632                        const int *attribList,
 633                        const wxPalette& palette)
 634 {
 635     Init();
 636
 637     if ( Create(parent, id, pos, size, style, name, attribList, palette) )
 638         m_glContext = new wxGLContext(this, shared);
 639 }
 640
 641 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 642                        const wxGLCanvas *shared,
 643                        wxWindowID id,
 644                        const wxPoint& pos,
 645                        const wxSize& size,
 646                        long style,
 647                        const wxString& name,
 648                        const int *attribList,
 649                        const wxPalette& palette)
 650 {
 651     Init();
 652
 653     if ( Create(parent, id, pos, size, style, name, attribList, palette) )
 654         m_glContext = new wxGLContext(this, shared ? shared->m_glContext : NULL);
 655 }
 656
 657 #endif // WXWIN_COMPATIBILITY_2_8
 658
 659
 660 // ----------------------------------------------------------------------------
 661 // wxGLApp
 662 // ----------------------------------------------------------------------------
 663
 664 bool wxGLApp::InitGLVisual(const int *attribList)
 665 {
 666     if ( !wxGLCanvas::ChooseMatchingPixelFormat(ScreenHDC(), attribList) )
 667     {
 668         wxLogError(_("Failed to initialize OpenGL"));
 669         return false;
 670     }
 671
 672     return true;
 673 }
 674
 675 #endif // wxUSE_GLCANVAS