/*
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*
*/
package org.apache.flex.swf.builders;
import org.apache.flex.swf.ISWFConstants;
import org.apache.flex.swf.types.CurvedEdgeRecord;
import org.apache.flex.swf.types.EdgeRecord;
import org.apache.flex.swf.types.FillStyleArray;
import org.apache.flex.swf.types.LineStyleArray;
import org.apache.flex.swf.types.Shape;
import org.apache.flex.swf.types.StraightEdgeRecord;
import org.apache.flex.swf.types.StyleChangeRecord;
import org.apache.flex.swf.types.Styles;
import org.apache.flex.utils.Point;
import org.apache.flex.utils.Trace;
/**
* A utility class to help construct a SWF Shape from Java2D AWT Shapes. By
* default, all co-ordinates are coverted to twips (1/20th of a pixel).
*/
public final class ShapeBuilder
{
/**
* Constructor.
* <p>
* Creates an empty Flash Shape with the pen starting at [0.0, 0.0].
*/
public ShapeBuilder()
{
this(new Styles(new FillStyleArray(), new LineStyleArray()));
}
/**
* Constructor.
* <p>
* Creates an empty Flash Shape with the pen starting at [0.0,0.0].
*
* @param useTwips <code>true</code> to convert to twips.
*/
public ShapeBuilder(boolean useTwips)
{
this();
convertToTwips = useTwips;
}
/**
* Constructor.
* <p>
* Creates an empty Flash Shape with the pen starting at [0.0, 0.0].
*/
public ShapeBuilder(Styles styles)
{
this(styles, new Point());
}
/**
* Constructor.
* <p>
* Use this constructor to specify whether co-ordinates will be
* converted to twips (1/20th of a pixel). The default is to use this
* conversion.
*
* @param useTwips <code>true</code> to convert to twips.
*/
public ShapeBuilder(Styles styles, boolean useTwips)
{
this(styles);
convertToTwips = useTwips;
}
/**
* Constructor.
* <p>
* Creates an empty Flash Shape. <code>ShapeRecord</code>s can
* be added manually using the process shape method.
*
* @param origin the pen starting point, typically [0.0,0.0]
* @see #processShape(IShapeIterator)
*/
public ShapeBuilder(Styles styles, Point origin)
{
shape = new Shape();
if (origin == null)
origin = new Point();
this.start = new Point(origin.x, origin.y);
this.lastMoveTo = new Point(origin.x, origin.y);
this.pen = new Point(this.lastMoveTo.x, this.lastMoveTo.y);
this.styles = styles;
}
private boolean convertToTwips = true;
private boolean font123 = false;
private Shape shape;
private Point pen;
private Point lastMoveTo;
private Point start;
private int dxSumTwips = 0;
private int dySumTwips = 0;
private int lineStyle = -1;
private int fillStyle0 = -1;
private int fillStyle1 = -1;
private Styles styles;
private boolean useFillStyle1 = true;
private boolean useFillStyle0 = true;
private boolean lineStyleHasChanged;
private boolean fillStyle1HasChanged;
private boolean fillStyle0HasChanged;
private boolean closed;
public Shape build()
{
return shape;
}
/**
* Processes a <code>Shape</code> by converting its general path to a series
* of <code>ShapeRecord</code>s. The records are not terminated with an
* <code>EndShapeRecord</code> so that subsequent calls can be made to this
* method to concatenate more shape paths.
* <p/>
* For closed shapes (including character glyphs) there exists a high
* possibility of rounding errors caused by the conversion of
* double-precision pixel co-ordinates to integer twips (1 twip = 1/20th
* pixel at 72 dpi). As such, at each move command this error is checked and
* corrected.
* <p/>
*
* @param si A IShapeIterator who's path will be converted to records and
* added to the collection
*/
public void processShape(IShapeIterator si)
{
while (!si.isDone())
{
double[] coords = new double[6];
short code = si.currentSegment(coords);
switch (code)
{
case IShapeIterator.MOVE_TO:
{
correctRoundingErrors();
move(coords[0], coords[1]);
closed = false; //reset closed flag after move
break;
}
case IShapeIterator.LINE_TO:
{
straight(coords[0], coords[1]);
break;
}
case IShapeIterator.QUAD_TO:
{
curved(coords[0], coords[1], coords[2], coords[3]);
break;
}
case IShapeIterator.CUBIC_TO:
{
approximateCubicBezier(new Point(pen.x, pen.y),
new Point(coords[0], coords[1]),
new Point(coords[2], coords[3]),
new Point(coords[4], coords[5]));
break;
}
case IShapeIterator.CLOSE:
{
closed = true;
close();
break;
}
}
si.next();
}
correctRoundingErrors();
}
/**
* If a shape is closed then the start and finish records must match exactly
* to the nearest twip. This method attempts to close the shape by adding a
* <code>StraightEdgeRecord</code> with a delta equal to the accumulated
* rounding errors, if such errors exists.
*/
public void correctRoundingErrors()
{
if ((dxSumTwips != 0 || dySumTwips != 0) && (closed || fillStyle0 > 0 || fillStyle1 > 0))
{
addLineSubdivideAware(-dxSumTwips, -dySumTwips);
dxSumTwips = 0;
dySumTwips = 0;
}
}
/**
* Moves the current pen position to a new location without drawing. In SWF,
* this requires a style change record and a delta is calculated between the
* current position and the new position.
* <p/>
* If fill or line style information has changed since the last move
* command, the new style information is also included in the record.
*
* @param x The new horizontal location.
* @param y The new vertical location.
*/
public void move(double x, double y)
{
double dx = x - start.x; //dx is delta from origin-x to final-x
double dy = y - start.y; //dy is delta from origin-y to final-y
if (convertToTwips)
{
dx *= ISWFConstants.TWIPS_PER_PIXEL;
dy *= ISWFConstants.TWIPS_PER_PIXEL;
}
StyleChangeRecord scr = new StyleChangeRecord();
scr.setMove((int)Math.rint(dx), (int)Math.rint(dy));
//Reset rounding counters, as this info is only useful per sub-shape/fill closure
dxSumTwips = 0;
dySumTwips = 0;
int fillStyle0Index = -1;
int fillStyle1Index = -1;
int lineStyleIndex = -1;
//Check styles
if (lineStyleHasChanged)
{
lineStyleIndex = lineStyle;
lineStyleHasChanged = false;
}
if (fillStyle0HasChanged && useFillStyle0)
{
fillStyle0Index = fillStyle0;
fillStyle0HasChanged = false;
}
if (fillStyle1HasChanged && useFillStyle1)
{
fillStyle1Index = fillStyle1;
fillStyle1HasChanged = false;
}
if (font123)
scr.setDefinedFontStyles(fillStyle0Index, fillStyle1Index, lineStyleIndex, styles);
else
scr.setDefinedStyles(fillStyle0Index, fillStyle1Index, lineStyleIndex, styles);
lastMoveTo.x = x;
lastMoveTo.y = y;
pen.x = x;
pen.y = y;
shape.addShapeRecord(scr);
}
/**
* Calculates the change or 'delta' in position between the current pen
* location and a given co-ordinate pair. This delta is used to create a
* straight-edge shape record in SWF, i.e. a simple line.
*
* @param x The new horizontal location.
* @param y The new vertical location.
*/
public void straight(double x, double y)
{
double dx = x - pen.x; //dx is delta from origin-x to final-x
double dy = y - pen.y; //dy is delta from origin-y to final-y
if (convertToTwips)
{
dx *= ISWFConstants.TWIPS_PER_PIXEL;
dy *= ISWFConstants.TWIPS_PER_PIXEL;
}
if (dx == 0 && dy == 0)
{
return; //For now, we ignore zero length lines
}
else
{
int intdx = (int)Math.rint(dx);
int intdy = (int)Math.rint(dy);
addLineSubdivideAware(intdx, intdy);
pen.x = x;
pen.y = y;
dxSumTwips += intdx;
dySumTwips += intdy;
}
}
/**
* Creates a quadratic spline in SWF as a curved-edge record. The current
* pen position is used as the first anchor point, and is used with the two
* other points supplied to calculate a delta between the origin and the
* control point, and the control point and the final anchor point.
*
* @param cx - control point-x
* @param cy - control point-y
* @param ax - anchor point-x
* @param ay - anchor point-y
*/
public void curved(double cx, double cy, double ax, double ay)
{
double[] points = new double[] {pen.x, pen.y, cx, cy, ax, ay};
int[] deltas = addCurveSubdivideAware(points);
pen.x = ax;
pen.y = ay;
dxSumTwips += (deltas[2] + deltas[0]);
dySumTwips += (deltas[3] + deltas[1]);
}
/**
* Creates a straight-edge record (i.e a straight line) from the current
* drawing position to the last move-to position. If the delta for the x and
* y co-ordinates is zero, a line is not necessary and the method does
* nothing.
*/
public void close()
{
double dx = lastMoveTo.x - pen.x; //dx is delta from lastMoveTo-x to pen-x
double dy = lastMoveTo.y - pen.y; //dy is delta from lastMoveTo-y to pen-y
if (convertToTwips)
{
dx *= ISWFConstants.TWIPS_PER_PIXEL;
dy *= ISWFConstants.TWIPS_PER_PIXEL;
}
pen.x = lastMoveTo.x;
pen.y = lastMoveTo.y;
if (dx == 0 && dy == 0)
{
return; //No action required
}
else
{
int intdx = (int)Math.rint(dx);
int intdy = (int)Math.rint(dy);
addLineSubdivideAware(intdx, intdy);
dxSumTwips += intdx;
dySumTwips += intdy;
}
}
private void addLineSubdivideAware(int x, int y)
{
int limit = EdgeRecord.MAX_DELTA_IN_TWIPS;
if (Math.abs(x) > limit || Math.abs(y) > limit)
{
int midXLeft = (int)Math.rint(Math.floor(x / 2.0));
int midYLeft = (int)Math.rint(Math.floor(y / 2.0));
int midXRight = (int)Math.rint(Math.ceil(x / 2.0));
int midYRight = (int)Math.rint(Math.ceil(y / 2.0));
if (Math.abs(midXLeft) > limit || Math.abs(midYLeft) > limit)
addLineSubdivideAware(midXLeft, midYLeft);
else
shape.addShapeRecord(new StraightEdgeRecord(midXLeft, midYLeft));
if (Math.abs(midXRight) > limit || Math.abs(midYRight) > limit)
addLineSubdivideAware(midXRight, midYRight);
else
shape.addShapeRecord(new StraightEdgeRecord(midXRight, midYRight));
}
else
{
shape.addShapeRecord(new StraightEdgeRecord(x, y));
}
}
/**
* Recursively draws smaller sub-sections of a curve until the
* control-anchor point delta values fit into a SWF EdgeRecord.
*
* @param curve An array of 6 values representing the origin x-y, control
* x-y, anchor x-y
* @return int[] The four x-y delta values between the two anchor points and
* one control point.
* @see EdgeRecord#MAX_DELTA_IN_TWIPS
*/
private int[] addCurveSubdivideAware(double[] curve)
{
int[] delta = curveDeltas(curve);
if (exceedsEdgeRecordLimit(delta))
{
double[] left = new double[6];
double[] right = new double[6];
divideQuad(curve, 0, left, 0, right, 0);
int[] deltaLeft = curveDeltas(left);
int[] deltaRight = curveDeltas(right);
if (exceedsEdgeRecordLimit(deltaLeft))
addCurveSubdivideAware(left);
else
curveRecord(deltaLeft);
if (exceedsEdgeRecordLimit(deltaRight))
addCurveSubdivideAware(right);
else
curveRecord(deltaRight);
}
else
{
curveRecord(delta);
}
return delta;
}
/**
* From java.awt.geom.QuadCurve2D
*/
public static void divideQuad(double src[], int srcoff, double left[], int loff, double right[], int roff)
{
double x1 = src[srcoff + 0];
double y1 = src[srcoff + 1];
double ctrlx = src[srcoff + 2];
double ctrly = src[srcoff + 3];
double x2 = src[srcoff + 4];
double y2 = src[srcoff + 5];
if (left != null)
{
left[loff + 0] = x1;
left[loff + 1] = y1;
}
if (right != null)
{
right[roff + 4] = x2;
right[roff + 5] = y2;
}
x1 = (x1 + ctrlx) / 2.0;
y1 = (y1 + ctrly) / 2.0;
x2 = (x2 + ctrlx) / 2.0;
y2 = (y2 + ctrly) / 2.0;
ctrlx = (x1 + x2) / 2.0;
ctrly = (y1 + y2) / 2.0;
if (left != null)
{
left[loff + 2] = x1;
left[loff + 3] = y1;
left[loff + 4] = ctrlx;
left[loff + 5] = ctrly;
}
if (right != null)
{
right[roff + 0] = ctrlx;
right[roff + 1] = ctrly;
right[roff + 2] = x2;
right[roff + 3] = y2;
}
}
private void curveRecord(int[] delta)
{
CurvedEdgeRecord cer = new CurvedEdgeRecord();
cer.setControlDeltaX(delta[0]);
cer.setControlDeltaY(delta[1]);
cer.setAnchorDeltaX(delta[2]);
cer.setAnchorDeltaY(delta[3]);
shape.addShapeRecord(cer);
}
private int[] curveDeltas(double[] curve)
{
int[] deltas = new int[4];
double dcx = curve[2] - curve[0]; //dcx is delta from origin-x to control point-x
double dcy = curve[3] - curve[1]; //dcy is delta from origin-y to control point-y
double dax = curve[4] - curve[2]; //dax is delta from control point-x to anchor point-x
double day = curve[5] - curve[3]; //day is delta from control point-y to anchor point-y
if (convertToTwips)
{
dcx *= ISWFConstants.TWIPS_PER_PIXEL;
dcy *= ISWFConstants.TWIPS_PER_PIXEL;
dax *= ISWFConstants.TWIPS_PER_PIXEL;
day *= ISWFConstants.TWIPS_PER_PIXEL;
}
deltas[0] = (int)Math.rint(dcx);
deltas[1] = (int)Math.rint(dcy);
deltas[2] = (int)Math.rint(dax);
deltas[3] = (int)Math.rint(day);
return deltas;
}
private boolean exceedsEdgeRecordLimit(int[] values)
{
for (int i = 0; i < values.length; i++)
{
if (Math.abs(values[i]) > EdgeRecord.MAX_DELTA_IN_TWIPS)
return true;
}
return false;
}
/**
* Set whether the shape is part of a DefineFont1, DefineFont2 or
* DefineFont3 tag.
*
* @param b true if shape part of a font tag
*/
public void setFont12or3(boolean b)
{
this.font123 = b;
}
/**
* Gets the current line style index. Note that a value of zero represents
* the empty stroke.
*
* @return index to the current line style in the
* <code>LineStyleArray</code>
*/
public int getCurrentLineStyle()
{
return lineStyle;
}
/**
* Sets the current line style index. Note that a value of zero represents
* the empty stroke.
*
* @param index index to a line style in the <code>LineStyleArray</code>
*/
public void setCurrentLineStyle(int index)
{
if (index != lineStyle)
{
lineStyleHasChanged = true;
lineStyle = index;
}
}
/**
* Gets the current fill style index. Note that a value of zero represents a
* blank fill.
*
* @return index to the current fill style in the
* <code>FillStyleArray</code>
*/
public int getCurrentFillStyle0()
{
return fillStyle0;
}
/**
* Sets the current fill style index. Note that a value of zero represents a
* blank fill.
*
* @param index The index of a fill style.
*/
public void setCurrentFillStyle0(int index)
{
if (index != fillStyle0)
{
fillStyle0HasChanged = true;
fillStyle0 = index;
}
}
/**
* Gets the current fill style 1 index. A fill style 1 record represents the
* fill of intersecting shape areas. Note that a value of zero represents a
* blank fill.
*
* @return index to the current fill style in the
* <code>FillStyleArray</code>
*/
public int getCurrentFillStyle1()
{
return fillStyle1;
}
/**
* Sets the current fill style 1 index. A fill style 1 record represents the
* fill of intersecting shape areas. Note that a value of zero represents a
* blank fill.
*
* @param index The index of a fill style.
*/
public void setCurrentFillStyle1(int index)
{
if (index != fillStyle1)
{
fillStyle1HasChanged = true;
fillStyle1 = index;
}
}
/**
* Gets whether the current paint method should include fill style 1
* information, which controls how intersecting shape fills are drawn.
*/
public boolean getUseFillStyle1()
{
return useFillStyle1;
}
/**
* Sets the paint method to include fill style 1 information, which controls
* how intersecting shape fills are drawn.
*
* @param b if set to true, fill style 1 information will be used for
* intersecting shapes
*/
public void setUseFillStyle1(boolean b)
{
useFillStyle1 = b;
}
/**
* Sets the paint method to include fill style 0 information, which is for
* filling simple shapes.
*
* @param b if set to true, fill style 0 information will be used for normal
* shapes
*/
public void setUseFillStyle0(boolean b)
{
useFillStyle0 = b;
}
/**
* Return a point on a segment [P0, P1] which distance from P0 is ratio of
* the length [P0, P1]
*/
public static Point getPointOnSegment(Point P0, Point P1, double ratio)
{
return new Point((P0.x + ((P1.x - P0.x) * ratio)), (P0.y + ((P1.y - P0.y) * ratio)));
}
/**
* Based on Timothee Groleau's public ActionScript library (which is based
* on Helen Triolo's approach) using Casteljau's approximation for drawing
* 3rd-order Cubic curves as a collection of 2nd-order Quadratic curves -
* with a fixed level of accuracy using just 4 quadratic curves.
* <p/>
* The reason this fixed-level approach was chosen is because it is very
* fast and should provide us with a reasonable approximation for small
* curves involved in fonts.
* <p/>
* "This function will trace a cubic approximation of the cubic Bezier
* It will calculate a series of [control point/Destination point] which
* will be used to draw quadratic Bezier starting from P0"
* <p/>
*
* @see <a href="http://timotheegroleau.com/Flash/articles/cubic_bezier_in_flash.htm">Cubic Bezier in Flash</a>
*/
private void approximateCubicBezier(final Point P0, final Point P1, final Point P2, final Point P3)
{
// calculates the useful base points
Point PA = getPointOnSegment(P0, P1, 3.0 / 4.0);
Point PB = getPointOnSegment(P3, P2, 3.0 / 4.0);
// get 1/16 of the [P3, P0] segment
double dx = (P3.x - P0.x) / 16.0;
double dy = (P3.y - P0.y) / 16.0;
// calculate control point 1
Point c1 = getPointOnSegment(P0, P1, 3.0 / 8.0);
// calculate control point 2
Point c2 = getPointOnSegment(PA, PB, 3.0 / 8.0);
c2.x = c2.x - dx;
c2.y = c2.y - dy;
// calculate control point 3
Point c3 = getPointOnSegment(PB, PA, 3.0 / 8.0);
c3.x = c3.x + dx;
c3.y = c3.y + dy;
// calculate control point 4
Point c4 = getPointOnSegment(P3, P2, 3.0 / 8.0);
// calculate the 3 anchor points (as midpoints of the control segments)
Point a1 = new Point(((c1.x + c2.x) / 2.0), ((c1.y + c2.y) / 2.0));
Point a2 = new Point(((PA.x + PB.x) / 2.0), ((PA.y + PB.y) / 2.0));
Point a3 = new Point(((c3.x + c4.x) / 2.0), ((c3.y + c4.y) / 2.0));
// draw the four quadratic sub-segments
curved(c1.x, c1.y, a1.x, a1.y);
curved(c2.x, c2.y, a2.x, a2.y);
curved(c3.x, c3.y, a3.x, a3.y);
curved(c4.x, c4.y, P3.x, P3.y);
if (Trace.font_cubic)
{
Trace.trace("Cubic Curve\n");
Trace.trace("P0:\t" + P0.x + "\t" + P0.y);
Trace.trace("c1:\t" + c1.x + "\t" + c1.y + "\t\tP1:\t" + P1.x + "\t" + P1.y);
Trace.trace("a1:\t" + a1.x + "\t" + a1.y);
Trace.trace("c2:\t" + c2.x + "\t" + c2.y);
Trace.trace("a2:\t" + a2.x + "\t" + a2.y);
Trace.trace("c3:\t" + c3.x + "\t" + c3.y);
Trace.trace("a3:\t" + a3.x + "\t" + a3.y);
Trace.trace("c4:\t" + c4.x + "\t" + c4.y + "\t\tP2:\t" + P2.x + "\t" + P2.y);
Trace.trace("P3:\t" + P3.x + "\t" + P3.y);
}
}
}