Changeset 561 for trunk/src/svg/qsvgstyle.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/svg/qsvgstyle.cpp (modified) (29 diffs)

trunk/src/svg/qsvgstyle.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtSvg module of the Qt Toolkit.
@@ -21 +22 @@
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** 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.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -60 +60 @@
 QSvgExtraStates::QSvgExtraStates()
     : fillOpacity(1.0)
+    , strokeOpacity(1.0)
+    , svgFont(0)
+    , textAnchor(Qt::AlignLeft)
+    , fontWeight(400)
+    , fillRule(Qt::WindingFill)
+    , strokeDashOffset(0)
+    , vectorEffect(false)
 {
 }
@@ -66 +73 @@
 {
 }
+
+void QSvgFillStyleProperty::apply(QPainter *, const QRectF &, QSvgNode *, QSvgExtraStates &)
+{
+    Q_ASSERT(!"This should not be called!");
+}
+
+void QSvgFillStyleProperty::revert(QPainter *, QSvgExtraStates &)
+{
+    Q_ASSERT(!"This should not be called!");
+}
+
 
 QSvgQualityStyle::QSvgQualityStyle(int color)
@@ -81 +99 @@
 }
 
-QSvgFillStyle::QSvgFillStyle(const QBrush &brush)
-    : m_fill(brush), m_style(0), m_fillRuleSet(false), m_fillOpacitySet(false)
-{
-}
-
-QSvgFillStyle::QSvgFillStyle(QSvgStyleProperty *style)
-    : m_style(style), m_fillRuleSet(false), m_fillOpacitySet(false)
+QSvgFillStyle::QSvgFillStyle()
+    : m_style(0)
+    , m_fillRule(Qt::WindingFill)
+    , m_oldFillRule(Qt::WindingFill)
+    , m_fillOpacity(1.0)
+    , m_oldFillOpacity(0)
+    , m_gradientResolved(1)
+    , m_fillRuleSet(0)
+    , m_fillOpacitySet(0)
+    , m_fillSet(0)
 {
 }
@@ -93 +114 @@
 void QSvgFillStyle::setFillRule(Qt::FillRule f)
 {
-    m_fillRuleSet = true;
+    m_fillRuleSet = 1;
     m_fillRule = f;
 }
@@ -99 +120 @@
 void QSvgFillStyle::setFillOpacity(qreal opacity)
 {
-    m_fillOpacitySet = true;
+    m_fillOpacitySet = 1;
     m_fillOpacity = opacity;
 }
 
-static void recursivelySetFill(QSvgNode *node, Qt::FillRule f)
-{
-    if (node->type() == QSvgNode::PATH) {
-        QSvgPath *path = static_cast<QSvgPath*>(node);
-        path->qpath()->setFillRule(f);
-    } else if (node->type() == QSvgNode::G) {
-        QList<QSvgNode*> renderers = static_cast<QSvgG*>(node)->renderers();
-        foreach(QSvgNode *n, renderers) {
-            recursivelySetFill(n, f);
-        }
-    }
-}
-void QSvgFillStyle::apply(QPainter *p, const QRectF &rect, QSvgNode *node, QSvgExtraStates &states)
+void QSvgFillStyle::setFillStyle(QSvgFillStyleProperty* style)
+{
+    m_style = style;
+    m_fillSet = 1;
+}
+
+void QSvgFillStyle::setBrush(QBrush brush)
+{
+    m_fill = brush;
+    m_style = 0;
+    m_fillSet = 1;
+}
+
+void QSvgFillStyle::apply(QPainter *p, const QRectF &, QSvgNode *, QSvgExtraStates &states)
 {
     m_oldFill = p->brush();
-    m_oldOpacity = states.fillOpacity;
-
-    if (m_fillRuleSet) {
-        recursivelySetFill(node, m_fillRule);
-        m_fillRuleSet = false;//set it only on the first run
-    }
-    p->setBrush(m_fill);
+    m_oldFillRule = states.fillRule;
+    m_oldFillOpacity = states.fillOpacity;
+
+    if (m_fillRuleSet)
+        states.fillRule = m_fillRule;
+    if (m_fillSet) {
+        if (m_style)
+            p->setBrush(m_style->brush(p, states));
+        else
+            p->setBrush(m_fill);
+    }
     if (m_fillOpacitySet)
         states.fillOpacity = m_fillOpacity;
-    if (m_style)
-        m_style->apply(p, rect, node, states);
 }
 
 void QSvgFillStyle::revert(QPainter *p, QSvgExtraStates &states)
 {
-    if (m_style)
-        m_style->revert(p, states);
-    p->setBrush(m_oldFill);
     if (m_fillOpacitySet)
-        states.fillOpacity = m_oldOpacity;
+        states.fillOpacity = m_oldFillOpacity;
+    if (m_fillSet)
+        p->setBrush(m_oldFill);
+    if (m_fillRuleSet)
+        states.fillRule = m_oldFillRule;
 }
 
