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

**

** 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 plugins 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 "qdirectfbscreen.h"

#include "qdirectfbwindowsurface.h"

#include "qdirectfbpixmap.h"

#include "qdirectfbmouse.h"

#include "qdirectfbkeyboard.h"

#include <QtGui/qwsdisplay_qws.h>

#include <QtGui/qcolor.h>

#include <QtGui/qapplication.h>

#include <QtGui/qwindowsystem_qws.h>

#include <QtGui/private/qgraphicssystem_qws_p.h>

#include <QtGui/private/qwssignalhandler_p.h>

#include <QtCore/qvarlengtharray.h>

#include <QtCore/qvector.h>

#include <QtCore/qrect.h>

#ifndef QT_NO_QWS_DIRECTFB

QT_BEGIN_NAMESPACE

class QDirectFBScreenPrivate : public QObject, public QWSGraphicsSystem

{

    Q_OBJECT

public:

    QDirectFBScreenPrivate(QDirectFBScreen *qptr);

    ~QDirectFBScreenPrivate();

    void setFlipFlags(const QStringList &args);

    QPixmapData *createPixmapData(QPixmapData::PixelType type) const;

public slots:

#ifdef QT_DIRECTFB_WM

    void onWindowEvent(QWSWindow *window, QWSServer::WindowEvent event);

#endif

public:

    IDirectFB *dfb;

    DFBSurfaceFlipFlags flipFlags;

    QDirectFBScreen::DirectFBFlags directFBFlags;

    QImage::Format alphaPixmapFormat;

    IDirectFBScreen *dfbScreen;

#ifdef QT_NO_DIRECTFB_WM

    IDirectFBSurface *primarySurface;

    QColor backgroundColor;

#endif

#ifndef QT_NO_DIRECTFB_LAYER

    IDirectFBDisplayLayer *dfbLayer;

#endif

    QSet<IDirectFBSurface*> allocatedSurfaces;

#ifndef QT_NO_DIRECTFB_MOUSE

    QDirectFBMouseHandler *mouse;

#endif

#ifndef QT_NO_DIRECTFB_KEYBOARD

    QDirectFBKeyboardHandler *keyboard;

#endif

#if defined QT_DIRECTFB_IMAGEPROVIDER && defined QT_DIRECTFB_IMAGEPROVIDER_KEEPALIVE

    IDirectFBImageProvider *imageProvider;

#endif

    IDirectFBSurface *cursorSurface;

    qint64 cursorImageKey;

    QDirectFBScreen *q;

    static QDirectFBScreen *instance;

};

QDirectFBScreen *QDirectFBScreenPrivate::instance = 0;

QDirectFBScreenPrivate::QDirectFBScreenPrivate(QDirectFBScreen *qptr)

    : QWSGraphicsSystem(qptr), dfb(0), flipFlags(DSFLIP_NONE),

      directFBFlags(QDirectFBScreen::NoFlags), alphaPixmapFormat(QImage::Format_Invalid),

      dfbScreen(0)

#ifdef QT_NO_DIRECTFB_WM

    , primarySurface(0)

#endif

#ifndef QT_NO_DIRECTFB_LAYER

    , dfbLayer(0)

#endif

#ifndef QT_NO_DIRECTFB_MOUSE

    , mouse(0)

#endif

#ifndef QT_NO_DIRECTFB_KEYBOARD

    , keyboard(0)

#endif

#if defined QT_DIRECTFB_IMAGEPROVIDER && defined QT_DIRECTFB_IMAGEPROVIDER_KEEPALIVE

    , imageProvider(0)

#endif

    , cursorSurface(0)

    , cursorImageKey(0)

    , q(qptr)

{

#ifndef QT_NO_QWS_SIGNALHANDLER

    QWSSignalHandler::instance()->addObject(this);

#endif

#ifdef QT_DIRECTFB_WM

    connect(QWSServer::instance(), SIGNAL(windowEvent(QWSWindow*,QWSServer::WindowEvent)),

            this, SLOT(onWindowEvent(QWSWindow*,QWSServer::WindowEvent)));

#endif

}

QDirectFBScreenPrivate::~QDirectFBScreenPrivate()

{

#ifndef QT_NO_DIRECTFB_MOUSE

    delete mouse;

#endif

#ifndef QT_NO_DIRECTFB_KEYBOARD

    delete keyboard;

#endif

#if defined QT_DIRECTFB_IMAGEPROVIDER_KEEPALIVE

    if (imageProvider)

        imageProvider->Release(imageProvider);

#endif

    for (QSet<IDirectFBSurface*>::const_iterator it = allocatedSurfaces.begin(); it != allocatedSurfaces.end(); ++it) {

        (*it)->Release(*it);

    }

#ifdef QT_NO_DIRECTFB_WM

    if (primarySurface)

        primarySurface->Release(primarySurface);

#endif

#ifndef QT_NO_DIRECTFB_LAYER

    if (dfbLayer)

        dfbLayer->Release(dfbLayer);

#endif

    if (dfbScreen)

        dfbScreen->Release(dfbScreen);

    if (dfb)

        dfb->Release(dfb);

}

