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

**

** Copyright (C) 2009 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 "qgl_p.h"

#include "qmap.h"

#include "qapplication.h"

#include "qcolormap.h"

#include "qdesktopwidget.h"

#include "qpixmap.h"

#include "qhash.h"

#include "qlibrary.h"

#include "qdebug.h"

#include <private/qfontengine_ft_p.h>

#include <private/qt_x11_p.h>

#include <private/qpixmap_x11_p.h>

#ifdef Q_OS_HPUX

// for GLXPBuffer

#include <private/qglpixelbuffer_p.h>

#endif

// We always define GLX_EXT_texture_from_pixmap ourselves because

// we can't trust system headers to do it properly

#define GLX_EXT_texture_from_pixmap 1

#define INT8  dummy_INT8

#define INT32 dummy_INT32

#include <GL/glx.h>

#undef  INT8

#undef  INT32

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/Xos.h>

#ifdef Q_OS_VXWORS

#  ifdef open

#    undef open

#  endif

#  ifdef getpid

#    undef getpid

#  endif

#endif // Q_OS_VXWORKS

#include <X11/Xatom.h>

#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)

#include <dlfcn.h>

#endif

QT_BEGIN_NAMESPACE

extern Drawable qt_x11Handle(const QPaintDevice *pd);

extern const QX11Info *qt_x11Info(const QPaintDevice *pd);

#ifndef GLX_ARB_multisample

#define GLX_SAMPLE_BUFFERS_ARB  100000

#define GLX_SAMPLES_ARB         100001

#endif

#ifndef GLX_TEXTURE_2D_BIT_EXT

#define GLX_TEXTURE_2D_BIT_EXT             0x00000002

#define GLX_TEXTURE_RECTANGLE_BIT_EXT      0x00000004

#define GLX_BIND_TO_TEXTURE_RGB_EXT        0x20D0

#define GLX_BIND_TO_TEXTURE_RGBA_EXT       0x20D1

#define GLX_BIND_TO_MIPMAP_TEXTURE_EXT     0x20D2

#define GLX_BIND_TO_TEXTURE_TARGETS_EXT    0x20D3

#define GLX_Y_INVERTED_EXT                 0x20D4

#define GLX_TEXTURE_FORMAT_EXT             0x20D5

#define GLX_TEXTURE_TARGET_EXT             0x20D6

#define GLX_MIPMAP_TEXTURE_EXT             0x20D7

#define GLX_TEXTURE_FORMAT_NONE_EXT        0x20D8

#define GLX_TEXTURE_FORMAT_RGB_EXT         0x20D9

#define GLX_TEXTURE_FORMAT_RGBA_EXT        0x20DA

#define GLX_TEXTURE_2D_EXT                 0x20DC

#define GLX_TEXTURE_RECTANGLE_EXT          0x20DD

#define GLX_FRONT_LEFT_EXT                 0x20DE

#endif

/*

  The qt_gl_choose_cmap function is internal and used by QGLWidget::setContext()

  and GLX (not Windows).  If the application can't find any sharable

  colormaps, it must at least create as few colormaps as possible.  The

  dictionary solution below ensures only one colormap is created per visual.

  Colormaps are also deleted when the application terminates.

*/

struct QCMapEntry {

    QCMapEntry();

    ~QCMapEntry();

    Colormap cmap;

    bool alloc;

    XStandardColormap scmap;

};

QCMapEntry::QCMapEntry()

{

    cmap = 0;

    alloc = false;

    scmap.colormap = 0;

}

QCMapEntry::~QCMapEntry()

{

    if (alloc)

        XFreeColormap(X11->display, cmap);

}

typedef QHash<int, QCMapEntry *> CMapEntryHash;

typedef QHash<int, QMap<int, QRgb> > GLCMapHash;

static bool mesa_gl = false;

static bool first_time = true;

static void cleanup_cmaps();

struct QGLCMapCleanupHandler {

    QGLCMapCleanupHandler() {

        cmap_hash = new CMapEntryHash;

        qglcmap_hash = new GLCMapHash;

    }

    ~QGLCMapCleanupHandler() {

        delete cmap_hash;

        delete qglcmap_hash;

    }

    CMapEntryHash *cmap_hash;

    GLCMapHash *qglcmap_hash;

};

