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

**

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

#include "qpixmapdata_vg_p.h"

#include "qpixmapfilter_vg_p.h"

#include "qvgcompositionhelper_p.h"

#include "qvgimagepool_p.h"

#if !defined(QT_NO_EGL)

#include <QtGui/private/qegl_p.h>

#include "qwindowsurface_vgegl_p.h"

#endif

#include <QtCore/qvarlengtharray.h>

#include <QtGui/private/qdrawhelper_p.h>

#include <QtGui/private/qtextureglyphcache_p.h>

#include <QtGui/private/qtextengine_p.h>

#include <QtGui/private/qfontengine_p.h>

#include <QtGui/private/qpainterpath_p.h>

#include <QDebug>

#include <QSet>

QT_BEGIN_NAMESPACE

// vgDrawGlyphs() only exists in OpenVG 1.1 and higher.

#if !defined(OPENVG_VERSION_1_1) && !defined(QVG_NO_DRAW_GLYPHS)

#define QVG_NO_DRAW_GLYPHS 1

#endif

// vgRenderToMask() only exists in OpenVG 1.1 and higher.

// Also, disable masking completely if we are using the scissor to clip.

#if !defined(OPENVG_VERSION_1_1) && !defined(QVG_NO_RENDER_TO_MASK)

#define QVG_NO_RENDER_TO_MASK 1

#endif

#if defined(QVG_SCISSOR_CLIP) && !defined(QVG_NO_RENDER_TO_MASK)

#define QVG_NO_RENDER_TO_MASK 1

#endif

#if !defined(QVG_NO_DRAW_GLYPHS)

extern int qt_defaultDpiX();

extern int qt_defaultDpiY();

class QVGPaintEnginePrivate;

class QVGFontGlyphCache

{

public:

    QVGFontGlyphCache();

    ~QVGFontGlyphCache();

    void cacheGlyphs(QVGPaintEnginePrivate *d,

                     const QTextItemInt &ti,

                     const QVarLengthArray<glyph_t> &glyphs);

    void setScaleFromText(const QTextItemInt &ti);

    VGFont font;

    VGfloat scaleX;

    VGfloat scaleY;

    uint cachedGlyphsMask[256 / 32];

    QSet<glyph_t> cachedGlyphs;

};

typedef QHash<QFontEngine*, QVGFontGlyphCache*> QVGFontCache;

#endif

class QVGFontEngineCleaner : public QObject

{

    Q_OBJECT

public:

    QVGFontEngineCleaner(QVGPaintEnginePrivate *d);

    ~QVGFontEngineCleaner();

public slots:

    void fontEngineDestroyed();

private:

    QVGPaintEnginePrivate *d_ptr;

};

class QVGPaintEnginePrivate : public QPaintEngineExPrivate

{

public:

    QVGPaintEnginePrivate();

    ~QVGPaintEnginePrivate();

    void init();

    void initObjects();

    void destroy();

    void setTransform(VGMatrixMode mode, const QTransform& transform);

    void updateTransform(QPaintDevice *pdev);

    void draw(VGPath path, const QPen& pen, const QBrush& brush, VGint rule = VG_EVEN_ODD);

    void stroke(VGPath path, const QPen& pen);

    void fill(VGPath path, const QBrush& brush, VGint rule = VG_EVEN_ODD);

    VGPath roundedRectPath(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode);

    VGPaintType setBrush

        (VGPaint paint, const QBrush& brush, VGMatrixMode mode,

         VGPaintType prevPaintType);

    void setPenParams(const QPen& pen);

    void setBrushTransform(const QBrush& brush, VGMatrixMode mode);

    void setupColorRamp(const QGradient *grad, VGPaint paint);

    void setImageOptions();

#if !defined(QVG_SCISSOR_CLIP)

    void ensureMask(QVGPaintEngine *engine, int width, int height);

    void modifyMask

        (QVGPaintEngine *engine, VGMaskOperation op, const QRegion& region);

    void modifyMask

        (QVGPaintEngine *engine, VGMaskOperation op, const QRect& rect);

#endif

