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

**

** 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 <qcolor.h>

#include <qt_windows.h>

typedef bool (APIENTRY *PFNWGLGETPIXELFORMATATTRIBIVARB)(HDC hdc,

                                                         int iPixelFormat,

                                                         int iLayerPlane,

                                                         uint nAttributes,

                                                         const int *piAttributes,

                                                         int *piValues);

typedef bool (APIENTRY *PFNWGLCHOOSEPIXELFORMATARB)(HDC hdc,

                                                    const int *piAttribList,

                                                    const float *pfAttribFList,

                                                    uint nMaxFormats,

                                                    int *piFormats,

                                                    UINT *nNumFormats);

#ifndef WGL_ARB_multisample

#define WGL_SAMPLE_BUFFERS_ARB               0x2041

#define WGL_SAMPLES_ARB                      0x2042

#endif

#ifndef WGL_ARB_pixel_format

#define WGL_NUMBER_PIXEL_FORMATS_ARB   0x2000

#define WGL_DRAW_TO_WINDOW_ARB         0x2001

#define WGL_DRAW_TO_BITMAP_ARB         0x2002

#define WGL_ACCELERATION_ARB           0x2003

#define WGL_NEED_PALETTE_ARB           0x2004

#define WGL_NEED_SYSTEM_PALETTE_ARB    0x2005

#define WGL_SWAP_LAYER_BUFFERS_ARB     0x2006

#define WGL_SWAP_METHOD_ARB            0x2007

#define WGL_NUMBER_OVERLAYS_ARB        0x2008

#define WGL_NUMBER_UNDERLAYS_ARB       0x2009

#define WGL_TRANSPARENT_ARB            0x200A

#define WGL_TRANSPARENT_RED_VALUE_ARB  0x2037

#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038

#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039

#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A

#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B

#define WGL_SHARE_DEPTH_ARB            0x200C

#define WGL_SHARE_STENCIL_ARB          0x200D

#define WGL_SHARE_ACCUM_ARB            0x200E

#define WGL_SUPPORT_GDI_ARB            0x200F

#define WGL_SUPPORT_OPENGL_ARB         0x2010

#define WGL_DOUBLE_BUFFER_ARB          0x2011

#define WGL_STEREO_ARB                 0x2012

#define WGL_PIXEL_TYPE_ARB             0x2013

#define WGL_COLOR_BITS_ARB             0x2014

#define WGL_RED_BITS_ARB               0x2015

#define WGL_RED_SHIFT_ARB              0x2016

#define WGL_GREEN_BITS_ARB             0x2017

#define WGL_GREEN_SHIFT_ARB            0x2018

#define WGL_BLUE_BITS_ARB              0x2019

#define WGL_BLUE_SHIFT_ARB             0x201A

#define WGL_ALPHA_BITS_ARB             0x201B

#define WGL_ALPHA_SHIFT_ARB            0x201C

#define WGL_ACCUM_BITS_ARB             0x201D

#define WGL_ACCUM_RED_BITS_ARB         0x201E

#define WGL_ACCUM_GREEN_BITS_ARB       0x201F

#define WGL_ACCUM_BLUE_BITS_ARB        0x2020

#define WGL_ACCUM_ALPHA_BITS_ARB       0x2021

#define WGL_DEPTH_BITS_ARB             0x2022

#define WGL_STENCIL_BITS_ARB           0x2023

#define WGL_AUX_BUFFERS_ARB            0x2024

#define WGL_NO_ACCELERATION_ARB        0x2025

#define WGL_GENERIC_ACCELERATION_ARB   0x2026

#define WGL_FULL_ACCELERATION_ARB      0x2027

#define WGL_SWAP_EXCHANGE_ARB          0x2028

#define WGL_SWAP_COPY_ARB              0x2029

#define WGL_SWAP_UNDEFINED_ARB         0x202A

#define WGL_TYPE_RGBA_ARB              0x202B

#define WGL_TYPE_COLORINDEX_ARB        0x202C

#endif

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

**

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

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;

};

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();

}

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

  QGLFormat Win32/WGL-specific code

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

void qwglError(const char* method, const char* func)

{

#ifndef QT_NO_DEBUG

    char* lpMsgBuf;

    FormatMessageA(

                  FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

                  0, GetLastError(),

                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),

                  (char*) &lpMsgBuf, 0, 0);

    qWarning("%s : %s failed: %s", method, func, lpMsgBuf);

    LocalFree(lpMsgBuf);

#else

    Q_UNUSED(method);

    Q_UNUSED(func);

#endif

}

bool QGLFormat::hasOpenGL()

{

    return true;

}

static bool opengl32dll = false;

bool QGLFormat::hasOpenGLOverlays()