Q_GLOBAL_STATIC(QGLCMapCleanupHandler, cmap_handler)

static void cleanup_cmaps()

{

    CMapEntryHash *hash = cmap_handler()->cmap_hash;

    QHash<int, QCMapEntry *>::ConstIterator it = hash->constBegin();

    while (it != hash->constEnd()) {

        delete it.value();

        ++it;

    }

    hash->clear();

    cmap_handler()->qglcmap_hash->clear();

}

Colormap qt_gl_choose_cmap(Display *dpy, XVisualInfo *vi)

{

    if (first_time) {

        const char *v = glXQueryServerString(dpy, vi->screen, GLX_VERSION);

        if (v)

            mesa_gl = (strstr(v, "Mesa") != 0);

        first_time = false;

    }

    CMapEntryHash *hash = cmap_handler()->cmap_hash;

    CMapEntryHash::ConstIterator it = hash->constFind((long) vi->visualid + (vi->screen * 256));

    if (it != hash->constEnd())

        return it.value()->cmap; // found colormap for visual

    if (vi->visualid ==

        XVisualIDFromVisual((Visual *) QX11Info::appVisual(vi->screen))) {

        // qDebug("Using x11AppColormap");

        return QX11Info::appColormap(vi->screen);

    }

    QCMapEntry *x = new QCMapEntry();

    XStandardColormap *c;

    int n, i;

    // qDebug("Choosing cmap for vID %0x", vi->visualid);

    if (mesa_gl) {                                // we're using MesaGL

        Atom hp_cmaps = XInternAtom(dpy, "_HP_RGB_SMOOTH_MAP_LIST", true);

        if (hp_cmaps && vi->visual->c_class == TrueColor && vi->depth == 8) {

            if (XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,

                                 hp_cmaps)) {

                i = 0;

                while (i < n && x->cmap == 0) {

                    if (c[i].visualid == vi->visual->visualid) {

                        x->cmap = c[i].colormap;

                        x->scmap = c[i];

                        //qDebug("Using HP_RGB scmap");

                    }

                    i++;

                }

                XFree((char *)c);

            }

        }

    }

    if (!x->cmap) {

        if (XGetRGBColormaps(dpy,RootWindow(dpy,vi->screen),&c,&n,

                             XA_RGB_DEFAULT_MAP)) {

            for (int i = 0; i < n && x->cmap == 0; ++i) {

                if (!c[i].red_max ||

                    !c[i].green_max ||

                    !c[i].blue_max ||

                    !c[i].red_mult ||

                    !c[i].green_mult ||

                    !c[i].blue_mult)

                    continue; // invalid stdcmap

                if (c[i].visualid == vi->visualid) {

                    x->cmap = c[i].colormap;

                    x->scmap = c[i];

                    //qDebug("Using RGB_DEFAULT scmap");

                }

            }

            XFree((char *)c);

        }

    }

    if (!x->cmap) {                                // no shared cmap found

        x->cmap = XCreateColormap(dpy, RootWindow(dpy,vi->screen), vi->visual,

                                  AllocNone);

        x->alloc = true;

        // qDebug("Allocating cmap");

    }

    // colormap hash should be cleanup only when the QApplication dtor is called

    if (hash->isEmpty())

        qAddPostRoutine(cleanup_cmaps);

    // associate cmap with visualid

    hash->insert((long) vi->visualid + (vi->screen * 256), x);

    return x->cmap;

}

struct QTransColor

{

    VisualID vis;

    int screen;

    long color;

};

static QVector<QTransColor> trans_colors;

static int trans_colors_init = false;

static void find_trans_colors()

