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

**

** 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 QtSvg 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$

**

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

#ifndef QSVGSTYLE_P_H

#define QSVGSTYLE_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "QtGui/qpainter.h"

#ifndef QT_NO_SVG

#include "QtGui/qpen.h"

#include "QtGui/qbrush.h"

#include "QtGui/qmatrix.h"

#include "QtGui/qcolor.h"

#include "QtGui/qfont.h"

#include <qdebug.h>

QT_BEGIN_NAMESPACE

class QPainter;

class QSvgNode;

class QSvgFont;

class QSvgTinyDocument;

template <class T> class QSvgRefCounter

{

public:

    QSvgRefCounter() { t = 0; }

    QSvgRefCounter(T *_t)

    {

        t = _t;

        if (t)

            t->ref();

    }

    QSvgRefCounter(const QSvgRefCounter &other)

    {

        t = other.t;

        if (t)

            t->ref();

    }

    QSvgRefCounter &operator =(T *_t)

    {

        if(_t)

            _t->ref();

        if (t)

            t->deref();

        t = _t;

        return *this;

    }

    QSvgRefCounter &operator =(const QSvgRefCounter &other)

    {

        if(other.t)

            other.t->ref();

        if (t)

            t->deref();

        t = other.t;

        return *this;

    }

    ~QSvgRefCounter()

    {

        if (t)

            t->deref();

    }

    inline T *operator->() const { return t; }

    inline operator T*() const { return t; }

private:

    T *t;

};

class QSvgRefCounted

{

public:

    QSvgRefCounted() { _ref = 0; }

    virtual ~QSvgRefCounted() {}

    void ref() {

        ++_ref;

//        qDebug() << this << ": adding ref, now " << _ref;

    }

    void deref() {

//        qDebug() << this << ": removing ref, now " << _ref;

        if(!--_ref) {

//            qDebug("     deleting");

            delete this;

        }

    }

private:

    int _ref;

};

struct QSvgExtraStates

{

    QSvgExtraStates();

    qreal fillOpacity;

    qreal strokeOpacity;

    QSvgFont *svgFont;

    Qt::Alignment textAnchor;

    int fontWeight;

    Qt::FillRule fillRule;

    qreal strokeDashOffset;

    bool vectorEffect; // true if pen is cosmetic

};

class QSvgStyleProperty : public QSvgRefCounted

{

public:

    enum Type

    {

        QUALITY,

        FILL,

        VIEWPORT_FILL,

        FONT,

        STROKE,

        SOLID_COLOR,

        GRADIENT,

        TRANSFORM,

        ANIMATE_TRANSFORM,

        ANIMATE_COLOR,

        OPACITY,

        COMP_OP

    };

public:

    virtual ~QSvgStyleProperty();

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states)  =0;

    virtual void revert(QPainter *p, QSvgExtraStates &states) =0;

    virtual Type type() const=0;

};

class QSvgFillStyleProperty : public QSvgStyleProperty

{

public:

    virtual QBrush brush(QPainter *p, QSvgExtraStates &states) = 0;

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states);

    virtual void revert(QPainter *p, QSvgExtraStates &states);

};

class QSvgQualityStyle : public QSvgStyleProperty

{

public:

    QSvgQualityStyle(int color);

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states);

    virtual void revert(QPainter *p, QSvgExtraStates &states);

    virtual Type type() const;

private:

    // color-render ing v 	v 	'auto' | 'optimizeSpeed' |

    //                                  'optimizeQuality' | 'inherit'

    int m_colorRendering;

    // shape-rendering v 	v 	'auto' | 'optimizeSpeed' | 'crispEdges' |

    //                                  'geometricPrecision' | 'inherit'

    //QSvgShapeRendering m_shapeRendering;

    // text-rendering    v 	v 	'auto' | 'optimizeSpeed' | 'optimizeLegibility'

    //                                | 'geometricPrecision' | 'inherit'

    //QSvgTextRendering m_textRendering;

    // vector-effect         v 	x 	'default' | 'non-scaling-stroke' | 'inherit'

    //QSvgVectorEffect m_vectorEffect;

    // image-rendering v 	v 	'auto' | 'optimizeSpeed' | 'optimizeQuality' |

    //                                      'inherit'

    //QSvgImageRendering m_imageRendering;

};