{

    // workaround for matrox driver:

    // make a cheap call to opengl to force loading of DLL

    if (!opengl32dll) {

        GLint params;

        glGetIntegerv(GL_DEPTH_BITS, &params);

        opengl32dll = true;

    }

    static bool checkDone = false;

    static bool hasOl = false;

    if (!checkDone) {

        checkDone = true;

        HDC display_dc = GetDC(0);

        int pfiMax = DescribePixelFormat(display_dc, 0, 0, NULL);

        PIXELFORMATDESCRIPTOR pfd;

        for (int pfi = 1; pfi <= pfiMax; pfi++) {

            DescribePixelFormat(display_dc, pfi, sizeof(PIXELFORMATDESCRIPTOR), &pfd);

            if ((pfd.bReserved & 0x0f) && (pfd.dwFlags & PFD_SUPPORT_OPENGL)) {

                // This format has overlays/underlays

                LAYERPLANEDESCRIPTOR lpd;

                wglDescribeLayerPlane(display_dc, pfi, 1,

                                       sizeof(LAYERPLANEDESCRIPTOR), &lpd);

                if (lpd.dwFlags & LPD_SUPPORT_OPENGL) {

                    hasOl = true;

                    break;

                }

            }

        }

        ReleaseDC(0, display_dc);

    }

    return hasOl;

}

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

  QGLContext Win32/WGL-specific code

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

static uchar qgl_rgb_palette_comp(int idx, uint nbits, uint shift)

{

    const uchar map_3_to_8[8] = {

        0, 0111>>1, 0222>>1, 0333>>1, 0444>>1, 0555>>1, 0666>>1, 0377

    };

    const uchar map_2_to_8[4] = {

        0, 0x55, 0xaa, 0xff

    };

    const uchar map_1_to_8[2] = {

        0, 255

    };

    uchar val = (uchar) (idx >> shift);

    uchar res = 0;

    switch (nbits) {

    case 1:

        val &= 0x1;

        res =  map_1_to_8[val];

        break;

    case 2:

        val &= 0x3;

        res = map_2_to_8[val];

        break;

    case 3:

        val &= 0x7;

        res = map_3_to_8[val];

        break;

    default:

        res = 0;

    }

    return res;

}

static QRgb* qgl_create_rgb_palette(const PIXELFORMATDESCRIPTOR* pfd)

{

    if ((pfd->iPixelType != PFD_TYPE_RGBA) ||

         !(pfd->dwFlags & PFD_NEED_PALETTE) ||

         (pfd->cColorBits != 8))

        return 0;

    int numEntries = 1 << pfd->cColorBits;

    QRgb* pal = new QRgb[numEntries];

    for (int i = 0; i < numEntries; i++) {

        int r = qgl_rgb_palette_comp(i, pfd->cRedBits, pfd->cRedShift);

        int g = qgl_rgb_palette_comp(i, pfd->cGreenBits, pfd->cGreenShift);

        int b = qgl_rgb_palette_comp(i, pfd->cBlueBits, pfd->cBlueShift);

        pal[i] = qRgb(r, g, b);

    }

    const int syscol_indices[12] = {

        3, 24, 27, 64, 67, 88, 173, 181, 236, 247, 164, 91

    };

    const uint syscols[20] = {

        0x000000, 0x800000, 0x008000, 0x808000, 0x000080, 0x800080,

        0x008080, 0xc0c0c0, 0xc0dcc0, 0xa6caf0, 0xfffbf0, 0xa0a0a4,

        0x808080, 0xff0000, 0x00ff00, 0xffff00, 0x0000ff, 0xff00ff,

        0x00ffff, 0xffffff

    };        // colors #1 - #12 are not present in pal; gets added below

    if ((pfd->cColorBits == 8)                                &&

         (pfd->cRedBits   == 3) && (pfd->cRedShift   == 0)        &&

         (pfd->cGreenBits == 3) && (pfd->cGreenShift == 3)        &&

         (pfd->cBlueBits  == 2) && (pfd->cBlueShift  == 6)) {

        for (int j = 0 ; j < 12 ; j++)

            pal[syscol_indices[j]] = QRgb(syscols[j+1]);

    }

    return pal;

}

static QGLFormat pfdToQGLFormat(const PIXELFORMATDESCRIPTOR* pfd)

{

    QGLFormat fmt;

    fmt.setDoubleBuffer(pfd->dwFlags & PFD_DOUBLEBUFFER);

    fmt.setDepth(pfd->cDepthBits);

    if (fmt.depth())

        fmt.setDepthBufferSize(pfd->cDepthBits);

    fmt.setRgba(pfd->iPixelType == PFD_TYPE_RGBA);

    fmt.setRedBufferSize(pfd->cRedBits);

    fmt.setGreenBufferSize(pfd->cGreenBits);

    fmt.setBlueBufferSize(pfd->cBlueBits);