{

    struct OverlayProp {

        long  visual;

        long  type;

        long  value;

        long  layer;

    };

    trans_colors_init = true;

    Display* appDisplay = X11->display;

    int scr;

    int lastsize = 0;

    for (scr = 0; scr < ScreenCount(appDisplay); scr++) {

        QWidget* rootWin = QApplication::desktop()->screen(scr);

        if (!rootWin)

            return;                                        // Should not happen

        Atom overlayVisualsAtom = XInternAtom(appDisplay,

                                               "SERVER_OVERLAY_VISUALS", True);

        if (overlayVisualsAtom == XNone)

            return;                                        // Server has no overlays

        Atom actualType;

        int actualFormat;

        ulong nItems;

        ulong bytesAfter;

        unsigned char *retval = 0;

        int res = XGetWindowProperty(appDisplay, rootWin->winId(),

                                      overlayVisualsAtom, 0, 10000, False,

                                      overlayVisualsAtom, &actualType,

                                      &actualFormat, &nItems, &bytesAfter,

                                      &retval);

        if (res != Success || actualType != overlayVisualsAtom

             || actualFormat != 32 || nItems < 4 || !retval)

            return;                                        // Error reading property

        OverlayProp *overlayProps = (OverlayProp *)retval;

        int numProps = nItems / 4;

        trans_colors.resize(lastsize + numProps);

        int j = lastsize;

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

            if (overlayProps[i].type == 1) {

                trans_colors[j].vis = (VisualID)overlayProps[i].visual;

                trans_colors[j].screen = scr;

                trans_colors[j].color = (int)overlayProps[i].value;

                j++;

            }

        }

        XFree(overlayProps);

        lastsize = j;

        trans_colors.resize(lastsize);

    }

}

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

  QGLFormat UNIX/GLX-specific code

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

void* qglx_getProcAddress(const char* procName)

{

    // On systems where the GL driver is pluggable (like Mesa), we have to use

    // the glXGetProcAddressARB extension to resolve other function pointers as

    // the symbols wont be in the GL library, but rather in a plugin loaded by

    // the GL library.

    typedef void* (*qt_glXGetProcAddressARB)(const char *);

    static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;

    static bool triedResolvingGlxGetProcAddress = false;

    if (!triedResolvingGlxGetProcAddress) {

        triedResolvingGlxGetProcAddress = true;

        QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));

        if (glxExt.contains(QLatin1String("GLX_ARB_get_proc_address"))) {

#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)

            void *handle = dlopen(NULL, RTLD_LAZY);

            if (handle) {

                glXGetProcAddressARB = (qt_glXGetProcAddressARB) dlsym(handle, "glXGetProcAddressARB");

                dlclose(handle);

            }

            if (!glXGetProcAddressARB)

#endif

            {

#if !defined(QT_NO_LIBRARY)

                extern const QString qt_gl_library_name();

                QLibrary lib(qt_gl_library_name());

                glXGetProcAddressARB = (qt_glXGetProcAddressARB) lib.resolve("glXGetProcAddressARB");

#endif

            }

        }

    }

    void *procAddress = 0;

    if (glXGetProcAddressARB)

        procAddress = glXGetProcAddressARB(procName);

    // If glXGetProcAddress didn't work, try looking the symbol up in the GL library

#if defined(Q_OS_LINUX) || defined(Q_OS_BSD4)

    if (!procAddress) {

        void *handle = dlopen(NULL, RTLD_LAZY);

        if (handle) {

            procAddress = dlsym(handle, procName);

            dlclose(handle);

        }

    }

#endif

#if !defined(QT_NO_LIBRARY)

    if (!procAddress) {

        extern const QString qt_gl_library_name();

        QLibrary lib(qt_gl_library_name());

        procAddress = lib.resolve(procName);

    }

#endif

    return procAddress;

}

bool QGLFormat::hasOpenGL()

{

    return glXQueryExtension(X11->display, 0, 0) != 0;

}

bool QGLFormat::hasOpenGLOverlays()

{

    if (!trans_colors_init)

        find_trans_colors();

    return trans_colors.size() > 0;

}

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

  QGLContext UNIX/GLX-specific code

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

bool QGLContext::chooseContext(const QGLContext* shareContext)

