qplatformwindowformat_qpa.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** 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, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qplatformwindowformat_qpa.h"

#include <QtCore/QDebug>

Q_GLOBAL_STATIC(QPlatformWindowFormat, q_platformwindow_default_format);

class QPlatformWindowFormatPrivate
{
public:
    QPlatformWindowFormatPrivate()
        : ref(1)
        , opts(QPlatformWindowFormat::DoubleBuffer | QPlatformWindowFormat::DepthBuffer
             | QPlatformWindowFormat::Rgba | QPlatformWindowFormat::DirectRendering
             | QPlatformWindowFormat::StencilBuffer | QPlatformWindowFormat::DeprecatedFunctions
             | QPlatformWindowFormat::HasWindowSurface)
        , depthSize(-1)
        , accumSize(-1)
        , stencilSize(-1)
        , redSize(-1)
        , greenSize(-1)
        , blueSize(-1)
        , alphaSize(-1)
        , numSamples(-1)
        , swapInterval(-1)
        , windowApi(QPlatformWindowFormat::Raster)
        , sharedContext(0)
    {
    }

    QPlatformWindowFormatPrivate(const QPlatformWindowFormatPrivate *other)
        : ref(1),
          opts(other->opts),
          depthSize(other->depthSize),
          accumSize(other->accumSize),
          stencilSize(other->stencilSize),
          redSize(other->redSize),
          greenSize(other->greenSize),
          blueSize(other->blueSize),
          alphaSize(other->alphaSize),
          numSamples(other->numSamples),
          swapInterval(other->swapInterval),
          windowApi(other->windowApi),
          sharedContext(other->sharedContext)
    {
    }
    QAtomicInt ref;
    QPlatformWindowFormat::FormatOptions opts;
    int depthSize;
    int accumSize;
    int stencilSize;
    int redSize;
    int greenSize;
    int blueSize;
    int alphaSize;
    int numSamples;
    int swapInterval;
    QPlatformWindowFormat::WindowApi windowApi;
    QPlatformGLContext *sharedContext;
};

QPlatformWindowFormat::QPlatformWindowFormat()
{
    d = new QPlatformWindowFormatPrivate;
}


QPlatformWindowFormat::QPlatformWindowFormat(QPlatformWindowFormat::FormatOptions options)
{
    d = new QPlatformWindowFormatPrivate;
    QPlatformWindowFormat::FormatOptions newOpts = options;
    d->opts = defaultFormat().d->opts;
    d->opts |= (newOpts & 0xffff);
    d->opts &= ~(newOpts >> 16);
}

void QPlatformWindowFormat::detach()
{
    if (d->ref != 1) {
        QPlatformWindowFormatPrivate *newd = new QPlatformWindowFormatPrivate(d);
        if (!d->ref.deref())
            delete d;
        d = newd;
    }
}

QPlatformWindowFormat::QPlatformWindowFormat(const QPlatformWindowFormat &other)
{
    d = other.d;
    d->ref.ref();
}

QPlatformWindowFormat &QPlatformWindowFormat::operator=(const QPlatformWindowFormat &other)
{
    if (d != other.d) {
        other.d->ref.ref();
        if (!d->ref.deref())
            delete d;
        d = other.d;
    }
    return *this;
}

QPlatformWindowFormat::~QPlatformWindowFormat()
{
    if (!d->ref.deref())
        delete d;
}

void QPlatformWindowFormat::setDoubleBuffer(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::DoubleBuffer : QPlatformWindowFormat::SingleBuffer);
}


void QPlatformWindowFormat::setDepth(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::DepthBuffer : QPlatformWindowFormat::NoDepthBuffer);
}


void QPlatformWindowFormat::setRgba(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::Rgba : QPlatformWindowFormat::ColorIndex);
}


void QPlatformWindowFormat::setAlpha(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::AlphaChannel : QPlatformWindowFormat::NoAlphaChannel);
}


void QPlatformWindowFormat::setAccum(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::AccumBuffer : QPlatformWindowFormat::NoAccumBuffer);
}


void QPlatformWindowFormat::setStencil(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::StencilBuffer: QPlatformWindowFormat::NoStencilBuffer);
}


void QPlatformWindowFormat::setStereo(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::StereoBuffers : QPlatformWindowFormat::NoStereoBuffers);
}


