| /* |
| * Copyright (C) Research In Motion Limited 2010, 2011. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #include "config.h" |
| |
| #if ENABLE(SVG) |
| #include "SVGPathBlender.h" |
| |
| #include "SVGPathSeg.h" |
| |
| namespace WebCore { |
| |
| SVGPathBlender::SVGPathBlender() |
| : m_fromSource(0) |
| , m_toSource(0) |
| , m_consumer(0) |
| , m_progress(0) |
| { |
| } |
| |
| // Helper functions |
| static inline FloatPoint blendFloatPoint(const FloatPoint& a, const FloatPoint& b, float progress) |
| { |
| return FloatPoint((b.x() - a.x()) * progress + a.x(), (b.y() - a.y()) * progress + a.y()); |
| } |
| |
| static inline float blendAnimatedFloat(float from, float to, float progress) |
| { |
| return (to - from) * progress + from; |
| } |
| |
| float SVGPathBlender::blendAnimatedDimensonalFloat(float from, float to, FloatBlendMode blendMode) |
| { |
| if (m_fromMode == m_toMode) |
| return blendAnimatedFloat(from, to, m_progress); |
| |
| float fromValue = blendMode == BlendHorizontal ? m_fromCurrentPoint.x() : m_fromCurrentPoint.y(); |
| float toValue = blendMode == BlendHorizontal ? m_toCurrentPoint.x() : m_toCurrentPoint.y(); |
| |
| // Transform toY to the coordinate mode of fromY |
| float animValue = blendAnimatedFloat(from, m_fromMode == AbsoluteCoordinates ? to + toValue : to - toValue, m_progress); |
| |
| if (m_isInFirstHalfOfAnimation) |
| return animValue; |
| |
| // Transform the animated point to the coordinate mode, needed for the current progress. |
| float currentValue = blendAnimatedFloat(fromValue, toValue, m_progress); |
| return m_toMode == AbsoluteCoordinates ? animValue + currentValue : animValue - currentValue; |
| } |
| |
| FloatPoint SVGPathBlender::blendAnimatedFloatPoint(const FloatPoint& fromPoint, const FloatPoint& toPoint) |
| { |
| if (m_fromMode == m_toMode) |
| return blendFloatPoint(fromPoint, toPoint, m_progress); |
| |
| // Transform toPoint to the coordinate mode of fromPoint |
| FloatPoint animatedPoint = toPoint; |
| if (m_fromMode == AbsoluteCoordinates) |
| animatedPoint += m_toCurrentPoint; |
| else |
| animatedPoint.move(-m_toCurrentPoint.x(), -m_toCurrentPoint.y()); |
| |
| animatedPoint = blendFloatPoint(fromPoint, animatedPoint, m_progress); |
| |
| if (m_isInFirstHalfOfAnimation) |
| return animatedPoint; |
| |
| // Transform the animated point to the coordinate mode, needed for the current progress. |
| FloatPoint currentPoint = blendFloatPoint(m_fromCurrentPoint, m_toCurrentPoint, m_progress); |
| if (m_toMode == AbsoluteCoordinates) |
| return animatedPoint + currentPoint; |
| |
| animatedPoint.move(-currentPoint.x(), -currentPoint.y()); |
| return animatedPoint; |
| } |
| |
| bool SVGPathBlender::blendMoveToSegment() |
| { |
| FloatPoint fromTargetPoint; |
| FloatPoint toTargetPoint; |
| if (!m_fromSource->parseMoveToSegment(fromTargetPoint) |
| || !m_toSource->parseMoveToSegment(toTargetPoint)) |
| return false; |
| |
| m_consumer->moveTo(blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint), false, m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint; |
| m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint; |
| return true; |
| } |
| |
| bool SVGPathBlender::blendLineToSegment() |
| { |
| FloatPoint fromTargetPoint; |
| FloatPoint toTargetPoint; |
| if (!m_fromSource->parseLineToSegment(fromTargetPoint) |
| || !m_toSource->parseLineToSegment(toTargetPoint)) |
| return false; |
| |
| m_consumer->lineTo(blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint), m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint; |
| m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint; |
| return true; |
| } |
| |
| bool SVGPathBlender::blendLineToHorizontalSegment() |
| { |
| float fromX; |
| float toX; |
| if (!m_fromSource->parseLineToHorizontalSegment(fromX) |
| || !m_toSource->parseLineToHorizontalSegment(toX)) |
| return false; |
| |
| m_consumer->lineToHorizontal(blendAnimatedDimensonalFloat(fromX, toX, BlendHorizontal), m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint.setX(m_fromMode == AbsoluteCoordinates ? fromX : m_fromCurrentPoint.x() + fromX); |
| m_toCurrentPoint.setX(m_toMode == AbsoluteCoordinates ? toX : m_toCurrentPoint.x() + toX); |
| return true; |
| } |
| |
| bool SVGPathBlender::blendLineToVerticalSegment() |
| { |
| float fromY; |
| float toY; |
| if (!m_fromSource->parseLineToVerticalSegment(fromY) |
| || !m_toSource->parseLineToVerticalSegment(toY)) |
| return false; |
| |
| m_consumer->lineToVertical(blendAnimatedDimensonalFloat(fromY, toY, BlendVertical), m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint.setY(m_fromMode == AbsoluteCoordinates ? fromY : m_fromCurrentPoint.y() + fromY); |
| m_toCurrentPoint.setY(m_toMode == AbsoluteCoordinates ? toY : m_toCurrentPoint.y() + toY); |
| return true; |
| } |
| |
| bool SVGPathBlender::blendCurveToCubicSegment() |
| { |
| FloatPoint fromTargetPoint; |
| FloatPoint fromPoint1; |
| FloatPoint fromPoint2; |
| FloatPoint toTargetPoint; |
| FloatPoint toPoint1; |
| FloatPoint toPoint2; |
| if (!m_fromSource->parseCurveToCubicSegment(fromPoint1, fromPoint2, fromTargetPoint) |
| || !m_toSource->parseCurveToCubicSegment(toPoint1, toPoint2, toTargetPoint)) |
| return false; |
| |
| m_consumer->curveToCubic(blendAnimatedFloatPoint(fromPoint1, toPoint1), |
| blendAnimatedFloatPoint(fromPoint2, toPoint2), |
| blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint), |
| m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint; |
| m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint; |
| return true; |
| } |
| |
| bool SVGPathBlender::blendCurveToCubicSmoothSegment() |
| { |
| FloatPoint fromTargetPoint; |
| FloatPoint fromPoint2; |
| FloatPoint toTargetPoint; |
| FloatPoint toPoint2; |
| if (!m_fromSource->parseCurveToCubicSmoothSegment(fromPoint2, fromTargetPoint) |
| || !m_toSource->parseCurveToCubicSmoothSegment(toPoint2, toTargetPoint)) |
| return false; |
| |
| m_consumer->curveToCubicSmooth(blendAnimatedFloatPoint(fromPoint2, toPoint2), |
| blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint), |
| m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint; |
| m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint; |
| return true; |
| } |
| |
| bool SVGPathBlender::blendCurveToQuadraticSegment() |
| { |
| FloatPoint fromTargetPoint; |
| FloatPoint fromPoint1; |
| FloatPoint toTargetPoint; |
| FloatPoint toPoint1; |
| if (!m_fromSource->parseCurveToQuadraticSegment(fromPoint1, fromTargetPoint) |
| || !m_toSource->parseCurveToQuadraticSegment(toPoint1, toTargetPoint)) |
| return false; |
| |
| m_consumer->curveToQuadratic(blendAnimatedFloatPoint(fromPoint1, toPoint1), |
| blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint), |
| m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint; |
| m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint; |
| return true; |
| } |
| |
| bool SVGPathBlender::blendCurveToQuadraticSmoothSegment() |
| { |
| FloatPoint fromTargetPoint; |
| FloatPoint toTargetPoint; |
| if (!m_fromSource->parseCurveToQuadraticSmoothSegment(fromTargetPoint) |
| || !m_toSource->parseCurveToQuadraticSmoothSegment(toTargetPoint)) |
| return false; |
| |
| m_consumer->curveToQuadraticSmooth(blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint), m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint; |
| m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint; |
| return true; |
| } |
| |
| bool SVGPathBlender::blendArcToSegment() |
| { |
| float fromRx; |
| float fromRy; |
| float fromAngle; |
| bool fromLargeArc; |
| bool fromSweep; |
| FloatPoint fromTargetPoint; |
| float toRx; |
| float toRy; |
| float toAngle; |
| bool toLargeArc; |
| bool toSweep; |
| FloatPoint toTargetPoint; |
| if (!m_fromSource->parseArcToSegment(fromRx, fromRy, fromAngle, fromLargeArc, fromSweep, fromTargetPoint) |
| || !m_toSource->parseArcToSegment(toRx, toRy, toAngle, toLargeArc, toSweep, toTargetPoint)) |
| return false; |
| |
| m_consumer->arcTo(blendAnimatedFloat(fromRx, toRx, m_progress), |
| blendAnimatedFloat(fromRy, toRy, m_progress), |
| blendAnimatedFloat(fromAngle, toAngle, m_progress), |
| m_isInFirstHalfOfAnimation ? fromLargeArc : toLargeArc, |
| m_isInFirstHalfOfAnimation ? fromSweep : toSweep, |
| blendAnimatedFloatPoint(fromTargetPoint, toTargetPoint), |
| m_isInFirstHalfOfAnimation ? m_fromMode : m_toMode); |
| m_fromCurrentPoint = m_fromMode == AbsoluteCoordinates ? fromTargetPoint : m_fromCurrentPoint + fromTargetPoint; |
| m_toCurrentPoint = m_toMode == AbsoluteCoordinates ? toTargetPoint : m_toCurrentPoint + toTargetPoint; |
| return true; |
| } |
| |
| static inline PathCoordinateMode coordinateModeOfCommand(const SVGPathSegType& type) |
| { |
| if (type < PathSegMoveToAbs) |
| return AbsoluteCoordinates; |
| |
| // Odd number = relative command |
| if (type % 2) |
| return RelativeCoordinates; |
| |
| return AbsoluteCoordinates; |
| } |
| |
| static inline bool isSegmentEqual(const SVGPathSegType& fromType, const SVGPathSegType& toType, const PathCoordinateMode& fromMode, const PathCoordinateMode& toMode) |
| { |
| if (fromType == toType && (fromType == PathSegUnknown || fromType == PathSegClosePath)) |
| return true; |
| |
| unsigned short from = fromType; |
| unsigned short to = toType; |
| if (fromMode == toMode) |
| return from == to; |
| if (fromMode == AbsoluteCoordinates) |
| return from == to - 1; |
| return to == from - 1; |
| } |
| |
| bool SVGPathBlender::blendAnimatedPath(float progress, SVGPathSource* fromSource, SVGPathSource* toSource, SVGPathConsumer* consumer) |
| { |
| ASSERT(fromSource); |
| ASSERT(toSource); |
| ASSERT(consumer); |
| m_fromSource = fromSource; |
| m_toSource = toSource; |
| m_consumer = consumer; |
| m_isInFirstHalfOfAnimation = progress < 0.5f; |
| |
| m_progress = progress; |
| while (true) { |
| SVGPathSegType fromCommand; |
| SVGPathSegType toCommand; |
| if (!m_fromSource->parseSVGSegmentType(fromCommand) || !m_toSource->parseSVGSegmentType(toCommand)) |
| return false; |
| |
| m_fromMode = coordinateModeOfCommand(fromCommand); |
| m_toMode = coordinateModeOfCommand(toCommand); |
| if (!isSegmentEqual(fromCommand, toCommand, m_fromMode, m_toMode)) |
| return false; |
| |
| switch (fromCommand) { |
| case PathSegMoveToRel: |
| case PathSegMoveToAbs: |
| if (!blendMoveToSegment()) |
| return false; |
| break; |
| case PathSegLineToRel: |
| case PathSegLineToAbs: |
| if (!blendLineToSegment()) |
| return false; |
| break; |
| case PathSegLineToHorizontalRel: |
| case PathSegLineToHorizontalAbs: |
| if (!blendLineToHorizontalSegment()) |
| return false; |
| break; |
| case PathSegLineToVerticalRel: |
| case PathSegLineToVerticalAbs: |
| if (!blendLineToVerticalSegment()) |
| return false; |
| break; |
| case PathSegClosePath: |
| m_consumer->closePath(); |
| break; |
| case PathSegCurveToCubicRel: |
| case PathSegCurveToCubicAbs: |
| if (!blendCurveToCubicSegment()) |
| return false; |
| break; |
| case PathSegCurveToCubicSmoothRel: |
| case PathSegCurveToCubicSmoothAbs: |
| if (!blendCurveToCubicSmoothSegment()) |
| return false; |
| break; |
| case PathSegCurveToQuadraticRel: |
| case PathSegCurveToQuadraticAbs: |
| if (!blendCurveToQuadraticSegment()) |
| return false; |
| break; |
| case PathSegCurveToQuadraticSmoothRel: |
| case PathSegCurveToQuadraticSmoothAbs: |
| if (!blendCurveToQuadraticSmoothSegment()) |
| return false; |
| break; |
| case PathSegArcRel: |
| case PathSegArcAbs: |
| if (!blendArcToSegment()) |
| return false; |
| break; |
| default: |
| return false; |
| } |
| if (m_fromSource->hasMoreData() != m_toSource->hasMoreData()) |
| return false; |
| if (!m_fromSource->hasMoreData() || !m_toSource->hasMoreData()) |
| break; |
| } |
| return true; |
| } |
| |
| void SVGPathBlender::cleanup() |
| { |
| ASSERT(m_toSource); |
| ASSERT(m_fromSource); |
| ASSERT(m_consumer); |
| |
| m_consumer->cleanup(); |
| m_toSource = 0; |
| m_fromSource = 0; |
| m_consumer = 0; |
| m_fromCurrentPoint = FloatPoint(); |
| m_toCurrentPoint = FloatPoint(); |
| } |
| |
| } |
| |
| #endif // ENABLE(SVG) |
