libs/hwui/utils/VectorDrawableUtils.cpp - android_frameworks_base - Gitiles

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "VectorDrawableUtils.h"

 #include "PathParser.h"

 #include <math.h>
 #include <utils/Log.h>

 namespace android {
 namespace uirenderer {

 class PathResolver {
 public:
     float currentX = 0;
     float currentY = 0;
     float ctrlPointX = 0;
     float ctrlPointY = 0;
     float currentSegmentStartX = 0;
     float currentSegmentStartY = 0;
     void addCommand(SkPath* outPath, char previousCmd, char cmd, const std::vector<float>* points,
                     size_t start, size_t end);
 };

 bool VectorDrawableUtils::canMorph(const PathData& morphFrom, const PathData& morphTo) {
     if (morphFrom.verbs.size() != morphTo.verbs.size()) {
         return false;
     }

     for (unsigned int i = 0; i < morphFrom.verbs.size(); i++) {
         if (morphFrom.verbs[i] != morphTo.verbs[i] ||
             morphFrom.verbSizes[i] != morphTo.verbSizes[i]) {
             return false;
         }
     }
     return true;
 }

 bool VectorDrawableUtils::interpolatePathData(PathData* outData, const PathData& morphFrom,
                                               const PathData& morphTo, float fraction) {
     if (!canMorph(morphFrom, morphTo)) {
         return false;
     }
     interpolatePaths(outData, morphFrom, morphTo, fraction);
     return true;
 }

 /**
 * Convert an array of PathVerb to Path.
 */
 void VectorDrawableUtils::verbsToPath(SkPath* outPath, const PathData& data) {
     PathResolver resolver;
     char previousCommand = 'm';
     size_t start = 0;
     outPath->reset();
     for (unsigned int i = 0; i < data.verbs.size(); i++) {
         size_t verbSize = data.verbSizes[i];
         resolver.addCommand(outPath, previousCommand, data.verbs[i], &data.points, start,
                             start + verbSize);
         previousCommand = data.verbs[i];
         start += verbSize;
     }
 }

 /**
  * The current PathVerb will be interpolated between the
  * <code>nodeFrom</code> and <code>nodeTo</code> according to the
  * <code>fraction</code>.
  *
  * @param nodeFrom The start value as a PathVerb.
  * @param nodeTo The end value as a PathVerb
  * @param fraction The fraction to interpolate.
  */
 void VectorDrawableUtils::interpolatePaths(PathData* outData, const PathData& from,
                                            const PathData& to, float fraction) {
     outData->points.resize(from.points.size());
     outData->verbSizes = from.verbSizes;
     outData->verbs = from.verbs;

     for (size_t i = 0; i < from.points.size(); i++) {
         outData->points[i] = from.points[i] * (1 - fraction) + to.points[i] * fraction;
     }
 }

 // Use the given verb, and points in the range [start, end) to insert a command into the SkPath.
 void PathResolver::addCommand(SkPath* outPath, char previousCmd, char cmd,
                               const std::vector<float>* points, size_t start, size_t end) {
     int incr = 2;
     float reflectiveCtrlPointX;
     float reflectiveCtrlPointY;

     switch (cmd) {
         case 'z':
         case 'Z':
             outPath->close();
             // Path is closed here, but we need to move the pen to the
             // closed position. So we cache the segment's starting position,
             // and restore it here.
             currentX = currentSegmentStartX;
             currentY = currentSegmentStartY;
             ctrlPointX = currentSegmentStartX;
             ctrlPointY = currentSegmentStartY;
             outPath->moveTo(currentX, currentY);
             break;
         case 'm':
         case 'M':
         case 'l':
         case 'L':
         case 't':
         case 'T':
             incr = 2;
             break;
         case 'h':
         case 'H':
         case 'v':
         case 'V':
             incr = 1;
             break;
         case 'c':
         case 'C':
             incr = 6;
             break;
         case 's':
         case 'S':
         case 'q':
         case 'Q':
             incr = 4;
             break;
         case 'a':
         case 'A':
             incr = 7;
             break;
     }

     for (unsigned int k = start; k < end; k += incr) {
         switch (cmd) {
             case 'm':  // moveto - Start a new sub-path (relative)
                 currentX += points->at(k + 0);
                 currentY += points->at(k + 1);
                 if (k > start) {
                     // According to the spec, if a moveto is followed by multiple
                     // pairs of coordinates, the subsequent pairs are treated as
                     // implicit lineto commands.
                     outPath->rLineTo(points->at(k + 0), points->at(k + 1));
                 } else {
                     outPath->rMoveTo(points->at(k + 0), points->at(k + 1));
                     currentSegmentStartX = currentX;
                     currentSegmentStartY = currentY;
                 }
                 break;
             case 'M':  // moveto - Start a new sub-path
                 currentX = points->at(k + 0);
                 currentY = points->at(k + 1);
                 if (k > start) {
                     // According to the spec, if a moveto is followed by multiple
                     // pairs of coordinates, the subsequent pairs are treated as
                     // implicit lineto commands.
                     outPath->lineTo(points->at(k + 0), points->at(k + 1));
                 } else {
                     outPath->moveTo(points->at(k + 0), points->at(k + 1));
                     currentSegmentStartX = currentX;
                     currentSegmentStartY = currentY;
                 }
                 break;
             case 'l':  // lineto - Draw a line from the current point (relative)
                 outPath->rLineTo(points->at(k + 0), points->at(k + 1));
                 currentX += points->at(k + 0);
                 currentY += points->at(k + 1);
                 break;
             case 'L':  // lineto - Draw a line from the current point
                 outPath->lineTo(points->at(k + 0), points->at(k + 1));
                 currentX = points->at(k + 0);
                 currentY = points->at(k + 1);
                 break;
             case 'h':  // horizontal lineto - Draws a horizontal line (relative)
                 outPath->rLineTo(points->at(k + 0), 0);
                 currentX += points->at(k + 0);
                 break;
             case 'H':  // horizontal lineto - Draws a horizontal line
                 outPath->lineTo(points->at(k + 0), currentY);
                 currentX = points->at(k + 0);
                 break;
             case 'v':  // vertical lineto - Draws a vertical line from the current point (r)
                 outPath->rLineTo(0, points->at(k + 0));
                 currentY += points->at(k + 0);
                 break;
             case 'V':  // vertical lineto - Draws a vertical line from the current point
                 outPath->lineTo(currentX, points->at(k + 0));
                 currentY = points->at(k + 0);
                 break;
             case 'c':  // curveto - Draws a cubic Bézier curve (relative)
                 outPath->rCubicTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
                                   points->at(k + 3), points->at(k + 4), points->at(k + 5));

                 ctrlPointX = currentX + points->at(k + 2);
                 ctrlPointY = currentY + points->at(k + 3);
                 currentX += points->at(k + 4);
                 currentY += points->at(k + 5);

                 break;
             case 'C':  // curveto - Draws a cubic Bézier curve
                 outPath->cubicTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
                                  points->at(k + 3), points->at(k + 4), points->at(k + 5));
                 currentX = points->at(k + 4);
                 currentY = points->at(k + 5);
                 ctrlPointX = points->at(k + 2);
                 ctrlPointY = points->at(k + 3);
                 break;
             case 's':  // smooth curveto - Draws a cubic Bézier curve (reflective cp)
                 reflectiveCtrlPointX = 0;
                 reflectiveCtrlPointY = 0;
                 if (previousCmd == 'c' || previousCmd == 's' || previousCmd == 'C' ||
                     previousCmd == 'S') {
                     reflectiveCtrlPointX = currentX - ctrlPointX;
                     reflectiveCtrlPointY = currentY - ctrlPointY;
                 }
                 outPath->rCubicTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
                                   points->at(k + 1), points->at(k + 2), points->at(k + 3));
                 ctrlPointX = currentX + points->at(k + 0);
                 ctrlPointY = currentY + points->at(k + 1);
                 currentX += points->at(k + 2);
                 currentY += points->at(k + 3);
                 break;
             case 'S':  // shorthand/smooth curveto Draws a cubic Bézier curve(reflective cp)
                 reflectiveCtrlPointX = currentX;
                 reflectiveCtrlPointY = currentY;
                 if (previousCmd == 'c' || previousCmd == 's' || previousCmd == 'C' ||
                     previousCmd == 'S') {
                     reflectiveCtrlPointX = 2 * currentX - ctrlPointX;
                     reflectiveCtrlPointY = 2 * currentY - ctrlPointY;
                 }
                 outPath->cubicTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
                                  points->at(k + 1), points->at(k + 2), points->at(k + 3));
                 ctrlPointX = points->at(k + 0);
                 ctrlPointY = points->at(k + 1);
                 currentX = points->at(k + 2);
                 currentY = points->at(k + 3);
                 break;
             case 'q':  // Draws a quadratic Bézier (relative)
                 outPath->rQuadTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
                                  points->at(k + 3));
                 ctrlPointX = currentX + points->at(k + 0);
                 ctrlPointY = currentY + points->at(k + 1);
                 currentX += points->at(k + 2);
                 currentY += points->at(k + 3);
                 break;
             case 'Q':  // Draws a quadratic Bézier
                 outPath->quadTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
                                 points->at(k + 3));
                 ctrlPointX = points->at(k + 0);
                 ctrlPointY = points->at(k + 1);
                 currentX = points->at(k + 2);
                 currentY = points->at(k + 3);
                 break;
             case 't':  // Draws a quadratic Bézier curve(reflective control point)(relative)
                 reflectiveCtrlPointX = 0;
                 reflectiveCtrlPointY = 0;
                 if (previousCmd == 'q' || previousCmd == 't' || previousCmd == 'Q' ||
                     previousCmd == 'T') {
                     reflectiveCtrlPointX = currentX - ctrlPointX;
                     reflectiveCtrlPointY = currentY - ctrlPointY;
                 }
                 outPath->rQuadTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
                                  points->at(k + 1));
                 ctrlPointX = currentX + reflectiveCtrlPointX;
                 ctrlPointY = currentY + reflectiveCtrlPointY;
                 currentX += points->at(k + 0);
                 currentY += points->at(k + 1);
                 break;
             case 'T':  // Draws a quadratic Bézier curve (reflective control point)
                 reflectiveCtrlPointX = currentX;
                 reflectiveCtrlPointY = currentY;
                 if (previousCmd == 'q' || previousCmd == 't' || previousCmd == 'Q' ||
                     previousCmd == 'T') {
                     reflectiveCtrlPointX = 2 * currentX - ctrlPointX;
                     reflectiveCtrlPointY = 2 * currentY - ctrlPointY;
                 }
                 outPath->quadTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
                                 points->at(k + 1));
                 ctrlPointX = reflectiveCtrlPointX;
                 ctrlPointY = reflectiveCtrlPointY;
                 currentX = points->at(k + 0);
                 currentY = points->at(k + 1);
                 break;
             case 'a':  // Draws an elliptical arc
                 // (rx ry x-axis-rotation large-arc-flag sweep-flag x y)
                 outPath->arcTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
                                (SkPath::ArcSize) (points->at(k + 3) != 0),
                                (SkPathDirection) (points->at(k + 4) == 0),
                                points->at(k + 5) + currentX, points->at(k + 6) + currentY);
                 currentX += points->at(k + 5);
                 currentY += points->at(k + 6);
                 ctrlPointX = currentX;
                 ctrlPointY = currentY;
                 break;
             case 'A':  // Draws an elliptical arc
                 outPath->arcTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
                                (SkPath::ArcSize) (points->at(k + 3) != 0),
                                (SkPathDirection) (points->at(k + 4) == 0),
                                points->at(k + 5), points->at(k + 6));
                 currentX = points->at(k + 5);
                 currentY = points->at(k + 6);
                 ctrlPointX = currentX;
                 ctrlPointY = currentY;
                 break;
             default:
                 LOG_ALWAYS_FATAL("Unsupported command: %c", cmd);
                 break;
         }
         previousCmd = cmd;
     }
 }

 }  // namespace uirenderer
 }  // namespace android
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "VectorDrawableUtils.h"

	#include "PathParser.h"

	#include <math.h>
	#include <utils/Log.h>

	namespace android {
	namespace uirenderer {

	class PathResolver {
	public:
	float currentX = 0;
	float currentY = 0;
	float ctrlPointX = 0;
	float ctrlPointY = 0;
	float currentSegmentStartX = 0;
	float currentSegmentStartY = 0;
	void addCommand(SkPath* outPath, char previousCmd, char cmd, const std::vector<float>* points,
	size_t start, size_t end);
	};

	bool VectorDrawableUtils::canMorph(const PathData& morphFrom, const PathData& morphTo) {
	if (morphFrom.verbs.size() != morphTo.verbs.size()) {
	return false;
	}

	for (unsigned int i = 0; i < morphFrom.verbs.size(); i++) {
	if (morphFrom.verbs[i] != morphTo.verbs[i] \|\|
	morphFrom.verbSizes[i] != morphTo.verbSizes[i]) {
	return false;
	}
	}
	return true;
	}

	bool VectorDrawableUtils::interpolatePathData(PathData* outData, const PathData& morphFrom,
	const PathData& morphTo, float fraction) {
	if (!canMorph(morphFrom, morphTo)) {
	return false;
	}
	interpolatePaths(outData, morphFrom, morphTo, fraction);
	return true;
	}

	/**
	* Convert an array of PathVerb to Path.
	*/
	void VectorDrawableUtils::verbsToPath(SkPath* outPath, const PathData& data) {
	PathResolver resolver;
	char previousCommand = 'm';
	size_t start = 0;
	outPath->reset();
	for (unsigned int i = 0; i < data.verbs.size(); i++) {
	size_t verbSize = data.verbSizes[i];
	resolver.addCommand(outPath, previousCommand, data.verbs[i], &data.points, start,
	start + verbSize);
	previousCommand = data.verbs[i];
	start += verbSize;
	}
	}

	/**
	* The current PathVerb will be interpolated between the
	* <code>nodeFrom</code> and <code>nodeTo</code> according to the
	* <code>fraction</code>.
	*
	* @param nodeFrom The start value as a PathVerb.
	* @param nodeTo The end value as a PathVerb
	* @param fraction The fraction to interpolate.
	*/
	void VectorDrawableUtils::interpolatePaths(PathData* outData, const PathData& from,
	const PathData& to, float fraction) {
	outData->points.resize(from.points.size());
	outData->verbSizes = from.verbSizes;
	outData->verbs = from.verbs;

	for (size_t i = 0; i < from.points.size(); i++) {
	outData->points[i] = from.points[i] * (1 - fraction) + to.points[i] * fraction;
	}
	}

	// Use the given verb, and points in the range [start, end) to insert a command into the SkPath.
	void PathResolver::addCommand(SkPath* outPath, char previousCmd, char cmd,
	const std::vector<float>* points, size_t start, size_t end) {
	int incr = 2;
	float reflectiveCtrlPointX;
	float reflectiveCtrlPointY;

	switch (cmd) {
	case 'z':
	case 'Z':
	outPath->close();
	// Path is closed here, but we need to move the pen to the
	// closed position. So we cache the segment's starting position,
	// and restore it here.
	currentX = currentSegmentStartX;
	currentY = currentSegmentStartY;
	ctrlPointX = currentSegmentStartX;
	ctrlPointY = currentSegmentStartY;
	outPath->moveTo(currentX, currentY);
	break;
	case 'm':
	case 'M':
	case 'l':
	case 'L':
	case 't':
	case 'T':
	incr = 2;
	break;
	case 'h':
	case 'H':
	case 'v':
	case 'V':
	incr = 1;
	break;
	case 'c':
	case 'C':
	incr = 6;
	break;
	case 's':
	case 'S':
	case 'q':
	case 'Q':
	incr = 4;
	break;
	case 'a':
	case 'A':
	incr = 7;
	break;
	}

	for (unsigned int k = start; k < end; k += incr) {
	switch (cmd) {
	case 'm': // moveto - Start a new sub-path (relative)
	currentX += points->at(k + 0);
	currentY += points->at(k + 1);
	if (k > start) {
	// According to the spec, if a moveto is followed by multiple
	// pairs of coordinates, the subsequent pairs are treated as
	// implicit lineto commands.
	outPath->rLineTo(points->at(k + 0), points->at(k + 1));
	} else {
	outPath->rMoveTo(points->at(k + 0), points->at(k + 1));
	currentSegmentStartX = currentX;
	currentSegmentStartY = currentY;
	}
	break;
	case 'M': // moveto - Start a new sub-path
	currentX = points->at(k + 0);
	currentY = points->at(k + 1);
	if (k > start) {
	// According to the spec, if a moveto is followed by multiple
	// pairs of coordinates, the subsequent pairs are treated as
	// implicit lineto commands.
	outPath->lineTo(points->at(k + 0), points->at(k + 1));
	} else {
	outPath->moveTo(points->at(k + 0), points->at(k + 1));
	currentSegmentStartX = currentX;
	currentSegmentStartY = currentY;
	}
	break;
	case 'l': // lineto - Draw a line from the current point (relative)
	outPath->rLineTo(points->at(k + 0), points->at(k + 1));
	currentX += points->at(k + 0);
	currentY += points->at(k + 1);
	break;
	case 'L': // lineto - Draw a line from the current point
	outPath->lineTo(points->at(k + 0), points->at(k + 1));
	currentX = points->at(k + 0);
	currentY = points->at(k + 1);
	break;
	case 'h': // horizontal lineto - Draws a horizontal line (relative)
	outPath->rLineTo(points->at(k + 0), 0);
	currentX += points->at(k + 0);
	break;
	case 'H': // horizontal lineto - Draws a horizontal line
	outPath->lineTo(points->at(k + 0), currentY);
	currentX = points->at(k + 0);
	break;
	case 'v': // vertical lineto - Draws a vertical line from the current point (r)
	outPath->rLineTo(0, points->at(k + 0));
	currentY += points->at(k + 0);
	break;
	case 'V': // vertical lineto - Draws a vertical line from the current point
	outPath->lineTo(currentX, points->at(k + 0));
	currentY = points->at(k + 0);
	break;
	case 'c': // curveto - Draws a cubic Bézier curve (relative)
	outPath->rCubicTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
	points->at(k + 3), points->at(k + 4), points->at(k + 5));

	ctrlPointX = currentX + points->at(k + 2);
	ctrlPointY = currentY + points->at(k + 3);
	currentX += points->at(k + 4);
	currentY += points->at(k + 5);

	break;
	case 'C': // curveto - Draws a cubic Bézier curve
	outPath->cubicTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
	points->at(k + 3), points->at(k + 4), points->at(k + 5));
	currentX = points->at(k + 4);
	currentY = points->at(k + 5);
	ctrlPointX = points->at(k + 2);
	ctrlPointY = points->at(k + 3);
	break;
	case 's': // smooth curveto - Draws a cubic Bézier curve (reflective cp)
	reflectiveCtrlPointX = 0;
	reflectiveCtrlPointY = 0;
	if (previousCmd == 'c' \|\| previousCmd == 's' \|\| previousCmd == 'C' \|\|
	previousCmd == 'S') {
	reflectiveCtrlPointX = currentX - ctrlPointX;
	reflectiveCtrlPointY = currentY - ctrlPointY;
	}
	outPath->rCubicTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
	points->at(k + 1), points->at(k + 2), points->at(k + 3));
	ctrlPointX = currentX + points->at(k + 0);
	ctrlPointY = currentY + points->at(k + 1);
	currentX += points->at(k + 2);
	currentY += points->at(k + 3);
	break;
	case 'S': // shorthand/smooth curveto Draws a cubic Bézier curve(reflective cp)
	reflectiveCtrlPointX = currentX;
	reflectiveCtrlPointY = currentY;
	if (previousCmd == 'c' \|\| previousCmd == 's' \|\| previousCmd == 'C' \|\|
	previousCmd == 'S') {
	reflectiveCtrlPointX = 2 * currentX - ctrlPointX;
	reflectiveCtrlPointY = 2 * currentY - ctrlPointY;
	}
	outPath->cubicTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
	points->at(k + 1), points->at(k + 2), points->at(k + 3));
	ctrlPointX = points->at(k + 0);
	ctrlPointY = points->at(k + 1);
	currentX = points->at(k + 2);
	currentY = points->at(k + 3);
	break;
	case 'q': // Draws a quadratic Bézier (relative)
	outPath->rQuadTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
	points->at(k + 3));
	ctrlPointX = currentX + points->at(k + 0);
	ctrlPointY = currentY + points->at(k + 1);
	currentX += points->at(k + 2);
	currentY += points->at(k + 3);
	break;
	case 'Q': // Draws a quadratic Bézier
	outPath->quadTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
	points->at(k + 3));
	ctrlPointX = points->at(k + 0);
	ctrlPointY = points->at(k + 1);
	currentX = points->at(k + 2);
	currentY = points->at(k + 3);
	break;
	case 't': // Draws a quadratic Bézier curve(reflective control point)(relative)
	reflectiveCtrlPointX = 0;
	reflectiveCtrlPointY = 0;
	if (previousCmd == 'q' \|\| previousCmd == 't' \|\| previousCmd == 'Q' \|\|
	previousCmd == 'T') {
	reflectiveCtrlPointX = currentX - ctrlPointX;
	reflectiveCtrlPointY = currentY - ctrlPointY;
	}
	outPath->rQuadTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
	points->at(k + 1));
	ctrlPointX = currentX + reflectiveCtrlPointX;
	ctrlPointY = currentY + reflectiveCtrlPointY;
	currentX += points->at(k + 0);
	currentY += points->at(k + 1);
	break;
	case 'T': // Draws a quadratic Bézier curve (reflective control point)
	reflectiveCtrlPointX = currentX;
	reflectiveCtrlPointY = currentY;
	if (previousCmd == 'q' \|\| previousCmd == 't' \|\| previousCmd == 'Q' \|\|
	previousCmd == 'T') {
	reflectiveCtrlPointX = 2 * currentX - ctrlPointX;
	reflectiveCtrlPointY = 2 * currentY - ctrlPointY;
	}
	outPath->quadTo(reflectiveCtrlPointX, reflectiveCtrlPointY, points->at(k + 0),
	points->at(k + 1));
	ctrlPointX = reflectiveCtrlPointX;
	ctrlPointY = reflectiveCtrlPointY;
	currentX = points->at(k + 0);
	currentY = points->at(k + 1);
	break;
	case 'a': // Draws an elliptical arc
	// (rx ry x-axis-rotation large-arc-flag sweep-flag x y)
	outPath->arcTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
	(SkPath::ArcSize) (points->at(k + 3) != 0),
	(SkPathDirection) (points->at(k + 4) == 0),
	points->at(k + 5) + currentX, points->at(k + 6) + currentY);
	currentX += points->at(k + 5);
	currentY += points->at(k + 6);
	ctrlPointX = currentX;
	ctrlPointY = currentY;
	break;
	case 'A': // Draws an elliptical arc
	outPath->arcTo(points->at(k + 0), points->at(k + 1), points->at(k + 2),
	(SkPath::ArcSize) (points->at(k + 3) != 0),
	(SkPathDirection) (points->at(k + 4) == 0),
	points->at(k + 5), points->at(k + 6));
	currentX = points->at(k + 5);
	currentY = points->at(k + 6);
	ctrlPointX = currentX;
	ctrlPointY = currentY;
	break;
	default:
	LOG_ALWAYS_FATAL("Unsupported command: %c", cmd);
	break;
	}
	previousCmd = cmd;
	}
	}

	} // namespace uirenderer
	} // namespace android