void QPlatformWindowFormat::setDirectRendering(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::DirectRendering : QPlatformWindowFormat::IndirectRendering);
}

void QPlatformWindowFormat::setSampleBuffers(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::SampleBuffers : QPlatformWindowFormat::NoSampleBuffers);
}

int QPlatformWindowFormat::samples() const
{
   return d->numSamples;
}

void QPlatformWindowFormat::setSamples(int numSamples)
{
    detach();
    if (numSamples < 0) {
        qWarning("QPlatformWindowFormat::setSamples: Cannot have negative number of samples per pixel %d", numSamples);
        return;
    }
    d->numSamples = numSamples;
    setSampleBuffers(numSamples > 0);
}

void QPlatformWindowFormat::setSwapInterval(int interval)
{
    detach();
    d->swapInterval = interval;
}

int QPlatformWindowFormat::swapInterval() const
{
    return d->swapInterval;
}

void QPlatformWindowFormat::setWindowApi(QPlatformWindowFormat::WindowApi api)
{
    detach();
    d->windowApi = api;
}

QPlatformWindowFormat::WindowApi QPlatformWindowFormat::windowApi() const
{
    return d->windowApi;
}

void QPlatformWindowFormat::setSharedContext(QPlatformGLContext *context)
{
    d->sharedContext = context;
}

QPlatformGLContext *QPlatformWindowFormat::sharedGLContext() const
{
    return d->sharedContext;
}

void QPlatformWindowFormat::setWindowSurface(bool enable)
{
    setOption(enable ? QPlatformWindowFormat::HasWindowSurface : QPlatformWindowFormat::NoWindowSurface);
}

void QPlatformWindowFormat::setOption(QPlatformWindowFormat::FormatOptions opt)
{
    detach();
    if (opt & 0xffff)
        d->opts |= opt;
    else
       d->opts &= ~(opt >> 16);
}



bool QPlatformWindowFormat::testOption(QPlatformWindowFormat::FormatOptions opt) const
{
    if (opt & 0xffff)
       return (d->opts & opt) != 0;
    else
       return (d->opts & (opt >> 16)) == 0;
}

void QPlatformWindowFormat::setDepthBufferSize(int size)
{
    detach();
    if (size < 0) {
        qWarning("QPlatformWindowFormat::setDepthBufferSize: Cannot set negative depth buffer size %d", size);
        return;
    }
    d->depthSize = size;
    setDepth(size > 0);
}

int QPlatformWindowFormat::depthBufferSize() const
{
   return d->depthSize;
}

void QPlatformWindowFormat::setRedBufferSize(int size)
{
    detach();
    if (size < 0) {
        qWarning("QPlatformWindowFormat::setRedBufferSize: Cannot set negative red buffer size %d", size);
        return;
    }
    d->redSize = size;
}

int QPlatformWindowFormat::redBufferSize() const
{
   return d->redSize;
}

void QPlatformWindowFormat::setGreenBufferSize(int size)
{
    detach();
    if (size < 0) {
        qWarning("QPlatformWindowFormat::setGreenBufferSize: Cannot set negative green buffer size %d", size);
        return;
    }
    d->greenSize = size;
}

int QPlatformWindowFormat::greenBufferSize() const
{
   return d->greenSize;
}

void QPlatformWindowFormat::setBlueBufferSize(int size)
{
    detach();
    if (size < 0) {
        qWarning("QPlatformWindowFormat::setBlueBufferSize: Cannot set negative blue buffer size %d", size);
        return;
    }
    d->blueSize = size;
}

int QPlatformWindowFormat::blueBufferSize() const
{
   return d->blueSize;
}

void QPlatformWindowFormat::setAlphaBufferSize(int size)
{
    detach();
    if (size < 0) {
        qWarning("QPlatformWindowFormat::setAlphaBufferSize: Cannot set negative alpha buffer size %d", size);
        return;
    }
    d->alphaSize = size;
    setAlpha(size > 0);
}

int QPlatformWindowFormat::alphaBufferSize() const
{
   return d->alphaSize;
}

void QPlatformWindowFormat::setAccumBufferSize(int size)
{
    detach();
    if (size < 0) {
        qWarning("QPlatformWindowFormat::setAccumBufferSize: Cannot set negative accumulate buffer size %d", size);
        return;
    }
    d->accumSize = size;
    setAccum(size > 0);
}

