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

**

** 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 <private/qt_x11_p.h>

#include <private/qpixmap_x11_p.h>

#include <private/qimagepixmapcleanuphooks_p.h>

#include <private/qgl_p.h>

#include <private/qpaintengine_opengl_p.h>

#include "qgl_egl_p.h"

#include "qcolormap.h"

#include <QDebug>

QT_BEGIN_NAMESPACE

bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config,

                             const QX11Info &x11Info, bool useArgbVisual);

/*

    QGLTemporaryContext implementation

*/

class QGLTemporaryContextPrivate

{

public:

    bool initialized;

    Window window;

    EGLContext context;

    EGLSurface surface;

    EGLDisplay display;

};

QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)

    : d(new QGLTemporaryContextPrivate)

{

    d->initialized = false;

    d->window = 0;

    d->context = 0;

    d->surface = 0;

    int screen = 0;

    d->display = eglGetDisplay(EGLNativeDisplayType(X11->display));

    if (!eglInitialize(d->display, NULL, NULL)) {

        qWarning("QGLTemporaryContext: Unable to initialize EGL display.");

        return;

    }

    EGLConfig config;

    int numConfigs = 0;

    EGLint attribs[] = {

        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,

#ifdef QT_OPENGL_ES_2

        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,

#endif

        EGL_NONE

    };

    eglChooseConfig(d->display, attribs, &config, 1, &numConfigs);

    if (!numConfigs) {

        qWarning("QGLTemporaryContext: No EGL configurations available.");

        return;

    }

    XVisualInfo visualInfo;

    XVisualInfo *vi;

    int numVisuals;

    EGLint id = 0;

    eglGetConfigAttrib(d->display, config, EGL_NATIVE_VISUAL_ID, &id);

    if (id == 0) {

        // EGL_NATIVE_VISUAL_ID is optional and might not be supported

        // on some implementations - we'll have to do it the hard way

        QX11Info xinfo;

        qt_egl_setup_x11_visual(visualInfo, d->display, config, xinfo, false);

    } else {

        visualInfo.visualid = id;

    }

    vi = XGetVisualInfo(X11->display, VisualIDMask, &visualInfo, &numVisuals);

    if (!vi || numVisuals < 1) {

        qWarning("QGLTemporaryContext: Unable to get X11 visual info id.");

        return;

    }

    d->window = XCreateWindow(X11->display, RootWindow(X11->display, screen),

                              0, 0, 1, 1, 0,

                              vi->depth, InputOutput, vi->visual,

                              0, 0);

    d->surface = eglCreateWindowSurface(d->display, config, (EGLNativeWindowType) d->window, NULL);

    if (d->surface == EGL_NO_SURFACE) {

        qWarning("QGLTemporaryContext: Error creating EGL surface.");

        XFree(vi);

        XDestroyWindow(X11->display, d->window);

        return;

    }

    EGLint contextAttribs[] = {

#ifdef QT_OPENGL_ES_2

        EGL_CONTEXT_CLIENT_VERSION, 2,

#endif

        EGL_NONE

    };

    d->context = eglCreateContext(d->display, config, 0, contextAttribs);

    if (d->context != EGL_NO_CONTEXT

        && eglMakeCurrent(d->display, d->surface, d->surface, d->context))

    {

        d->initialized = true;

    } else {

        qWarning("QGLTemporaryContext: Error creating EGL context.");

        eglDestroySurface(d->display, d->surface);

        XDestroyWindow(X11->display, d->window);

    }

    XFree(vi);

}

QGLTemporaryContext::~QGLTemporaryContext()

