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

**

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

#ifndef QT_NO_QWS_DIRECTFB

#include "qdirectfbwindowsurface.h"

#include "qdirectfbscreen.h"

#include "qdirectfbpixmap.h"

#include <directfb.h>

#include <qtransform.h>

#include <qvarlengtharray.h>

#include <qcache.h>

#include <qmath.h>

#include <private/qpixmapdata_p.h>

#include <private/qpixmap_raster_p.h>

#include <private/qimagepixmapcleanuphooks_p.h>

QT_BEGIN_NAMESPACE

class SurfaceCache;

class QDirectFBPaintEnginePrivate : public QRasterPaintEnginePrivate

{

public:

    enum TransformationTypeFlags {

        Matrix_NegativeScale = 0x100,

        Matrix_RectsUnsupported = (QTransform::TxRotate|QTransform::TxShear|QTransform::TxProject),

        Matrix_BlitsUnsupported = (Matrix_NegativeScale|Matrix_RectsUnsupported)

    };

    enum CompositionModeStatus {

        PorterDuff_None = 0x0,

        PorterDuff_Supported = 0x1,

        PorterDuff_PremultiplyColors = 0x2,

        PorterDuff_AlwaysBlend = 0x4

    };

    enum ClipType {

        ClipUnset,

        NoClip,

        RectClip,

        RegionClip,

        ComplexClip

    };

    QDirectFBPaintEnginePrivate(QDirectFBPaintEngine *p);

    ~QDirectFBPaintEnginePrivate();

    inline void setTransform(const QTransform &transforma);

    inline void setPen(const QPen &pen);

    inline void setCompositionMode(QPainter::CompositionMode mode);

    inline void setRenderHints(QPainter::RenderHints hints);

    inline void setDFBColor(const QColor &color);

    inline void lock();

    inline void unlock();

    static inline void unlock(QDirectFBPaintDevice *device);

    inline bool isSimpleBrush(const QBrush &brush) const;

    void drawTiledPixmap(const QRectF &dest, const QPixmap &pixmap, const QPointF &pos);

    void blit(const QRectF &dest, IDirectFBSurface *surface, const QRectF &src);

    inline bool supportsStretchBlit() const;

    inline void updateClip();

    virtual void systemStateChanged();

    static IDirectFBSurface *getSurface(const QImage &img, bool *release);

#ifdef QT_DIRECTFB_IMAGECACHE

    static inline int cacheCost(const QImage &img) { return img.width() * img.height() * img.depth() / 8; }

#endif

    void prepareForBlit(bool alpha);

    IDirectFBSurface *surface;

    bool antialiased;

    bool simplePen;

    uint transformationType; // this is QTransform::type() + Matrix_NegativeScale if qMin(transform.m11(), transform.m22()) < 0

    SurfaceCache *surfaceCache;

    IDirectFB *fb;

    quint8 opacity;

    ClipType clipType;

    QDirectFBPaintDevice *dfbDevice;

    uint compositionModeStatus;

    bool isPremultiplied;

    bool inClip;

    QRect currentClip;

    QDirectFBPaintEngine *q;

};

class SurfaceCache

{

public:

    SurfaceCache() : surface(0), buffer(0), bufsize(0) {}

    ~SurfaceCache() { clear(); }

    IDirectFBSurface *getSurface(const uint *buf, int size);

    void clear();

private:

    IDirectFBSurface *surface;

    uint *buffer;

    int bufsize;

};

#ifdef QT_DIRECTFB_IMAGECACHE

QT_BEGIN_INCLUDE_NAMESPACE

#include <private/qimage_p.h>

QT_END_INCLUDE_NAMESPACE

struct CachedImage

{

    IDirectFBSurface *surface;

    ~CachedImage()

    {

        if (surface && QDirectFBScreen::instance()) {

            QDirectFBScreen::instance()->releaseDFBSurface(surface);

        }

    }

};

static QCache<qint64, CachedImage> imageCache(4*1024*1024); // 4 MB

#endif

#define VOID_ARG() static_cast<bool>(false)

enum PaintOperation {

    DRAW_RECTS = 0x0001, DRAW_LINES = 0x0002, DRAW_IMAGE = 0x0004,

    DRAW_PIXMAP = 0x0008, DRAW_TILED_PIXMAP = 0x0010, STROKE_PATH = 0x0020,

    DRAW_PATH = 0x0040, DRAW_POINTS = 0x0080, DRAW_ELLIPSE = 0x0100,

    DRAW_POLYGON = 0x0200, DRAW_TEXT = 0x0400, FILL_PATH = 0x0800,

    FILL_RECT = 0x1000, DRAW_COLORSPANS = 0x2000, DRAW_ROUNDED_RECT = 0x4000,