class QSvgOpacityStyle : public QSvgStyleProperty

{

public:

    QSvgOpacityStyle(qreal opacity);

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states);

    virtual void revert(QPainter *p, QSvgExtraStates &states);

    virtual Type type() const;

private:

    qreal m_opacity;

    qreal m_oldOpacity;

};

class QSvgFillStyle : public QSvgStyleProperty

{

public:

    QSvgFillStyle();

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states);

    virtual void revert(QPainter *p, QSvgExtraStates &states);

    virtual Type type() const;

    void setFillRule(Qt::FillRule f);

    void setFillOpacity(qreal opacity);

    void setFillStyle(QSvgFillStyleProperty* style);

    void setBrush(QBrush brush);

    const QBrush & qbrush() const

    {

        return m_fill;

    }

    qreal fillOpacity() const

    {

        return m_fillOpacity;

    }

    Qt::FillRule fillRule() const

    {

        return m_fillRule;

    }

    QSvgFillStyleProperty* style() const

    {

        return m_style;

    }

    void setGradientId(const QString &Id)

    {

        m_gradientId = Id;

    }

    QString gradientId() const

    {

        return m_gradientId;

    }

    void setGradientResolved(bool resolved)

    {

        m_gradientResolved = resolved;

    }

    bool isGradientResolved() const

    {

        return m_gradientResolved;

    }

private:

    // fill            v 	v 	'inherit' | <Paint.datatype>

    // fill-opacity    v 	v 	'inherit' | <OpacityValue.datatype>

    QBrush m_fill;

    QBrush m_oldFill;

    QSvgFillStyleProperty *m_style;

    Qt::FillRule m_fillRule;

    Qt::FillRule m_oldFillRule;

    qreal m_fillOpacity;

    qreal m_oldFillOpacity;

    QString m_gradientId;

    uint m_gradientResolved : 1;

    uint m_fillRuleSet : 1;

    uint m_fillOpacitySet : 1;

    uint m_fillSet : 1;

};

class QSvgViewportFillStyle : public QSvgStyleProperty

{

public:

    QSvgViewportFillStyle(const QBrush &brush);

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states);

    virtual void revert(QPainter *p, QSvgExtraStates &states);

    virtual Type type() const;

    const QBrush & qbrush() const

    {

        return m_viewportFill;

    }

private:

    // viewport-fill         v 	x 	'inherit' | <Paint.datatype>

    // viewport-fill-opacity 	v 	x 	'inherit' | <OpacityValue.datatype>

    QBrush m_viewportFill;

    QBrush m_oldFill;

};

class QSvgFontStyle : public QSvgStyleProperty

{

public:

    static const int LIGHTER = -1;

    static const int BOLDER = 1;

    QSvgFontStyle(QSvgFont *font, QSvgTinyDocument *doc);

    QSvgFontStyle();

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states);

    virtual void revert(QPainter *p, QSvgExtraStates &states);

    virtual Type type() const;

    void setSize(qreal size)

    {

        // Store the _pixel_ size in the font. Since QFont::setPixelSize() only takes an int, call

        // QFont::SetPointSize() instead. Set proper font size just before rendering.

        m_qfont.setPointSize(size);

        m_sizeSet = 1;

    }

    void setTextAnchor(Qt::Alignment anchor)

    {

        m_textAnchor = anchor;

        m_textAnchorSet = 1;

    }

    void setFamily(const QString &family)

    {

        m_qfont.setFamily(family);

        m_familySet = 1;

    }

    void setStyle(QFont::Style fontStyle) {

        m_qfont.setStyle(fontStyle);

        m_styleSet = 1;

    }

    void setVariant(QFont::Capitalization fontVariant)

    {

        m_qfont.setCapitalization(fontVariant);

        m_variantSet = 1;

    }

    static int SVGToQtWeight(int weight);

    void setWeight(int weight)

    {

        m_weight = weight;

        m_weightSet = 1;

    }

    QSvgFont * svgFont() const

    {

        return m_svgFont;

    }

    const QFont &qfont() const

    {

        return m_qfont;

    }

    QSvgTinyDocument *doc() const {return m_doc;}