{

    if (d->initialized) {

        eglMakeCurrent(d->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

        eglDestroyContext(d->display, d->context);

        eglDestroySurface(d->display, d->surface);

        XDestroyWindow(X11->display, d->window);

    }

}

bool QGLFormat::hasOpenGLOverlays()

{

    return false;

}

void qt_egl_add_platform_config(QEglProperties& props, QPaintDevice *device)

{

    if (device->devType() == QInternal::Image)

        props.setPixelFormat(static_cast<QImage *>(device)->format());

}

// Chooses the EGL config and creates the EGL context

bool QGLContext::chooseContext(const QGLContext* shareContext)

{

    Q_D(QGLContext);

    if (!device())

        return false;

    int devType = device()->devType();

    // Get the display and initialize it.

    if (d->eglContext == 0) {

        d->eglContext = new QEglContext();

        d->eglContext->setApi(QEgl::OpenGL);

        // Construct the configuration we need for this surface.

        QEglProperties configProps;

        qt_egl_set_format(configProps, devType, d->glFormat);

        qt_egl_add_platform_config(configProps, device());

        configProps.setRenderableType(QEgl::OpenGL);

#if We_have_an_EGL_library_which_bothers_to_check_EGL_BUFFER_SIZE

        if (device()->depth() == 16 && configProps.value(EGL_ALPHA_SIZE) <= 0) {

            qDebug("Setting EGL_BUFFER_SIZE to 16");

            configProps.setValue(EGL_BUFFER_SIZE, 16);

            configProps.setValue(EGL_ALPHA_SIZE, 0);

        }

        if (!d->eglContext->chooseConfig(configProps, QEgl::BestPixelFormat)) {

            delete d->eglContext;

            d->eglContext = 0;

            return false;

        }

#else

        QEgl::PixelFormatMatch matchType = QEgl::BestPixelFormat;

        if ((device()->depth() == 16) && configProps.value(EGL_ALPHA_SIZE) == 0) {

            configProps.setValue(EGL_RED_SIZE, 5);

            configProps.setValue(EGL_GREEN_SIZE, 6);

            configProps.setValue(EGL_BLUE_SIZE, 5);

            configProps.setValue(EGL_ALPHA_SIZE, 0);

            matchType = QEgl::ExactPixelFormat;

        }

        // Search for a matching configuration, reducing the complexity

        // each time until we get something that matches.

        if (!d->eglContext->chooseConfig(configProps, matchType)) {

            delete d->eglContext;

            d->eglContext = 0;

            return false;

        }

#endif

//        qDebug("QGLContext::chooseContext() - using EGL config %d:", d->eglContext->config());

//        qDebug() << QEglProperties(d->eglContext->config()).toString();

        // 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

    }

    // Inform the higher layers about the actual format properties.

    qt_egl_update_format(*(d->eglContext), d->glFormat);

    return true;

}

void QGLWidget::resizeEvent(QResizeEvent *)

{

    Q_D(QGLWidget);

    if (!isValid())

        return;

    makeCurrent();

    if (!d->glcx->initialized())

        glInit();

    resizeGL(width(), height());

    //handle overlay

}

const QGLContext* QGLWidget::overlayContext() const

{

    return 0;

}

void QGLWidget::makeOverlayCurrent()

{

    //handle overlay

}

void QGLWidget::updateOverlayGL()

{

    //handle overlay

}

//#define QT_DEBUG_X11_VISUAL_SELECTION 1

bool qt_egl_setup_x11_visual(XVisualInfo &vi, EGLDisplay display, EGLConfig config, const QX11Info &x11Info, bool useArgbVisual)

{

    bool foundVisualIsArgb = useArgbVisual;

#ifdef QT_DEBUG_X11_VISUAL_SELECTION

    qDebug("qt_egl_setup_x11_visual() - useArgbVisual=%d", useArgbVisual);

#endif

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

    EGLint eglConfigColorSize;

    eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &eglConfigColorSize);

    // Check to see if EGL is suggesting an appropriate visual id:

    EGLint nativeVisualId;

    eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &nativeVisualId);

    vi.visualid = nativeVisualId;

    if (vi.visualid) {

        // EGL has suggested a visual id, so get the rest of the visual info for that id:

        XVisualInfo *chosenVisualInfo;

        int matchingCount = 0;

        chosenVisualInfo = XGetVisualInfo(x11Info.display(), VisualIDMask, &vi, &matchingCount);

        if (chosenVisualInfo) {

#if !defined(QT_NO_XRENDER)

            if (useArgbVisual) {

                // Check to make sure the visual provided by EGL is ARGB

                XRenderPictFormat *format;

                format = XRenderFindVisualFormat(x11Info.display(), chosenVisualInfo->visual);

                if (format->type == PictTypeDirect && format->direct.alphaMask) {

#ifdef QT_DEBUG_X11_VISUAL_SELECTION

                    qDebug("Using ARGB X Visual ID (%d) provided by EGL", (int)vi.visualid);

#endif

                    foundVisualIsArgb = true;

                    vi = *chosenVisualInfo;

                }

                else {

                    qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this is not ARGB",

                             nativeVisualId, (int)config);

                    vi.visualid = 0;

                }

            } else

#endif

            {

                if (eglConfigColorSize == chosenVisualInfo->depth) {

#ifdef QT_DEBUG_X11_VISUAL_SELECTION

                    qDebug("Using opaque X Visual ID (%d) provided by EGL", (int)vi.visualid);

#endif

                    vi = *chosenVisualInfo;

                } else

                    qWarning("Warning: EGL suggested using X visual ID %d (%d bpp) for config %d (%d bpp), but the depths do not match!",

                             nativeVisualId, chosenVisualInfo->depth, (int)config, eglConfigColorSize);

            }

            XFree(chosenVisualInfo);

        }

        else {

            qWarning("Warning: EGL suggested using X visual ID %d for config %d, but this seems to be invalid!",

                     nativeVisualId, (int)config);

            vi.visualid = 0;

        }

    }

    // If EGL does not know the visual ID, so try to select an appropriate one ourselves, first

    // using XRender if we're supposed to have an alpha, then falling back to XGetVisualInfo

