1 files changed, 0 insertions, 636 deletions
diff --git a/src/opengl/qgl_wince.cpp b/src/opengl/qgl_wince.cpp
deleted file mode 100644
index d6d8f24bfa..0000000000
--- a/src/opengl/qgl_wince.cpp
+++ /dev/null
@@ -1,636 +0,0 @@
-/****************************************************************************
-**
-** 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