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

**

** 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"

// There are functions that are deprecated in 10.5, but really there's no way around them

// for Carbon, so just undefine them.

#undef DEPRECATED_ATTRIBUTE

#define DEPRECATED_ATTRIBUTE

#if defined(Q_WS_MAC)

#ifndef QT_MAC_USE_COCOA

#ifdef qDebug

#    undef qDebug

#    include <AGL/agl.h>

#    include <AGL/aglRenderers.h>

#    include <OpenGL/gl.h>

#    ifdef QT_NO_DEBUG

#        define qDebug qt_noop(),1?(void)0:qDebug

#    endif

#else

#    include <AGL/agl.h>

#    include <AGL/aglRenderers.h>

#    include <OpenGL/gl.h>

#endif

#else

#include <private/qcocoaview_mac_p.h>

#endif

#include <OpenGL/gl.h>

#include <CoreServices/CoreServices.h>

#include <private/qfont_p.h>

#include <private/qfontengine_p.h>

#include <private/qgl_p.h>

#include <private/qpaintengine_opengl_p.h>

#include <private/qt_mac_p.h>

#include <qpixmap.h>

#include <qtimer.h>

#include <qapplication.h>

#include <qstack.h>

#include <qdesktopwidget.h>

#include <qdebug.h>

QT_BEGIN_NAMESPACE

#ifdef QT_MAC_USE_COCOA

QT_END_NAMESPACE

QT_FORWARD_DECLARE_CLASS(QWidget)

QT_FORWARD_DECLARE_CLASS(QWidgetPrivate)

QT_FORWARD_DECLARE_CLASS(QGLWidgetPrivate)

QT_BEGIN_NAMESPACE

void *qt_current_nsopengl_context()

{

    return [NSOpenGLContext currentContext];

}

static GLint attribValue(NSOpenGLPixelFormat *fmt, NSOpenGLPixelFormatAttribute attrib)

{

    GLint res;

    [fmt getValues:&res forAttribute:attrib forVirtualScreen:0];

    return res;

}

static int def(int val, int defVal)

{

    return val != -1 ? val : defVal;

}

#else

QRegion qt_mac_get_widget_rgn(const QWidget *widget);

#endif

extern quint32 *qt_mac_pixmap_get_base(const QPixmap *);

extern int qt_mac_pixmap_get_bytes_per_line(const QPixmap *);

extern RgnHandle qt_mac_get_rgn(); //qregion_mac.cpp

extern void qt_mac_dispose_rgn(RgnHandle); //qregion_mac.cpp

extern QRegion qt_mac_convert_mac_region(RgnHandle); //qregion_mac.cpp

extern void qt_mac_to_pascal_string(QString s, Str255 str, TextEncoding encoding=0, int len=-1);  //qglobal.cpp

/*

    QGLTemporaryContext implementation

*/

class QGLTemporaryContextPrivate

{

public:

#ifndef QT_MAC_USE_COCOA

    AGLContext ctx;

#else

    NSOpenGLContext *ctx;

#endif

};

QGLTemporaryContext::QGLTemporaryContext(bool, QWidget *)

    : d(new QGLTemporaryContextPrivate)

{

    d->ctx = 0;

#ifndef QT_MAC_USE_COCOA

    GLint attribs[] = {AGL_RGBA, AGL_NONE};

    AGLPixelFormat fmt = aglChoosePixelFormat(0, 0, attribs);

    if (!fmt) {

        qDebug("QGLTemporaryContext: Couldn't find any RGB visuals");

        return;

    }

    d->ctx = aglCreateContext(fmt, 0);

    if (!d->ctx)

        qDebug("QGLTemporaryContext: Unable to create context");

    else

        aglSetCurrentContext(d->ctx);

    aglDestroyPixelFormat(fmt);

#else

    QMacCocoaAutoReleasePool pool;

    NSOpenGLPixelFormatAttribute attribs[] = { 0 };

    NSOpenGLPixelFormat *fmt = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];

    if (!fmt) {

        qWarning("QGLTemporaryContext: Cannot find any visuals");

        return;

    }

    d->ctx = [[NSOpenGLContext alloc] initWithFormat:fmt shareContext:0];

    if (!d->ctx)

        qWarning("QGLTemporaryContext: Cannot create context");

    else

        [d->ctx makeCurrentContext];

    [fmt release];

#endif

}

QGLTemporaryContext::~QGLTemporaryContext()

{

    if (d->ctx) {

#ifndef QT_MAC_USE_COCOA

        aglSetCurrentContext(0);

        aglDestroyContext(d->ctx);

#else

        [NSOpenGLContext clearCurrentContext];

        [d->ctx release];

#endif

    }

}