    DRAW_STATICTEXT = 0x8000, ALL = 0xffff

};

{

            }

        }

    }

}

template <typename device, typename T1, typename T2, typename T3>

static void rasterFallbackWarn(const char *msg, const char *func, const device *dev,

                               uint transformationType, bool simplePen,

                               uint clipType, uint compositionModeStatus,

                               const char *nameOne, const T1 &one,

                               const char *nameTwo, const T2 &two,

                               const char *nameThree, const T3 &three);

#define RASTERFALLBACK(op, one, two, three)                             \

    {                                                                   \

                               __FUNCTION__,                            \

                               state()->painter->device(),              \

                               d_func()->transformationType,            \

                               d_func()->simplePen,                     \

                               d_func()->clipType,                      \

                               d_func()->compositionModeStatus,         \

                               #one, one, #two, two, #three, three);    \

            return;                                                     \

    }

template <class T>

static inline void drawLines(const T *lines, int n, const QTransform &transform, IDirectFBSurface *surface);

template <class T>

static inline void fillRects(const T *rects, int n, const QTransform &transform, IDirectFBSurface *surface);

template <class T>

static inline void drawRects(const T *rects, int n, const QTransform &transform, IDirectFBSurface *surface);

#define CLIPPED_PAINT(operation) {                                      \

        d->unlock();                                                    \

        DFBRegion clipRegion;                                           \

        switch (d->clipType) {                                          \

        case QDirectFBPaintEnginePrivate::NoClip:                       \

        case QDirectFBPaintEnginePrivate::RectClip:                     \

            operation;                                                  \

            break;                                                      \

        case QDirectFBPaintEnginePrivate::RegionClip: {                 \

            Q_ASSERT(d->clip());                                        \

            const QVector<QRect> cr = d->clip()->clipRegion.rects();    \

            const int size = cr.size();                                 \

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

                d->currentClip = cr.at(i);                              \

                clipRegion.x1 = d->currentClip.x();                     \

                clipRegion.y1 = d->currentClip.y();                     \

                clipRegion.x2 = d->currentClip.right();                 \

                clipRegion.y2 = d->currentClip.bottom();                \

                d->surface->SetClip(d->surface, &clipRegion);           \

                operation;                                              \

            }                                                           \

            d->updateClip();                                            \

            break; }                                                    \

        case QDirectFBPaintEnginePrivate::ComplexClip:                  \

        case QDirectFBPaintEnginePrivate::ClipUnset:                    \

            qFatal("CLIPPED_PAINT internal error %d", d->clipType);     \

            break;                                                      \

        }                                                               \

    }

QDirectFBPaintEngine::QDirectFBPaintEngine(QPaintDevice *device)

    : QRasterPaintEngine(*(new QDirectFBPaintEnginePrivate(this)), device)

{

}

QDirectFBPaintEngine::~QDirectFBPaintEngine()

{

}

bool QDirectFBPaintEngine::begin(QPaintDevice *device)

{

    Q_D(QDirectFBPaintEngine);

    if (device->devType() == QInternal::CustomRaster) {

        d->dfbDevice = static_cast<QDirectFBPaintDevice*>(device);

    } else if (device->devType() == QInternal::Pixmap) {

        QPixmapData *data = static_cast<QPixmap*>(device)->pixmapData();

        Q_ASSERT(data->classId() == QPixmapData::DirectFBClass);

        QDirectFBPixmapData *dfbPixmapData = static_cast<QDirectFBPixmapData*>(data);

        QDirectFBPaintEnginePrivate::unlock(dfbPixmapData);

        d->dfbDevice = static_cast<QDirectFBPaintDevice*>(dfbPixmapData);

    }

    if (d->dfbDevice)

        d->surface = d->dfbDevice->directFBSurface();

    if (!d->surface) {

        qFatal("QDirectFBPaintEngine used on an invalid device: 0x%x",

               device->devType());

    }

    d->isPremultiplied = QDirectFBScreen::isPremultiplied(d->dfbDevice->format());

    d->prepare(d->dfbDevice);

    gccaps = AllFeatures;

    d->setCompositionMode(state()->composition_mode);

    return QRasterPaintEngine::begin(device);

}

bool QDirectFBPaintEngine::end()

{

    Q_D(QDirectFBPaintEngine);

    d->unlock();

    d->dfbDevice = 0;

#if (Q_DIRECTFB_VERSION >= 0x010000)

    d->surface->ReleaseSource(d->surface);

#endif

    d->currentClip = QRect();

    d->surface->SetClip(d->surface, NULL);

    d->surface = 0;

    return QRasterPaintEngine::end();

}

