/****************************************************************************

**

** Copyright (C) 2010 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);