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

**

** 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 <QtGui/QApplication>

#include <QtGui/QColormap>

#include <QtGui/QDesktopWidget>

#include <QtGui/QPaintDevice>

#include <QtGui/QWidget>

#include <qglframebufferobject.h>

#include <qglpixelbuffer.h>

#include <qcolormap.h>

#include <qdesktopwidget.h>

#include "qdebug.h"

#ifdef Q_WS_X11

#include <private/qt_x11_p.h>

#include <qx11info_x11.h>

#ifndef QT_OPENGL_ES

#include <GL/glx.h>

#include <X11/Xlib.h>

#endif

#endif //Q_WS_X11

#include <private/qglextensions_p.h>

#include <private/qwindowsurface_gl_p.h>

#include <private/qgl_p.h>

#include <private/qglpixelbuffer_p.h>

#include <private/qgraphicssystem_gl_p.h>

#include <private/qpaintengineex_opengl2_p.h>

#include <private/qpixmapdata_gl_p.h>

#ifndef QT_OPENGL_ES_2

#include <private/qpaintengine_opengl_p.h>

#endif

#ifndef GLX_ARB_multisample

#define GLX_SAMPLE_BUFFERS_ARB  100000

#define GLX_SAMPLES_ARB         100001

#endif

#ifdef QT_OPENGL_ES_1_CL

#include "qgl_cl_p.h"

#endif

#ifdef QT_OPENGL_ES

#include <private/qegl_p.h>

#endif

QT_BEGIN_NAMESPACE

//

// QGLGraphicsSystem

//

#ifdef Q_WS_WIN

extern Q_GUI_EXPORT bool qt_win_owndc_required;

#endif

QGLGraphicsSystem::QGLGraphicsSystem()

    : QGraphicsSystem()

{

#if defined(Q_WS_X11) && !defined(QT_OPENGL_ES)

    // only override the system defaults if the user hasn't already

    // picked a visual

    if (X11->visual == 0 && X11->visual_id == -1 && X11->visual_class == -1) {

        // find a double buffered, RGBA visual that supports OpenGL

        // and set that as the default visual for windows in Qt

        int i = 0;

        int spec[16];

        spec[i++] = GLX_RGBA;

        spec[i++] = GLX_DOUBLEBUFFER;

        if (!qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull()) {

            spec[i++] = GLX_DEPTH_SIZE;

            spec[i++] = 8;

            spec[i++] = GLX_STENCIL_SIZE;

            spec[i++] = 8;

            spec[i++] = GLX_SAMPLE_BUFFERS_ARB;

            spec[i++] = 1;

            spec[i++] = GLX_SAMPLES_ARB;

            spec[i++] = 4;

        }

        spec[i++] = XNone;

        XVisualInfo *vi = glXChooseVisual(X11->display, X11->defaultScreen, spec);

        if (vi) {

            X11->visual_id = vi->visualid;

            X11->visual_class = vi->c_class;

            QGLFormat format;

            int res;

            glXGetConfig(X11->display, vi, GLX_LEVEL, &res);

            format.setPlane(res);

            glXGetConfig(X11->display, vi, GLX_DOUBLEBUFFER, &res);

            format.setDoubleBuffer(res);

            glXGetConfig(X11->display, vi, GLX_DEPTH_SIZE, &res);

            format.setDepth(res);

            if (format.depth())

                format.setDepthBufferSize(res);

            glXGetConfig(X11->display, vi, GLX_RGBA, &res);

            format.setRgba(res);

            glXGetConfig(X11->display, vi, GLX_RED_SIZE, &res);

            format.setRedBufferSize(res);

            glXGetConfig(X11->display, vi, GLX_GREEN_SIZE, &res);

            format.setGreenBufferSize(res);

            glXGetConfig(X11->display, vi, GLX_BLUE_SIZE, &res);

            format.setBlueBufferSize(res);

            glXGetConfig(X11->display, vi, GLX_ALPHA_SIZE, &res);

            format.setAlpha(res);

            if (format.alpha())

                format.setAlphaBufferSize(res);

            glXGetConfig(X11->display, vi, GLX_ACCUM_RED_SIZE, &res);

            format.setAccum(res);

            if (format.accum())

                format.setAccumBufferSize(res);

            glXGetConfig(X11->display, vi, GLX_STENCIL_SIZE, &res);

            format.setStencil(res);

            if (format.stencil())

                format.setStencilBufferSize(res);

            glXGetConfig(X11->display, vi, GLX_STEREO, &res);

            format.setStereo(res);

            glXGetConfig(X11->display, vi, GLX_SAMPLE_BUFFERS_ARB, &res);

            format.setSampleBuffers(res);

            if (format.sampleBuffers()) {

                glXGetConfig(X11->display, vi, GLX_SAMPLES_ARB, &res);

                format.setSamples(res);

            }

            QGLWindowSurface::surfaceFormat = format;

            XFree(vi);

            printf("using visual class %x, id %x\n", X11->visual_class, X11->visual_id);

        }

    }

#elif defined(Q_WS_WIN)

    QGLWindowSurface::surfaceFormat.setDoubleBuffer(true);

    qt_win_owndc_required = true;

#endif

}