private:

    QSvgFont *m_svgFont;

    QSvgTinyDocument *m_doc;

    QFont m_qfont;

    int m_weight;

    Qt::Alignment m_textAnchor;

    QSvgFont *m_oldSvgFont;

    QFont m_oldQFont;

    Qt::Alignment m_oldTextAnchor;

    int m_oldWeight;

    uint m_familySet : 1;

    uint m_sizeSet : 1;

    uint m_styleSet : 1;

    uint m_variantSet : 1;

    uint m_weightSet : 1;

    uint m_textAnchorSet : 1;

};

class QSvgStrokeStyle : public QSvgStyleProperty

{

public:

    QSvgStrokeStyle();

    virtual void apply(QPainter *p, const QRectF &, QSvgNode *node, QSvgExtraStates &states);

    virtual void revert(QPainter *p, QSvgExtraStates &states);

    virtual Type type() const;

    void setStroke(QBrush brush)

    {

        m_stroke.setBrush(brush);

        m_style = 0;

        m_strokeSet = 1;

    }

    void setStyle(QSvgFillStyleProperty *style)

    {

        m_style = style;

        m_strokeSet = 1;

    }

    void setDashArray(const QVector<qreal> &dashes);

    void setDashArrayNone()

    {

        m_stroke.setStyle(Qt::SolidLine);

        m_strokeDashArraySet = 1;

    }

    void setDashOffset(qreal offset)

    {

        m_strokeDashOffset = offset;

        m_strokeDashOffsetSet = 1;

    }

    void setLineCap(Qt::PenCapStyle cap)

    {

        m_stroke.setCapStyle(cap);

        m_strokeLineCapSet = 1;

    }

    void setLineJoin(Qt::PenJoinStyle join)

    {

        m_stroke.setJoinStyle(join);

        m_strokeLineJoinSet = 1;

    }

    void setMiterLimit(qreal limit)

    {

        m_stroke.setMiterLimit(limit);

        m_strokeMiterLimitSet = 1;

    }

    void setOpacity(qreal opacity)

    {

        m_strokeOpacity = opacity;

        m_strokeOpacitySet = 1;

    }

    void setWidth(qreal width)

    {

        m_stroke.setWidthF(width);

        m_strokeWidthSet = 1;

        Q_ASSERT(!m_strokeDashArraySet); // set width before dash array.

    }

    qreal width()

    {

        return m_stroke.widthF();

    }

    void setVectorEffect(bool nonScalingStroke)

    {

        m_vectorEffect = nonScalingStroke;

        m_vectorEffectSet = 1;

    }

    QSvgFillStyleProperty* style() const

    {

        return m_style;

    }

    void setGradientId(const QString &Id)

    {

        m_gradientId = Id;

    }

    QString gradientId() const

    {

        return m_gradientId;

    }

    void setGradientResolved(bool resolved)

    {

        m_gradientResolved = resolved;

    }

    bool isGradientResolved() const

    {

        return m_gradientResolved;

    }

    QPen stroke() const

    {

        return m_stroke;

    }

private:

    // stroke            v 	v 	'inherit' | <Paint.datatype>

    // stroke-dasharray  v 	v 	'inherit' | <StrokeDashArrayValue.datatype>

    // stroke-dashoffset v 	v 	'inherit' | <StrokeDashOffsetValue.datatype>

    // stroke-linecap    v 	v 	'butt' | 'round' | 'square' | 'inherit'

    // stroke-linejoin   v 	v 	'miter' | 'round' | 'bevel' | 'inherit'

    // stroke-miterlimit v 	v 	'inherit' | <StrokeMiterLimitValue.datatype>

    // stroke-opacity    v 	v 	'inherit' | <OpacityValue.datatype>

    // stroke-width      v 	v 	'inherit' | <StrokeWidthValue.datatype>

    QPen m_stroke;

    QPen m_oldStroke;

    qreal m_strokeOpacity;

    qreal m_oldStrokeOpacity;

    qreal m_strokeDashOffset;