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 // define possibly missing WGL constants
  51 // ----------------------------------------------------------------------------
  52
  53 #ifndef WGL_ARB_pixel_format
  54 #define WGL_DRAW_TO_WINDOW_ARB            0x2001
  55 #define WGL_ACCELERATION_ARB              0x2003
  56 #define WGL_NUMBER_OVERLAYS_ARB           0x2008
  57 #define WGL_NUMBER_UNDERLAYS_ARB          0x2009
  58 #define WGL_SUPPORT_OPENGL_ARB            0x2010
  59 #define WGL_DOUBLE_BUFFER_ARB             0x2011
  60 #define WGL_STEREO_ARB                    0x2012
  61 #define WGL_COLOR_BITS_ARB                0x2014
  62 #define WGL_RED_BITS_ARB                  0x2015
  63 #define WGL_GREEN_BITS_ARB                0x2017
  64 #define WGL_BLUE_BITS_ARB                 0x2019
  65 #define WGL_ALPHA_BITS_ARB                0x201B
  66 #define WGL_ACCUM_RED_BITS_ARB            0x201E
  67 #define WGL_ACCUM_GREEN_BITS_ARB          0x201F
  68 #define WGL_ACCUM_BLUE_BITS_ARB           0x2020
  69 #define WGL_ACCUM_ALPHA_BITS_ARB          0x2021
  70 #define WGL_DEPTH_BITS_ARB                0x2022
  71 #define WGL_STENCIL_BITS_ARB              0x2023
  72 #define WGL_AUX_BUFFERS_ARB               0x2024
  73 #define WGL_FULL_ACCELERATION_ARB         0x2027
  74 #endif
  75
  76 #ifndef WGL_ARB_multisample
  77 #define WGL_SAMPLE_BUFFERS_ARB            0x2041
  78 #define WGL_SAMPLES_ARB                   0x2042
  79 #endif
  80
  81 // ----------------------------------------------------------------------------
  82 // libraries
  83 // ----------------------------------------------------------------------------
  84
  85 /*
  86   The following two compiler directives are specific to the Microsoft Visual
  87   C++ family of compilers
  88
  89   Fundementally what they do is instruct the linker to use these two libraries
  90   for the resolution of symbols. In essence, this is the equivalent of adding
  91   these two libraries to either the Makefile or project file.
  92
  93   This is NOT a recommended technique, and certainly is unlikely to be used
  94   anywhere else in wxWidgets given it is so specific to not only wxMSW, but
  95   also the VC compiler. However, in the case of opengl support, it's an
  96   applicable technique as opengl is optional in setup.h This code (wrapped by
  97   wxUSE_GLCANVAS), now allows opengl support to be added purely by modifying
  98   setup.h rather than by having to modify either the project or DSP fle.
  99
 100   See MSDN for further information on the exact usage of these commands.
 101 */
 102 #ifdef _MSC_VER
 103 #  pragma comment( lib, "opengl32" )
 104 #  pragma comment( lib, "glu32" )
 105 #endif
 106
 107 // ----------------------------------------------------------------------------
 108 // constants
 109 // ----------------------------------------------------------------------------
 110
 111 static const wxChar *wxGLCanvasClassName = wxT("wxGLCanvasClass");
 112 static const wxChar *wxGLCanvasClassNameNoRedraw = wxT("wxGLCanvasClassNR");
 113
 114 // ============================================================================
 115 // implementation
 116 // ============================================================================
 117
 118 // ----------------------------------------------------------------------------
 119 // wxGLModule is responsible for unregistering wxGLCanvasClass Windows class
 120 // ----------------------------------------------------------------------------
 121
 122 class wxGLModule : public wxModule
 123 {
 124 public:
 125     bool OnInit() { return true; }
 126     void OnExit() { UnregisterClasses(); }
 127
 128     // register the GL classes if not done yet, return true if ok, false if
 129     // registration failed
 130     static bool RegisterClasses();
 131
 132     // unregister the classes, done automatically on program termination
 133     static void UnregisterClasses();
 134
 135 private:
 136     // wxGLCanvas is only used from the main thread so this is MT-ok
 137     static bool ms_registeredGLClasses;
 138
 139     DECLARE_DYNAMIC_CLASS(wxGLModule)
 140 };
 141
 142 IMPLEMENT_DYNAMIC_CLASS(wxGLModule, wxModule)
 143
 144 bool wxGLModule::ms_registeredGLClasses = false;
 145
 146 /* static */
 147 bool wxGLModule::RegisterClasses()
 148 {
 149     if ( ms_registeredGLClasses )
 150         return true;
 151
 152     // We have to register a special window class because we need the CS_OWNDC
 153     // style for GLCanvas: some OpenGL drivers are buggy and don't work with
 154     // windows without this style
 155     WNDCLASS wndclass;
 156
 157     // the fields which are common to all classes
 158     wndclass.lpfnWndProc   = (WNDPROC)wxWndProc;
 159     wndclass.cbClsExtra    = 0;
 160     wndclass.cbWndExtra    = sizeof( DWORD ); // VZ: what is this DWORD used for?
 161     wndclass.hInstance     = wxhInstance;
 162     wndclass.hIcon         = (HICON) NULL;
 163     wndclass.hCursor       = ::LoadCursor((HINSTANCE)NULL, IDC_ARROW);
 164     wndclass.lpszMenuName  = NULL;
 165
 166     // Register the GLCanvas class name
 167     wndclass.hbrBackground = (HBRUSH)NULL;
 168     wndclass.lpszClassName = wxGLCanvasClassName;
 169     wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_OWNDC;
 170
 171     if ( !::RegisterClass(&wndclass) )
 172     {
 173         wxLogLastError(wxT("RegisterClass(wxGLCanvasClass)"));
 174         return false;
 175     }
 176
 177     // Register the GLCanvas class name for windows which don't do full repaint
 178     // on resize
 179     wndclass.lpszClassName = wxGLCanvasClassNameNoRedraw;
 180     wndclass.style        &= ~(CS_HREDRAW | CS_VREDRAW);
 181
 182     if ( !::RegisterClass(&wndclass) )
 183     {
 184         wxLogLastError(wxT("RegisterClass(wxGLCanvasClassNameNoRedraw)"));
 185
 186         ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
 187
 188         return false;
 189     }
 190
 191     ms_registeredGLClasses = true;
 192
 193     return true;
 194 }
 195
 196 /* static */
 197 void wxGLModule::UnregisterClasses()
 198 {
 199     // we need to unregister the classes in case we're in a DLL which is
 200     // unloaded and then loaded again because if we don't, the registration is
 201     // going to fail in wxGLCanvas::Create() the next time we're loaded
 202     if ( ms_registeredGLClasses )
 203     {
 204         ::UnregisterClass(wxGLCanvasClassName, wxhInstance);
 205         ::UnregisterClass(wxGLCanvasClassNameNoRedraw, wxhInstance);
 206
 207         ms_registeredGLClasses = false;
 208     }
 209 }
 210
 211 // ----------------------------------------------------------------------------
 212 // wxGLContext
 213 // ----------------------------------------------------------------------------
 214
 215 IMPLEMENT_CLASS(wxGLContext, wxObject)
 216
 217 wxGLContext::wxGLContext(wxGLCanvas *win, const wxGLContext* other)
 218 {
 219     m_glContext = wglCreateContext(win->GetHDC());
 220     wxCHECK_RET( m_glContext, wxT("Couldn't create OpenGL context") );
 221
 222     if ( other )
 223     {
 224         if ( !wglShareLists(other->m_glContext, m_glContext) )
 225             wxLogLastError(_T("wglShareLists"));
 226     }
 227 }
 228
 229 wxGLContext::~wxGLContext()
 230 {
 231     // note that it's ok to delete the context even if it's the current one
 232     wglDeleteContext(m_glContext);
 233 }
 234
 235 bool wxGLContext::SetCurrent(const wxGLCanvas& win) const
 236 {
 237     if ( !wglMakeCurrent(win.GetHDC(), m_glContext) )
 238     {
 239         wxLogLastError(_T("wglMakeCurrent"));
 240         return false;
 241     }
 242     return true;
 243 }
 244
 245 // ============================================================================
 246 // wxGLCanvas
 247 // ============================================================================
 248
 249 IMPLEMENT_CLASS(wxGLCanvas, wxWindow)
 250
 251 BEGIN_EVENT_TABLE(wxGLCanvas, wxWindow)
 252     EVT_PALETTE_CHANGED(wxGLCanvas::OnPaletteChanged)
 253     EVT_QUERY_NEW_PALETTE(wxGLCanvas::OnQueryNewPalette)
 254 END_EVENT_TABLE()
 255
 256 // ----------------------------------------------------------------------------
 257 // wxGLCanvas construction
 258 // ----------------------------------------------------------------------------
 259
 260 static int ChoosePixelFormatARB(HDC hdc, const int *attribList);
 261
 262 void wxGLCanvas::Init()
 263 {
 264 #if WXWIN_COMPATIBILITY_2_8
 265     m_glContext = NULL;
 266 #endif
 267     m_hDC = NULL;
 268 }
 269
 270 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 271                        wxWindowID id,
 272                        const int *attribList,
 273                        const wxPoint& pos,
 274                        const wxSize& size,
 275                        long style,
 276                        const wxString& name,
 277                        const wxPalette& palette)
 278 {
 279     Init();
 280
 281     (void)Create(parent, id, pos, size, style, name, attribList, palette);
 282 }
 283
 284 wxGLCanvas::~wxGLCanvas()
 285 {
 286     ::ReleaseDC(GetHwnd(), m_hDC);
 287 }
 288
 289 // Replaces wxWindow::Create functionality, since we need to use a different
 290 // window class
 291 bool wxGLCanvas::CreateWindow(wxWindow *parent,
 292                               wxWindowID id,
 293                               const wxPoint& pos,
 294                               const wxSize& size,
 295                               long style,
 296                               const wxString& name)
 297 {
 298     wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
 299
 300     if ( !wxGLModule::RegisterClasses() )
 301     {
 302         wxLogError(_("Failed to register OpenGL window class."));
 303
 304         return false;
 305     }
 306
 307     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 308         return false;
 309
 310     parent->AddChild(this);
 311
 312     /*
 313        A general rule with OpenGL and Win32 is that any window that will have a
 314        HGLRC built for it must have two flags:  WS_CLIPCHILDREN & WS_CLIPSIBLINGS.
 315        You can find references about this within the knowledge base and most OpenGL
 316        books that contain the wgl function descriptions.
 317      */
 318     WXDWORD exStyle = 0;
 319     DWORD msflags = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN;
 320     msflags |= MSWGetStyle(style, &exStyle);
 321
 322     if ( !MSWCreate(wxGLCanvasClassName, NULL, pos, size, msflags, exStyle) )
 323         return false;
 324
 325     m_hDC = ::GetDC(GetHwnd());
 326     if ( !m_hDC )
 327         return false;
 328
 329     return true;
 330 }
 331
 332 bool wxGLCanvas::Create(wxWindow *parent,
 333                         wxWindowID id,
 334                         const wxPoint& pos,
 335                         const wxSize& size,
 336                         long style,
 337                         const wxString& name,
 338                         const int *attribList,
 339                         const wxPalette& palette)
 340 {
 341     // Create the window first: we will either use it as is or use it to query
 342     // for multisampling support and recreate it later with another pixel format
 343     if ( !CreateWindow(parent, id, pos, size, style, name) )
 344         return false;
 345
 346     PIXELFORMATDESCRIPTOR pfd;
 347     const int setupVal = DoSetup(pfd, attribList);
 348     if ( setupVal == 0 ) // PixelFormat error
 349         return false;
 350
 351     if ( setupVal == -1 ) // FSAA requested
 352     {
 353         // now that we have a valid OpenGL window, query it for FSAA support
 354         int pixelFormat;
 355         {
 356             wxGLContext ctx(this);
 357             ctx.SetCurrent(*this);
 358             pixelFormat = ::ChoosePixelFormatARB(m_hDC, attribList);
 359         }
 360
 361         if ( pixelFormat > 0 )
 362         {
 363             // from http://msdn.microsoft.com/en-us/library/ms537559(VS.85).aspx:
 364             //
 365             //      Setting the pixel format of a window more than once can
 366             //      lead to significant complications for the Window Manager
 367             //      and for multithread applications, so it is not allowed. An
 368             //      application can only set the pixel format of a window one
 369             //      time. Once a window's pixel format is set, it cannot be
 370             //      changed.
 371             //
 372             // so we need to delete the old window and create the new one
 373
 374             // destroy Window
 375             ::ReleaseDC(GetHwnd(), m_hDC);
 376             m_hDC = 0;
 377
 378             parent->RemoveChild(this);
 379             const HWND hwnd = GetHwnd();
 380             DissociateHandle(); // will do SetHWND(0);
 381             ::DestroyWindow(hwnd);
 382
 383             // now recreate with FSAA pixelFormat
 384             if ( !CreateWindow(parent, id, pos, size, style, name) )
 385                 return false;
 386
 387             if ( !::SetPixelFormat(m_hDC, pixelFormat, &pfd) )
 388             {
 389                 wxLogLastError(_T("SetPixelFormat"));
 390                 return false;
 391             }
 392         }
 393     }
 394
 395 #if wxUSE_PALETTE
 396     if ( !SetupPalette(palette) )
 397         return false;
 398 #else // !wxUSE_PALETTE
 399     wxUnusedVar(palette);
 400 #endif // wxUSE_PALETTE/!wxUSE_PALETTE
 401
 402     return true;
 403 }
 404
 405 // ----------------------------------------------------------------------------
 406 // operations
 407 // ----------------------------------------------------------------------------
 408
 409 bool wxGLCanvas::SwapBuffers()
 410 {
 411     if ( !::SwapBuffers(m_hDC) )
 412     {
 413         wxLogLastError(_T("SwapBuffers"));
 414         return false;
 415     }
 416
 417     return true;
 418 }
 419
 420
 421 // ----------------------------------------------------------------------------
 422 // multi sample support
 423 // ----------------------------------------------------------------------------
 424
 425 // this macro defines a variable of type "name_t" called "name" and initializes
 426 // it with the pointer to WGL function "name" (which may be NULL)
 427 #define wxDEFINE_WGL_FUNC(name) \
 428     name##_t name = (name##_t)wglGetProcAddress(#name)
 429
 430 /* static */
 431 bool wxGLCanvasBase::IsExtensionSupported(const char *extension)
 432 {
 433     static const char *s_extensionsList = (char *)wxUIntPtr(-1);
 434     if ( s_extensionsList == (char *)wxUIntPtr(-1) )
 435     {
 436         typedef const char * (WINAPI *wglGetExtensionsStringARB_t)(HDC hdc);
 437
 438         wxDEFINE_WGL_FUNC(wglGetExtensionsStringARB);
 439         if ( wglGetExtensionsStringARB )
 440         {
 441             s_extensionsList = wglGetExtensionsStringARB(wglGetCurrentDC());
 442         }
 443         else
 444         {
 445             typedef const char * (WINAPI * wglGetExtensionsStringEXT_t)();
 446
 447             wxDEFINE_WGL_FUNC(wglGetExtensionsStringEXT);
 448             if ( wglGetExtensionsStringEXT )
 449             {
 450                 s_extensionsList = wglGetExtensionsStringEXT();
 451             }
 452             else
 453             {
 454                 s_extensionsList = NULL;
 455             }
 456         }
 457     }
 458
 459     return s_extensionsList && IsExtensionInList(s_extensionsList, extension);
 460 }
 461
 462 // this is a wrapper around wglChoosePixelFormatARB(): returns the pixel format
 463 // index matching the given attributes on success or 0 on failure
 464 static int ChoosePixelFormatARB(HDC hdc, const int *attribList)
 465 {
 466     if ( !wxGLCanvas::IsExtensionSupported("WGL_ARB_multisample") )
 467         return 0;
 468
 469     typedef BOOL (WINAPI * wglChoosePixelFormatARB_t)
 470                  (HDC hdc,
 471                   const int *piAttribIList,
 472                   const FLOAT *pfAttribFList,
 473                   UINT nMaxFormats,
 474                   int *piFormats,
 475                   UINT *nNumFormats
 476                  );
 477
 478     wxDEFINE_WGL_FUNC(wglChoosePixelFormatARB);
 479     if ( !wglChoosePixelFormatARB )
 480         return 0; // should not occur if extension is supported
 481
 482     int iAttributes[128];
 483     int dst = 0; // index in iAttributes array
 484
 485     #define ADD_ATTR(attr, value) \
 486         iAttributes[dst++] = attr; iAttributes[dst++] = value
 487
 488     ADD_ATTR( WGL_DRAW_TO_WINDOW_ARB,    GL_TRUE );
 489     ADD_ATTR( WGL_SUPPORT_OPENGL_ARB,    GL_TRUE );
 490     ADD_ATTR( WGL_ACCELERATION_ARB,      WGL_FULL_ACCELERATION_ARB );
 491
 492     if ( !attribList )
 493     {
 494         ADD_ATTR( WGL_COLOR_BITS_ARB,          24 );
 495         ADD_ATTR( WGL_ALPHA_BITS_ARB,           8 );
 496         ADD_ATTR( WGL_DEPTH_BITS_ARB,          16 );
 497         ADD_ATTR( WGL_STENCIL_BITS_ARB,         0 );
 498         ADD_ATTR( WGL_DOUBLE_BUFFER_ARB,  GL_TRUE );
 499         ADD_ATTR( WGL_SAMPLE_BUFFERS_ARB, GL_TRUE );
 500         ADD_ATTR( WGL_SAMPLES_ARB,              4 );
 501     }
 502     else // have custom attributes
 503     {
 504         #define ADD_ATTR_VALUE(attr) ADD_ATTR(attr, attribList[src++])
 505
 506         int src = 0;
 507         while ( attribList[src] )
 508         {
 509             switch ( attribList[src++] )
 510             {
 511                 case WX_GL_RGBA:
 512                     ADD_ATTR( WGL_COLOR_BITS_ARB, 24 );
 513                     ADD_ATTR( WGL_ALPHA_BITS_ARB,  8 );
 514                     break;
 515
 516                 case WX_GL_BUFFER_SIZE:
 517                     ADD_ATTR_VALUE( WGL_COLOR_BITS_ARB);
 518                     break;
 519
 520                 case WX_GL_LEVEL:
 521                     if ( attribList[src] > 0 )
 522                     {
 523                         ADD_ATTR( WGL_NUMBER_OVERLAYS_ARB, 1 );
 524                     }
 525                     else if ( attribList[src] <0 )
 526                     {
 527                         ADD_ATTR( WGL_NUMBER_UNDERLAYS_ARB, 1 );
 528                     }
 529                     //else: ignore it
 530
 531                     src++; // skip the value in any case
 532                     break;
 533
 534                 case WX_GL_DOUBLEBUFFER:
 535                     ADD_ATTR( WGL_DOUBLE_BUFFER_ARB, GL_TRUE );
 536                     break;
 537
 538                 case WX_GL_STEREO:
 539                     ADD_ATTR( WGL_STEREO_ARB, GL_TRUE );
 540                     break;
 541
 542                 case WX_GL_AUX_BUFFERS:
 543                     ADD_ATTR_VALUE( WGL_AUX_BUFFERS_ARB );
 544                     break;
 545
 546                 case WX_GL_MIN_RED:
 547                     ADD_ATTR_VALUE( WGL_RED_BITS_ARB );
 548                     break;
 549
 550                 case WX_GL_MIN_GREEN:
 551                     ADD_ATTR_VALUE( WGL_GREEN_BITS_ARB );
 552                     break;
 553
 554                 case WX_GL_MIN_BLUE:
 555                     ADD_ATTR_VALUE( WGL_BLUE_BITS_ARB );
 556                     break;
 557
 558                 case WX_GL_MIN_ALPHA:
 559                     ADD_ATTR_VALUE( WGL_ALPHA_BITS_ARB );
 560                    break;
 561
 562                 case WX_GL_DEPTH_SIZE:
 563                     ADD_ATTR_VALUE( WGL_DEPTH_BITS_ARB );
 564                     break;
 565
 566                 case WX_GL_STENCIL_SIZE:
 567                     ADD_ATTR_VALUE( WGL_STENCIL_BITS_ARB );
 568                     break;
 569
 570                case WX_GL_MIN_ACCUM_RED:
 571                     ADD_ATTR_VALUE( WGL_ACCUM_RED_BITS_ARB );
 572                     break;
 573
 574                 case WX_GL_MIN_ACCUM_GREEN:
 575                     ADD_ATTR_VALUE( WGL_ACCUM_GREEN_BITS_ARB );
 576                     break;
 577
 578                 case WX_GL_MIN_ACCUM_BLUE:
 579                     ADD_ATTR_VALUE( WGL_ACCUM_BLUE_BITS_ARB );
 580                     break;
 581
 582                 case WX_GL_MIN_ACCUM_ALPHA:
 583                     ADD_ATTR_VALUE( WGL_ACCUM_ALPHA_BITS_ARB );
 584                     break;
 585
 586                 case WX_GL_SAMPLE_BUFFERS:
 587                     ADD_ATTR_VALUE( WGL_SAMPLE_BUFFERS_ARB );
 588                     break;
 589
 590                 case WX_GL_SAMPLES:
 591                     ADD_ATTR_VALUE( WGL_SAMPLES_ARB );
 592                     break;
 593             }
 594         }
 595
 596         #undef ADD_ATTR_VALUE
 597     }
 598
 599     #undef ADD_ATTR
 600
 601     iAttributes[dst++] = 0;
 602
 603     int pf;
 604     UINT numFormats = 0;
 605     if ( !wglChoosePixelFormatARB(hdc, iAttributes, NULL, 1, &pf, &numFormats) )
 606     {
 607         wxLogLastError(_T("wglChoosePixelFormatARB"));
 608         return 0;
 609     }
 610
 611     return pf;
 612 }
 613
 614 // ----------------------------------------------------------------------------
 615 // pixel format stuff
 616 // ----------------------------------------------------------------------------
 617
 618 // returns true if pfd was adjusted accordingly to attributes provided, false
 619 // if there is an error with attributes or -1 if the attributes indicate
 620 // features not supported by ChoosePixelFormat() at all (currently only multi
 621 // sampling)
 622 static int
 623 AdjustPFDForAttributes(PIXELFORMATDESCRIPTOR& pfd, const int *attribList)
 624 {
 625     if ( !attribList )
 626         return 1;
 627
 628     // remove default attributes
 629     pfd.dwFlags &= ~PFD_DOUBLEBUFFER;
 630     pfd.iPixelType = PFD_TYPE_COLORINDEX;
 631
 632     bool requestFSAA = false;
 633     for ( int arg = 0; attribList[arg]; )
 634     {
 635         switch ( attribList[arg++] )
 636         {
 637             case WX_GL_RGBA:
 638                 pfd.iPixelType = PFD_TYPE_RGBA;
 639                 break;
 640
 641             case WX_GL_BUFFER_SIZE:
 642                 pfd.cColorBits = attribList[arg++];
 643                 break;
 644
 645             case WX_GL_LEVEL:
 646                 // this member looks like it may be obsolete
 647                 if ( attribList[arg] > 0 )
 648                     pfd.iLayerType = PFD_OVERLAY_PLANE;
 649                 else if ( attribList[arg] < 0 )
 650                     pfd.iLayerType = (BYTE)PFD_UNDERLAY_PLANE;
 651                 else
 652                     pfd.iLayerType = PFD_MAIN_PLANE;
 653                 arg++;
 654                 break;
 655
 656             case WX_GL_DOUBLEBUFFER:
 657                 pfd.dwFlags |= PFD_DOUBLEBUFFER;
 658                 break;
 659
 660             case WX_GL_STEREO:
 661                 pfd.dwFlags |= PFD_STEREO;
 662                 break;
 663
 664             case WX_GL_AUX_BUFFERS:
 665                 pfd.cAuxBuffers = attribList[arg++];
 666                 break;
 667
 668             case WX_GL_MIN_RED:
 669                 pfd.cColorBits += (pfd.cRedBits = attribList[arg++]);
 670                 break;
 671
 672             case WX_GL_MIN_GREEN:
 673                 pfd.cColorBits += (pfd.cGreenBits = attribList[arg++]);
 674                 break;
 675
 676             case WX_GL_MIN_BLUE:
 677                 pfd.cColorBits += (pfd.cBlueBits = attribList[arg++]);
 678                 break;
 679
 680             case WX_GL_MIN_ALPHA:
 681                 // doesn't count in cColorBits
 682                 pfd.cAlphaBits = attribList[arg++];
 683                 break;
 684
 685             case WX_GL_DEPTH_SIZE:
 686                 pfd.cDepthBits = attribList[arg++];
 687                 break;
 688
 689             case WX_GL_STENCIL_SIZE:
 690                 pfd.cStencilBits = attribList[arg++];
 691                 break;
 692
 693             case WX_GL_MIN_ACCUM_RED:
 694                 pfd.cAccumBits += (pfd.cAccumRedBits = attribList[arg++]);
 695                 break;
 696
 697             case WX_GL_MIN_ACCUM_GREEN:
 698                 pfd.cAccumBits += (pfd.cAccumGreenBits = attribList[arg++]);
 699                 break;
 700
 701             case WX_GL_MIN_ACCUM_BLUE:
 702                 pfd.cAccumBits += (pfd.cAccumBlueBits = attribList[arg++]);
 703                 break;
 704
 705             case WX_GL_MIN_ACCUM_ALPHA:
 706                 pfd.cAccumBits += (pfd.cAccumAlphaBits = attribList[arg++]);
 707                 break;
 708
 709             case WX_GL_SAMPLE_BUFFERS:
 710             case WX_GL_SAMPLES:
 711                 // There is no support for multisample when using PIXELFORMATDESCRIPTOR
 712                 requestFSAA = true; // Remember that multi sample is requested.
 713                 arg++;              // will call ChoosePixelFormatARB() later
 714                 break;
 715         }
 716     }
 717
 718     return requestFSAA ? -1 : 1;
 719 }
 720
 721 /* static */
 722 int
 723 wxGLCanvas::ChooseMatchingPixelFormat(HDC hdc,
 724                                       const int *attribList,
 725                                       PIXELFORMATDESCRIPTOR *ppfd)
 726 {
 727     // default neutral pixel format
 728     PIXELFORMATDESCRIPTOR pfd =
 729     {
 730         sizeof(PIXELFORMATDESCRIPTOR),  // size
 731         1,                              // version
 732         PFD_SUPPORT_OPENGL |
 733         PFD_DRAW_TO_WINDOW |
 734         PFD_DOUBLEBUFFER,               // use double-buffering by default
 735         PFD_TYPE_RGBA,                  // default pixel type
 736         0,                              // preferred color depth (don't care)
 737         0, 0, 0, 0, 0, 0,               // color bits and shift bits (ignored)
 738         0, 0,                           // alpha bits and shift (ignored)
 739         0,                              // accumulation total bits
 740         0, 0, 0, 0,                     // accumulator RGBA bits (not used)
 741         16,                             // depth buffer
 742         0,                              // no stencil buffer
 743         0,                              // no auxiliary buffers
 744         PFD_MAIN_PLANE,                 // main layer
 745         0,                              // reserved
 746         0, 0, 0,                        // no layer, visible, damage masks
 747     };
 748
 749     if ( !ppfd )
 750         ppfd = &pfd;
 751     else
 752         *ppfd = pfd;
 753
 754     // adjust the PFD using the provided attributes and also check if we can
 755     // use PIXELFORMATDESCRIPTOR at all: if multisampling is requested, we
 756     // can't as it's not supported by ChoosePixelFormat()
 757     switch ( AdjustPFDForAttributes(*ppfd, attribList) )
 758     {
 759         case 1:
 760             return ::ChoosePixelFormat(hdc, ppfd);
 761
 762         default:
 763             wxFAIL_MSG( "unexpected AdjustPFDForAttributes() return value" );
 764             // fall through
 765
 766         case 0:
 767             // error in attributes
 768             return 0;
 769
 770         case -1:
 771             // requestFSAA == true, will continue as normal
 772             // in order to query later for a FSAA pixelformat
 773             return -1;
 774     }
 775 }
 776
 777 /* static */
 778 bool wxGLCanvasBase::IsDisplaySupported(const int *attribList)
 779 {
 780     // We need a device context to test the pixel format, so get one
 781     // for the root window.
 782     return wxGLCanvas::ChooseMatchingPixelFormat(ScreenHDC(), attribList) > 0;
 783 }
 784
 785 int wxGLCanvas::DoSetup(PIXELFORMATDESCRIPTOR &pfd, const int *attribList)
 786 {
 787     int pixelFormat = ChooseMatchingPixelFormat(m_hDC, attribList, &pfd);
 788
 789     const bool requestFSAA = pixelFormat == -1;
 790     if ( requestFSAA )
 791         pixelFormat = ::ChoosePixelFormat(m_hDC, &pfd);
 792
 793     if ( !pixelFormat )
 794     {
 795         wxLogLastError(_T("ChoosePixelFormat"));
 796         return 0;
 797     }
 798
 799     if ( !::SetPixelFormat(m_hDC, pixelFormat, &pfd) )
 800     {
 801         wxLogLastError(_T("SetPixelFormat"));
 802         return 0;
 803     }
 804
 805     return requestFSAA ? -1 : 1;
 806 }
 807
 808 // ----------------------------------------------------------------------------
 809 // palette stuff
 810 // ----------------------------------------------------------------------------
 811
 812 #if wxUSE_PALETTE
 813
 814 bool wxGLCanvas::SetupPalette(const wxPalette& palette)
 815 {
 816     const int pixelFormat = ::GetPixelFormat(m_hDC);
 817     if ( !pixelFormat )
 818     {
 819         wxLogLastError(_T("GetPixelFormat"));
 820         return false;
 821     }
 822
 823     PIXELFORMATDESCRIPTOR pfd;
 824     if ( !::DescribePixelFormat(m_hDC, pixelFormat, sizeof(pfd), &pfd) )
 825     {
 826         wxLogLastError(_T("DescribePixelFormat"));
 827         return false;
 828     }
 829
 830     if ( !(pfd.dwFlags & PFD_NEED_PALETTE) )
 831         return true;
 832
 833     m_palette = palette;
 834
 835     if ( !m_palette.Ok() )
 836     {
 837         m_palette = CreateDefaultPalette();
 838         if ( !m_palette.Ok() )
 839             return false;
 840     }
 841
 842     if ( !::SelectPalette(m_hDC, GetHpaletteOf(m_palette), FALSE) )
 843     {
 844         wxLogLastError(_T("SelectPalette"));
 845         return false;
 846     }
 847
 848     if ( ::RealizePalette(m_hDC) == GDI_ERROR )
 849     {
 850         wxLogLastError(_T("RealizePalette"));
 851         return false;
 852     }
 853
 854     return true;
 855 }
 856
 857 wxPalette wxGLCanvas::CreateDefaultPalette()
 858 {
 859     PIXELFORMATDESCRIPTOR pfd;
 860     int paletteSize;
 861     int pixelFormat = GetPixelFormat(m_hDC);
 862
 863     DescribePixelFormat(m_hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
 864
 865     paletteSize = 1 << pfd.cColorBits;
 866
 867     LOGPALETTE* pPal =
 868      (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
 869     pPal->palVersion = 0x300;
 870     pPal->palNumEntries = (WORD)paletteSize;
 871
 872     /* build a simple RGB color palette */
 873     int redMask = (1 << pfd.cRedBits) - 1;
 874     int greenMask = (1 << pfd.cGreenBits) - 1;
 875     int blueMask = (1 << pfd.cBlueBits) - 1;
 876
 877     for (int i=0; i<paletteSize; ++i)
 878     {
 879         pPal->palPalEntry[i].peRed =
 880             (BYTE)((((i >> pfd.cRedShift) & redMask) * 255) / redMask);
 881         pPal->palPalEntry[i].peGreen =
 882             (BYTE)((((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask);
 883         pPal->palPalEntry[i].peBlue =
 884             (BYTE)((((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask);
 885         pPal->palPalEntry[i].peFlags = 0;
 886     }
 887
 888     HPALETTE hPalette = CreatePalette(pPal);
 889     free(pPal);
 890
 891     wxPalette palette;
 892     palette.SetHPALETTE((WXHPALETTE) hPalette);
 893
 894     return palette;
 895 }
 896
 897 void wxGLCanvas::OnQueryNewPalette(wxQueryNewPaletteEvent& event)
 898 {
 899   /* realize palette if this is the current window */
 900   if ( GetPalette()->Ok() ) {
 901     ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
 902     ::SelectPalette(GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
 903     ::RealizePalette(GetHDC());
 904     Refresh();
 905     event.SetPaletteRealized(true);
 906   }
 907   else
 908     event.SetPaletteRealized(false);
 909 }
 910
 911 void wxGLCanvas::OnPaletteChanged(wxPaletteChangedEvent& event)
 912 {
 913   /* realize palette if this is *not* the current window */
 914   if ( GetPalette() &&
 915        GetPalette()->Ok() && (this != event.GetChangedWindow()) )
 916   {
 917     ::UnrealizeObject((HPALETTE) GetPalette()->GetHPALETTE());
 918     ::SelectPalette(GetHDC(), (HPALETTE) GetPalette()->GetHPALETTE(), FALSE);
 919     ::RealizePalette(GetHDC());
 920     Refresh();
 921   }
 922 }
 923
 924 #endif // wxUSE_PALETTE
 925
 926 // ----------------------------------------------------------------------------
 927 // deprecated wxGLCanvas methods using implicit wxGLContext
 928 // ----------------------------------------------------------------------------
 929
 930 // deprecated constructors creating an implicit m_glContext
 931 #if WXWIN_COMPATIBILITY_2_8
 932
 933 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 934                        wxWindowID id,
 935                        const wxPoint& pos,
 936                        const wxSize& size,
 937                        long style,
 938                        const wxString& name,
 939                        const int *attribList,
 940                        const wxPalette& palette)
 941 {
 942     Init();
 943
 944     if ( Create(parent, id, pos, size, style, name, attribList, palette) )
 945         m_glContext = new wxGLContext(this);
 946 }
 947
 948 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 949                        const wxGLContext *shared,
 950                        wxWindowID id,
 951                        const wxPoint& pos,
 952                        const wxSize& size,
 953                        long style,
 954                        const wxString& name,
 955                        const int *attribList,
 956                        const wxPalette& palette)
 957 {
 958     Init();
 959
 960     if ( Create(parent, id, pos, size, style, name, attribList, palette) )
 961         m_glContext = new wxGLContext(this, shared);
 962 }
 963
 964 wxGLCanvas::wxGLCanvas(wxWindow *parent,
 965                        const wxGLCanvas *shared,
 966                        wxWindowID id,
 967                        const wxPoint& pos,
 968                        const wxSize& size,
 969                        long style,
 970                        const wxString& name,
 971                        const int *attribList,
 972                        const wxPalette& palette)
 973 {
 974     Init();
 975
 976     if ( Create(parent, id, pos, size, style, name, attribList, palette) )
 977         m_glContext = new wxGLContext(this, shared ? shared->m_glContext : NULL);
 978 }
 979
 980 #endif // WXWIN_COMPATIBILITY_2_8
 981
 982
 983 // ----------------------------------------------------------------------------
 984 // wxGLApp
 985 // ----------------------------------------------------------------------------
 986
 987 bool wxGLApp::InitGLVisual(const int *attribList)
 988 {
 989     if ( !wxGLCanvas::ChooseMatchingPixelFormat(ScreenHDC(), attribList) )
 990     {
 991         wxLogError(_("Failed to initialize OpenGL"));
 992         return false;
 993     }
 994
 995     return true;
 996 }
 997
 998 #endif // wxUSE_GLCANVAS