/**

private static final int MOVE_TO = 0;

/**

private static final int LINE_TO = 1;

/**

private static final int CURVE_TO = 2;

/** The number of points in the path. */

private final int numPoints;

/** The x-location of each point (fixed). */

private final int[] xPoints;

/** The y-location of each point (fixed). */

private final int[] yPoints;

/** The value, from 0 to 1, representing the portion of the total length at each point. */

private final int[] pPoints;

private int totalLength;

private boolean isClosed;

private transient int lastCalcP = -1;

private transient int[] lastCalcPoint = new int[2];

/**

public Path(String svgPathData) throws IllegalArgumentException {

ArrayList commands = parseSVGPathData(svgPathData);

int[][] points = toLineSegments(commands);

this.xPoints = points[0];

this.yPoints = points[1];

this.numPoints = xPoints.length;

this.pPoints = new int[numPoints];

init();

}

/**

public Path(float[] xPoints, float[] yPoints) {

this.xPoints = toFixed(xPoints);

this.yPoints = toFixed(yPoints);

this.numPoints = xPoints.length;

this.pPoints = new int[numPoints];

init();

}

/**

public boolean isClosed() {

return isClosed;

}

public double getLength() {

return CoreMath.toDouble(totalLength);

}

// These two methods are commented out because they are untested

//

///**

// Returns the area of the polygon defined by this closed path.

//*/

//public float getArea() {

// if (area == 0) {

//

// // Based on "Calculating the area and centroid of a polygon" by Paul Bourke

// // http://local.wasp.uwa.edu.au/~pbourke/geometry/polyarea/

// for (int i = 0; i < numPoints; i++) {

// int j = (i + 1) % numPoints;

// area += CoreMath.toFloat(xPoints[i]) * CoreMath.toFloat(yPoints[j]);

// area -= CoreMath.toFloat(xPoints[j]) * CoreMath.toFloat(yPoints[i]);

// }

// area /= 2;

// }

// return area;

//}

//

//

///**

// Returns true if the specified point is contained inside

// the polygon defined by this closed path.

//*/

//public boolean contains(float x, float y) {

// int fx = CoreMath.toFixed(x);

// int fy = CoreMath.toFixed(y);

//

// // Based on the "Point Inclusion in Polygon Test" article by W. Randolph Franklin

// // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html

// boolean isInside = false;

// int xpj = xPoints[numPoints - 1];

// int ypj = yPoints[numPoints - 1];

// for (int i = 0; i < numPoints; i++) {

// int xpi = xPoints[i];

// int ypi = yPoints[i];

//

// if (((ypi <= fy && fy < ypj) || (ypj <= fy && fy < ypi)) &&

// (fx < CoreMath.mulDiv(xpj - xpi, fy - ypi, ypj - ypi) + xpi))

// {

// // The ray crossed an edge

// isInside = !isInside;

// }

// xpj = xpi;

// ypj = ypi;

// }

//

// return isInside;

//}

private int[] toFixed(float[] n) {

int[] f = new int[n.length];

for (int i = 0; i < n.length; i++) {

f[i] = CoreMath.toFixed(n[i]);

}

return f;

}

private void init() {

// Find the lengths of each segment;

totalLength = 0;

int[] segmentLength = new int[numPoints - 1];

for (int i = 0; i < numPoints - 1; i++) {

int dist = (int)CoreMath.dist(xPoints[i], yPoints[i], xPoints[i + 1], yPoints[i + 1]);

segmentLength[i] = dist;

totalLength += dist;

}

pPoints[0] = 0;

pPoints[numPoints - 1] = CoreMath.ONE;

int length = 0;

for (int i = 1; i < numPoints - 1; i++) {

length += segmentLength[i - 1];

pPoints[i] = CoreMath.div(length, totalLength);

}

isClosed = xPoints[0] == xPoints[numPoints - 1] && yPoints[0] == yPoints[numPoints - 1];

}

public void translate(double x, double y) {

if (x == 0 && y == 0) {

return;

}

int fX = CoreMath.toFixed(x);

int fY = CoreMath.toFixed(y);

for (int i = 0; i < numPoints; i++) {

xPoints[i] += fX;

yPoints[i] += fY;

}

}

public int getStartX() {

return CoreMath.toInt(xPoints[0]);

}

