Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 636 insertions, 0 deletions

diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp
new file mode 100644
index 0000000000..e1989f9f2f
--- /dev/null
+++ b/src/opengl/qgl_wince.cpp
@@ -0,0 +1,636 @@
+/****************************************************************************
+**
+** 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$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, 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.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $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