    VGint maxScissorRects;  // Maximum scissor rectangles for clipping.

    VGPaint penPaint;       // Paint for currently active pen.

    VGPaint brushPaint;     // Paint for currently active brush.

    VGPaint opacityPaint;   // Paint for drawing images with opacity.

    VGPaint fillPaint;      // Current fill paint that is active.

    QPen currentPen;        // Current pen set in "penPaint".

    QBrush currentBrush;    // Current brush set in "brushPaint".

    bool forcePenChange;    // Force a pen change, even if the same.

    bool forceBrushChange;  // Force a brush change, even if the same.

    VGPaintType penType;    // Type of the last pen that was set.

    VGPaintType brushType;  // Type of the last brush that was set.

    QPointF brushOrigin;    // Current brush origin.

    VGint fillRule;         // Last fill rule that was set.

    qreal opacity;          // Current drawing opacity.

    qreal paintOpacity;     // Opacity in opacityPaint.

#if !defined(QVG_NO_MODIFY_PATH)

    VGPath rectPath;        // Cached path for quick drawing of rectangles.

    VGPath linePath;        // Cached path for quick drawing of lines.

    VGPath roundRectPath;   // Cached path for quick drawing of rounded rects.

#endif

    QTransform transform;   // Currently active transform.

    bool simpleTransform;   // True if the transform is simple (non-projective).

    qreal penScale;         // Pen scaling factor from "transform".

    QTransform pathTransform;  // Calculated VG path transformation.

    QTransform imageTransform; // Calculated VG image transformation.

    bool pathTransformSet;  // True if path transform set in the VG context.

    bool maskValid;         // True if vgMask() contains valid data.

    bool maskIsSet;         // True if mask would be fully set if it was valid.

    bool scissorMask;       // True if scissor is used in place of the mask.

    bool rawVG;             // True if processing a raw VG escape.

    QRect maskRect;         // Rectangle version of mask if it is simple.

    QTransform penTransform;   // Transform for the pen.

    QTransform brushTransform; // Transform for the brush.

    VGMatrixMode matrixMode;    // Last matrix mode that was set.

    VGImageMode imageMode;      // Last image mode that was set.

    QRegion scissorRegion;  // Currently active scissor region.

    bool scissorActive;     // True if scissor region is active.

    bool scissorDirty;      // True if scissor is dirty after native painting.

    QPaintEngine::DirtyFlags dirty;

    QColor clearColor;      // Last clear color that was set.

    VGfloat clearOpacity;   // Opacity during the last clear.

    VGBlendMode blendMode;  // Active blend mode.

    VGRenderingQuality renderingQuality; // Active rendering quality.

    VGImageQuality imageQuality;    // Active image quality.

#if !defined(QVG_NO_DRAW_GLYPHS)

    QVGFontCache fontCache;

    QVGFontEngineCleaner *fontEngineCleaner;

#endif

    QScopedPointer<QPixmapFilter> convolutionFilter;

    QScopedPointer<QPixmapFilter> colorizeFilter;

    QScopedPointer<QPixmapFilter> dropShadowFilter;

    QScopedPointer<QPixmapFilter> blurFilter;

    // Ensure that the path transform is properly set in the VG context

    // before we perform a vgDrawPath() operation.

    inline void ensurePathTransform()

    {

        if (!pathTransformSet) {

            setTransform(VG_MATRIX_PATH_USER_TO_SURFACE, pathTransform);

            pathTransformSet = true;

        }

    }

    // Ensure that a specific pen has been set into penPaint.

    inline void ensurePen(const QPen& pen) {

        if (forcePenChange || pen != currentPen) {

            currentPen = pen;

            forcePenChange = false;

            penType = setBrush

                (penPaint, pen.brush(),

                 VG_MATRIX_STROKE_PAINT_TO_USER, penType);

            setPenParams(pen);

        }

    }

    // Ensure that a specific brush has been set into brushPaint.

