| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtOpenGL module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| |
| #include <qgl.h> |
| #include <qlist.h> |
| #include <qmap.h> |
| #include <qpixmap.h> |
| #include <qevent.h> |
| #include <private/qgl_p.h> |
| #include <qcolormap.h> |
| #include <qvarlengtharray.h> |
| #include <qdebug.h> |
| #include <qapplication.h> |
| #include <qdesktopwidget> |
| |
| #include <windows.h> |
| |
| #include <private/qeglproperties_p.h> |
| #include <private/qeglcontext_p.h> |
| #include <private/qgl_egl_p.h> |
| |
| |
| QT_BEGIN_NAMESPACE |
| |
| |
| |
| class QGLCmapPrivate |
| { |
| public: |
| QGLCmapPrivate() : count(1) { } |
| void ref() { ++count; } |
| bool deref() { return !--count; } |
| uint count; |
| |
| enum AllocState{ UnAllocated = 0, Allocated = 0x01, Reserved = 0x02 }; |
| |
| int maxSize; |
| QVector<uint> colorArray; |
| QVector<quint8> allocArray; |
| QVector<quint8> contextArray; |
| QMap<uint,int> colorMap; |
| }; |
| |
| /***************************************************************************** |
| QColorMap class - temporarily here, until it is ready for prime time |
| *****************************************************************************/ |
| |
| /**************************************************************************** |
| ** |
| ** Definition of QColorMap class |
| ** |
| ****************************************************************************/ |
| |
| #ifndef QGLCMAP_H |
| #define QGLCMAP_H |
| |
| #include <qcolor.h> |
| |
| /* |
| QGLTemporaryContext implementation |
| */ |
| |
| class QGLTemporaryContextPrivate |
| { |
| public: |
| QGLWidget *widget; |
| }; |
| |
| QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *) |
| : d(new QGLTemporaryContextPrivate) |
| { |
| d->widget = new QGLWidget; |
| d->widget->makeCurrent(); |
| } |
| |
| QGLTemporaryContext::~QGLTemporaryContext() |
| { |
| delete d->widget; |
| } |
| |
| /***************************************************************************** |
| QGLFormat Win32/WGL-specific code |
| *****************************************************************************/ |
| |
| static bool opengl32dll = false; |
| |
| bool QGLFormat::hasOpenGLOverlays() |
| { |
| return false; // ### |
| } |
| |
| |
| bool QGLContext::chooseContext(const QGLContext* shareContext) |
| { |
| Q_D(QGLContext); |
| |
| // Validate the device. |
| if (!device()) |
| return false; |
| int devType = device()->devType(); |
| if (devType != QInternal::Pixmap && devType != QInternal::Image && devType != QInternal::Widget) { |
| qWarning("QGLContext::chooseContext(): Cannot create QGLContext's for paint device type %d", devType); |
| return false; |
| } |
| |
| // Get the display and initialize it. |
| d->eglContext = new QEglContext(); |
| d->ownsEglContext = true; |
| d->eglContext->setApi(QEgl::OpenGL); |
| |
| // Construct the configuration we need for this surface. |
| QEglProperties configProps; |
| qt_eglproperties_set_glformat(configProps, d->glFormat); |
| configProps.setDeviceType(devType); |
| configProps.setPaintDeviceFormat(device()); |
| configProps.setRenderableType(QEgl::OpenGL); |
| |
| // Search for a matching configuration, reducing the complexity |
| // each time until we get something that matches. |
| if (!d->eglContext->chooseConfig(configProps)) { |
| delete d->eglContext; |
| d->eglContext = 0; |
| return false; |
| } |
| |
| // Inform the higher layers about the actual format properties. |
| qt_glformat_from_eglconfig(d->glFormat, d->eglContext->config()); |
| |
| // Create a new context for the configuration. |
| if (!d->eglContext->createContext |
| (shareContext ? shareContext->d_func()->eglContext : 0)) { |
| delete d->eglContext; |
| d->eglContext = 0; |
| return false; |
| } |
| d->sharing = d->eglContext->isSharing(); |
| if (d->sharing && shareContext) |
| const_cast<QGLContext *>(shareContext)->d_func()->sharing = true; |
| |
| #if defined(EGL_VERSION_1_1) |
| if (d->glFormat.swapInterval() != -1 && devType == QInternal::Widget) |
| eglSwapInterval(d->eglContext->display(), d->glFormat.swapInterval()); |
| #endif |
| |
| // Create the EGL surface to draw into. |
| d->eglSurface = d->eglContext->createSurface(device()); |
| if (d->eglSurface == EGL_NO_SURFACE) { |
| delete d->eglContext; |
| d->eglContext = 0; |
| return false; |
| } |
| |
| return true; |
| |
| } |
| |
| |
| |
| static bool qLogEq(bool a, bool b) |
| { |
| return (((!a) && (!b)) || (a && b)); |
| } |
| |
| int QGLContext::choosePixelFormat(void* , HDC ) |
| { |
| |
| return 0; |
| } |
| |
| class QGLCmapPrivate; |
| |
| class /*Q_EXPORT*/ QGLCmap |
| { |
| public: |
| enum Flags { Reserved = 0x01 }; |
| |
| QGLCmap(int maxSize = 256); |
| QGLCmap(const QGLCmap& map); |
| ~QGLCmap(); |
| |
| QGLCmap& operator=(const QGLCmap& map); |
| |
| // isEmpty and/or isNull ? |
| int size() const; |
| int maxSize() const; |
| |
| void resize(int newSize); |
| |
| int find(QRgb color) const; |
| int findNearest(QRgb color) const; |
| int allocate(QRgb color, uint flags = 0, quint8 context = 0); |
| |
| void setEntry(int idx, QRgb color, uint flags = 0, quint8 context = 0); |
| |
| const QRgb* colors() const; |
| |
| private: |
| void detach(); |
| QGLCmapPrivate* d; |
| }; |
| |
| #endif |
| |
| |
| QGLCmap::QGLCmap(int maxSize) // add a bool prealloc? |
| { |
| d = new QGLCmapPrivate; |
| d->maxSize = maxSize; |
| } |
| |
| QGLCmap::QGLCmap(const QGLCmap& map) |
| { |
| d = map.d; |
| d->ref(); |
| } |
| |
| QGLCmap::~QGLCmap() |
| { |
| if (d && d->deref()) |
| delete d; |
| d = 0; |
| } |
| |
| QGLCmap& QGLCmap::operator=(const QGLCmap& map) |
| { |
| map.d->ref(); |
| if (d->deref()) |
| delete d; |
| d = map.d; |
| return *this; |
| } |
| |
| int QGLCmap::size() const |
| { |
| return d->colorArray.size(); |
| } |
| |
| int QGLCmap::maxSize() const |
| { |
| return d->maxSize; |
| } |
| |
| void QGLCmap::detach() |
| { |
| if (d->count != 1) { |
| d->deref(); |
| QGLCmapPrivate* newd = new QGLCmapPrivate; |
| newd->maxSize = d->maxSize; |
| newd->colorArray = d->colorArray; |
| newd->allocArray = d->allocArray; |
| newd->contextArray = d->contextArray; |
| newd->colorArray.detach(); |
| newd->allocArray.detach(); |
| newd->contextArray.detach(); |
| newd->colorMap = d->colorMap; |
| d = newd; |
| } |
| } |
| |
| |
| void QGLCmap::resize(int newSize) |
| { |
| if (newSize < 0 || newSize > d->maxSize) { |
| qWarning("QGLCmap::resize(): size out of range"); |
| return; |
| } |
| int oldSize = size(); |
| detach(); |
| //if shrinking; remove the lost elems from colorMap |
| d->colorArray.resize(newSize); |
| d->allocArray.resize(newSize); |
| d->contextArray.resize(newSize); |
| if (newSize > oldSize) { |
| memset(d->allocArray.data() + oldSize, 0, newSize - oldSize); |
| memset(d->contextArray.data() + oldSize, 0, newSize - oldSize); |
| } |
| } |
| |
| |
| int QGLCmap::find(QRgb color) const |
| { |
| QMap<uint,int>::ConstIterator it = d->colorMap.find(color); |
| if (it != d->colorMap.end()) |
| return *it; |
| return -1; |
| } |
| |
| |
| int QGLCmap::findNearest(QRgb color) const |
| { |
| int idx = find(color); |
| if (idx >= 0) |
| return idx; |
| int mapSize = size(); |
| int mindist = 200000; |
| int r = qRed(color); |
| int g = qGreen(color); |
| int b = qBlue(color); |
| int rx, gx, bx, dist; |
| for (int i=0; i < mapSize; i++) { |
| if (!(d->allocArray[i] & QGLCmapPrivate::Allocated)) |
| continue; |
| QRgb ci = d->colorArray[i]; |
| rx = r - qRed(ci); |
| gx = g - qGreen(ci); |
| bx = b - qBlue(ci); |
| dist = rx*rx + gx*gx + bx*bx; // calculate distance |
| if (dist < mindist) { // minimal? |
| mindist = dist; |
| idx = i; |
| } |
| } |
| return idx; |
| } |
| |
| |
| // Does not always allocate; returns existing c idx if found |
| |
| int QGLCmap::allocate(QRgb color, uint flags, quint8 context) |
| { |
| int idx = find(color); |
| if (idx >= 0) |
| return idx; |
| |
| int mapSize = d->colorArray.size(); |
| int newIdx = d->allocArray.indexOf(QGLCmapPrivate::UnAllocated); |
| |
| if (newIdx < 0) { // Must allocate more room |
| if (mapSize < d->maxSize) { |
| newIdx = mapSize; |
| mapSize++; |
| resize(mapSize); |
| } |
| else { |
| //# add a bool param that says what to do in case no more room - |
| // fail (-1) or return nearest? |
| return -1; |
| } |
| } |
| |
| d->colorArray[newIdx] = color; |
| if (flags & QGLCmap::Reserved) { |
| d->allocArray[newIdx] = QGLCmapPrivate::Reserved; |
| } |
| else { |
| d->allocArray[newIdx] = QGLCmapPrivate::Allocated; |
| d->colorMap.insert(color, newIdx); |
| } |
| d->contextArray[newIdx] = context; |
| return newIdx; |
| } |
| |
| |
| void QGLCmap::setEntry(int idx, QRgb color, uint flags, quint8 context) |
| { |
| if (idx < 0 || idx >= d->maxSize) { |
| qWarning("QGLCmap::set(): Index out of range"); |
| return; |
| } |
| detach(); |
| int mapSize = size(); |
| if (idx >= mapSize) { |
| mapSize = idx + 1; |
| resize(mapSize); |
| } |
| d->colorArray[idx] = color; |
| if (flags & QGLCmap::Reserved) { |
| d->allocArray[idx] = QGLCmapPrivate::Reserved; |
| } |
| else { |
| d->allocArray[idx] = QGLCmapPrivate::Allocated; |
| d->colorMap.insert(color, idx); |
| } |
| d->contextArray[idx] = context; |
| } |
| |
| |
| const QRgb* QGLCmap::colors() const |
| { |
| return d->colorArray.data(); |
| } |
| |
| |
| /***************************************************************************** |
| QGLWidget Win32/WGL-specific code |
| *****************************************************************************/ |
| |
| void QGLWidgetPrivate::init(QGLContext *ctx, const QGLWidget* shareWidget) |
| { |
| Q_Q(QGLWidget); |
| olcx = 0; |
| initContext(ctx, shareWidget); |
| |
| if (q->isValid() && q->context()->format().hasOverlay()) { |
| olcx = new QGLContext(QGLFormat::defaultOverlayFormat(), q); |
| if (!olcx->create(shareWidget ? shareWidget->overlayContext() : 0)) { |
| delete olcx; |
| olcx = 0; |
| glcx->d_func()->glFormat.setOverlay(false); |
| } |
| } else { |
| olcx = 0; |
| } |
| } |
| |
| /*\internal |
| Store color values in the given colormap. |
| */ |
| static void qStoreColors(HPALETTE cmap, const QGLColormap & cols) |
| { |
| QRgb color; |
| PALETTEENTRY pe; |
| |
| for (int i = 0; i < cols.size(); i++) { |
| color = cols.entryRgb(i); |
| pe.peRed = qRed(color); |
| pe.peGreen = qGreen(color); |
| pe.peBlue = qBlue(color); |
| pe.peFlags = 0; |
| |
| SetPaletteEntries(cmap, i, 1, &pe); |
| } |
| } |
| |
| void QGLWidgetPrivate::updateColormap() |
| { |
| Q_Q(QGLWidget); |
| if (!cmap.handle()) |
| return; |
| HDC hdc = GetDC(q->winId()); |
| SelectPalette(hdc, (HPALETTE) cmap.handle(), TRUE); |
| qStoreColors((HPALETTE) cmap.handle(), cmap); |
| RealizePalette(hdc); |
| ReleaseDC(q->winId(), hdc); |
| } |
| |
| bool QGLWidget::event(QEvent *e) |
| { |
| Q_D(QGLWidget); |
| if (e->type() == QEvent::ParentChange) { |
| setContext(new QGLContext(d->glcx->requestedFormat(), this)); |
| // the overlay needs to be recreated as well |
| delete d->olcx; |
| if (isValid() && context()->format().hasOverlay()) { |
| d->olcx = new QGLContext(QGLFormat::defaultOverlayFormat(), this); |
| if (!d->olcx->create(isSharing() ? d->glcx : 0)) { |
| delete d->olcx; |
| d->olcx = 0; |
| d->glcx->d_func()->glFormat.setOverlay(false); |
| } |
| } else { |
| d->olcx = 0; |
| } |
| } else if (e->type() == QEvent::Show && !format().rgba()) { |
| d->updateColormap(); |
| } |
| |
| return QWidget::event(e); |
| } |
| |
| |
| void QGLWidget::resizeEvent(QResizeEvent *) |
| { |
| Q_D(QGLWidget); |
| if (!isValid()) |
| return; |
| makeCurrent(); |
| if (!d->glcx->initialized()) |
| glInit(); |
| resizeGL(width(), height()); |
| if (d->olcx) { |
| makeOverlayCurrent(); |
| resizeOverlayGL(width(), height()); |
| } |
| } |
| |
| |
| const QGLContext* QGLWidget::overlayContext() const |
| { |
| return d_func()->olcx; |
| } |
| |
| |
| void QGLWidget::makeOverlayCurrent() |
| { |
| Q_D(QGLWidget); |
| if (d->olcx) { |
| d->olcx->makeCurrent(); |
| if (!d->olcx->initialized()) { |
| initializeOverlayGL(); |
| d->olcx->setInitialized(true); |
| } |
| } |
| } |
| |
| |
| void QGLWidget::updateOverlayGL() |
| { |
| Q_D(QGLWidget); |
| if (d->olcx) { |
| makeOverlayCurrent(); |
| paintOverlayGL(); |
| if (d->olcx->format().doubleBuffer()) { |
| if (d->autoSwap) |
| d->olcx->swapBuffers(); |
| } |
| else { |
| glFlush(); |
| } |
| } |
| } |
| |
| void QGLWidget::setContext(QGLContext *context, |
| const QGLContext* shareContext, |
| bool deleteOldContext) |
| { |
| Q_D(QGLWidget); |
| if (context == 0) { |
| qWarning("QGLWidget::setContext: Cannot set null context"); |
| return; |
| } |
| if (!context->deviceIsPixmap() && context->device() != this) { |
| qWarning("QGLWidget::setContext: Context must refer to this widget"); |
| return; |
| } |
| |
| if (d->glcx) |
| d->glcx->doneCurrent(); |
| QGLContext* oldcx = d->glcx; |
| d->glcx = context; |
| |
| bool doShow = false; |
| if (oldcx && oldcx->d_func()->win == winId() && !d->glcx->deviceIsPixmap()) { |
| // We already have a context and must therefore create a new |
| // window since Windows does not permit setting a new OpenGL |
| // context for a window that already has one set. |
| doShow = isVisible(); |
| QWidget *pW = static_cast<QWidget *>(parent()); |
| QPoint pos = geometry().topLeft(); |
| setParent(pW, windowFlags()); |
| move(pos); |
| } |
| |
| if (!d->glcx->isValid()) { |
| d->glcx->create(shareContext ? shareContext : oldcx); |
| // the above is a trick to keep disp lists etc when a |
| // QGLWidget has been reparented, so remove the sharing |
| // flag if we don't actually have a sharing context. |
| if (!shareContext) |
| d->glcx->d_ptr->sharing = false; |
| } |
| |
| if (deleteOldContext) |
| delete oldcx; |
| |
| if (doShow) |
| show(); |
| } |
| |
| |
| void QGLWidgetPrivate::cleanupColormaps() |
| { |
| Q_Q(QGLWidget); |
| if (cmap.handle()) { |
| HDC hdc = GetDC(q->winId()); |
| SelectPalette(hdc, (HPALETTE) GetStockObject(DEFAULT_PALETTE), FALSE); |
| DeleteObject((HPALETTE) cmap.handle()); |
| ReleaseDC(q->winId(), hdc); |
| cmap.setHandle(0); |
| } |
| return; |
| } |
| |
| const QGLColormap & QGLWidget::colormap() const |
| { |
| return d_func()->cmap; |
| } |
| |
| void QGLWidget::setColormap(const QGLColormap & c) |
| { |
| Q_D(QGLWidget); |
| d->cmap = c; |
| |
| if (d->cmap.handle()) { // already have an allocated cmap |
| d->updateColormap(); |
| } else { |
| LOGPALETTE *lpal = (LOGPALETTE *) malloc(sizeof(LOGPALETTE) |
| +c.size()*sizeof(PALETTEENTRY)); |
| lpal->palVersion = 0x300; |
| lpal->palNumEntries = c.size(); |
| d->cmap.setHandle(CreatePalette(lpal)); |
| free(lpal); |
| d->updateColormap(); |
| } |
| } |
| |
| QT_END_NAMESPACE |