//

// QGLWindowSurface

//

class QGLGlobalShareWidget

{

public:

    QGLGlobalShareWidget() : widget(0), initializing(false) {}

    QGLWidget *shareWidget() {

        if (!initializing && !widget && !cleanedUp) {

            initializing = true;

            widget = new QGLWidget;

            initializing = false;

        }

        return widget;

    }

    void cleanup() {

        QGLWidget *w = widget;

        cleanedUp = true;

        widget = 0;

        delete w;

    }

    static bool cleanedUp;

private:

    QGLWidget *widget;

    bool initializing;

};

bool QGLGlobalShareWidget::cleanedUp = false;

static void qt_cleanup_gl_share_widget();

Q_GLOBAL_STATIC_WITH_INITIALIZER(QGLGlobalShareWidget, _qt_gl_share_widget,

                                 {

                                     qAddPostRoutine(qt_cleanup_gl_share_widget);

                                 })

static void qt_cleanup_gl_share_widget()

{

    _qt_gl_share_widget()->cleanup();

}

QGLWidget* qt_gl_share_widget()

{

    if (QGLGlobalShareWidget::cleanedUp)

        return 0;

    return _qt_gl_share_widget()->shareWidget();

}

struct QGLWindowSurfacePrivate

{

    QGLFramebufferObject *fbo;

    QGLPixelBuffer *pb;

    GLuint tex_id;

    GLuint pb_tex_id;

    int tried_fbo : 1;

    int tried_pb : 1;

    int destructive_swap_buffers : 1;

    int geometry_updated : 1;

    QGLContext *ctx;

    QList<QGLContext **> contexts;

    QRegion paintedRegion;

    QSize size;

    QList<QImage> buffers;

    QGLWindowSurfaceGLPaintDevice glDevice;

    QGLWindowSurface* q_ptr;

};

QGLFormat QGLWindowSurface::surfaceFormat;

void QGLWindowSurfaceGLPaintDevice::endPaint()

{

    glFlush();

    QGLPaintDevice::endPaint();

}

QSize QGLWindowSurfaceGLPaintDevice::size() const

{

    return d->size;

}

QGLContext* QGLWindowSurfaceGLPaintDevice::context() const

{

    return d->ctx;

}

int QGLWindowSurfaceGLPaintDevice::metric(PaintDeviceMetric m) const

{

    return qt_paint_device_metric(d->q_ptr->window(), m);

}

QPaintEngine *QGLWindowSurfaceGLPaintDevice::paintEngine() const

{

    return qt_qgl_paint_engine();

}

QGLWindowSurface::QGLWindowSurface(QWidget *window)

    : QWindowSurface(window), d_ptr(new QGLWindowSurfacePrivate)

