1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtOpenGL module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <qgl.h>

    44 #include <qlist.h>

    45 #include <qmap.h>

    46 #include <qpixmap.h>

    47 #include <qevent.h>

    48 #include <private/qgl_p.h>

    49 #include <qcolormap.h>

    50 #include <qvarlengtharray.h>

    51 #include <qdebug.h>

    52 #include <qcolor.h>

    53 

    54 #include <qt_windows.h>

    55 

    56 typedef bool (APIENTRY *PFNWGLGETPIXELFORMATATTRIBIVARB)(HDC hdc,

    57                                                          int iPixelFormat,

    58                                                          int iLayerPlane,

    59                                                          uint nAttributes,

    60                                                          const int *piAttributes,

    61                                                          int *piValues);

    62 typedef bool (APIENTRY *PFNWGLCHOOSEPIXELFORMATARB)(HDC hdc,

    63                                                     const int *piAttribList,

    64                                                     const float *pfAttribFList,

    65                                                     uint nMaxFormats,

    66                                                     int *piFormats,

    67                                                     UINT *nNumFormats);

    68 #ifndef WGL_ARB_multisample

    69 #define WGL_SAMPLE_BUFFERS_ARB               0x2041

    70 #define WGL_SAMPLES_ARB                      0x2042

    71 #endif

    72 

    73 #ifndef WGL_ARB_pixel_format

    74 #define WGL_NUMBER_PIXEL_FORMATS_ARB   0x2000

    75 #define WGL_DRAW_TO_WINDOW_ARB         0x2001

    76 #define WGL_DRAW_TO_BITMAP_ARB         0x2002

    77 #define WGL_ACCELERATION_ARB           0x2003

    78 #define WGL_NEED_PALETTE_ARB           0x2004

    79 #define WGL_NEED_SYSTEM_PALETTE_ARB    0x2005

    80 #define WGL_SWAP_LAYER_BUFFERS_ARB     0x2006

    81 #define WGL_SWAP_METHOD_ARB            0x2007

    82 #define WGL_NUMBER_OVERLAYS_ARB        0x2008

    83 #define WGL_NUMBER_UNDERLAYS_ARB       0x2009

    84 #define WGL_TRANSPARENT_ARB            0x200A

    85 #define WGL_TRANSPARENT_RED_VALUE_ARB  0x2037

    86 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038

    87 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039

    88 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A

    89 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B

    90 #define WGL_SHARE_DEPTH_ARB            0x200C

    91 #define WGL_SHARE_STENCIL_ARB          0x200D

    92 #define WGL_SHARE_ACCUM_ARB            0x200E

    93 #define WGL_SUPPORT_GDI_ARB            0x200F

    94 #define WGL_SUPPORT_OPENGL_ARB         0x2010

    95 #define WGL_DOUBLE_BUFFER_ARB          0x2011

    96 #define WGL_STEREO_ARB                 0x2012

    97 #define WGL_PIXEL_TYPE_ARB             0x2013

    98 #define WGL_COLOR_BITS_ARB             0x2014

    99 #define WGL_RED_BITS_ARB               0x2015

   100 #define WGL_RED_SHIFT_ARB              0x2016

   101 #define WGL_GREEN_BITS_ARB             0x2017

   102 #define WGL_GREEN_SHIFT_ARB            0x2018

   103 #define WGL_BLUE_BITS_ARB              0x2019

   104 #define WGL_BLUE_SHIFT_ARB             0x201A

   105 #define WGL_ALPHA_BITS_ARB             0x201B

   106 #define WGL_ALPHA_SHIFT_ARB            0x201C

   107 #define WGL_ACCUM_BITS_ARB             0x201D

   108 #define WGL_ACCUM_RED_BITS_ARB         0x201E

   109 #define WGL_ACCUM_GREEN_BITS_ARB       0x201F

   110 #define WGL_ACCUM_BLUE_BITS_ARB        0x2020

   111 #define WGL_ACCUM_ALPHA_BITS_ARB       0x2021

   112 #define WGL_DEPTH_BITS_ARB             0x2022

   113 #define WGL_STENCIL_BITS_ARB           0x2023

   114 #define WGL_AUX_BUFFERS_ARB            0x2024

   115 #define WGL_NO_ACCELERATION_ARB        0x2025

   116 #define WGL_GENERIC_ACCELERATION_ARB   0x2026

   117 #define WGL_FULL_ACCELERATION_ARB      0x2027

   118 #define WGL_SWAP_EXCHANGE_ARB          0x2028

   119 #define WGL_SWAP_COPY_ARB              0x2029

   120 #define WGL_SWAP_UNDEFINED_ARB         0x202A

   121 #define WGL_TYPE_RGBA_ARB              0x202B

   122 #define WGL_TYPE_COLORINDEX_ARB        0x202C

   123 #endif

   124 

   125 QT_BEGIN_NAMESPACE

   126 

   127 class QGLCmapPrivate

   128 {

   129 public:

   130     QGLCmapPrivate() : count(1) { }

   131     void ref()                { ++count; }

   132     bool deref()        { return !--count; }

   133     uint count;

   134 

   135     enum AllocState{ UnAllocated = 0, Allocated = 0x01, Reserved = 0x02 };

   136 

   137     int maxSize;

   138     QVector<uint> colorArray;

   139     QVector<quint8> allocArray;

   140     QVector<quint8> contextArray;

   141     QMap<uint,int> colorMap;

   142 };

   143 

   144 /*****************************************************************************

   145   QColorMap class - temporarily here, until it is ready for prime time

   146  *****************************************************************************/

   147 

   148 /****************************************************************************

   149 **

   150 ** Definition of QColorMap class

   151 **

   152 ****************************************************************************/

   153 

   154 class QGLCmapPrivate;

   155 

   156 class /*Q_EXPORT*/ QGLCmap

   157 {

   158 public:

   159     enum Flags { Reserved = 0x01 };

   160 

   161     QGLCmap(int maxSize = 256);

   162     QGLCmap(const QGLCmap& map);

   163     ~QGLCmap();

   164 

   165     QGLCmap& operator=(const QGLCmap& map);

   166 

   167     // isEmpty and/or isNull ?

   168     int size() const;

   169     int maxSize() const;

   170 

   171     void resize(int newSize);

   172 

   173     int find(QRgb color) const;

   174     int findNearest(QRgb color) const;

   175     int allocate(QRgb color, uint flags = 0, quint8 context = 0);

   176 

   177     void setEntry(int idx, QRgb color, uint flags = 0, quint8 context = 0);

   178 

   179     const QRgb* colors() const;

   180 

   181 private:

   182     void detach();

   183     QGLCmapPrivate* d;

   184 };

   185 

   186 

   187 QGLCmap::QGLCmap(int maxSize) // add a bool prealloc?

   188 {

   189     d = new QGLCmapPrivate;

   190     d->maxSize = maxSize;

   191 }

   192 

   193 

   194 QGLCmap::QGLCmap(const QGLCmap& map)

   195 {

   196     d = map.d;

   197     d->ref();

   198 }

   199 

   200 

   201 QGLCmap::~QGLCmap()

   202 {

   203     if (d && d->deref())

   204         delete d;

   205     d = 0;

   206 }

   207 

   208 

   209 QGLCmap& QGLCmap::operator=(const QGLCmap& map)

   210 {

   211     map.d->ref();

   212     if (d->deref())

   213         delete d;

   214     d = map.d;

   215     return *this;

   216 }

   217 

   218 

   219 int QGLCmap::size() const

   220 {

   221     return d->colorArray.size();

   222 }

   223 

   224 

   225 int QGLCmap::maxSize() const

   226 {

   227     return d->maxSize;

   228 }

   229 

   230 

   231 void QGLCmap::detach()

   232 {

   233     if (d->count != 1) {

   234         d->deref();

   235         QGLCmapPrivate* newd = new QGLCmapPrivate;

   236         newd->maxSize = d->maxSize;

   237         newd->colorArray = d->colorArray;

   238         newd->allocArray = d->allocArray;

   239         newd->contextArray = d->contextArray;

   240         newd->colorArray.detach();

   241         newd->allocArray.detach();

   242         newd->contextArray.detach();

   243         newd->colorMap = d->colorMap;

   244         d = newd;

   245     }

   246 }

   247 

   248 

   249 void QGLCmap::resize(int newSize)

   250 {

   251     if (newSize < 0 || newSize > d->maxSize) {

   252         qWarning("QGLCmap::resize(): size out of range");

   253         return;

   254     }

   255     int oldSize = size();

   256     detach();

   257     //if shrinking; remove the lost elems from colorMap

   258     d->colorArray.resize(newSize);

   259     d->allocArray.resize(newSize);

   260     d->contextArray.resize(newSize);

   261     if (newSize > oldSize) {

   262         memset(d->allocArray.data() + oldSize, 0, newSize - oldSize);

   263         memset(d->contextArray.data() + oldSize, 0, newSize - oldSize);

   264     }

   265 }

   266 

   267 

   268 int QGLCmap::find(QRgb color) const

   269 {

   270     QMap<uint,int>::ConstIterator it = d->colorMap.find(color);

   271     if (it != d->colorMap.end())

   272         return *it;

   273     return -1;

   274 }

   275 

   276 

   277 int QGLCmap::findNearest(QRgb color) const

   278 {

   279     int idx = find(color);

   280     if (idx >= 0)

   281         return idx;

   282     int mapSize = size();

   283     int mindist = 200000;

   284     int r = qRed(color);

   285     int g = qGreen(color);

   286     int b = qBlue(color);

   287     int rx, gx, bx, dist;

   288     for (int i=0; i < mapSize; i++) {

   289         if (!(d->allocArray[i] & QGLCmapPrivate::Allocated))

   290             continue;

   291         QRgb ci = d->colorArray[i];

   292         rx = r - qRed(ci);

   293         gx = g - qGreen(ci);

   294         bx = b - qBlue(ci);

   295         dist = rx*rx + gx*gx + bx*bx;                // calculate distance

   296         if (dist < mindist) {                        // minimal?

   297             mindist = dist;

   298             idx = i;

   299         }

   300     }

   301     return idx;

   302 }

   303 

   304 

   305 

   306 

   307 // Does not always allocate; returns existing c idx if found

   308 

   309 int QGLCmap::allocate(QRgb color, uint flags, quint8 context)

   310 {

   311     int idx = find(color);

   312     if (idx >= 0)

   313         return idx;

   314 

   315     int mapSize = d->colorArray.size();

   316     int newIdx = d->allocArray.indexOf(QGLCmapPrivate::UnAllocated);

   317 

   318     if (newIdx < 0) {                        // Must allocate more room

   319         if (mapSize < d->maxSize) {

   320             newIdx = mapSize;

   321             mapSize++;

   322             resize(mapSize);

   323         }

   324         else {

   325             //# add a bool param that says what to do in case no more room -

   326             // fail (-1) or return nearest?

   327             return -1;

   328         }

   329     }

   330 

   331     d->colorArray[newIdx] = color;

   332     if (flags & QGLCmap::Reserved) {

   333         d->allocArray[newIdx] = QGLCmapPrivate::Reserved;

   334     }

   335     else {

   336         d->allocArray[newIdx] = QGLCmapPrivate::Allocated;

   337         d->colorMap.insert(color, newIdx);

   338     }

   339     d->contextArray[newIdx] = context;

   340     return newIdx;

   341 }

   342 

   343 

   344 void QGLCmap::setEntry(int idx, QRgb color, uint flags, quint8 context)

   345 {

   346     if (idx < 0 || idx >= d->maxSize) {

   347         qWarning("QGLCmap::set(): Index out of range");

   348         return;

   349     }

   350     detach();

   351     int mapSize = size();

   352     if (idx >= mapSize) {

   353         mapSize = idx + 1;

   354         resize(mapSize);

   355     }

   356     d->colorArray[idx] = color;

   357     if (flags & QGLCmap::Reserved) {

   358         d->allocArray[idx] = QGLCmapPrivate::Reserved;

   359     }

   360     else {

   361         d->allocArray[idx] = QGLCmapPrivate::Allocated;

   362         d->colorMap.insert(color, idx);

   363     }

   364     d->contextArray[idx] = context;

   365 }

   366 

   367 

   368 const QRgb* QGLCmap::colors() const

   369 {

   370     return d->colorArray.data();

   371 }

   372 

   373 

   374 

   375 /*****************************************************************************

   376   QGLFormat Win32/WGL-specific code

   377  *****************************************************************************/

   378 

   379 

   380 void qwglError(const char* method, const char* func)

   381 {

   382 #ifndef QT_NO_DEBUG

   383     char* lpMsgBuf;

   384     FormatMessageA(

   385                   FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

   386                   0, GetLastError(),

   387                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

   388                   (char*) &lpMsgBuf, 0, 0);

   389     qWarning("%s : %s failed: %s", method, func, lpMsgBuf);

   390     LocalFree(lpMsgBuf);

   391 #else

   392     Q_UNUSED(method);

   393     Q_UNUSED(func);

   394 #endif

   395 }

   396 

   397 

   398 

   399 bool QGLFormat::hasOpenGL()

   400 {

   401     return true;

   402 }

   403 

   404 static bool opengl32dll = false;

   405 

   406 bool QGLFormat::hasOpenGLOverlays()

   407 {

   408     // workaround for matrox driver:

   409     // make a cheap call to opengl to force loading of DLL

   410     if (!opengl32dll) {

   411         GLint params;

   412         glGetIntegerv(GL_DEPTH_BITS, &params);

   413         opengl32dll = true;

   414     }

   415 

   416     static bool checkDone = false;

   417     static bool hasOl = false;

   418 

   419     if (!checkDone) {

   420         checkDone = true;

   421         HDC display_dc = GetDC(0);

   422         int pfiMax = DescribePixelFormat(display_dc, 0, 0, NULL);

   423         PIXELFORMATDESCRIPTOR pfd;

   424         for (int pfi = 1; pfi <= pfiMax; pfi++) {

   425             DescribePixelFormat(display_dc, pfi, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

   426             if ((pfd.bReserved & 0x0f) && (pfd.dwFlags & PFD_SUPPORT_OPENGL)) {

   427                 // This format has overlays/underlays

   428                 LAYERPLANEDESCRIPTOR lpd;

   429                 wglDescribeLayerPlane(display_dc, pfi, 1,

   430                                        sizeof(LAYERPLANEDESCRIPTOR), &lpd);

   431                 if (lpd.dwFlags & LPD_SUPPORT_OPENGL) {

   432                     hasOl = true;

   433                     break;

   434                 }

   435             }

   436         }

   437         ReleaseDC(0, display_dc);

   438     }

   439     return hasOl;

   440 }

   441 

   442 

   443 /*****************************************************************************

   444   QGLContext Win32/WGL-specific code

   445  *****************************************************************************/

   446 

   447 static uchar qgl_rgb_palette_comp(int idx, uint nbits, uint shift)

   448 {

   449     const uchar map_3_to_8[8] = {

   450         0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377

   451     };

   452     const uchar map_2_to_8[4] = {

   453         0, 0x55, 0xaa, 0xff

   454     };

   455     const uchar map_1_to_8[2] = {

   456         0, 255

   457     };

   458 

   459     uchar val = (uchar) (idx >> shift);

   460     uchar res = 0;

   461     switch (nbits) {

   462     case 1:

   463         val &= 0x1;

   464         res =  map_1_to_8[val];

   465         break;

   466     case 2:

   467         val &= 0x3;

   468         res = map_2_to_8[val];

   469         break;

   470     case 3:

   471         val &= 0x7;

   472         res = map_3_to_8[val];

   473         break;

   474     default:

   475         res = 0;

   476     }

   477     return res;

   478 }

   479 

   480 

   481 static QRgb* qgl_create_rgb_palette(const PIXELFORMATDESCRIPTOR* pfd)

   482 {

   483     if ((pfd->iPixelType != PFD_TYPE_RGBA) ||

   484          !(pfd->dwFlags & PFD_NEED_PALETTE) ||

   485          (pfd->cColorBits != 8))

   486         return 0;

   487     int numEntries = 1 << pfd->cColorBits;

   488     QRgb* pal = new QRgb[numEntries];

   489     for (int i = 0; i < numEntries; i++) {

   490         int r = qgl_rgb_palette_comp(i, pfd->cRedBits, pfd->cRedShift);

   491         int g = qgl_rgb_palette_comp(i, pfd->cGreenBits, pfd->cGreenShift);

   492         int b = qgl_rgb_palette_comp(i, pfd->cBlueBits, pfd->cBlueShift);

   493         pal[i] = qRgb(r, g, b);

   494     }

   495 

   496     const int syscol_indices[12] = {

   497         3, 24, 27, 64, 67, 88, 173, 181, 236, 247, 164, 91

   498     };

   499 

   500     const uint syscols[20] = {

   501         0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080,

   502         0x008080, 0xc0c0c0, 0xc0dcc0, 0xa6caf0, 0xfffbf0, 0xa0a0a4,

   503         0x808080, 0xff0000, 0x00ff00, 0xffff00, 0x0000ff, 0xff00ff,

   504         0x00ffff, 0xffffff

   505     };        // colors #1 - #12 are not present in pal; gets added below

   506 

   507     if ((pfd->cColorBits == 8)                                &&

   508          (pfd->cRedBits   == 3) && (pfd->cRedShift   == 0)        &&

   509          (pfd->cGreenBits == 3) && (pfd->cGreenShift == 3)        &&

   510          (pfd->cBlueBits  == 2) && (pfd->cBlueShift  == 6)) {

   511         for (int j = 0 ; j < 12 ; j++)

   512             pal[syscol_indices[j]] = QRgb(syscols[j+1]);

   513     }

   514 

   515     return pal;

   516 }

   517 

   518 static QGLFormat pfdToQGLFormat(const PIXELFORMATDESCRIPTOR* pfd)

   519 {

   520     QGLFormat fmt;

   521     fmt.setDoubleBuffer(pfd->dwFlags & PFD_DOUBLEBUFFER);

   522     fmt.setDepth(pfd->cDepthBits);

   523     if (fmt.depth())

   524         fmt.setDepthBufferSize(pfd->cDepthBits);

   525     fmt.setRgba(pfd->iPixelType == PFD_TYPE_RGBA);

   526     fmt.setRedBufferSize(pfd->cRedBits);

   527     fmt.setGreenBufferSize(pfd->cGreenBits);

   528     fmt.setBlueBufferSize(pfd->cBlueBits);

   529     fmt.setAlpha(pfd->cAlphaBits);

   530     if (fmt.alpha())

   531         fmt.setAlphaBufferSize(pfd->cAlphaBits);

   532     fmt.setAccum(pfd->cAccumBits);

   533     if (fmt.accum())

   534         fmt.setAccumBufferSize(pfd->cAccumRedBits);

   535     fmt.setStencil(pfd->cStencilBits);

   536     if (fmt.stencil())

   537         fmt.setStencilBufferSize(pfd->cStencilBits);

   538     fmt.setStereo(pfd->dwFlags & PFD_STEREO);

   539     fmt.setDirectRendering((pfd->dwFlags & PFD_GENERIC_ACCELERATED) ||

   540                             !(pfd->dwFlags & PFD_GENERIC_FORMAT));

   541     fmt.setOverlay((pfd->bReserved & 0x0f) != 0);

   542     return fmt;

   543 }

   544 

   545 /*

   546    NB! requires a current GL context to work

   547 */

   548 QGLFormat pfiToQGLFormat(HDC hdc, int pfi)

   549 {

   550     QGLFormat fmt;

   551     QVarLengthArray<int> iAttributes(40);

   552     QVarLengthArray<int> iValues(40);

   553     int i = 0;

   554     bool has_sample_buffers = QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers;

   555 

   556     iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB; // 0

   557     iAttributes[i++] = WGL_DEPTH_BITS_ARB; // 1

   558     iAttributes[i++] = WGL_PIXEL_TYPE_ARB; // 2

   559     iAttributes[i++] = WGL_RED_BITS_ARB; // 3

   560     iAttributes[i++] = WGL_GREEN_BITS_ARB; // 4

   561     iAttributes[i++] = WGL_BLUE_BITS_ARB; // 5

   562     iAttributes[i++] = WGL_ALPHA_BITS_ARB; // 6

   563     iAttributes[i++] = WGL_ACCUM_BITS_ARB; // 7

   564     iAttributes[i++] = WGL_STENCIL_BITS_ARB; // 8

   565     iAttributes[i++] = WGL_STEREO_ARB; // 9

   566     iAttributes[i++] = WGL_ACCELERATION_ARB; // 10

   567     iAttributes[i++] = WGL_NUMBER_OVERLAYS_ARB; // 11

   568     if (has_sample_buffers) {

   569         iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB; // 12

   570         iAttributes[i++] = WGL_SAMPLES_ARB; // 13

   571     }

   572     PFNWGLGETPIXELFORMATATTRIBIVARB wglGetPixelFormatAttribivARB =

   573         (PFNWGLGETPIXELFORMATATTRIBIVARB) wglGetProcAddress("wglGetPixelFormatAttribivARB");

   574 

   575     if (wglGetPixelFormatAttribivARB

   576         && wglGetPixelFormatAttribivARB(hdc, pfi, 0, i,

   577                                         iAttributes.constData(),

   578                                         iValues.data()))

   579     {

   580         fmt.setDoubleBuffer(iValues[0]);

   581         fmt.setDepth(iValues[1]);

   582         if (fmt.depth())

   583             fmt.setDepthBufferSize(iValues[1]);

   584         fmt.setRgba(iValues[2] == WGL_TYPE_RGBA_ARB);

   585         fmt.setRedBufferSize(iValues[3]);

   586         fmt.setGreenBufferSize(iValues[4]);

   587         fmt.setBlueBufferSize(iValues[5]);

   588         fmt.setAlpha(iValues[6]);

   589         if (fmt.alpha())

   590             fmt.setAlphaBufferSize(iValues[6]);

   591         fmt.setAccum(iValues[7]);

   592         if (fmt.accum())

   593             fmt.setAccumBufferSize(iValues[7]);

   594         fmt.setStencil(iValues[8]);

   595         if (fmt.stencil())

   596             fmt.setStencilBufferSize(iValues[8]);

   597         fmt.setStereo(iValues[9]);

   598         if (iValues[10] == WGL_FULL_ACCELERATION_ARB)

   599             fmt.setDirectRendering(true);

   600         else

   601             fmt.setDirectRendering(false);

   602         fmt.setOverlay(iValues[11]);

   603         if (has_sample_buffers) {

   604             fmt.setSampleBuffers(iValues[12]);

   605             if (fmt.sampleBuffers())

   606                 fmt.setSamples(iValues[13]);

   607         }

   608     }

   609 #if 0

   610     qDebug() << "values for pfi:" << pfi;

   611     qDebug() << "doublebuffer  0:" << fmt.doubleBuffer();

   612     qDebug() << "depthbuffer   1:" << fmt.depthBufferSize();

   613     qDebug() << "rgba          2:" << fmt.rgba();

   614     qDebug() << "red size      3:" << fmt.redBufferSize();

   615     qDebug() << "green size    4:" << fmt.greenBufferSize();

   616     qDebug() << "blue size     5:" << fmt.blueBufferSize();

   617     qDebug() << "alpha size    6:" << fmt.alphaBufferSize();

   618     qDebug() << "accum size    7:" << fmt.accumBufferSize();

   619     qDebug() << "stencil size  8:" << fmt.stencilBufferSize();

   620     qDebug() << "stereo        9:" << fmt.stereo();

   621     qDebug() << "direct       10:" << fmt.directRendering();

   622     qDebug() << "has overlays 11:" << fmt.hasOverlay();

   623     qDebug() << "sample buff  12:" << fmt.sampleBuffers();

   624     qDebug() << "num samples  13:" << fmt.samples();

   625 #endif

   626     return fmt;

   627 }

   628 

   629 

   630 /*

   631     QGLTemporaryContext implementation

   632 */

   633 

   634 Q_GUI_EXPORT const QString qt_getRegisteredWndClass();

   635 

   636 class QGLTemporaryContextPrivate

   637 {

   638 public:

   639     HDC dmy_pdc;

   640     HGLRC dmy_rc;

   641     HDC old_dc;

   642     HGLRC old_context;

   643     WId dmy_id;

   644 };

   645 

   646 QGLTemporaryContext::QGLTemporaryContext(bool directRendering, QWidget *parent)

   647     : d(new QGLTemporaryContextPrivate)

   648 {

   649     QString windowClassName = qt_getRegisteredWndClass();

   650     if (parent && !parent->internalWinId())

   651         parent = parent->nativeParentWidget();

   652 

   653     d->dmy_id = CreateWindow((const wchar_t *)windowClassName.utf16(),

   654                              0, 0, 0, 0, 1, 1,

   655                              parent ? parent->winId() : 0, 0, qWinAppInst(), 0);

   656 

   657     d->dmy_pdc = GetDC(d->dmy_id);

   658     PIXELFORMATDESCRIPTOR dmy_pfd;

   659     memset(&dmy_pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));

   660     dmy_pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);

   661     dmy_pfd.nVersion = 1;

   662     dmy_pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;

   663     dmy_pfd.iPixelType = PFD_TYPE_RGBA;

   664     if (!directRendering)

   665         dmy_pfd.dwFlags |= PFD_GENERIC_FORMAT;

   666 

   667     int dmy_pf = ChoosePixelFormat(d->dmy_pdc, &dmy_pfd);

   668     SetPixelFormat(d->dmy_pdc, dmy_pf, &dmy_pfd);

   669     d->dmy_rc = wglCreateContext(d->dmy_pdc);

   670     d->old_dc = wglGetCurrentDC();

   671     d->old_context = wglGetCurrentContext();

   672     wglMakeCurrent(d->dmy_pdc, d->dmy_rc);

   673 }

   674 

   675 QGLTemporaryContext::~QGLTemporaryContext()

   676 {

   677     wglMakeCurrent(d->dmy_pdc, 0);

   678     wglDeleteContext(d->dmy_rc);

   679     ReleaseDC(d->dmy_id, d->dmy_pdc);

   680     DestroyWindow(d->dmy_id);

   681     if (d->old_dc && d->old_context)

   682         wglMakeCurrent(d->old_dc, d->old_context);

   683 }

   684 

   685 bool QGLContext::chooseContext(const QGLContext* shareContext)

   686 {

   687     Q_D(QGLContext);

   688     // workaround for matrox driver:

   689     // make a cheap call to opengl to force loading of DLL

   690     if (!opengl32dll) {

   691         GLint params;

   692         glGetIntegerv(GL_DEPTH_BITS, &params);

   693         opengl32dll = true;

   694     }

   695 

   696     bool result = true;

   697     HDC myDc;

   698     QWidget *widget = 0;

   699 

   700     if (deviceIsPixmap()) {

   701         if (d->glFormat.plane())

   702             return false;                // Pixmaps can't have overlay

   703         d->win = 0;

   704         HDC display_dc = GetDC(0);

   705         myDc = d->hbitmap_hdc = CreateCompatibleDC(display_dc);

   706         QPixmap *px = static_cast<QPixmap *>(d->paintDevice);

   707 

   708         BITMAPINFO bmi;

   709         memset(&bmi, 0, sizeof(bmi));

   710         bmi.bmiHeader.biSize        = sizeof(BITMAPINFOHEADER);

   711         bmi.bmiHeader.biWidth       = px->width();

   712         bmi.bmiHeader.biHeight      = px->height();

   713         bmi.bmiHeader.biPlanes      = 1;

   714         bmi.bmiHeader.biBitCount    = 32;

   715         bmi.bmiHeader.biCompression = BI_RGB;

   716         d->hbitmap = CreateDIBSection(display_dc, &bmi, DIB_RGB_COLORS, 0, 0, 0);

   717         SelectObject(myDc, d->hbitmap);

   718         ReleaseDC(0, display_dc);

   719     } else {

   720         widget = static_cast<QWidget *>(d->paintDevice);

   721         d->win = widget->winId();

   722         myDc = GetDC(d->win);

   723     }

   724 

   725     // NB! the QGLTemporaryContext object is needed for the

   726     // wglGetProcAddress() calls to succeed and are absolutely

   727     // necessary - don't remove!

   728     QGLTemporaryContext tmp_ctx(d->glFormat.directRendering(), widget);

   729 

   730     if (!myDc) {

   731         qWarning("QGLContext::chooseContext(): Paint device cannot be null");

   732         result = false;

   733         goto end;

   734     }

   735 

   736     if (d->glFormat.plane()) {

   737         d->pixelFormatId = ((QGLWidget*)d->paintDevice)->context()->d_func()->pixelFormatId;

   738         if (!d->pixelFormatId) {                // I.e. the glwidget is invalid

   739             qWarning("QGLContext::chooseContext(): Cannot create overlay context for invalid widget");

   740             result = false;

   741             goto end;

   742         }

   743 

   744         d->rc = wglCreateLayerContext(myDc, d->glFormat.plane());

   745         if (!d->rc) {

   746             qwglError("QGLContext::chooseContext()", "CreateLayerContext");

   747             result = false;

   748             goto end;

   749         }

   750 

   751         LAYERPLANEDESCRIPTOR lpfd;

   752         wglDescribeLayerPlane(myDc, d->pixelFormatId, d->glFormat.plane(), sizeof(LAYERPLANEDESCRIPTOR), &lpfd);

   753         d->glFormat.setDoubleBuffer(lpfd.dwFlags & LPD_DOUBLEBUFFER);

   754         d->glFormat.setDepth(lpfd.cDepthBits);

   755         d->glFormat.setRgba(lpfd.iPixelType == PFD_TYPE_RGBA);

   756         if (d->glFormat.rgba()) {

   757             if (d->glFormat.redBufferSize() != -1)

   758                 d->glFormat.setRedBufferSize(lpfd.cRedBits);

   759             if (d->glFormat.greenBufferSize() != -1)

   760                 d->glFormat.setGreenBufferSize(lpfd.cGreenBits);

   761             if (d->glFormat.blueBufferSize() != -1)

   762                 d->glFormat.setBlueBufferSize(lpfd.cBlueBits);

   763         }

   764         d->glFormat.setAlpha(lpfd.cAlphaBits);

   765         d->glFormat.setAccum(lpfd.cAccumBits);

   766         d->glFormat.setStencil(lpfd.cStencilBits);

   767         d->glFormat.setStereo(lpfd.dwFlags & LPD_STEREO);

   768         d->glFormat.setDirectRendering(false);

   769         if (d->glFormat.depth())

   770             d->glFormat.setDepthBufferSize(lpfd.cDepthBits);

   771         if (d->glFormat.alpha())

   772             d->glFormat.setAlphaBufferSize(lpfd.cAlphaBits);

   773         if (d->glFormat.accum())

   774             d->glFormat.setAccumBufferSize(lpfd.cAccumRedBits);

   775         if (d->glFormat.stencil())

   776             d->glFormat.setStencilBufferSize(lpfd.cStencilBits);

   777 

   778         if (d->glFormat.rgba()) {

   779             if (lpfd.dwFlags & LPD_TRANSPARENT)

   780                 d->transpColor = QColor(lpfd.crTransparent & 0xff,

   781                                         (lpfd.crTransparent >> 8) & 0xff,

   782                                         (lpfd.crTransparent >> 16) & 0xff);

   783             else

   784                 d->transpColor = QColor(0, 0, 0);

   785         }

   786         else {

   787             if (lpfd.dwFlags & LPD_TRANSPARENT)

   788                 d->transpColor = QColor(qRgb(1, 2, 3));//, lpfd.crTransparent);

   789             else

   790                 d->transpColor = QColor(qRgb(1, 2, 3));//, 0);

   791 

   792             d->cmap = new QGLCmap(1 << lpfd.cColorBits);

   793             d->cmap->setEntry(lpfd.crTransparent, qRgb(1, 2, 3));//, QGLCmap::Reserved);

   794         }

   795 

   796         if (shareContext && shareContext->isValid()) {

   797             QGLContext *share = const_cast<QGLContext *>(shareContext);

   798             d->sharing = (wglShareLists(shareContext->d_func()->rc, d->rc) != 0);

   799             share->d_func()->sharing = d->sharing;

   800         }

   801 

   802         goto end;

   803     }

   804     {

   805         PIXELFORMATDESCRIPTOR pfd;

   806         PIXELFORMATDESCRIPTOR realPfd;

   807         d->pixelFormatId = choosePixelFormat(&pfd, myDc);

   808         if (d->pixelFormatId == 0) {

   809             qwglError("QGLContext::chooseContext()", "ChoosePixelFormat");

   810             result = false;

   811             goto end;

   812         }

   813 

   814         bool overlayRequested = d->glFormat.hasOverlay();

   815         DescribePixelFormat(myDc, d->pixelFormatId, sizeof(PIXELFORMATDESCRIPTOR), &realPfd);

   816 

   817         if (!deviceIsPixmap() && wglGetProcAddress("wglGetPixelFormatAttribivARB"))

   818             d->glFormat = pfiToQGLFormat(myDc, d->pixelFormatId);

   819         else

   820             d->glFormat = pfdToQGLFormat(&realPfd);

   821 

   822         d->glFormat.setOverlay(d->glFormat.hasOverlay() && overlayRequested);

   823 

   824         if (deviceIsPixmap() && !(realPfd.dwFlags & PFD_DRAW_TO_BITMAP)) {

   825             qWarning("QGLContext::chooseContext(): Failed to get pixmap rendering context.");

   826             result = false;

   827             goto end;

   828         }

   829 

   830         if (deviceIsPixmap() &&

   831             (((QPixmap*)d->paintDevice)->depth() != realPfd.cColorBits)) {

   832             qWarning("QGLContext::chooseContext(): Failed to get pixmap rendering context of suitable depth.");

   833             result = false;

   834             goto end;

   835         }

   836 

   837         if (!SetPixelFormat(myDc, d->pixelFormatId, &realPfd)) {

   838             qwglError("QGLContext::chooseContext()", "SetPixelFormat");

   839             result = false;

   840             goto end;

   841         }

   842 

   843         if (!(d->rc = wglCreateLayerContext(myDc, 0))) {

   844             qwglError("QGLContext::chooseContext()", "wglCreateContext");

   845             result = false;

   846             goto end;

   847         }

   848 

   849         if (shareContext && shareContext->isValid()) {

   850             d->sharing = (wglShareLists(shareContext->d_func()->rc, d->rc) != 0);

   851             const_cast<QGLContext *>(shareContext)->d_func()->sharing = d->sharing;

   852         }

   853 

   854         if(!deviceIsPixmap()) {

   855             QRgb* pal = qgl_create_rgb_palette(&realPfd);

   856             if (pal) {

   857                 QGLColormap cmap;

   858                 cmap.setEntries(256, pal);

   859                 ((QGLWidget*)d->paintDevice)->setColormap(cmap);

   860                 delete[] pal;

   861             }

   862         }

   863     }

   864 

   865 end:

   866     // vblanking

   867     wglMakeCurrent(myDc, d->rc);

   868     typedef BOOL (APIENTRYP PFNWGLSWAPINTERVALEXT) (int interval);

   869     typedef int (APIENTRYP PFNWGLGETSWAPINTERVALEXT) (void);

   870     PFNWGLSWAPINTERVALEXT wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXT) wglGetProcAddress("wglSwapIntervalEXT");

   871     PFNWGLGETSWAPINTERVALEXT wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXT) wglGetProcAddress("wglGetSwapIntervalEXT");

   872     if (wglSwapIntervalEXT && wglGetSwapIntervalEXT) {

   873         if (d->reqFormat.swapInterval() != -1)

   874             wglSwapIntervalEXT(d->reqFormat.swapInterval());

   875         d->glFormat.setSwapInterval(wglGetSwapIntervalEXT());

   876     }

   877 

   878     if (d->win)

   879         ReleaseDC(d->win, myDc);

   880     return result;

   881 }

   882 

   883 

   884 

   885 static bool qLogEq(bool a, bool b)

   886 {

   887     return (((!a) && (!b)) || (a && b));

   888 }

   889 

   890 /*

   891   See qgl.cpp for qdoc comment.

   892  */

   893 int QGLContext::choosePixelFormat(void* dummyPfd, HDC pdc)

   894 {

   895     Q_D(QGLContext);

   896     // workaround for matrox driver:

   897     // make a cheap call to opengl to force loading of DLL

   898     if (!opengl32dll) {

   899         GLint params;

   900         glGetIntegerv(GL_DEPTH_BITS, &params);

   901         opengl32dll = true;

   902     }

   903 

   904     PFNWGLCHOOSEPIXELFORMATARB wglChoosePixelFormatARB =

   905         (PFNWGLCHOOSEPIXELFORMATARB) wglGetProcAddress("wglChoosePixelFormatARB");

   906     int chosenPfi = 0;

   907     if (!deviceIsPixmap() && wglChoosePixelFormatARB) {

   908         bool valid;

   909         int pixelFormat = 0;

   910         uint numFormats = 0;

   911         QVarLengthArray<int> iAttributes(40);

   912         int i = 0;

   913         iAttributes[i++] = WGL_ACCELERATION_ARB;

   914         if (d->glFormat.directRendering())

   915             iAttributes[i++] = WGL_FULL_ACCELERATION_ARB;

   916         else

   917             iAttributes[i++] = WGL_NO_ACCELERATION_ARB;

   918         iAttributes[i++] = WGL_SUPPORT_OPENGL_ARB;

   919         iAttributes[i++] = TRUE;

   920         iAttributes[i++] = WGL_DRAW_TO_WINDOW_ARB;

   921         iAttributes[i++] = TRUE;

   922         iAttributes[i++] = WGL_COLOR_BITS_ARB;

   923         iAttributes[i++] = 32;

   924         iAttributes[i++] = WGL_DOUBLE_BUFFER_ARB;

   925         iAttributes[i++] = d->glFormat.doubleBuffer();

   926         if (d->glFormat.stereo()) {

   927             iAttributes[i++] = WGL_STEREO_ARB;

   928             iAttributes[i++] = TRUE;

   929         }

   930         if (d->glFormat.depth()) {

   931             iAttributes[i++] = WGL_DEPTH_BITS_ARB;

   932             iAttributes[i++] = d->glFormat.depthBufferSize() == -1 ? 24 : d->glFormat.depthBufferSize();

   933         }

   934         iAttributes[i++] = WGL_PIXEL_TYPE_ARB;

   935         if (d->glFormat.rgba()) {

   936             iAttributes[i++] = WGL_TYPE_RGBA_ARB;

   937             if (d->glFormat.redBufferSize() != -1) {

   938                 iAttributes[i++] = WGL_RED_BITS_ARB;

   939                 iAttributes[i++] = d->glFormat.redBufferSize();

   940             }

   941             if (d->glFormat.greenBufferSize() != -1) {

   942                 iAttributes[i++] = WGL_GREEN_BITS_ARB;

   943                 iAttributes[i++] = d->glFormat.greenBufferSize();

   944             }

   945             if (d->glFormat.blueBufferSize() != -1) {

   946                 iAttributes[i++] = WGL_BLUE_BITS_ARB;

   947                 iAttributes[i++] = d->glFormat.blueBufferSize();

   948             }

   949         } else {

   950             iAttributes[i++] = WGL_TYPE_COLORINDEX_ARB;

   951         }

   952         if (d->glFormat.alpha()) {

   953             iAttributes[i++] = WGL_ALPHA_BITS_ARB;

   954             iAttributes[i++] = d->glFormat.alphaBufferSize() == -1 ? 8 : d->glFormat.alphaBufferSize();

   955         }

   956         if (d->glFormat.accum()) {

   957             iAttributes[i++] = WGL_ACCUM_BITS_ARB;

   958             iAttributes[i++] = d->glFormat.accumBufferSize() == -1 ? 16 : d->glFormat.accumBufferSize();

   959         }

   960         if (d->glFormat.stencil()) {

   961             iAttributes[i++] = WGL_STENCIL_BITS_ARB;

   962             iAttributes[i++] = d->glFormat.stencilBufferSize() == -1 ? 8 : d->glFormat.stencilBufferSize();

   963         }

   964         if (d->glFormat.hasOverlay()) {

   965             iAttributes[i++] = WGL_NUMBER_OVERLAYS_ARB;

   966             iAttributes[i++] = 1;

   967         }

   968         int si = 0;

   969         bool trySampleBuffers = QGLExtensions::glExtensions() & QGLExtensions::SampleBuffers;

   970         if (trySampleBuffers && d->glFormat.sampleBuffers()) {

   971             iAttributes[i++] = WGL_SAMPLE_BUFFERS_ARB;

   972             iAttributes[i++] = TRUE;

   973             iAttributes[i++] = WGL_SAMPLES_ARB;

   974             si = i;

   975             iAttributes[i++] = d->glFormat.samples() == -1 ? 4 : d->glFormat.samples();

   976         }

   977         iAttributes[i] = 0;

   978 

   979         do {

   980             valid = wglChoosePixelFormatARB(pdc, iAttributes.constData(), 0, 1,

   981                                             &pixelFormat, &numFormats);

   982             if (trySampleBuffers  && (!valid || numFormats < 1) && d->glFormat.sampleBuffers())

   983                 iAttributes[si] /= 2; // try different no. samples - we aim for the best one

   984             else

   985                 break;

   986         } while ((!valid || numFormats < 1) && iAttributes[si] > 1);

   987         chosenPfi = pixelFormat;

   988     }

   989 

   990     if (!chosenPfi) { // fallback if wglChoosePixelFormatARB() failed

   991         int pmDepth = deviceIsPixmap() ? ((QPixmap*)d->paintDevice)->depth() : 0;

   992         PIXELFORMATDESCRIPTOR* p = (PIXELFORMATDESCRIPTOR*)dummyPfd;

   993         memset(p, 0, sizeof(PIXELFORMATDESCRIPTOR));

   994         p->nSize = sizeof(PIXELFORMATDESCRIPTOR);

   995         p->nVersion = 1;

   996         p->dwFlags  = PFD_SUPPORT_OPENGL;

   997         if (deviceIsPixmap())

   998             p->dwFlags |= PFD_DRAW_TO_BITMAP;

   999         else

  1000             p->dwFlags |= PFD_DRAW_TO_WINDOW;

  1001         if (!d->glFormat.directRendering())

  1002             p->dwFlags |= PFD_GENERIC_FORMAT;

  1003         if (d->glFormat.doubleBuffer() && !deviceIsPixmap())

  1004             p->dwFlags |= PFD_DOUBLEBUFFER;

  1005         if (d->glFormat.stereo())

  1006             p->dwFlags |= PFD_STEREO;

  1007         if (d->glFormat.depth())

  1008             p->cDepthBits = d->glFormat.depthBufferSize() == -1 ? 32 : d->glFormat.depthBufferSize();

  1009         else

  1010             p->dwFlags |= PFD_DEPTH_DONTCARE;

  1011         if (d->glFormat.rgba()) {

  1012             p->iPixelType = PFD_TYPE_RGBA;

  1013             if (d->glFormat.redBufferSize() != -1)

  1014                 p->cRedBits = d->glFormat.redBufferSize();

  1015             if (d->glFormat.greenBufferSize() != -1)

  1016                 p->cGreenBits = d->glFormat.greenBufferSize();

  1017             if (d->glFormat.blueBufferSize() != -1)

  1018                 p->cBlueBits = d->glFormat.blueBufferSize();

  1019             if (deviceIsPixmap())

  1020                 p->cColorBits = pmDepth;

  1021             else

  1022                 p->cColorBits = 32;

  1023         } else {

  1024             p->iPixelType = PFD_TYPE_COLORINDEX;

  1025             p->cColorBits = 8;

  1026         }

  1027         if (d->glFormat.alpha())

  1028             p->cAlphaBits = d->glFormat.alphaBufferSize() == -1 ? 8 : d->glFormat.alphaBufferSize();

  1029         if (d->glFormat.accum()) {

  1030             p->cAccumRedBits = p->cAccumGreenBits = p->cAccumBlueBits = p->cAccumAlphaBits =

  1031                                d->glFormat.accumBufferSize() == -1 ? 16 : d->glFormat.accumBufferSize();

  1032         }

  1033         if (d->glFormat.stencil())

  1034             p->cStencilBits = d->glFormat.stencilBufferSize() == -1 ? 8 : d->glFormat.stencilBufferSize();

  1035         p->iLayerType = PFD_MAIN_PLANE;

  1036         chosenPfi = ChoosePixelFormat(pdc, p);

  1037 

  1038         if (!chosenPfi)

  1039             qErrnoWarning("QGLContext: ChoosePixelFormat failed");

  1040 

  1041         // Since the GDI function ChoosePixelFormat() does not handle

  1042         // overlay and direct-rendering requests, we must roll our own here

  1043 

  1044         bool doSearch = chosenPfi <= 0;

  1045         PIXELFORMATDESCRIPTOR pfd;

  1046         QGLFormat fmt;

  1047         if (!doSearch) {

  1048             DescribePixelFormat(pdc, chosenPfi, sizeof(PIXELFORMATDESCRIPTOR),

  1049                                 &pfd);

  1050             fmt = pfdToQGLFormat(&pfd);

  1051             if (d->glFormat.hasOverlay() && !fmt.hasOverlay())

  1052                 doSearch = true;

  1053             else if (!qLogEq(d->glFormat.directRendering(), fmt.directRendering()))

  1054                 doSearch = true;

  1055             else if (deviceIsPixmap() && (!(pfd.dwFlags & PFD_DRAW_TO_BITMAP) ||

  1056                                           pfd.cColorBits != pmDepth))

  1057                 doSearch = true;

  1058             else if (!deviceIsPixmap() && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))

  1059                 doSearch = true;

  1060             else if (!qLogEq(d->glFormat.rgba(), fmt.rgba()))

  1061                 doSearch = true;

  1062         }

  1063 

  1064         if (doSearch) {

  1065             int pfiMax = DescribePixelFormat(pdc, 0, 0, NULL);

  1066             int bestScore = -1;

  1067             int bestPfi = -1;

  1068             for (int pfi = 1; pfi <= pfiMax; pfi++) {

  1069                 DescribePixelFormat(pdc, pfi, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

  1070                 if (!(pfd.dwFlags & PFD_SUPPORT_OPENGL))

  1071                     continue;

  1072                 if (deviceIsPixmap() && (!(pfd.dwFlags & PFD_DRAW_TO_BITMAP) ||

  1073                                          pfd.cColorBits != pmDepth))

  1074                     continue;

  1075                 if (!deviceIsPixmap() && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))

  1076                     continue;

  1077 

  1078                 fmt = pfdToQGLFormat(&pfd);

  1079                 if (d->glFormat.hasOverlay() && !fmt.hasOverlay())

  1080                     continue;

  1081 

  1082                 int score = pfd.cColorBits;

  1083                 if (qLogEq(d->glFormat.depth(), fmt.depth()))

  1084                     score += pfd.cDepthBits;

  1085                 if (qLogEq(d->glFormat.alpha(), fmt.alpha()))

  1086                     score += pfd.cAlphaBits;

  1087                 if (qLogEq(d->glFormat.accum(), fmt.accum()))

  1088                     score += pfd.cAccumBits;

  1089                 if (qLogEq(d->glFormat.stencil(), fmt.stencil()))

  1090                     score += pfd.cStencilBits;

  1091                 if (qLogEq(d->glFormat.doubleBuffer(), fmt.doubleBuffer()))

  1092                     score += 1000;

  1093                 if (qLogEq(d->glFormat.stereo(), fmt.stereo()))

  1094                     score += 2000;

  1095                 if (qLogEq(d->glFormat.directRendering(), fmt.directRendering()))

  1096                     score += 4000;

  1097                 if (qLogEq(d->glFormat.rgba(), fmt.rgba()))

  1098                     score += 8000;

  1099                 if (score > bestScore) {

  1100                     bestScore = score;

  1101                     bestPfi = pfi;

  1102                 }

  1103             }

  1104 

  1105             if (bestPfi > 0)

  1106                 chosenPfi = bestPfi;

  1107         }

  1108     }

  1109     return chosenPfi;

  1110 }

  1111 

  1112 

  1113 

  1114 void QGLContext::reset()

  1115 {

  1116     Q_D(QGLContext);

  1117     // workaround for matrox driver:

  1118     // make a cheap call to opengl to force loading of DLL

  1119     if (!opengl32dll) {

  1120         GLint params;

  1121         glGetIntegerv(GL_DEPTH_BITS, &params);

  1122         opengl32dll = true;

  1123     }

  1124 

  1125     if (!d->valid)

  1126         return;

  1127     d->cleanup();

  1128     doneCurrent();

  1129     if (d->rc)

  1130         wglDeleteContext(d->rc);

  1131     d->rc  = 0;

  1132     if (d->win && d->dc)

  1133         ReleaseDC(d->win, d->dc);

  1134     if (deviceIsPixmap()) {

  1135         DeleteDC(d->hbitmap_hdc);