@@ -157 +182 @@
 
 QSvgFontStyle::QSvgFontStyle(QSvgFont *font, QSvgTinyDocument *doc)
-    : m_font(font), m_pointSize(24), m_doc(doc)
-{
-}
-
-QSvgFontStyle::QSvgFontStyle(const QFont &font, QSvgTinyDocument *doc)
-    : m_font(0), m_pointSize(24), m_doc(doc), m_qfont(font)
-{
-}
-
-
-void QSvgFontStyle::setPointSize(qreal size)
-{
-    m_pointSize = size;
-}
-
-qreal QSvgFontStyle::pointSize() const
-{
-    return m_pointSize;
-}
-
-void QSvgFontStyle::apply(QPainter *p, const QRectF &, QSvgNode *, QSvgExtraStates &)
-{
-    if (!m_font) {
-        m_oldFont = p->font();
-        p->setFont(m_qfont);
-    }
-}
-
-void QSvgFontStyle::revert(QPainter *p, QSvgExtraStates &)
-{
-    if (!m_font) {
-        p->setFont(m_oldFont);
-    }
-}
-
-QSvgStrokeStyle::QSvgStrokeStyle(const QPen &pen)
-    : m_stroke(pen)
-{
-}
-
-void QSvgStrokeStyle::apply(QPainter *p, const QRectF &, QSvgNode *, QSvgExtraStates &)
+    : m_svgFont(font)
+    , m_doc(doc)
+    , m_familySet(0)
+    , m_sizeSet(0)
+    , m_styleSet(0)
+    , m_variantSet(0)
+    , m_weightSet(0)
+    , m_textAnchorSet(0)
+{
+}
+
+QSvgFontStyle::QSvgFontStyle()
+    : m_svgFont(0)
+    , m_doc(0)
+    , m_familySet(0)
+    , m_sizeSet(0)
+    , m_styleSet(0)
+    , m_variantSet(0)
+    , m_weightSet(0)
+    , m_textAnchorSet(0)
+{
+}
+
+int QSvgFontStyle::SVGToQtWeight(int weight) {
+    switch (weight) {
+    case 100:
+    case 200:
+        return QFont::Light;
+    case 300:
+    case 400:
+        return QFont::Normal;
+    case 500:
+    case 600:
+        return QFont::DemiBold;
+    case 700:
+    case 800:
+        return QFont::Bold;
+    case 900:
+        return QFont::Black;
+    }
+    return QFont::Normal;
+}
+
+void QSvgFontStyle::apply(QPainter *p, const QRectF &, QSvgNode *, QSvgExtraStates &states)
+{
+    m_oldQFont = p->font();
+    m_oldSvgFont = states.svgFont;
+    m_oldTextAnchor = states.textAnchor;
+    m_oldWeight = states.fontWeight;
+
+    if (m_textAnchorSet)
+        states.textAnchor = m_textAnchor;
+
+    QFont font = m_oldQFont;
+    if (m_familySet) {
+        states.svgFont = m_svgFont;
+        font.setFamily(m_qfont.family());
+    }
+
+    if (m_sizeSet)
+        font.setPointSize(m_qfont.pointSizeF());
+
+    if (m_styleSet)
+        font.setStyle(m_qfont.style());
+
+    if (m_variantSet)
+        font.setCapitalization(m_qfont.capitalization());
+
+    if (m_weightSet) {
+        if (m_weight == BOLDER) {
+            states.fontWeight = qMin(states.fontWeight + 100, 900);
+        } else if (m_weight == LIGHTER) {
+            states.fontWeight = qMax(states.fontWeight - 100, 100);
+        } else {
+            states.fontWeight = m_weight;
+        }
+        font.setWeight(SVGToQtWeight(states.fontWeight));
+    }
+
+    p->setFont(font);
+}
+
+void QSvgFontStyle::revert(QPainter *p, QSvgExtraStates &states)
+{
+    p->setFont(m_oldQFont);
+    states.svgFont = m_oldSvgFont;
+    states.textAnchor = m_oldTextAnchor;
+    states.fontWeight = m_oldWeight;
+}
+
+QSvgStrokeStyle::QSvgStrokeStyle()
+    : m_strokeOpacity(1.0)
+    , m_oldStrokeOpacity(0.0)
+    , m_strokeDashOffset(0)
+    , m_oldStrokeDashOffset(0)
+    , m_style(0)
+    , m_gradientResolved(1)
+    , m_vectorEffect(0)
+    , m_oldVectorEffect(0)
+    , m_strokeSet(0)
+    , m_strokeDashArraySet(0)
+    , m_strokeDashOffsetSet(0)
+    , m_strokeLineCapSet(0)
+    , m_strokeLineJoinSet(0)
+    , m_strokeMiterLimitSet(0)
+    , m_strokeOpacitySet(0)
+    , m_strokeWidthSet(0)
+    , m_vectorEffectSet(0)
+{
+}
+
+void QSvgStrokeStyle::apply(QPainter *p, const QRectF &, QSvgNode *, QSvgExtraStates &states)
 {
     m_oldStroke = p->pen();
-    p->setPen(m_stroke);
-}
-
-void QSvgStrokeStyle::revert(QPainter *p, QSvgExtraStates &)
+    m_oldStrokeOpacity = states.strokeOpacity;
+    m_oldStrokeDashOffset = states.strokeDashOffset;
+    m_oldVectorEffect = states.vectorEffect;
+
+    QPen pen = p->pen();
+
+    qreal oldWidth = pen.widthF();
+    qreal width = m_stroke.widthF();
+    if (oldWidth == 0)
+        oldWidth = 1;
+    if (width == 0)
+        width = 1;
+    qreal scale = oldWidth / width;
+
+    if (m_strokeOpacitySet)
+        states.strokeOpacity = m_strokeOpacity;
+
+    if (m_vectorEffectSet)
+        states.vectorEffect = m_vectorEffect;
+
+    if (m_strokeSet) {
+        if (m_style)
+            pen.setBrush(m_style->brush(p, states));
+        else
+            pen.setBrush(m_stroke.brush());
+    }
+
+    if (m_strokeWidthSet)
+        pen.setWidthF(m_stroke.widthF());
+
+    bool setDashOffsetNeeded = false;
+
+    if (m_strokeDashOffsetSet) {
+        states.strokeDashOffset = m_strokeDashOffset;
+        setDashOffsetNeeded = true;
+    }
+
+    if (m_strokeDashArraySet) {
+        if (m_stroke.style() == Qt::SolidLine) {
+            pen.setStyle(Qt::SolidLine);
+        } else if (m_strokeWidthSet || oldWidth == 1) {
+            // If both width and dash array was set, the dash array is already scaled correctly.
+            pen.setDashPattern(m_stroke.dashPattern());
+            setDashOffsetNeeded = true;
+        } else {
+            // If dash array was set, but not the width, the dash array has to be scaled with respect to the old width.
+            QVector<qreal> dashes = m_stroke.dashPattern();
+            for (int i = 0; i < dashes.size(); ++i)
+                dashes[i] /= oldWidth;
+            pen.setDashPattern(dashes);
+            setDashOffsetNeeded = true;
+        }
+    } else if (m_strokeWidthSet && pen.style() != Qt::SolidLine && scale != 1) {
+        // If the width was set, but not the dash array, the old dash array must be scaled with respect to the new width.
+        QVector<qreal> dashes = pen.dashPattern();
+        for (int i = 0; i < dashes.size(); ++i)
+            dashes[i] *= scale;
+        pen.setDashPattern(dashes);
+        setDashOffsetNeeded = true;
+    }
+
+    if (m_strokeLineCapSet)
+        pen.setCapStyle(m_stroke.capStyle());
+    if (m_strokeLineJoinSet)
+        pen.setJoinStyle(m_stroke.joinStyle());
+    if (m_strokeMiterLimitSet)
+        pen.setMiterLimit(m_stroke.miterLimit());
+
+    // You can have dash offset on solid strokes in SVG files, but not in Qt.
+    // QPen::setDashOffset() will set the pen style to Qt::CustomDashLine,
+    // so don't call the method if the pen is solid.
+    if (setDashOffsetNeeded && pen.style() != Qt::SolidLine) {
+        qreal currentWidth = pen.widthF();
+        if (currentWidth == 0)
+            currentWidth = 1;
+        pen.setDashOffset(states.strokeDashOffset / currentWidth);
+    }
+
+    pen.setCosmetic(states.vectorEffect);
+
+    p->setPen(pen);
+}
+
+void QSvgStrokeStyle::revert(QPainter *p, QSvgExtraStates &states)
 {
     p->setPen(m_oldStroke);
+    states.strokeOpacity = m_oldStrokeOpacity;
+    states.strokeDashOffset = m_oldStrokeDashOffset;
+    states.vectorEffect = m_oldVectorEffect;
+}
+
+void QSvgStrokeStyle::setDashArray(const QVector<qreal> &dashes)
+{
+    if (m_strokeWidthSet) {
+        QVector<qreal> d = dashes;
+        qreal w = m_stroke.widthF();
+        if (w != 0 && w != 1) {
+            for (int i = 0; i < d.size(); ++i)
+                d[i] /= w;
+        }
+        m_stroke.setDashPattern(d);
+    } else {
+        m_stroke.setDashPattern(dashes);
+    }
+    m_strokeDashArraySet = 1;
 }
 