#if !defined(QT_NO_XRENDER)

    if (vi.visualid == 0 && useArgbVisual) {

        // Try to use XRender to find an ARGB visual we can use

        vi.screen  = x11Info.screen();

        vi.depth   = 32; //### We might at some point (soon) get ARGB4444

        vi.c_class = TrueColor;

        XVisualInfo *matchingVisuals;

        int matchingCount = 0;

        matchingVisuals = XGetVisualInfo(x11Info.display(),

                                         VisualScreenMask|VisualDepthMask|VisualClassMask,

                                         &vi, &matchingCount);

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

            XRenderPictFormat *format;

            format = XRenderFindVisualFormat(x11Info.display(), matchingVisuals[i].visual);

            if (format->type == PictTypeDirect && format->direct.alphaMask) {

                vi = matchingVisuals[i];

                foundVisualIsArgb = true;

#ifdef QT_DEBUG_X11_VISUAL_SELECTION

                qDebug("Using X Visual ID (%d) for ARGB visual as provided by XRender", (int)vi.visualid);

#endif

                break;

            }

        }

        XFree(matchingVisuals);

    }

#endif

    if (vi.visualid == 0) {

        EGLint depth;

        eglGetConfigAttrib(display, config, EGL_BUFFER_SIZE, &depth);

        int err;

        err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);

        if (err == 0) {

            qWarning("Warning: Can't find an X visual which matches the EGL config(%d)'s depth (%d)!",

                     (int)config, depth);

            depth = x11Info.depth();

            err = XMatchVisualInfo(x11Info.display(), x11Info.screen(), depth, TrueColor, &vi);

            if (err == 0) {

                qWarning("Error: Couldn't get any matching X visual!");

                return false;

            } else

                qWarning("         - Falling back to X11 suggested depth (%d)", depth);

        }

