X-Git-Url: http://git.megacz.com/?p=org.ibex.core.git;a=blobdiff_plain;f=src%2Forg%2Fibex%2Fgraphics%2FPath.java;h=7dce44bdda19c68286a7568f3d59ebe6d2d5255f;hp=79fecba5185e8f04eaa9cfe946f02399bf4873d5;hb=HEAD;hpb=4daeeb4119b901d53b44913c86f8af3ce67db925

diff --git a/src/org/ibex/graphics/Path.java b/src/org/ibex/graphics/Path.java
index 79fecba..7dce44b 100644
--- a/src/org/ibex/graphics/Path.java
+++ b/src/org/ibex/graphics/Path.java
@@ -1,201 +1,269 @@
-// FIXME
-// Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL]
-package org.ibex;
+// Copyright 2000-2005 the Contributors, as shown in the revision logs.
+// Licensed under the GNU General Public License version 2 ("the License").
+// You may not use this file except in compliance with the License.
+
+package org.ibex.graphics;
 import java.util.*;
+import org.ibex.util.*;
 
-// FIXME: offer a "subpixel" mode where we pass floats to the Platform and don't do any snapping
-// FIXME: fracture when realizing instead of when parsing?
+/** an abstract path; may contain splines and arcs */
+public class Path {
 
-/*
-    v1.0
-    - textpath
-    - gradients
-    - patterns
-    - clipping/masking
-    - filters (filtering of a group must be performed AFTER the group is assembled; sep. canvas)
+    public static final float PX_PER_INCH = 72;
+    public static final float INCHES_PER_CM = (float)0.3937;
+    public static final float INCHES_PER_MM = INCHES_PER_CM / 10;
+    private static final int DEFAULT_PATHLEN = 1000;
+    private static final int NUMSTEPS = 10;
+    private static final float PI = (float)Math.PI;
 
-    v1.1
-    - bump caps [requires Paint that can fill circles...] [remember to distinguish between closed/unclosed]
-    - line joins
-        - mitre    (hard)
-        - bevel    (easy)
-        - bump     (easy, but requires 'round' Paint)
-    - subtree sharing? otherwise the memory consumption might be outrageous... clone="" attribute?
-    - better clipping
-        - intersect clip regions (linearity)
-        - clip on trapezoids, not pixels
-    - faster gradients and patterns:
-        - transform each corner of the trapezoid and then interpolate
-*/
+    boolean closed = false;
+    Curve head = null;
+    Curve tail = null;
+    protected void add(Curve c) {
+        if (head==null) { tail=head=c; return; }
+        c.prev = tail;
+        tail.next = c;
+        tail = c;
+    }
 
-/** Ibex's fully conformant Static SVG Viewer; see SVG spec, section G.7 */
-public final class VectorGraphics {
+    public void addTo(Mesh m, boolean evenOdd) {
+        for(Curve c = head; c != null; c = c.next) c.addTo(m);
+        m.setIn(evenOdd);
+    }
 
-    // Private Constants ///////////////////////////////////////////////////////////////////
+    abstract class Curve {
+        Curve next, prev;
+        float x, y;
+        float c1x, c1y, c2x, c2y;
+        public Curve() { }
+        public abstract void addTo(Mesh ret);
+    }
 
-    private static final int DEFAULT_PATHLEN = 1000;
-    private static final float PI = (float)Math.PI;
+    class Line extends Curve {
+        public void addTo(Mesh ret) {
+            float rx = next.x;
+            float ry = next.y;
+            ret.add(rx,ry);
+        }
+    }
 
+    class Move extends Curve {
+        public void addTo(Mesh ret) {
+            ret.newcontour();
+            if (next==null) return;
+            float rx = next.x;
+            float ry = next.y;
+            ret.add(rx, ry);
+        }
+    }
 
-    // Public entry points /////////////////////////////////////////////////////////////////
+    class Arc extends Curve {
+        public void addTo(Mesh ret) {
+            System.out.println("ARC!");
+            float rx = c1x;
+            float ry = c1y;
+            float phi = c2x;
+            float fa = ((int)c2y) >> 1;
+            float fs = ((int)c2y) & 1;
+            float x1 = x;
+            float y1 = y;
+            float x2 = next.x;
+            float y2 = next.y;
+
+            // F.6.5: given x1,y1,x2,y2,fa,fs, compute cx,cy,theta1,dtheta
+            float x1_ = (float)Math.cos(phi) * (x1 - x2) / 2 + (float)Math.sin(phi) * (y1 - y2) / 2;
+            float y1_ = -1 * (float)Math.sin(phi) * (x1 - x2) / 2 + (float)Math.cos(phi) * (y1 - y2) / 2;
+            float tmp = (float)Math.sqrt((rx * rx * ry * ry - rx * rx * y1_ * y1_ - ry * ry * x1_ * x1_) /
+                                         (rx * rx * y1_ * y1_ + ry * ry * x1_ * x1_));
+            float cx_ = (fa == fs ? -1 : 1) * tmp * (rx * y1_ / ry);
+            float cy_ = (fa == fs ? -1 : 1) * -1 * tmp * (ry * x1_ / rx);
+            float cx = (float)Math.cos(phi) * cx_ - (float)Math.sin(phi) * cy_ + (x1 + x2) / 2;
+            float cy = (float)Math.sin(phi) * cx_ + (float)Math.cos(phi) * cy_ + (y1 + y2) / 2;
+            
+            // F.6.4 Conversion from center to endpoint parameterization
+            float ux = 1, uy = 0, vx = (x1_ - cx_) / rx, vy = (y1_ - cy_) / ry;
+            float det = ux * vy - uy * vx;
+            float theta1 = (det < 0 ? -1 : 1) *
+                (float)Math.acos((ux * vx + uy * vy) / 
+                                 ((float)Math.sqrt(ux * ux + uy * uy) * (float)Math.sqrt(vx * vx + vy * vy)));
+            ux = (x1_ - cx_) / rx; uy = (y1_ - cy_) / ry;
+            vx = (-1 * x1_ - cx_) / rx; vy = (-1 * y1_ - cy_) / ry;
+            det = ux * vy - uy * vx;
+            float dtheta = (det < 0 ? -1 : 1) *
+                (float)Math.acos((ux * vx + uy * vy) / 
+                                 ((float)Math.sqrt(ux * ux + uy * uy) * (float)Math.sqrt(vx * vx + vy * vy)));
+            dtheta = dtheta % (float)(2 * Math.PI);
+            
+            if (fs == 0 && dtheta > 0) theta1 -= 2 * PI; 
+            if (fs == 1 && dtheta < 0) theta1 += 2 * PI;
+            
+            if (fa == 1 && dtheta < 0) dtheta = 2 * PI + dtheta;
+            else if (fa == 1 && dtheta > 0) dtheta = -1 * (2 * PI - dtheta);
+
+            // FIXME: integrate F.6.6
+            // FIXME: isn't quite ending where it should...
+
+            // F.6.3: Parameterization alternatives
+            float theta = theta1;
+            for(int j=0; j<NUMSTEPS; j++) {
+                float rasterx = rx * (float)Math.cos(theta) * (float)Math.cos(phi) -
+                    ry * (float)Math.sin(theta) * (float)Math.sin(phi) + cx;
+                float rastery = rx * (float)Math.cos(theta) * (float)Math.sin(phi) +
+                    ry * (float)Math.cos(phi) * (float)Math.sin(theta) + cy;
+                ret.add(rasterx, rastery);
+                theta += dtheta / NUMSTEPS;
+            }
+        }
+    }
+
+    class Bezier extends Curve {
+        float cx, cy;
+        public void addTo(Mesh ret) {
+            float ax = next.x - 3 * c2x + 3 * c1x - x;
+            float bx = 3 * c2x - 6 * c1x + 3 * x;
+            float cx = 3 * c1x - 3 * x;
+            float dx = x;
+            float ay = next.y - 3 * c2y + 3 * c1y - y;
+            float by = 3 * c2y - 6 * c1y + 3 * y;
+            float cy = 3 * c1y - 3 * y;
+            float dy = y;
+            
+            float x0 = x;
+            float y0 = y;
+            float x1 = next.x;
+            float y1 = next.y;
+            float steps = (float)Math.sqrt( (x1-x0) * (x1-x0) + (y1-y0) * (y1-y0) );
+            
+            //for(float t=0; t<1; t += 0.5) {
+            for(float t=0; t<1; t += 1/(steps/20)) {
+                float rx = ax * t * t * t + bx * t * t + cx * t + dx;
+                float ry = ay * t * t * t + by * t * t + cy * t + dy;
+                ret.add(rx,ry);
+            }
+        }
+    }
 
-    public static VectorPath parseVectorPath(String s) {
-        if (s == null) return null;
-        PathTokenizer t = new PathTokenizer(s);
-        VectorPath ret = new VectorPath();
+    class QuadBezier extends Curve {
+        float cx, cy, cx2, cy2;
+        public void addTo(Mesh ret) {
+            throw new Error("doesn't work yet");
+            /*
+            float bx = next.x - 2 * c1x + x;
+            float cx = 2 * c1x - 2 * x;
+            float dx = x;
+            float by = next.y - 2 * c1y + y;
+            float cy = 2 * c1y - 2 * y;
+            float dy = y;
+		    	
+            float x0 = a.multiply_px(x, y);
+            float y0 = a.multiply_py(x, y);
+            float x1 = a.multiply_px(next.x, next.y);
+            float y1 = a.multiply_py(next.x, next.y);
+            float steps = (float)Math.sqrt( (x1-x0) * (x1-x0) + (y1-y0) * (y1-y0) );
+
+            for(float t=0; t<1; t += 1 / (steps/20)) {
+                float rx = bx * t * t + cx * t + dx;
+                float ry = by * t * t + cy * t + dy;
+                ret.add(a.multiply_px(rx, ry), a.multiply_py(rx, ry));
+            }
+            */
+        }
+    }
+
+    public Path(String s) {
+        //this.toString = s;
+        Tokenizer t = new Tokenizer(s);
         char last_command = 'M';
         boolean first = true;
         while(t.hasMoreTokens()) {
             char command = t.parseCommand();
+            if (first && command == 'm') command = 'M';
             if (first && command != 'M') throw new RuntimeException("the first command of a path must be 'M'");
             first = false;
             boolean relative = Character.toLowerCase(command) == command;
             command = Character.toLowerCase(command);
-            ret.parseSingleCommandAndArguments(t, command, relative);
+            parseSingleCommandAndArguments(t, command, relative);
             last_command = command;
         }
-        return ret;
     }
 
+    public long boundingBox(Affine a) {
+        long hb = horizontalBounds(a);
+        long vb = verticalBounds(a);
+        return Encode.twoFloatsToLong(Math.abs(Encode.longToFloat1(hb) - Encode.longToFloat2(hb)),
+                                      Math.abs(Encode.longToFloat1(vb) - Encode.longToFloat2(vb)));
+    }
 
-    // Affine //////////////////////////////////////////////////////////////////////////////
-
-    /** an affine transform; all operations are destructive */
-    public static final class Affine {
-
-	//  [ a b e ]
-	//  [ c d f ]
-	//  [ 0 0 1 ]
-        public float a, b, c, d, e, f;
-
-	Affine(float _a, float _b, float _c, float _d, float _e, float _f) { a = _a; b = _b; c = _c; d = _d; e = _e; f = _f; }
-	public String toString() { return "[ " + a + ", " + b + ", " + c + ", " + d + ", " + e + ", " + f + " ]"; }
-	public Affine copy() { return new Affine(a, b, c, d, e, f); }
-        public static Affine identity() { return new Affine(1, 0, 0, 1, 0, 0); }
-	public static Affine scale(float sx, float sy) { return new Affine(sx, 0, 0, sy, 0, 0); }
-	public static Affine shear(float degrees) {
-            return new Affine(1, 0, (float)Math.tan(degrees * (float)(Math.PI / 180.0)), 1, 0, 0); }
-	public static Affine translate(float tx, float ty) { return new Affine(1, 0, 0, 1, tx, ty); }
-	public static Affine flip(boolean horiz, boolean vert) { return new Affine(horiz ? -1 : 1, 0, 0, vert ? -1 : 1, 0, 0); }
-        public float multiply_px(float x, float y) { return x * a + y * c + e; }
-	public float multiply_py(float x, float y) { return x * b + y * d + f; }
-        public boolean equalsIgnoringTranslation(Affine x) { return a == x.a && b == x.b && c == x.c && d == x.d; }
-
-        public boolean equals(Object o) {
-            if (!(o instanceof Affine)) return false;
-            Affine x = (Affine)o;
-            return a == x.a && b == x.b && c == x.c && d == x.d && e == x.e && f == x.f;
+    //#repeat width/height multiply_px/multiply_py horizontalBounds/verticalBounds
+    public long horizontalBounds(Affine a) {
+        // FIXME wrong
+        float min = Float.MAX_VALUE;
+        float max = Float.MIN_VALUE;
+        for(Curve c = head; c != null; c = c.next) {
+            min = Math.min(min, a.multiply_px(c.x, c.y));
+            max = Math.max(max, a.multiply_px(c.x, c.y));
         }
-
-	public static Affine rotate(float degrees) {
-	    float s = (float)Math.sin(degrees * (float)(Math.PI / 180.0));
-	    float c = (float)Math.cos(degrees * (float)(Math.PI / 180.0));
-	    return new Affine(c, s, -s, c, 0, 0);
-	}
-
-	/** this = this * a */
-        public Affine multiply(Affine A) {
-	    float _a = this.a * A.a + this.b * A.c;
-	    float _b = this.a * A.b + this.b * A.d;
-	    float _c = this.c * A.a + this.d * A.c;
-	    float _d = this.c * A.b + this.d * A.d;
-	    float _e = this.e * A.a + this.f * A.c + A.e;
-	    float _f = this.e * A.b + this.f * A.d + A.f;
-	    a = _a; b = _b; c = _c; d = _d; e = _e; f = _f;
-            return this;
-	}
-
-        public void invert() {
-	    float det = 1 / (a * d - b * c);
-	    float _a = d * det;
-	    float _b = -1 * b * det;
-	    float _c = -1 * c * det;
-	    float _d = a * det;
-	    float _e = -1 * e * a - f * c;
-	    float _f = -1 * e * b - f * d;
-	    a = _a; b = _b; c = _c; d = _d; e = _e; f = _f;
-	}
+        return Encode.twoFloatsToLong(max, min);
     }
-
-
-    // PathTokenizer //////////////////////////////////////////////////////////////////////////////
-
-    public static Affine parseTransform(String t) {
-        if (t == null) return null;
-        t = t.trim();
-        Affine ret = VectorGraphics.Affine.identity();
-        while (t.length() > 0) {
-            if (t.startsWith("skewX(")) {
-                // FIXME
-                
-            } else if (t.startsWith("shear(")) {
-                // FIXME: nonstandard; remove this
-                ret.multiply(VectorGraphics.Affine.shear(Float.parseFloat(t.substring(t.indexOf('(') + 1, t.indexOf(')')))));
-                
-            } else if (t.startsWith("skewY(")) {
-                // FIXME
-                
-            } else if (t.startsWith("rotate(")) {
-                String sub = t.substring(t.indexOf('(') + 1, t.indexOf(')'));
-                if (sub.indexOf(',') != -1) {
-                    float angle = Float.parseFloat(sub.substring(0, sub.indexOf(',')));
-                    sub = sub.substring(sub.indexOf(',') + 1);
-                    float cx = Float.parseFloat(sub.substring(0, sub.indexOf(',')));
-                    sub = sub.substring(sub.indexOf(',') + 1);
-                    float cy = Float.parseFloat(sub);
-                    ret.multiply(VectorGraphics.Affine.translate(cx, cy));
-                    ret.multiply(VectorGraphics.Affine.rotate(angle));
-                    ret.multiply(VectorGraphics.Affine.translate(-1 * cx, -1 * cy));
-                } else {
-                    ret.multiply(VectorGraphics.Affine.rotate(Float.parseFloat(t.substring(t.indexOf('(') + 1, t.indexOf(')')))));
-                }
-                
-            } else if (t.startsWith("translate(")) {
-                String sub = t.substring(t.indexOf('(') + 1, t.indexOf(')'));
-                if (sub.indexOf(',') > -1) {
-                    ret.multiply(VectorGraphics.Affine.translate(Float.parseFloat(t.substring(t.indexOf('(') + 1, t.indexOf(','))),
-                                                                 Float.parseFloat(t.substring(t.indexOf(',') + 1, t.indexOf(')')))));
-                } else {
-                    ret.multiply(VectorGraphics.Affine.translate(Float.parseFloat(t.substring(t.indexOf('(') + 1, t.indexOf(','))), 0));
-                }
-                
-            } else if (t.startsWith("flip(")) {
-                String which = t.substring(t.indexOf('(') + 1, t.indexOf(')'));
-                ret.multiply(VectorGraphics.Affine.flip(which.equals("horizontal"), which.equals("vertical")));
-                
-            } else if (t.startsWith("scale(")) {
-                String sub = t.substring(t.indexOf('(') + 1, t.indexOf(')'));
-                if (sub.indexOf(',') > -1) {
-                    ret.multiply(VectorGraphics.Affine.scale(Float.parseFloat(t.substring(t.indexOf('(') + 1, t.indexOf(','))),
-                                                             Float.parseFloat(t.substring(t.indexOf(',') + 1, t.indexOf(')')))));
-                } else {
-                    ret.multiply(VectorGraphics.Affine.scale(Float.parseFloat(t.substring(t.indexOf('(') + 1, t.indexOf(','))),
-                                                             Float.parseFloat(t.substring(t.indexOf('(') + 1, t.indexOf(',')))));
-                }
-                
-            } else if (t.startsWith("matrix(")) {
-                // FIXME: is this mapped right?
-                float d[] = new float[6];
-                StringTokenizer st = new StringTokenizer(t, ",", false);
-                for(int i=0; i<6; i++)
-                    d[i] = Float.parseFloat(st.nextToken());
-                ret.multiply(new VectorGraphics.Affine(d[0], d[1], d[2], d[3], d[4], d[5]));
+    //#end
+
+    public long transform(Affine a, boolean forReal) { return transform(a, forReal, true); }
+    public long transform(Affine a, boolean forReal, boolean widthheight) {
+        float minx = Integer.MAX_VALUE; float miny = Integer.MAX_VALUE;
+        float maxx = Integer.MIN_VALUE; float maxy = Integer.MIN_VALUE;
+        for(Curve c = head; c != null; c = c.next) {
+            if (c instanceof Arc) { /* FIXME!!! WRONG!!!! */ continue; }
+            float x   = a.multiply_px(c.x,   c.y);    if (x>maxx) maxx = x; if (x<minx) minx = x;
+            float y   = a.multiply_py(c.x,   c.y);    if (y>maxy) maxy = y; if (y<miny) miny = y;
+            float c1x = a.multiply_px(c.c1x, c.c1y);  if (c1x>maxx) maxx = c1x; if (c1x<minx) minx = c1x;
+            float c1y = a.multiply_py(c.c1x, c.c1y);  if (c1y>maxy) maxy = c1y; if (c1y<miny) miny = c1y;
+            float c2x = a.multiply_px(c.c2x, c.c2y);  if (c2x>maxx) maxx = c2x; if (c2x<minx) minx = c2x;
+            float c2y = a.multiply_py(c.c2x, c.c2y);  if (c2y>maxy) maxy = c2y; if (c2y<miny) miny = c2y;
+            if (forReal) {
+                c.x = x; c.y = y;
+                c.c1x = c1x; c.c1y = c1y;
+                c.c2x = c2x; c.c2y = c2y;
             }
-            t = t.substring(t.indexOf(')') + 1).trim();
         }
-        return ret;
+        if (widthheight) return ((((long)Float.floatToIntBits(maxx - minx)) << 32) | ((long)Float.floatToIntBits(maxy - miny)));
+        else return ((((long)Float.floatToIntBits(minx)) << 32) | ((long)Float.floatToIntBits(miny)));
     }
-    
-    public static final float PX_PER_INCH = 72;
-    public static final float INCHES_PER_CM = (float)0.3937;
-    public static final float INCHES_PER_MM = INCHES_PER_CM / 10;
 
-    public static class PathTokenizer {
+    public void alignToOrigin() {
+        float minx = Integer.MAX_VALUE; float miny = Integer.MAX_VALUE;
+        for(Curve c = head; c != null; c = c.next) { if (c.x < minx) minx = c.x; if (c.y < miny) miny = c.y; }
+        for(Curve c = head; c != null; c = c.next) {
+            c.x -= minx; c.y -= miny;
+            if (c instanceof Arc) continue;
+            c.c1x -= minx; c.c2x -= minx; c.c1y -= miny; c.c2y -= miny;
+        }
+    }
+
+    public static class Tokenizer {
         // FIXME: check array bounds exception for improperly terminated string
         String s;
         int i = 0;
         char lastCommand = 'M';
-        public PathTokenizer(String s) { this.s = s; }
+        public Tokenizer(String s) { this.s = s; }
+            
+        public static Path parse(String s) {
+            if (s == null) return null;
+            Tokenizer t = new Tokenizer(s);
+            Path ret = new Path(s);
+            return ret;/*
+            char last_command = 'M';
+            boolean first = true;
+            while(t.hasMoreTokens()) {
+                char command = t.parseCommand();
+                if (first && command != 'M') throw new RuntimeException("the first command of a path must be 'M'");
+                first = false;
+                boolean relative = Character.toLowerCase(command) == command;
+                command = Character.toLowerCase(command);
+                ret.parseSingleCommandAndArguments(t, command, relative);
+                last_command = command;
+            }
+            return ret;*/
+        }
         private void consumeWhitespace() {
             while(i < s.length() && (Character.isWhitespace(s.charAt(i)))) i++;
             if (i < s.length() && s.charAt(i) == ',') i++;
@@ -230,585 +298,110 @@ public final class VectorGraphics {
                     throw new RuntimeException("didn't expect character \"" + c + "\" in a numeric constant");
                 }
             }
-            if (start == i) throw new RuntimeException("FIXME");
-            return Float.parseFloat(s.substring(start, i)) * multiplier;
+            //if (start == i) throw new RuntimeException("FIXME");
+            if (start == i) return (float)0.0;
+            try {
+                return Float.parseFloat(s.substring(start, i)) * multiplier;
+            } catch (NumberFormatException nfe) {
+                Log.warn(Path.class, "offending string was \"" + s.substring(start, i) + "\"");
+                throw nfe;
+            }
         }
     }
 
-
-    // Abstract Path //////////////////////////////////////////////////////////////////////////////
-
-    /** an abstract path; may contain splines and arcs */
-    public static class VectorPath {
-
-        // the number of vertices on this path
-	int numvertices = 0;
-
-        // the vertices of the path
-	float[] x = new float[DEFAULT_PATHLEN];
-	float[] y = new float[DEFAULT_PATHLEN];
-
-        // the type of each edge; type[i] is the type of the edge from x[i],y[i] to x[i+1],y[i+1]
-	byte[] type = new byte[DEFAULT_PATHLEN];
-
-	// bezier control points
-	float[] c1x = new float[DEFAULT_PATHLEN];  // or rx (arcto)
-	float[] c1y = new float[DEFAULT_PATHLEN];  // or ry (arcto)
-	float[] c2x = new float[DEFAULT_PATHLEN];  // or x-axis-rotation (arcto)
-	float[] c2y = new float[DEFAULT_PATHLEN];  // or large-arc << 1 | sweep (arcto)
-
-	boolean closed = false;
-
-	static final byte TYPE_MOVETO = 0;
-	static final byte TYPE_LINETO = 1;
-	static final byte TYPE_ARCTO = 2;
-	static final byte TYPE_CUBIC = 3;
-	static final byte TYPE_QUADRADIC = 4;
-
-        /** Creates a concrete vector path transformed through the given matrix. */
-	public RasterPath realize(Affine a) {
-
-            RasterPath ret = new RasterPath();
-            int NUMSTEPS = 5;  // FIXME
-	    ret.numvertices = 1;
-            ret.x[0] = (int)Math.round(a.multiply_px(x[0], y[0]));
-            ret.y[0] = (int)Math.round(a.multiply_py(x[0], y[0]));
-
-	    for(int i=1; i<numvertices; i++) {
-		if (type[i] == TYPE_LINETO) {
-		    float rx = x[i];
-		    float ry = y[i];
-                    ret.x[ret.numvertices] = (int)Math.round(a.multiply_px(rx, ry));
-                    ret.y[ret.numvertices] = (int)Math.round(a.multiply_py(rx, ry));
-                    ret.edges[ret.numedges++] = ret.numvertices - 1; ret.numvertices++;
-
-                } else if (type[i] == TYPE_MOVETO) {
-		    float rx = x[i];
-		    float ry = y[i];
-                    ret.x[ret.numvertices] = (int)Math.round(a.multiply_px(rx, ry));
-                    ret.y[ret.numvertices] = (int)Math.round(a.multiply_py(rx, ry));
-                    ret.numvertices++;
-
-		} else if (type[i] == TYPE_ARCTO) {
-		    float rx = c1x[i];
-		    float ry = c1y[i];
-		    float phi = c2x[i];
-		    float fa = ((int)c2y[i]) >> 1;
-		    float fs = ((int)c2y[i]) & 1;
-		    float x1 = x[i];
-		    float y1 = y[i];
-		    float x2 = x[i+1];
-		    float y2 = y[i+1];
-
-		    // F.6.5: given x1,y1,x2,y2,fa,fs, compute cx,cy,theta1,dtheta
-		    float x1_ = (float)Math.cos(phi) * (x1 - x2) / 2 + (float)Math.sin(phi) * (y1 - y2) / 2;
-		    float y1_ = -1 * (float)Math.sin(phi) * (x1 - x2) / 2 + (float)Math.cos(phi) * (y1 - y2) / 2;
-		    float tmp = (float)Math.sqrt((rx * rx * ry * ry - rx * rx * y1_ * y1_ - ry * ry * x1_ * x1_) /
-                                                 (rx * rx * y1_ * y1_ + ry * ry * x1_ * x1_));
-		    float cx_ = (fa == fs ? -1 : 1) * tmp * (rx * y1_ / ry);
-		    float cy_ = (fa == fs ? -1 : 1) * -1 * tmp * (ry * x1_ / rx);
-		    float cx = (float)Math.cos(phi) * cx_ - (float)Math.sin(phi) * cy_ + (x1 + x2) / 2;
-		    float cy = (float)Math.sin(phi) * cx_ + (float)Math.cos(phi) * cy_ + (y1 + y2) / 2;
-
-                    // F.6.4 Conversion from center to endpoint parameterization
-                    float ux = 1, uy = 0, vx = (x1_ - cx_) / rx, vy = (y1_ - cy_) / ry;
-                    float det = ux * vy - uy * vx;
-                    float theta1 = (det < 0 ? -1 : 1) *
-                        (float)Math.acos((ux * vx + uy * vy) / 
-                                  ((float)Math.sqrt(ux * ux + uy * uy) * (float)Math.sqrt(vx * vx + vy * vy)));
-                    ux = (x1_ - cx_) / rx; uy = (y1_ - cy_) / ry;
-                    vx = (-1 * x1_ - cx_) / rx; vy = (-1 * y1_ - cy_) / ry;
-                    det = ux * vy - uy * vx;
-                    float dtheta = (det < 0 ? -1 : 1) *
-                        (float)Math.acos((ux * vx + uy * vy) / 
-                                  ((float)Math.sqrt(ux * ux + uy * uy) * (float)Math.sqrt(vx * vx + vy * vy)));
-                    dtheta = dtheta % (float)(2 * Math.PI);
-
-		    if (fs == 0 && dtheta > 0) theta1 -= 2 * PI; 
-		    if (fs == 1 && dtheta < 0) theta1 += 2 * PI;
-
-		    if (fa == 1 && dtheta < 0) dtheta = 2 * PI + dtheta;
-		    else if (fa == 1 && dtheta > 0) dtheta = -1 * (2 * PI - dtheta);
-
-		    // FIXME: integrate F.6.6
-		    // FIXME: isn't quite ending where it should...
-
-		    // F.6.3: Parameterization alternatives
-		    float theta = theta1;
-		    for(int j=0; j<NUMSTEPS; j++) {
-			float rasterx = rx * (float)Math.cos(theta) * (float)Math.cos(phi) -
-                            ry * (float)Math.sin(theta) * (float)Math.sin(phi) + cx;
-			float rastery = rx * (float)Math.cos(theta) * (float)Math.sin(phi) +
-                            ry * (float)Math.cos(phi) * (float)Math.sin(theta) + cy;
-                        ret.x[ret.numvertices] = (int)Math.round(a.multiply_px(rasterx, rastery));
-                        ret.y[ret.numvertices] = (int)Math.round(a.multiply_py(rasterx, rastery));
-                        ret.edges[ret.numedges++] = ret.numvertices - 1; ret.numvertices++;
-			theta += dtheta / NUMSTEPS;
-		    }
-
-		} else if (type[i] == TYPE_CUBIC) {
-
-		    float ax = x[i+1] - 3 * c2x[i] + 3 * c1x[i] - x[i];
-		    float bx = 3 * c2x[i] - 6 * c1x[i] + 3 * x[i];
-		    float cx = 3 * c1x[i] - 3 * x[i];
-		    float dx = x[i];
-		    float ay = y[i+1] - 3 * c2y[i] + 3 * c1y[i] - y[i];
-		    float by = 3 * c2y[i] - 6 * c1y[i] + 3 * y[i];
-		    float cy = 3 * c1y[i] - 3 * y[i];
-		    float dy = y[i];
-		    
-		    for(float t=0; t<1; t += 1 / (float)NUMSTEPS) {
-			float rx = ax * t * t * t + bx * t * t + cx * t + dx;
-			float ry = ay * t * t * t + by * t * t + cy * t + dy;
-                        ret.x[ret.numvertices] = (int)Math.round(a.multiply_px(rx, ry));
-                        ret.y[ret.numvertices] = (int)Math.round(a.multiply_py(rx, ry));
-                        ret.edges[ret.numedges++] = ret.numvertices - 1; ret.numvertices++;
-		    }
-
-
-		} else if (type[i] == TYPE_QUADRADIC) {
-
-		    float bx = x[i+1] - 2 * c1x[i] + x[i];
-		    float cx = 2 * c1x[i] - 2 * x[i];
-		    float dx = x[i];
-		    float by = y[i+1] - 2 * c1y[i] + y[i];
-		    float cy = 2 * c1y[i] - 2 * y[i];
-		    float dy = y[i];
-		    	
-                    for(float t=0; t<1; t += 1 / (float)NUMSTEPS) {
-			float rx = bx * t * t + cx * t + dx;
-			float ry = by * t * t + cy * t + dy;
-                        ret.x[ret.numvertices] = (int)Math.round(a.multiply_px(rx, ry));
-                        ret.y[ret.numvertices] = (int)Math.round(a.multiply_py(rx, ry));
-                        ret.edges[ret.numedges++] = ret.numvertices - 1; ret.numvertices++;
-		    }
-
-		}
-
-	    }
-            
-            if (ret.numedges > 0) ret.sort(0, ret.numedges - 1, false);
-            return ret;
-	}
-
-        protected void parseSingleCommandAndArguments(PathTokenizer t, char command, boolean relative) {
-            if (numvertices == 0 && command != 'm') throw new RuntimeException("first command MUST be an 'm'");
-            if (numvertices > x.length - 2) {
-                float[] new_x = new float[x.length * 2]; System.arraycopy(x, 0, new_x, 0, x.length); x = new_x;
-                float[] new_y = new float[y.length * 2]; System.arraycopy(y, 0, new_y, 0, y.length); y = new_y;
-            }
-            switch(command) {
+    protected void parseSingleCommandAndArguments(Tokenizer t, char command, boolean relative) {
+        if (tail==null && command!='m') throw new RuntimeException("first command MUST be an 'm', not a " + command);
+        switch(command) {
             case 'z': {
-		int where;
-                type[numvertices-1] = TYPE_LINETO;
-		for(where = numvertices - 1; where > 0; where--)
-		    if (type[where - 1] == TYPE_MOVETO) break;
-                x[numvertices] = x[where];
-                y[numvertices] = y[where];
-                numvertices++;
+                Curve c;
+                for(c = tail.prev; c != null && !(c instanceof Move); c = c.prev);
+                Line ret = new Line();
+                ret.x = c.x;
+                ret.y = c.y;
+                add(ret);
+                Move mov = new Move();
+                mov.x = ret.x;
+                mov.y = ret.y;
+                add(mov);
                 closed = true;
+                // FIXME: actually, we should search back to the last 'z' or 'm', not just 'm'
                 break;
             }
 
             case 'm': {
-                if (numvertices > 0) type[numvertices-1] = TYPE_MOVETO;
-		x[numvertices] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-		y[numvertices] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-		numvertices++;
+                // feature: collapse consecutive movetos
+                Move ret = new Move();
+                ret.x = t.parseFloat() + (relative ? tail.y : 0);
+                ret.y = t.parseFloat() + (relative ? tail.y : 0);
+                add(ret);
                 break;
             }
 
             case 'l': case 'h': case 'v': {
-                type[numvertices-1] = TYPE_LINETO;
                 float first = t.parseFloat(), second;
-                if (command == 'h') {
-                    second = relative ? 0 : y[numvertices - 1];
-                } else if (command == 'v') {
-                    second = first; first = relative ? 0 : x[numvertices - 1];
-                } else {
-                    second = t.parseFloat();
-                }
-                x[numvertices] = first + (relative ? x[numvertices - 1] : 0);
-                y[numvertices] = second + (relative ? y[numvertices - 1] : 0);
-                numvertices++;
+                if (command == 'h')      second = relative ? 0 : tail.y;
+                else if (command == 'v') { second = first; first = relative ? 0 : tail.x; }
+                else                     second = t.parseFloat();
+                Line ret = new Line();
+                ret.x = first + (relative ? tail.x : 0);
+                ret.y = second + (relative ? tail.y : 0);
+                add(ret);
                 break;
             }
             
             case 'a': {
-		type[numvertices-1] = TYPE_ARCTO;
-		c1x[numvertices-1] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-		c1y[numvertices-1] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-		c2x[numvertices-1] = (t.parseFloat() / 360) * 2 * PI;
-		c2y[numvertices-1] = (((int)t.parseFloat()) << 1) | (int)t.parseFloat();
-		x[numvertices] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-		y[numvertices] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-                numvertices++;
+                Arc ret = new Arc();
+                ret.c1x = t.parseFloat() + (relative ? tail.x : 0);
+                ret.c1y = t.parseFloat() + (relative ? tail.y : 0);
+                ret.c2x = (t.parseFloat() / 360) * 2 * PI;
+                ret.c2y = t.parseFloat();
+                ret.x = t.parseFloat() + (relative ? tail.x : 0);
+                ret.y = t.parseFloat() + (relative ? tail.y : 0);
+                add(ret);
                 break;
             }
 
             case 's': case 'c': {
-                type[numvertices-1] = TYPE_CUBIC;
+                Bezier ret = new Bezier();
                 if (command == 'c') {
-                    c1x[numvertices-1] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-                    c1y[numvertices-1] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-                } else if (numvertices > 1 && type[numvertices-2] == TYPE_CUBIC) {
-                    c1x[numvertices-1] = 2 * x[numvertices - 1] - c2x[numvertices-2];
-                    c1y[numvertices-1] = 2 * y[numvertices - 1] - c2y[numvertices-2];
+                    tail.c1x = t.parseFloat() + (relative ? tail.x : 0);
+                    tail.c1y = t.parseFloat() + (relative ? tail.y : 0);
+                } else if (head != null && tail instanceof Bezier) {
+                    tail.c1x = 2 * tail.x-((Bezier)tail).c2x;
+                    tail.c1y = 2 * tail.y-((Bezier)tail).c2x;
                 } else {
-                    c1x[numvertices-1] = x[numvertices-1];
-                    c1y[numvertices-1] = y[numvertices-1];
+                    tail.c1x = tail.x;
+                    tail.c1y = tail.y;
                 }
-                c2x[numvertices-1] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-                c2y[numvertices-1] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-		x[numvertices] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-		y[numvertices] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-                numvertices++;
+                tail.c2x = t.parseFloat() + (relative ? tail.x : 0);
+                tail.c2y = t.parseFloat() + (relative ? tail.y : 0);
+		ret.x = t.parseFloat() + (relative ? tail.x : 0);
+		ret.y = t.parseFloat() + (relative ? tail.y : 0);
+                add(ret);
                 break;
             }
 
             case 't': case 'q': {
-                type[numvertices-1] = TYPE_QUADRADIC;
+                QuadBezier ret = new QuadBezier();
                 if (command == 'q') {
-                    c1x[numvertices-1] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-                    c1y[numvertices-1] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-                } else if (numvertices > 1 && type[numvertices-2] == TYPE_QUADRADIC) {
-                    c1x[numvertices-1] = 2 * x[numvertices - 1] - c1x[numvertices-2];
-                    c1y[numvertices-1] = 2 * y[numvertices - 1] - c1y[numvertices-2];
+                    tail.c1x = t.parseFloat() + (relative ? tail.x : 0);
+                    tail.c1y = t.parseFloat() + (relative ? tail.y : 0);
+                } else if (head != null && tail instanceof QuadBezier) {
+                    tail.c1x = 2 * tail.x-((QuadBezier)tail).c1x;
+                    tail.c1y = 2 * tail.y-((QuadBezier)tail).c1y;
                 } else {
-                    c1x[numvertices-1] = x[numvertices-1];
-                    c1y[numvertices-1] = y[numvertices-1];
+                    tail.c1x = tail.x;
+                    tail.c1y = tail.y;
                 }
-                x[numvertices] = t.parseFloat() + (relative ? x[numvertices - 1] : 0);
-                y[numvertices] = t.parseFloat() + (relative ? y[numvertices - 1] : 0);
-                numvertices++;
+                ret.x = t.parseFloat() + (relative ? tail.x : 0);
+                ret.y = t.parseFloat() + (relative ? tail.y : 0);
+                add(ret);
                 break;
             }
 
             default:
-                // FIXME
-	    }
-
-            /*
-            // invariant: after this loop, no two lines intersect other than at a vertex
-            // FIXME: cleanup
-            int index = numvertices - 2;
-            for(int i=0; i<Math.min(numvertices - 3, index); i++) {
-                for(int j = index; j < numvertices - 1; j++) {
-
-                    // I'm not sure how to deal with vertical lines...
-                    if (x[i+1] == x[i] || x[j+1] == x[j]) continue;
-			
-                    float islope = (y[i+1] - y[i]) / (x[i+1] - x[i]);
-                    float jslope = (y[j+1] - y[j]) / (x[j+1] - x[j]);
-                    if (islope == jslope) continue;   // parallel lines can't intersect
-			
-                    float _x = (islope * x[i] - jslope * x[j] + y[j] - y[i]) / (islope - jslope);
-                    float _y = islope * (_x - x[i]) + y[i];
-			
-                    if (_x > Math.min(x[i+1], x[i]) && _x < Math.max(x[i+1], x[i]) &&
-                        _x > Math.min(x[j+1], x[j]) && _x < Math.max(x[j+1], x[j])) {
-                        // FIXME: something's not right in here.  See if we can do without fracturing line 'i'.
-                        for(int k = ++numvertices; k>i; k--) { x[k] = x[k - 1]; y[k] = y[k - 1]; }
-                        x[i+1] = _x;
-                        y[i+1] = _y;
-                        x[numvertices] = x[numvertices - 1];  x[numvertices - 1] = _x;
-                        y[numvertices] = y[numvertices - 1];  y[numvertices - 1] = _y;
-                        edges[numedges++] = numvertices - 1; numvertices++;
-                        index++;
-                        break;  // actually 'continue' the outermost loop
-                    }
-                }
-            }
-            */
-
-	}
-    }
-
-
-
-
-    // Rasterized Vector Path //////////////////////////////////////////////////////////////////////////////
-    
-    /** a vector path */
-    public static class RasterPath {
-
-	// the vertices of this path
-	int[] x = new int[DEFAULT_PATHLEN];
-	int[] y = new int[DEFAULT_PATHLEN];
-	int numvertices = 0;
-
-        /**
-         *  A list of the vertices on this path which *start* an *edge* (rather than a moveto), sorted by increasing y.
-         *  example: x[edges[1]],y[edges[1]] - x[edges[i]+1],y[edges[i]+1] is the second-topmost edge
-         *  note that if x[i],y[i] - x[i+1],y[i+1] is a MOVETO, then no element in edges will be equal to i
-         */
-	int[] edges = new int[DEFAULT_PATHLEN];
-        int numedges = 0;
-
-        /** translate a rasterized path */
-        public void translate(int dx, int dy) { for(int i=0; i<numvertices; i++) { x[i] += dx; y[i] += dy; } }
-
-        /** simple quicksort, from http://sourceforge.net/snippet/detail.php?type=snippet&id=100240 */
-        int sort(int left, int right, boolean partition) {
-	    if (partition) {
-		int i, j, middle;
-		middle = (left + right) / 2;
-		int s = edges[right]; edges[right] = edges[middle]; edges[middle] = s;
-		for (i = left - 1, j = right; ; ) {
-		    while (y[edges[++i]] < y[edges[right]]);
-		    while (j > left && y[edges[--j]] > y[edges[right]]);
-		    if (i >= j) break;
-		    s = edges[i]; edges[i] = edges[j]; edges[j] = s;
-		}
-		s = edges[right]; edges[right] = edges[i]; edges[i] = s;
-		return i;
-	    } else {
-		if (left >= right) return 0;
-		int p = sort(left, right, true);
-		sort(left, p - 1, false);
-		sort(p + 1, right, false);
-		return 0;
-	    }
-        }
-
-        /** finds the x value at which the line intercepts the line y=_y */
-	private int intercept(int i, float _y, boolean includeTop, boolean includeBottom) {
-            if (includeTop ? (_y < Math.min(y[i], y[i+1])) : (_y <= Math.min(y[i], y[i+1])))
-                return Integer.MIN_VALUE;
-            if (includeBottom ? (_y > Math.max(y[i], y[i+1])) : (_y >= Math.max(y[i], y[i+1])))
-                return Integer.MIN_VALUE;
-	    return (int)Math.round((((float)(x[i + 1] - x[i])) /
-                                    ((float)(y[i + 1] - y[i])) ) * ((float)(_y - y[i])) + x[i]);
-	}
-
-        /** fill the interior of the path */
-	public void fill(PixelBuffer buf, Paint paint) {
-            if (numedges == 0) return;
-	    int y0 = y[edges[0]], y1 = y0;
-	    boolean useEvenOdd = false;
-
-            // we iterate over all endpoints in increasing y-coordinate order
-            for(int index = 1; index<numedges; index++) {
-                int count = 0;
-
-                // we now examine the horizontal band between y=y0 and y=y1
-		y0 = y1;
-		y1 = y[edges[index]];
-                if (y0 == y1) continue;
- 
-                // within this band, we iterate over all edges
-                int x0 = Integer.MIN_VALUE;
-                int leftSegment = -1;
-                while(true) {
-                    int x1 = Integer.MAX_VALUE;
-                    int rightSegment = Integer.MAX_VALUE;
-                    for(int i=0; i<numedges; i++) {
-                        if (y[edges[i]] == y[edges[i]+1]) continue; // ignore horizontal lines; they are irrelevant.
-                        // we order the segments by the x-coordinate of their midpoint;
-                        // since segments cannot intersect, this is a well-ordering
-                        int i0 = intercept(edges[i], y0, true, false);
-                        int i1 = intercept(edges[i], y1, false, true);
-                        if (i0 == Integer.MIN_VALUE || i1 == Integer.MIN_VALUE) continue;
-                        int midpoint = i0 + i1;
-                        if (midpoint < x0) continue;
-                        if (midpoint == x0 && i <= leftSegment) continue;
-                        if (midpoint > x1) continue;
-                        if (midpoint == x1 && i >= rightSegment) continue;
-                        rightSegment = i;
-                        x1 = midpoint;
-                    }
-                    if (leftSegment == rightSegment || rightSegment == Integer.MAX_VALUE) break;
-                    if (leftSegment != -1)
-                        if ((useEvenOdd && count % 2 != 0) || (!useEvenOdd && count != 0))
-                            paint.fillTrapezoid(intercept(edges[leftSegment], y0, true, true),
-                                                intercept(edges[rightSegment], y0, true, true), y0,
-                                                intercept(edges[leftSegment], y1, true, true),
-                                                intercept(edges[rightSegment], y1, true, true), y1,
-                                                buf);
-                    if (useEvenOdd) count++;
-                    else count += (y[edges[rightSegment]] < y[edges[rightSegment]+1]) ? -1 : 1;
-                    leftSegment = rightSegment; x0 = x1;
-                }
-            }
-        }
-        
-        /** stroke the outline of the path */
-        public void stroke(PixelBuffer buf, int width, int color) { stroke(buf, width, color, null, 0, 0); }
-        public void stroke(PixelBuffer buf, int width, int color, String dashArray, int dashOffset, float segLength) {
-
-            if (dashArray == null) {
-                for(int i=0; i<numedges; i++)
-                    buf.drawLine((int)x[edges[i]],
-                                 (int)y[edges[i]], (int)x[edges[i]+1], (int)y[edges[i]+1], width, color, false);
-                return;
-            }
-
-            float ratio = 1;
-            if (segLength > 0) {
-                float actualLength = 0;
-                for(int i=0; i<numvertices; i++) {
-                    // skip over MOVETOs -- they do not contribute to path length
-                    if (x[i] == x[i+1] && y[i] == y[i+1]) continue;
-                    if (x[i+1] == x[i+2] && y[i+1] == y[i+2]) continue;
-                    int x1 = x[i];
-                    int x2 = x[i + 1];
-                    int y1 = y[i];
-                    int y2 = y[i + 1];
-                    actualLength += java.lang.Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
-                }
-                ratio = actualLength / segLength;
-            }
-            PathTokenizer pt = new PathTokenizer(dashArray);
-            Vector v = new Vector();
-            while (pt.hasMoreTokens()) v.addElement(new Float(pt.parseFloat()));
-            float[] dashes = new float[v.size() % 2 == 0 ? v.size() : 2 * v.size()];
-            for(int i=0; i<dashes.length; i++) dashes[i] = ((Float)v.elementAt(i % v.size())).floatValue();
-            int dashpos = dashOffset;
-            boolean on = dashpos % 2 == 0;
-            for(int i=0; i<numvertices; i++) {
-                // skip over MOVETOs -- they do not contribute to path length
-                if (x[i] == x[i+1] && y[i] == y[i+1]) continue;
-                if (x[i+1] == x[i+2] && y[i+1] == y[i+2]) continue;
-                int x1 = (int)x[i];
-                int x2 = (int)x[i + 1];
-                int y1 = (int)y[i];
-                int y2 = (int)y[i + 1];
-                float segmentLength = (float)java.lang.Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
-                int _x1 = x1, _y1 = y1;
-                float pos = 0;
-                do {
-                    pos = Math.min(segmentLength, pos + dashes[dashpos] * ratio);
-                    if (pos != segmentLength) dashpos = (dashpos + 1) % dashes.length;
-                    int _x2 = (int)((x2 * pos + x1 * (segmentLength - pos)) / segmentLength);
-                    int _y2 = (int)((y2 * pos + y1 * (segmentLength - pos)) / segmentLength);
-                    if (on) buf.drawLine(_x1, _y1, _x2, _y2, width, color, false);
-                    on = !on;
-                    _x1 = _x2; _y1 = _y2;
-                } while(pos < segmentLength);
-            }
-	}
-
-        // FEATURE: make this faster and cache it; also deal with negative coordinates
-        public int boundingBoxWidth() {
-            int ret = 0;
-            for(int i=0; i<numvertices; i++) ret = Math.max(ret, x[i]);
-            return ret;
         }
 
-        // FEATURE: make this faster and cache it; also deal with negative coordinates
-        public int boundingBoxHeight() {
-            int ret = 0;
-            for(int i=0; i<numvertices; i++) ret = Math.max(ret, y[i]);
-            return ret;
-        }
-    }
-    
-    
-    // Paint //////////////////////////////////////////////////////////////////////////////
-
-    public static interface Paint {
-	public abstract void
-            fillTrapezoid(int tx1, int tx2, int ty1, int tx3, int tx4, int ty2, PixelBuffer buf);
-    }
-
-    public static class SingleColorPaint implements Paint {
-        int color;
-        public SingleColorPaint(int color) { this.color = color; }
-        public void fillTrapezoid(int x1, int x2, int y1, int x3, int x4, int y2, PixelBuffer buf) {
-            buf.fillTrapezoid(x1, x2, y1, x3, x4, y2, color);
-        }
     }
 
 }
-
-
-
-
-
-
-
-
-
-    /*
-    public static abstract class GradientPaint extends Paint {
-        public GradientPaint(boolean reflect, boolean repeat, Affine gradientTransform,
-                             int[] stop_colors, float[] stop_offsets) {
-            this.reflect = reflect; this.repeat = repeat;
-            this.gradientTransform = gradientTransform;
-            this.stop_colors = stop_colors;
-            this.stop_offsets = stop_offsets;
-        }
-        Affine gradientTransform = Affine.identity();
-	boolean useBoundingBox = false;            // FIXME not supported
-	boolean patternUseBoundingBox = false;     // FIXME not supported
-
-	// it's invalid for both of these to be true
-	boolean reflect = false;                   // FIXME not supported
-	boolean repeat = false;                    // FIXME not supported
-	int[] stop_colors;
-	float[] stop_offsets;
-
-	public void fillTrapezoid(float tx1, float tx2, float ty1, float tx3, float tx4, float ty2, PixelBuffer buf) {
-            Affine a = buf.a;
-	    Affine inverse = a.copy().invert();
-	    float slope1 = (tx3 - tx1) / (ty2 - ty1);
-	    float slope2 = (tx4 - tx2) / (ty2 - ty1);
-	    for(float y=ty1; y<ty2; y++) {
-		float _x1 = (y - ty1) * slope1 + tx1;
-		float _x2 = (y - ty1) * slope2 + tx2;
-		if (_x1 > _x2) { float _x0 = _x1; _x1 = _x2; _x2 = _x0; }
-
-		for(float x=_x1; x<_x2; x++) {
-		    
-		    float distance = isLinear ?
-			// length of projection of <x,y> onto the gradient vector == {<x,y> \dot {grad \over |grad|}}
-			(x * (x2 - x1) + y * (y2 - y1)) / (float)Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1)) :
-			
-			// radial form is simple! FIXME, not quite right
-			(float)Math.sqrt((x - cx) * (x - cx) + (y - cy) * (y - cy));
-			
-		    // FIXME: offsets are 0..1, not 0..length(gradient)
-		    int i = 0; for(; i<stop_offsets.length; i++) if (distance < stop_offsets[i]) break;
-
-		    // FIXME: handle points beyond the bounds
-		    if (i < 0 || i >= stop_offsets.length) continue;
-
-		    // gradate from offsets[i - 1] to offsets[i]
-		    float percentage = ((distance - stop_offsets[i - 1]) / (stop_offsets[i] - stop_offsets[i - 1]));
-
-		    int a = (int)((((stop_colors[i] >> 24) & 0xff) - ((stop_colors[i - 1] >> 24) & 0xff)) * percentage) +
-			((stop_colors[i - 1] >> 24) & 0xff);
-		    int r = (int)((((stop_colors[i] >> 16) & 0xff) - ((stop_colors[i - 1] >> 16) & 0xff)) * percentage) +
-			((stop_colors[i - 1] >> 16) & 0xff);
-		    int g = (int)((((stop_colors[i] >> 8) & 0xff)  - ((stop_colors[i - 1] >> 8) & 0xff)) * percentage) +
-			((stop_colors[i - 1] >> 8) & 0xff);
-		    int b = (int)((((stop_colors[i] >> 0) & 0xff)  - ((stop_colors[i - 1] >> 0) & 0xff)) * percentage) +
-			((stop_colors[i - 1] >> 0) & 0xff);
-		    int argb = (a << 24) | (r << 16) | (g << 8) | b;
-		    buf.drawPoint((int)x, (int)Math.floor(y), argb);
-		}
-	    }
-	}
-    }
-
-    public static class LinearGradientPaint extends GradientPaint {
-        public LinearGradientPaint(float x1, float y1, float x2, float y2, boolean reflect, boolean repeat,
-                                   Affine gradientTransform,  int[] stop_colors, float[] stop_offsets) {
-            super(reflect, repeat, gradientTransform, stop_colors, stop_offsets);
-            this.x1 = x1; this.x2 = x2; this.y1 = y1; this.y2 = y2;
-        }
-	float x1 = 0, y1 = 0, x2 = 300, y2 = 300;
-    }
-
-    public static class RadialGradientPaint extends GradientPaint {
-        public RadialGradientPaint(float cx, float cy, float fx, float fy, float r, boolean reflect, boolean repeat,
-                             Affine gradientTransform, int[] stop_colors, float[] stop_offsets) {
-            super(reflect, repeat, gradientTransform, stop_colors, stop_offsets);
-            this.cx = cx; this.cy = cy; this.fx = fx; this.fy = fy; this.r = r;
-        }
-            
-	float cx, cy, r, fx, fy;
-
-    }
-    */
-