    inline void ensureBrush(const QBrush& brush) {

        if (forceBrushChange || brush != currentBrush) {

            currentBrush = brush;

            forceBrushChange = false;

            brushType = setBrush

                (brushPaint, brush, VG_MATRIX_FILL_PAINT_TO_USER, brushType);

        }

        if (fillPaint != brushPaint) {

            vgSetPaint(brushPaint, VG_FILL_PATH);

            fillPaint = brushPaint;

        }

    }

    // Set various modes, but only if different.

    inline void setImageMode(VGImageMode mode);

    inline void setRenderingQuality(VGRenderingQuality mode);

    inline void setImageQuality(VGImageQuality mode);

    inline void setBlendMode(VGBlendMode mode);

    inline void setFillRule(VGint mode);

    // Clear all lazily-set modes.

    void clearModes();

};

inline void QVGPaintEnginePrivate::setImageMode(VGImageMode mode)

{

    if (imageMode != mode) {

        imageMode = mode;

        vgSeti(VG_IMAGE_MODE, mode);

    }

}

inline void QVGPaintEnginePrivate::setRenderingQuality(VGRenderingQuality mode)

{

    if (renderingQuality != mode) {

        vgSeti(VG_RENDERING_QUALITY, mode);

        renderingQuality = mode;

    }

}

inline void QVGPaintEnginePrivate::setImageQuality(VGImageQuality mode)

{

    if (imageQuality != mode) {

        vgSeti(VG_IMAGE_QUALITY, mode);

        imageQuality = mode;

    }

}

inline void QVGPaintEnginePrivate::setBlendMode(VGBlendMode mode)

{

    if (blendMode != mode) {

        vgSeti(VG_BLEND_MODE, mode);

        blendMode = mode;

    }

}

inline void QVGPaintEnginePrivate::setFillRule(VGint mode)

{

    if (fillRule != mode) {

        fillRule = mode;

        vgSeti(VG_FILL_RULE, mode);

    }

}

void QVGPaintEnginePrivate::clearModes()

{

    matrixMode = (VGMatrixMode)0;

    imageMode = (VGImageMode)0;

    blendMode = (VGBlendMode)0;

    renderingQuality = (VGRenderingQuality)0;

    imageQuality = (VGImageQuality)0;

}

QVGPaintEnginePrivate::QVGPaintEnginePrivate()

{

    init();

}

void QVGPaintEnginePrivate::init()

{

    maxScissorRects = 0;

    penPaint = 0;

    brushPaint = 0;

    opacityPaint = 0;

    fillPaint = 0;

    forcePenChange = true;

    forceBrushChange = true;

    penType = (VGPaintType)0;

    brushType = (VGPaintType)0;

    brushOrigin = QPointF(0.0f, 0.0f);

    fillRule = 0;

    opacity = 1.0;

    paintOpacity = 1.0f;

#if !defined(QVG_NO_MODIFY_PATH)

    rectPath = 0;

    linePath = 0;

    roundRectPath = 0;

#endif

    simpleTransform = true;

    pathTransformSet = false;

    penScale = 1.0;

    maskValid = false;

    maskIsSet = false;

    scissorMask = false;

    rawVG = false;

    scissorActive = false;

    scissorDirty = false;

    dirty = 0;

    clearOpacity = 1.0f;

#if !defined(QVG_NO_DRAW_GLYPHS)

    fontEngineCleaner = 0;

#endif

    clearModes();

}

QVGPaintEnginePrivate::~QVGPaintEnginePrivate()

{

    destroy();

}

void QVGPaintEnginePrivate::initObjects()