bool QGLFormat::hasOpenGL()

{

    return true;

}

bool QGLFormat::hasOpenGLOverlays()

{

    return false;

}

bool QGLContext::chooseContext(const QGLContext *shareContext)

{

    QMacCocoaAutoReleasePool pool;

    Q_D(QGLContext);

    d->cx = 0;

    d->vi = chooseMacVisual(0);

    if (!d->vi)

        return false;

#ifndef QT_MAC_USE_COCOA

    AGLPixelFormat fmt = (AGLPixelFormat)d->vi;

    GLint res;

    aglDescribePixelFormat(fmt, AGL_LEVEL, &res);

    d->glFormat.setPlane(res);

    if (deviceIsPixmap())

        res = 0;

    else

        aglDescribePixelFormat(fmt, AGL_DOUBLEBUFFER, &res);

    d->glFormat.setDoubleBuffer(res);

    aglDescribePixelFormat(fmt, AGL_DEPTH_SIZE, &res);

    d->glFormat.setDepth(res);

    if (d->glFormat.depth())

        d->glFormat.setDepthBufferSize(res);

    aglDescribePixelFormat(fmt, AGL_RGBA, &res);

    d->glFormat.setRgba(res);

    aglDescribePixelFormat(fmt, AGL_RED_SIZE, &res);

    d->glFormat.setRedBufferSize(res);

    aglDescribePixelFormat(fmt, AGL_GREEN_SIZE, &res);

    d->glFormat.setGreenBufferSize(res);

    aglDescribePixelFormat(fmt, AGL_BLUE_SIZE, &res);

    d->glFormat.setBlueBufferSize(res);

    aglDescribePixelFormat(fmt, AGL_ALPHA_SIZE, &res);

    d->glFormat.setAlpha(res);

    if (d->glFormat.alpha())

        d->glFormat.setAlphaBufferSize(res);

    aglDescribePixelFormat(fmt, AGL_ACCUM_RED_SIZE, &res);

    // Bug in Apple OpenGL (rdr://5015603), when we don't have an accumulation

    // buffer, it still claims that we have a 16-bit one (which is pretty rare).

    // So, we just assume we can never have a buffer that small.

    d->glFormat.setAccum(res > 5);

    if (d->glFormat.accum())

        d->glFormat.setAccumBufferSize(res);

    aglDescribePixelFormat(fmt, AGL_STENCIL_SIZE, &res);

    d->glFormat.setStencil(res);

    if (d->glFormat.stencil())

        d->glFormat.setStencilBufferSize(res);

    aglDescribePixelFormat(fmt, AGL_STEREO, &res);

    d->glFormat.setStereo(res);

    aglDescribePixelFormat(fmt, AGL_SAMPLE_BUFFERS_ARB, &res);

    d->glFormat.setSampleBuffers(res);

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

        aglDescribePixelFormat(fmt, AGL_SAMPLES_ARB, &res);

        d->glFormat.setSamples(res);

    }

#else

    NSOpenGLPixelFormat *fmt = static_cast<NSOpenGLPixelFormat *>(d->vi);

    d->glFormat = QGLFormat();

    // ### make sure to reset other options

    d->glFormat.setDoubleBuffer(attribValue(fmt, NSOpenGLPFADoubleBuffer));

    int depthSize = attribValue(fmt, NSOpenGLPFADepthSize);

    d->glFormat.setDepth(depthSize > 0);

    if (depthSize > 0)

        d->glFormat.setDepthBufferSize(depthSize);

    int alphaSize = attribValue(fmt, NSOpenGLPFAAlphaSize);

    d->glFormat.setAlpha(alphaSize > 0);

    if (alphaSize > 0)

        d->glFormat.setAlphaBufferSize(alphaSize);

    int accumSize = attribValue(fmt, NSOpenGLPFAAccumSize);

    d->glFormat.setAccum(accumSize > 0);

    if (accumSize > 0)

        d->glFormat.setAccumBufferSize(accumSize);

    int stencilSize = attribValue(fmt, NSOpenGLPFAStencilSize);

    d->glFormat.setStencil(stencilSize > 0);

    if (stencilSize > 0)

        d->glFormat.setStencilBufferSize(stencilSize);

    d->glFormat.setStereo(attribValue(fmt, NSOpenGLPFAStereo));

    int sampleBuffers = attribValue(fmt, NSOpenGLPFASampleBuffers);

    d->glFormat.setSampleBuffers(sampleBuffers);

    if (sampleBuffers > 0)

        d->glFormat.setSamples(attribValue(fmt, NSOpenGLPFASamples));

#endif

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

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

        shareContext = 0;

    }

    // sharing between rgba and color-index will give wrong colors

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

        shareContext = 0;

