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

     2 **

     3 ** Copyright (C) 2009 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 <qapplication.h>

    53 #include <qdesktopwidget>

    54 

    55 #include <windows.h>

    56 

    57 #include "qegl_p.h"

    58 #include "qgl_egl_p.h"

    59 #include "qgl_cl_p.h"

    60 

    61 

    62 QT_BEGIN_NAMESPACE

    63 

    64 

    65 

    66 class QGLCmapPrivate

    67 {

    68 public:

    69     QGLCmapPrivate() : count(1) { }

    70     void ref()                { ++count; }

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

    72     uint count;

    73 

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

    75 

    76     int maxSize;

    77     QVector<uint> colorArray;

    78     QVector<quint8> allocArray;

    79     QVector<quint8> contextArray;

    80     QMap<uint,int> colorMap;

    81 };

    82 

    83 /*****************************************************************************

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

    85  *****************************************************************************/

    86 

    87 /****************************************************************************

    88 **

    89 ** Definition of QColorMap class

    90 **

    91 ****************************************************************************/

    92 

    93 #ifndef QGLCMAP_H

    94 #define QGLCMAP_H

    95 

    96 #include <qcolor.h>

    97 

    98 

    99 

   100 

   101 /*****************************************************************************

   102   QGLFormat Win32/WGL-specific code

   103  *****************************************************************************/

   104 

   105 void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)

   106 {

   107     int devType = device->devType();

   108     if (devType == QInternal::Image)

   109         props.setPixelFormat(static_cast<QImage *>(device)->format());

   110     else

   111         props.setPixelFormat(QImage::Format_RGB16);

   112 }

   113 

   114 

   115 static bool opengl32dll = false;

   116 

   117 bool QGLFormat::hasOpenGLOverlays()

   118 {

   119     return false; // ###

   120 }

   121 

   122 

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

   124 {

   125         Q_D(QGLContext);

   126 

   127     // Validate the device.

   128     if (!device())

   129         return false;

   130     int devType = device()->devType();

   131     if (devType != QInternal::Pixmap && devType != QInternal::Image && devType != QInternal::Widget) {

   132         qWarning("QGLContext::chooseContext(): Cannot create QGLContext's for paint device type %d", devType);

   133         return false;

   134     }

   135 

   136     // Get the display and initialize it.

   137     d->eglContext = new QEglContext();

   138     d->eglContext->setApi(QEgl::OpenGL);

   139     if (!d->eglContext->openDisplay(device())) {

   140         delete d->eglContext;

   141         d->eglContext = 0;

   142         return false;

   143     }

   144 

   145     // Construct the configuration we need for this surface.

   146     QEglProperties configProps;

   147     qt_egl_add_platform_config(configProps, device());

   148     qt_egl_set_format(configProps, devType, d->glFormat);

   149     configProps.setRenderableType(QEgl::OpenGL);

   150 

   151     // Search for a matching configuration, reducing the complexity

   152     // each time until we get something that matches.

   153     if (!d->eglContext->chooseConfig(configProps)) {

   154         delete d->eglContext;

   155         d->eglContext = 0;

   156         return false;

   157     }

   158 

   159     // Inform the higher layers about the actual format properties.

   160     qt_egl_update_format(*(d->eglContext), d->glFormat);

   161 

   162     // Create a new context for the configuration.

   163     if (!d->eglContext->createContext

   164             (shareContext ? shareContext->d_func()->eglContext : 0)) {

   165         delete d->eglContext;

   166         d->eglContext = 0;

   167         return false;

   168     }

   169 

   170 #if defined(EGL_VERSION_1_1)

   171     if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget)

   172         eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval());

   173 #endif

   174 

   175     // Create the EGL surface to draw into.

   176     d->eglSurface = d->eglContext->createSurface(device());

   177     if (d->eglSurface == EGL_NO_SURFACE) {

   178         delete d->eglContext;

   179         d->eglContext = 0;

   180         return false;

   181     }

   182 

   183     return true;

   184 

   185 }

   186 

   187 

   188 

   189 static bool qLogEq(bool a, bool b)

   190 {

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

   192 }

   193 

   194 int QGLContext::choosePixelFormat(void* , HDC )

   195 {

   196 

   197     return 0;

   198 }

   199 

   200 class QGLCmapPrivate;

   201 

   202 class /*Q_EXPORT*/ QGLCmap

   203 {

   204 public:

   205     enum Flags { Reserved = 0x01 };

   206 

   207     QGLCmap(int maxSize = 256);

   208     QGLCmap(const QGLCmap& map);

   209     ~QGLCmap();

   210 

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

   212 

   213     // isEmpty and/or isNull ?

   214     int size() const;

   215     int maxSize() const;

   216 

   217     void resize(int newSize);

   218 

   219     int find(QRgb color) const;

   220     int findNearest(QRgb color) const;

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

   222 

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

   224 

   225     const QRgb* colors() const;

   226 

   227 private:

   228     void detach();

   229     QGLCmapPrivate* d;

   230 };

   231 

   232 #endif

   233 

   234 

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

   236 {

   237     d = new QGLCmapPrivate;

   238     d->maxSize = maxSize;

   239 }

   240 

   241 QGLCmap::QGLCmap(const QGLCmap& map)

   242 {

   243     d = map.d;

   244     d->ref();

   245 }

   246 

   247 QGLCmap::~QGLCmap()

   248 {

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

   250         delete d;

   251     d = 0;

   252 }

   253 

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

   255 {

   256     map.d->ref();

   257     if (d->deref())

   258         delete d;

   259     d = map.d;

   260     return *this;

   261 }

   262 

   263 int QGLCmap::size() const

   264 {

   265     return d->colorArray.size();

   266 }

   267 

   268 int QGLCmap::maxSize() const

   269 {

   270     return d->maxSize;

   271 }

   272 

   273 void QGLCmap::detach()

   274 {

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

   276         d->deref();

   277         QGLCmapPrivate* newd = new QGLCmapPrivate;

   278         newd->maxSize = d->maxSize;

   279         newd->colorArray = d->colorArray;

   280         newd->allocArray = d->allocArray;

   281         newd->contextArray = d->contextArray;

   282         newd->colorArray.detach();

   283         newd->allocArray.detach();

   284         newd->contextArray.detach();

   285         newd->colorMap = d->colorMap;

   286         d = newd;

   287     }

   288 }

   289 

   290 

   291 void QGLCmap::resize(int newSize)

   292 {

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

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

   295         return;

   296     }

   297     int oldSize = size();

   298     detach();

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

   300     d->colorArray.resize(newSize);

   301     d->allocArray.resize(newSize);

   302     d->contextArray.resize(newSize);

   303     if (newSize > oldSize) {

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

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

   306     }

   307 }

   308 

   309 

   310 int QGLCmap::find(QRgb color) const

   311 {

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

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

   314         return *it;

   315     return -1;

   316 }

   317 

   318 

   319 int QGLCmap::findNearest(QRgb color) const

   320 {

   321     int idx = find(color);

   322     if (idx >= 0)

   323         return idx;

   324     int mapSize = size();

   325     int mindist = 200000;

   326     int r = qRed(color);

   327     int g = qGreen(color);

   328     int b = qBlue(color);

   329     int rx, gx, bx, dist;

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

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

   332             continue;

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

   334         rx = r - qRed(ci);

   335         gx = g - qGreen(ci);

   336         bx = b - qBlue(ci);

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

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

   339             mindist = dist;

   340             idx = i;

   341         }

   342     }

   343     return idx;

   344 }

   345 

   346 

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

   348 

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

   350 {

   351     int idx = find(color);

   352     if (idx >= 0)

   353         return idx;

   354 

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

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

   357 

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

   359         if (mapSize < d->maxSize) {

   360             newIdx = mapSize;

   361             mapSize++;

   362             resize(mapSize);

   363         }

   364         else {

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

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

   367             return -1;

   368         }

   369     }

   370 

   371     d->colorArray[newIdx] = color;

   372     if (flags & QGLCmap::Reserved) {

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

   374     }

   375     else {

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

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

   378     }

   379     d->contextArray[newIdx] = context;

   380     return newIdx;

   381 }

   382 

   383 

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

   385 {

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

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

   388         return;

   389     }

   390     detach();

   391     int mapSize = size();

   392     if (idx >= mapSize) {

   393         mapSize = idx + 1;

   394         resize(mapSize);

   395     }

   396     d->colorArray[idx] = color;

   397     if (flags & QGLCmap::Reserved) {

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

   399     }

   400     else {

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

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

   403     }

   404     d->contextArray[idx] = context;

   405 }

   406 

   407 

   408 const QRgb* QGLCmap::colors() const

   409 {

   410     return d->colorArray.data();

   411 }

   412 

   413 

   414 /*****************************************************************************

   415   QGLWidget Win32/WGL-specific code

   416  *****************************************************************************/

   417 

   418 void QGLWidgetPrivate::init(QGLContext *ctx, const QGLWidget* shareWidget)

   419 {

   420     Q_Q(QGLWidget);

   421     olcx = 0;

   422     initContext(ctx, shareWidget);

   423 

   424     if (q->isValid() && q->context()->format().hasOverlay()) {

   425         olcx = new QGLContext(QGLFormat::defaultOverlayFormat(), q);

   426         if (!olcx->create(shareWidget ? shareWidget->overlayContext() : 0)) {

   427             delete olcx;

   428             olcx = 0;

   429             glcx->d_func()->glFormat.setOverlay(false);

   430         }

   431     } else {

   432         olcx = 0;

   433     }

   434 }

   435 

   436 /*\internal

   437   Store color values in the given colormap.

   438 */

   439 static void qStoreColors(HPALETTE cmap, const QGLColormap & cols)

   440 {

   441     QRgb color;

   442     PALETTEENTRY pe;

   443 

   444     for (int i = 0; i < cols.size(); i++) {

   445         color = cols.entryRgb(i);

   446         pe.peRed   = qRed(color);

   447         pe.peGreen = qGreen(color);

   448         pe.peBlue  = qBlue(color);

   449         pe.peFlags = 0;

   450 

   451         SetPaletteEntries(cmap, i, 1, &pe);

   452     }

   453 }

   454 

   455 void QGLWidgetPrivate::updateColormap()

   456 {

   457     Q_Q(QGLWidget);

   458     if (!cmap.handle())

   459         return;

   460     HDC hdc = GetDC(q->winId());

   461     SelectPalette(hdc, (HPALETTE) cmap.handle(), TRUE);

   462     qStoreColors((HPALETTE) cmap.handle(), cmap);

   463     RealizePalette(hdc);

   464     ReleaseDC(q->winId(), hdc);

   465 }

   466 

   467 bool QGLWidget::event(QEvent *e)

   468 {

   469     Q_D(QGLWidget);

   470     if (e->type() == QEvent::ParentChange) {

   471         setContext(new QGLContext(d->glcx->requestedFormat(), this));

   472         // the overlay needs to be recreated as well

   473         delete d->olcx;

   474         if (isValid() && context()->format().hasOverlay()) {

   475             d->olcx = new QGLContext(QGLFormat::defaultOverlayFormat(), this);

   476             if (!d->olcx->create(isSharing() ? d->glcx : 0)) {

   477                 delete d->olcx;

   478                 d->olcx = 0;

   479                 d->glcx->d_func()->glFormat.setOverlay(false);

   480             }

   481         } else {

   482             d->olcx = 0;

   483         }

   484     } else if (e->type() == QEvent::Show && !format().rgba()) {

   485         d->updateColormap();

   486     }

   487 

   488     return QWidget::event(e);

   489 }

   490 

   491 

   492 void QGLWidget::resizeEvent(QResizeEvent *)

   493 {

   494     Q_D(QGLWidget);

   495     if (!isValid())

   496         return;

   497     makeCurrent();

   498     if (!d->glcx->initialized())

   499         glInit();

   500     resizeGL(width(), height());

   501     if (d->olcx) {

   502         makeOverlayCurrent();

   503         resizeOverlayGL(width(), height());

   504     }

   505 }

   506 

   507 

   508 const QGLContext* QGLWidget::overlayContext() const

   509 {

   510     return d_func()->olcx;

   511 }

   512 

   513 

   514 void QGLWidget::makeOverlayCurrent()

   515 {

   516     Q_D(QGLWidget);

   517     if (d->olcx) {

   518         d->olcx->makeCurrent();

   519         if (!d->olcx->initialized()) {

   520             initializeOverlayGL();

   521             d->olcx->setInitialized(true);

   522         }

   523     }

   524 }

   525 

   526 

   527 void QGLWidget::updateOverlayGL()

   528 {

   529     Q_D(QGLWidget);

   530     if (d->olcx) {

   531         makeOverlayCurrent();

   532         paintOverlayGL();

   533         if (d->olcx->format().doubleBuffer()) {

   534             if (d->autoSwap)

   535                 d->olcx->swapBuffers();

   536         }

   537         else {

   538             glFlush();

   539         }

   540     }

   541 }

   542 

   543 void QGLWidget::setContext(QGLContext *context,

   544                             const QGLContext* shareContext,

   545                             bool deleteOldContext)

   546 {

   547     Q_D(QGLWidget);

   548     if (context == 0) {

   549         qWarning("QGLWidget::setContext: Cannot set null context");

   550         return;

   551     }

   552     if (!context->deviceIsPixmap() && context->device() != this) {

   553         qWarning("QGLWidget::setContext: Context must refer to this widget");

   554         return;

   555     }

   556 

   557     if (d->glcx)

   558         d->glcx->doneCurrent();

   559     QGLContext* oldcx = d->glcx;

   560     d->glcx = context;

   561 

   562     bool doShow = false;

   563     if (oldcx && oldcx->d_func()->win == winId() && !d->glcx->deviceIsPixmap()) {

   564         // We already have a context and must therefore create a new

   565         // window since Windows does not permit setting a new OpenGL

   566         // context for a window that already has one set.

   567         doShow = isVisible();

   568         QWidget *pW = static_cast<QWidget *>(parent());

   569         QPoint pos = geometry().topLeft();

   570         setParent(pW, windowFlags());

   571         move(pos);

   572     }

   573 

   574     if (!d->glcx->isValid()) {

   575         d->glcx->create(shareContext ? shareContext : oldcx);

   576         // the above is a trick to keep disp lists etc when a

   577         // QGLWidget has been reparented, so remove the sharing

   578         // flag if we don't actually have a sharing context.

   579         if (!shareContext)

   580             d->glcx->d_ptr->sharing = false;

   581     }

   582 

   583     if (deleteOldContext)

   584         delete oldcx;

   585 

   586     if (doShow)

   587         show();

   588 }

   589 

   590 

   591 void QGLWidgetPrivate::cleanupColormaps()

   592 {

   593     Q_Q(QGLWidget);

   594     if (cmap.handle()) {

   595         HDC hdc = GetDC(q->winId());

   596         SelectPalette(hdc, (HPALETTE) GetStockObject(DEFAULT_PALETTE), FALSE);

   597         DeleteObject((HPALETTE) cmap.handle());

   598         ReleaseDC(q->winId(), hdc);

   599         cmap.setHandle(0);

   600     }

   601     return;

   602 }

   603 

   604 const QGLColormap & QGLWidget::colormap() const

   605 {

   606     return d_func()->cmap;

   607 }

   608 

   609 void QGLWidget::setColormap(const QGLColormap & c)

   610 {

   611     Q_D(QGLWidget);

   612     d->cmap = c;

   613 

   614     if (d->cmap.handle()) { // already have an allocated cmap

   615         d->updateColormap();

   616     } else {

   617         LOGPALETTE *lpal = (LOGPALETTE *) malloc(sizeof(LOGPALETTE)

   618                                                  +c.size()*sizeof(PALETTEENTRY));

   619         lpal->palVersion    = 0x300;

   620         lpal->palNumEntries = c.size();

   621         d->cmap.setHandle(CreatePalette(lpal));

   622         free(lpal);

   623         d->updateColormap();

   624     }

   625 }

   626 

   627 void QGLExtensions::init()

   628 {

   629     static bool init_done = false;

   630 

   631     if (init_done)

   632         return;

   633     init_done = true;

   634 

   635     // We need a context current to initialize the extensions.

   636     QGLWidget tmpWidget;

   637     tmpWidget.makeCurrent();

   638 

   639     init_extensions();

   640 

   641     tmpWidget.doneCurrent();

   642 }

   643 

   644 QT_END_NAMESPACE