{

    maxScissorRects = vgGeti(VG_MAX_SCISSOR_RECTS);

    penPaint = vgCreatePaint();

    vgSetParameteri(penPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

    vgSetPaint(penPaint, VG_STROKE_PATH);

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_STROKE_PAINT_TO_USER);

    vgLoadIdentity();

    brushPaint = vgCreatePaint();

    vgSetParameteri(brushPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

    vgSetPaint(brushPaint, VG_FILL_PATH);

    fillPaint = brushPaint;

    vgSeti(VG_MATRIX_MODE, VG_MATRIX_FILL_PAINT_TO_USER);

    vgLoadIdentity();

    matrixMode = VG_MATRIX_FILL_PAINT_TO_USER;

    opacityPaint = vgCreatePaint();

    vgSetParameteri(opacityPaint, VG_PAINT_TYPE, VG_PAINT_TYPE_COLOR);

    VGfloat values[4];

    values[0] = 1.0f;

    values[1] = 1.0f;

    values[2] = 1.0f;

    values[3] = paintOpacity;

    vgSetParameterfv(opacityPaint, VG_PAINT_COLOR, 4, values);

#if !defined(QVG_NO_MODIFY_PATH)

    // Create a dummy path for rectangle drawing, which we can

    // modify later with vgModifyPathCoords().  This should be

    // faster than constantly creating and destroying paths.

    rectPath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

                            VG_PATH_DATATYPE_F,

                            1.0f, // scale

                            0.0f, // bias

                            5,    // segmentCapacityHint

                            8,    // coordCapacityHint

                            VG_PATH_CAPABILITY_ALL);

    static VGubyte const segments[5] = {

        VG_MOVE_TO_ABS,

        VG_LINE_TO_ABS,

        VG_LINE_TO_ABS,

        VG_LINE_TO_ABS,

        VG_CLOSE_PATH

    };

    VGfloat coords[8];

    coords[0] = 0.0f;

    coords[1] = 0.0f;

    coords[2] = 100.0f;

    coords[3] = coords[1];

    coords[4] = coords[2];

    coords[5] = 100.0f;

    coords[6] = coords[0];

    coords[7] = coords[5];

    vgAppendPathData(rectPath, 5, segments, coords);

    // Create a dummy line drawing path as well.

    linePath = vgCreatePath(VG_PATH_FORMAT_STANDARD,

                            VG_PATH_DATATYPE_F,

                            1.0f, // scale

                            0.0f, // bias

                            2,    // segmentCapacityHint

                            4,    // coordCapacityHint

                            VG_PATH_CAPABILITY_ALL);

    vgAppendPathData(linePath, 2, segments, coords);

#endif

}

void QVGPaintEnginePrivate::destroy()

{

    if (penPaint)

        vgDestroyPaint(penPaint);

    if (brushPaint)

        vgDestroyPaint(brushPaint);

    if (opacityPaint)

        vgDestroyPaint(opacityPaint);

#if !defined(QVG_NO_MODIFY_PATH)

    if (rectPath)

        vgDestroyPath(rectPath);

    if (linePath)

        vgDestroyPath(linePath);

    if (roundRectPath)

        vgDestroyPath(roundRectPath);

#endif

#if !defined(QVG_NO_DRAW_GLYPHS)

    QVGFontCache::Iterator it;

    for (it = fontCache.begin(); it != fontCache.end(); ++it)

        delete it.value();

    fontCache.clear();

    delete fontEngineCleaner;

#endif

}

// Set a specific VG transformation matrix in the current VG context.

void QVGPaintEnginePrivate::setTransform

        (VGMatrixMode mode, const QTransform& transform)

{

    VGfloat mat[9];

    if (mode != matrixMode) {

        vgSeti(VG_MATRIX_MODE, mode);

        matrixMode = mode;

    }

    mat[0] = transform.m11();

    mat[1] = transform.m12();

    mat[2] = transform.m13();

    mat[3] = transform.m21();

    mat[4] = transform.m22();

    mat[5] = transform.m23();

    mat[6] = transform.m31();

    mat[7] = transform.m32();

    mat[8] = transform.m33();

    vgLoadMatrix(mat);

}

extern bool qt_scaleForTransform(const QTransform &transform, qreal *scale);

void QVGPaintEnginePrivate::updateTransform(QPaintDevice *pdev)

{

    // Construct the VG transform by combining the Qt transform with

    // the following viewport transformation:

    // The full VG transform is effectively:

    //      1. Apply the user's transformation matrix.

    //      3. Flip the co-ordinate system upside down.

    QTransform viewport(1.0f, 0.0f, 0.0f,

                        0.0f, -1.0f, 0.0f,