IDirectFBSurface *QDirectFBScreen::createDFBSurface(const QImage &image, QImage::Format format, SurfaceCreationOptions options, DFBResult *resultPtr)

{

    if (image.isNull()) // assert?

        return 0;

    if (QDirectFBScreen::getSurfacePixelFormat(format) == DSPF_UNKNOWN) {

        format = QDirectFBPixmapData::hasAlphaChannel(image) ? d_ptr->alphaPixmapFormat : pixelFormat();

    }

    if (image.format() != format) {

        return createDFBSurface(image.convertToFormat(format), format, options | NoPreallocated, resultPtr);

    }

    DFBSurfaceDescription description;

    memset(&description, 0, sizeof(DFBSurfaceDescription));

    description.width = image.width();

    description.height = image.height();

    description.flags = DSDESC_WIDTH|DSDESC_HEIGHT|DSDESC_PIXELFORMAT;

    initSurfaceDescriptionPixelFormat(&description, format);

    bool doMemCopy = true;

#ifdef QT_DIRECTFB_PREALLOCATED

    if (!(options & NoPreallocated)) {

        doMemCopy = false;

        description.flags |= DSDESC_PREALLOCATED;

        description.preallocated[0].data = const_cast<uchar*>(image.bits());

        description.preallocated[0].pitch = image.bytesPerLine();

        description.preallocated[1].data = 0;

        description.preallocated[1].pitch = 0;

    }

#endif

    DFBResult result;

    IDirectFBSurface *surface = createDFBSurface(description, options, &result);

    if (resultPtr)

        *resultPtr = result;

    if (!surface) {

        DirectFBError("Couldn't create surface createDFBSurface(QImage, QImage::Format, SurfaceCreationOptions)", result);

        return 0;

    }

    if (doMemCopy) {

        int bplDFB;

        uchar *mem = QDirectFBScreen::lockSurface(surface, DSLF_WRITE, &bplDFB);

        if (mem) {

            const int height = image.height();

            const int bplQt = image.bytesPerLine();

            if (bplQt == bplDFB && bplQt == (image.width() * image.depth() / 8)) {

                memcpy(mem, image.bits(), image.byteCount());

            } else {

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

                    memcpy(mem, image.scanLine(i), bplQt);

                    mem += bplDFB;

                }

            }

            surface->Unlock(surface);

        }

    }

#ifdef QT_DIRECTFB_PALETTE

    if (image.colorCount() != 0 && surface)

        QDirectFBScreen::setSurfaceColorTable(surface, image);

#endif

    return surface;

}

IDirectFBSurface *QDirectFBScreen::copyDFBSurface(IDirectFBSurface *src,

                                                  QImage::Format format,

                                                  SurfaceCreationOptions options,

                                                  DFBResult *result)

{

    Q_ASSERT(src);

    QSize size;

    src->GetSize(src, &size.rwidth(), &size.rheight());

    IDirectFBSurface *surface = createDFBSurface(size, format, options, result);

    DFBSurfaceBlittingFlags flags = QDirectFBScreen::hasAlphaChannel(surface)

                                    ? DSBLIT_BLEND_ALPHACHANNEL

                                    : DSBLIT_NOFX;

    if (flags & DSBLIT_BLEND_ALPHACHANNEL)

        surface->Clear(surface, 0, 0, 0, 0);

    surface->SetBlittingFlags(surface, flags);

    surface->Blit(surface, src, 0, 0, 0);

#if (Q_DIRECTFB_VERSION >= 0x010000)

    surface->ReleaseSource(surface);

#endif

    return surface;

}

IDirectFBSurface *QDirectFBScreen::createDFBSurface(const QSize &size,

                                                    QImage::Format format,

                                                    SurfaceCreationOptions options,

                                                    DFBResult *result)

{

    DFBSurfaceDescription desc;

    memset(&desc, 0, sizeof(DFBSurfaceDescription));

    desc.flags |= DSDESC_WIDTH|DSDESC_HEIGHT;

    if (!QDirectFBScreen::initSurfaceDescriptionPixelFormat(&desc, format))

        return 0;

    desc.width = size.width();

    desc.height = size.height();

    return createDFBSurface(desc, options, result);

}

IDirectFBSurface *QDirectFBScreen::createDFBSurface(DFBSurfaceDescription desc, SurfaceCreationOptions options, DFBResult *resultPtr)