#ifndef QT_MAC_USE_COCOA

    AGLContext ctx = aglCreateContext(fmt, (AGLContext) (shareContext ? shareContext->d_func()->cx : 0));

#else

    NSOpenGLContext *ctx = [[NSOpenGLContext alloc] initWithFormat:fmt

        shareContext:(shareContext ? static_cast<NSOpenGLContext *>(shareContext->d_func()->cx)

                                   : 0)];

#endif

    if (!ctx) {

#ifndef QT_MAC_USE_COCOA

        GLenum err = aglGetError();

        if (err == AGL_BAD_MATCH || err == AGL_BAD_CONTEXT) {

            if (shareContext && shareContext->d_func()->cx) {

                qWarning("QGLContext::chooseContext(): Context sharing mismatch!");

                if (!(ctx = aglCreateContext(fmt, 0)))

                    return false;

                shareContext = 0;

            }

        }

#else

        if (shareContext) {

            ctx = [[NSOpenGLContext alloc] initWithFormat:fmt shareContext:0];

            if (ctx) {

                qWarning("QGLContext::chooseContext: Context sharing mismatch");

                shareContext = 0;

            }

        }

#endif

        if (!ctx) {

            qWarning("QGLContext::chooseContext: Unable to create QGLContext");

            return false;

        }

    }

    d->cx = ctx;

    if (shareContext && shareContext->d_func()->cx) {

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

        d->sharing = true;

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

    }

    if (deviceIsPixmap())

        updatePaintDevice();

    // vblank syncing

    GLint interval = d->reqFormat.swapInterval();

    if (interval != -1) {

#ifndef QT_MAC_USE_COCOA

        aglSetInteger((AGLContext)d->cx, AGL_SWAP_INTERVAL, &interval);

        if (interval != 0)

            aglEnable((AGLContext)d->cx, AGL_SWAP_INTERVAL);

        else

            aglDisable((AGLContext)d->cx, AGL_SWAP_INTERVAL);

#else

        [ctx setValues:&interval forParameter:NSOpenGLCPSwapInterval];

#endif

    }

#ifndef QT_MAC_USE_COCOA

    aglGetInteger((AGLContext)d->cx, AGL_SWAP_INTERVAL, &interval);

#else

    [ctx getValues:&interval forParameter:NSOpenGLCPSwapInterval];

#endif

    d->glFormat.setSwapInterval(interval);

    return true;

}

void *QGLContextPrivate::tryFormat(const QGLFormat &format)