@@ -213 +408 @@
 }
 
-void QSvgSolidColorStyle::apply(QPainter *p, const QRectF &, QSvgNode *, QSvgExtraStates &)
-{
-    m_oldFill = p->brush();
-    m_oldStroke = p->pen();
-    QBrush b = m_oldFill;
-    b.setColor(m_solidColor);
-    p->setBrush(b);
-    QPen pen = m_oldStroke;
-    pen.setColor(m_solidColor);
-    p->setPen(pen);
-}
-
-void QSvgSolidColorStyle::revert(QPainter *p, QSvgExtraStates &)
-{
-    p->setBrush(m_oldFill);
-    p->setPen(m_oldStroke);
-}
-
 QSvgGradientStyle::QSvgGradientStyle(QGradient *grad)
     : m_gradient(grad), m_gradientStopsSet(false)
@@ -236 +413 @@
 }
 
-void QSvgGradientStyle::apply(QPainter *p, const QRectF &/*rect*/, QSvgNode *, QSvgExtraStates &)
+QBrush QSvgGradientStyle::brush(QPainter *, QSvgExtraStates &)
 {
     if (!m_link.isEmpty()) {
         resolveStops();
-    }
-
-    m_oldFill = p->brush();
-
-    //resolving stop colors
-    if (!m_resolvePoints.isEmpty()) {
-        QColor color = p->brush().color();
-        if (!color.isValid())
-            color = p->pen().color();
-        QList<qreal>::const_iterator itr = m_resolvePoints.constBegin();
-        for (; itr != m_resolvePoints.constEnd(); ++itr) {
-            //qDebug()<<"resolving "<<(*itr)<<" to "<<color;
-            m_gradient->setColorAt(*itr, color);
-        }
     }
 
@@ -262 +425 @@
     }
 