{

    Q_D(QGLContext);

    const QX11Info *xinfo = qt_x11Info(d->paintDevice);

    Display* disp = xinfo->display();

    d->vi = chooseVisual();

    if (!d->vi)

        return false;

    if (deviceIsPixmap() &&

         (((XVisualInfo*)d->vi)->depth != xinfo->depth() ||

          ((XVisualInfo*)d->vi)->screen != xinfo->screen()))

    {

        XFree(d->vi);

        XVisualInfo appVisInfo;

        memset(&appVisInfo, 0, sizeof(XVisualInfo));

        appVisInfo.visualid = XVisualIDFromVisual((Visual *) xinfo->visual());

        appVisInfo.screen = xinfo->screen();

        int nvis;

        d->vi = XGetVisualInfo(disp, VisualIDMask | VisualScreenMask, &appVisInfo, &nvis);

        if (!d->vi)

            return false;

        int useGL;

        glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_USE_GL, &useGL);

        if (!useGL)

            return false;        //# Chickening out already...

    }

    int res;

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_LEVEL, &res);

    d->glFormat.setPlane(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_DOUBLEBUFFER, &res);

    d->glFormat.setDoubleBuffer(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_DEPTH_SIZE, &res);

    d->glFormat.setDepth(res);

    if (d->glFormat.depth())

        d->glFormat.setDepthBufferSize(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_RGBA, &res);

    d->glFormat.setRgba(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_RED_SIZE, &res);

    d->glFormat.setRedBufferSize(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_GREEN_SIZE, &res);

    d->glFormat.setGreenBufferSize(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_BLUE_SIZE, &res);

    d->glFormat.setBlueBufferSize(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_ALPHA_SIZE, &res);

    d->glFormat.setAlpha(res);

    if (d->glFormat.alpha())

        d->glFormat.setAlphaBufferSize(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_ACCUM_RED_SIZE, &res);

    d->glFormat.setAccum(res);

    if (d->glFormat.accum())

        d->glFormat.setAccumBufferSize(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_STENCIL_SIZE, &res);

    d->glFormat.setStencil(res);

    if (d->glFormat.stencil())

        d->glFormat.setStencilBufferSize(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_STEREO, &res);

    d->glFormat.setStereo(res);

    glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_SAMPLE_BUFFERS_ARB, &res);

    d->glFormat.setSampleBuffers(res);

    if (d->glFormat.sampleBuffers()) {

        glXGetConfig(disp, (XVisualInfo*)d->vi, GLX_SAMPLES_ARB, &res);

        d->glFormat.setSamples(res);

    }

    Bool direct = format().directRendering() ? True : False;

    if (shareContext &&

         (!shareContext->isValid() || !shareContext->d_func()->cx)) {

            qWarning("QGLContext::chooseContext(): Cannot share with invalid context");

            shareContext = 0;

    }

    // 1. Sharing between rgba and color-index will give wrong colors.

    // 2. Contexts cannot be shared btw. direct/non-direct renderers.

    // 3. Pixmaps cannot share contexts that are set up for direct rendering.

    // 4. If the contexts are not created on the same screen, they can't be shared

    if (shareContext

        && (format().rgba() != shareContext->format().rgba()

            || (deviceIsPixmap() && glXIsDirect(disp, (GLXContext)shareContext->d_func()->cx))

            || (shareContext->d_func()->screen != xinfo->screen())))

    {

        shareContext = 0;

    }

    d->cx = 0;

    if (shareContext) {

        d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi,

                               (GLXContext)shareContext->d_func()->cx, direct);

        d->screen = ((XVisualInfo*)d->vi)->screen;

        if (d->cx) {

            QGLContext *share = const_cast<QGLContext *>(shareContext);

            d->sharing = true;

            share->d_func()->sharing = true;

        }

    }

    if (!d->cx) {

        d->cx = glXCreateContext(disp, (XVisualInfo *)d->vi, NULL, direct);

        d->screen = ((XVisualInfo*)d->vi)->screen;

    }

    if (!d->cx)

        return false;

    d->glFormat.setDirectRendering(glXIsDirect(disp, (GLXContext)d->cx));

    if (deviceIsPixmap()) {

#if defined(GLX_MESA_pixmap_colormap) && defined(QGL_USE_MESA_EXT)

        d->gpm = glXCreateGLXPixmapMESA(disp, (XVisualInfo *)d->vi,

                                        qt_x11Handle(d->paintDevice),

                                        qt_gl_choose_cmap(disp, (XVisualInfo *)d->vi));

#else

        d->gpm = (quint32)glXCreateGLXPixmap(disp, (XVisualInfo *)d->vi,

                                              qt_x11Handle(d->paintDevice));

#endif

        if (!d->gpm)

            return false;

    }

    QString glxExt = QLatin1String(glXGetClientString(QX11Info::display(), GLX_EXTENSIONS));

    if (glxExt.contains(QLatin1String("GLX_SGI_video_sync"))) {

        if (d->glFormat.swapInterval() == -1)

            d->glFormat.setSwapInterval(0);