third_party/WebKit/Source/core/svg/SVGPathBlender.cpp - chromium/src - Git at Google

 /*
  * 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 "core/svg/SVGPathBlender.h"

 #include "core/svg/SVGPathByteStreamSource.h"
 #include "core/svg/SVGPathConsumer.h"
 #include "core/svg/SVGPathData.h"
 #include "platform/animation/AnimationUtilities.h"

 namespace blink {

 enum FloatBlendMode {
     BlendHorizontal,
     BlendVertical
 };

 class SVGPathBlender::BlendState {
 public:
     BlendState(float progress, unsigned addTypesCount = 0)
         : m_progress(progress)
         , m_addTypesCount(addTypesCount)
         , m_isInFirstHalfOfAnimation(progress < 0.5f)
         , m_typesAreEqual(false)
         , m_fromIsAbsolute(false)
     {
     }

     bool blendSegments(const PathSegmentData& fromSeg, const PathSegmentData& toSeg, PathSegmentData&);

 private:
     float blendAnimatedDimensonalFloat(float, float, FloatBlendMode);
     FloatPoint blendAnimatedFloatPointSameCoordinates(const FloatPoint& from, const FloatPoint& to);
     FloatPoint blendAnimatedFloatPoint(const FloatPoint& from, const FloatPoint& to);
     bool canBlend(const PathSegmentData& fromSeg, const PathSegmentData& toSeg);

     FloatPoint m_fromSubPathPoint;
     FloatPoint m_fromCurrentPoint;
     FloatPoint m_toSubPathPoint;
     FloatPoint m_toCurrentPoint;

     float m_progress;
     unsigned m_addTypesCount;
     bool m_isInFirstHalfOfAnimation;
     // This is per-segment blend state corresponding to the 'from' and 'to'
     // segments currently being blended, and only used within blendSegments().
     bool m_typesAreEqual;
     bool m_fromIsAbsolute;
 };

 // Helper functions
 static inline FloatPoint blendFloatPoint(const FloatPoint& a, const FloatPoint& b, float progress)
 {
     return FloatPoint(blend(a.x(), b.x(), progress), blend(a.y(), b.y(), progress));
 }

 float SVGPathBlender::BlendState::blendAnimatedDimensonalFloat(float from, float to, FloatBlendMode blendMode)
 {
     if (m_addTypesCount) {
         ASSERT(m_typesAreEqual);
         return from + to * m_addTypesCount;
     }

     if (m_typesAreEqual)
         return blend(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 = blend(from, m_fromIsAbsolute ? to + toValue : to - toValue, m_progress);

     // If we're in the first half of the animation, we should use the type of the from segment.
     if (m_isInFirstHalfOfAnimation)
         return animValue;

     // Transform the animated point to the coordinate mode, needed for the current progress.
     float currentValue = blend(fromValue, toValue, m_progress);
     return !m_fromIsAbsolute ? animValue + currentValue : animValue - currentValue;
 }

 FloatPoint SVGPathBlender::BlendState::blendAnimatedFloatPointSameCoordinates(const FloatPoint& fromPoint, const FloatPoint& toPoint)
 {
     if (m_addTypesCount) {
         FloatPoint repeatedToPoint = toPoint;
         repeatedToPoint.scale(m_addTypesCount, m_addTypesCount);
         return fromPoint + repeatedToPoint;
     }
     return blendFloatPoint(fromPoint, toPoint, m_progress);
 }

 FloatPoint SVGPathBlender::BlendState::blendAnimatedFloatPoint(const FloatPoint& fromPoint, const FloatPoint& toPoint)
 {
     if (m_typesAreEqual)
         return blendAnimatedFloatPointSameCoordinates(fromPoint, toPoint);

     // Transform toPoint to the coordinate mode of fromPoint
     FloatPoint animatedPoint = toPoint;
     if (m_fromIsAbsolute)
         animatedPoint += m_toCurrentPoint;
     else
         animatedPoint.move(-m_toCurrentPoint.x(), -m_toCurrentPoint.y());

     animatedPoint = blendFloatPoint(fromPoint, animatedPoint, m_progress);

     // If we're in the first half of the animation, we should use the type of the from segment.
     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_fromIsAbsolute)
         return animatedPoint + currentPoint;

     animatedPoint.move(-currentPoint.x(), -currentPoint.y());
     return animatedPoint;
 }

 bool SVGPathBlender::BlendState::canBlend(const PathSegmentData& fromSeg, const PathSegmentData& toSeg)
 {
     // Update state first because we'll need it if we return true below.
     m_typesAreEqual = fromSeg.command == toSeg.command;
     m_fromIsAbsolute = isAbsolutePathSegType(fromSeg.command);

     // If the types are equal, they'll blend regardless of parameters.
     if (m_typesAreEqual)
         return true;

     // Addition require segments with the same type.
     if (m_addTypesCount)
         return false;

     // Allow the segments to differ in "relativeness".
     return toAbsolutePathSegType(fromSeg.command) == toAbsolutePathSegType(toSeg.command);
 }

 static void updateCurrentPoint(FloatPoint& subPathPoint, FloatPoint& currentPoint, const PathSegmentData& segment)
 {
     switch (segment.command) {
     case PathSegMoveToRel:
         currentPoint += segment.targetPoint;
         subPathPoint = currentPoint;
         break;
     case PathSegLineToRel:
     case PathSegCurveToCubicRel:
     case PathSegCurveToQuadraticRel:
     case PathSegArcRel:
     case PathSegLineToHorizontalRel:
     case PathSegLineToVerticalRel:
     case PathSegCurveToCubicSmoothRel:
     case PathSegCurveToQuadraticSmoothRel:
         currentPoint += segment.targetPoint;
         break;
     case PathSegMoveToAbs:
         currentPoint = segment.targetPoint;
         subPathPoint = currentPoint;
         break;
     case PathSegLineToAbs:
     case PathSegCurveToCubicAbs:
     case PathSegCurveToQuadraticAbs:
     case PathSegArcAbs:
     case PathSegCurveToCubicSmoothAbs:
     case PathSegCurveToQuadraticSmoothAbs:
         currentPoint = segment.targetPoint;
         break;
     case PathSegLineToHorizontalAbs:
         currentPoint.setX(segment.targetPoint.x());
         break;
     case PathSegLineToVerticalAbs:
         currentPoint.setY(segment.targetPoint.y());
         break;
     case PathSegClosePath:
         currentPoint = subPathPoint;
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 }

 bool SVGPathBlender::BlendState::blendSegments(const PathSegmentData& fromSeg, const PathSegmentData& toSeg, PathSegmentData& blendedSegment)
 {
     if (!canBlend(fromSeg, toSeg))
         return false;

     blendedSegment.command = m_isInFirstHalfOfAnimation ? fromSeg.command : toSeg.command;

     switch (toSeg.command) {
     case PathSegCurveToCubicRel:
     case PathSegCurveToCubicAbs:
         blendedSegment.point1 = blendAnimatedFloatPoint(fromSeg.point1, toSeg.point1);
         /* fall through */
     case PathSegCurveToCubicSmoothRel:
     case PathSegCurveToCubicSmoothAbs:
         blendedSegment.point2 = blendAnimatedFloatPoint(fromSeg.point2, toSeg.point2);
         /* fall through */
     case PathSegMoveToRel:
     case PathSegMoveToAbs:
     case PathSegLineToRel:
     case PathSegLineToAbs:
     case PathSegCurveToQuadraticSmoothRel:
     case PathSegCurveToQuadraticSmoothAbs:
         blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint);
         break;
     case PathSegLineToHorizontalRel:
     case PathSegLineToHorizontalAbs:
         blendedSegment.targetPoint.setX(blendAnimatedDimensonalFloat(fromSeg.targetPoint.x(), toSeg.targetPoint.x(), BlendHorizontal));
         break;
     case PathSegLineToVerticalRel:
     case PathSegLineToVerticalAbs:
         blendedSegment.targetPoint.setY(blendAnimatedDimensonalFloat(fromSeg.targetPoint.y(), toSeg.targetPoint.y(), BlendVertical));
         break;
     case PathSegClosePath:
         break;
     case PathSegCurveToQuadraticRel:
     case PathSegCurveToQuadraticAbs:
         blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint);
         blendedSegment.point1 = blendAnimatedFloatPoint(fromSeg.point1, toSeg.point1);
         break;
     case PathSegArcRel:
     case PathSegArcAbs:
         blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint);
         blendedSegment.point1 = blendAnimatedFloatPointSameCoordinates(fromSeg.arcRadii(), toSeg.arcRadii());
         blendedSegment.point2 = blendAnimatedFloatPointSameCoordinates(fromSeg.point2, toSeg.point2);
         if (m_addTypesCount) {
             blendedSegment.arcLarge = fromSeg.arcLarge || toSeg.arcLarge;
             blendedSegment.arcSweep = fromSeg.arcSweep || toSeg.arcSweep;
         } else {
             blendedSegment.arcLarge = m_isInFirstHalfOfAnimation ? fromSeg.arcLarge : toSeg.arcLarge;
             blendedSegment.arcSweep = m_isInFirstHalfOfAnimation ? fromSeg.arcSweep : toSeg.arcSweep;
         }
         break;
     default:
         ASSERT_NOT_REACHED();
     }

     updateCurrentPoint(m_fromSubPathPoint, m_fromCurrentPoint, fromSeg);
     updateCurrentPoint(m_toSubPathPoint, m_toCurrentPoint, toSeg);

     return true;
 }

 SVGPathBlender::SVGPathBlender(SVGPathByteStreamSource* fromSource, SVGPathByteStreamSource* toSource, SVGPathConsumer* consumer)
     : m_fromSource(fromSource)
     , m_toSource(toSource)
     , m_consumer(consumer)
 {
     ASSERT(m_fromSource);
     ASSERT(m_toSource);
     ASSERT(m_consumer);
 }

 bool SVGPathBlender::addAnimatedPath(unsigned repeatCount)
 {
     BlendState blendState(0, repeatCount);
     return blendAnimatedPath(blendState);
 }

 bool SVGPathBlender::blendAnimatedPath(float progress)
 {
     BlendState blendState(progress);
     return blendAnimatedPath(blendState);
 }

 bool SVGPathBlender::blendAnimatedPath(BlendState& blendState)
 {
     bool fromSourceIsEmpty = !m_fromSource->hasMoreData();
     while (m_toSource->hasMoreData()) {
         PathSegmentData toSeg = m_toSource->parseSegment();
         if (toSeg.command == PathSegUnknown)
             return false;

         PathSegmentData fromSeg;
         fromSeg.command = toSeg.command;

         if (m_fromSource->hasMoreData()) {
             fromSeg = m_fromSource->parseSegment();
             if (fromSeg.command == PathSegUnknown)
                 return false;
         }

         PathSegmentData blendedSeg;
         if (!blendState.blendSegments(fromSeg, toSeg, blendedSeg))
             return false;

         m_consumer->emitSegment(blendedSeg);

         if (fromSourceIsEmpty)
             continue;
         if (m_fromSource->hasMoreData() != m_toSource->hasMoreData())
             return false;
     }
     return true;
 }

 } // namespace blink
	/*
	* 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 "core/svg/SVGPathBlender.h"

	#include "core/svg/SVGPathByteStreamSource.h"
	#include "core/svg/SVGPathConsumer.h"
	#include "core/svg/SVGPathData.h"
	#include "platform/animation/AnimationUtilities.h"

	namespace blink {

	enum FloatBlendMode {
	BlendHorizontal,
	BlendVertical
	};

	class SVGPathBlender::BlendState {
	public:
	BlendState(float progress, unsigned addTypesCount = 0)
	: m_progress(progress)
	, m_addTypesCount(addTypesCount)
	, m_isInFirstHalfOfAnimation(progress < 0.5f)
	, m_typesAreEqual(false)
	, m_fromIsAbsolute(false)
	{
	}

	bool blendSegments(const PathSegmentData& fromSeg, const PathSegmentData& toSeg, PathSegmentData&);

	private:
	float blendAnimatedDimensonalFloat(float, float, FloatBlendMode);
	FloatPoint blendAnimatedFloatPointSameCoordinates(const FloatPoint& from, const FloatPoint& to);
	FloatPoint blendAnimatedFloatPoint(const FloatPoint& from, const FloatPoint& to);
	bool canBlend(const PathSegmentData& fromSeg, const PathSegmentData& toSeg);

	FloatPoint m_fromSubPathPoint;
	FloatPoint m_fromCurrentPoint;
	FloatPoint m_toSubPathPoint;
	FloatPoint m_toCurrentPoint;

	float m_progress;
	unsigned m_addTypesCount;
	bool m_isInFirstHalfOfAnimation;
	// This is per-segment blend state corresponding to the 'from' and 'to'
	// segments currently being blended, and only used within blendSegments().
	bool m_typesAreEqual;
	bool m_fromIsAbsolute;
	};

	// Helper functions
	static inline FloatPoint blendFloatPoint(const FloatPoint& a, const FloatPoint& b, float progress)
	{
	return FloatPoint(blend(a.x(), b.x(), progress), blend(a.y(), b.y(), progress));
	}

	float SVGPathBlender::BlendState::blendAnimatedDimensonalFloat(float from, float to, FloatBlendMode blendMode)
	{
	if (m_addTypesCount) {
	ASSERT(m_typesAreEqual);
	return from + to * m_addTypesCount;
	}

	if (m_typesAreEqual)
	return blend(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 = blend(from, m_fromIsAbsolute ? to + toValue : to - toValue, m_progress);

	// If we're in the first half of the animation, we should use the type of the from segment.
	if (m_isInFirstHalfOfAnimation)
	return animValue;

	// Transform the animated point to the coordinate mode, needed for the current progress.
	float currentValue = blend(fromValue, toValue, m_progress);
	return !m_fromIsAbsolute ? animValue + currentValue : animValue - currentValue;
	}

	FloatPoint SVGPathBlender::BlendState::blendAnimatedFloatPointSameCoordinates(const FloatPoint& fromPoint, const FloatPoint& toPoint)
	{
	if (m_addTypesCount) {
	FloatPoint repeatedToPoint = toPoint;
	repeatedToPoint.scale(m_addTypesCount, m_addTypesCount);
	return fromPoint + repeatedToPoint;
	}
	return blendFloatPoint(fromPoint, toPoint, m_progress);
	}

	FloatPoint SVGPathBlender::BlendState::blendAnimatedFloatPoint(const FloatPoint& fromPoint, const FloatPoint& toPoint)
	{
	if (m_typesAreEqual)
	return blendAnimatedFloatPointSameCoordinates(fromPoint, toPoint);

	// Transform toPoint to the coordinate mode of fromPoint
	FloatPoint animatedPoint = toPoint;
	if (m_fromIsAbsolute)
	animatedPoint += m_toCurrentPoint;
	else
	animatedPoint.move(-m_toCurrentPoint.x(), -m_toCurrentPoint.y());

	animatedPoint = blendFloatPoint(fromPoint, animatedPoint, m_progress);

	// If we're in the first half of the animation, we should use the type of the from segment.
	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_fromIsAbsolute)
	return animatedPoint + currentPoint;

	animatedPoint.move(-currentPoint.x(), -currentPoint.y());
	return animatedPoint;
	}

	bool SVGPathBlender::BlendState::canBlend(const PathSegmentData& fromSeg, const PathSegmentData& toSeg)
	{
	// Update state first because we'll need it if we return true below.
	m_typesAreEqual = fromSeg.command == toSeg.command;
	m_fromIsAbsolute = isAbsolutePathSegType(fromSeg.command);

	// If the types are equal, they'll blend regardless of parameters.
	if (m_typesAreEqual)
	return true;

	// Addition require segments with the same type.
	if (m_addTypesCount)
	return false;

	// Allow the segments to differ in "relativeness".
	return toAbsolutePathSegType(fromSeg.command) == toAbsolutePathSegType(toSeg.command);
	}

	static void updateCurrentPoint(FloatPoint& subPathPoint, FloatPoint& currentPoint, const PathSegmentData& segment)
	{
	switch (segment.command) {
	case PathSegMoveToRel:
	currentPoint += segment.targetPoint;
	subPathPoint = currentPoint;
	break;
	case PathSegLineToRel:
	case PathSegCurveToCubicRel:
	case PathSegCurveToQuadraticRel:
	case PathSegArcRel:
	case PathSegLineToHorizontalRel:
	case PathSegLineToVerticalRel:
	case PathSegCurveToCubicSmoothRel:
	case PathSegCurveToQuadraticSmoothRel:
	currentPoint += segment.targetPoint;
	break;
	case PathSegMoveToAbs:
	currentPoint = segment.targetPoint;
	subPathPoint = currentPoint;
	break;
	case PathSegLineToAbs:
	case PathSegCurveToCubicAbs:
	case PathSegCurveToQuadraticAbs:
	case PathSegArcAbs:
	case PathSegCurveToCubicSmoothAbs:
	case PathSegCurveToQuadraticSmoothAbs:
	currentPoint = segment.targetPoint;
	break;
	case PathSegLineToHorizontalAbs:
	currentPoint.setX(segment.targetPoint.x());
	break;
	case PathSegLineToVerticalAbs:
	currentPoint.setY(segment.targetPoint.y());
	break;
	case PathSegClosePath:
	currentPoint = subPathPoint;
	break;
	default:
	ASSERT_NOT_REACHED();
	}
	}

	bool SVGPathBlender::BlendState::blendSegments(const PathSegmentData& fromSeg, const PathSegmentData& toSeg, PathSegmentData& blendedSegment)
	{
	if (!canBlend(fromSeg, toSeg))
	return false;

	blendedSegment.command = m_isInFirstHalfOfAnimation ? fromSeg.command : toSeg.command;

	switch (toSeg.command) {
	case PathSegCurveToCubicRel:
	case PathSegCurveToCubicAbs:
	blendedSegment.point1 = blendAnimatedFloatPoint(fromSeg.point1, toSeg.point1);
	/* fall through */
	case PathSegCurveToCubicSmoothRel:
	case PathSegCurveToCubicSmoothAbs:
	blendedSegment.point2 = blendAnimatedFloatPoint(fromSeg.point2, toSeg.point2);
	/* fall through */
	case PathSegMoveToRel:
	case PathSegMoveToAbs:
	case PathSegLineToRel:
	case PathSegLineToAbs:
	case PathSegCurveToQuadraticSmoothRel:
	case PathSegCurveToQuadraticSmoothAbs:
	blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint);
	break;
	case PathSegLineToHorizontalRel:
	case PathSegLineToHorizontalAbs:
	blendedSegment.targetPoint.setX(blendAnimatedDimensonalFloat(fromSeg.targetPoint.x(), toSeg.targetPoint.x(), BlendHorizontal));
	break;
	case PathSegLineToVerticalRel:
	case PathSegLineToVerticalAbs:
	blendedSegment.targetPoint.setY(blendAnimatedDimensonalFloat(fromSeg.targetPoint.y(), toSeg.targetPoint.y(), BlendVertical));
	break;
	case PathSegClosePath:
	break;
	case PathSegCurveToQuadraticRel:
	case PathSegCurveToQuadraticAbs:
	blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint);
	blendedSegment.point1 = blendAnimatedFloatPoint(fromSeg.point1, toSeg.point1);
	break;
	case PathSegArcRel:
	case PathSegArcAbs:
	blendedSegment.targetPoint = blendAnimatedFloatPoint(fromSeg.targetPoint, toSeg.targetPoint);
	blendedSegment.point1 = blendAnimatedFloatPointSameCoordinates(fromSeg.arcRadii(), toSeg.arcRadii());
	blendedSegment.point2 = blendAnimatedFloatPointSameCoordinates(fromSeg.point2, toSeg.point2);
	if (m_addTypesCount) {
	blendedSegment.arcLarge = fromSeg.arcLarge \|\| toSeg.arcLarge;
	blendedSegment.arcSweep = fromSeg.arcSweep \|\| toSeg.arcSweep;
	} else {
	blendedSegment.arcLarge = m_isInFirstHalfOfAnimation ? fromSeg.arcLarge : toSeg.arcLarge;
	blendedSegment.arcSweep = m_isInFirstHalfOfAnimation ? fromSeg.arcSweep : toSeg.arcSweep;
	}
	break;
	default:
	ASSERT_NOT_REACHED();
	}

	updateCurrentPoint(m_fromSubPathPoint, m_fromCurrentPoint, fromSeg);
	updateCurrentPoint(m_toSubPathPoint, m_toCurrentPoint, toSeg);

	return true;
	}

	SVGPathBlender::SVGPathBlender(SVGPathByteStreamSource* fromSource, SVGPathByteStreamSource* toSource, SVGPathConsumer* consumer)
	: m_fromSource(fromSource)
	, m_toSource(toSource)
	, m_consumer(consumer)
	{
	ASSERT(m_fromSource);
	ASSERT(m_toSource);
	ASSERT(m_consumer);
	}

	bool SVGPathBlender::addAnimatedPath(unsigned repeatCount)
	{
	BlendState blendState(0, repeatCount);
	return blendAnimatedPath(blendState);
	}

	bool SVGPathBlender::blendAnimatedPath(float progress)
	{
	BlendState blendState(progress);
	return blendAnimatedPath(blendState);
	}

	bool SVGPathBlender::blendAnimatedPath(BlendState& blendState)
	{
	bool fromSourceIsEmpty = !m_fromSource->hasMoreData();
	while (m_toSource->hasMoreData()) {
	PathSegmentData toSeg = m_toSource->parseSegment();
	if (toSeg.command == PathSegUnknown)
	return false;

	PathSegmentData fromSeg;
	fromSeg.command = toSeg.command;

	if (m_fromSource->hasMoreData()) {
	fromSeg = m_fromSource->parseSegment();
	if (fromSeg.command == PathSegUnknown)
	return false;
	}

	PathSegmentData blendedSeg;
	if (!blendState.blendSegments(fromSeg, toSeg, blendedSeg))
	return false;

	m_consumer->emitSegment(blendedSeg);

	if (fromSourceIsEmpty)
	continue;
	if (m_fromSource->hasMoreData() != m_toSource->hasMoreData())
	return false;
	}
	return true;
	}

	} // namespace blink