-    QBrush brush;
-    brush = QBrush(*m_gradient);
+    QBrush b(*m_gradient);
 
     if (!m_matrix.isIdentity())
-        brush.setMatrix(m_matrix);
-
-    p->setBrush(brush);
-}
-
-void QSvgGradientStyle::revert(QPainter *p, QSvgExtraStates &)
-{
-    p->setBrush(m_oldFill);
+        b.setMatrix(m_matrix);
+
+    return b;
 }
 
@@ -280 +437 @@
 {
     m_matrix = mat;
-}
-
-void QSvgGradientStyle::addResolve(qreal offset)
-{
-    m_resolvePoints.append(offset);
 }
 
@@ -390 +542 @@
     if (stroke) {
         stroke->apply(p, rect, node, states);
-    }
-
-    if (solidColor) {
-        solidColor->apply(p, rect, node, states);
-    }
-
-    if (gradient) {
-        gradient->apply(p, rect, node, states);
     }
 
@@ -411 +555 @@
     //_after_ the original object transformations
     if (!animateTransforms.isEmpty()) {
-        QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr;
-        for (itr = animateTransforms.constBegin(); itr != animateTransforms.constEnd();
-             ++itr) {
-            (*itr)->apply(p, rect, node, states);
+        qreal totalTimeElapsed = node->document()->currentElapsed();
+        // Find the last animateTransform with additive="replace", since this will override all
+        // previous animateTransforms.
+        QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr = animateTransforms.constEnd();
+        do {
+            --itr;
+            if ((*itr)->animActive(totalTimeElapsed)
+                && (*itr)->additiveType() == QSvgAnimateTransform::Replace) {
+                // An animateTransform with additive="replace" will replace the transform attribute.
+                if (transform)
+                    transform->revert(p, states);
+                break;
+            }
+        } while (itr != animateTransforms.constBegin());
+
+        // Apply the animateTransforms after and including the last one with additive="replace".
+        for (; itr != animateTransforms.constEnd(); ++itr) {
+            if ((*itr)->animActive(totalTimeElapsed))
+                (*itr)->apply(p, rect, node, states);
         }
     }
@@ -447 +606 @@
     if (stroke) {
         stroke->revert(p, states);
-    }
-
-    if (solidColor) {
-        solidColor->revert(p, states);
-    }
-
-    if (gradient) {
-        gradient->revert(p, states);
     }
 
@@ -460 +611 @@
     //the native transforms
     if (!animateTransforms.isEmpty()) {
-        QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr;
-        itr = animateTransforms.constBegin();
-        //only need to rever the first one because that
-        //one has the original world matrix for the primitve
-        if (itr != animateTransforms.constEnd()) {
-            (*itr)->revert(p, states);
+        QList<QSvgRefCounter<QSvgAnimateTransform> >::const_iterator itr = animateTransforms.constBegin();
+        for (; itr != animateTransforms.constEnd(); ++itr) {
+            if ((*itr)->transformApplied()) {
+                (*itr)->revert(p, states);
+                break;
+            }
         }
+        for (; itr != animateTransforms.constEnd(); ++itr)
+            (*itr)->clearTransformApplied();
     }
 
@@ -489 +642 @@
     : QSvgStyleProperty(),
       m_from(startMs), m_to(endMs), m_by(byMs),
-      m_type(Empty), m_count(0), m_finished(false)
+      m_type(Empty), m_additive(Replace), m_count(0), m_finished(false), m_transformApplied(false)
 {
     m_totalRunningTime = m_to - m_from;
 }
 
-void QSvgAnimateTransform::setArgs(TransformType type, const QVector<qreal> &args)
+void QSvgAnimateTransform::setArgs(TransformType type, Additive additive, const QVector<qreal> &args)
 {
     m_type = type;
     m_args = args;
+    m_additive = additive;
     Q_ASSERT(!(args.count()%3));
     m_count = args.count() / 3;
@@ -506 +660 @@
     m_oldWorldTransform = p->worldTransform();
     resolveMatrix(node);
-    if (!m_finished || m_freeze)
-        p->setWorldTransform(m_transform, true);
+    p->setWorldTransform(m_transform, true);
+    m_transformApplied = true;
 }
 
 void QSvgAnimateTransform::revert(QPainter *p, QSvgExtraStates &)
 {
-    if (!m_finished || m_freeze) {
-        p->setWorldTransform(m_oldWorldTransform, false /* don't combine */);
-    }
+    p->setWorldTransform(m_oldWorldTransform, false /* don't combine */);
+    m_transformApplied = false;
 }
 
@@ -524 +677 @@
         return;
 
-    qreal animationFrame = (totalTimeElapsed - m_from) / m_to;
-
-    if (m_repeatCount >= 0 && m_repeatCount < animationFrame) {
-        m_finished = true;
-        animationFrame = m_repeatCount;
+    qreal animationFrame = 0;
+    if (m_totalRunningTime != 0) {
+        animationFrame = (totalTimeElapsed - m_from) / m_totalRunningTime;
+
+        if (m_repeatCount >= 0 && m_repeatCount < animationFrame) {
+            m_finished = true;
+            animationFrame = m_repeatCount;
+        }
     }
 
@@ -545 +701 @@
         startElem *= 3;
         endElem   *= 3;
-        qreal from1, from2, from3;
-        qreal to1, to2, to3;
+        qreal from1, from2;
+        qreal to1, to2;
         from1 = m_args[startElem++];
         from2 = m_args[startElem++];
-        from3 = m_args[startElem++];
         to1   = m_args[endElem++];
         to2   = m_args[endElem++];
-        to3   = m_args[endElem++];
 
         qreal transXDiff = (to1-from1) * percentOfAnimation;
@@ -565 +719 @@
         startElem *= 3;
         endElem   *= 3;
-        qreal from1, from2, from3;
-        qreal to1, to2, to3;
+        qreal from1, from2;
+        qreal to1, to2;
         from1 = m_args[startElem++];
         from2 = m_args[startElem++];
-        from3 = m_args[startElem++];
         to1   = m_args[endElem++];
         to2   = m_args[endElem++];
-        to3   = m_args[endElem++];
 
         qreal transXDiff = (to1-from1) * percentOfAnimation;
@@ -612 +764 @@
         startElem *= 3;
         endElem   *= 3;
-        qreal from1, from2, from3;
-        qreal to1, to2, to3;
+        qreal from1;
+        qreal to1;
         from1 = m_args[startElem++];
-        from2 = m_args[startElem++];
-        from3 = m_args[startElem++];
         to1   = m_args[endElem++];
-        to2   = m_args[endElem++];
-        to3   = m_args[endElem++];
 
         qreal transXDiff = (to1-from1) * percentOfAnimation;
         qreal transX = from1 + transXDiff;
         m_transform = QTransform();
-        m_transform.shear(tan(transX * deg2rad), 0);
+        m_transform.shear(qTan(transX * deg2rad), 0);
         break;
     }
@@ -630 +778 @@
         startElem *= 3;
         endElem   *= 3;
-        qreal from1, from2, from3;
-        qreal to1, to2, to3;
+        qreal from1;
+        qreal to1;
         from1 = m_args[startElem++];
-        from2 = m_args[startElem++];
-        from3 = m_args[startElem++];
         to1   = m_args[endElem++];
-        to2   = m_args[endElem++];
-        to3   = m_args[endElem++];
 
 
@@ -643 +787 @@
         qreal transY = from1 + transYDiff;
         m_transform = QTransform();
-        m_transform.shear(0, tan(transY * deg2rad));
+        m_transform.shear(0, qTan(transY * deg2rad));
         break;
     }
@@ -697 +841 @@
         return;
 
-    qreal animationFrame = (totalTimeElapsed - m_from) / m_to;
+    qreal animationFrame = 0;
+    if (m_totalRunningTime != 0)
+        animationFrame = (totalTimeElapsed - m_from) / m_totalRunningTime;
 
     if (m_repeatCount >= 0 && m_repeatCount < animationFrame) {
@@ -761 +907 @@
 }
 
-QString QSvgFontStyle::textAnchor() const
-{
-    return m_textAnchor;
-}
-
-void QSvgFontStyle::setTextAnchor(const QString &anchor)
-{
-    m_textAnchor = anchor;
-}
-
 QSvgOpacityStyle::QSvgOpacityStyle(qreal opacity)
-    : m_opacity(opacity)
+    : m_opacity(opacity), m_oldOpacity(0)
 {
 
@@ -802 +938 @@
 {
     if (!m_link.isEmpty() && m_doc) {
-        QSvgStyleProperty *prop = m_doc->scopeStyle(m_link);
+        QSvgStyleProperty *prop = m_doc->styleProperty(m_link);
         if (prop) {
             if (prop->type() == QSvgStyleProperty::GRADIENT) {
@@ -809 +945 @@
                 st->resolveStops();
                 m_gradient->setStops(st->qgradient()->stops());
+                m_gradientStopsSet = st->gradientStopsSet();
             }
+        } else {
+            qWarning("Could not resolve property : %s", qPrintable(m_link));
         }
         m_link = QString();