void QDirectFBPaintEngine::clipEnabledChanged()

{

    Q_D(QDirectFBPaintEngine);

    QRasterPaintEngine::clipEnabledChanged();

    d->updateClip();

}

void QDirectFBPaintEngine::penChanged()

{

    Q_D(QDirectFBPaintEngine);

    d->setPen(state()->pen);

    QRasterPaintEngine::penChanged();

}

void QDirectFBPaintEngine::opacityChanged()

{

    Q_D(QDirectFBPaintEngine);

    d->opacity = quint8(state()->opacity * 255);

    QRasterPaintEngine::opacityChanged();

}

void QDirectFBPaintEngine::compositionModeChanged()

{

    Q_D(QDirectFBPaintEngine);

    d->setCompositionMode(state()->compositionMode());

    QRasterPaintEngine::compositionModeChanged();

}

void QDirectFBPaintEngine::renderHintsChanged()

{

    Q_D(QDirectFBPaintEngine);

    d->setRenderHints(state()->renderHints);

    QRasterPaintEngine::renderHintsChanged();

}

void QDirectFBPaintEngine::transformChanged()

{

    Q_D(QDirectFBPaintEngine);

    d->setTransform(state()->matrix);

    QRasterPaintEngine::transformChanged();

}

void QDirectFBPaintEngine::setState(QPainterState *state)

{

    Q_D(QDirectFBPaintEngine);

    QRasterPaintEngine::setState(state);

    d->setPen(state->pen);

    d->opacity = quint8(state->opacity * 255);

    d->setCompositionMode(state->compositionMode());

    d->setTransform(state->transform());

    d->setRenderHints(state->renderHints);

    if (d->surface)

        d->updateClip();

}

void QDirectFBPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)

{

    Q_D(QDirectFBPaintEngine);

    const bool wasInClip = d->inClip;

    d->inClip = true;

    QRasterPaintEngine::clip(path, op);

    if (!wasInClip) {

        d->inClip = false;

        d->updateClip();

    }

}

void QDirectFBPaintEngine::clip(const QRegion &region, Qt::ClipOperation op)

{

    Q_D(QDirectFBPaintEngine);

    const bool wasInClip = d->inClip;

    d->inClip = true;

    QRasterPaintEngine::clip(region, op);

    if (!wasInClip) {

        d->inClip = false;

        d->updateClip();

    }

}

void QDirectFBPaintEngine::clip(const QRect &rect, Qt::ClipOperation op)

{

    Q_D(QDirectFBPaintEngine);

    const bool wasInClip = d->inClip;

    d->inClip = true;

    QRasterPaintEngine::clip(rect, op);

    if (!wasInClip) {

        d->inClip = false;

        d->updateClip();

    }

}

void QDirectFBPaintEngine::drawRects(const QRect *rects, int rectCount)

{

    Q_D(QDirectFBPaintEngine);

    const QPen &pen = state()->pen;

    const QBrush &brush = state()->brush;

    if (brush.style() == Qt::NoBrush && pen.style() == Qt::NoPen)

        return;

    if ((d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported)

        || !d->simplePen

        || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip

        || !d->isSimpleBrush(brush)

        || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {

        RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());

        d->lock();

        QRasterPaintEngine::drawRects(rects, rectCount);

        return;

    }

    if (brush.style() != Qt::NoBrush) {

        d->setDFBColor(brush.color());

        CLIPPED_PAINT(QT_PREPEND_NAMESPACE(fillRects<QRect>)(rects, rectCount, state()->matrix, d->surface));

    }

    if (pen.style() != Qt::NoPen) {

        d->setDFBColor(pen.color());

        CLIPPED_PAINT(QT_PREPEND_NAMESPACE(drawRects<QRect>)(rects, rectCount, state()->matrix, d->surface));

    }

}

void QDirectFBPaintEngine::drawRects(const QRectF *rects, int rectCount)

{

    Q_D(QDirectFBPaintEngine);

    const QPen &pen = state()->pen;

    const QBrush &brush = state()->brush;

    if (brush.style() == Qt::NoBrush && pen.style() == Qt::NoPen)

        return;

    if ((d->transformationType & QDirectFBPaintEnginePrivate::Matrix_RectsUnsupported)

        || !d->simplePen

        || d->clipType == QDirectFBPaintEnginePrivate::ComplexClip

        || !d->isSimpleBrush(brush)

        || !(d->compositionModeStatus & QDirectFBPaintEnginePrivate::PorterDuff_Supported)) {

        RASTERFALLBACK(DRAW_RECTS, rectCount, VOID_ARG(), VOID_ARG());

        d->lock();