{

    DFBResult tmp;

    DFBResult &result = (resultPtr ? *resultPtr : tmp);

    result = DFB_OK;

    IDirectFBSurface *newSurface = 0;

    if (!d_ptr->dfb) {

        qWarning("QDirectFBScreen::createDFBSurface() - not connected");

        return 0;

    }

    if (d_ptr->directFBFlags & VideoOnly

        && !(desc.flags & DSDESC_PREALLOCATED)

        && (!(desc.flags & DSDESC_CAPS) || !(desc.caps & DSCAPS_SYSTEMONLY))) {

        // Add the video only capability. This means the surface will be created in video ram

        if (!(desc.flags & DSDESC_CAPS)) {

            desc.caps = DSCAPS_VIDEOONLY;

            desc.flags |= DSDESC_CAPS;

        } else {

            desc.caps |= DSCAPS_VIDEOONLY;

        }

        result = d_ptr->dfb->CreateSurface(d_ptr->dfb, &desc, &newSurface);

        if (result != DFB_OK

#ifdef QT_NO_DEBUG

            && (desc.flags & DSDESC_CAPS) && (desc.caps & DSCAPS_PRIMARY)

#endif

            ) {

            qWarning("QDirectFBScreen::createDFBSurface() Failed to create surface in video memory!\n"

                     "   Flags %0x Caps %0x width %d height %d pixelformat %0x %d preallocated %p %d\n%s",

                     desc.flags, desc.caps, desc.width, desc.height,

                     desc.pixelformat, DFB_PIXELFORMAT_INDEX(desc.pixelformat),

                     desc.preallocated[0].data, desc.preallocated[0].pitch,

                     DirectFBErrorString(result));

        }

        desc.caps &= ~DSCAPS_VIDEOONLY;

    }

    if (d_ptr->directFBFlags & SystemOnly)

        desc.caps |= DSCAPS_SYSTEMONLY;

    if (!newSurface)

        result = d_ptr->dfb->CreateSurface(d_ptr->dfb, &desc, &newSurface);

    if (result != DFB_OK) {

        qWarning("QDirectFBScreen::createDFBSurface() Failed!\n"

                 "   Flags %0x Caps %0x width %d height %d pixelformat %0x %d preallocated %p %d\n%s",

                 desc.flags, desc.caps, desc.width, desc.height,

                 desc.pixelformat, DFB_PIXELFORMAT_INDEX(desc.pixelformat),

                 desc.preallocated[0].data, desc.preallocated[0].pitch,

                 DirectFBErrorString(result));

        return 0;

    }

    Q_ASSERT(newSurface);

    if (options & TrackSurface) {

        d_ptr->allocatedSurfaces.insert(newSurface);

    }

    return newSurface;

}

#ifdef QT_DIRECTFB_SUBSURFACE

IDirectFBSurface *QDirectFBScreen::getSubSurface(IDirectFBSurface *surface,

                                                 const QRect &rect,

                                                 SurfaceCreationOptions options,

                                                 DFBResult *resultPtr)

{

    Q_ASSERT(!(options & NoPreallocated));

    Q_ASSERT(surface);

    DFBResult res;

    DFBResult &result = (resultPtr ? *resultPtr : res);

    IDirectFBSurface *subSurface = 0;

    if (rect.isNull()) {

        result = surface->GetSubSurface(surface, 0, &subSurface);

    } else {

        const DFBRectangle subRect = { rect.x(), rect.y(), rect.width(), rect.height() };

        result = surface->GetSubSurface(surface, &subRect, &subSurface);

    }

    if (result != DFB_OK) {

        DirectFBError("Can't get sub surface", result);

    } else if (options & TrackSurface) {

        d_ptr->allocatedSurfaces.insert(subSurface);

    }

    return subSurface;

}

#endif

void QDirectFBScreen::releaseDFBSurface(IDirectFBSurface *surface)

{

    Q_ASSERT(QDirectFBScreen::instance());

    Q_ASSERT(surface);

    surface->Release(surface);

    if (!d_ptr->allocatedSurfaces.remove(surface))

        qWarning("QDirectFBScreen::releaseDFBSurface() - %p not in list", surface);

    //qDebug("Released surface at %p. New count = %d", surface, d_ptr->allocatedSurfaces.count());

}

QDirectFBScreen::DirectFBFlags QDirectFBScreen::directFBFlags() const

{

    return d_ptr->directFBFlags;

}

IDirectFB *QDirectFBScreen::dfb()

{

    return d_ptr->dfb;

}

#ifdef QT_NO_DIRECTFB_WM

IDirectFBSurface *QDirectFBScreen::primarySurface()

{

    return d_ptr->primarySurface;

}

#endif

#ifndef QT_NO_DIRECTFB_LAYER

IDirectFBDisplayLayer *QDirectFBScreen::dfbDisplayLayer()