{

    Q_ASSERT(window->isTopLevel());

    QGLExtensions::init();

    d_ptr->pb = 0;

    d_ptr->fbo = 0;

    d_ptr->ctx = 0;

#if defined (QT_OPENGL_ES_2)

    d_ptr->tried_fbo = true;

    d_ptr->tried_pb = true;

#else

    d_ptr->tried_fbo = false;

    d_ptr->tried_pb = false;

#endif

    d_ptr->destructive_swap_buffers = qgetenv("QT_GL_SWAPBUFFER_PRESERVE").isNull();

    d_ptr->glDevice.d = d_ptr;

    d_ptr->q_ptr = this;

    d_ptr->geometry_updated = false;

}

QGLWindowSurface::~QGLWindowSurface()

{

    if (d_ptr->ctx)

        glDeleteTextures(1, &d_ptr->tex_id);

    foreach(QGLContext **ctx, d_ptr->contexts) {

        delete *ctx;

        *ctx = 0;

    }

    delete d_ptr->pb;

    delete d_ptr->fbo;

    delete d_ptr;

}

void QGLWindowSurface::deleted(QObject *object)

{

    // Make sure that the fbo is destroyed before destroying its context.

    delete d_ptr->fbo;

    d_ptr->fbo = 0;

    QWidget *widget = qobject_cast<QWidget *>(object);

    if (widget) {

        QWidgetPrivate *widgetPrivate = widget->d_func();

        if (widgetPrivate->extraData()) {

            union { QGLContext **ctxPtr; void **voidPtr; };

            voidPtr = &widgetPrivate->extraData()->glContext;

            int index = d_ptr->contexts.indexOf(ctxPtr);

            if (index != -1) {

                delete *ctxPtr;

                *ctxPtr = 0;

                d_ptr->contexts.removeAt(index);

            }

        }

    }

}

void QGLWindowSurface::hijackWindow(QWidget *widget)

{

    QWidgetPrivate *widgetPrivate = widget->d_func();

    widgetPrivate->createExtra();

    if (widgetPrivate->extraData()->glContext)

        return;

    QGLContext *ctx = new QGLContext(surfaceFormat, widget);

    ctx->create(qt_gl_share_widget()->context());

#if defined(Q_WS_X11) && defined(QT_OPENGL_ES)

    // Create the EGL surface to draw into.  QGLContext::chooseContext()

    // does not do this for X11/EGL, but does do it for other platforms.

    // This probably belongs in qgl_x11egl.cpp.

    QGLContextPrivate *ctxpriv = ctx->d_func();

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

    if (ctxpriv->eglSurface == EGL_NO_SURFACE) {

        qWarning() << "hijackWindow() could not create EGL surface";

    }

#endif

    widgetPrivate->extraData()->glContext = ctx;

    union { QGLContext **ctxPtr; void **voidPtr; };

    voidPtr = &widgetPrivate->extraData()->glContext;

    d_ptr->contexts << ctxPtr;

    qDebug() << "hijackWindow() context created for" << widget << d_ptr->contexts.size();

}

QGLContext *QGLWindowSurface::context() const

{

    return d_ptr->ctx;

}

QPaintDevice *QGLWindowSurface::paintDevice()

{

    updateGeometry();

    if (d_ptr->pb)

        return d_ptr->pb;

    if (d_ptr->ctx)

        return &d_ptr->glDevice;

    QGLContext *ctx = reinterpret_cast<QGLContext *>(window()->d_func()->extraData()->glContext);

    ctx->makeCurrent();

    return d_ptr->fbo;

}

static void drawTexture(const QRectF &rect, GLuint tex_id, const QSize &texSize, const QRectF &src = QRectF());

void QGLWindowSurface::beginPaint(const QRegion &)

{

}

void QGLWindowSurface::endPaint(const QRegion &rgn)

{

    if (context())

        d_ptr->paintedRegion |= rgn;

    d_ptr->buffers.clear();

}