{

    static const int Max = 40;

#ifndef QT_MAC_USE_COCOA

    GLint attribs[Max], cnt = 0;

    bool device_is_pixmap = (paintDevice->devType() == QInternal::Pixmap);

    attribs[cnt++] = AGL_RGBA;

    attribs[cnt++] = AGL_BUFFER_SIZE;

    attribs[cnt++] = device_is_pixmap ? static_cast<QPixmap *>(paintDevice)->depth() : 32;

    attribs[cnt++] = AGL_LEVEL;

    attribs[cnt++] = format.plane();

    if (format.redBufferSize() != -1) {

        attribs[cnt++] = AGL_RED_SIZE;

        attribs[cnt++] = format.redBufferSize();

    }

    if (format.greenBufferSize() != -1) {

        attribs[cnt++] = AGL_GREEN_SIZE;

        attribs[cnt++] = format.greenBufferSize();

    }

    if (format.blueBufferSize() != -1) {

        attribs[cnt++] = AGL_BLUE_SIZE;

        attribs[cnt++] = format.blueBufferSize();

    }

    if (device_is_pixmap) {

        attribs[cnt++] = AGL_PIXEL_SIZE;

        attribs[cnt++] = static_cast<QPixmap *>(paintDevice)->depth();

        attribs[cnt++] = AGL_OFFSCREEN;

        if (!format.alpha()) {

            attribs[cnt++] = AGL_ALPHA_SIZE;

            attribs[cnt++] = 8;

        }

    } else {

        if (format.doubleBuffer())

            attribs[cnt++] = AGL_DOUBLEBUFFER;

    }

    if (format.stereo())

        attribs[cnt++] = AGL_STEREO;

    if (format.alpha()) {

        attribs[cnt++] = AGL_ALPHA_SIZE;

        attribs[cnt++] = format.alphaBufferSize() == -1 ? 8 : format.alphaBufferSize();

    }

    if (format.stencil()) {

        attribs[cnt++] = AGL_STENCIL_SIZE;

        attribs[cnt++] = format.stencilBufferSize() == -1 ? 8 : format.stencilBufferSize();

    }

    if (format.depth()) {

        attribs[cnt++] = AGL_DEPTH_SIZE;

        attribs[cnt++] = format.depthBufferSize() == -1 ? 32 : format.depthBufferSize();

    }

    if (format.accum()) {

        attribs[cnt++] = AGL_ACCUM_RED_SIZE;

        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();

        attribs[cnt++] = AGL_ACCUM_BLUE_SIZE;

        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();

        attribs[cnt++] = AGL_ACCUM_GREEN_SIZE;

        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();

        attribs[cnt++] = AGL_ACCUM_ALPHA_SIZE;

        attribs[cnt++] = format.accumBufferSize() == -1 ? 1 : format.accumBufferSize();

    }

    if (format.sampleBuffers()) {

        attribs[cnt++] = AGL_SAMPLE_BUFFERS_ARB;

        attribs[cnt++] = 1;

        attribs[cnt++] = AGL_SAMPLES_ARB;

        attribs[cnt++] = format.samples() == -1 ? 4 : format.samples();

    }

    attribs[cnt] = AGL_NONE;

    Q_ASSERT(cnt < Max);

    return aglChoosePixelFormat(0, 0, attribs);

#else

    NSOpenGLPixelFormatAttribute attribs[Max];

    int cnt = 0;

    int devType = paintDevice->devType();

    bool device_is_pixmap = (devType == QInternal::Pixmap);

    int depth = device_is_pixmap ? static_cast<QPixmap *>(paintDevice)->depth() : 32;

    attribs[cnt++] = NSOpenGLPFAColorSize;

    attribs[cnt++] = depth;

    if (device_is_pixmap) {

        attribs[cnt++] = NSOpenGLPFAOffScreen;

    } else {

        if (format.doubleBuffer())

            attribs[cnt++] = NSOpenGLPFADoubleBuffer;

    }

    if (glFormat.stereo())

        attribs[cnt++] = NSOpenGLPFAStereo;

    if (device_is_pixmap || format.alpha()) {

        attribs[cnt++] = NSOpenGLPFAAlphaSize;

        attribs[cnt++] = def(format.alphaBufferSize(), 8);

    }

    if (format.stencil()) {

        attribs[cnt++] = NSOpenGLPFAStencilSize;

        attribs[cnt++] = def(format.stencilBufferSize(), 8);

    }

    if (format.depth()) {

        attribs[cnt++] = NSOpenGLPFADepthSize;

        attribs[cnt++] = def(format.depthBufferSize(), 32);

    }

    if (format.accum()) {

        attribs[cnt++] = NSOpenGLPFAAccumSize;

        attribs[cnt++] = def(format.accumBufferSize(), 1);

    }

    if (format.sampleBuffers()) {

        attribs[cnt++] = NSOpenGLPFASampleBuffers;

        attribs[cnt++] = 1;

        attribs[cnt++] = NSOpenGLPFASamples;

        attribs[cnt++] = def(format.samples(), 4);

    }

    if (format.directRendering())

        attribs[cnt++] = NSOpenGLPFAAccelerated;

    if (devType == QInternal::Pbuffer)

        attribs[cnt++] = NSOpenGLPFAPixelBuffer;

    attribs[cnt] = 0;

    Q_ASSERT(cnt < Max);

    return [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];

#endif

}

void QGLContextPrivate::clearDrawable()

{

    [static_cast<NSOpenGLContext *>(cx) clearDrawable];

}

/*!

    \bold{Mac OS X only:} This virtual function tries to find a visual that

    matches the format, reducing the demands if the original request

    cannot be met.

    The algorithm for reducing the demands of the format is quite

    simple-minded, so override this method in your subclass if your

    application has spcific requirements on visual selection.

    The \a handle argument is always zero and is not used

    \sa chooseContext()

*/

void *QGLContext::chooseMacVisual(GDHandle /* handle */)

{

    Q_D(QGLContext);

    void *fmt = d->tryFormat(d->glFormat);

    if (!fmt && d->glFormat.stereo()) {

        d->glFormat.setStereo(false);

        fmt = d->tryFormat(d->glFormat);

    }

    if (!fmt && d->glFormat.sampleBuffers()) {

        d->glFormat.setSampleBuffers(false);

        fmt = d->tryFormat(d->glFormat);

    }

    if (!fmt)

        qWarning("QGLContext::chooseMacVisual: Unable to choose a pixel format");

    return fmt;

}

void QGLContext::reset()

{

    Q_D(QGLContext);

    if (!d->valid)

        return;

    d->cleanup();

    doneCurrent();

#ifndef QT_MAC_USE_COCOA

    if (d->cx)

        aglDestroyContext((AGLContext)d->cx);

#else