#ifdef QT_DEBUG_X11_VISUAL_SELECTION

        else

            qDebug("Using X Visual ID (%d) for EGL provided depth (%d)", (int)vi.visualid, depth);

#endif

        // Don't try to use ARGB now unless the visual is 32-bit - even then it might stil fail :-(

        if (useArgbVisual)

            foundVisualIsArgb = vi.depth == 32; //### We might at some point (soon) get ARGB4444

    }

#ifdef QT_DEBUG_X11_VISUAL_SELECTION

    qDebug("Visual Info:");

    qDebug("   bits_per_rgb=%d", vi.bits_per_rgb);

    qDebug("   red_mask=0x%x", vi.red_mask);

    qDebug("   green_mask=0x%x", vi.green_mask);

    qDebug("   blue_mask=0x%x", vi.blue_mask);

    qDebug("   colormap_size=%d", vi.colormap_size);

    qDebug("   c_class=%d", vi.c_class);

    qDebug("   depth=%d", vi.depth);

    qDebug("   screen=%d", vi.screen);

    qDebug("   visualid=%d", vi.visualid);

#endif

    return foundVisualIsArgb;

}

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;

    if (parentWidget()) {

        // force creation of delay-created widgets

        parentWidget()->winId();

        if (parentWidget()->x11Info().screen() != x11Info().screen())

            d_func()->xinfo = parentWidget()->d_func()->xinfo;

    }

    // If the application has set WA_TranslucentBackground and not explicitly set

    // the alpha buffer size to zero, modify the format so it have an alpha channel

    QGLFormat& fmt = d->glcx->d_func()->glFormat;

    const bool tryArgbVisual = testAttribute(Qt::WA_TranslucentBackground) || fmt.alpha();

    if (tryArgbVisual && fmt.alphaBufferSize() == -1)

        fmt.setAlphaBufferSize(1);

    bool createFailed = false;

    if (!d->glcx->isValid()) {

        // Create the QGLContext here, which in turn chooses the EGL config

        // and creates the EGL context:

        if (!d->glcx->create(shareContext ? shareContext : oldcx))

            createFailed = true;

    }

    if (createFailed) {

        if (deleteOldContext)

            delete oldcx;

        return;

    }

    if (d->glcx->windowCreated() || d->glcx->deviceIsPixmap()) {

        if (deleteOldContext)

            delete oldcx;

        return;

    }

    bool visible = isVisible();

    if (visible)

        hide();

    XVisualInfo vi;

    QEglContext *eglContext = d->glcx->d_func()->eglContext;

    bool usingArgbVisual = qt_egl_setup_x11_visual(vi, eglContext->display(), eglContext->config(),

                                                   x11Info(), tryArgbVisual);

    XSetWindowAttributes a;

    Window p = RootWindow(x11Info().display(), x11Info().screen());

    if (parentWidget())

        p = parentWidget()->winId();

    QColormap colmap = QColormap::instance(vi.screen);

    a.background_pixel = colmap.pixel(palette().color(backgroundRole()));

    a.border_pixel = colmap.pixel(Qt::black);

    unsigned int valueMask = CWBackPixel|CWBorderPixel;

    if (usingArgbVisual) {

        a.colormap = XCreateColormap(x11Info().display(), p, vi.visual, AllocNone);

        valueMask |= CWColormap;

    }

    Window w = XCreateWindow(x11Info().display(), p, x(), y(), width(), height(),

                             0, vi.depth, InputOutput, vi.visual, valueMask, &a);

    if (deleteOldContext)

        delete oldcx;

    oldcx = 0;

    create(w); // Create with the ID of the window we've just created

    // Create the EGL surface to draw into.

    QGLContextPrivate *ctxpriv = d->glcx->d_func();

    ctxpriv->eglSurface = ctxpriv->eglContext->createSurface(this);

    if (ctxpriv->eglSurface == EGL_NO_SURFACE) {

        delete ctxpriv->eglContext;

        ctxpriv->eglContext = 0;

        return;