LinearGradientPaint class provides a way to fill
+ * a {@link java.awt.Shape} with a linear color gradient pattern. The user may
+ * specify 2 or more gradient colors, and this paint will provide an
+ * interpolation between each color. The user also specifies start and end
+ * points which define where in user space the color gradient should begin
+ * and end.
+ * + * The user must provide an array of floats specifying how to distribute the + * colors along the gradient. These values should range from 0.0 to 1.0 and + * act like keyframes along the gradient (they mark where the gradient should + * be exactly a particular color). + *
+ * For example:
+ *
+ * Point2D start = new Point2D.Float(0, 0);
+ *
+ *
+ *
+ * Point2D end = new Point2D.Float(100,100);
+ * float[] dist = {0.0, 0.2, 1.0};
+ * Color[] colors = {Color.red, Color.white, Color.blue};
+ * LinearGradientPaint p = new LinearGradientPaint(start, end, dist, colors);
+ *
+ * This code will create a LinearGradientPaint which interpolates between + * red and white for the first 20% of the gradient and between white and blue + * for the remaining 80%. + * + *
In the event that the user does not set the first keyframe value equal
+ * to 0 and the last keyframe value equal to 1, keyframes will be created at
+ * these positions and the first and last colors will be replicated there.
+ * So, if a user specifies the following arrays to construct a gradient:
+ * {Color.blue, Color.red}, {.3, .7}
+ * this will be converted to a gradient with the following keyframes:
+ * {Color.blue, Color.blue, Color.red, Color.red}, {0, .3, .7, 1}
+ *
+ *
+ * The user may also select what action the LinearGradientPaint should take + * when filling color outside the start and end points. If no cycle method is + * specified, NO_CYCLE will be chosen by default, so the endpoint colors + * will be used to fill the remaining area. + * + *
The following image demonstrates the options NO_CYCLE and REFLECT. + * + *
+ * 
+ *
+ *
The colorSpace parameter allows the user to specify in which colorspace + * the interpolation should be performed, default sRGB or linearized RGB. + * + * + * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans + * @author Vincent Hardy + * @version $Id: LinearGradientPaint.java,v 1.2 2004/09/27 09:27:27 kitfox Exp $ + * @see java.awt.Paint + * @see java.awt.Graphics2D#setPaint + * + */ + +public final class LinearGradientPaint extends MultipleGradientPaint { + + /** Gradient start and end points. */ + private Point2D start, end; + + /**
+ * Constructs an LinearGradientPaint with the default
+ * NO_CYCLE repeating method and SRGB colorspace.
+ *
+ * @param startX the x coordinate of the gradient axis start point
+ * in user space
+ *
+ * @param startY the y coordinate of the gradient axis start point
+ * in user space
+ *
+ * @param endX the x coordinate of the gradient axis end point
+ * in user space
+ *
+ * @param endY the y coordinate of the gradient axis end point
+ * in user space
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors corresponding to each fractional value
+ *
+ *
+ * @throws IllegalArgumentException if start and end points are the
+ * same points, or if fractions.length != colors.length, or if colors
+ * is less than 2 in size.
+ *
+ */
+ public LinearGradientPaint(float startX, float startY,
+ float endX, float endY,
+ float[] fractions, Color[] colors) {
+
+ this(new Point2D.Float(startX, startY),
+ new Point2D.Float(endX, endY),
+ fractions,
+ colors,
+ NO_CYCLE,
+ SRGB);
+ }
+
+ /**
+ * Constructs an LinearGradientPaint with default SRGB
+ * colorspace.
+ *
+ * @param startX the x coordinate of the gradient axis start point
+ * in user space
+ *
+ * @param startY the y coordinate of the gradient axis start point
+ * in user space
+ *
+ * @param endX the x coordinate of the gradient axis end point
+ * in user space
+ *
+ * @param endY the y coordinate of the gradient axis end point
+ * in user space
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors corresponding to each fractional value
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @throws IllegalArgumentException if start and end points are the
+ * same points, or if fractions.length != colors.length, or if colors
+ * is less than 2 in size.
+ *
+ */
+ public LinearGradientPaint(float startX, float startY,
+ float endX, float endY,
+ float[] fractions, Color[] colors,
+ CycleMethodEnum cycleMethod) {
+ this(new Point2D.Float(startX, startY),
+ new Point2D.Float(endX, endY),
+ fractions,
+ colors,
+ cycleMethod,
+ SRGB);
+ }
+
+ /**
+ * Constructs a LinearGradientPaint with the default
+ * NO_CYCLE repeating method and SRGB colorspace.
+ *
+ * @param start the gradient axis start Point in user space
+ *
+ * @param end the gradient axis end Point in user space
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors corresponding to each fractional value
+ *
+ * @throws NullPointerException if one of the points is null
+ *
+ * @throws IllegalArgumentException if start and end points are the
+ * same points, or if fractions.length != colors.length, or if colors
+ * is less than 2 in size.
+ *
+ */
+ public LinearGradientPaint(Point2D start, Point2D end, float[] fractions,
+ Color[] colors) {
+
+ this(start, end, fractions, colors, NO_CYCLE, SRGB);
+ }
+
+ /**
+ * Constructs a LinearGradientPaint.
+ *
+ * @param start the gradient axis start Point in user space
+ *
+ * @param end the gradient axis end Point in user space
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors corresponding to each fractional value
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @param colorSpace which colorspace to use for interpolation,
+ * either SRGB or LINEAR_RGB
+ *
+ * @throws NullPointerException if one of the points is null
+ *
+ * @throws IllegalArgumentException if start and end points are the
+ * same points, or if fractions.length != colors.length, or if colors
+ * is less than 2 in size.
+ *
+ */
+ public LinearGradientPaint(Point2D start, Point2D end, float[] fractions,
+ Color[] colors,
+ CycleMethodEnum cycleMethod,
+ ColorSpaceEnum colorSpace) {
+
+ this(start, end, fractions, colors, cycleMethod, colorSpace,
+ new AffineTransform());
+
+ }
+
+ /**
+ * Constructs a
+ * This class provides a way to fill a shape with a circular radial color
+ * gradient pattern. The user may specify 2 or more gradient colors, and this
+ * paint will provide an interpolation between each color.
+ *
+ *
+ * The user must provide an array of floats specifying how to distribute the
+ * colors along the gradient. These values should range from 0.0 to 1.0 and
+ * act like keyframes along the gradient (they mark where the gradient should
+ * be exactly a particular color).
+ *
+ *
+ * This paint will map the first color of the gradient to a focus point within
+ * the circle, and the last color to the perimeter of the circle, interpolating
+ * smoothly for any inbetween colors specified by the user. Any line drawn
+ * from the focus point to the circumference will span the all the gradient
+ * colors. By default the focus is set to be the center of the circle.
+ *
+ *
+ * Specifying a focus point outside of the circle's radius will result in the
+ * focus being set to the intersection point of the focus-center line and the
+ * perimenter of the circle.
+ *
+ *
+ * Specifying a cycle method allows the user to control the painting behavior
+ * outside of the bounds of the circle's radius. See LinearGradientPaint for
+ * more details.
+ *
+ *
+ * The following code demonstrates typical usage of RadialGradientPaint:
+ *
+ * In the event that the user does not set the first keyframe value equal
+ * to 0 and the last keyframe value equal to 1, keyframes will be created at
+ * these positions and the first and last colors will be replicated there.
+ * So, if a user specifies the following arrays to construct a gradient:
+ *
+ * This image demonstrates a radial gradient with NO_CYCLE and default focus.
+ *
+ *
+ *
+ * This image demonstrates a radial gradient with NO_CYCLE and non-centered
+ * focus.
+ *
+ *
+ *
+ * This image demonstrates a radial gradient with REFLECT and non-centered
+ * focus.
+ *
+ * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans
+ * @author Vincent Hardy
+ * @version $Id: RadialGradientPaint.java,v 1.1 2004/09/06 19:35:39 kitfox Exp $
+ *
+ */
+
+public final class RadialGradientPaint extends MultipleGradientPaint {
+
+ /** Focus point which defines the 0% gradient stop x coordinate. */
+ private Point2D focus;
+
+ /** Center of the circle defining the 100% gradient stop x coordinate. */
+ private Point2D center;
+
+ /** Radius of the outermost circle defining the 100% gradient stop. */
+ private float radius;
+
+ /**
+ *
+ *
+ * Constructs a
+ *
+ * Constructs a
+ *
+ * Constructs a
+ *
+ * Constructs a
+ *
+ * Constructs a
+ *
+ * Constructs a
+ *
+ * Constructs a
+ * Creates and returns a PaintContext used to generate the color pattern,
+ * for use by the internal rendering engine.
+ *
+ * @param cm {@link ColorModel} that receives
+ * the
+ * This method
+ * simply performs
+ * This method simply performs the call
+ *
+ * This method simply performs
+ * The
+ * Implements the abstract write method of OutputStream.
+ *
+ * @param b the
+ * The
+ * Note that this method does not call the one-argument
+ *
+ * The
+ * Note that this method does not call the
+ * The
+ * The LinearGradientPaint.
+ *
+ * @param start the gradient axis start Point in user space
+ *
+ * @param end the gradient axis end Point in user space
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors corresponding to each fractional value
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @param colorSpace which colorspace to use for interpolation,
+ * either SRGB or LINEAR_RGB
+ *
+ * @param gradientTransform transform to apply to the gradient
+ *
+ * @throws NullPointerException if one of the points is null,
+ * or gradientTransform is null
+ *
+ * @throws IllegalArgumentException if start and end points are the
+ * same points, or if fractions.length != colors.length, or if colors
+ * is less than 2 in size.
+ *
+ */
+ public LinearGradientPaint(Point2D start, Point2D end, float[] fractions,
+ Color[] colors,
+ CycleMethodEnum cycleMethod,
+ ColorSpaceEnum colorSpace,
+ AffineTransform gradientTransform) {
+ super(fractions, colors, cycleMethod, colorSpace, gradientTransform);
+
+ //
+ // Check input parameters
+ //
+ if (start == null || end == null) {
+ throw new NullPointerException("Start and end points must be" +
+ "non-null");
+ }
+
+ if (start.equals(end)) {
+ throw new IllegalArgumentException("Start point cannot equal" +
+ "endpoint");
+ }
+
+ //copy the points...
+ this.start = (Point2D)start.clone();
+
+ this.end = (Point2D)end.clone();
+
+ }
+
+ /**
+ * Creates and returns a PaintContext used to generate the color pattern,
+ * for use by the internal rendering engine.
+ *
+ * @param cm {@link ColorModel} that receives
+ * the Paint data. This is used only as a hint.
+ *
+ * @param deviceBounds the device space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param userBounds the user space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param transform the {@link AffineTransform} from user
+ * space into device space
+ *
+ * @param hints the hints that the context object uses to choose
+ * between rendering alternatives
+ *
+ * @return the {@link PaintContext} that generates color patterns.
+ *
+ * @see PaintContext
+ */
+ public PaintContext createContext(ColorModel cm,
+ Rectangle deviceBounds,
+ Rectangle2D userBounds,
+ AffineTransform transform,
+ RenderingHints hints) {
+
+ // Can't modify the transform passed in...
+ transform = new AffineTransform(transform);
+ //incorporate the gradient transform
+ transform.concatenate(gradientTransform);
+
+ try {
+ return new LinearGradientPaintContext(cm,
+ deviceBounds,
+ userBounds,
+ transform,
+ hints,
+ start,
+ end,
+ fractions,
+ this.getColors(),
+ cycleMethod,
+ colorSpace);
+ }
+
+ catch(NoninvertibleTransformException e) {
+ e.printStackTrace();
+ throw new IllegalArgumentException("transform should be" +
+ "invertible");
+ }
+ }
+
+ /**
+ * Returns a copy of the start point of the gradient axis
+ * @return a {@link Point2D} object that is a copy of the point
+ * that anchors the first color of this
+ * LinearGradientPaint.
+ */
+ public Point2D getStartPoint() {
+ return new Point2D.Double(start.getX(), start.getY());
+ }
+
+ /** Returns a copy of the end point of the gradient axis
+ * @return a {@link Point2D} object that is a copy of the point
+ * that anchors the last color of this
+ * LinearGradientPaint.
+ */
+ public Point2D getEndPoint() {
+ return new Point2D.Double(end.getX(), end.getY());
+ }
+
+}
+
+
Index: trunk/src/com/kitfox/svg/batik/LinearGradientPaintContext.java
===================================================================
--- trunk/src/com/kitfox/svg/batik/LinearGradientPaintContext.java (revision 4256)
+++ trunk/src/com/kitfox/svg/batik/LinearGradientPaintContext.java (revision 4256)
@@ -0,0 +1,529 @@
+/*****************************************************************************
+ * Copyright (C) The Apache Software Foundation. All rights reserved. *
+ * ------------------------------------------------------------------------- *
+ * This software is published under the terms of the Apache Software License *
+ * version 1.1, a copy of which has been included with this distribution in *
+ * the LICENSE file. *
+ *****************************************************************************/
+
+package com.kitfox.svg.batik;
+
+import java.awt.Color;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+
+/**
+ * Provides the actual implementation for the LinearGradientPaint
+ * This is where the pixel processing is done.
+ *
+ * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans
+ * @author Vincent Hardy
+ * @version $Id: LinearGradientPaintContext.java,v 1.2 2007/02/04 01:28:05 kitfox Exp $
+ * @see java.awt.PaintContext
+ * @see java.awt.Paint
+ * @see java.awt.GradientPaint
+ */
+final class LinearGradientPaintContext extends MultipleGradientPaintContext {
+
+ /**
+ * The following invariants are used to process the gradient value from
+ * a device space coordinate, (X, Y):
+ * g(X, Y) = dgdX*X + dgdY*Y + gc
+ */
+ private float dgdX, dgdY, gc, pixSz;
+
+ private static final int DEFAULT_IMPL = 1;
+ private static final int ANTI_ALIAS_IMPL = 3;
+
+ private int fillMethod;
+
+ /**
+ * Constructor for LinearGradientPaintContext.
+ *
+ * @param cm {@link ColorModel} that receives
+ * the Paint data. This is used only as a hint.
+ *
+ * @param deviceBounds the device space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param userBounds the user space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param t the {@link AffineTransform} from user
+ * space into device space (gradientTransform should be
+ * concatenated with this)
+ *
+ * @param hints the hints that the context object uses to choose
+ * between rendering alternatives
+ *
+ * @param start gradient start point, in user space
+ *
+ * @param end gradient end point, in user space
+ *
+ * @param fractions the fractions specifying the gradient distribution
+ *
+ * @param colors the gradient colors
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @param colorSpace which colorspace to use for interpolation,
+ * either SRGB or LINEAR_RGB
+ *
+ */
+ public LinearGradientPaintContext(ColorModel cm,
+ Rectangle deviceBounds,
+ Rectangle2D userBounds,
+ AffineTransform t,
+ RenderingHints hints,
+ Point2D dStart,
+ Point2D dEnd,
+ float[] fractions,
+ Color[] colors,
+ MultipleGradientPaint.CycleMethodEnum
+ cycleMethod,
+ MultipleGradientPaint.ColorSpaceEnum
+ colorSpace)
+ throws NoninvertibleTransformException
+ {
+ super(cm, deviceBounds, userBounds, t, hints, fractions,
+ colors, cycleMethod, colorSpace);
+
+ // Use single precision floating points
+ Point2D.Float start = new Point2D.Float((float)dStart.getX(),
+ (float)dStart.getY());
+ Point2D.Float end = new Point2D.Float((float)dEnd.getX(),
+ (float)dEnd.getY());
+
+ // A given point in the raster should take on the same color as its
+ // projection onto the gradient vector.
+ // Thus, we want the projection of the current position vector
+ // onto the gradient vector, then normalized with respect to the
+ // length of the gradient vector, giving a value which can be mapped into
+ // the range 0-1.
+ // projection = currentVector dot gradientVector / length(gradientVector)
+ // normalized = projection / length(gradientVector)
+
+ float dx = end.x - start.x; // change in x from start to end
+ float dy = end.y - start.y; // change in y from start to end
+ float dSq = dx*dx + dy*dy; // total distance squared
+
+ //avoid repeated calculations by doing these divides once.
+ float constX = dx/dSq;
+ float constY = dy/dSq;
+
+ //incremental change along gradient for +x
+ dgdX = a00*constX + a10*constY;
+ //incremental change along gradient for +y
+ dgdY = a01*constX + a11*constY;
+
+ float dgdXAbs = Math.abs(dgdX);
+ float dgdYAbs = Math.abs(dgdY);
+ if (dgdXAbs > dgdYAbs) pixSz = dgdXAbs;
+ else pixSz = dgdYAbs;
+
+ //constant, incorporates the translation components from the matrix
+ gc = (a02-start.x)*constX + (a12-start.y)*constY;
+
+ Object colorRend = hints == null ? RenderingHints.VALUE_COLOR_RENDER_SPEED : hints.get(RenderingHints.KEY_COLOR_RENDERING);
+ Object rend = hints == null ? RenderingHints.VALUE_RENDER_SPEED : hints.get(RenderingHints.KEY_RENDERING);
+
+ fillMethod = DEFAULT_IMPL;
+
+ if ((cycleMethod == MultipleGradientPaint.REPEAT) ||
+ hasDiscontinuity) {
+ if (rend == RenderingHints.VALUE_RENDER_QUALITY)
+ fillMethod = ANTI_ALIAS_IMPL;
+ // ColorRend overrides rend.
+ if (colorRend == RenderingHints.VALUE_COLOR_RENDER_SPEED)
+ fillMethod = DEFAULT_IMPL;
+ else if (colorRend == RenderingHints.VALUE_COLOR_RENDER_QUALITY)
+ fillMethod = ANTI_ALIAS_IMPL;
+ }
+ }
+
+ protected void fillHardNoCycle(int[] pixels, int off, int adjust,
+ int x, int y, int w, int h) {
+
+ //constant which can be pulled out of the inner loop
+ final float initConst = (dgdX*x) + gc;
+
+ for(int i=0; i
+ * Point2D center = new Point2D.Float(0, 0);
+ *
+ *
+ * float radius = 20;
+ * float[] dist = {0.0, 0.2, 1.0};
+ * Color[] colors = {Color.red, Color.white, Color.blue};
+ * RadialGradientPaint p = new RadialGradientPaint(center, radius,
+ * dist, colors);
+ *
+ * {Color.blue, Color.red}, {.3, .7}
+ * this will be converted to a gradient with the following keyframes:
+ * {Color.blue, Color.blue, Color.red, Color.red}, {0, .3, .7, 1}
+ *
+ *
+ * 
+ * 
+ * 
+ * RadialGradientPaint, using the center as the
+ * focus point.
+ *
+ * @param cx the x coordinate in user space of the center point of the
+ * circle defining the gradient. The last color of the gradient is mapped
+ * to the perimeter of this circle
+ *
+ * @param cy the y coordinate in user space of the center point of the
+ * circle defining the gradient. The last color of the gradient is mapped
+ * to the perimeter of this circle
+ *
+ * @param radius the radius of the circle defining the extents of the
+ * color gradient
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors to use in the gradient. The first color
+ * is used at the focus point, the last color around the perimeter of the
+ * circle.
+ *
+ *
+ * @throws IllegalArgumentException
+ * if fractions.length != colors.length, or if colors is less
+ * than 2 in size, or if radius < 0
+ *
+ *
+ */
+ public RadialGradientPaint(float cx, float cy, float radius,
+ float[] fractions, Color[] colors) {
+ this(cx, cy,
+ radius,
+ cx, cy,
+ fractions,
+ colors);
+ }
+
+ /**
+ * RadialGradientPaint, using the center as the
+ * focus point.
+ *
+ * @param center the center point, in user space, of the circle defining
+ * the gradient
+ *
+ * @param radius the radius of the circle defining the extents of the
+ * color gradient
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors to use in the gradient. The first color
+ * is used at the focus point, the last color around the perimeter of the
+ * circle.
+ *
+ * @throws NullPointerException if center point is null
+ *
+ * @throws IllegalArgumentException
+ * if fractions.length != colors.length, or if colors is less
+ * than 2 in size, or if radius < 0
+ *
+ *
+ */
+ public RadialGradientPaint(Point2D center, float radius,
+ float[] fractions, Color[] colors) {
+ this(center,
+ radius,
+ center,
+ fractions,
+ colors);
+ }
+
+ /**
+ * RadialGradientPaint.
+ *
+ * @param cx the x coordinate in user space of the center point of the
+ * circle defining the gradient. The last color of the gradient is mapped
+ * to the perimeter of this circle
+ *
+ * @param cy the y coordinate in user space of the center point of the
+ * circle defining the gradient. The last color of the gradient is mapped
+ * to the perimeter of this circle
+ *
+ * @param radius the radius of the circle defining the extents of the
+ * color gradient
+ *
+ * @param fx the x coordinate of the point in user space to which the
+ * first color is mapped
+ *
+ * @param fy the y coordinate of the point in user space to which the
+ * first color is mapped
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors to use in the gradient. The first color
+ * is used at the focus point, the last color around the perimeter of the
+ * circle.
+ *
+ * @throws IllegalArgumentException
+ * if fractions.length != colors.length, or if colors is less
+ * than 2 in size, or if radius < 0
+ *
+ *
+ */
+ public RadialGradientPaint(float cx, float cy, float radius,
+ float fx, float fy,
+ float[] fractions, Color[] colors) {
+ this(new Point2D.Float(cx, cy),
+ radius,
+ new Point2D.Float(fx, fy),
+ fractions,
+ colors,
+ NO_CYCLE,
+ SRGB);
+ }
+
+ /**
+ * RadialGradientPaint.
+ *
+ * @param center the center point, in user space, of the circle defining
+ * the gradient. The last color of the gradient is mapped to the perimeter
+ * of this circle
+ *
+ * @param radius the radius of the circle defining the extents of the color
+ * gradient
+ *
+ * @param focus the point, in user space, to which the first color is
+ * mapped
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors to use in the gradient. The first color
+ * is used at the focus point, the last color around the perimeter of the
+ * circle.
+ *
+ * @throws NullPointerException if one of the points is null
+ *
+ * @throws IllegalArgumentException
+ * if fractions.length != colors.length, or if colors is less
+ * than 2 in size, or if radius < 0
+ *
+ */
+ public RadialGradientPaint(Point2D center, float radius,
+ Point2D focus,
+ float[] fractions, Color[] colors) {
+ this(center,
+ radius,
+ focus,
+ fractions,
+ colors,
+ NO_CYCLE,
+ SRGB);
+ }
+
+ /**
+ * RadialGradientPaint.
+ *
+ * @param center the center point in user space of the circle defining the
+ * gradient. The last color of the gradient is mapped to the perimeter of
+ * this circle
+ *
+ * @param radius the radius of the circle defining the extents of the color
+ * gradient
+ *
+ * @param focus the point in user space to which the first color is mapped
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors to use in the gradient. The first color is
+ * used at the focus point, the last color around the perimeter of the
+ * circle.
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @param colorSpace which colorspace to use for interpolation,
+ * either SRGB or LINEAR_RGB
+ *
+ * @throws NullPointerException if one of the points is null
+ *
+ * @throws IllegalArgumentException
+ * if fractions.length != colors.length, or if colors is less
+ * than 2 in size, or if radius < 0
+ *
+ */
+ public RadialGradientPaint(Point2D center, float radius,
+ Point2D focus,
+ float[] fractions, Color[] colors,
+ CycleMethodEnum cycleMethod,
+ ColorSpaceEnum colorSpace) {
+ this(center,
+ radius,
+ focus,
+ fractions,
+ colors,
+ cycleMethod,
+ colorSpace,
+ new AffineTransform());
+ }
+
+ /**
+ * RadialGradientPaint.
+ *
+ * @param center the center point in user space of the circle defining the
+ * gradient. The last color of the gradient is mapped to the perimeter of
+ * this circle
+ *
+ * @param radius the radius of the circle defining the extents of the color
+ * gradient.
+ *
+ * @param focus the point in user space to which the first color is mapped
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors to use in the gradient. The first color is
+ * used at the focus point, the last color around the perimeter of the
+ * circle.
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @param colorSpace which colorspace to use for interpolation,
+ * either SRGB or LINEAR_RGB
+ *
+ * @param gradientTransform transform to apply to the gradient
+ *
+ * @throws NullPointerException if one of the points is null,
+ * or gradientTransform is null
+ *
+ * @throws IllegalArgumentException
+ * if fractions.length != colors.length, or if colors is less
+ * than 2 in size, or if radius < 0
+ *
+ */
+ public RadialGradientPaint(Point2D center,
+ float radius,
+ Point2D focus,
+ float[] fractions, Color[] colors,
+ CycleMethodEnum cycleMethod,
+ ColorSpaceEnum colorSpace,
+ AffineTransform gradientTransform){
+ super(fractions, colors, cycleMethod, colorSpace, gradientTransform);
+
+ // Check input arguments
+ if (center == null) {
+ throw new NullPointerException("Center point should not be null.");
+ }
+
+ if (focus == null) {
+ throw new NullPointerException("Focus point should not be null.");
+ }
+
+ if (radius <= 0) {
+ throw new IllegalArgumentException("radius should be greater than zero");
+ }
+
+ //copy parameters
+ this.center = (Point2D)center.clone();
+ this.focus = (Point2D)focus.clone();
+ this.radius = radius;
+ }
+
+ /**
+ * RadialGradientPaint, the gradient circle is
+ * defined by a bounding box.
+ *
+ * @param gradientBounds the bounding box, in user space, of the circle
+ * defining outermost extent of the gradient.
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors to use in the gradient. The first color
+ * is used at the focus point, the last color around the perimeter of the
+ * circle.
+ *
+ * @throws NullPointerException if the gradientBounds is null
+ *
+ * @throws IllegalArgumentException
+ * if fractions.length != colors.length, or if colors is less
+ * than 2 in size, or if radius < 0
+ *
+ */
+ public RadialGradientPaint(Rectangle2D gradientBounds,
+ float[] fractions, Color[] colors) {
+
+ //calculate center point and radius based on bounding box coordinates.
+ this((float)gradientBounds.getX() +
+ ( (float)gradientBounds.getWidth() / 2),
+
+ (float)gradientBounds.getY() +
+ ( (float)gradientBounds.getWidth() / 2),
+
+ (float)gradientBounds.getWidth() / 2,
+ fractions, colors);
+ }
+
+
+ /** Paint data. This is used only as a hint.
+ *
+ * @param deviceBounds the device space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param userBounds the user space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param transform the {@link AffineTransform} from user
+ * space into device space
+ *
+ * @param hints the hints that the context object uses to choose
+ * between rendering alternatives
+ *
+ * @return the {@link PaintContext} that generates color patterns.
+ *
+ * @throws IllegalArgumentException if the transform is not invertible
+ *
+ * @see PaintContext
+ */
+ public PaintContext createContext(ColorModel cm,
+ Rectangle deviceBounds,
+ Rectangle2D userBounds,
+ AffineTransform transform,
+ RenderingHints hints) {
+ // Can't modify the transform passed in...
+ transform = new AffineTransform(transform);
+ // incorporate the gradient transform
+ transform.concatenate(gradientTransform);
+
+ try{
+ return new RadialGradientPaintContext
+ (cm, deviceBounds, userBounds, transform, hints,
+ (float)center.getX(), (float)center.getY(), radius,
+ (float)focus.getX(), (float)focus.getY(),
+ fractions, colors, cycleMethod, colorSpace);
+ }
+
+ catch(NoninvertibleTransformException e){
+ throw new IllegalArgumentException("transform should be " +
+ "invertible");
+ }
+ }
+
+ /**
+ * Returns a copy of the center point of the radial gradient.
+ * @return a {@link Point2D} object that is a copy of the center point
+ */
+ public Point2D getCenterPoint() {
+ return new Point2D.Double(center.getX(), center.getY());
+ }
+
+ /** Returns a copy of the end point of the gradient axis.
+ * @return a {@link Point2D} object that is a copy of the focus point
+ */
+ public Point2D getFocusPoint() {
+ return new Point2D.Double(focus.getX(), focus.getY());
+ }
+
+ /** Returns the radius of the circle defining the radial gradient.
+ * @return the radius of the circle defining the radial gradient
+ */
+ public float getRadius() {
+ return radius;
+ }
+
+}
+
Index: trunk/src/com/kitfox/svg/batik/RadialGradientPaintContext.java
===================================================================
--- trunk/src/com/kitfox/svg/batik/RadialGradientPaintContext.java (revision 4256)
+++ trunk/src/com/kitfox/svg/batik/RadialGradientPaintContext.java (revision 4256)
@@ -0,0 +1,775 @@
+/*****************************************************************************
+ * Copyright (C) The Apache Software Foundation. All rights reserved. *
+ * ------------------------------------------------------------------------- *
+ * This software is published under the terms of the Apache Software License *
+ * version 1.1, a copy of which has been included with this distribution in *
+ * the LICENSE file. *
+ *****************************************************************************/
+
+package com.kitfox.svg.batik;
+
+import java.awt.Color;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+
+/**
+ * Provides the actual implementation for the RadialGradientPaint.
+ * This is where the pixel processing is done. A RadialGradienPaint
+ * only supports circular gradients, but it should be possible to scale
+ * the circle to look approximately elliptical, by means of a
+ * gradient transform passed into the RadialGradientPaint constructor.
+ *
+ * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans
+ * @author Vincent Hardy
+ * @version $Id: RadialGradientPaintContext.java,v 1.2 2005/10/12 20:36:55 kitfox Exp $
+ *
+ */
+final class RadialGradientPaintContext extends MultipleGradientPaintContext {
+
+ /** True when (focus == center) */
+ private boolean isSimpleFocus = false;
+
+ /** True when (cycleMethod == NO_CYCLE) */
+ private boolean isNonCyclic = false;
+
+ /** Radius of the outermost circle defining the 100% gradient stop. */
+ private float radius;
+
+ /** Variables representing center and focus points. */
+ private float centerX, centerY, focusX, focusY;
+
+ /** Radius of the gradient circle squared. */
+ private float radiusSq;
+
+ /** Constant part of X, Y user space coordinates. */
+ private float constA, constB;
+
+ /** This value represents the solution when focusX == X. It is called
+ * trivial because it is easier to calculate than the general case.
+ */
+ private float trivial;
+
+ private static final int FIXED_POINT_IMPL = 1;
+ private static final int DEFAULT_IMPL = 2;
+ private static final int ANTI_ALIAS_IMPL = 3;
+
+ private int fillMethod;
+
+ /** Amount for offset when clamping focus. */
+ private static final float SCALEBACK = .97f;
+
+ /**
+ * Constructor for RadialGradientPaintContext.
+ *
+ * @param cm {@link ColorModel} that receives
+ * the Paint data. This is used only as a hint.
+ *
+ * @param deviceBounds the device space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param userBounds the user space bounding box of the
+ * graphics primitive being rendered
+ *
+ * @param t the {@link AffineTransform} from user
+ * space into device space (gradientTransform should be
+ * concatenated with this)
+ *
+ * @param hints the hints that the context object uses to choose
+ * between rendering alternatives
+ *
+ * @param cx the center point in user space of the circle defining
+ * the gradient. The last color of the gradient is mapped to the
+ * perimeter of this circle X coordinate
+ *
+ * @param cy the center point in user space of the circle defining
+ * the gradient. The last color of the gradient is mapped to the
+ * perimeter of this circle Y coordinate
+ *
+ * @param r the radius of the circle defining the extents of the
+ * color gradient
+ *
+ * @param fx the point in user space to which the first color is mapped
+ * X coordinate
+ *
+ * @param fy the point in user space to which the first color is mapped
+ * Y coordinate
+ *
+ * @param fractions the fractions specifying the gradient distribution
+ *
+ * @param colors the gradient colors
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @param colorSpace which colorspace to use for interpolation,
+ * either SRGB or LINEAR_RGB
+ *
+ */
+ public RadialGradientPaintContext(ColorModel cm,
+ Rectangle deviceBounds,
+ Rectangle2D userBounds,
+ AffineTransform t,
+ RenderingHints hints,
+ float cx, float cy,
+ float r,
+ float fx, float fy,
+ float[] fractions,
+ Color[] colors,
+ MultipleGradientPaint.CycleMethodEnum
+ cycleMethod,
+ MultipleGradientPaint.ColorSpaceEnum
+ colorSpace)
+ throws NoninvertibleTransformException
+ {
+ super(cm, deviceBounds, userBounds, t, hints, fractions, colors,
+ cycleMethod, colorSpace);
+
+ //copy some parameters.
+ centerX = cx;
+ centerY = cy;
+ focusX = fx;
+ focusY = fy;
+ radius = r;
+
+ this.isSimpleFocus = (focusX == centerX) && (focusY == centerY);
+ this.isNonCyclic = (cycleMethod == RadialGradientPaint.NO_CYCLE);
+
+ //for use in the quadractic equation
+ radiusSq = radius * radius;
+
+ float dX = focusX - centerX;
+ float dY = focusY - centerY;
+
+ double dist = Math.sqrt((dX * dX) + (dY * dY));
+
+ //test if distance from focus to center is greater than the radius
+ if (dist > radius* SCALEBACK) { //clamp focus to radius
+ double angle = Math.atan2(dY, dX);
+
+ //x = r cos theta, y = r sin theta
+ focusX = (float)(SCALEBACK * radius * Math.cos(angle)) + centerX;
+
+ focusY = (float)(SCALEBACK * radius * Math.sin(angle)) + centerY;
+ }
+
+ //calculate the solution to be used in the case where X == focusX
+ //in cyclicCircularGradientFillRaster
+ dX = focusX - centerX;
+ trivial = (float)Math.sqrt(radiusSq - (dX * dX));
+
+ // constant parts of X, Y user space coordinates
+ constA = a02 - centerX;
+ constB = a12 - centerY;
+
+ Object colorRend;
+ Object rend;
+ //hints can be null on Mac OSX
+ if (hints == null)
+ {
+ colorRend = RenderingHints.VALUE_COLOR_RENDER_DEFAULT;
+ rend = RenderingHints.VALUE_RENDER_DEFAULT;
+ }
+ else
+ {
+ colorRend = hints.get(RenderingHints.KEY_COLOR_RENDERING);
+ rend = hints.get(RenderingHints.KEY_RENDERING);
+ }
+
+ fillMethod = 0;
+
+ if ((rend == RenderingHints.VALUE_RENDER_QUALITY) ||
+ (colorRend == RenderingHints.VALUE_COLOR_RENDER_QUALITY)) {
+ // System.out.println("AAHints set: " + rend + ", " + colorRend);
+ fillMethod = ANTI_ALIAS_IMPL;
+ }
+
+ if ((rend == RenderingHints.VALUE_RENDER_SPEED) ||
+ (colorRend == RenderingHints.VALUE_COLOR_RENDER_SPEED)) {
+ // System.out.println("SPHints set: " + rend + ", " + colorRend);
+ fillMethod = DEFAULT_IMPL;
+ }
+
+ // We are in the 'default' case, no hint or hint set to
+ // DEFAULT values...
+ if (fillMethod == 0) {
+ // For now we will always use the 'default' impl if
+ // one is not specified.
+ fillMethod = DEFAULT_IMPL;
+
+ if (false) {
+ // This could be used for a 'smart' choice in
+ // the default case, if the gradient has obvious
+ // discontinuites use AA, otherwise default
+ if (hasDiscontinuity) {
+ fillMethod = ANTI_ALIAS_IMPL;
+ } else {
+ fillMethod = DEFAULT_IMPL;
+ }
+ }
+ }
+
+ if ((fillMethod == DEFAULT_IMPL) &&
+ (isSimpleFocus && isNonCyclic && isSimpleLookup)) {
+ this.calculateFixedPointSqrtLookupTable();
+ fillMethod = FIXED_POINT_IMPL;
+ }
+ }
+
+ /**
+ * Return a Raster containing the colors generated for the graphics
+ * operation.
+ * @param x,y,w,h The area in device space for which colors are
+ * generated.
+ */
+ protected void fillRaster(int pixels[], int off, int adjust,
+ int x, int y, int w, int h) {
+ switch(fillMethod) {
+ case FIXED_POINT_IMPL:
+ // System.out.println("Calling FP");
+ fixedPointSimplestCaseNonCyclicFillRaster(pixels, off, adjust, x,
+ y, w, h);
+ break;
+ case ANTI_ALIAS_IMPL:
+ // System.out.println("Calling AA");
+ antiAliasFillRaster(pixels, off, adjust, x, y, w, h);
+ break;
+ case DEFAULT_IMPL:
+ default:
+ // System.out.println("Calling Default");
+ cyclicCircularGradientFillRaster(pixels, off, adjust, x, y, w, h);
+ }
+ }
+
+ /**
+ * This code works in the simplest of cases, where the focus == center
+ * point, the gradient is noncyclic, and the gradient lookup method is
+ * fast (single array index, no conversion necessary).
+ *
+ */
+ private void fixedPointSimplestCaseNonCyclicFillRaster(int pixels[],
+ int off,
+ int adjust,
+ int x, int y,
+ int w, int h) {
+ float iSq=0; // Square distance index
+ final float indexFactor = fastGradientArraySize / radius;
+
+ //constant part of X and Y coordinates for the entire raster
+ final float constX = (a00*x) + (a01*y) + constA;
+ final float constY = (a10*x) + (a11*y) + constB;
+ final float deltaX = indexFactor * a00; //incremental change in dX
+ final float deltaY = indexFactor * a10; //incremental change in dY
+ float dX, dY; //the current distance from center
+ final int fixedArraySizeSq=
+ (fastGradientArraySize * fastGradientArraySize);
+ float g, gDelta, gDeltaDelta, temp; //gradient square value
+ int gIndex; // integer number used to index gradient array
+ int iSqInt; // Square distance index
+
+ int end, j; //indexing variables
+ int indexer = off;//used to index pixels array
+
+ temp = ((deltaX * deltaX) + (deltaY * deltaY));
+ gDeltaDelta = ((temp * 2));
+
+ if (temp > fixedArraySizeSq) {
+ // This combination of scale and circle radius means
+ // essentially no pixels will be anything but the end
+ // stop color. This also avoids math problems.
+ final int val = gradientOverflow;
+ for(j = 0; j < h; j++){ //for every row
+ //for every column (inner loop begins here)
+ for (end = indexer+w; indexer < end; indexer++)
+ pixels[indexer] = val;
+ indexer += adjust;
+ }
+ return;
+ }
+
+ // For every point in the raster, calculate the color at that point
+ for(j = 0; j < h; j++){ //for every row
+ //x and y (in user space) of the first pixel of this row
+ dX = indexFactor * ((a01*j) + constX);
+ dY = indexFactor * ((a11*j) + constY);
+
+ // these values below here allow for an incremental calculation
+ // of dX^2 + dY^2
+
+ //initialize to be equal to distance squared
+ g = (((dY * dY) + (dX * dX)) );
+ gDelta = (((((deltaY * dY) + (deltaX * dX))* 2) +
+ temp));
+
+ //for every column (inner loop begins here)
+ for (end = indexer+w; indexer < end; indexer++) {
+ //determine the distance to the center
+
+ //since this is a non cyclic fill raster, crop at "1" and 0
+ if (g >= fixedArraySizeSq) {
+ pixels[indexer] = gradientOverflow;
+ }
+
+ // This should not happen as gIndex is a square
+ // quantity. Code commented out on purpose, can't underflow.
+ // else if (g < 0) {
+ // gIndex = 0;
+ // }
+
+ else {
+ iSq = (g * invSqStepFloat);
+
+ iSqInt = (int)iSq; //chop off fractional part
+ iSq -= iSqInt;
+ gIndex = sqrtLutFixed[iSqInt];
+ gIndex += (int)(iSq * (sqrtLutFixed[iSqInt + 1]-gIndex));
+ pixels[indexer] = gradient[gIndex];
+ }
+
+
+ //incremental calculation
+ g += gDelta;
+ gDelta += gDeltaDelta;
+ }
+ indexer += adjust;
+ }
+ }
+
+ /** Length of a square distance intervale in the lookup table */
+ private float invSqStepFloat;
+
+ /** Used to limit the size of the square root lookup table */
+ private int MAX_PRECISION = 256;
+
+ /** Square root lookup table */
+ private int sqrtLutFixed[] = new int[MAX_PRECISION];
+
+ /**
+ * Build square root lookup table
+ */
+ private void calculateFixedPointSqrtLookupTable() {
+ float sqStepFloat;
+ sqStepFloat = ((fastGradientArraySize * fastGradientArraySize)
+ / (MAX_PRECISION - 2));
+
+ // The last two values are the same so that linear square root
+ // interpolation can happen on the maximum reachable element in the
+ // lookup table (precision-2)
+ int i;
+ for (i = 0; i < MAX_PRECISION - 1; i++) {
+ sqrtLutFixed[i] = (int)(Math.sqrt(i*sqStepFloat));
+ }
+ sqrtLutFixed[i] = sqrtLutFixed[i-1];
+ invSqStepFloat = 1/sqStepFloat;
+ }
+
+ /** Fill the raster, cycling the gradient colors when a point falls outside
+ * of the perimeter of the 100% stop circle.
+ *
+ * This calculation first computes the intersection point of the line
+ * from the focus through the current point in the raster, and the
+ * perimeter of the gradient circle.
+ *
+ * Then it determines the percentage distance of the current point along
+ * that line (focus is 0%, perimeter is 100%).
+ *
+ * Equation of a circle centered at (a,b) with radius r:
+ * (x-a)^2 + (y-b)^2 = r^2
+ * Equation of a line with slope m and y-intercept b
+ * y = mx + b
+ * replacing y in the cirlce equation and solving using the quadratic
+ * formula produces the following set of equations. Constant factors have
+ * been extracted out of the inner loop.
+ *
+ */
+ private void cyclicCircularGradientFillRaster(int pixels[], int off,
+ int adjust,
+ int x, int y,
+ int w, int h) {
+ // Constant part of the C factor of the quadratic equation
+ final double constC =
+ -(radiusSq) + (centerX * centerX) + (centerY * centerY);
+ double A; //coefficient of the quadratic equation (Ax^2 + Bx + C = 0)
+ double B; //coefficient of the quadratic equation
+ double C; //coefficient of the quadratic equation
+ double slope; //slope of the focus-perimeter line
+ double yintcpt; //y-intercept of the focus-perimeter line
+ double solutionX;//intersection with circle X coordinate
+ double solutionY;//intersection with circle Y coordinate
+ final float constX = (a00*x) + (a01*y) + a02;//const part of X coord
+ final float constY = (a10*x) + (a11*y) + a12; //const part of Y coord
+ final float precalc2 = 2 * centerY;//const in inner loop quad. formula
+ final float precalc3 =-2 * centerX;//const in inner loop quad. formula
+ float X; // User space point X coordinate
+ float Y; // User space point Y coordinate
+ float g;//value between 0 and 1 specifying position in the gradient
+ float det; //determinant of quadratic formula (should always be >0)
+ float currentToFocusSq;//sq distance from the current pt. to focus
+ float intersectToFocusSq;//sq distance from the intersect pt. to focus
+ float deltaXSq; //temp variable for a change in X squared.
+ float deltaYSq; //temp variable for a change in Y squared.
+ int indexer = off; //index variable for pixels array
+ int i, j; //indexing variables for FOR loops
+ int pixInc = w+adjust;//incremental index change for pixels array
+
+ for (j = 0; j < h; j++) { //for every row
+
+ X = (a01*j) + constX; //constants from column to column
+ Y = (a11*j) + constY;
+
+ //for every column (inner loop begins here)
+ for (i = 0; i < w; i++) {
+
+ // special case to avoid divide by zero or very near zero
+ if (((X-focusX)>-0.000001) &&
+ ((X-focusX)< 0.000001)) {
+ solutionX = focusX;
+
+ solutionY = centerY;
+
+ solutionY += (Y > focusY)?trivial:-trivial;
+ }
+
+ else {
+
+ //slope of the focus-current line
+ slope = (Y - focusY) / (X - focusX);
+
+ yintcpt = Y - (slope * X); //y-intercept of that same line
+
+ //use the quadratic formula to calculate the intersection
+ //point
+ A = (slope * slope) + 1;
+
+ B = precalc3 + (-2 * slope * (centerY - yintcpt));
+
+ C = constC + (yintcpt* (yintcpt - precalc2));
+
+ det = (float)Math.sqrt((B * B) - ( 4 * A * C));
+
+ solutionX = -B;
+
+ //choose the positive or negative root depending
+ //on where the X coord lies with respect to the focus.
+ solutionX += (X < focusX)?-det:det;
+
+ solutionX = solutionX / (2 * A);//divisor
+
+ solutionY = (slope * solutionX) + yintcpt;
+ }
+
+ //calculate the square of the distance from the current point
+ //to the focus and the square of the distance from the
+ //intersection point to the focus. Want the squares so we can
+ //do 1 square root after division instead of 2 before.
+
+ deltaXSq = (float)solutionX - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = (float)solutionY - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ intersectToFocusSq = deltaXSq + deltaYSq;
+
+ deltaXSq = X - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = Y - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ currentToFocusSq = deltaXSq + deltaYSq;
+
+ //want the percentage (0-1) of the current point along the
+ //focus-circumference line
+ g = (float)Math.sqrt(currentToFocusSq / intersectToFocusSq);
+
+ //Get the color at this point
+ pixels[indexer + i] = indexIntoGradientsArrays(g);
+
+ X += a00; //incremental change in X, Y
+ Y += a10;
+ } //end inner loop
+ indexer += pixInc;
+ } //end outer loop
+ }
+
+
+ /** Fill the raster, cycling the gradient colors when a point
+ * falls outside of the perimeter of the 100% stop circle. Use
+ * the anti-aliased gradient lookup.
+ *
+ * This calculation first computes the intersection point of the line
+ * from the focus through the current point in the raster, and the
+ * perimeter of the gradient circle.
+ *
+ * Then it determines the percentage distance of the current point along
+ * that line (focus is 0%, perimeter is 100%).
+ *
+ * Equation of a circle centered at (a,b) with radius r:
+ * (x-a)^2 + (y-b)^2 = r^2
+ * Equation of a line with slope m and y-intercept b
+ * y = mx + b
+ * replacing y in the cirlce equation and solving using the quadratic
+ * formula produces the following set of equations. Constant factors have
+ * been extracted out of the inner loop.
+ * */
+ private void antiAliasFillRaster(int pixels[], int off,
+ int adjust,
+ int x, int y,
+ int w, int h) {
+ // Constant part of the C factor of the quadratic equation
+ final double constC =
+ -(radiusSq) + (centerX * centerX) + (centerY * centerY);
+ //coefficients of the quadratic equation (Ax^2 + Bx + C = 0)
+ final float precalc2 = 2 * centerY;//const in inner loop quad. formula
+ final float precalc3 =-2 * centerX;//const in inner loop quad. formula
+
+ //const part of X,Y coord (shifted to bottom left corner of pixel.
+ final float constX = (a00*(x-.5f)) + (a01*(y+.5f)) + a02;
+ final float constY = (a10*(x-.5f)) + (a11*(y+.5f)) + a12;
+ float X; // User space point X coordinate
+ float Y; // User space point Y coordinate
+ int i, j; //indexing variables for FOR loops
+ int indexer = off-1; //index variable for pixels array
+
+ // Size of a pixel in user space.
+ double pixSzSq = (float)(a00*a00+a01*a01+a10*a10+a11*a11);
+ double [] prevGs = new double[w+1];
+ double deltaXSq, deltaYSq;
+ double solutionX, solutionY;
+ double slope, yintcpt, A, B, C, det;
+ double intersectToFocusSq, currentToFocusSq;
+ double g00, g01, g10, g11;
+
+ // Set X,Y to top left corner of first pixel of first row.
+ X = constX - a01;
+ Y = constY - a11;
+
+ // Calc top row of g's.
+ for (i=0; i <= w; i++) {
+ // special case to avoid divide by zero or very near zero
+ if (((X-focusX)>-0.000001) &&
+ ((X-focusX)< 0.000001)) {
+ solutionX = focusX;
+ solutionY = centerY;
+ solutionY += (Y > focusY)?trivial:-trivial;
+ }
+ else {
+ // Formula for Circle: (X-Xc)^2 + (Y-Yc)^2 - R^2 = 0
+ // Formula line: Y = Slope*x + Y0;
+ //
+ // So you substitue line into Circle and apply
+ // Quadradic formula.
+
+
+ //slope of the focus-current line
+ slope = (Y - focusY) / (X - focusX);
+
+ yintcpt = Y - (slope * X); //y-intercept of that same line
+
+ //use the quadratic formula to calculate the intersection
+ //point
+ A = (slope * slope) + 1;
+
+ B = precalc3 + (-2 * slope * (centerY - yintcpt));
+
+ C = constC + (yintcpt* (yintcpt - precalc2));
+
+ det = Math.sqrt((B * B) - ( 4 * A * C));
+
+ solutionX = -B;
+
+ //choose the positive or negative root depending
+ //on where the X coord lies with respect to the focus.
+ solutionX += (X < focusX)?-det:det;
+
+ solutionX = solutionX / (2 * A);//divisor
+
+ solutionY = (slope * solutionX) + yintcpt;
+ }
+
+ //calculate the square of the distance from the current point
+ //to the focus and the square of the distance from the
+ //intersection point to the focus. Want the squares so we can
+ //do 1 square root after division instead of 2 before.
+ deltaXSq = solutionX - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = solutionY - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ intersectToFocusSq = deltaXSq + deltaYSq;
+
+ deltaXSq = X - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = Y - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ currentToFocusSq = deltaXSq + deltaYSq;
+
+ //want the percentage (0-1) of the current point along the
+ //focus-circumference line
+ prevGs[i] = Math.sqrt(currentToFocusSq / intersectToFocusSq);
+
+ X += a00; //incremental change in X, Y
+ Y += a10;
+ }
+
+ for (j = 0; j < h; j++) { //for every row
+
+ // Set X,Y to bottom edge of pixel row.
+ X = (a01*j) + constX; //constants from row to row
+ Y = (a11*j) + constY;
+
+ g10 = prevGs[0];
+ // special case to avoid divide by zero or very near zero
+ if (((X-focusX)>-0.000001) &&
+ ((X-focusX)< 0.000001)) {
+ solutionX = focusX;
+ solutionY = centerY;
+ solutionY += (Y > focusY)?trivial:-trivial;
+ }
+ else {
+ // Formula for Circle: (X-Xc)^2 + (Y-Yc)^2 - R^2 = 0
+ // Formula line: Y = Slope*x + Y0;
+ //
+ // So you substitue line into Circle and apply
+ // Quadradic formula.
+
+
+ //slope of the focus-current line
+ slope = (Y - focusY) / (X - focusX);
+
+ yintcpt = Y - (slope * X); //y-intercept of that same line
+
+ //use the quadratic formula to calculate the intersection
+ //point
+ A = (slope * slope) + 1;
+
+ B = precalc3 + (-2 * slope * (centerY - yintcpt));
+
+ C = constC + (yintcpt* (yintcpt - precalc2));
+
+ det = Math.sqrt((B * B) - ( 4 * A * C));
+
+ solutionX = -B;
+
+ //choose the positive or negative root depending
+ //on where the X coord lies with respect to the focus.
+ solutionX += (X < focusX)?-det:det;
+
+ solutionX = solutionX / (2 * A);//divisor
+
+ solutionY = (slope * solutionX) + yintcpt;
+ }
+
+ //calculate the square of the distance from the current point
+ //to the focus and the square of the distance from the
+ //intersection point to the focus. Want the squares so we can
+ //do 1 square root after division instead of 2 before.
+ deltaXSq = solutionX - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = solutionY - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ intersectToFocusSq = deltaXSq + deltaYSq;
+
+ deltaXSq = X - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = Y - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ currentToFocusSq = deltaXSq + deltaYSq;
+ g11 = Math.sqrt(currentToFocusSq / intersectToFocusSq);
+ prevGs[0] = g11;
+
+ X += a00; //incremental change in X, Y
+ Y += a10;
+
+ //for every column (inner loop begins here)
+ for (i=1; i <= w; i++) {
+ g00 = g10;
+ g01 = g11;
+ g10 = prevGs[i];
+
+ // special case to avoid divide by zero or very near zero
+ if (((X-focusX)>-0.000001) &&
+ ((X-focusX)< 0.000001)) {
+ solutionX = focusX;
+ solutionY = centerY;
+ solutionY += (Y > focusY)?trivial:-trivial;
+ }
+ else {
+ // Formula for Circle: (X-Xc)^2 + (Y-Yc)^2 - R^2 = 0
+ // Formula line: Y = Slope*x + Y0;
+ //
+ // So you substitue line into Circle and apply
+ // Quadradic formula.
+
+
+ //slope of the focus-current line
+ slope = (Y - focusY) / (X - focusX);
+
+ yintcpt = Y - (slope * X); //y-intercept of that same line
+
+ //use the quadratic formula to calculate the intersection
+ //point
+ A = (slope * slope) + 1;
+
+ B = precalc3 + (-2 * slope * (centerY - yintcpt));
+
+ C = constC + (yintcpt* (yintcpt - precalc2));
+
+ det = Math.sqrt((B * B) - ( 4 * A * C));
+
+ solutionX = -B;
+
+ //choose the positive or negative root depending
+ //on where the X coord lies with respect to the focus.
+ solutionX += (X < focusX)?-det:det;
+
+ solutionX = solutionX / (2 * A);//divisor
+
+ solutionY = (slope * solutionX) + yintcpt;
+ }
+
+ //calculate the square of the distance from the current point
+ //to the focus and the square of the distance from the
+ //intersection point to the focus. Want the squares so we can
+ //do 1 square root after division instead of 2 before.
+ deltaXSq = solutionX - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = solutionY - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ intersectToFocusSq = deltaXSq + deltaYSq;
+
+ deltaXSq = X - focusX;
+ deltaXSq = deltaXSq * deltaXSq;
+
+ deltaYSq = Y - focusY;
+ deltaYSq = deltaYSq * deltaYSq;
+
+ currentToFocusSq = deltaXSq + deltaYSq;
+ g11 = Math.sqrt(currentToFocusSq / intersectToFocusSq);
+ prevGs[i] = g11;
+
+ //Get the color at this point
+ pixels[indexer+i] = indexGradientAntiAlias
+ ((float)((g00+g01+g10+g11)/4),
+ (float)Math.max(Math.abs(g11-g00),
+ Math.abs(g10-g01)));
+
+ X += a00; //incremental change in X, Y
+ Y += a10;
+ } //end inner loop
+ indexer += (w+adjust);
+ } //end outer loop
+ }
+}
Index: trunk/src/com/kitfox/svg/composite/AdobeComposite.java
===================================================================
--- trunk/src/com/kitfox/svg/composite/AdobeComposite.java (revision 4256)
+++ trunk/src/com/kitfox/svg/composite/AdobeComposite.java (revision 4256)
@@ -0,0 +1,70 @@
+/*
+ * AdobeComposite.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on April 1, 2004, 6:40 AM
+ */
+
+package com.kitfox.svg.composite;
+
+import java.awt.*;
+import java.awt.image.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class AdobeComposite implements Composite
+{
+ public static final int CT_NORMAL = 0;
+ public static final int CT_MULTIPLY = 1;
+ public static final int CT_LAST = 2;
+
+ final int compositeType;
+ final float extraAlpha;
+
+ /** Creates a new instance of AdobeComposite */
+ public AdobeComposite(int compositeType, float extraAlpha)
+ {
+ this.compositeType = compositeType;
+ this.extraAlpha = extraAlpha;
+
+ if (compositeType < 0 || compositeType >= CT_LAST)
+ {
+ new Exception("Invalid composite type").printStackTrace();
+ }
+
+ if (extraAlpha < 0f || extraAlpha > 1f)
+ {
+ new Exception("Invalid alpha").printStackTrace();
+ }
+ }
+
+ public int getCompositeType() { return compositeType; }
+
+ public CompositeContext createContext(ColorModel srcColorModel, ColorModel dstColorModel, RenderingHints hints)
+ {
+ return new AdobeCompositeContext(compositeType, extraAlpha);
+ }
+
+}
Index: trunk/src/com/kitfox/svg/composite/AdobeCompositeContext.java
===================================================================
--- trunk/src/com/kitfox/svg/composite/AdobeCompositeContext.java (revision 4256)
+++ trunk/src/com/kitfox/svg/composite/AdobeCompositeContext.java (revision 4256)
@@ -0,0 +1,97 @@
+/*
+ * AdobeCompositeContext.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on April 1, 2004, 6:41 AM
+ */
+
+package com.kitfox.svg.composite;
+
+import java.awt.*;
+import java.awt.image.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class AdobeCompositeContext implements CompositeContext
+{
+ final int compositeType;
+ final float extraAlpha;
+
+ float[] rgba_src = new float[4];
+ float[] rgba_dstIn = new float[4];
+ float[] rgba_dstOut = new float[4];
+
+ /** Creates a new instance of AdobeCompositeContext */
+ public AdobeCompositeContext(int compositeType, float extraAlpha)
+ {
+ this.compositeType = compositeType;
+ this.extraAlpha = extraAlpha;
+
+ rgba_dstOut[3] = 1f;
+ }
+
+ public void compose(Raster src, Raster dstIn, WritableRaster dstOut)
+ {
+ int width = src.getWidth();
+ int height = src.getHeight();
+
+ for (int j = 0; j < height; j++)
+ {
+ for (int i = 0; i < width; i++)
+ {
+ src.getPixel(i, j, rgba_src);
+ dstIn.getPixel(i, j, rgba_dstIn);
+
+ //Ignore transparent pixels
+ if (rgba_src[3] == 0)
+ {
+// dstOut.setPixel(i, j, rgba_dstIn);
+ continue;
+ }
+
+ float alpha = rgba_src[3];
+
+ switch (compositeType)
+ {
+ default:
+ case AdobeComposite.CT_NORMAL:
+ rgba_dstOut[0] = rgba_src[0] * alpha + rgba_dstIn[0] * (1f - alpha);
+ rgba_dstOut[1] = rgba_src[1] * alpha + rgba_dstIn[1] * (1f - alpha);
+ rgba_dstOut[2] = rgba_src[2] * alpha + rgba_dstIn[2] * (1f - alpha);
+ break;
+ case AdobeComposite.CT_MULTIPLY:
+ rgba_dstOut[0] = rgba_src[0] * rgba_dstIn[0] * alpha + rgba_dstIn[0] * (1f - alpha);
+ rgba_dstOut[1] = rgba_src[1] * rgba_dstIn[1] * alpha + rgba_dstIn[1] * (1f - alpha);
+ rgba_dstOut[2] = rgba_src[2] * rgba_dstIn[2] * alpha + rgba_dstIn[2] * (1f - alpha);
+ break;
+ }
+ }
+ }
+ }
+
+ public void dispose() {
+ }
+
+}
Index: trunk/src/com/kitfox/svg/package-info.java
===================================================================
--- trunk/src/com/kitfox/svg/package-info.java (revision 4256)
+++ trunk/src/com/kitfox/svg/package-info.java (revision 4256)
@@ -0,0 +1,9 @@
+/**
+ * Provides the nodes of an SVG scene graph. This graph can be queried, updated
+ * and picked against at runtime. See the online docs for instructions on
+ * how to use SVGSalamander
+ *
+ * @author Mark McKay (C) 2005
+ */
+
+package com.kitfox.svg;
Index: trunk/src/com/kitfox/svg/pathcmd/Arc.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/Arc.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/Arc.java (revision 4256)
@@ -0,0 +1,245 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.*;
+import java.awt.geom.*;
+
+/**
+ * This is a little used SVG function, as most editors will save curves as
+ * Beziers. To reduce the need to rely on the Batik library, this functionallity
+ * is being bypassed for the time being. In the future, it would be nice to
+ * extend the GeneralPath command to include the arcTo ability provided by Batik.
+ *
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class Arc extends PathCommand
+{
+
+ public float rx = 0f;
+ public float ry = 0f;
+ public float xAxisRot = 0f;
+ public boolean largeArc = false;
+ public boolean sweep = false;
+ public float x = 0f;
+ public float y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public Arc() {
+ }
+
+ public Arc(boolean isRelative, float rx, float ry, float xAxisRot, boolean largeArc, boolean sweep, float x, float y) {
+ super(isRelative);
+ this.rx = rx;
+ this.ry = ry;
+ this.xAxisRot = xAxisRot;
+ this.largeArc = largeArc;
+ this.sweep = sweep;
+ this.x = x;
+ this.y = y;
+ }
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ arcTo(path, rx, ry, xAxisRot, largeArc, sweep, x + offx, y + offy, hist.history[0].x, hist.history[0].y);
+// path.lineTo(x + offx, y + offy);
+ hist.setPoint(x + offx, y + offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 6;
+ }
+
+ /**
+ * Adds an elliptical arc, defined by two radii, an angle from the
+ * x-axis, a flag to choose the large arc or not, a flag to
+ * indicate if we increase or decrease the angles and the final
+ * point of the arc.
+ *
+ * @param rx the x radius of the ellipse
+ * @param ry the y radius of the ellipse
+ *
+ * @param angle the angle from the x-axis of the current
+ * coordinate system to the x-axis of the ellipse in degrees.
+ *
+ * @param largeArcFlag the large arc flag. If true the arc
+ * spanning less than or equal to 180 degrees is chosen, otherwise
+ * the arc spanning greater than 180 degrees is chosen
+ *
+ * @param sweepFlag the sweep flag. If true the line joining
+ * center to arc sweeps through decreasing angles otherwise it
+ * sweeps through increasing angles
+ *
+ * @param x the absolute x coordinate of the final point of the arc.
+ * @param y the absolute y coordinate of the final point of the arc.
+ * @param x0 - The absolute x coordinate of the initial point of the arc.
+ * @param y0 - The absolute y coordinate of the initial point of the arc.
+ */
+ public void arcTo(GeneralPath path, float rx, float ry,
+ float angle,
+ boolean largeArcFlag,
+ boolean sweepFlag,
+ float x, float y, float x0, float y0)
+ {
+
+ // Ensure radii are valid
+ if (rx == 0 || ry == 0) {
+ path.lineTo((float) x, (float) y);
+ return;
+ }
+
+ if (x0 == x && y0 == y) {
+ // If the endpoints (x, y) and (x0, y0) are identical, then this
+ // is equivalent to omitting the elliptical arc segment entirely.
+ return;
+ }
+
+ Arc2D arc = computeArc(x0, y0, rx, ry, angle,
+ largeArcFlag, sweepFlag, x, y);
+ if (arc == null) return;
+
+ AffineTransform t = AffineTransform.getRotateInstance
+ (Math.toRadians(angle), arc.getCenterX(), arc.getCenterY());
+ Shape s = t.createTransformedShape(arc);
+ path.append(s, true);
+ }
+
+
+ /**
+ * This constructs an unrotated Arc2D from the SVG specification of an
+ * Elliptical arc. To get the final arc you need to apply a rotation
+ * transform such as:
+ *
+ * AffineTransform.getRotateInstance
+ * (angle, arc.getX()+arc.getWidth()/2, arc.getY()+arc.getHeight()/2);
+ */
+ public static Arc2D computeArc(double x0, double y0,
+ double rx, double ry,
+ double angle,
+ boolean largeArcFlag,
+ boolean sweepFlag,
+ double x, double y) {
+ //
+ // Elliptical arc implementation based on the SVG specification notes
+ //
+
+ // Compute the half distance between the current and the final point
+ double dx2 = (x0 - x) / 2.0;
+ double dy2 = (y0 - y) / 2.0;
+ // Convert angle from degrees to radians
+ angle = Math.toRadians(angle % 360.0);
+ double cosAngle = Math.cos(angle);
+ double sinAngle = Math.sin(angle);
+
+ //
+ // Step 1 : Compute (x1, y1)
+ //
+ double x1 = (cosAngle * dx2 + sinAngle * dy2);
+ double y1 = (-sinAngle * dx2 + cosAngle * dy2);
+ // Ensure radii are large enough
+ rx = Math.abs(rx);
+ ry = Math.abs(ry);
+ double Prx = rx * rx;
+ double Pry = ry * ry;
+ double Px1 = x1 * x1;
+ double Py1 = y1 * y1;
+ // check that radii are large enough
+ double radiiCheck = Px1/Prx + Py1/Pry;
+ if (radiiCheck > 1) {
+ rx = Math.sqrt(radiiCheck) * rx;
+ ry = Math.sqrt(radiiCheck) * ry;
+ Prx = rx * rx;
+ Pry = ry * ry;
+ }
+
+ //
+ // Step 2 : Compute (cx1, cy1)
+ //
+ double sign = (largeArcFlag == sweepFlag) ? -1 : 1;
+ double sq = ((Prx*Pry)-(Prx*Py1)-(Pry*Px1)) / ((Prx*Py1)+(Pry*Px1));
+ sq = (sq < 0) ? 0 : sq;
+ double coef = (sign * Math.sqrt(sq));
+ double cx1 = coef * ((rx * y1) / ry);
+ double cy1 = coef * -((ry * x1) / rx);
+
+ //
+ // Step 3 : Compute (cx, cy) from (cx1, cy1)
+ //
+ double sx2 = (x0 + x) / 2.0;
+ double sy2 = (y0 + y) / 2.0;
+ double cx = sx2 + (cosAngle * cx1 - sinAngle * cy1);
+ double cy = sy2 + (sinAngle * cx1 + cosAngle * cy1);
+
+ //
+ // Step 4 : Compute the angleStart (angle1) and the angleExtent (dangle)
+ //
+ double ux = (x1 - cx1) / rx;
+ double uy = (y1 - cy1) / ry;
+ double vx = (-x1 - cx1) / rx;
+ double vy = (-y1 - cy1) / ry;
+ double p, n;
+ // Compute the angle start
+ n = Math.sqrt((ux * ux) + (uy * uy));
+ p = ux; // (1 * ux) + (0 * uy)
+ sign = (uy < 0) ? -1d : 1d;
+ double angleStart = Math.toDegrees(sign * Math.acos(p / n));
+
+ // Compute the angle extent
+ n = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
+ p = ux * vx + uy * vy;
+ sign = (ux * vy - uy * vx < 0) ? -1d : 1d;
+ double angleExtent = Math.toDegrees(sign * Math.acos(p / n));
+ if(!sweepFlag && angleExtent > 0) {
+ angleExtent -= 360f;
+ } else if (sweepFlag && angleExtent < 0) {
+ angleExtent += 360f;
+ }
+ angleExtent %= 360f;
+ angleStart %= 360f;
+
+ //
+ // We can now build the resulting Arc2D in double precision
+ //
+ Arc2D.Double arc = new Arc2D.Double();
+ arc.x = cx - rx;
+ arc.y = cy - ry;
+ arc.width = rx * 2.0;
+ arc.height = ry * 2.0;
+ arc.start = -angleStart;
+ arc.extent = -angleExtent;
+
+ return arc;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/BuildHistory.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/BuildHistory.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/BuildHistory.java (revision 4256)
@@ -0,0 +1,68 @@
+/*
+ * BuildHistory.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 9:18 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+import java.awt.geom.Point2D;
+
+/**
+ * When building a path from command segments, most need to cache information
+ * (such as the point finished at) for future commands. This structure allows
+ * that
+ *
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class BuildHistory {
+
+// Point2D.Float[] history = new Point2D.Float[2];
+ Point2D.Float[] history = {new Point2D.Float(), new Point2D.Float()};
+ Point2D.Float start = new Point2D.Float();
+ int length = 0;
+
+ /** Creates a new instance of BuildHistory */
+ public BuildHistory() {
+ }
+
+ public void setPoint(float x, float y)
+ {
+ history[0].setLocation(x, y);
+ length = 1;
+ }
+
+ public void setStart(float x, float y)
+ {
+ start.setLocation(x, y);
+ }
+
+ public void setPointAndKnot(float x, float y, float kx, float ky)
+ {
+ history[0].setLocation(x, y);
+ history[1].setLocation(kx, ky);
+ length = 2;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/Cubic.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/Cubic.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/Cubic.java (revision 4256)
@@ -0,0 +1,74 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class Cubic extends PathCommand {
+
+ public float k1x = 0f;
+ public float k1y = 0f;
+ public float k2x = 0f;
+ public float k2y = 0f;
+ public float x = 0f;
+ public float y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public Cubic() {
+ }
+
+ public Cubic(boolean isRelative, float k1x, float k1y, float k2x, float k2y, float x, float y) {
+ super(isRelative);
+ this.k1x = k1x;
+ this.k1y = k1y;
+ this.k2x = k2x;
+ this.k2y = k2y;
+ this.x = x;
+ this.y = y;
+ }
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ path.curveTo(k1x + offx, k1y + offy, k2x + offx, k2y + offy, x + offx, y + offy);
+ hist.setPointAndKnot(x + offx, y + offy, k2x + offx, k2y + offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 6;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/CubicSmooth.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/CubicSmooth.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/CubicSmooth.java (revision 4256)
@@ -0,0 +1,78 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class CubicSmooth extends PathCommand {
+
+ public float x = 0f;
+ public float y = 0f;
+ public float k2x = 0f;
+ public float k2y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public CubicSmooth() {
+ }
+
+ public CubicSmooth(boolean isRelative, float k2x, float k2y, float x, float y) {
+ super(isRelative);
+ this.k2x = k2x;
+ this.k2y = k2y;
+ this.x = x;
+ this.y = y;
+ }
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ float oldKx = hist.history.length >= 2 ? hist.history[1].x : hist.history[0].x;
+ float oldKy = hist.history.length >= 2 ? hist.history[1].y : hist.history[0].y;
+ float oldX = hist.history[0].x;
+ float oldY = hist.history[0].y;
+ //Calc knot as reflection of old knot
+ float k1x = oldX * 2f - oldKx;
+ float k1y = oldY * 2f - oldKy;
+
+ path.curveTo(k1x, k1y, k2x + offx, k2y + offy, x + offx, y + offy);
+ hist.setPointAndKnot(x + offx, y + offy, k2x + offx, k2y + offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 6;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/Horizontal.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/Horizontal.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/Horizontal.java (revision 4256)
@@ -0,0 +1,65 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class Horizontal extends PathCommand {
+
+ public float x = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public Horizontal() {
+ }
+
+ public Horizontal(boolean isRelative, float x) {
+ super(isRelative);
+ this.x = x;
+ }
+
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = hist.history[0].y;
+
+ path.lineTo(x + offx, offy);
+ hist.setPoint(x + offx, offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 2;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/LineTo.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/LineTo.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/LineTo.java (revision 4256)
@@ -0,0 +1,67 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class LineTo extends PathCommand {
+
+ public float x = 0f;
+ public float y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public LineTo() {
+ }
+
+ public LineTo(boolean isRelative, float x, float y) {
+ super(isRelative);
+ this.x = x;
+ this.y = y;
+ }
+
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ path.lineTo(x + offx, y + offy);
+ hist.setPoint(x + offx, y + offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 2;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/MoveTo.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/MoveTo.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/MoveTo.java (revision 4256)
@@ -0,0 +1,67 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class MoveTo extends PathCommand {
+
+ public float x = 0f;
+ public float y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public MoveTo() {
+ }
+
+ public MoveTo(boolean isRelative, float x, float y) {
+ super(isRelative);
+ this.x = x;
+ this.y = y;
+ }
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ path.moveTo(x + offx, y + offy);
+ hist.setPoint(x + offx, y + offy);
+ hist.setStart(x + offx, y + offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 2;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/PathCommand.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/PathCommand.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/PathCommand.java (revision 4256)
@@ -0,0 +1,56 @@
+/*
+ * PathCommand.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:39 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * This is the element of a path and contains instructions for rendering a
+ * portion of the path
+ *
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+abstract public class PathCommand {
+
+ public boolean isRelative = false;
+
+ /** Creates a new instance of PathCommand */
+ public PathCommand() {
+ }
+
+ public PathCommand(boolean isRelative) {
+ this.isRelative = isRelative;
+ }
+
+// abstract public void appendPath(ExtendedGeneralPath path, BuildHistory hist);
+ abstract public void appendPath(GeneralPath path, BuildHistory hist);
+
+ abstract public int getNumKnotsAdded();
+}
Index: trunk/src/com/kitfox/svg/pathcmd/PathUtil.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/PathUtil.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/PathUtil.java (revision 4256)
@@ -0,0 +1,72 @@
+/*
+ * PathUtil.java
+ *
+ * Created on May 10, 2005, 5:56 AM
+ *
+ * To change this template, choose Tools | Options and locate the template under
+ * the Source Creation and Management node. Right-click the template and choose
+ * Open. You can then make changes to the template in the Source Editor.
+ */
+
+package com.kitfox.svg.pathcmd;
+
+import java.awt.geom.*;
+
+/**
+ *
+ * @author kitfox
+ */
+public class PathUtil
+{
+
+ /** Creates a new instance of PathUtil */
+ public PathUtil()
+ {
+ }
+
+ /**
+ * Converts a GeneralPath into an SVG representation
+ */
+ public static String buildPathString(GeneralPath path)
+ {
+ float[] coords = new float[6];
+
+ StringBuffer sb = new StringBuffer();
+
+ for (PathIterator pathIt = path.getPathIterator(new AffineTransform()); !pathIt.isDone(); pathIt.next())
+ {
+ int segId = pathIt.currentSegment(coords);
+
+ switch (segId)
+ {
+ case PathIterator.SEG_CLOSE:
+ {
+ sb.append(" Z");
+ break;
+ }
+ case PathIterator.SEG_CUBICTO:
+ {
+ sb.append(" C " + coords[0] + " " + coords[1] + " " + coords[2] + " " + coords[3] + " " + coords[4] + " " + coords[5]);
+ break;
+ }
+ case PathIterator.SEG_LINETO:
+ {
+ sb.append(" L " + coords[0] + " " + coords[1]);
+ break;
+ }
+ case PathIterator.SEG_MOVETO:
+ {
+ sb.append(" M " + coords[0] + " " + coords[1]);
+ break;
+ }
+ case PathIterator.SEG_QUADTO:
+ {
+ sb.append(" Q " + coords[0] + " " + coords[1] + " " + coords[2] + " " + coords[3]);
+ break;
+ }
+ }
+ }
+
+ return sb.toString();
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/Quadratic.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/Quadratic.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/Quadratic.java (revision 4256)
@@ -0,0 +1,70 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class Quadratic extends PathCommand {
+
+ public float kx = 0f;
+ public float ky = 0f;
+ public float x = 0f;
+ public float y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public Quadratic() {
+ }
+
+ public Quadratic(boolean isRelative, float kx, float ky, float x, float y) {
+ super(isRelative);
+ this.kx = kx;
+ this.ky = ky;
+ this.x = x;
+ this.y = y;
+ }
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ path.quadTo(kx + offx, ky + offy, x + offx, y + offy);
+ hist.setPointAndKnot(x + offx, y + offy, kx + offx, ky + offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 4;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/QuadraticSmooth.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/QuadraticSmooth.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/QuadraticSmooth.java (revision 4256)
@@ -0,0 +1,74 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class QuadraticSmooth extends PathCommand {
+
+ public float x = 0f;
+ public float y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public QuadraticSmooth() {
+ }
+
+ public QuadraticSmooth(boolean isRelative, float x, float y) {
+ super(isRelative);
+ this.x = x;
+ this.y = y;
+ }
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = isRelative ? hist.history[0].x : 0f;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ float oldKx = hist.history.length >= 2 ? hist.history[1].x : hist.history[0].x;
+ float oldKy = hist.history.length >= 2 ? hist.history[1].y : hist.history[0].y;
+ float oldX = hist.history[0].x;
+ float oldY = hist.history[0].y;
+ //Calc knot as reflection of old knot
+ float kx = oldX * 2f - oldKx;
+ float ky = oldY * 2f - oldKy;
+
+ path.quadTo(kx, ky, x + offx, y + offy);
+ hist.setPointAndKnot(x + offx, y + offy, kx, ky);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 4;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/Terminal.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/Terminal.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/Terminal.java (revision 4256)
@@ -0,0 +1,57 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * Finishes a path
+ *
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class Terminal extends PathCommand {
+
+ /** Creates a new instance of MoveTo */
+ public Terminal() {
+ }
+
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ path.closePath();
+ hist.setPoint(hist.start.x, hist.start.y);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 0;
+ }
+}
Index: trunk/src/com/kitfox/svg/pathcmd/Vertical.java
===================================================================
--- trunk/src/com/kitfox/svg/pathcmd/Vertical.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pathcmd/Vertical.java (revision 4256)
@@ -0,0 +1,64 @@
+/*
+ * MoveTo.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 8:40 PM
+ */
+
+package com.kitfox.svg.pathcmd;
+
+//import org.apache.batik.ext.awt.geom.ExtendedGeneralPath;
+import java.awt.geom.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class Vertical extends PathCommand {
+
+ public float y = 0f;
+
+ /** Creates a new instance of MoveTo */
+ public Vertical() {
+ }
+
+ public Vertical(boolean isRelative, float y) {
+ super(isRelative);
+ this.y = y;
+ }
+
+// public void appendPath(ExtendedGeneralPath path, BuildHistory hist)
+ public void appendPath(GeneralPath path, BuildHistory hist)
+ {
+ float offx = hist.history[0].x;
+ float offy = isRelative ? hist.history[0].y : 0f;
+
+ path.lineTo(offx, y + offy);
+ hist.setPoint(offx, y + offy);
+ }
+
+ public int getNumKnotsAdded()
+ {
+ return 2;
+ }
+}
Index: trunk/src/com/kitfox/svg/pattern/PatternPaint.java
===================================================================
--- trunk/src/com/kitfox/svg/pattern/PatternPaint.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pattern/PatternPaint.java (revision 4256)
@@ -0,0 +1,60 @@
+/*
+ * PatternPaint.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on April 1, 2004, 3:37 AM
+ */
+
+package com.kitfox.svg.pattern;
+
+import java.awt.*;
+import java.awt.geom.*;
+import java.awt.image.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class PatternPaint implements Paint
+{
+ BufferedImage source; //Image we're rendering from
+ AffineTransform xform;
+
+ /** Creates a new instance of PatternPaint */
+ public PatternPaint(BufferedImage source, AffineTransform xform)
+ {
+ this.source = source;
+ this.xform = xform;
+ }
+
+ public PaintContext createContext(ColorModel cm, Rectangle deviceBounds, Rectangle2D userBounds, AffineTransform xform, RenderingHints hints)
+ {
+ return new PatternPaintContext(source, deviceBounds, xform, this.xform);
+ }
+
+ public int getTransparency()
+ {
+ return source.getColorModel().getTransparency();
+ }
+
+}
Index: trunk/src/com/kitfox/svg/pattern/PatternPaintContext.java
===================================================================
--- trunk/src/com/kitfox/svg/pattern/PatternPaintContext.java (revision 4256)
+++ trunk/src/com/kitfox/svg/pattern/PatternPaintContext.java (revision 4256)
@@ -0,0 +1,120 @@
+/*
+ * PatternPaintContext.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on April 1, 2004, 3:37 AM
+ */
+
+package com.kitfox.svg.pattern;
+
+import java.awt.*;
+import java.awt.geom.*;
+import java.awt.image.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class PatternPaintContext implements PaintContext
+{
+ BufferedImage source; //Image we're rendering from
+ Rectangle deviceBounds; //int size of rectangle we're rendering to
+// AffineTransform userXform; //xform from user space to device space
+// AffineTransform distortXform; //distortion applied to this pattern
+
+ AffineTransform xform; //distortion applied to this pattern
+
+ int sourceWidth;
+ int sourceHeight;
+
+ //Raster we use to build tile
+ BufferedImage buf;
+
+ /** Creates a new instance of PatternPaintContext */
+ public PatternPaintContext(BufferedImage source, Rectangle deviceBounds, AffineTransform userXform, AffineTransform distortXform)
+ {
+//System.err.println("Bounds " + deviceBounds);
+ this.source = source;
+ this.deviceBounds = deviceBounds;
+ try {
+// this.distortXform = distortXform.createInverse();
+// this.userXform = userXform.createInverse();
+
+// xform = userXform.createInverse();
+// xform.concatenate(distortXform.createInverse());
+ xform = distortXform.createInverse();
+ xform.concatenate(userXform.createInverse());
+ }
+ catch (Exception e) { e.printStackTrace(); }
+
+ sourceWidth = source.getWidth();
+ sourceHeight = source.getHeight();
+ }
+
+ public void dispose() {
+ }
+
+ public ColorModel getColorModel() {
+ return source.getColorModel();
+ }
+
+ public Raster getRaster(int x, int y, int w, int h)
+ {
+//System.err.println("" + x + ", " + y + ", " + w + ", " + h);
+ if (buf == null || buf.getWidth() != w || buf.getHeight() != buf.getHeight())
+ {
+ buf = new BufferedImage(w, h, source.getType());
+ }
+
+// Point2D.Float srcPt = new Point2D.Float(), srcPt2 = new Point2D.Float(), destPt = new Point2D.Float();
+ Point2D.Float srcPt = new Point2D.Float(), destPt = new Point2D.Float();
+ for (int j = 0; j < h; j++)
+ {
+ for (int i = 0; i < w; i++)
+ {
+ destPt.setLocation(i + x, j + y);
+
+ xform.transform(destPt, srcPt);
+
+// userXform.transform(destPt, srcPt2);
+// distortXform.transform(srcPt2, srcPt);
+
+ int ii = ((int)srcPt.x) % sourceWidth;
+ if (ii < 0) ii += sourceWidth;
+ int jj = ((int)srcPt.y) % sourceHeight;
+ if (jj < 0) jj += sourceHeight;
+
+ buf.setRGB(i, j, source.getRGB(ii, jj));
+ }
+ }
+
+ return buf.getData();
+ }
+
+ public static void main(String[] argv)
+ {
+ int i = -4;
+ System.err.println("Hello " + (i % 4));
+ }
+
+}
Index: trunk/src/com/kitfox/svg/xml/Base64InputStream.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/Base64InputStream.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/Base64InputStream.java (revision 4256)
@@ -0,0 +1,82 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.kitfox.svg.xml;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ *
+ * @author kitfox
+ */
+public class Base64InputStream extends FilterInputStream
+{
+ int buf; //Cached bytes to read
+ int bufSize; //Number of bytes waiting to be read from buffer
+ boolean drain = false; //After set, read no more chunks
+
+ public Base64InputStream(InputStream in)
+ {
+ super(in);
+ }
+
+ public int read() throws IOException
+ {
+ if (drain && bufSize == 0)
+ {
+ return -1;
+ }
+
+ if (bufSize == 0)
+ {
+ //Read next chunk into 4 byte buffer
+ int chunk = in.read();
+ if (chunk == -1)
+ {
+ drain = true;
+ return -1;
+ }
+
+ //get remaining 3 bytes
+ for (int i = 0; i < 3; ++i)
+ {
+ int value = in.read();
+ if (value == -1)
+ {
+ throw new IOException("Early termination of base64 stream");
+ }
+ chunk = (chunk << 8) | (value & 0xff);
+ }
+
+ //Check for special termination characters
+ if ((chunk & 0xffff) == (((byte)'=' << 8) | (byte)'='))
+ {
+ bufSize = 1;
+ drain = true;
+ }
+ else if ((chunk & 0xff) == (byte)'=')
+ {
+ bufSize = 2;
+ drain = true;
+ }
+ else
+ {
+ bufSize = 3;
+ }
+
+ //Fill buffer with decoded characters
+ for (int i = 0; i < bufSize + 1; ++i)
+ {
+ buf = (buf << 6) | Base64Util.decodeByte((chunk >> 24) & 0xff);
+ chunk <<= 8;
+ }
+ }
+
+ //Return nth remaing bte & decrement counter
+ return (buf >> (--bufSize * 8)) & 0xff;
+ }
+}
Index: trunk/src/com/kitfox/svg/xml/Base64OutputStream.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/Base64OutputStream.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/Base64OutputStream.java (revision 4256)
@@ -0,0 +1,90 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.kitfox.svg.xml;
+
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ *
+ * @author kitfox
+ */
+public class Base64OutputStream extends FilterOutputStream
+{
+ int buf;
+ int numBytes;
+ int numChunks;
+
+ public Base64OutputStream(OutputStream out)
+ {
+ super(out);
+ }
+
+ public void flush() throws IOException
+ {
+ out.flush();
+ }
+
+ public void close() throws IOException
+ {
+ switch (numBytes)
+ {
+ case 1:
+ buf <<= 4;
+ out.write(getBase64Byte(1));
+ out.write(getBase64Byte(0));
+ out.write('=');
+ out.write('=');
+ break;
+ case 2:
+ buf <<= 2;
+ out.write(getBase64Byte(2));
+ out.write(getBase64Byte(1));
+ out.write(getBase64Byte(0));
+ out.write('=');
+ break;
+ case 3:
+ out.write(getBase64Byte(3));
+ out.write(getBase64Byte(2));
+ out.write(getBase64Byte(1));
+ out.write(getBase64Byte(0));
+ break;
+ default:
+ assert false;
+ }
+
+ out.close();
+ }
+
+ public void write(int b) throws IOException
+ {
+ buf = (buf << 8) | (0xff & b);
+ numBytes++;
+
+ if (numBytes == 3)
+ {
+ out.write(getBase64Byte(3));
+ out.write(getBase64Byte(2));
+ out.write(getBase64Byte(1));
+ out.write(getBase64Byte(0));
+
+ numBytes = 0;
+ numChunks++;
+ if (numChunks == 16)
+ {
+// out.write('\r');
+// out.write('\n');
+ numChunks = 0;
+ }
+ }
+ }
+
+ public byte getBase64Byte(int index)
+ {
+ return Base64Util.encodeByte((buf >> (index * 6)) & 0x3f);
+ }
+}
Index: trunk/src/com/kitfox/svg/xml/Base64Util.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/Base64Util.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/Base64Util.java (revision 4256)
@@ -0,0 +1,32 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.kitfox.svg.xml;
+
+/**
+ *
+ * @author kitfox
+ */
+public class Base64Util
+{
+ static final byte[] valueToBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".getBytes();
+ static final byte[] base64ToValue = new byte[128];
+ static {
+ for (int i = 0; i < valueToBase64.length; ++i)
+ {
+ base64ToValue[valueToBase64[i]] = (byte)i;
+ }
+ }
+
+ static public byte encodeByte(int value)
+ {
+ return valueToBase64[value];
+ }
+
+ static public byte decodeByte(int base64Char)
+ {
+ return base64ToValue[base64Char];
+ }
+}
Index: trunk/src/com/kitfox/svg/xml/ColorTable.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/ColorTable.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/ColorTable.java (revision 4256)
@@ -0,0 +1,283 @@
+/*
+ * ColorTable.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 26, 2004, 4:34 AM
+ */
+
+package com.kitfox.svg.xml;
+
+import java.awt.*;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class ColorTable
+{
+
+ static final Map colorTable;
+ static {
+ HashMap table = new HashMap();
+
+ //We really should be interpreting the currentColor keyword as
+ // a reference to the referring node's color, but this quick hack
+ // will stop the program from crashing.
+ table.put("currentcolor", new Color(0x0));
+
+ table.put("aliceblue", new Color(0xf0f8ff));
+ table.put("antiquewhite", new Color(0xfaebd7));
+ table.put("aqua", new Color(0x00ffff));
+ table.put("aquamarine", new Color(0x7fffd4));
+ table.put("azure", new Color(0xf0ffff));
+ table.put("beige", new Color(0xf5f5dc));
+ table.put("bisque", new Color(0xffe4c4));
+ table.put("black", new Color(0x000000));
+ table.put("blanchedalmond", new Color(0xffebcd));
+ table.put("blue", new Color(0x0000ff));
+ table.put("blueviolet", new Color(0x8a2be2));
+ table.put("brown", new Color(0xa52a2a));
+ table.put("burlywood", new Color(0xdeb887));
+ table.put("cadetblue", new Color(0x5f9ea0));
+ table.put("chartreuse", new Color(0x7fff00));
+ table.put("chocolate", new Color(0xd2691e));
+ table.put("coral", new Color(0xff7f50));
+ table.put("cornflowerblue", new Color(0x6495ed));
+ table.put("cornsilk", new Color(0xfff8dc));
+ table.put("crimson", new Color(0xdc143c));
+ table.put("cyan", new Color(0x00ffff));
+ table.put("darkblue", new Color(0x00008b));
+ table.put("darkcyan", new Color(0x008b8b));
+ table.put("darkgoldenrod", new Color(0xb8860b));
+ table.put("darkgray", new Color(0xa9a9a9));
+ table.put("darkgreen", new Color(0x006400));
+ table.put("darkkhaki", new Color(0xbdb76b));
+ table.put("darkmagenta", new Color(0x8b008b));
+ table.put("darkolivegreen", new Color(0x556b2f));
+ table.put("darkorange", new Color(0xff8c00));
+ table.put("darkorchid", new Color(0x9932cc));
+ table.put("darkred", new Color(0x8b0000));
+ table.put("darksalmon", new Color(0xe9967a));
+ table.put("darkseagreen", new Color(0x8fbc8f));
+ table.put("darkslateblue", new Color(0x483d8b));
+ table.put("darkslategray", new Color(0x2f4f4f));
+ table.put("darkturquoise", new Color(0x00ced1));
+ table.put("darkviolet", new Color(0x9400d3));
+ table.put("deeppink", new Color(0xff1493));
+ table.put("deepskyblue", new Color(0x00bfff));
+ table.put("dimgray", new Color(0x696969));
+ table.put("dodgerblue", new Color(0x1e90ff));
+ table.put("feldspar", new Color(0xd19275));
+ table.put("firebrick", new Color(0xb22222));
+ table.put("floralwhite", new Color(0xfffaf0));
+ table.put("forestgreen", new Color(0x228b22));
+ table.put("fuchsia", new Color(0xff00ff));
+ table.put("gainsboro", new Color(0xdcdcdc));
+ table.put("ghostwhite", new Color(0xf8f8ff));
+ table.put("gold", new Color(0xffd700));
+ table.put("goldenrod", new Color(0xdaa520));
+ table.put("gray", new Color(0x808080));
+ table.put("green", new Color(0x008000));
+ table.put("greenyellow", new Color(0xadff2f));
+ table.put("honeydew", new Color(0xf0fff0));
+ table.put("hotpink", new Color(0xff69b4));
+ table.put("indianred", new Color(0xcd5c5c));
+ table.put("indigo", new Color(0x4b0082));
+ table.put("ivory", new Color(0xfffff0));
+ table.put("khaki", new Color(0xf0e68c));
+ table.put("lavender", new Color(0xe6e6fa));
+ table.put("lavenderblush", new Color(0xfff0f5));
+ table.put("lawngreen", new Color(0x7cfc00));
+ table.put("lemonchiffon", new Color(0xfffacd));
+ table.put("lightblue", new Color(0xadd8e6));
+ table.put("lightcoral", new Color(0xf08080));
+ table.put("lightcyan", new Color(0xe0ffff));
+ table.put("lightgoldenrodyellow", new Color(0xfafad2));
+ table.put("lightgrey", new Color(0xd3d3d3));
+ table.put("lightgreen", new Color(0x90ee90));
+ table.put("lightpink", new Color(0xffb6c1));
+ table.put("lightsalmon", new Color(0xffa07a));
+ table.put("lightseagreen", new Color(0x20b2aa));
+ table.put("lightskyblue", new Color(0x87cefa));
+ table.put("lightslateblue", new Color(0x8470ff));
+ table.put("lightslategray", new Color(0x778899));
+ table.put("lightsteelblue", new Color(0xb0c4de));
+ table.put("lightyellow", new Color(0xffffe0));
+ table.put("lime", new Color(0x00ff00));
+ table.put("limegreen", new Color(0x32cd32));
+ table.put("linen", new Color(0xfaf0e6));
+ table.put("magenta", new Color(0xff00ff));
+ table.put("maroon", new Color(0x800000));
+ table.put("mediumaquamarine", new Color(0x66cdaa));
+ table.put("mediumblue", new Color(0x0000cd));
+ table.put("mediumorchid", new Color(0xba55d3));
+ table.put("mediumpurple", new Color(0x9370d8));
+ table.put("mediumseagreen", new Color(0x3cb371));
+ table.put("mediumslateblue", new Color(0x7b68ee));
+ table.put("mediumspringgreen", new Color(0x00fa9a));
+ table.put("mediumturquoise", new Color(0x48d1cc));
+ table.put("mediumvioletred", new Color(0xc71585));
+ table.put("midnightblue", new Color(0x191970));
+ table.put("mintcream", new Color(0xf5fffa));
+ table.put("mistyrose", new Color(0xffe4e1));
+ table.put("moccasin", new Color(0xffe4b5));
+ table.put("navajowhite", new Color(0xffdead));
+ table.put("navy", new Color(0x000080));
+ table.put("oldlace", new Color(0xfdf5e6));
+ table.put("olive", new Color(0x808000));
+ table.put("olivedrab", new Color(0x6b8e23));
+ table.put("orange", new Color(0xffa500));
+ table.put("orangered", new Color(0xff4500));
+ table.put("orchid", new Color(0xda70d6));
+ table.put("palegoldenrod", new Color(0xeee8aa));
+ table.put("palegreen", new Color(0x98fb98));
+ table.put("paleturquoise", new Color(0xafeeee));
+ table.put("palevioletred", new Color(0xd87093));
+ table.put("papayawhip", new Color(0xffefd5));
+ table.put("peachpuff", new Color(0xffdab9));
+ table.put("peru", new Color(0xcd853f));
+ table.put("pink", new Color(0xffc0cb));
+ table.put("plum", new Color(0xdda0dd));
+ table.put("powderblue", new Color(0xb0e0e6));
+ table.put("purple", new Color(0x800080));
+ table.put("red", new Color(0xff0000));
+ table.put("rosybrown", new Color(0xbc8f8f));
+ table.put("royalblue", new Color(0x4169e1));
+ table.put("saddlebrown", new Color(0x8b4513));
+ table.put("salmon", new Color(0xfa8072));
+ table.put("sandybrown", new Color(0xf4a460));
+ table.put("seagreen", new Color(0x2e8b57));
+ table.put("seashell", new Color(0xfff5ee));
+ table.put("sienna", new Color(0xa0522d));
+ table.put("silver", new Color(0xc0c0c0));
+ table.put("skyblue", new Color(0x87ceeb));
+ table.put("slateblue", new Color(0x6a5acd));
+ table.put("slategray", new Color(0x708090));
+ table.put("snow", new Color(0xfffafa));
+ table.put("springgreen", new Color(0x00ff7f));
+ table.put("steelblue", new Color(0x4682b4));
+ table.put("tan", new Color(0xd2b48c));
+ table.put("teal", new Color(0x008080));
+ table.put("thistle", new Color(0xd8bfd8));
+ table.put("tomato", new Color(0xff6347));
+ table.put("turquoise", new Color(0x40e0d0));
+ table.put("violet", new Color(0xee82ee));
+ table.put("violetred", new Color(0xd02090));
+ table.put("wheat", new Color(0xf5deb3));
+ table.put("white", new Color(0xffffff));
+ table.put("whitesmoke", new Color(0xf5f5f5));
+ table.put("yellow", new Color(0xffff00));
+ table.put("yellowgreen", new Color(0x9acd32));
+
+ colorTable = Collections.unmodifiableMap(table);
+ }
+
+ static ColorTable singleton = new ColorTable();
+
+ /** Creates a new instance of ColorTable */
+ protected ColorTable() {
+// buildColorList();
+ }
+
+ static public ColorTable instance() { return singleton; }
+
+ public Color lookupColor(String name) {
+ Object obj = colorTable.get(name.toLowerCase());
+ if (obj == null) return null;
+
+ return (Color)obj;
+ }
+
+ public static Color parseColor(String val)
+ {
+ Color retVal = null;
+
+ if (val.charAt(0) == '#')
+ {
+ String hexStrn = val.substring(1);
+
+ if (hexStrn.length() == 3)
+ {
+ hexStrn = "" + hexStrn.charAt(0) + hexStrn.charAt(0) + hexStrn.charAt(1) + hexStrn.charAt(1) + hexStrn.charAt(2) + hexStrn.charAt(2);
+ }
+ int hexVal = parseHex(hexStrn);
+
+ retVal = new Color(hexVal);
+ }
+ else
+ {
+ final String number = "\\s*(((\\d+)(\\.\\d*)?)|(\\.\\d+))(%)?\\s*";
+ final Matcher rgbMatch = Pattern.compile("rgb\\(" + number + "," + number + "," + number + "\\)", Pattern.CASE_INSENSITIVE).matcher("");
+
+ rgbMatch.reset(val);
+ if (rgbMatch.matches())
+ {
+ float rr = Float.parseFloat(rgbMatch.group(1));
+ float gg = Float.parseFloat(rgbMatch.group(7));
+ float bb = Float.parseFloat(rgbMatch.group(13));
+ rr /= "%".equals(rgbMatch.group(6)) ? 100 : 255;
+ gg /= "%".equals(rgbMatch.group(12)) ? 100 : 255;
+ bb /= "%".equals(rgbMatch.group(18)) ? 100 : 255;
+ retVal = new Color(rr, gg, bb);
+ }
+ else
+ {
+ Color lookupCol = ColorTable.instance().lookupColor(val);
+ if (lookupCol != null) retVal = lookupCol;
+ }
+ }
+
+ return retVal;
+ }
+
+ public static int parseHex(String val)
+ {
+ int retVal = 0;
+
+ for (int i = 0; i < val.length(); i++)
+ {
+ retVal <<= 4;
+
+ char ch = val.charAt(i);
+ if (ch >= '0' && ch <= '9')
+ {
+ retVal |= ch - '0';
+ }
+ else if (ch >= 'a' && ch <= 'z')
+ {
+ retVal |= ch - 'a' + 10;
+ }
+ else if (ch >= 'A' && ch <= 'Z')
+ {
+ retVal |= ch - 'A' + 10;
+ }
+ else throw new RuntimeException();
+ }
+
+ return retVal;
+ }
+
+}
Index: trunk/src/com/kitfox/svg/xml/NumberWithUnits.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/NumberWithUnits.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/NumberWithUnits.java (revision 4256)
@@ -0,0 +1,148 @@
+/*
+ * NumberWithUnits.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on February 18, 2004, 2:43 PM
+ */
+
+package com.kitfox.svg.xml;
+
+import java.io.Serializable;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class NumberWithUnits implements Serializable
+{
+ public static final long serialVersionUID = 0;
+
+ public static final int UT_UNITLESS = 0;
+ public static final int UT_PX = 1; //Pixels
+ public static final int UT_CM = 2; //Centimeters
+ public static final int UT_MM = 3; //Millimeters
+ public static final int UT_IN = 4; //Inches
+ public static final int UT_EM = 5; //Default font height
+ public static final int UT_EX = 6; //Height of character 'x' in default font
+ public static final int UT_PT = 7; //Points - 1/72 of an inch
+ public static final int UT_PC = 8; //Picas - 1/6 of an inch
+ public static final int UT_PERCENT = 9; //Percent - relative width
+
+ float value = 0f;
+ int unitType = UT_UNITLESS;
+
+ /** Creates a new instance of NumberWithUnits */
+ public NumberWithUnits()
+ {
+ }
+
+ public NumberWithUnits(String value)
+ {
+ set(value);
+ }
+
+ public NumberWithUnits(float value, int unitType)
+ {
+ this.value = value;
+ this.unitType = unitType;
+ }
+
+ public float getValue() { return value; }
+ public int getUnits() { return unitType; }
+
+ public void set(String value)
+ {
+ this.value = XMLParseUtil.findFloat(value);
+ unitType = UT_UNITLESS;
+
+ if (value.indexOf("px") != -1) { unitType = UT_PX; return; }
+ if (value.indexOf("cm") != -1) { unitType = UT_CM; return; }
+ if (value.indexOf("mm") != -1) { unitType = UT_MM; return; }
+ if (value.indexOf("in") != -1) { unitType = UT_IN; return; }
+ if (value.indexOf("em") != -1) { unitType = UT_EM; return; }
+ if (value.indexOf("ex") != -1) { unitType = UT_EX; return; }
+ if (value.indexOf("pt") != -1) { unitType = UT_PT; return; }
+ if (value.indexOf("pc") != -1) { unitType = UT_PC; return; }
+ if (value.indexOf("%") != -1) { unitType = UT_PERCENT; return; }
+ }
+
+ public static String unitsAsString(int unitIdx)
+ {
+ switch (unitIdx)
+ {
+ default:
+ return "";
+ case UT_PX:
+ return "px";
+ case UT_CM:
+ return "cm";
+ case UT_MM:
+ return "mm";
+ case UT_IN:
+ return "in";
+ case UT_EM:
+ return "em";
+ case UT_EX:
+ return "ex";
+ case UT_PT:
+ return "pt";
+ case UT_PC:
+ return "pc";
+ case UT_PERCENT:
+ return "%";
+ }
+ }
+
+ public String toString()
+ {
+ return "" + value + unitsAsString(unitType);
+ }
+
+ public boolean equals(Object obj)
+ {
+ if (obj == null) {
+ return false;
+ }
+ if (getClass() != obj.getClass()) {
+ return false;
+ }
+ final NumberWithUnits other = (NumberWithUnits) obj;
+ if (Float.floatToIntBits(this.value) != Float.floatToIntBits(other.value)) {
+ return false;
+ }
+ if (this.unitType != other.unitType) {
+ return false;
+ }
+ return true;
+ }
+
+ public int hashCode()
+ {
+ int hash = 5;
+ hash = 37 * hash + Float.floatToIntBits(this.value);
+ hash = 37 * hash + this.unitType;
+ return hash;
+ }
+
+
+}
Index: trunk/src/com/kitfox/svg/xml/ReadableXMLElement.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/ReadableXMLElement.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/ReadableXMLElement.java (revision 4256)
@@ -0,0 +1,48 @@
+/*
+ * LoadableObject.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on September 1, 2003, 1:46 AM
+ */
+
+package com.kitfox.svg.xml;
+
+import org.w3c.dom.*;
+import java.net.*;
+import java.util.*;
+import java.lang.reflect.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public interface ReadableXMLElement {
+
+ /**
+ * Initializes this element from the passed DOM tree.
+ * @param root - DOM tree to build from
+ * @param docRoot - URL of the document this DOM tree was created from
+ */
+ public void read(Element root, URL docRoot);
+
+}
Index: trunk/src/com/kitfox/svg/xml/StyleAttribute.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/StyleAttribute.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/StyleAttribute.java (revision 4256)
@@ -0,0 +1,290 @@
+/*
+ * StyleAttribute.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on January 27, 2004, 2:53 PM
+ */
+
+package com.kitfox.svg.xml;
+
+import java.awt.*;
+import java.net.*;
+import java.io.*;
+import java.util.regex.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class StyleAttribute implements Serializable
+{
+ public static final long serialVersionUID = 0;
+
+ static final Matcher matchUrl = Pattern.compile("\\s*url\\((.*)\\)\\s*").matcher("");
+ static final Matcher matchFpNumUnits = Pattern.compile("\\s*([-+]?((\\d*\\.\\d+)|(\\d+))([-+]?[eE]\\d+)?)\\s*(px|cm|mm|in|pc|pt|em|ex)\\s*").matcher("");
+
+ String name;
+ String stringValue;
+
+ boolean colorCompatable = false;
+ boolean urlCompatable = false;
+
+ /** Creates a new instance of StyleAttribute */
+ public StyleAttribute()
+ {
+ this(null, null);
+ }
+
+ public StyleAttribute(String name)
+ {
+ this.name = name;
+ stringValue = null;
+ }
+
+ public StyleAttribute(String name, String stringValue)
+ {
+ this.name = name;
+ this.stringValue = stringValue;
+ }
+
+ public String getName() { return name; }
+ public StyleAttribute setName(String name) { this.name = name; return this; }
+
+ public String getStringValue() { return stringValue; }
+
+ public String[] getStringList()
+ {
+ return XMLParseUtil.parseStringList(stringValue);
+ }
+
+ public void setStringValue(String value)
+ {
+ stringValue = value;
+ }
+
+ public boolean getBooleanValue() {
+ return stringValue.toLowerCase().equals("true");
+ }
+
+ public int getIntValue() {
+ return XMLParseUtil.findInt(stringValue);
+ }
+
+ public int[] getIntList() {
+ return XMLParseUtil.parseIntList(stringValue);
+ }
+
+ public double getDoubleValue() {
+ return XMLParseUtil.findDouble(stringValue);
+ }
+
+ public double[] getDoubleList() {
+ return XMLParseUtil.parseDoubleList(stringValue);
+ }
+
+ public float getFloatValue() {
+ return XMLParseUtil.findFloat(stringValue);
+ }
+
+ public float[] getFloatList() {
+ return XMLParseUtil.parseFloatList(stringValue);
+ }
+
+ public float getRatioValue() {
+ return (float)XMLParseUtil.parseRatio(stringValue);
+// try { return Float.parseFloat(stringValue); }
+// catch (Exception e) {}
+// return 0f;
+ }
+
+ public String getUnits() {
+ matchFpNumUnits.reset(stringValue);
+ if (!matchFpNumUnits.matches()) return null;
+ return matchFpNumUnits.group(6);
+ }
+
+ public NumberWithUnits getNumberWithUnits() {
+ return XMLParseUtil.parseNumberWithUnits(stringValue);
+ }
+
+ public float getFloatValueWithUnits()
+ {
+ NumberWithUnits number = getNumberWithUnits();
+ return convertUnitsToPixels(number.getUnits(), number.getValue());
+ }
+
+ static public float convertUnitsToPixels(int unitType, float value)
+ {
+ if (unitType == NumberWithUnits.UT_UNITLESS || unitType == NumberWithUnits.UT_PERCENT)
+ {
+ return value;
+ }
+
+ float pixPerInch;
+ try
+ {
+ pixPerInch = (float)Toolkit.getDefaultToolkit().getScreenResolution();
+ }
+ catch (HeadlessException ex)
+ {
+ //default to 72 dpi
+ pixPerInch = 72;
+ }
+ final float inchesPerCm = .3936f;
+
+ switch (unitType)
+ {
+ case NumberWithUnits.UT_IN:
+ return value * pixPerInch;
+ case NumberWithUnits.UT_CM:
+ return value * inchesPerCm * pixPerInch;
+ case NumberWithUnits.UT_MM:
+ return value * .1f * inchesPerCm * pixPerInch;
+ case NumberWithUnits.UT_PT:
+ return value * (1f / 72f) * pixPerInch;
+ case NumberWithUnits.UT_PC:
+ return value * (1f / 6f) * pixPerInch;
+ }
+
+ return value;
+ }
+
+ public Color getColorValue()
+ {
+ return ColorTable.parseColor(stringValue);
+ }
+
+ public String parseURLFn()
+ {
+ matchUrl.reset(stringValue);
+ if (!matchUrl.matches()) return null;
+ return matchUrl.group(1);
+ }
+
+ public URL getURLValue(URL docRoot)
+ {
+ String fragment = parseURLFn();
+ if (fragment == null) return null;
+ try {
+ return new URL(docRoot, fragment);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ public URL getURLValue(URI docRoot)
+ {
+ String fragment = parseURLFn();
+ if (fragment == null) return null;
+ try {
+ URI ref = docRoot.resolve(fragment);
+ return ref.toURL();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ public URI getURIValue()
+ {
+ return getURIValue(null);
+ }
+
+ /**
+ * Parse this sytle attribute as a URL and return it in URI form resolved
+ * against the passed base.
+ *
+ * @param base - URI to resolve against. If null, will return value without
+ * attempting to resolve it.
+ */
+ public URI getURIValue(URI base)
+ {
+ try {
+ String fragment = parseURLFn();
+ if (fragment == null) fragment = stringValue.replaceAll("\\s+", "");
+ if (fragment == null) return null;
+
+ //======================
+ //This gets around a bug in the 1.5.0 JDK
+ if (Pattern.matches("[a-zA-Z]:!\\\\.*", fragment))
+ {
+ File file = new File(fragment);
+ return file.toURI();
+ }
+ //======================
+
+ //[scheme:]scheme-specific-part[#fragment]
+
+ URI uriFrag = new URI(fragment);
+ if (uriFrag.isAbsolute())
+ {
+ //Has scheme
+ return uriFrag;
+ }
+
+ if (base == null) return uriFrag;
+
+ URI relBase = new URI(null, base.getSchemeSpecificPart(), null);
+ URI relUri;
+ if (relBase.isOpaque())
+ {
+ relUri = new URI(null, base.getSchemeSpecificPart(), uriFrag.getFragment());
+ }
+ else
+ {
+ relUri = relBase.resolve(uriFrag);
+ }
+ return new URI(base.getScheme() + ":" + relUri);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ public static void main(String[] args)
+ {
+ try
+ {
+ URI uri = new URI("jar:http://www.kitfox.com/jackal/jackal.jar!/res/doc/about.svg");
+ uri = uri.resolve("#myFragment");
+
+ System.err.println(uri.toString());
+
+ uri = new URI("http://www.kitfox.com/jackal/jackal.html");
+ uri = uri.resolve("#myFragment");
+
+ System.err.println(uri.toString());
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+}
Index: trunk/src/com/kitfox/svg/xml/WritableXMLElement.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/WritableXMLElement.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/WritableXMLElement.java (revision 4256)
@@ -0,0 +1,48 @@
+/*
+ * LoadableObject.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on September 1, 2003, 1:46 AM
+ */
+
+package com.kitfox.svg.xml;
+
+import org.w3c.dom.*;
+import java.net.*;
+import java.util.*;
+import java.lang.reflect.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public interface WritableXMLElement {
+
+ /**
+ * Initializes this element from the passed DOM tree.
+ * @param root - DOM tree to build from
+ * @param docRoot - URL of the document this DOM tree was created from
+ */
+// public void write(Element root, URL docRoot);
+
+}
Index: trunk/src/com/kitfox/svg/xml/XMLParseUtil.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/XMLParseUtil.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/XMLParseUtil.java (revision 4256)
@@ -0,0 +1,821 @@
+/*
+ * XMLParseUtil.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on February 18, 2004, 1:49 PM
+ */
+
+package com.kitfox.svg.xml;
+
+import org.w3c.dom.*;
+import java.awt.*;
+import java.net.*;
+import java.util.*;
+import java.util.regex.*;
+import java.lang.reflect.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class XMLParseUtil
+{
+ static final Matcher fpMatch = Pattern.compile("([-+]?((\\d*\\.\\d+)|(\\d+))([eE][+-]?\\d+)?)(\\%|in|cm|mm|pt|pc|px|em|ex)?").matcher("");
+ static final Matcher intMatch = Pattern.compile("[-+]?\\d+").matcher("");
+
+ /** Creates a new instance of XMLParseUtil */
+ private XMLParseUtil()
+ {
+ }
+
+ /**
+ * Scans the tag's children and returns the first text element found
+ */
+ public static String getTagText(Element ele)
+ {
+ NodeList nl = ele.getChildNodes();
+ int size = nl.getLength();
+
+ Node node = null;
+ int i = 0;
+ for (; i < size; i++)
+ {
+ node = nl.item(i);
+ if (node instanceof Text) break;
+ }
+ if (i == size || node == null) return null;
+
+ return ((Text)node).getData();
+ }
+
+ /**
+ * Returns the first node that is a direct child of root with the coresponding
+ * name. Does not search children of children.
+ */
+ public static Element getFirstChild(Element root, String name)
+ {
+ NodeList nl = root.getChildNodes();
+ int size = nl.getLength();
+ for (int i = 0; i < size; i++)
+ {
+ Node node = nl.item(i);
+ if (!(node instanceof Element)) continue;
+ Element ele = (Element)node;
+ if (ele.getTagName().equals(name)) return ele;
+ }
+
+ return null;
+ }
+
+ public static String[] parseStringList(String list)
+ {
+// final Pattern patWs = Pattern.compile("\\s+");
+ final Matcher matchWs = Pattern.compile("[^\\s]+").matcher("");
+ matchWs.reset(list);
+
+ LinkedList matchList = new LinkedList();
+ while (matchWs.find())
+ {
+ matchList.add(matchWs.group());
+ }
+
+ String[] retArr = new String[matchList.size()];
+ return (String[])matchList.toArray(retArr);
+ }
+
+ public static boolean isDouble(String val)
+ {
+ fpMatch.reset(val);
+ return fpMatch.matches();
+ }
+
+ public static double parseDouble(String val)
+ {
+ /*
+ if (val == null) return 0.0;
+
+ double retVal = 0.0;
+ try
+ { retVal = Double.parseDouble(val); }
+ catch (Exception e)
+ {}
+ return retVal;
+ */
+ return findDouble(val);
+ }
+
+ /**
+ * Searches the given string for the first floating point number it contains,
+ * parses and returns it.
+ */
+ public synchronized static double findDouble(String val)
+ {
+ if (val == null) return 0;
+
+ fpMatch.reset(val);
+ try
+ {
+ if (!fpMatch.find()) return 0;
+ }
+ catch (StringIndexOutOfBoundsException e)
+ {
+ System.err.println("XMLParseUtil: regex parse problem: '" + val + "'");
+ e.printStackTrace();
+ }
+
+ val = fpMatch.group(1);
+ //System.err.println("Parsing " + val);
+
+ double retVal = 0;
+ try
+ {
+ retVal = Double.parseDouble(val);
+
+ float pixPerInch;
+ try {
+ pixPerInch = (float)Toolkit.getDefaultToolkit().getScreenResolution();
+ }
+ catch (NoClassDefFoundError err)
+ {
+ //Default value for headless X servers
+ pixPerInch = 72;
+ }
+ final float inchesPerCm = .3936f;
+ final String units = fpMatch.group(6);
+
+ if ("%".equals(units)) retVal /= 100;
+ else if ("in".equals(units))
+ {
+ retVal *= pixPerInch;
+ }
+ else if ("cm".equals(units))
+ {
+ retVal *= inchesPerCm * pixPerInch;
+ }
+ else if ("mm".equals(units))
+ {
+ retVal *= inchesPerCm * pixPerInch * .1f;
+ }
+ else if ("pt".equals(units))
+ {
+ retVal *= (1f / 72f) * pixPerInch;
+ }
+ else if ("pc".equals(units))
+ {
+ retVal *= (1f / 6f) * pixPerInch;
+ }
+ }
+ catch (Exception e)
+ {}
+ return retVal;
+ }
+
+ /**
+ * Scans an input string for double values. For each value found, places
+ * in a list. This method regards any characters not part of a floating
+ * point value to be seperators. Thus this will parse whitespace seperated,
+ * comma seperated, and many other separation schemes correctly.
+ */
+ public synchronized static double[] parseDoubleList(String list)
+ {
+ if (list == null) return null;
+
+ fpMatch.reset(list);
+
+ LinkedList doubList = new LinkedList();
+ while (fpMatch.find())
+ {
+ String val = fpMatch.group(1);
+ doubList.add(Double.valueOf(val));
+ }
+
+ double[] retArr = new double[doubList.size()];
+ Iterator it = doubList.iterator();
+ int idx = 0;
+ while (it.hasNext())
+ {
+ retArr[idx++] = ((Double)it.next()).doubleValue();
+ }
+
+ return retArr;
+ }
+
+ public static float parseFloat(String val)
+ {
+ /*
+ if (val == null) return 0f;
+
+ float retVal = 0f;
+ try
+ { retVal = Float.parseFloat(val); }
+ catch (Exception e)
+ {}
+ return retVal;
+ */
+ return findFloat(val);
+ }
+
+ /**
+ * Searches the given string for the first floating point number it contains,
+ * parses and returns it.
+ */
+ public synchronized static float findFloat(String val)
+ {
+ if (val == null) return 0f;
+
+ fpMatch.reset(val);
+ if (!fpMatch.find()) return 0f;
+
+ val = fpMatch.group(1);
+ //System.err.println("Parsing " + val);
+
+ float retVal = 0f;
+ try
+ {
+ retVal = Float.parseFloat(val);
+ String units = fpMatch.group(6);
+ if ("%".equals(units)) retVal /= 100;
+ }
+ catch (Exception e)
+ {}
+ return retVal;
+ }
+
+ public synchronized static float[] parseFloatList(String list)
+ {
+ if (list == null) return null;
+
+ fpMatch.reset(list);
+
+ LinkedList floatList = new LinkedList();
+ while (fpMatch.find())
+ {
+ String val = fpMatch.group(1);
+ floatList.add(Float.valueOf(val));
+ }
+
+ float[] retArr = new float[floatList.size()];
+ Iterator it = floatList.iterator();
+ int idx = 0;
+ while (it.hasNext())
+ {
+ retArr[idx++] = ((Float)it.next()).floatValue();
+ }
+
+ return retArr;
+ }
+
+ public static int parseInt(String val)
+ {
+ if (val == null) return 0;
+
+ int retVal = 0;
+ try
+ { retVal = Integer.parseInt(val); }
+ catch (Exception e)
+ {}
+ return retVal;
+ }
+
+ /**
+ * Searches the given string for the first integer point number it contains,
+ * parses and returns it.
+ */
+ public static int findInt(String val)
+ {
+ if (val == null) return 0;
+
+ intMatch.reset(val);
+ if (!intMatch.find()) return 0;
+
+ val = intMatch.group();
+ //System.err.println("Parsing " + val);
+
+ int retVal = 0;
+ try
+ { retVal = Integer.parseInt(val); }
+ catch (Exception e)
+ {}
+ return retVal;
+ }
+
+ public static int[] parseIntList(String list)
+ {
+ if (list == null) return null;
+
+ intMatch.reset(list);
+
+ LinkedList intList = new LinkedList();
+ while (intMatch.find())
+ {
+ String val = intMatch.group();
+ intList.add(Integer.valueOf(val));
+ }
+
+ int[] retArr = new int[intList.size()];
+ Iterator it = intList.iterator();
+ int idx = 0;
+ while (it.hasNext())
+ {
+ retArr[idx++] = ((Integer)it.next()).intValue();
+ }
+
+ return retArr;
+ }
+/*
+ public static int parseHex(String val)
+ {
+ int retVal = 0;
+
+ for (int i = 0; i < val.length(); i++)
+ {
+ retVal <<= 4;
+
+ char ch = val.charAt(i);
+ if (ch >= '0' && ch <= '9')
+ {
+ retVal |= ch - '0';
+ }
+ else if (ch >= 'a' && ch <= 'z')
+ {
+ retVal |= ch - 'a' + 10;
+ }
+ else if (ch >= 'A' && ch <= 'Z')
+ {
+ retVal |= ch - 'A' + 10;
+ }
+ else throw new RuntimeException();
+ }
+
+ return retVal;
+ }
+*/
+ /**
+ * The input string represents a ratio. Can either be specified as a
+ * double number on the range of [0.0 1.0] or as a percentage [0% 100%]
+ */
+ public static double parseRatio(String val)
+ {
+ if (val == null || val.equals("")) return 0.0;
+
+ if (val.charAt(val.length() - 1) == '%')
+ {
+ parseDouble(val.substring(0, val.length() - 1));
+ }
+ return parseDouble(val);
+ }
+
+ public static NumberWithUnits parseNumberWithUnits(String val)
+ {
+ if (val == null) return null;
+
+ return new NumberWithUnits(val);
+ }
+/*
+ public static Color parseColor(String val)
+ {
+ Color retVal = null;
+
+ if (val.charAt(0) == '#')
+ {
+ String hexStrn = val.substring(1);
+
+ if (hexStrn.length() == 3)
+ {
+ hexStrn = "" + hexStrn.charAt(0) + hexStrn.charAt(0) + hexStrn.charAt(1) + hexStrn.charAt(1) + hexStrn.charAt(2) + hexStrn.charAt(2);
+ }
+ int hexVal = parseHex(hexStrn);
+
+ retVal = new Color(hexVal);
+ }
+ else
+ {
+ final Matcher rgbMatch = Pattern.compile("rgb\\((\\d+),(\\d+),(\\d+)\\)", Pattern.CASE_INSENSITIVE).matcher("");
+
+ rgbMatch.reset(val);
+ if (rgbMatch.matches())
+ {
+ int r = Integer.parseInt(rgbMatch.group(1));
+ int g = Integer.parseInt(rgbMatch.group(2));
+ int b = Integer.parseInt(rgbMatch.group(3));
+ retVal = new Color(r, g, b);
+ }
+ else
+ {
+ Color lookupCol = ColorTable.instance().lookupColor(val);
+ if (lookupCol != null) retVal = lookupCol;
+ }
+ }
+
+ return retVal;
+ }
+*/
+ /**
+ * Parses the given attribute of this tag and returns it as a String.
+ */
+ public static String getAttribString(Element ele, String name)
+ {
+ return ele.getAttribute(name);
+ }
+
+ /**
+ * Parses the given attribute of this tag and returns it as an int.
+ */
+ public static int getAttribInt(Element ele, String name)
+ {
+ String sval = ele.getAttribute(name);
+ int val = 0;
+ try { val = Integer.parseInt(sval); } catch (Exception e) {}
+
+ return val;
+ }
+
+ /**
+ * Parses the given attribute of this tag as a hexadecimal encoded string and
+ * returns it as an int
+ */
+ public static int getAttribIntHex(Element ele, String name)
+ {
+ String sval = ele.getAttribute(name);
+ int val = 0;
+ try { val = Integer.parseInt(sval, 16); } catch (Exception e) {}
+
+ return val;
+ }
+
+ /**
+ * Parses the given attribute of this tag and returns it as a float
+ */
+ public static float getAttribFloat(Element ele, String name)
+ {
+ String sval = ele.getAttribute(name);
+ float val = 0.0f;
+ try { val = Float.parseFloat(sval); } catch (Exception e) {}
+
+ return val;
+ }
+
+ /**
+ * Parses the given attribute of this tag and returns it as a double.
+ */
+ public static double getAttribDouble(Element ele, String name)
+ {
+ String sval = ele.getAttribute(name);
+ double val = 0.0;
+ try { val = Double.parseDouble(sval); } catch (Exception e) {}
+
+ return val;
+ }
+
+ /**
+ * Parses the given attribute of this tag and returns it as a boolean.
+ * Essentially compares the lower case textual value to the string "true"
+ */
+ public static boolean getAttribBoolean(Element ele, String name)
+ {
+ String sval = ele.getAttribute(name);
+
+ return sval.toLowerCase().equals("true");
+ }
+
+ public static URL getAttribURL(Element ele, String name, URL docRoot)
+ {
+ String sval = ele.getAttribute(name);
+
+ URL url;
+ try
+ {
+ return new URL(docRoot, sval);
+ }
+ catch (Exception e)
+ {
+ return null;
+ }
+ }
+
+ /**
+ * Returns the first ReadableXMLElement with the given name
+ */
+ public static ReadableXMLElement getElement(Class classType, Element root, String name, URL docRoot)
+ {
+ if (root == null) return null;
+
+ //Do not process if not a LoadableObject
+ if (!ReadableXMLElement.class.isAssignableFrom(classType))
+ {
+ return null;
+ }
+
+ NodeList nl = root.getChildNodes();
+ int size = nl.getLength();
+ for (int i = 0; i < size; i++)
+ {
+ Node node = nl.item(i);
+ if (!(node instanceof Element)) continue;
+ Element ele = (Element)node;
+ if (!ele.getTagName().equals(name)) continue;
+
+ ReadableXMLElement newObj = null;
+ try { newObj = (ReadableXMLElement)classType.newInstance(); }
+ catch (Exception e) { e.printStackTrace(); continue; }
+ newObj.read(ele, docRoot);
+
+ if (newObj == null) continue;
+
+ return newObj;
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns a HashMap of nodes that are children of root. All nodes will
+ * be of class classType and have a tag name of 'name'. 'key' is
+ * an attribute of tag 'name' who's string value will be used as the key
+ * in the HashMap
+ */
+ public static HashMap getElementHashMap(Class classType, Element root, String name, String key, URL docRoot)
+ {
+ if (root == null) return null;
+
+ //Do not process if not a LoadableObject
+ if (!ReadableXMLElement.class.isAssignableFrom(classType))
+ {
+ return null;
+ }
+
+ HashMap retMap = new HashMap();
+
+/*
+ Class[] params = {Element.class, URL.class};
+ Method loadMethod = null;
+ try { loadMethod = classType.getMethod("load", params); }
+ catch (Exception e) { e.printStackTrace(); return null; }
+
+ */
+ NodeList nl = root.getChildNodes();
+ int size = nl.getLength();
+ for (int i = 0; i < size; i++)
+ {
+ Node node = nl.item(i);
+ if (!(node instanceof Element)) continue;
+ Element ele = (Element)node;
+ if (!ele.getTagName().equals(name)) continue;
+
+ ReadableXMLElement newObj = null;
+ try { newObj = (ReadableXMLElement)classType.newInstance(); }
+ catch (Exception e) { e.printStackTrace(); continue; }
+ newObj.read(ele, docRoot);
+/*
+ Object[] args = {ele, source};
+ Object obj = null;
+ try { obj = loadMethod.invoke(null, args); }
+ catch (Exception e) { e.printStackTrace(); }
+
+ */
+ if (newObj == null) continue;
+
+ String keyVal = getAttribString(ele, key);
+ retMap.put(keyVal, newObj);
+ }
+
+ return retMap;
+ }
+
+ public static HashSet getElementHashSet(Class classType, Element root, String name, URL docRoot)
+ {
+ if (root == null) return null;
+
+ //Do not process if not a LoadableObject
+ if (!ReadableXMLElement.class.isAssignableFrom(classType))
+ {
+ return null;
+ }
+
+ HashSet retSet = new HashSet();
+
+ /*
+ Class[] params = {Element.class, URL.class};
+ Method loadMethod = null;
+ try { loadMethod = classType.getMethod("load", params); }
+ catch (Exception e) { e.printStackTrace(); return null; }
+ */
+
+ NodeList nl = root.getChildNodes();
+ int size = nl.getLength();
+ for (int i = 0; i < size; i++)
+ {
+ Node node = nl.item(i);
+ if (!(node instanceof Element)) continue;
+ Element ele = (Element)node;
+ if (!ele.getTagName().equals(name)) continue;
+
+ ReadableXMLElement newObj = null;
+ try { newObj = (ReadableXMLElement)classType.newInstance(); }
+ catch (Exception e) { e.printStackTrace(); continue; }
+ newObj.read(ele, docRoot);
+ /*
+ Object[] args = {ele, source};
+ Object obj = null;
+ try { obj = loadMethod.invoke(null, args); }
+ catch (Exception e) { e.printStackTrace(); }
+ */
+
+ if (newObj == null) continue;
+
+ retSet.add(newObj);
+ }
+
+ return retSet;
+ }
+
+
+ public static LinkedList getElementLinkedList(Class classType, Element root, String name, URL docRoot)
+ {
+ if (root == null) return null;
+
+ //Do not process if not a LoadableObject
+ if (!ReadableXMLElement.class.isAssignableFrom(classType))
+ {
+ return null;
+ }
+
+ NodeList nl = root.getChildNodes();
+ LinkedList elementCache = new LinkedList();
+ int size = nl.getLength();
+ for (int i = 0; i < size; i++)
+ {
+ Node node = nl.item(i);
+ if (!(node instanceof Element)) continue;
+ Element ele = (Element)node;
+ if (!ele.getTagName().equals(name)) continue;
+
+ ReadableXMLElement newObj = null;
+ try { newObj = (ReadableXMLElement)classType.newInstance(); }
+ catch (Exception e) { e.printStackTrace(); continue; }
+ newObj.read(ele, docRoot);
+
+ elementCache.addLast(newObj);
+ }
+
+ return elementCache;
+ }
+
+ public static Object[] getElementArray(Class classType, Element root, String name, URL docRoot)
+ {
+ if (root == null) return null;
+
+ //Do not process if not a LoadableObject
+ if (!ReadableXMLElement.class.isAssignableFrom(classType))
+ {
+ return null;
+ }
+
+ LinkedList elementCache = getElementLinkedList(classType, root, name, docRoot);
+
+ Object[] retArr = (Object[])Array.newInstance(classType, elementCache.size());
+ return elementCache.toArray(retArr);
+ }
+
+ /**
+ * Takes a number of tags of name 'name' that are children of 'root', and
+ * looks for attributes of 'attrib' on them. Converts attributes to an
+ * int and returns in an array.
+ */
+ public static int[] getElementArrayInt(Element root, String name, String attrib)
+ {
+ if (root == null) return null;
+
+ NodeList nl = root.getChildNodes();
+ LinkedList elementCache = new LinkedList();
+ int size = nl.getLength();
+
+ for (int i = 0; i < size; i++)
+ {
+ Node node = nl.item(i);
+ if (!(node instanceof Element)) continue;
+ Element ele = (Element)node;
+ if (!ele.getTagName().equals(name)) continue;
+
+ String valS = ele.getAttribute(attrib);
+ int eleVal = 0;
+ try { eleVal = Integer.parseInt(valS); }
+ catch (Exception e) {}
+
+ elementCache.addLast(new Integer(eleVal));
+ }
+
+ int[] retArr = new int[elementCache.size()];
+ Iterator it = elementCache.iterator();
+ int idx = 0;
+ while (it.hasNext())
+ {
+ retArr[idx++] = ((Integer)it.next()).intValue();
+ }
+
+ return retArr;
+ }
+
+ /**
+ * Takes a number of tags of name 'name' that are children of 'root', and
+ * looks for attributes of 'attrib' on them. Converts attributes to an
+ * int and returns in an array.
+ */
+ public static String[] getElementArrayString(Element root, String name, String attrib)
+ {
+ if (root == null) return null;
+
+ NodeList nl = root.getChildNodes();
+ LinkedList elementCache = new LinkedList();
+ int size = nl.getLength();
+
+ for (int i = 0; i < size; i++)
+ {
+ Node node = nl.item(i);
+ if (!(node instanceof Element)) continue;
+ Element ele = (Element)node;
+ if (!ele.getTagName().equals(name)) continue;
+
+ String valS = ele.getAttribute(attrib);
+
+ elementCache.addLast(valS);
+ }
+
+ String[] retArr = new String[elementCache.size()];
+ Iterator it = elementCache.iterator();
+ int idx = 0;
+ while (it.hasNext())
+ {
+ retArr[idx++] = (String)it.next();
+ }
+
+ return retArr;
+ }
+
+ /**
+ * Takes a CSS style string and retursn a hash of them.
+ * @param styleString - A CSS formatted string of styles. Eg,
+ * "font-size:12;fill:#d32c27;fill-rule:evenodd;stroke-width:1pt;"
+ */
+ public static HashMap parseStyle(String styleString) {
+ return parseStyle(styleString, new HashMap());
+ }
+
+ /**
+ * Takes a CSS style string and returns a hash of them.
+ * @param styleString - A CSS formatted string of styles. Eg,
+ * "font-size:12;fill:#d32c27;fill-rule:evenodd;stroke-width:1pt;"
+ * @param map - A map to which these styles will be added
+ */
+ public static HashMap parseStyle(String styleString, HashMap map) {
+ final Pattern patSemi = Pattern.compile(";");
+ final Pattern patColonSpace = Pattern.compile(":");
+
+ //Strips left and right whitespace
+ final Matcher matcherContent = Pattern.compile("\\s*([^\\s](.*[^\\s])?)\\s*").matcher("");
+
+ String[] styles = patSemi.split(styleString);
+
+ for (int i = 0; i < styles.length; i++)
+ {
+ if (styles[i].length() == 0)
+ {
+ continue;
+ }
+
+ String[] vals = patColonSpace.split(styles[i]);
+
+ matcherContent.reset(vals[0]);
+ matcherContent.matches();
+ vals[0] = matcherContent.group(1);
+
+ matcherContent.reset(vals[1]);
+ matcherContent.matches();
+ vals[1] = matcherContent.group(1);
+
+ map.put(vals[0], new StyleAttribute(vals[0], vals[1]));
+ }
+
+ return map;
+ }
+}
Index: trunk/src/com/kitfox/svg/xml/cpx/CPXConsts.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/cpx/CPXConsts.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/cpx/CPXConsts.java (revision 4256)
@@ -0,0 +1,40 @@
+/*
+ * CPXConst.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on February 12, 2004, 12:51 PM
+ */
+
+package com.kitfox.svg.xml.cpx;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public interface CPXConsts {
+
+ static final byte[] MAGIC_NUMBER = {'C', 'P', 'X', 0};
+
+ static final int XL_PLAIN = 0;
+ static final int XL_ZIP_CRYPT = 1;
+}
Index: trunk/src/com/kitfox/svg/xml/cpx/CPXInputStream.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/cpx/CPXInputStream.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/cpx/CPXInputStream.java (revision 4256)
@@ -0,0 +1,293 @@
+/*
+ * CPXInputStream.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on February 12, 2004, 10:34 AM
+ */
+
+package com.kitfox.svg.xml.cpx;
+
+import java.io.*;
+import java.util.*;
+import java.util.zip.*;
+import java.security.*;
+import javax.crypto.*;
+
+/**
+ * This class reads/decodes the CPX file format. This format is a simple
+ * compression/encryption transformer for XML data. This stream takes in
+ * encrypted XML and outputs decrypted. It does this by checking for a magic
+ * number at the start of the stream. If absent, it treats the stream as
+ * raw XML data and passes it through unaltered. This is to aid development
+ * in debugging versions, where the XML files will not be in CPX format.
+ *
+ * See http://java.sun.com/developer/technicalArticles/Security/Crypto/
+ *
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class CPXInputStream extends FilterInputStream implements CPXConsts {
+
+
+ SecureRandom sec = new SecureRandom();
+
+ Inflater inflater = new Inflater();
+
+ int xlateMode;
+
+ //Keep header bytes in case this stream turns out to be plain text
+ byte[] head = new byte[4];
+ int headSize = 0;
+ int headPtr = 0;
+
+ boolean reachedEOF = false;
+ byte[] inBuffer = new byte[2048];
+ byte[] decryptBuffer = new byte[2048];
+
+ /** Creates a new instance of CPXInputStream */
+ public CPXInputStream(InputStream in) throws IOException {
+ super(in);
+
+ //Determine processing type
+ for (int i = 0; i < 4; i++)
+ {
+ int val = in.read();
+ head[i] = (byte)val;
+ if (val == -1 || head[i] != MAGIC_NUMBER[i])
+ {
+ headSize = i + 1;
+ xlateMode = XL_PLAIN;
+ return;
+ }
+ }
+
+ xlateMode = XL_ZIP_CRYPT;
+ }
+
+ /**
+ * We do not allow marking
+ */
+ public boolean markSupported() { return false; }
+
+ /**
+ * Closes this input stream and releases any system resources
+ * associated with the stream.
+ * This
+ * method simply performs in.close().
+ *
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterInputStream#in
+ */
+ public void close() throws IOException {
+ reachedEOF = true;
+ in.close();
+ }
+
+ /**
+ * Reads the next byte of data from this input stream. The value
+ * byte is returned as an int in the range
+ * 0 to 255. If no byte is available
+ * because the end of the stream has been reached, the value
+ * -1 is returned. This method blocks until input data
+ * is available, the end of the stream is detected, or an exception
+ * is thrown.
+ * in.read() and returns the result.
+ *
+ * @return the next byte of data, or -1 if the end of the
+ * stream is reached.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterInputStream#in
+ */
+ public int read() throws IOException
+ {
+ final byte[] b = new byte[1];
+ int retVal = read(b, 0, 1);
+ if (retVal == -1) return -1;
+ return b[0];
+ }
+
+ /**
+ * Reads up to byte.length bytes of data from this
+ * input stream into an array of bytes. This method blocks until some
+ * input is available.
+ * read(b, 0, b.length) and returns
+ * the result. It is important that it does
+ * not do in.read(b) instead;
+ * certain subclasses of FilterInputStream
+ * depend on the implementation strategy actually
+ * used.
+ *
+ * @param b the buffer into which the data is read.
+ * @return the total number of bytes read into the buffer, or
+ * -1 if there is no more data because the end of
+ * the stream has been reached.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterInputStream#read(byte[], int, int)
+ */
+ public int read(byte[] b) throws IOException
+ {
+ return read(b, 0, b.length);
+ }
+
+ /**
+ * Reads up to len bytes of data from this input stream
+ * into an array of bytes. This method blocks until some input is
+ * available.
+ * in.read(b, off, len)
+ * and returns the result.
+ *
+ * @param b the buffer into which the data is read.
+ * @param off the start offset of the data.
+ * @param len the maximum number of bytes read.
+ * @return the total number of bytes read into the buffer, or
+ * -1 if there is no more data because the end of
+ * the stream has been reached.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterInputStream#in
+ */
+ public int read(byte[] b, int off, int len) throws IOException
+ {
+ if (reachedEOF) return -1;
+
+ if (xlateMode == XL_PLAIN)
+ {
+ int count = 0;
+ //Write header if appropriate
+ while (headPtr < headSize && len > 0)
+ {
+ b[off++] = head[headPtr++];
+ count++;
+ len--;
+ }
+
+ return (len == 0) ? count : count + in.read(b, off, len);
+ }
+
+ //Decrypt and inflate
+ if (inflater.needsInput() && !decryptChunk())
+ {
+ reachedEOF = true;
+
+ //Read remaining bytes
+ int numRead;
+ try {
+ numRead = inflater.inflate(b, off, len);
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ return -1;
+ }
+
+ if (!inflater.finished())
+ {
+ new Exception("Inflation incomplete").printStackTrace();
+ }
+
+ return numRead == 0 ? -1 : numRead;
+ }
+
+ try {
+ return inflater.inflate(b, off, len);
+ }
+ catch (DataFormatException e)
+ {
+ e.printStackTrace();
+ return -1;
+ }
+ }
+
+
+ /**
+ * Call when inflater indicates that it needs more bytes.
+ * @return - true if we decrypted more bytes to deflate, false if we
+ * encountered the end of stream
+ */
+ protected boolean decryptChunk() throws IOException
+ {
+ while (inflater.needsInput())
+ {
+ int numInBytes = in.read(inBuffer);
+ if (numInBytes == -1) return false;
+// int numDecryptBytes = cipher.update(inBuffer, 0, numInBytes, decryptBuffer);
+// inflater.setInput(decryptBuffer, 0, numDecryptBytes);
+inflater.setInput(inBuffer, 0, numInBytes);
+ }
+
+ return true;
+ }
+
+ /**
+ * This method returns 1 if we've not reached EOF, 0 if we have. Programs
+ * should not rely on this to determine the number of bytes that can be
+ * read without blocking.
+ */
+ public int available() { return reachedEOF ? 0 : 1; }
+
+ /**
+ * Skips bytes by reading them into a cached buffer
+ */
+ public long skip(long n) throws IOException
+ {
+ int skipSize = (int)n;
+ if (skipSize > inBuffer.length) skipSize = inBuffer.length;
+ return read(inBuffer, 0, skipSize);
+ }
+
+}
+
+/*
+ import java.security.KeyPairGenerator;
+ import java.security.KeyPair;
+ import java.security.KeyPairGenerator;
+ import java.security.PrivateKey;
+ import java.security.PublicKey;
+ import java.security.SecureRandom;
+ import java.security.Cipher;
+
+ ....
+
+ java.security.Security.addProvider(new cryptix.provider.Cryptix());
+
+ SecureRandom random = new SecureRandom(SecureRandom.getSeed(30));
+ KeyPairGenerator keygen = KeyPairGenerator.getInstance("RSA");
+ keygen.initialize(1024, random);
+ keypair = keygen.generateKeyPair();
+
+ PublicKey pubkey = keypair.getPublic();
+ PrivateKey privkey = keypair.getPrivate();
+ */
+
+/*
+ *
+ *Generate key pairs
+KeyPairGenerator keyGen =
+ KeyPairGenerator.getInstance("DSA");
+KeyGen.initialize(1024, new SecureRandom(userSeed));
+KeyPair pair = KeyGen.generateKeyPair();
+ */
Index: trunk/src/com/kitfox/svg/xml/cpx/CPXOutputStream.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/cpx/CPXOutputStream.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/cpx/CPXOutputStream.java (revision 4256)
@@ -0,0 +1,174 @@
+/*
+ * CPXOutputStream.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on February 12, 2004, 12:50 PM
+ */
+
+package com.kitfox.svg.xml.cpx;
+
+import java.io.*;
+import java.util.zip.*;
+import java.security.*;
+import javax.crypto.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class CPXOutputStream extends FilterOutputStream implements CPXConsts {
+
+ Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION);
+
+ /** Creates a new instance of CPXOutputStream */
+ public CPXOutputStream(OutputStream os) throws IOException {
+ super(os);
+
+ //Write magic number
+ os.write(MAGIC_NUMBER);
+ }
+
+ /**
+ * Writes the specified byte to this output stream.
+ * write method of FilterOutputStream
+ * calls the write method of its underlying output stream,
+ * that is, it performs out.write(b).
+ * byte.
+ * @exception IOException if an I/O error occurs.
+ */
+ public void write(int b) throws IOException {
+ final byte[] buf = new byte[1];
+ buf[0] = (byte)b;
+ write(buf, 0, 1);
+ }
+
+ /**
+ * Writes b.length bytes to this output stream.
+ * write method of FilterOutputStream
+ * calls its write method of three arguments with the
+ * arguments b, 0, and
+ * b.length.
+ * write method of its underlying stream with the single
+ * argument b.
+ *
+ * @param b the data to be written.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#write(byte[], int, int)
+ */
+ public void write(byte b[]) throws IOException {
+ write(b, 0, b.length);
+ }
+
+ byte[] deflateBuffer = new byte[2048];
+
+ /**
+ * Writes len bytes from the specified
+ * byte array starting at offset off to
+ * this output stream.
+ * write method of FilterOutputStream
+ * calls the write method of one argument on each
+ * byte to output.
+ * write method
+ * of its underlying input stream with the same arguments. Subclasses
+ * of FilterOutputStream should provide a more efficient
+ * implementation of this method.
+ *
+ * @param b the data.
+ * @param off the start offset in the data.
+ * @param len the number of bytes to write.
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#write(int)
+ */
+ public void write(byte b[], int off, int len) throws IOException
+ {
+ deflater.setInput(b, off, len);
+
+ processAllData();
+ /*
+ int numDeflatedBytes;
+ while ((numDeflatedBytes = deflater.deflate(deflateBuffer)) != 0)
+ {
+// byte[] cipherBuf = cipher.update(deflateBuffer, 0, numDeflatedBytes);
+// out.write(cipherBytes);
+out.write(deflateBuffer, 0, numDeflatedBytes);
+ }
+ */
+ }
+
+ protected void processAllData() throws IOException
+ {
+ int numDeflatedBytes;
+ while ((numDeflatedBytes = deflater.deflate(deflateBuffer)) != 0)
+ {
+// byte[] cipherBuf = cipher.update(deflateBuffer, 0, numDeflatedBytes);
+// out.write(cipherBytes);
+out.write(deflateBuffer, 0, numDeflatedBytes);
+ }
+ }
+
+ /**
+ * Flushes this output stream and forces any buffered output bytes
+ * to be written out to the stream.
+ * flush method of FilterOutputStream
+ * calls the flush method of its underlying output stream.
+ *
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#out
+ */
+ public void flush() throws IOException {
+ out.flush();
+ }
+
+ /**
+ * Closes this output stream and releases any system resources
+ * associated with the stream.
+ * close method of FilterOutputStream
+ * calls its flush method, and then calls the
+ * close method of its underlying output stream.
+ *
+ * @exception IOException if an I/O error occurs.
+ * @see java.io.FilterOutputStream#flush()
+ * @see java.io.FilterOutputStream#out
+ */
+ public void close() throws IOException {
+ deflater.finish();
+ processAllData();
+
+ try {
+ flush();
+ } catch (IOException ignored) {
+ }
+ out.close();
+ }
+}
Index: trunk/src/com/kitfox/svg/xml/cpx/CPXTest.java
===================================================================
--- trunk/src/com/kitfox/svg/xml/cpx/CPXTest.java (revision 4256)
+++ trunk/src/com/kitfox/svg/xml/cpx/CPXTest.java (revision 4256)
@@ -0,0 +1,100 @@
+/*
+ * CPXTest.java
+ *
+ *
+ * The Salamander Project - 2D and 3D graphics libraries in Java
+ * Copyright (C) 2004 Mark McKay
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Mark McKay can be contacted at mark@kitfox.com. Salamander and other
+ * projects can be found at http://www.kitfox.com
+ *
+ * Created on February 12, 2004, 2:45 PM
+ */
+
+package com.kitfox.svg.xml.cpx;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * @author Mark McKay
+ * @author Mark McKay
+ */
+public class CPXTest {
+
+ /** Creates a new instance of CPXTest */
+ public CPXTest() {
+
+// FileInputStream fin = new FileInputStream();
+ writeTest();
+ readTest();
+ }
+
+ public void writeTest()
+ {
+ try {
+
+ InputStream is = CPXTest.class.getResourceAsStream("/data/readme.txt");
+//System.err.println("Is " + is);
+
+ FileOutputStream fout = new FileOutputStream("C:\\tmp\\cpxFile.cpx");
+ CPXOutputStream cout = new CPXOutputStream(fout);
+
+ byte[] buffer = new byte[1024];
+ int numBytes;
+ while ((numBytes = is.read(buffer)) != -1)
+ {
+ cout.write(buffer, 0, numBytes);
+ }
+ cout.close();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ public void readTest()
+ {
+ try {
+
+// InputStream is = CPXTest.class.getResourceAsStream("/rawdata/test/cpx/text.txt");
+// InputStream is = CPXTest.class.getResourceAsStream("/rawdata/test/cpx/cpxFile.cpx");
+ FileInputStream is = new FileInputStream("C:\\tmp\\cpxFile.cpx");
+ CPXInputStream cin = new CPXInputStream(is);
+
+ BufferedReader br = new BufferedReader(new InputStreamReader(cin));
+ String line;
+ while ((line = br.readLine()) != null)
+ {
+ System.err.println(line);
+ }
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ /**
+ * @param args the command line arguments
+ */
+ public static void main(String[] args) {
+ new CPXTest();
+ }
+
+}
Index: trunk/src/org/openstreetmap/josm/tools/ImageProvider.java
===================================================================
--- trunk/src/org/openstreetmap/josm/tools/ImageProvider.java (revision 4255)
+++ trunk/src/org/openstreetmap/josm/tools/ImageProvider.java (revision 4256)
@@ -3,4 +3,8 @@
import static org.openstreetmap.josm.tools.I18n.tr;
+
+import com.kitfox.svg.SVGDiagram;
+import com.kitfox.svg.SVGException;
+import com.kitfox.svg.SVGUniverse;
import java.awt.Component;
@@ -20,4 +24,5 @@
import java.io.InputStream;
import java.net.MalformedURLException;
+import java.net.URI;
import java.net.URL;
import java.util.Arrays;
@@ -42,4 +47,6 @@
public class ImageProvider {
+ private static SVGUniverse svgUniverse;
+
/**
* Position of an overlay icon
@@ -48,4 +55,8 @@
public static enum OverlayPosition {
NORTHWEST, NORTHEAST, SOUTHWEST, SOUTHEAST
+ }
+
+ public static enum ImageType {
+ PNG, SVG
}
@@ -71,6 +82,6 @@
* Return an image from the specified location.
*
- * @param subdir The position of the directory, e.g. "layer"
- * @param name The icons name (without the ending of ".png")
+ * @param subdir The position of the directory, e.g. 'layer'
+ * @param name The icons name (with or without '.png' or '.svg' extension)
* @return The requested Image.
*/
@@ -86,4 +97,11 @@
}
+ /**
+ * Shortcut for get("", name);
+ */
+ public static ImageIcon get(String name) {
+ return get("", name);
+ }
+
public static ImageIcon getIfAvailable(String subdir, String name) {
return getIfAvailable((Collection