third_party/WebKit/Source/core/svg/SVGPathBuilder.cpp

/*
 * Copyright (C) 2002, 2003 The Karbon Developers
 * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
 * Copyright (C) 2006, 2007 Rob Buis <buis@kde.org>
 * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
 * Copyright (C) Research In Motion Limited 2010. 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/SVGPathBuilder.h"

#include "platform/graphics/Path.h"

namespace blink {

FloatPoint SVGPathBuilder::smoothControl(bool isCompatibleSegment) const {
  // The control point is assumed to be the reflection of the control point on
  // the previous command relative to the current point. If there is no previous
  // command or if the previous command was not a [quad/cubic], assume the
  // control point is coincident with the current point.
  // [https://www.w3.org/TR/SVG/paths.html#PathDataCubicBezierCommands]
  // [https://www.w3.org/TR/SVG/paths.html#PathDataQuadraticBezierCommands]
  FloatPoint controlPoint = m_currentPoint;
  if (isCompatibleSegment)
    controlPoint += m_currentPoint - m_lastControlPoint;

  return controlPoint;
}

void SVGPathBuilder::emitClose() {
  m_path.closeSubpath();

  // At the end of the [closepath] command, the new current
  // point is set to the initial point of the current subpath.
  // [https://www.w3.org/TR/SVG/paths.html#PathDataClosePathCommand]
  m_currentPoint = m_subpathPoint;
}

void SVGPathBuilder::emitMoveTo(const FloatPoint& p) {
  m_path.moveTo(p);

  m_subpathPoint = p;
  m_currentPoint = p;
}

void SVGPathBuilder::emitLineTo(const FloatPoint& p) {
  m_path.addLineTo(p);
  m_currentPoint = p;
}

void SVGPathBuilder::emitQuadTo(const FloatPoint& c0, const FloatPoint& p) {
  m_path.addQuadCurveTo(c0, p);
  m_lastControlPoint = c0;
  m_currentPoint = p;
}

void SVGPathBuilder::emitSmoothQuadTo(const FloatPoint& p) {
  bool lastWasQuadratic = m_lastCommand == PathSegCurveToQuadraticAbs ||
                          m_lastCommand == PathSegCurveToQuadraticRel ||
                          m_lastCommand == PathSegCurveToQuadraticSmoothAbs ||
                          m_lastCommand == PathSegCurveToQuadraticSmoothRel;

  emitQuadTo(smoothControl(lastWasQuadratic), p);
}

void SVGPathBuilder::emitCubicTo(const FloatPoint& c0,
                                 const FloatPoint& c1,
                                 const FloatPoint& p) {
  m_path.addBezierCurveTo(c0, c1, p);
  m_lastControlPoint = c1;
  m_currentPoint = p;
}

void SVGPathBuilder::emitSmoothCubicTo(const FloatPoint& c1,
                                       const FloatPoint& p) {
  bool lastWasCubic = m_lastCommand == PathSegCurveToCubicAbs ||
                      m_lastCommand == PathSegCurveToCubicRel ||
                      m_lastCommand == PathSegCurveToCubicSmoothAbs ||
                      m_lastCommand == PathSegCurveToCubicSmoothRel;

  emitCubicTo(smoothControl(lastWasCubic), c1, p);
}

void SVGPathBuilder::emitArcTo(const FloatPoint& p,
                               const FloatSize& r,
                               float rotate,
                               bool largeArc,
                               bool sweep) {
  m_path.addArcTo(p, r, rotate, largeArc, sweep);
  m_currentPoint = p;
}

void SVGPathBuilder::emitSegment(const PathSegmentData& segment) {
  switch (segment.command) {
    case PathSegClosePath:
      emitClose();
      break;
    case PathSegMoveToAbs:
      emitMoveTo(segment.targetPoint);
      break;
    case PathSegMoveToRel:
      emitMoveTo(m_currentPoint + segment.targetPoint);
      break;
    case PathSegLineToAbs:
      emitLineTo(segment.targetPoint);
      break;
    case PathSegLineToRel:
      emitLineTo(m_currentPoint + segment.targetPoint);
      break;
    case PathSegLineToHorizontalAbs:
      emitLineTo(FloatPoint(segment.targetPoint.x(), m_currentPoint.y()));
      break;
    case PathSegLineToHorizontalRel:
      emitLineTo(m_currentPoint + FloatSize(segment.targetPoint.x(), 0));
      break;
    case PathSegLineToVerticalAbs:
      emitLineTo(FloatPoint(m_currentPoint.x(), segment.targetPoint.y()));
      break;
    case PathSegLineToVerticalRel:
      emitLineTo(m_currentPoint + FloatSize(0, segment.targetPoint.y()));
      break;
    case PathSegCurveToQuadraticAbs:
      emitQuadTo(segment.point1, segment.targetPoint);
      break;
    case PathSegCurveToQuadraticRel:
      emitQuadTo(m_currentPoint + segment.point1,
                 m_currentPoint + segment.targetPoint);
      break;
    case PathSegCurveToQuadraticSmoothAbs:
      emitSmoothQuadTo(segment.targetPoint);
      break;
    case PathSegCurveToQuadraticSmoothRel:
      emitSmoothQuadTo(m_currentPoint + segment.targetPoint);
      break;
    case PathSegCurveToCubicAbs:
      emitCubicTo(segment.point1, segment.point2, segment.targetPoint);
      break;
    case PathSegCurveToCubicRel:
      emitCubicTo(m_currentPoint + segment.point1,
                  m_currentPoint + segment.point2,
                  m_currentPoint + segment.targetPoint);
      break;
    case PathSegCurveToCubicSmoothAbs:
      emitSmoothCubicTo(segment.point2, segment.targetPoint);
      break;
    case PathSegCurveToCubicSmoothRel:
      emitSmoothCubicTo(m_currentPoint + segment.point2,
                        m_currentPoint + segment.targetPoint);
      break;
    case PathSegArcAbs:
      emitArcTo(segment.targetPoint, toFloatSize(segment.arcRadii()),
                segment.arcAngle(), segment.largeArcFlag(),
                segment.sweepFlag());
      break;
    case PathSegArcRel:
      emitArcTo(m_currentPoint + segment.targetPoint,
                toFloatSize(segment.arcRadii()), segment.arcAngle(),
                segment.largeArcFlag(), segment.sweepFlag());
      break;
    default:
      ASSERT_NOT_REACHED();
  }

  m_lastCommand = segment.command;
}

}  // namespace blink