{

    return d_ptr->dfbLayer;

}

#endif

DFBSurfacePixelFormat QDirectFBScreen::getSurfacePixelFormat(QImage::Format format)

{

    switch (format) {

#ifndef QT_NO_DIRECTFB_PALETTE

    case QImage::Format_Indexed8:

        return DSPF_LUT8;

#endif

    case QImage::Format_RGB888:

        return DSPF_RGB24;

    case QImage::Format_ARGB4444_Premultiplied:

        return DSPF_ARGB4444;

#if (Q_DIRECTFB_VERSION >= 0x010100)

    case QImage::Format_RGB444:

        return DSPF_RGB444;

    case QImage::Format_RGB555:

        return DSPF_RGB555;

#endif

    case QImage::Format_RGB16:

        return DSPF_RGB16;

#if (Q_DIRECTFB_VERSION >= 0x010000)

    case QImage::Format_ARGB6666_Premultiplied:

        return DSPF_ARGB6666;

    case QImage::Format_RGB666:

        return DSPF_RGB18;

#endif

    case QImage::Format_RGB32:

        return DSPF_RGB32;

    case QImage::Format_ARGB32_Premultiplied:

    case QImage::Format_ARGB32:

        return DSPF_ARGB;

    default:

        return DSPF_UNKNOWN;

    };

}

QImage::Format QDirectFBScreen::getImageFormat(IDirectFBSurface *surface)

{

    DFBSurfacePixelFormat format;

    surface->GetPixelFormat(surface, &format);

    switch (format) {

    case DSPF_LUT8:

        return QImage::Format_Indexed8;

    case DSPF_RGB24:

        return QImage::Format_RGB888;

    case DSPF_ARGB4444:

        return QImage::Format_ARGB4444_Premultiplied;

#if (Q_DIRECTFB_VERSION >= 0x010100)

    case DSPF_RGB444:

        return QImage::Format_RGB444;

    case DSPF_RGB555:

#endif

    case DSPF_ARGB1555:

        return QImage::Format_RGB555;

    case DSPF_RGB16:

        return QImage::Format_RGB16;

#if (Q_DIRECTFB_VERSION >= 0x010000)

    case DSPF_ARGB6666:

        return QImage::Format_ARGB6666_Premultiplied;

    case DSPF_RGB18:

        return QImage::Format_RGB666;

#endif

    case DSPF_RGB32:

        return QImage::Format_RGB32;

    case DSPF_ARGB: {

        DFBSurfaceCapabilities caps;

        const DFBResult result = surface->GetCapabilities(surface, &caps);

        Q_ASSERT(result == DFB_OK);

        Q_UNUSED(result);

        return (caps & DSCAPS_PREMULTIPLIED

                ? QImage::Format_ARGB32_Premultiplied

                : QImage::Format_ARGB32); }

    default:

        break;

    }

    return QImage::Format_Invalid;

}

DFBSurfaceDescription QDirectFBScreen::getSurfaceDescription(const uint *buffer,

                                                             int length)

{

    DFBSurfaceDescription description;

    memset(&description, 0, sizeof(DFBSurfaceDescription));

    description.flags = DSDESC_CAPS|DSDESC_WIDTH|DSDESC_HEIGHT|DSDESC_PIXELFORMAT|DSDESC_PREALLOCATED;

    description.caps = DSCAPS_PREMULTIPLIED;

    description.width = length;

    description.height = 1;

    description.pixelformat = DSPF_ARGB;

    description.preallocated[0].data = (void*)buffer;

    description.preallocated[0].pitch = length * sizeof(uint);

    description.preallocated[1].data = 0;

    description.preallocated[1].pitch = 0;

    return description;

}

#ifndef QT_NO_DIRECTFB_PALETTE

void QDirectFBScreen::setSurfaceColorTable(IDirectFBSurface *surface,

                                           const QImage &image)

{

    if (!surface)

        return;

    const int numColors = image.colorCount();

    if (numColors == 0)

        return;

    QVarLengthArray<DFBColor, 256> colors(numColors);

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

        QRgb c = image.color(i);

        colors[i].a = qAlpha(c);

        colors[i].r = qRed(c);

        colors[i].g = qGreen(c);

        colors[i].b = qBlue(c);

    }

    IDirectFBPalette *palette;

    DFBResult result;

    result = surface->GetPalette(surface, &palette);

    if (result != DFB_OK) {

        DirectFBError("QDirectFBScreen::setSurfaceColorTable GetPalette",

                      result);

        return;

    }

    result = palette->SetEntries(palette, colors.data(), numColors, 0);

    if (result != DFB_OK) {

        DirectFBError("QDirectFBScreen::setSurfaceColorTable SetEntries",

                      result);

    }

    palette->Release(palette);

}