/*
* Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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 General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* (C) Copyright IBM Corp. 2005, All Rights Reserved.
*/
package sun.font;
//
// This is the 'simple' mapping implementation. It does things the most
// straightforward way even if that is a bit slow. It won't
// handle complex paths efficiently, and doesn't handle closed paths.
//
import java.awt.Shape;
import java.awt.font.LayoutPath;
import java.awt.geom.AffineTransform;
import java.awt.geom.GeneralPath;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.PathIterator;
import java.awt.geom.Point2D;
import java.util.Formatter;
import java.util.ArrayList;
import static java.awt.geom.PathIterator.*;
import static java.lang.Math.abs;
import static java.lang.Math.sqrt;
public abstract class LayoutPathImpl extends LayoutPath {
//
// Convenience APIs
//
public Point2D pointToPath(double x, double y) {
Point2D.Double pt = new Point2D.Double(x, y);
pointToPath(pt, pt);
return pt;
}
public Point2D pathToPoint(double a, double o, boolean preceding) {
Point2D.Double pt = new Point2D.Double(a, o);
pathToPoint(pt, preceding, pt);
return pt;
}
public void pointToPath(double x, double y, Point2D pt) {
pt.setLocation(x, y);
pointToPath(pt, pt);
}
public void pathToPoint(double a, double o, boolean preceding, Point2D pt) {
pt.setLocation(a, o);
pathToPoint(pt, preceding, pt);
}
//
// extra utility APIs
//
public abstract double start();
public abstract double end();
public abstract double length();
public abstract Shape mapShape(Shape s);
//
// debugging flags
//
private static final boolean LOGMAP = false;
private static final Formatter LOG = new Formatter(System.out);
/**
* Indicate how positions past the start and limit of the
* path are treated. PINNED adjusts these positions so
* as to be within start and limit. EXTENDED ignores the
* start and limit and effectively extends the first and
* last segments of the path 'infinitely'. CLOSED wraps
* positions around the ends of the path.
*/
public static enum EndType {
PINNED, EXTENDED, CLOSED;
public boolean isPinned() { return this == PINNED; }
public boolean isExtended() { return this == EXTENDED; }
public boolean isClosed() { return this == CLOSED; }
};
//
// Top level construction.
//
/**
* Return a path representing the path from the origin through the points in order.
*/
public static LayoutPathImpl getPath(EndType etype, double ... coords) {
if ((coords.length & 0x1) != 0) {
throw new IllegalArgumentException("odd number of points not allowed");
}
return SegmentPath.get(etype, coords);
}
/**
* Use to build a SegmentPath. This takes the data and preanalyzes it for
* information that the SegmentPath needs, then constructs a SegmentPath
* from that. Mainly, this lets SegmentPath cache the lengths along
* the path to each line segment, and so avoid calculating them over and over.
*/
public static final class SegmentPathBuilder {
private double[] data;
private int w;
private double px;
private double py;
private double a;
private boolean pconnect;
/**
* Construct a SegmentPathBuilder.
*/
public SegmentPathBuilder() {
}
/**
* Reset the builder for a new path. Datalen is a hint of how many
* points will be in the path, and the working buffer will be sized
* to accomodate at least this number of points. If datalen is zero,
* the working buffer is freed (it will be allocated on first use).
*/
public void reset(int datalen) {
if (data == null || datalen > data.length) {
data = new double[datalen];
} else if (datalen == 0) {
data = null;
}
w = 0;
px = py = 0;
pconnect = false;
}
/**
* Automatically build from a list of points represented by pairs of
* doubles. Initial advance is zero.
*/
public SegmentPath build(EndType etype, double... pts) {
assert(pts.length % 2 == 0);
reset(pts.length / 2 * 3);
for (int i = 0; i < pts.length; i += 2) {
nextPoint(pts[i], pts[i+1], i != 0);
}
return complete(etype);
}
/**
* Move to a new point. If there is no data, this will become the
* first point. If there is data, and the previous call was a lineTo, this
* point is checked against the previous point, and if different, this
* starts a new segment at the same advance as the end of the last
* segment. If there is data, and the previous call was a moveTo, this
* replaces the point used for that previous call.
*
* Calling this is optional, lineTo will suffice and the initial point
* will be set to 0, 0.
*/
public void moveTo(double x, double y) {
nextPoint(x, y, false);
}
/**
* Connect to a new point. If there is no data, the previous point
* is presumed to be 0, 0. This point is checked against
* the previous point, and if different, this point is added to
* the path and the advance extended. If this point is the same as the
* previous point, the path remains unchanged.
*/
public void lineTo(double x, double y) {
nextPoint(x, y, true);
}
/**
* Add a new point, and increment advance if connect is true.
*
* This automatically rejects duplicate points and multiple disconnected points.
*/
private void nextPoint(double x, double y, boolean connect) {
// if zero length move or line, ignore
if (x == px && y == py) {
return;
}
if (w == 0) { // this is the first point, make sure we have space
if (data == null) {
data = new double[6];
}
if (connect) {
w = 3; // default first point to 0, 0
}
}
// if multiple disconnected move, just update position, leave advance alone
if (w != 0 && !connect && !pconnect) {
data[w-3] = px = x;
data[w-2] = py = y;
return;
}
// grow data to deal with new point
if (w == data.length) {
double[] t = new double[w * 2];
System.arraycopy(data, 0, t, 0, w);
data = t;
}
if (connect) {
double dx = x - px;
double dy = y - py;
a += sqrt(dx * dx + dy * dy);
}
// update data
data[w++] = x;
data[w++] = y;
data[w++] = a;
// update state
px = x;
py = y;
pconnect = connect;
}
public SegmentPath complete() {
return complete(EndType.EXTENDED);
}
/**
* Complete building a SegmentPath. Once this is called, the builder is restored
* to its initial state and information about the previous path is released. The
* end type indicates whether to treat the path as closed, extended, or pinned.
*/
public SegmentPath complete(EndType etype) {
SegmentPath result;
if (data == null || w < 6) {
return null;
}
if (w == data.length) {
result = new SegmentPath(data, etype);
reset(0); // releases pointer to data
} else {
double[] dataToAdopt = new double[w];
System.arraycopy(data, 0, dataToAdopt, 0, w);
result = new SegmentPath(dataToAdopt, etype);
reset(2); // reuses data, since we held on to it
}
return result;
}
}
/**
* Represents a path built from segments. Each segment is
* represented by a triple: x, y, and cumulative advance.
* These represent the end point of the segment. The start
* point of the first segment is represented by the triple
* at position 0.
*
* The path might have breaks in it, e.g. it is not connected.
* These will be represented by pairs of triplets that share the
* same advance.
*
* The path might be extended, pinned, or closed. If extended,
* the initial and final segments are considered to extend
* 'indefinitely' past the bounds of the advance. If pinned,
* they end at the bounds of the advance. If closed,
* advances before the start or after the end 'wrap around' the
* path.
*
* The start of the path is the initial triple. This provides
* the nominal advance at the given x, y position (typically
* zero). The end of the path is the final triple. This provides
* the advance at the end, the total length of the path is
* thus the ending advance minus the starting advance.
*
* Note: We might want to cache more auxiliary data than the
* advance, but this seems adequate for now.
*/
public static final class SegmentPath extends LayoutPathImpl {
private double[] data; // triplets x, y, a
EndType etype;
public static SegmentPath get(EndType etype, double... pts) {
return new SegmentPathBuilder().build(etype, pts);
}
/**
* Internal, use SegmentPathBuilder or one of the static
* helper functions to construct a SegmentPath.
*/
SegmentPath(double[] data, EndType etype) {
this.data = data;
this.etype = etype;
}
//
// LayoutPath API
//
public void pathToPoint(Point2D location, boolean preceding, Point2D point) {
locateAndGetIndex(location, preceding, point);
}
// the path consists of line segments, which i'll call
// 'path vectors'. call each run of path vectors a 'path segment'.
// no path vector in a path segment is zero length (in the
// data, such vectors start a new path segment).
//
// for each path segment...
//
// for each path vector...
//
// we look at the dot product of the path vector and the vector from the
// origin of the path vector to the test point. if <0 (case
// A), the projection of the test point is before the start of
// the path vector. if > the square of the length of the path vector
// (case B), the projection is past the end point of the
// path vector. otherwise (case C), it lies on the path vector.
// determine the closeset point on the path vector. if case A, it
// is the start of the path vector. if case B and this is the last
// path vector in the path segment, it is the end of the path vector. If
// case C, it is the projection onto the path vector. Otherwise
// there is no closest point.
//
// if we have a closest point, compare the distance from it to
// the test point against our current closest distance.
// (culling should be fast, currently i am using distance
// squared, but there's probably better ways). if we're
// closer, save the new point as the current closest point,
// and record the path vector index so we can determine the final
// info if this turns out to be the closest point in the end.
//
// after we have processed all the segments we will have
// tested each path vector and each endpoint. if our point is not on
// an endpoint, we're done; we can compute the position and
// offset again, or if we saved it off we can just use it. if
// we're on an endpoint we need to see which path vector we should
// associate with. if we're at the start or end of a path segment,
// we're done-- the first or last vector of the segment is the
// one we associate with. we project against that vector to
// get the offset, and pin to that vector to get the length.
//
// otherwise, we compute the information as follows. if the
// dot product (see above) with the following vector is zero,
// we associate with that vector. otherwise, if the dot
// product with the previous vector is zero, we associate with
// that vector. otherwise we're beyond the end of the
// previous vector and before the start of the current vector.
// we project against both vectors and get the distance from
// the test point to the projection (this will be the offset).
// if they are the same, we take the following vector.
// otherwise use the vector from which the test point is the
// _farthest_ (this is because the point lies most clearly in
// the half of the plane defined by extending that vector).
//
// the returned position is the path length to the (possibly
// pinned) point, the offset is the projection onto the line
// along the vector, and we have a boolean flag which if false
// indicates that we associate with the previous vector at a
// junction (which is necessary when projecting such a
// location back to a point).
public boolean pointToPath(Point2D pt, Point2D result) {
double x = pt.getX(); // test point
double y = pt.getY();
double bx = data[0]; // previous point
double by = data[1];
double bl = data[2];
// start with defaults
double cd2 = Double.MAX_VALUE; // current best distance from path, squared
double cx = 0; // current best x
double cy = 0; // current best y
double cl = 0; // current best position along path
int ci = 0; // current best index into data
for (int i = 3; i < data.length; i += 3) {
double nx = data[i]; // current end point
double ny = data[i+1];
double nl = data[i+2];
double dx = nx - bx; // vector from previous to current
double dy = ny - by;
double dl = nl - bl;
double px = x - bx; // vector from previous to test point
double py = y - by;
// determine sign of dot product of vectors from bx, by
// if < 0, we're before the start of this vector
double dot = dx * px + dy * py; // dot product
double vcx, vcy, vcl; // hold closest point on vector as x, y, l
int vi; // hold index of line, is data.length if last point on path
do { // use break below, lets us avoid initializing vcx, vcy...
if (dl == 0 || // moveto, or
(dot < 0 && // before path vector and
(!etype.isExtended() ||
i != 3))) { // closest point is start of vector
vcx = bx;
vcy = by;
vcl = bl;
vi = i;
} else {
double l2 = dl * dl; // aka dx * dx + dy * dy, square of length
if (dot <= l2 || // closest point is not past end of vector, or
(etype.isExtended() && // we're extended and at the last segment
i == data.length - 3)) {
double p = dot / l2; // get parametric along segment
vcx = bx + p * dx; // compute closest point
vcy = by + p * dy;
vcl = bl + p * dl;
vi = i;
} else {
if (i == data.length - 3) {
vcx = nx; // special case, always test last point
vcy = ny;
vcl = nl;
vi = data.length;
} else {
break; // typical case, skip point, we'll pick it up next iteration
}
}
}
double tdx = x - vcx; // compute distance from (usually pinned) projection to test point
double tdy = y - vcy;
double td2 = tdx * tdx + tdy * tdy;
if (td2 <= cd2) { // new closest point, record info on it
cd2 = td2;
cx = vcx;
cy = vcy;
cl = vcl;
ci = vi;
}
} while (false);
bx = nx;
by = ny;
bl = nl;
}
// we have our closest point, get the info
bx = data[ci-3];
by = data[ci-2];
if (cx != bx || cy != by) { // not on endpoint, no need to resolve
double nx = data[ci];
double ny = data[ci+1];
double co = sqrt(cd2); // have a true perpendicular, so can use distance
if ((x-cx)*(ny-by) > (y-cy)*(nx-bx)) {
co = -co; // determine sign of offset
}
result.setLocation(cl, co);
return false;
} else { // on endpoint, we need to resolve which segment
boolean havePrev = ci != 3 && data[ci-1] != data[ci-4];
boolean haveFoll = ci != data.length && data[ci-1] != data[ci+2];
boolean doExtend = etype.isExtended() && (ci == 3 || ci == data.length);
if (havePrev && haveFoll) {
Point2D.Double pp = new Point2D.Double(x, y);
calcoffset(ci - 3, doExtend, pp);
Point2D.Double fp = new Point2D.Double(x, y);
calcoffset(ci, doExtend, fp);
if (abs(pp.y) > abs(fp.y)) {
result.setLocation(pp);
return true; // associate with previous
} else {
result.setLocation(fp);
return false; // associate with following
}
} else if (havePrev) {
result.setLocation(x, y);
calcoffset(ci - 3, doExtend, result);
return true;
} else {
result.setLocation(x, y);
calcoffset(ci, doExtend, result);
return false;
}
}
}
/**
* Return the location of the point passed in result as mapped to the
* line indicated by index. If doExtend is true, extend the
* x value without pinning to the ends of the line.
* this assumes that index is valid and references a line that has
* non-zero length.
*/
private void calcoffset(int index, boolean doExtend, Point2D result) {
double bx = data[index-3];
double by = data[index-2];
double px = result.getX() - bx;
double py = result.getY() - by;
double dx = data[index] - bx;
double dy = data[index+1] - by;
double l = data[index+2] - data[index - 1];
// rx = A dot B / |B|
// ry = A dot invB / |B|
double rx = (px * dx + py * dy) / l;
double ry = (px * -dy + py * dx) / l;
if (!doExtend) {
if (rx < 0) rx = 0;
else if (rx > l) rx = l;
}
rx += data[index-1];
result.setLocation(rx, ry);
}
//
// LayoutPathImpl API
//
public Shape mapShape(Shape s) {
return new Mapper().mapShape(s);
}
public double start() {
return data[2];
}
public double end() {
return data[data.length - 1];
}
public double length() {
return data[data.length-1] - data[2];
}
//
// Utilities
//
/**
* Get the 'modulus' of an advance on a closed path.
*/
private double getClosedAdvance(double a, boolean preceding) {
if (etype.isClosed()) {
a -= data[2];
int count = (int)(a/length());
a -= count * length();
if (a < 0 || (a == 0 && preceding)) {
a += length();
}
a += data[2];
}
return a;
}
/**
* Return the index of the segment associated with advance. This
* points to the start of the triple and is a multiple of 3 between
* 3 and data.length-3 inclusive. It never points to a 'moveto' triple.
*
* If the path is closed, 'a' is mapped to
* a value between the start and end of the path, inclusive.
* If preceding is true, and 'a' lies on a segment boundary,
* return the index of the preceding segment, else return the index
* of the current segment (if it is not a moveto segment) otherwise
* the following segment (which is never a moveto segment).
*
* Note: if the path is not closed, the advance might not actually
* lie on the returned segment-- it might be before the first, or
* after the last. The first or last segment (as appropriate)
* will be returned in this case.
*/
private int getSegmentIndexForAdvance(double a, boolean preceding) {
// must have local advance
a = getClosedAdvance(a, preceding);
// note we must avoid 'moveto' segments. the first segment is
// always a moveto segment, so we always skip it.
int i, lim;
for (i = 5, lim = data.length-1; i < lim; i += 3) {
double v = data[i];
if (a < v || (a == v && preceding)) {
break;
}
}
return i-2; // adjust to start of segment
}
/**
* Map a location based on the provided segment, returning in pt.
* Seg must be a valid 'lineto' segment. Note: if the path is
* closed, x must be within the start and end of the path.
*/
private void map(int seg, double a, double o, Point2D pt) {
double dx = data[seg] - data[seg-3];
double dy = data[seg+1] - data[seg-2];
double dl = data[seg+2] - data[seg-1];
double ux = dx/dl; // could cache these, but is it worth it?
double uy = dy/dl;
a -= data[seg-1];
pt.setLocation(data[seg-3] + a * ux - o * uy,
data[seg-2] + a * uy + o * ux);
}
/**
* Map the point, and return the segment index.
*/
private int locateAndGetIndex(Point2D loc, boolean preceding, Point2D result) {
double a = loc.getX();
double o = loc.getY();
int seg = getSegmentIndexForAdvance(a, preceding);
map(seg, a, o, result);
return seg;
}
//
// Mapping classes.
// Map the path onto each path segment.
// Record points where the advance 'enters' and 'exits' the path segment, and connect successive
// points when appropriate.
//
/**
* This represents a line segment from the iterator. Each target segment will
* interpret it, and since this process needs slope along the line
* segment, this lets us compute it once and pass it around easily.
*/
class LineInfo {
double sx, sy; // start
double lx, ly; // limit
double m; // slope dy/dx
/**
* Set the lineinfo to this line
*/
void set(double sx, double sy, double lx, double ly) {
this.sx = sx;
this.sy = sy;
this.lx = lx;
this.ly = ly;
double dx = lx - sx;
if (dx == 0) {
m = 0; // we'll check for this elsewhere
} else {
double dy = ly - sy;
m = dy / dx;
}
}
void set(LineInfo rhs) {
this.sx = rhs.sx;
this.sy = rhs.sy;
this.lx = rhs.lx;
this.ly = rhs.ly;
this.m = rhs.m;
}
/**
* Return true if we intersect the infinitely tall rectangle with
* lo <= x < hi. If we do, also return the pinned portion of ourselves in
* result.
*/
boolean pin(double lo, double hi, LineInfo result) {
result.set(this);
if (lx >= sx) {
if (sx < hi && lx >= lo) {
if (sx < lo) {
if (m != 0) result.sy = sy + m * (lo - sx);
result.sx = lo;
}
if (lx > hi) {
if (m != 0) result.ly = ly + m * (hi - lx);
result.lx = hi;
}
return true;
}
} else {
if (lx < hi && sx >= lo) {
if (lx < lo) {
if (m != 0) result.ly = ly + m * (lo - lx);
result.lx = lo;
}
if (sx > hi) {
if (m != 0) result.sy = sy + m * (hi - sx);
result.sx = hi;
}
return true;
}
}
return false;
}
/**
* Return true if we intersect the segment at ix. This takes
* the path end type into account and computes the relevant
* parameters to pass to pin(double, double, LineInfo).
*/
boolean pin(int ix, LineInfo result) {
double lo = data[ix-1];
double hi = data[ix+2];
switch (SegmentPath.this.etype) {
case PINNED:
break;
case EXTENDED:
if (ix == 3) lo = Double.NEGATIVE_INFINITY;
if (ix == data.length - 3) hi = Double.POSITIVE_INFINITY;
break;
case CLOSED:
// not implemented
break;
}
return pin(lo, hi, result);
}
}
/**
* Each segment will construct its own general path, mapping the provided lines
* into its own simple space.
*/
class Segment {
final int ix; // index into data array for this segment
final double ux, uy; // unit vector
final LineInfo temp; // working line info
boolean broken; // true if a moveto has occurred since we last added to our path
double cx, cy; // last point in gp
GeneralPath gp; // path built for this segment
Segment(int ix) {
this.ix = ix;
double len = data[ix+2] - data[ix-1];
this.ux = (data[ix] - data[ix-3]) / len;
this.uy = (data[ix+1] - data[ix-2]) / len;
this.temp = new LineInfo();
}
void init() {
if (LOGMAP) LOG.format("s(%d) init\n", ix);
broken = true;
cx = cy = Double.MIN_VALUE;
this.gp = new GeneralPath();
}
void move() {
if (LOGMAP) LOG.format("s(%d) move\n", ix);
broken = true;
}
void close() {
if (!broken) {
if (LOGMAP) LOG.format("s(%d) close\n[cp]\n", ix);
gp.closePath();
}
}
void line(LineInfo li) {
if (LOGMAP) LOG.format("s(%d) line %g, %g to %g, %g\n", ix, li.sx, li.sy, li.lx, li.ly);
if (li.pin(ix, temp)) {
if (LOGMAP) LOG.format("pin: %g, %g to %g, %g\n", temp.sx, temp.sy, temp.lx, temp.ly);
temp.sx -= data[ix-1];
double sx = data[ix-3] + temp.sx * ux - temp.sy * uy;
double sy = data[ix-2] + temp.sx * uy + temp.sy * ux;
temp.lx -= data[ix-1];
double lx = data[ix-3] + temp.lx * ux - temp.ly * uy;
double ly = data[ix-2] + temp.lx * uy + temp.ly * ux;
if (LOGMAP) LOG.format("points: %g, %g to %g, %g\n", sx, sy, lx, ly);
if (sx != cx || sy != cy) {
if (broken) {
if (LOGMAP) LOG.format("[mt %g, %g]\n", sx, sy);
gp.moveTo((float)sx, (float)sy);
} else {
if (LOGMAP) LOG.format("[lt %g, %g]\n", sx, sy);
gp.lineTo((float)sx, (float)sy);
}
}
if (LOGMAP) LOG.format("[lt %g, %g]\n", lx, ly);
gp.lineTo((float)lx, (float)ly);
broken = false;
cx = lx;
cy = ly;
}
}
}
class Mapper {
final LineInfo li; // working line info
final ArrayList<Segment> segments; // cache additional data on segments, working objects
final Point2D.Double mpt; // last moveto source point
final Point2D.Double cpt; // current source point
boolean haveMT; // true when last op was a moveto
Mapper() {
li = new LineInfo();
segments = new ArrayList<Segment>();
for (int i = 3; i < data.length; i += 3) {
if (data[i+2] != data[i-1]) { // a new segment
segments.add(new Segment(i));
}
}
mpt = new Point2D.Double();
cpt = new Point2D.Double();
}
void init() {
if (LOGMAP) LOG.format("init\n");
haveMT = false;
for (Segment s: segments) {
s.init();
}
}
void moveTo(double x, double y) {
if (LOGMAP) LOG.format("moveto %g, %g\n", x, y);
mpt.x = x;
mpt.y = y;
haveMT = true;
}
void lineTo(double x, double y) {
if (LOGMAP) LOG.format("lineto %g, %g\n", x, y);
if (haveMT) {
// prepare previous point for no-op check
cpt.x = mpt.x;
cpt.y = mpt.y;
}
if (x == cpt.x && y == cpt.y) {
// lineto is a no-op
return;
}
if (haveMT) {
// current point is the most recent moveto point
haveMT = false;
for (Segment s: segments) {
s.move();
}
}
li.set(cpt.x, cpt.y, x, y);
for (Segment s: segments) {
s.line(li);
}
cpt.x = x;
cpt.y = y;
}
void close() {
if (LOGMAP) LOG.format("close\n");
lineTo(mpt.x, mpt.y);
for (Segment s: segments) {
s.close();
}
}
public Shape mapShape(Shape s) {
if (LOGMAP) LOG.format("mapshape on path: %s\n", LayoutPathImpl.SegmentPath.this);
PathIterator pi = s.getPathIterator(null, 1); // cheap way to handle curves.
if (LOGMAP) LOG.format("start\n");
init();
final double[] coords = new double[2];
while (!pi.isDone()) {
switch (pi.currentSegment(coords)) {
case SEG_CLOSE: close(); break;
case SEG_MOVETO: moveTo(coords[0], coords[1]); break;
case SEG_LINETO: lineTo(coords[0], coords[1]); break;
default: break;
}
pi.next();
}
if (LOGMAP) LOG.format("finish\n\n");
GeneralPath gp = new GeneralPath();
for (Segment seg: segments) {
gp.append(seg.gp, false);
}
return gp;
}
}
//
// for debugging
//
public String toString() {
StringBuilder b = new StringBuilder();
b.append("{");
b.append(etype.toString());
b.append(" ");
for (int i = 0; i < data.length; i += 3) {
if (i > 0) {
b.append(",");
}
float x = ((int)(data[i] * 100))/100.0f;
float y = ((int)(data[i+1] * 100))/100.0f;
float l = ((int)(data[i+2] * 10))/10.0f;
b.append("{");
b.append(x);
b.append(",");
b.append(y);
b.append(",");
b.append(l);
b.append("}");
}
b.append("}");
return b.toString();
}
}
public static class EmptyPath extends LayoutPathImpl {
private AffineTransform tx;
public EmptyPath(AffineTransform tx) {
this.tx = tx;
}
public void pathToPoint(Point2D location, boolean preceding, Point2D point) {
if (tx != null) {
tx.transform(location, point);
} else {
point.setLocation(location);
}
}
public boolean pointToPath(Point2D pt, Point2D result) {
result.setLocation(pt);
if (tx != null) {
try {
tx.inverseTransform(pt, result);
}
catch (NoninvertibleTransformException ex) {
}
}
return result.getX() > 0;
}
public double start() { return 0; }
public double end() { return 0; }
public double length() { return 0; }
public Shape mapShape(Shape s) {
if (tx != null) {
return tx.createTransformedShape(s);
}
return s;
}
}
}