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

**

** 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 = 0x00,

        PorterDuff_SupportedBlits = 0x01,

        PorterDuff_SupportedPrimitives = 0x02,

        PorterDuff_SupportedOpaquePrimitives = 0x04,

        PorterDuff_Dirty = 0x10

    };

    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 testCompositionMode(const QPen *pen, const QBrush *brush, const QColor *color = 0) const;

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

#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS || defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS

#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,

    ALL = 0xffff

};

#endif

#ifdef QT_DIRECTFB_WARN_ON_RASTERFALLBACKS

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);

#endif

#if defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS && defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS

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

    if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \

        rasterFallbackWarn("Disabled raster engine operation",          \

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

                           d_func()->transformationType,                \

                           d_func()->simplePen,                         \

                           d_func()->clipType,                          \

                           d_func()->compositionModeStatus,             \

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

    if (op & (QT_DIRECTFB_DISABLE_RASTERFALLBACKS))                     \

        return;

#elif defined QT_DIRECTFB_DISABLE_RASTERFALLBACKS

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

    if (op & (QT_DIRECTFB_DISABLE_RASTERFALLBACKS))     \

        return;

#elif defined QT_DIRECTFB_WARN_ON_RASTERFALLBACKS

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

    if (op & (QT_DIRECTFB_WARN_ON_RASTERFALLBACKS))                     \

        rasterFallbackWarn("Falling back to raster engine for",         \

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

                           d_func()->transformationType,                \

                           d_func()->simplePen,                         \

                           d_func()->clipType,                          \

                           d_func()->compositionModeStatus,             \

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

#else

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

#endif

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->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->testCompositionMode(&pen, &brush)) {

        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->testCompositionMode(&pen, &brush)) {

        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(fillRects<QRectF>(rects, rectCount, state()->matrix, d->surface));

    }

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

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

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

    }

}

void QDirectFBPaintEngine::drawLines(const QLine *lines, int lineCount)

{

    Q_D(QDirectFBPaintEngine);

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

    if (!d->simplePen

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

        || !d->testCompositionMode(&pen, 0)) {

        RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());

        d->lock();

        QRasterPaintEngine::drawLines(lines, lineCount);

        return;

    }

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

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

        CLIPPED_PAINT(QT_PREPEND_NAMESPACE(drawLines<QLine>)(lines, lineCount, state()->matrix, d->surface));

    }

}

void QDirectFBPaintEngine::drawLines(const QLineF *lines, int lineCount)

{

    Q_D(QDirectFBPaintEngine);

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

    if (!d->simplePen

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

        || !d->testCompositionMode(&pen, 0)) {

        RASTERFALLBACK(DRAW_LINES, lineCount, VOID_ARG(), VOID_ARG());

        d->lock();

        QRasterPaintEngine::drawLines(lines, lineCount);

        return;

    }

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

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

        CLIPPED_PAINT(QT_PREPEND_NAMESPACE(drawLines<QLineF>)(lines, lineCount, state()->matrix, d->surface));

    }

}

void QDirectFBPaintEngine::drawImage(const QRectF &r, const QImage &image,

                                     const QRectF &sr,

                                     Qt::ImageConversionFlags flags)

{

    Q_D(QDirectFBPaintEngine);

    Q_UNUSED(flags);

    /*  This is hard to read. The way it works is like this:

    - If you do not have support for preallocated surfaces and do not use an

    image cache we always fall back to raster engine.

    - If it's rotated/sheared/mirrored (negative scale) or we can't

    clip it we fall back to raster engine.

    - If we don't cache the image, but we do have support for

    preallocated surfaces we fall back to the raster engine if the

    image is in a format DirectFB can't handle.

    - If we do cache the image but don't have support for preallocated

    images and the cost of caching the image (bytes used) is higher

    than the max image cache size we fall back to raster engine.