int QPlatformWindowFormat::accumBufferSize() const
{
   return d->accumSize;
}

void QPlatformWindowFormat::setStencilBufferSize(int size)
{
    detach();
    if (size < 0) {
        qWarning("QPlatformWindowFormat::setStencilBufferSize: Cannot set negative stencil buffer size %d", size);
        return;
    }
    d->stencilSize = size;
    setStencil(size > 0);
}

int QPlatformWindowFormat::stencilBufferSize() const
{
   return d->stencilSize;
}

QPlatformWindowFormat QPlatformWindowFormat::defaultFormat()
{
    return *q_platformwindow_default_format();
}

void QPlatformWindowFormat::setDefaultFormat(const QPlatformWindowFormat &f)
{
    *q_platformwindow_default_format() = f;
}


/*
    Returns the default QPlatformWindowFormat for overlay contexts.

    The default overlay format is:
    \list
    <li> \link setDoubleBuffer() Double buffer:\endlink Disabled.
    <li> \link setDepth() Depth buffer:\endlink Disabled.
    <li> \link setRgba() RGBA:\endlink Disabled (i.e., color index enabled).
    <li> \link setAlpha() Alpha channel:\endlink Disabled.
    <li> \link setAccum() Accumulator buffer:\endlink Disabled.
    <li> \link setStencil() Stencil buffer:\endlink Disabled.
    <li> \link setStereo() Stereo:\endlink Disabled.
    <li> \link setDirectRendering() Direct rendering:\endlink Enabled.
    <li> \link setSampleBuffers() Multisample buffers:\endlink Disabled.
    \endlist

    \sa setDefaultFormat()
*/

//QPlatformWindowFormat QPlatformWindowFormat::defaultOverlayFormat()
//{
//    return *defaultOverlayFormatInstance();
//}

//    Sets a new default QPlatformWindowFormat for overlay contexts to \a f. This
//    format is used whenever a QGLWidget is created with a format that
//    hasOverlay() enabled.

//    For example, to get a double buffered overlay context (if
//    available), use code like this:

//    \snippet doc/src/snippets/code/src_opengl_qgl.cpp 5

//    As usual, you can find out after widget creation whether the
//    underlying OpenGL system was able to provide the requested
//    specification:

//    \snippet doc/src/snippets/code/src_opengl_qgl.cpp 6

//    \sa defaultOverlayFormat()
//*/

//void QPlatformWindowFormat::setDefaultOverlayFormat(const QPlatformWindowFormat &f)
//{
//    QPlatformWindowFormat *defaultFormat = defaultOverlayFormatInstance();
//    *defaultFormat = f;
//    // Make sure the user doesn't request that the overlays themselves
//    // have overlays, since it is unlikely that the system supports
//    // infinitely many planes...
//    defaultFormat->setOverlay(false);
//}


bool operator==(const QPlatformWindowFormat& a, const QPlatformWindowFormat& b)
{
    return (a.d == b.d) || ((int) a.d->opts == (int) b.d->opts
        && a.d->alphaSize == b.d->alphaSize
        && a.d->accumSize == b.d->accumSize
        && a.d->stencilSize == b.d->stencilSize
        && a.d->depthSize == b.d->depthSize
        && a.d->redSize == b.d->redSize
        && a.d->greenSize == b.d->greenSize
        && a.d->blueSize == b.d->blueSize
        && a.d->numSamples == b.d->numSamples
        && a.d->swapInterval == b.d->swapInterval
        && a.d->windowApi == b.d->windowApi);
}


bool operator!=(const QPlatformWindowFormat& a, const QPlatformWindowFormat& b)
{
    return !(a == b);
}

#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug dbg, const QPlatformWindowFormat &f)
{
    const QPlatformWindowFormatPrivate * const d = f.d;

    dbg.nospace() << "QGLFormat("
                  << "options " << d->opts
                  << ", depthBufferSize " << d->depthSize
                  << ", accumBufferSize " << d->accumSize
                  << ", stencilBufferSize " << d->stencilSize
                  << ", redBufferSize " << d->redSize
                  << ", greenBufferSize " << d->greenSize
                  << ", blueBufferSize " << d->blueSize
                  << ", alphaBufferSize " << d->alphaSize
                  << ", samples " << d->numSamples
                  << ", swapInterval " << d->swapInterval
                  << ')';

    return dbg.space();
}
#endif