public int getStartY() {

return CoreMath.toInt(yPoints[0]);

}

public int getEndX() {

return CoreMath.toInt(xPoints[numPoints - 1]);

}

public int getEndY() {

return CoreMath.toInt(yPoints[numPoints - 1]);

}

//

//

//

/**

public double getX(double p) {

int px = clampP(p);

return CoreMath.toDouble(get(0, px));

}

/**

public double getY(double p) {

int px = clampP(p);

return CoreMath.toDouble(get(1, px));

}

/**

public double getAngle(double p) {

int px = clampP(p);

return CoreMath.toDouble(get(2, px));

//int i = getLowerSegment(px);

//return Math.atan2(yPoints[i + 1] - yPoints[i], xPoints[i + 1] - xPoints[i]);

}

/**

public void place(Sprite sprite, double p) {

int px = clampP(p);

sprite.x.setAsFixed(get(0, px));

sprite.y.setAsFixed(get(1, px));

}

/**

public void move(Sprite sprite, double startP, double endP, int duration) {

moveAsFixed(null, sprite, false, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, null, 0);

}

/**

public void moveAndRotate(Sprite sprite, double startP, double endP, int duration) {

moveAsFixed(null, sprite, true, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, null, 0);

}

/**

public void move(Sprite sprite, double startP, double endP, int duration,

Easing easing)

{

moveAsFixed(null, sprite, false, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, 0);

}

/**

public void moveAndRotate(Sprite sprite, double startP, double endP, int duration,

Easing easing)

{

moveAsFixed(null, sprite, true, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, 0);

}

/**

public void move(Sprite sprite, double startP, double endP, int duration,

Easing easing, int startDelay)

{

moveAsFixed(null, sprite, false, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, startDelay);

}

/**

public void moveAndRotate(Sprite sprite, double startP, double endP, int duration,

Easing easing, int startDelay)

{

moveAsFixed(null, sprite, true, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, startDelay);

}

/**

public void moveOnTimeline(Timeline timeline, Sprite sprite, double startP, double endP,

int duration, Easing easing, int startDelay)

{

moveAsFixed(timeline, sprite, false, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, startDelay);

}

/**

public void moveAndRotateOnTimeline(Timeline timeline, Sprite sprite, double startP, double endP,

int duration, Easing easing, int startDelay)

{

moveAsFixed(timeline, sprite, true, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, startDelay);

}

/**

public void guide(Timeline timeline, Sprite sprite, int duration) {

moveAsFixed(timeline, sprite, false, 0, CoreMath.ONE, duration, null, 0);

}

/**

public void guide(Timeline timeline, Sprite sprite, int duration, Easing easing) {

moveAsFixed(timeline, sprite, false, 0, CoreMath.ONE, duration, easing, 0);

}

/**

public void guide(Timeline timeline, Sprite sprite, int duration, Easing easing,

int startDelay)

{

moveAsFixed(timeline, sprite, false, 0, CoreMath.ONE, duration, easing, startDelay);

}

/**

public void guideBackwards(Timeline timeline, Sprite sprite, int duration) {

moveAsFixed(timeline, sprite, false, CoreMath.ONE, 0, duration, null, 0);

}

/**

public void guideBackwards(Timeline timeline, Sprite sprite, int duration, Easing easing) {

moveAsFixed(timeline, sprite, false, CoreMath.ONE, 0, duration, easing, 0);

}

/**

public void guideBackwards(Timeline timeline, Sprite sprite, int duration, Easing easing,

int startDelay)

{

moveAsFixed(timeline, sprite, false, CoreMath.ONE, 0, duration, easing, startDelay);

}

/**

public void guide(Timeline timeline, Sprite sprite, double startP, double endP, int duration) {

moveAsFixed(timeline, sprite, false, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, null, 0);

}

/**

public void guide(Timeline timeline, Sprite sprite, double startP, double endP, int duration,

Easing easing)

{

moveAsFixed(timeline, sprite, false, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, 0);

}

/**

public void guide(Timeline timeline, Sprite sprite, double startP, double endP, int duration,

Easing easing, int startDelay)

{

moveAsFixed(timeline, sprite, false, CoreMath.toFixed(startP), CoreMath.toFixed(endP),

duration, easing, startDelay);

}

private void moveAsFixed(Timeline timeline, Sprite sprite, boolean includeAngle,

int startP, int endP, int duration, Easing easing, int startDelay)

{

PathAnimation xAnimation =

new PathAnimation(PathAnimation.X_AXIS, startP, endP, duration, easing, startDelay);

PathAnimation yAnimation =

new PathAnimation(PathAnimation.Y_AXIS, startP, endP, duration, easing, startDelay);

PathAnimation angleAnimation =

new PathAnimation(PathAnimation.ANGLE, startP, endP, duration, easing, startDelay);

if (timeline == null) {

sprite.x.setBehavior(xAnimation);

sprite.y.setBehavior(yAnimation);

if (includeAngle) {

sprite.angle.setBehavior(angleAnimation);

}

}

else {

timeline.add(sprite.x, xAnimation);

timeline.add(sprite.y, yAnimation);

if (includeAngle) {

timeline.add(sprite.angle, angleAnimation);

}

}

}

private class PathAnimation extends Tween {

public static final int X_AXIS = 0;

public static final int Y_AXIS = 1;

public static final int ANGLE = 2;

private final int axis;

private final int startP;

private final int endP;

PathAnimation(int axis, int startP, int endP, int duration, Easing easing, int startDelay) {

super(

get(axis, startP),

get(axis, endP),

duration, easing, startDelay);

this.axis = axis;

this.startP = startP;

this.endP = endP;

}

protected void updateState(int animTime) {

if (getDuration() == 0) {

super.updateState(animTime);

}

else {

int p = startP + CoreMath.mulDiv(endP - startP, animTime, getDuration());

super.setValue(get(axis, p));

}

}

}

//

//

//

private int clampP(double p) {

return clampP(CoreMath.toFixed(p));

}

private int clampP(int p) {

if (isClosed()) {

// Only wrap if the path is closed.

// Special case: ONE is considered the end.

if (p != CoreMath.ONE) {

p &= 0xffff;

}

}

else {

p = CoreMath.clamp(p, 0, CoreMath.ONE);

}

return p;

}

private int get(int axis, int p) {

int px = clampP(p);

if (axis == 0 || axis == 1) {

return getLocation(px)[axis];

}

else {

int i = getLowerSegment(px);

int lowerAngle = CoreMath.atan2(yPoints[i + 1] - yPoints[i],

xPoints[i + 1] - xPoints[i]);

if (i == numPoints - 2) {

return lowerAngle;

}

else {

int higherAngle = CoreMath.atan2(yPoints[i + 2] - yPoints[i + 1],

xPoints[i + 2] - xPoints[i + 1]);

int dAngle = higherAngle - lowerAngle;

if (Math.abs(dAngle + CoreMath.TWO_PI) < Math.abs(dAngle)) {

dAngle += CoreMath.TWO_PI;

}

else if (Math.abs(dAngle - CoreMath.TWO_PI) < Math.abs(dAngle)) {

dAngle -= CoreMath.TWO_PI;

}

return lowerAngle + CoreMath.mulDiv(dAngle, px - pPoints[i], pPoints[i + 1] - pPoints[i]);

}

}

}

private int getLowerSegment(int p) {

// Binary search for P

int high = numPoints - 1;

int low = 0;

while (high - low > 1) {

int index = (high + low) >>> 1;

if (pPoints[index] > p) {

high = index;

}

else {

low = index;

}

}

return low;

}

private int[] getLocation(int p) {

if (p == lastCalcP) {

return lastCalcPoint;

}

lastCalcP = p;

if (p == 0) {

lastCalcPoint[0] = xPoints[0];

lastCalcPoint[1] = yPoints[0];

return lastCalcPoint;

}

else if (p == CoreMath.ONE) {

lastCalcPoint[0] = xPoints[numPoints - 1];

lastCalcPoint[1] = yPoints[numPoints - 1];

return lastCalcPoint;

}

// Binary search for P

int high = numPoints - 1;

int low = 0;

while (high - low > 1) {

int index = (high + low) >>> 1;

if (pPoints[index] > p) {

high = index;

}

else {

low = index;

}

}

if (high == low) {

lastCalcPoint[0] = xPoints[low];

lastCalcPoint[1] = yPoints[low];

}

else {

int q = p - pPoints[low];

int r = pPoints[high] - pPoints[low];

lastCalcPoint[0] = xPoints[low] + CoreMath.mulDiv(xPoints[high] - xPoints[low], q, r);

lastCalcPoint[1] = yPoints[low] + CoreMath.mulDiv(yPoints[high] - yPoints[low], q, r);

}

return lastCalcPoint;

}

/**

public void draw(CoreGraphics g, boolean drawJoints) {

int x1 = xPoints[0];

int y1 = yPoints[0];

for (int i = 1; i < numPoints; i++) {

if (drawJoints) {

g.fillRectFixedPoint(x1-CoreMath.ONE, y1-CoreMath.ONE,

CoreMath.toFixed(3), CoreMath.toFixed(3));

}

int x2 = xPoints[i];

int y2 = yPoints[i];

g.drawLineFixedPoint(x1, y1, x2, y2);

x1 = x2;

y1 = y2;

}

if (drawJoints) {

g.fillRectFixedPoint(x1-CoreMath.ONE, y1-CoreMath.ONE,

CoreMath.toFixed(3), CoreMath.toFixed(3));

}

}

//

// SVG path-data parsing

//

/**

private static ArrayList parseSVGPathData(String svgPathData) throws IllegalArgumentException {

ArrayList commands = new ArrayList();

svgPathData = svgPathData.trim();

StringTokenizer tokenizer = new StringTokenizer(svgPathData, "MmLlHhVvAaQqTtCcSsZz", true);

float currX = 0;

float currY = 0;

float initialX = 0;

float initialY = 0;

float lastControlX = 0;

float lastControlY = 0;

String lastCommand = "";

while (tokenizer.hasMoreTokens()) {

String commandType = tokenizer.nextToken();

if (commandType.trim().length() == 0) {

// This might happen after a Z command

continue;

}

boolean isRelative = false;

if (commandType.length() == 1 && Character.isLowerCase(commandType.charAt(0))) {

commandType = commandType.toUpperCase();

isRelative = true;

}

if ("Z".equals(commandType)) {

// Special case: don't parse numbers

if (currX != initialX || currY != initialY) {

commands.add(new float[] { LINE_TO, initialX, initialY });

currX = initialX;

currY = initialY;

}

}

else {

float[] numbers = parseNumberList(tokenizer.nextToken());

if ("M".equals(commandType)) {

checkIfSizeIsMultipleOf(commandType, numbers, 2);

for (int i = 0; i < numbers.length; i+=2) {

float endX = numbers[i];

float endY = numbers[i + 1];

if (isRelative) {

endX += currX;

endY += currY;

}

if (i == 0) {

commands.add(new float[] { MOVE_TO, endX, endY });

initialX = endX;

initialY = endY;

}

else {

commands.add(new float[] { LINE_TO, endX, endY });

}

currX = endX;

currY = endY;

}

}

else if ("L".equals(commandType)) {

checkIfSizeIsMultipleOf(commandType, numbers, 2);

for (int i = 0; i < numbers.length; i+=2) {

float endX = numbers[i];

float endY = numbers[i + 1];

if (isRelative) {

endX += currX;

endY += currY;

}

commands.add(new float[] { LINE_TO, endX, endY });

currX = endX;

currY = endY;

}

}

else if ("H".equals(commandType)) {

for (int i = 0; i < numbers.length; i++) {

float endX = numbers[i];

if (isRelative) {

endX += currX;

}

commands.add(new float[] { LINE_TO, endX, currY });

currX = endX;

}

}

else if ("V".equals(commandType)) {

for (int i = 0; i < numbers.length; i++) {

float endY = numbers[i];

if (isRelative) {

endY += currY;

}

commands.add(new float[] { LINE_TO, currX, endY });

currY = endY;

}

}

else if ("C".equals(commandType)) {

checkIfSizeIsMultipleOf(commandType, numbers, 6);

for (int i = 0; i < numbers.length; i+=6) {

float x1 = numbers[i + 0];

float y1 = numbers[i + 1];

float x2 = numbers[i + 2];

float y2 = numbers[i + 3];

float endX = numbers[i + 4];

float endY = numbers[i + 5];

if (isRelative) {

x1 += currX;

y1 += currY;

x2 += currX;

y2 += currY;

endX += currX;

endY += currY;

}

commands.add(new float[] { CURVE_TO, x1, y1, x2, y2, endX, endY });

currX = endX;

currY = endY;

lastControlX = x2;

lastControlY = y2;

}

}

else if ("S".equals(commandType)) {

checkIfSizeIsMultipleOf(commandType, numbers, 4);

for (int i = 0; i < numbers.length; i+=4) {

float x1;

float y1;

float x2 = numbers[i + 0];

float y2 = numbers[i + 1];

float endX = numbers[i + 2];

float endY = numbers[i + 3];

if (isRelative) {

x2 += currX;

y2 += currY;

endX += currX;

endY += currY;

}

if (i > 0 || "C".equals(lastCommand) || "S".equals(lastCommand)) {

// "The reflection of the second control point on the previous command

// relative to the current point"

x1 = 2*currX - lastControlX;

y1 = 2*currY - lastControlY;

}

else {

// "Coincident with the current point"

x1 = currX;

y1 = currY;

}

commands.add(new float[] { CURVE_TO, x1, y1, x2, y2, endX, endY });

currX = endX;

currY = endY;

lastControlX = x2;

lastControlY = y2;

}

}

else if ("Q".equals(commandType)) {

checkIfSizeIsMultipleOf(commandType, numbers, 4);

for (int i = 0; i < numbers.length; i+=4) {

float qx = numbers[i + 0];

float qy = numbers[i + 1];

float endX = numbers[i + 2];

float endY = numbers[i + 3];

if (isRelative) {

qx += currX;

qy += currY;

endX += currX;

endY += currY;

}

// Convert quadratic bezier to cubic

float x1 = (currX + 2 * qx) / 3;

float y1 = (currY + 2 * qy) / 3;

float x2 = (endX + 2 * qx) / 3;

float y2 = (endY + 2 * qy) / 3;

commands.add(new float[] { CURVE_TO, x1, y1, x2, y2, endX, endY });

currX = endX;

currY = endY;

lastControlX = qx;

lastControlY = qy;

}

}

else if ("T".equals(commandType)) {

checkIfSizeIsMultipleOf(commandType, numbers, 2);

for (int i = 0; i < numbers.length; i+=2) {

float qx;

float qy;

float endX = numbers[i + 0];

float endY = numbers[i + 1];

if (isRelative) {

endX += currX;

endY += currY;

}

if (i > 0 || "Q".equals(lastCommand) || "T".equals(lastCommand)) {

// "The reflection of the control point on the previous command relative

// to the current point"

qx = 2*currX - lastControlX;

qy = 2*currY - lastControlY;

}

else {

// "Coincident with the current point"

qx = currX;

qy = currY;

}

// Convert quadratic bezier to cubic

float x1 = (currX + 2 * qx) / 3;

float y1 = (currY + 2 * qy) / 3;

float x2 = (endX + 2 * qx) / 3;

float y2 = (endY + 2 * qy) / 3;

commands.add(new float[] { CURVE_TO, x1, y1, x2, y2, endX, endY });

currX = endX;

currY = endY;

lastControlX = qx;

lastControlY = qy;

}

}

else if ("A".equals(commandType)) {

checkIfSizeIsMultipleOf(commandType, numbers, 7);

for (int i = 0; i < numbers.length; i+=7) {

// See http://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes

float rx = numbers[i + 0];

float ry = numbers[i + 1];

float angle = (float)Math.toRadians(numbers[i + 2] % 360);

boolean largeArc = numbers[i + 3] != 0;

boolean sweep = numbers[i + 4] != 0;

float endX = numbers[i + 5];

float endY = numbers[i + 6];

if (isRelative) {

endX += currX;

endY += currY;

}

if (currX == endX && currY == endY) {

// Do nothing

}

else if (rx == 0 || ry == 0) {

commands.add(new float[] { LINE_TO, endX, endY });

}

else {

commands.addAll(parseArc(currX, currY, rx, ry, angle,

largeArc, sweep, endX, endY));

}

currX = endX;

currY = endY;

}

}

else {

throw new IllegalArgumentException("Not a supported command: " + commandType);

}

}

lastCommand = commandType;

}

return commands;

}

/**

private static ArrayList parseArc(float currX, float currY, float rx, float ry, float angle,

boolean largeArc, boolean sweep,

float endX, float endY)

{