The PathList class combines an explicit sequence
* of PathNode objects together with a winding rule to
* provide a flexible alternative to the Java class
* GeneralPath.
A PathList may be constructed or modifed using a list of
* PathNode objects or a Shape or
* a PathIterator.
Conversely, from a PathList, one can construct a
* Shape or a PathIterator.
Unlike GeneralPath, PathList does not
* implement Shape directly since we separate the aspects of
* collecting the path node data from the shape issues. This class provides
* methods to create various Shape objects as desired.
PathList utilizes the Java class GeneralPath
* for the implementation of the construction of a Shape given
* the data in this class.
In construction of a Shape via GeneralPath,
* Java requires that the start node have type MOVE. If this condition
* does not hold, Java throws IllegalPathStateException. In
* this class, the requirement that the start node have type MOVE is tested
* by the method isValid(). If this method returns false and
* the user calls makeShape, an empty Shape will
* be returned by this call rather than throwing an exception.
The constructor that initializes the path list using * the given array of path nodes * and sets the winding rule to WindingRule.WIND_NON_ZERO.
* * @param nodes the nodes to add to the path list */ public PathList(PathNode[] nodes) { this(); append(nodes); } /** *The constructor that initializes the path list using * the given array of path nodes and the given winding rule.
* * @param nodes the nodes to add to the path list * @param rule the winding rule as an object */ public PathList (PathNode[] nodes, WindingRule rule) { this(); append(nodes); setWindingRule(rule); } /** *The constructor that initializes the path list using * the given array of path nodes and the given winding rule.
* * @param nodes the nodes to add to the path list * @param rule the winding rule as an int */ public PathList (PathNode[] nodes, int rule) { this(); append(nodes); setWindingRule(rule); } /** *The constructor that makes a deep clone of an existing * path list.
* * @param list the path list to clone */ public PathList(PathList list) { this(); setPathList(list); } /** *The constructor that initializes the path list using
* the path nodes and winding rule obtained from the given
* PathIterator.
The constructor must execute the iteration so when it is
* complete then iterator.isDone() will be true.
The constructor that initializes the path list using
* the path nodes and winding rule obtained from the given
* Shape.
The constructor that initializes the path list using
* the path nodes and winding rule obtained from the given
* Shape
* after applying the given transform
* to the shape data.
The constructor that initializes the path list using
* the path nodes and winding rule obtained from the given
* Shape
* after applying the given transform and flatness
* to the shape data.
The constructor that makes a polygon path list using * the given array points of point data; the boolean close * determines whether or the polygon is open or closed.
* *Does nothing if points is null.
Ignores null data items in points.
The path list is constructed by doing MOVE to the * first point and LINE to all succeeding points. If the * boolean close is true then CLOSE is appended at the end.
* * @param points the polygon points * @param close whether or not to close the polygon */ public PathList(Point2D[] points, boolean close) { this(); if (points == null) return; int N = points.length; boolean first = true; for (int i = 0; i < N; i++) { if (points[i] == null) continue; int type = first ? MOVE : LINE; float x = (float) points[i].getX(); float y = (float) points[i].getY(); append(new PathNode(type, x, y, 0, 0, 0, 0)); first = false; } if (close) append(new PathNode(CLOSE, 0, 0, 0, 0, 0, 0)); } /** *The constructor that makes a polygon path list using * the given array points of point data; the boolean close * determines whether or the polygon is open or closed; * the given winding rule determines the winding rule.
* *Utilizes PathList(Point2D[], boolean).
The constructor that makes a polygon path list using * the given array points of point data; the boolean close * determines whether or the polygon is open or closed; * the given winding rule determines the winding rule.
* *Utilizes PathList(Point2D[], boolean).
Factory method that returns a new Shape based on the
* current data in this path list. The Shape is constructed
* using the Java class GeneralPath.
* *
In construction of a Shape via GeneralPath,
* Java requires that the start node have type MOVE. If this condition
* does not hold, Java throws IllegalPathStateException. In
* this class, the requirement that the start node have type MOVE is tested
* by the method isValid(). If this method returns false and
* the user calls makeShape, an empty Shape will
* be returned by this call rather than throwing an exception.
Factory method that returns a new PathListIterator
* based on the current data in this path list.
*/ public final PathListIterator makePathListIterator() { return new PathListIterator(this); } /** *
Returns a PaintableSequence whose components
* show the structure of the Shape associated with
* this PathList.
Each component in the sequence corresponds to one of the
* Color parameters and if a particular parameter
* is null or has an alpha value of 0 then that
* particular component is omitted from the sequence.
* *
The components are inserted into the sequence from top to * bottom as follows.
* *At the top, the dots corresponding to the Bezier control
* points are inserted as an internal paintable sequence. Each
* dot uses a PointPaintable with the control dots
* color.
Next, the dots corresponding to the vertex points are
* inserted as an internal paintable sequence. Each dot uses a
* PointPaintable with the vertex dots color.
Next, the shape constructed by makeShape is
* inserted into the sequence as a ShapePaintable to
* be drawn in the draw color.
Next, the frame constructed by makeBezierShape
* is inserted into the sequence as a ShapePaintable
* to be drawn in the bezier frame color.
Next, the frame constructed by makeVertexShape
* is inserted into the sequence as a ShapePaintable
* to be drawn in the vertex frame color.
Finally, the shape constructed by makeShape is
* inserted into the sequence as a ShapePaintable to
* be filled in the fill color.
This order of insertion ensures that the dots are on top, * the drawn shape is next, the frames are next, and the filled * shape is on the bottom. This order gives the maximum amount * of information to the user of this method.
* *The thickness controls the thickness of the drawing stroke.
* Also, the PointPaintable for the dots uses a size
* equal to (thickness+2).
Returns a PaintableSequence whose components
* show the structure of the Shape associated with
* this PathList.
Calls the more general method with the following defaults.
* *vertexDotsColor: Colors.red*
controlDotsColor: Colors.darkorange*
vertexFrameColor: Colors.transparent*
bezierFrameColor: Colors.darkorchid* *
In particular, with these defaults, the vertex frame is
* not included in the PaintableSequence.
Returns a PaintableSequence whose components
* show the structure of the Shape associated with
* this PathList.
Calls the more general method with the following defaults.
* *fillColor: Colors.lime*
drawColor: Colors.black*
vertexDotsColor: Colors.red*
controlDotsColor: Colors.darkorange*
vertexFrameColor: Colors.transparent*
bezierFrameColor: Colors.darkorchid* *
In particular, with these defaults, the vertex frame is
* not included in the PaintableSequence.
Returns a PaintableSequence whose components
* show the structure of the Shape associated with
* this PathList.
Calls the more general method with the following defaults.
* *fillColor: Colors.lime*
drawColor: Colors.black*
vertexDotsColor: Colors.red*
controlDotsColor: Colors.darkorange*
vertexFrameColor: Colors.transparent*
bezierFrameColor: Colors.darkorchid*
thickness: 2* *
In particular, with these defaults, the vertex frame is
* not included in the PaintableSequence.
Removes the current nodes in the path list and sets * the nodes to those in the given array of nodes.
* *If the given nodes array is null then
* does nothing.
Returns a PathNode array with the current
* path nodes in this path list.
The PathNode items in the array are live,
* that is, they are identical to the current items in the
* path list. This means that the user of this array may
* make changes to the path list directly. Obviously, this
* facility must be used with care.
The length of the array is size().
If the user changes the path list by adding or removing * items then this array will be out of synchronization with * the data in the path list.
*/ public final PathNode[] getPathNodes() { return (PathNode[]) pathlist.toArray(new PathNode[0]); } /** *Sets the winding rule as an object.
* *Does nothing if the parameter is null.
Sets the winding rule via an int.
* *GeneralPath.WIND_NON_ZERO corresponds
* to WindingRule.WIND_NON_ZERO.
GeneralPath.WIND_EVEN_ODD corresponds
* to WindingRule.WIND_EVEN_ODD.
Ignores an invalid parameter.
* * @param rule the winding rule as an int */ public final void setWindingRule(int rule) { if (rule == GeneralPath.WIND_NON_ZERO) windingrule = WindingRule.WIND_NON_ZERO; else if (rule == GeneralPath.WIND_EVEN_ODD) windingrule = WindingRule.WIND_EVEN_ODD; } /** * Get the winding rule as an object. * * @return the winding rule */ public final WindingRule getWindingRule() { return windingrule; } /** *
Sets this path list to be a deep clone of an existing * path list.
* *If the given path list is null then does
* nothing.
Sets the path list using
* the path nodes and winding rule obtained from the given
* PathIterator.
This method must execute the iteration so when it is
* complete then iterator.isDone() will be true.
If the given iterator is null then does
* nothing.
Sets the path list using
* the path nodes and winding rule obtained from the given
* Shape.
If the given shape is null then does
* nothing.
Sets the path list using
* the path nodes and winding rule obtained from the given
* Shape
* after applying the given transform
* to the shape data.
Sets the path list using
* the path nodes and winding rule obtained from the given
* Shape
* after applying the given transform and flatness
* to the shape data.
Sets the PathNode at the given index
* to a copy of the given node
* if the given node is non-null
* and if the given index is in range;
* otherwise does nothing.
Returns the PathNode at the given index
* if the given index is in range;
* otherwise returns null.
Sets the contents of the given slot of
* the PathNode at the given index
* to the given x, y
* if the index is in range and the slot is valid;
* otherwise does nothing.
Sets the contents of the given slot of
* the PathNode at the given index
* to the coordinates of the given pair
* if the index is in range and the slot is valid
* and if pair is non-null
* and of length 2;
* otherwise does nothing.
Sets the contents of the slot indices[1] of
* the PathNode at the index indices[0]
* to the given x, y
* if indices is non-null
* and of length 2
* and if the index is in range and the slot is valid;
* otherwise does nothing.
Sets the contents of the slot indices[1] of
* the PathNode at the index indices[0]
* to the coordinates of the given pair
* if indices is non-null
* and of length 2,
* if the index is in range and the slot is valid,
* and if pair is non-null
* and of length 2;
* otherwise does nothing.
Returns the contents of the given slot of
* the PathNode at the given index
* if the index is in range and the slot is valid;
* otherwise returns null.
Returns the contents of the slot indices[1] of
* the PathNode at the index indices[0]
* if indices is non-null
* and of length 2
* and if the index is in range and the slot is valid;
* otherwise returns null.
Searches the nodes in this path list
* and for each such node
* searches the slots in the node
* to determine if the given (x,y) is within epsilon
* of the values in the slot;
* if successful, returns an array int[2]
* with value 0 equal to the node index
* and value 1 equal to the slot index;
* if unsuccessful, returns null.
The metric Metric.MAX is used.
* * @param x the x-coordinate of the search point * @param y the y-coordinate of the search point * @param epsilon the measure of closeness */ public final int[] nearSlot(double x, double y, double epsilon) { return nearSlot(x, y, epsilon, Metric.MAX); } /** *Searches the nodes in this path list
* and for each such node
* searches the slots in the node
* to determine if the given (x,y) is within epsilon
* of the values in the slot relative to the given metric;
* if successful, returns an array int[2]
* with value 0 equal to the node index
* and value 1 equal to the slot index;
* if unsuccessful, returns null.
If the given metric is null
* then Metric.MAX is used.
Inserts the specified node at the specified position in
* this PathList and shifts any elements right as needed.
Does not clone the node but adds the node as is.
* *Does nothing if the given node is null. It is
* therefore impossible to place a null node in the list.
Forces the given index into the range:
* *0 <= index <= size()* * @param index the list position * @param node the node to add to the list */ public final void add(int index, PathNode node) { if (node == null) return; if (index < 0) index = 0; else if (index > size()) index = size(); pathlist.add(index, node); } /** *
Inserts the specified array of nodes into this
* PathList starting at the specified position in
* the list and shifts any elements right as needed.
Does not clone any nodes but adds them as is.
* *Does nothing if the given node array is null
* and ignores any null items in the array.
Forces the given start index into the range:
* *0 <= index <= size()* * @param index the list start position * @param nodes the nodes to clone and add to the list */ public final void add(int index, PathNode[] nodes) { add(index, nodes, false); } /** *
Inserts the specified array of nodes into this
* PathList starting at the specified position in
* the list and shifts any elements right as needed.
Does not clone any nodes but adds them as is.
* *Does nothing if the given node array is null
* and ignores any null items in the array.
Forces the given start index into the range:
* *0 <= index <= size()* *
If the connect parameter is true and if the insert start index * is not zero then if the first inserted node is a MOVE it will be * changed to a LINE. If the connect parameter is false then there * will be no change to the first inserted node.
* * @param index the list start position * @param nodes the nodes to clone and add to the list * @param connect whether or not to modify the first inserted node in * order to connect the inserted nodes to the existing nodes */ public final void add(int index, PathNode[] nodes, boolean connect) { if (nodes == null) return; int N = nodes.length; if (N == 0) return; if (index < 0) index = 0; else if (index > size()) index = size(); int start = index; for (int i = 0; i < N; i++) if (nodes[i] != null) { pathlist.add(index, nodes[i]); index++; } if (connect) if (start > 0) if (index > start) get(start).changeMoveToLine(); } /** *Appends the specified node to this PathList.
Does not clone the node but appends the node as is.
* *Does nothing if the given node is null.
Appends the specified array of nodes to this
* PathList.
Does not clone any nodes but appends them as is.
* *Does nothing if the given node array is null
* and ignores any null items in the array.
Appends the specified array of nodes to this
* PathList.
Does not clone any nodes but appends them as is.
* *Does nothing if the given node array is null
* and ignores any null items in the array.
If the connect parameter is true and if the current list is not * empty then if the first appended node is a MOVE it will be changed * to a LINE. If the connect parameter is false then there will be no * change to the first appended node.
* * @param nodes the nodes to clone and append to the list * @param connect whether or not to modify the first appended node in * order to connect the appended nodes to the existing nodes */ public final void append(PathNode[] nodes, boolean connect) { if (nodes == null) return; int N = nodes.length; if (N == 0) return; int start = size(); int index = start; for (int i = 0; i < N; i++) if (nodes[i] != null) { pathlist.add(nodes[i]); index++; } if (connect) if (start > 0) if (index > start) get(start).changeMoveToLine(); } /** *Extracts the path node data from the given iterator and appends * the nodes to this path list.
* *The method must execute the iteration so when it is
* complete then iterator.isDone() will be true.
Extracts the path node data from the given iterator and appends * the nodes to this path list.
* *If the connect parameter is true and if the current list is not * empty then if the first appended node is a MOVE it will be changed * to a LINE. If the connect parameter is false then there will be no * change to the first appended node.
* *The method must execute the iteration so when it is
* complete then iterator.isDone() will be true.
Extracts the path node data from the given shape and appends * the nodes to this path list.
* * @param shape the shape whose data is to be extracted */ public final void append(Shape shape) { append(shape, false); } /** *Extracts the path node data from the given shape and appends * the nodes to this path list.
* *If the connect parameter is true and if the current list is not * empty then the first appended node will be changed from a MOVE to * a LINE.
* * @param shape the shape whose data is to be extracted * @param connect whether or not to modify the first appended node in * order to connect the appended nodes to the existing nodes */ public final void append(Shape shape, boolean connect) { if (shape == null) return; append(shape.getPathIterator(null), connect); } /** *Extracts the path node data from the given shape and appends * the nodes to this path list * after applying the given transform.
* * @param shape the shape whose data is to be extracted * @param transform the transform to apply to the shape data */ public final void append (Shape shape, AffineTransform transform) { append(shape, transform, false); } /** *Extracts the path node data from the given shape and appends * the nodes to this path list * after applying the given transform.
* *If the connect parameter is true and if the current list is not * empty then the first appended node will be changed from a MOVE to * a LINE.
* * @param shape the shape whose data is to be extracted * @param transform the transform to apply to the shape data * @param connect whether or not to modify the first appended node in * order to connect the appended nodes to the existing nodes */ public final void append (Shape shape, AffineTransform transform, boolean connect) { if (shape == null) return; append(shape.getPathIterator(transform), connect); } /** *Extracts the path node data from the given shape and appends * the nodes to this path list * after applying the given transform and flatness.
* * @param shape the shape whose data is to be extracted * @param transform the transform to apply to the shape data * @param flatness the flatness to require */ public final void append (Shape shape, AffineTransform transform, double flatness) { append(shape, transform, flatness, false); } /** *Extracts the path node data from the given shape and appends * the nodes to this path list * after applying the given transform and flatness.
* *If the connect parameter is true and if the current list is not * empty then the first appended node will be changed from a MOVE to * a LINE.
* * @param shape the shape whose data is to be extracted * @param transform the transform to apply to the shape data * @param flatness the flatness to require * @param connect whether or not to modify the first appended node in * order to connect the appended nodes to the existing nodes */ public final void append (Shape shape, AffineTransform transform, double flatness, boolean connect) { if (shape == null) return; append(shape.getPathIterator(transform, flatness), connect); } /** *Inserts a clone of the specified node at the specified position in
* this PathList and shifts any elements right as needed.
Does nothing if the given node is null. It is
* therefore impossible to place a null node in the list.
Forces the given index into the range:
* *0 <= index <= size()* * @param index the list position * @param node the node to clone and add to the list */ public final void cloneAndAdd(int index, PathNode node) { if (node == null) return; if (index < 0) index = 0; else if (index > size()) index = size(); pathlist.add(index, new PathNode(node)); } /** *
Inserts clones of the specified array of nodes to this
* PathList starting at the specified position in
* the list and shifts any elements right as needed.
Does nothing if the given node array is null
* and ignores any null items in the array.
Forces the given start index into the range:
* *0 <= index <= size()* * @param index the list start position * @param nodes the nodes to clone and add to the list */ public final void cloneAndAdd(int index, PathNode[] nodes) { cloneAndAdd(index, nodes, false); } /** *
Inserts clones of the specified array of nodes to this
* PathList starting at the specified position in
* the list and shifts any elements right as needed.
Does nothing if the given node array is null
* and ignores any null items in the array.
Forces the given start index into the range:
* *0 <= index <= size()* *
If the connect parameter is true and if the insert start index * is not zero then if the first inserted node is a MOVE it will be * changed to a LINE. If the connect parameter is false then there * will be no change to the first inserted node.
* * @param index the list start position * @param nodes the nodes to clone and add to the list * @param connect whether or not to modify the first inserted node in * order to connect the inserted nodes to the existing nodes */ public final void cloneAndAdd(int index, PathNode[] nodes, boolean connect) { if (nodes == null) return; int N = nodes.length; if (N == 0) return; if (index < 0) index = 0; else if (index > size()) index = size(); int start = index; for (int i = 0; i < N; i++) if (nodes[i] != null) { pathlist.add(index, new PathNode(nodes[i])); index++; } if (connect) if (start > 0) if (index > start) get(start).changeMoveToLine(); } /** *Appends a clone of the specified node to this PathList.
Does nothing if the given node is null.
Appends clones of the specified array of nodes to this
* PathList.
Does nothing if the given node array is null
* and ignores any null items in the array.
Appends clones of the specified array of nodes to this
* PathList.
Does nothing if the given node array is null
* and ignores any null items in the array.
If the connect parameter is true and if the current list is not * empty then if the first appended node is a MOVE it will be changed * to a LINE. If the connect parameter is false then there will be no * change to the first appended node.
* * @param nodes the nodes to clone and append to the list * @param connect whether or not to modify the first appended node in * order to connect the appended nodes to the existing nodes */ public final void cloneAndAppend(PathNode[] nodes, boolean connect) { if (nodes == null) return; int N = nodes.length; if (N == 0) return; int start = size(); int index = start; for (int i = 0; i < N; i++) if (nodes[i] != null) { pathlist.add(new PathNode(nodes[i])); index++; } if (connect) if (start > 0) if (index > start) get(start).changeMoveToLine(); } /** *Removes the PathNode at the given index
* and returns the removed node.
Returns null if the index is not valid.
PathNode to remove
*/
public final PathNode remove(int index) {
if ((index >= 0) && (index < size()))
return (PathNode) pathlist.remove(index);
else
return null;
}
/**
* Removes the PathNodes starting at the given
* index m inclusive and ending at the given index n exclusive;
* returns an array with the removed nodes.
Forces m and n into range if needed.
* *Returns an array of length 0 if no nodes are removed.
* * @param m the starting index inclusive * @param n the ending index exclusive */ public final PathNode[] remove(int m, int n) { if (m < 0) m = 0; if (n > size()) n = size(); int c = n - m; if (c <= 0) return new PathNode[0]; PathNode[] result = new PathNode[c]; while (n > m) { c--; n--; result[c] = (PathNode) pathlist.remove(n); } return result; } /** * Removes allPathNodes from the path list
* and returns an array with the removed nodes.
*/
public final PathNode[] removeAll() {
return remove(0, size());
}
/**
* Transforms the internal data points in each path node using the given * affine transform.
* *Does nothing if the given affine transform is null.
Returns true if this PathList is a valid path list
* for the construction of a Shape.
More precisely, returns true if the list is empty (size is zero)
* or if the initial PathNode has type MOVE.
Returns true if the list has at least 2 nodes, all nodes in the * list have one of the following 3 types MOVE, LINE, CLOSE, and the * first node is MOVE.
* *This is a "loose" definition of "polygon" since the method does * not make assertions about whether the path consists of one open or * closed chain of line segments.
*/ public final boolean isPolygon() { int N = size(); if (N < 2) return false; if (get(0).getNodeType() != MOVE) return false; for (int i = 1; i < N; i++) { PathNode node = get(i); int type = node.getNodeType(); if ((type == QUAD) || (type == CUBIC)) return false; } return true; } /** *Returns true if the list has at least 2 nodes, the initial * node has type MOVE, the final node has type LINE or CLOSE, all * inner nodes have type LINE, and at least one node has type LINE.
* *Historical note: Java defines java.awt.Polygon.
* Since this class is awt-based, the coordinates of a point must
* be integers not floating point numbers. In addition, this class
* requires that a polygon be closed and have WIND_EVEN_ODD at its
* winding rule. This method intentionally does not test for these
* constraints since we do believe them to be essential.
Returns a new PathList with the same winding
* rule as this path list and whose nodes are constructed from
* the nodes of this path list by the following operations.
If the type of a node is MOVE, LINE, or CLOSE, then a copy * of the node is inserted in the new list.
* *A node of the form QUAD[x1;y1;x2;y2] is replaced by * a node LINE[x2;y2].
* *A node of the form CUBIC[x1;y1;x2;y2;x3;y3] is replaced by * a node LINE[x3;y3].
* *If isPolygon() is true then this method just
* returns a copy of this path list.
Returns a new PathList with the same winding
* rule as this path list and whose nodes are constructed from
* the nodes of this path list by the following operations.
If the type of a node is MOVE, LINE, or CLOSE, then a copy * of the node is inserted in the new list.
* *A node of the form QUAD[x1;y1;x2;y2] is replaced by * 2 nodes LINE[x1;y1], LINE[x2;y2].
* *A node of the form CUBIC[x1;y1;x2;y2;x3;y3] is replaced by * 3 nodes LINE[x1;y1], LINE[x2;y2], LINE[x3;y3].
* *If isPolygon() is true then this method just
* returns a copy of this path list.
Returns a new PathList with the same winding
* rule as this path list and whose nodes are constructed from
* the nodes of this path list by the following operations.
If the type of a node is CLOSE, then the node is * ignored.
* *A node of the form MOVE[x1;y1] or the form LINE[x1;y1] is * replaced by 2 nodes MOVE[x1;y1], LINE[x1;y1].
* *A node of the form QUAD[x1;y1;x2;y2] is replaced by * 2 nodes MOVE[x2;y2], LINE[x2;y2].
* *A node of the form CUBIC[x1;y1;x2;y2;x3;y3] is replaced by * 2 nodes MOVE[x3;y3], LINE[x3;y3].
*/ public final PathList makeVertexDotsPathList() { PathList list = new PathList(); list.setWindingRule(getWindingRule()); int N = size(); for (int i = 0; i < N; i++) { PathNode node = get(i); int type = node.getNodeType(); switch (type) { case MOVE: case LINE: { float x1 = node.getX1(); float y1 = node.getY1(); list.append(new PathNode(MOVE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(LINE, x1, y1, 0, 0, 0, 0)); break; } case QUAD: { float x2 = node.getX2(); float y2 = node.getY2(); list.append(new PathNode(MOVE, x2, y2, 0, 0, 0, 0)); list.append(new PathNode(LINE, x2, y2, 0, 0, 0, 0)); break; } case CUBIC: { float x3 = node.getX3(); float y3 = node.getY3(); list.append(new PathNode(MOVE, x3, y3, 0, 0, 0, 0)); list.append(new PathNode(LINE, x3, y3, 0, 0, 0, 0)); break; } case CLOSE: default: break; } } return list; } /** *Returns a new PathList with the same winding
* rule as this path list and whose nodes are constructed from
* the nodes of this path list by the following operations.
If the type of a node is CLOSE, then the node is * ignored.
* *A node of the form MOVE[x1;y1] or the form LINE[x1;y1] is * replaced by 2 nodes MOVE[x1;y1], LINE[x1;y1].
* *A node of the form QUAD[x1;y1;x2;y2] is replaced by * 4 nodes MOVE[x1;y1], LINE[x1;y1], MOVE[x2;y2], LINE[x2;y2].
* *A node of the form CUBIC[x1;y1;x2;y2;x3;y3] is replaced by * 6 nodes MOVE[x1;y1], LINE[x1;y1], MOVE[x2;y2], LINE[x2;y2], * MOVE[x3;y3], LINE[x3;y3].
*/ public final PathList makeBezierDotsPathList() { PathList list = new PathList(); list.setWindingRule(getWindingRule()); int N = size(); for (int i = 0; i < N; i++) { PathNode node = get(i); int type = node.getNodeType(); switch (type) { case MOVE: case LINE: { float x1 = node.getX1(); float y1 = node.getY1(); list.append(new PathNode(MOVE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(LINE, x1, y1, 0, 0, 0, 0)); break; } case QUAD: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); list.append(new PathNode(MOVE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(LINE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(MOVE, x2, y2, 0, 0, 0, 0)); list.append(new PathNode(LINE, x2, y2, 0, 0, 0, 0)); break; } case CUBIC: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); float x3 = node.getX3(); float y3 = node.getY3(); list.append(new PathNode(MOVE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(LINE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(MOVE, x2, y2, 0, 0, 0, 0)); list.append(new PathNode(LINE, x2, y2, 0, 0, 0, 0)); list.append(new PathNode(MOVE, x3, y3, 0, 0, 0, 0)); list.append(new PathNode(LINE, x3, y3, 0, 0, 0, 0)); break; } case CLOSE: default: break; } } return list; } /** *Returns a new PathList with the same winding
* rule as this path list and whose nodes are constructed from
* the nodes of this path list by the following operations.
If the type of a node is MOVE, LINE, or CLOSE, then the * node is ignored.
* *A node of the form QUAD[x1;y1;x2;y2] is replaced by * 2 nodes MOVE[x1;y1], LINE[x1;y1].
* *A node of the form CUBIC[x1;y1;x2;y2;x3;y3] is replaced by * 4 nodes MOVE[x1;y1], LINE[x1;y1], MOVE[x2;y2], LINE[x2;y2].
*/ public final PathList makeControlDotsPathList() { PathList list = new PathList(); list.setWindingRule(getWindingRule()); int N = size(); for (int i = 0; i < N; i++) { PathNode node = get(i); int type = node.getNodeType(); switch (type) { case QUAD: { float x1 = node.getX1(); float y1 = node.getY1(); list.append(new PathNode(MOVE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(LINE, x1, y1, 0, 0, 0, 0)); break; } case CUBIC: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); list.append(new PathNode(MOVE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(LINE, x1, y1, 0, 0, 0, 0)); list.append(new PathNode(MOVE, x2, y2, 0, 0, 0, 0)); list.append(new PathNode(LINE, x2, y2, 0, 0, 0, 0)); break; } case MOVE: case LINE: case CLOSE: default: break; } } return list; } /** * Returns aPathListIterator constructed from
* an instance of makeVertexPathList().
*/
public final PathListIterator makeVertexPathListIterator() {
return makeVertexPathList().makePathListIterator();
}
/**
* Returns a PathListIterator constructed from
* an instance of makeBezierPathList().
*/
public final PathListIterator makeBezierPathListIterator() {
return makeBezierPathList().makePathListIterator();
}
/**
* Returns a PathListIterator constructed from
* an instance of makeVertexDotsPathList().
*/
public final PathListIterator makeVertexDotsPathListIterator() {
return makeVertexDotsPathList().makePathListIterator();
}
/**
* Returns a PathListIterator constructed from
* an instance of makeBezierDotsPathList().
*/
public final PathListIterator makeBezierDotsPathListIterator() {
return makeBezierDotsPathList().makePathListIterator();
}
/**
* Returns a PathListIterator constructed from
* an instance of makeControlDotsPathList().
*/
public final PathListIterator makeControlDotsPathListIterator() {
return makeControlDotsPathList().makePathListIterator();
}
/**
* Returns a polygonal Shape that passes through
* the vertex points of this pathlist.
Returns a polygonal Shape that passes through
* the bezier points of this pathlist, that is, both the vertex
* points and the control points.
Shape that consists of the vertex dots.
*/
public final Shape makeVertexDotsShape() {
GeneralPath gp = new GeneralPath(getWindingRule().rule());
if (! isValid())
return gp;
int N = size();
for (int i = 0; i < N; i++) {
PathNode node = get(i);
int type = node.getNodeType();
switch (type) {
case MOVE:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
break;
case LINE:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
break;
case QUAD:
gp.moveTo(node.getX2(), node.getY2());
gp.lineTo(node.getX2(), node.getY2());
break;
case CUBIC:
gp.moveTo(node.getX3(), node.getY3());
gp.lineTo(node.getX3(), node.getY3());
break;
case CLOSE:
default:
break;
}
}
return gp;
}
/**
* Returns a Shape that consists of the bezier dots.
*/
public final Shape makeBezierDotsShape() {
GeneralPath gp = new GeneralPath(getWindingRule().rule());
if (! isValid())
return gp;
int N = size();
for (int i = 0; i < N; i++) {
PathNode node = get(i);
int type = node.getNodeType();
switch (type) {
case MOVE:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
break;
case LINE:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
break;
case QUAD:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
gp.moveTo(node.getX2(), node.getY2());
gp.lineTo(node.getX2(), node.getY2());
break;
case CUBIC:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
gp.moveTo(node.getX2(), node.getY2());
gp.lineTo(node.getX2(), node.getY2());
gp.moveTo(node.getX3(), node.getY3());
gp.lineTo(node.getX3(), node.getY3());
break;
case CLOSE:
default:
break;
}
}
return gp;
}
/**
* Returns a Shape that consists of the control dots.
*/
public final Shape makeControlDotsShape() {
GeneralPath gp = new GeneralPath(getWindingRule().rule());
if (! isValid())
return gp;
int N = size();
for (int i = 0; i < N; i++) {
PathNode node = get(i);
int type = node.getNodeType();
switch (type) {
case QUAD:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
break;
case CUBIC:
gp.moveTo(node.getX1(), node.getY1());
gp.lineTo(node.getX1(), node.getY1());
gp.moveTo(node.getX2(), node.getY2());
gp.lineTo(node.getX2(), node.getY2());
break;
case MOVE:
case LINE:
case CLOSE:
default:
break;
}
}
return gp;
}
/**
* Returns a new Point2D[] whose points are built
* to include the vertex points of the path list by the following
* operations.
For a node of the form MOVE[x1;y1] or LINE[x1;y1], * 1 point [x1;y1] is added to the array.
* *For a node of the form QUAD[x1;y1;x2;y2], * 1 point [x2;y2] is added to the array.
* *For a node of the form CUBIC[x1;y1;x2;y2;x3;y3], * 1 point [x3;y3] is added to the array.
*/ public final Point2D[] makeVertexPoints() { Vector list = new Vector(); int N = size(); for (int i = 0; i < N; i++) { PathNode node = get(i); int type = node.getNodeType(); switch (type) { case MOVE: case LINE: { float x1 = node.getX1(); float y1 = node.getY1(); list.add(new Point2D.Double(x1, y1)); break; } case QUAD: { float x2 = node.getX2(); float y2 = node.getY2(); list.add(new Point2D.Double(x2, y2)); break; } case CUBIC: { float x3 = node.getX3(); float y3 = node.getY3(); list.add(new Point2D.Double(x3, y3)); break; } case CLOSE: default: break; } } return (Point2D[]) list.toArray(new Point2D[0]); } /** *Returns a new Point2D[] whose points are built
* to include the bezier points of the path list by the following
* operations.
For a node of the form MOVE[x1;y1] or LINE[x1;y1], * 1 point [x1;y1] is added to the array.
* *For a node of the form QUAD[x1;y1;x2;y2], * 2 points [x1;y1], [x2;y2] are added to the array.
* *For a node of the form CUBIC[x1;y1;x2;y2;x3;y3], * 3 points [x1;y1], [x2;y2], [x3;y3] are added to the array.
*/ public final Point2D[] makeBezierPoints() { Vector list = new Vector(); int N = size(); for (int i = 0; i < N; i++) { PathNode node = get(i); int type = node.getNodeType(); switch (type) { case MOVE: case LINE: { float x1 = node.getX1(); float y1 = node.getY1(); list.add(new Point2D.Double(x1, y1)); break; } case QUAD: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); list.add(new Point2D.Double(x1, y1)); list.add(new Point2D.Double(x2, y2)); break; } case CUBIC: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); float x3 = node.getX3(); float y3 = node.getY3(); list.add(new Point2D.Double(x1, y1)); list.add(new Point2D.Double(x2, y2)); list.add(new Point2D.Double(x3, y3)); break; } case CLOSE: default: break; } } return (Point2D[]) list.toArray(new Point2D[0]); } /** *Returns a new Point2D[] whose points are built
* to include the control points of the path list by the following
* operations.
For a node of the form QUAD[x1;y1;x2;y2], * 1 point [x1;y1] is added to the array.
* *For a node of the form CUBIC[x1;y1;x2;y2;x3;y3], * 2 points [x1;y1], [x2;y2] are added to the array.
*/ public final Point2D[] makeControlPoints() { Vector list = new Vector(); int N = size(); for (int i = 0; i < N; i++) { PathNode node = get(i); int type = node.getNodeType(); switch (type) { case QUAD: { float x1 = node.getX1(); float y1 = node.getY1(); list.add(new Point2D.Double(x1, y1)); break; } case CUBIC: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); list.add(new Point2D.Double(x1, y1)); list.add(new Point2D.Double(x2, y2)); break; } case MOVE: case LINE: case CLOSE: default: break; } } return (Point2D[]) list.toArray(new Point2D[0]); } /** *Static method that returns the vertex shape corresponding to * the given shape.
* *Current implementation: Use the shape to make a path list and * then use the path list to make the associated vertex shape.
* * @param the shape whose vertex shape is desired */ public static Shape makeVertexShape(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeVertexShape(); } /** *Static method that returns the bezier shape corresponding to * the given shape.
* *Current implementation: Use the shape to make a path list and * then use the path list to make the associated bezier shape.
* * @param the shape whose bezier shape is desired */ public static Shape makeBezierShape(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeBezierShape(); } /** *Static method that returns the vertex dots shape corresponding to * the given shape.
* *Current implementation: Use the shape to make a path list and * then use the path list to make the associated vertex dots shape.
* * @param the shape whose vertex dots shape is desired */ public static Shape makeVertexDotsShape(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeVertexDotsShape(); } /** *Static method that returns the bezier dots shape corresponding to * the given shape.
* *Current implementation: Use the shape to make a path list and * then use the path list to make the associated bezier dots shape.
* * @param the shape whose bezier dots shape is desired */ public static Shape makeBezierDotsShape(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeBezierDotsShape(); } /** *Static method that returns the control dots shape corresponding to * the given shape.
* *Current implementation: Use the shape to make a path list and * then use the path list to make the associated control dots shape.
* * @param the shape whose control dots shape is desired */ public static Shape makeControlDotsShape(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeControlDotsShape(); } /** *Static method that returns the vertex point array for the * given shape.
* *Current implementation: Use the shape to make a path list * and then use the path list to make the associated vertex point * array.
* * @param the shape whose vertex point array is desired */ public static Point2D[] makeVertexPoints(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeVertexPoints(); } /** *Static method that returns the bezier point array for the * given shape.
* *Current implementation: Use the shape to make a path list * and then use the path list to make the associated bezier point * array.
* * @param the shape whose bezier point array is desired */ public static Point2D[] makeBezierPoints(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeBezierPoints(); } /** *Static method that returns the control point array for the * given shape.
* *Current implementation: Use the shape to make a path list * and then use the path list to make the associated control point * array.
* * @param the shape whose control point array is desired */ public static Point2D[] makeControlPoints(Shape shape) { PathList pathlist = new PathList(shape); return pathlist.makeControlPoints(); } /** *Without actually constructing the shape, this function returns * the mathematical point at float parameter t on the shape that * would correspond to this path list.
* *Let us explain how the computation is done and what happens in
* boundary cases. For brevity, we use the notation [x;y]
* to stand for an internal data pair or for a return value of the form
* new float[] { x, y }.
Returns [0;0] if the size of this list is 0 or if
* isValid() is false.
Otherwise, for this discussion, let N = size()
* and M = N - 1.
First assume that t is an integer with
* 0 <= t <= M.
* What is returned at t depends on the t-th node in the path list.
If the t-th node is MOVE[x1;y1] or
* LINE[x1;y1], return [x1;y1].
If the t-th node is QUAD[x1;y1;x2;y2], return
* [x2;y2].
If the t-th node is CUBIC[x1;y1;x2;y2;x3;y3], return
* [x3;y3].
If the t-th node is CLOSE[], return
* [xc;yc] where [xc;yc] is the
* coordinate pair of the last previous MOVE operation in the path list.
We next give the out-of-bounds return values.
* *If t < 0, return the value for
* t = 0.
If t > M, return the value for
* t = M.
Finally assume that t = k + z where
* k is an integer and 0 < z < 1.
* Assume also that [x0,y0] is the coordinate pair of the
* point returned by this function at the integer k.
If the node at (k+1) is MOVE[x1;y1], return
* [x0;y0] since a move represents a discontinuous jump.
If the node at (k+1) is LINE[x1;y1], return the
* linear interpolation by z between [x0;y0] and
* [x1;y1]. The linear interpolation is defined by:
(1-z)*[x0;y0] + z*[x1;y1]* *
If the node at (k+1) is QUAD[x1;y1;x2;y2], return
* the quadratic interpolation by z in the quadratic bezier arch
* [x0;y0;x1;y1;x2;y2].
If the node at (k+1) is CUBIC[x1;y1;x2;y2;x3;y3],
* return the cubic interpolation by z in the cubic bezier arch
* [x0;y0;x1;y1;x2;y2;x3;y3].
If the node at (k+1) is CLOSE[] return the linear
* interpolation by z between [x0;y0] and
* [xc;yc] where [xc;yc] is the coordinate
* pair of the last previous MOVE operation in the path list.
The Bezier polynomials defined in class Bezier
* are used to compute the x,y coordinates of the linear, quadratic,
* and cubic interpolations. See the comments in that class for more
* mathematical details.
Examination of the above algorithm reveals that we assume that * the parameter interval for each node in the pathlist is of length 1. * It is possible to assign a different parameter interval to each node * but we have decided to stick with the simplest case in this method.
* * @param t the parameter at which to a point on a shape */ public final float[] getShapePoint(float t) { int N = size(); if (N == 0) return new float[2]; PathNode start = get(0); if (! (start.getNodeType() == MOVE)) return new float[2]; // zero or out of bounds below if (t <= 0) { return new float[] { start.getX1(), start.getY1() }; } int M = N - 1; // out of bounds above if (t > M) return getShapePoint(M); // in bounds int k = (int) t; float z = t - k; // integer case if (z == 0) { PathNode node = get(k); int type = node.getNodeType(); switch (type) { case MOVE: case LINE: return new float[] { node.getX1(), node.getY1() }; case QUAD: return new float[] { node.getX2(), node.getY2() }; case CUBIC: return new float[] { node.getX3(), node.getY3() }; case CLOSE: k--; while (k >= 0) { node = get(k); type = node.getNodeType(); if (type == MOVE) return new float[] { node.getX1(), node.getY1() }; else k--; } // error situation default: return new float[2]; } } // non-integer case else { PathNode node = get(k+1); int type = node.getNodeType(); float[] last = getShapePoint(k); float x0 = last[0]; float y0 = last[1]; switch (type) { case MOVE: { return last; } case LINE: { float x1 = node.getX1(); float y1 = node.getY1(); float x = Bezier.bezierF(z, x0, x1); float y = Bezier.bezierF(z, y0, y1); return new float[] { x, y }; } case QUAD: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); float x = Bezier.bezierF(z, x0, x1, x2); float y = Bezier.bezierF(z, y0, y1, y2); return new float[] { x, y }; } case CUBIC: { float x1 = node.getX1(); float y1 = node.getY1(); float x2 = node.getX2(); float y2 = node.getY2(); float x3 = node.getX3(); float y3 = node.getY3(); float x = Bezier.bezierF(z, x0, x1, x2, x3); float y = Bezier.bezierF(z, y0, y1, y2, y3); return new float[] { x, y }; } case CLOSE: { while (k >= 0) { node = get(k); type = node.getNodeType(); if (type == MOVE) break; else k--; } float x1 = node.getX1(); float y1 = node.getY1(); float x = Bezier.bezierF(z, x0, x1); float y = Bezier.bezierF(z, y0, y1); return new float[] { x, y }; } // error situation default: return new float[2]; } } } /** *Returns the data in this path list as a multi-line
* String.
The first line returned is one of the following two * lines:
* *WIND_NON_ZERO* *
WIND_EVEN_ODD* *
The remaining lines give the PathNode
* information for each path node in the path list using
* the toString() method of that class.
String as toString(). */
public String toStringData() {
return toString();
}
/**
* Sets the data of this path list using String
* data in the format produced by toString().
Throws ParseException if the data is not in
* the correct format.
String with the list information
* @throws ParseException
*/
public void fromStringData(String data)
throws ParseException
{
if (data == null) {
String message = "PathList error: null data\n";
throw new ParseException(message, -1);
}
data = data.trim();
String[] item = Strings.tokenize(data, "\n", true);
int L = item.length;
if (L < 1) {
String message = "PathList error: Too few lines of data " + L + "\n"
+ data + "\n\n" + standardMessage;
throw new ParseException(message, -1);
}
WindingRule rule = getWindingRuleFromStringData(item[0]);
int N = L - 1;
PathNode[] nodes = new PathNode[N];
for (int i = 0; i < N; i++) {
String info = item[i + 1];
try {
nodes[i] = new PathNode(info);
}
catch (ParseException ex) {
String message = "PathList error in PathNode data item: " + i + "\n"
+ info + "\n\n"
+ ex.getMessage() + "\n"
+ standardMessage;
throw new ParseException(message, -1);
}
}
setWindingRule(rule);
setPathNodes(nodes);
}
/**
* Returns a String with the value of the method
* toStringData applied to each item in the array
* returned by getPathNodes.
Returns a String with the winding rule information.
Returns one of:
* *WIND_NON_ZERO* *
WIND_EVEN_ODD*/ public final String getWindingRuleString() { if (windingrule == WindingRule.WIND_NON_ZERO) return String_WIND_NON_ZERO; else return String_WIND_EVEN_ODD; } /** *
Returns the WindingRule that corresponds to the
* given String data.
The valid input data is:
* *WIND_NON_ZERO* *
WIND_EVEN_ODD* *
Throws ParseException if the winding rule data
* does not match either of the above strings.
String with the winding rule
* @throws ParseException
*/
public WindingRule getWindingRuleFromStringData(String data)
throws ParseException
{
if (data == null) {
String message = "PathList winding rule error: null data\n";
throw new ParseException(message, -1);
}
data = data.trim().toUpperCase();
if (data.equals(String_WIND_NON_ZERO))
return WindingRule.WIND_NON_ZERO;
if (data.equals(String_WIND_EVEN_ODD))
return WindingRule.WIND_EVEN_ODD;
String message =
"PathList winding rule error:\n" + data + "\n\n" + standardMessage;
throw new ParseException(message, -1);
}
/**
* Opens a file dialog to get the file name of a text file * with path list data and then reads the data.
* *
Does nothing to the current list if errors occur.
* * @return true if the operation succeeds */ public final boolean readDataFromFile() { int result = filechooser.showOpenDialog(null); if (result == JFileChooser.CANCEL_OPTION) return false; if (result == JFileChooser.ERROR_OPTION) { GeneralDialog.showOKDialog ("File Dialog Error", "File Dialog Error"); return false; } File source = filechooser.getSelectedFile(); filechooser.setCurrentDirectory(source); return readDataFromFile(source, true); } /** *Reads the path list data from the given text file.
* *
Does nothing to the current list if errors occur.
* * @param source the data source * @param displayErrorDialogs if true display error dialogs * * @return true if the operation succeeds */ public final boolean readDataFromFile (File source, boolean displayErrorDialogs) { if (source == null) { if (displayErrorDialogs) { String message = "Error in reading file\n" + "Null source File\n"; GeneralDialog.showOKDialog (message, "File Read Error"); } return false; } String data = ""; try { data = FileUtilities.readFile(source); } catch (Exception ex) { if (displayErrorDialogs) { String message = "Error in reading file\n" + source.getName() + "\n\n" + ex.getMessage() + "\n"; GeneralDialog.showOKDialog (message, "File Read Error"); } return false; } PathList list = new PathList(); try { list.fromStringData(data); } catch (ParseException ex) { if (displayErrorDialogs) { String message = "Error in reading data\n" + source.getName() + "\n\n" + ex.getMessage() + "\n"; GeneralDialog.showOKDialog (message, "File Data Error"); } return false; } setPathList(list); return true; } /** *Opens a file dialog to get the file name of a text file * and then saves the data to the file.
* *
The current path list is unchanged.
* *Does nothing if errors occur.
* * @return true if the operation succeeds */ public final boolean saveDataToFile() { int result = filechooser.showSaveDialog(null); if (result == JFileChooser.CANCEL_OPTION) return false; if (result == JFileChooser.ERROR_OPTION) { GeneralDialog.showOKDialog ("File Dialog Error", "File Dialog Error"); return false; } File target = filechooser.getSelectedFile(); filechooser.setCurrentDirectory(target); return saveDataToFile(target, true); } /** *Saves the path list data to the given text file.
* *
The current path list is unchanged.
* *Does nothing if errors occur.
* * @param target the data target * @param displayErrorDialogs if true display error dialogs * @return true if the operation succeeds */ public final boolean saveDataToFile (File target, boolean displayErrorDialogs) { if (target == null) { if (displayErrorDialogs) { String message = "Error in writing file\n" + "Null target File\n"; GeneralDialog.showOKDialog (message, "File Save Error"); } return false; } String data = toString(); try { FileUtilities.writeFile(target, data, true); } catch (Exception ex) { if (displayErrorDialogs) { String message = "Error in writing file\n" + target.getName() + "\n\n" + ex.getMessage() + "\n"; GeneralDialog.showOKDialog (message, "File Save Error"); } return false; } return true; } }