void QGLWindowSurface::flush(QWidget *widget, const QRegion &rgn, const QPoint &offset)

{

    if (context() && widget != window()) {

        qWarning("No native child widget support in GL window surface without FBOs or pixel buffers");

        return;

    }

    //### Find out why d_ptr->geometry_updated isn't always false.

    // flush() should not be called when d_ptr->geometry_updated is true. It assumes that either

    // d_ptr->fbo or d_ptr->pb is allocated and has the correct size.

    if (d_ptr->geometry_updated)

        return;

    QWidget *parent = widget->internalWinId() ? widget : widget->nativeParentWidget();

    Q_ASSERT(parent);

    if (!geometry().isValid())

        return;

    // Needed to support native child-widgets...

    hijackWindow(parent);

    QRect br = rgn.boundingRect().translated(offset);

    br = br.intersected(window()->rect());

    QPoint wOffset = qt_qwidget_data(parent)->wrect.topLeft();

    QRect rect = br.translated(-offset - wOffset);

    const GLenum target = GL_TEXTURE_2D;

    Q_UNUSED(target);

    if (context()) {

        context()->makeCurrent();

        if (context()->format().doubleBuffer()) {

#if !defined(QT_OPENGL_ES_2)

            if (d_ptr->destructive_swap_buffers) {

                glBindTexture(target, d_ptr->tex_id);

                QVector<QRect> rects = d_ptr->paintedRegion.rects();

                for (int i = 0; i < rects.size(); ++i) {

                    QRect br = rects.at(i);

                    if (br.isEmpty())

                        continue;

                    const uint bottom = window()->height() - (br.y() + br.height());

                    glCopyTexSubImage2D(target, 0, br.x(), bottom, br.x(), bottom, br.width(), br.height());

                }

                glBindTexture(target, 0);

                QRegion dirtyRegion = QRegion(window()->rect()) - d_ptr->paintedRegion;

                if (!dirtyRegion.isEmpty()) {

                    glMatrixMode(GL_MODELVIEW);

                    glLoadIdentity();

                    glMatrixMode(GL_PROJECTION);

                    glLoadIdentity();

#ifndef QT_OPENGL_ES

                    glOrtho(0, window()->width(), window()->height(), 0, -999999, 999999);

#else

                    glOrthof(0, window()->width(), window()->height(), 0, -999999, 999999);

#endif

                    glViewport(0, 0, window()->width(), window()->height());

                    QVector<QRect> rects = dirtyRegion.rects();

                    glColor4f(1, 1, 1, 1);

                    for (int i = 0; i < rects.size(); ++i) {

                        QRect rect = rects.at(i);

                        if (rect.isEmpty())

                            continue;

                        drawTexture(rect, d_ptr->tex_id, window()->size(), rect);

                    }

                }

            }

#endif

            d_ptr->paintedRegion = QRegion();

            context()->swapBuffers();

        } else {

            glFlush();

        }

        return;

    }

    QGLContext *previous_ctx = const_cast<QGLContext *>(QGLContext::currentContext());

    QGLContext *ctx = reinterpret_cast<QGLContext *>(parent->d_func()->extraData()->glContext);

    // QPainter::end() should have unbound the fbo, otherwise something is very wrong...

    Q_ASSERT(!d_ptr->fbo || !d_ptr->fbo->isBound());

    if (ctx != previous_ctx) {

        ctx->makeCurrent();

    }

    QSize size = widget->rect().size();

    if (d_ptr->destructive_swap_buffers && ctx->format().doubleBuffer()) {

        rect = parent->rect();

        br = rect.translated(wOffset + offset);

        size = parent->size();

    }

    glDisable(GL_SCISSOR_TEST);

    if (d_ptr->fbo && (QGLExtensions::glExtensions & QGLExtensions::FramebufferBlit)) {

        const int h = d_ptr->fbo->height();

        const int sx0 = br.left();

        const int sx1 = br.left() + br.width();