propane 3.1.0.pre-java → 3.2.0-java

data/src/main/java/processing/awt/PShapeJava2D.java

@@ -1,5 +1,3 @@
-/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-
 /*
   Part of the Processing project - http://processing.org
 
@@ -18,8 +16,7 @@
   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
-*/
-
+ */
 package processing.awt;
 
 import java.awt.Paint;
@@ -38,50 +35,48 @@ import processing.core.PGraphics;
 import processing.core.PShapeSVG;
 import processing.data.*;
 
-
 /**
- * Implements features for PShape that are specific to AWT and Java2D.
- * At the moment, this is gradients and java.awt.Paint handling.
+ * Implements features for PShape that are specific to AWT and Java2D. At the
+ * moment, this is gradients and java.awt.Paint handling.
  */
 public class PShapeJava2D extends PShapeSVG {
-  Paint strokeGradientPaint;
-  Paint fillGradientPaint;
 
+    Paint strokeGradientPaint;
+    Paint fillGradientPaint;
 
-  public PShapeJava2D(XML svg) {
-    super(svg);
-  }
-
-
-  public PShapeJava2D(PShapeSVG parent, XML properties, boolean parseKids) {
-    super(parent, properties, parseKids);
-  }
+    public PShapeJava2D(XML svg) {
+        super(svg);
+    }
 
+    public PShapeJava2D(PShapeSVG parent, XML properties, boolean parseKids) {
+        super(parent, properties, parseKids);
+    }
 
-  @Override
-  protected void setParent(PShapeSVG parent) {
-    super.setParent(parent);
+    @Override
+    protected void setParent(PShapeSVG parent) {
+        super.setParent(parent);
 
-    if (parent instanceof PShapeJava2D) {
-      PShapeJava2D pj = (PShapeJava2D) parent;
-      fillGradientPaint = pj.fillGradientPaint;
-      strokeGradientPaint = pj.strokeGradientPaint;
+        if (parent instanceof PShapeJava2D) {
+            PShapeJava2D pj = (PShapeJava2D) parent;
+            fillGradientPaint = pj.fillGradientPaint;
+            strokeGradientPaint = pj.strokeGradientPaint;
 
-    } else {  // parent is null or not Java2D
-      fillGradientPaint = null;
-      strokeGradientPaint = null;
+        } else {  // parent is null or not Java2D
+            fillGradientPaint = null;
+            strokeGradientPaint = null;
+        }
     }
-  }
-
 
-  /** Factory method for subclasses. */
-  @Override
-  protected PShapeSVG createShape(PShapeSVG parent, XML properties, boolean parseKids) {
-    return new PShapeJava2D(parent, properties, parseKids);
-  }
+    /**
+     * Factory method for subclasses.
+     */
+    @Override
+    protected PShapeSVG createShape(PShapeSVG parent, XML properties, boolean parseKids) {
+        return new PShapeJava2D(parent, properties, parseKids);
+    }
 
 
-  /*
+    /*
   @Override
   public void setColor(String colorText, boolean isFill) {
     super.setColor(colorText, isFill);
@@ -93,230 +88,239 @@ public class PShapeJava2D extends PShapeSVG {
       strokeGradientPaint = calcGradientPaint(strokeGradient);
     }
   }
-  */
-
-
-  static class LinearGradientPaint implements Paint {
-    float x1, y1, x2, y2;
-    float[] offset;
-    int[] color;
-    int count;
-    float opacity;
-
-    public LinearGradientPaint(float x1, float y1, float x2, float y2,
-                               float[] offset, int[] color, int count,
-                               float opacity) {
-      this.x1 = x1;
-      this.y1 = y1;
-      this.x2 = x2;
-      this.y2 = y2;
-      this.offset = offset;
-      this.color = color;
-      this.count = count;
-      this.opacity = opacity;
-    }
-
-    public PaintContext createContext(ColorModel cm,
-                                      Rectangle deviceBounds, Rectangle2D userBounds,
-                                      AffineTransform xform, RenderingHints hints) {
-      Point2D t1 = xform.transform(new Point2D.Float(x1, y1), null);
-      Point2D t2 = xform.transform(new Point2D.Float(x2, y2), null);
-      return new LinearGradientContext((float) t1.getX(), (float) t1.getY(),
-                                       (float) t2.getX(), (float) t2.getY());
-    }
-
-    public int getTransparency() {
-      return TRANSLUCENT;  // why not.. rather than checking each color
-    }
-
-    public class LinearGradientContext implements PaintContext {
-      int ACCURACY = 2;
-      float tx1, ty1, tx2, ty2;
-
-      public LinearGradientContext(float tx1, float ty1, float tx2, float ty2) {
-        this.tx1 = tx1;
-        this.ty1 = ty1;
-        this.tx2 = tx2;
-        this.ty2 = ty2;
-      }
+     */
+    static class LinearGradientPaint implements Paint {
+
+        float x1, y1, x2, y2;
+        float[] offset;
+        int[] color;
+        int count;
+        float opacity;
+
+        public LinearGradientPaint(float x1, float y1, float x2, float y2,
+                float[] offset, int[] color, int count,
+                float opacity) {
+            this.x1 = x1;
+            this.y1 = y1;
+            this.x2 = x2;
+            this.y2 = y2;
+            this.offset = offset;
+            this.color = color;
+            this.count = count;
+            this.opacity = opacity;
+        }
 
-      public void dispose() { }
+        public PaintContext createContext(ColorModel cm,
+                Rectangle deviceBounds, Rectangle2D userBounds,
+                AffineTransform xform, RenderingHints hints) {
+            Point2D t1 = xform.transform(new Point2D.Float(x1, y1), null);
+            Point2D t2 = xform.transform(new Point2D.Float(x2, y2), null);
+            return new LinearGradientContext((float) t1.getX(), (float) t1.getY(),
+                    (float) t2.getX(), (float) t2.getY());
+        }
 
-      public ColorModel getColorModel() { return ColorModel.getRGBdefault(); }
+        public int getTransparency() {
+            return TRANSLUCENT;  // why not.. rather than checking each color
+        }
 
-      public Raster getRaster(int x, int y, int w, int h) {
-        WritableRaster raster =
-          getColorModel().createCompatibleWritableRaster(w, h);
+        public class LinearGradientContext implements PaintContext {
 
-        int[] data = new int[w * h * 4];
+            int ACCURACY = 2;
+            float tx1, ty1, tx2, ty2;
 
-        // make normalized version of base vector
-        float nx = tx2 - tx1;
-        float ny = ty2 - ty1;
-        float len = (float) Math.sqrt(nx*nx + ny*ny);
-        if (len != 0) {
-          nx /= len;
-          ny /= len;
-        }
+            public LinearGradientContext(float tx1, float ty1, float tx2, float ty2) {
+                this.tx1 = tx1;
+                this.ty1 = ty1;
+                this.tx2 = tx2;
+                this.ty2 = ty2;
+            }
 
-        int span = (int) PApplet.dist(tx1, ty1, tx2, ty2) * ACCURACY;
-        if (span <= 0) {
-          //System.err.println("span is too small");
-          // annoying edge case where the gradient isn't legit
-          int index = 0;
-          for (int j = 0; j < h; j++) {
-            for (int i = 0; i < w; i++) {
-              data[index++] = 0;
-              data[index++] = 0;
-              data[index++] = 0;
-              data[index++] = 255;
+            public void dispose() {
             }
-          }
 
-        } else {
-          int[][] interp = new int[span][4];
-          int prev = 0;
-          for (int i = 1; i < count; i++) {
-            int c0 = color[i-1];
-            int c1 = color[i];
-            int last = (int) (offset[i] * (span-1));
-            //System.out.println("last is " + last);
-            for (int j = prev; j <= last; j++) {
-              float btwn = PApplet.norm(j, prev, last);
-              interp[j][0] = (int) PApplet.lerp((c0 >> 16) & 0xff, (c1 >> 16) & 0xff, btwn);
-              interp[j][1] = (int) PApplet.lerp((c0 >> 8) & 0xff, (c1 >> 8) & 0xff, btwn);
-              interp[j][2] = (int) PApplet.lerp(c0 & 0xff, c1 & 0xff, btwn);
-              interp[j][3] = (int) (PApplet.lerp((c0 >> 24) & 0xff, (c1 >> 24) & 0xff, btwn) * opacity);
-              //System.out.println(j + " " + interp[j][0] + " " + interp[j][1] + " " + interp[j][2]);
+            public ColorModel getColorModel() {
+                return ColorModel.getRGBdefault();
             }
-            prev = last;
-          }
-
-          int index = 0;
-          for (int j = 0; j < h; j++) {
-            for (int i = 0; i < w; i++) {
-              //float distance = 0; //PApplet.dist(cx, cy, x + i, y + j);
-              //int which = PApplet.min((int) (distance * ACCURACY), interp.length-1);
-              float px = (x + i) - tx1;
-              float py = (y + j) - ty1;
-              // distance up the line is the dot product of the normalized
-              // vector of the gradient start/stop by the point being tested
-              int which = (int) ((px*nx + py*ny) * ACCURACY);
-              if (which < 0) which = 0;
-              if (which > interp.length-1) which = interp.length-1;
-              //if (which > 138) System.out.println("grabbing " + which);
-
-              data[index++] = interp[which][0];
-              data[index++] = interp[which][1];
-              data[index++] = interp[which][2];
-              data[index++] = interp[which][3];
+
+            public Raster getRaster(int x, int y, int w, int h) {
+                WritableRaster raster
+                        = getColorModel().createCompatibleWritableRaster(w, h);
+
+                int[] data = new int[w * h * 4];
+
+                // make normalized version of base vector
+                float nx = tx2 - tx1;
+                float ny = ty2 - ty1;
+                float len = (float) Math.sqrt(nx * nx + ny * ny);
+                if (len != 0) {
+                    nx /= len;
+                    ny /= len;
+                }
+
+                int span = (int) PApplet.dist(tx1, ty1, tx2, ty2) * ACCURACY;
+                if (span <= 0) {
+                    //System.err.println("span is too small");
+                    // annoying edge case where the gradient isn't legit
+                    int index = 0;
+                    for (int j = 0; j < h; j++) {
+                        for (int i = 0; i < w; i++) {
+                            data[index++] = 0;
+                            data[index++] = 0;
+                            data[index++] = 0;
+                            data[index++] = 255;
+                        }
+                    }
+
+                } else {
+                    int[][] interp = new int[span][4];
+                    int prev = 0;
+                    for (int i = 1; i < count; i++) {
+                        int c0 = color[i - 1];
+                        int c1 = color[i];
+                        int last = (int) (offset[i] * (span - 1));
+                        //System.out.println("last is " + last);
+                        for (int j = prev; j <= last; j++) {
+                            float btwn = PApplet.norm(j, prev, last);
+                            interp[j][0] = (int) PApplet.lerp((c0 >> 16) & 0xff, (c1 >> 16) & 0xff, btwn);
+                            interp[j][1] = (int) PApplet.lerp((c0 >> 8) & 0xff, (c1 >> 8) & 0xff, btwn);
+                            interp[j][2] = (int) PApplet.lerp(c0 & 0xff, c1 & 0xff, btwn);
+                            interp[j][3] = (int) (PApplet.lerp((c0 >> 24) & 0xff, (c1 >> 24) & 0xff, btwn) * opacity);
+                            //System.out.println(j + " " + interp[j][0] + " " + interp[j][1] + " " + interp[j][2]);
+                        }
+                        prev = last;
+                    }
+
+                    int index = 0;
+                    for (int j = 0; j < h; j++) {
+                        for (int i = 0; i < w; i++) {
+                            //float distance = 0; //PApplet.dist(cx, cy, x + i, y + j);
+                            //int which = PApplet.min((int) (distance * ACCURACY), interp.length-1);
+                            float px = (x + i) - tx1;
+                            float py = (y + j) - ty1;
+                            // distance up the line is the dot product of the normalized
+                            // vector of the gradient start/stop by the point being tested
+                            int which = (int) ((px * nx + py * ny) * ACCURACY);
+                            if (which < 0) {
+                                which = 0;
+                            }
+                            if (which > interp.length - 1) {
+                                which = interp.length - 1;
+                            }
+                            //if (which > 138) System.out.println("grabbing " + which);
+
+                            data[index++] = interp[which][0];
+                            data[index++] = interp[which][1];
+                            data[index++] = interp[which][2];
+                            data[index++] = interp[which][3];
+                        }
+                    }
+                }
+                raster.setPixels(0, 0, w, h, data);
+
+                return raster;
             }
-          }
         }
-        raster.setPixels(0, 0, w, h, data);
-
-        return raster;
-      }
     }
-  }
 
+    static class RadialGradientPaint implements Paint {
+
+        float cx, cy, radius;
+        float[] offset;
+        int[] color;
+        int count;
+        float opacity;
+
+        public RadialGradientPaint(float cx, float cy, float radius,
+                float[] offset, int[] color, int count,
+                float opacity) {
+            this.cx = cx;
+            this.cy = cy;
+            this.radius = radius;
+            this.offset = offset;
+            this.color = color;
+            this.count = count;
+            this.opacity = opacity;
+        }
 
-  static class RadialGradientPaint implements Paint {
-    float cx, cy, radius;
-    float[] offset;
-    int[] color;
-    int count;
-    float opacity;
-
-    public RadialGradientPaint(float cx, float cy, float radius,
-                               float[] offset, int[] color, int count,
-                               float opacity) {
-      this.cx = cx;
-      this.cy = cy;
-      this.radius = radius;
-      this.offset = offset;
-      this.color = color;
-      this.count = count;
-      this.opacity = opacity;
-    }
+        public PaintContext createContext(ColorModel cm,
+                Rectangle deviceBounds, Rectangle2D userBounds,
+                AffineTransform xform, RenderingHints hints) {
+            return new RadialGradientContext();
+        }
 
-    public PaintContext createContext(ColorModel cm,
-                                      Rectangle deviceBounds, Rectangle2D userBounds,
-                                      AffineTransform xform, RenderingHints hints) {
-      return new RadialGradientContext();
-    }
+        public int getTransparency() {
+            return TRANSLUCENT;
+        }
 
-    public int getTransparency() {
-      return TRANSLUCENT;
-    }
+        public class RadialGradientContext implements PaintContext {
 
-    public class RadialGradientContext implements PaintContext {
-      int ACCURACY = 5;
-
-      public void dispose() {}
-
-      public ColorModel getColorModel() { return ColorModel.getRGBdefault(); }
-
-      public Raster getRaster(int x, int y, int w, int h) {
-        WritableRaster raster =
-          getColorModel().createCompatibleWritableRaster(w, h);
-
-        int span = (int) radius * ACCURACY;
-        int[][] interp = new int[span][4];
-        int prev = 0;
-        for (int i = 1; i < count; i++) {
-          int c0 = color[i-1];
-          int c1 = color[i];
-          int last = (int) (offset[i] * (span - 1));
-          for (int j = prev; j <= last; j++) {
-            float btwn = PApplet.norm(j, prev, last);
-            interp[j][0] = (int) PApplet.lerp((c0 >> 16) & 0xff, (c1 >> 16) & 0xff, btwn);
-            interp[j][1] = (int) PApplet.lerp((c0 >> 8) & 0xff, (c1 >> 8) & 0xff, btwn);
-            interp[j][2] = (int) PApplet.lerp(c0 & 0xff, c1 & 0xff, btwn);
-            interp[j][3] = (int) (PApplet.lerp((c0 >> 24) & 0xff, (c1 >> 24) & 0xff, btwn) * opacity);
-          }
-          prev = last;
-        }
+            int ACCURACY = 5;
 
-        int[] data = new int[w * h * 4];
-        int index = 0;
-        for (int j = 0; j < h; j++) {
-          for (int i = 0; i < w; i++) {
-            float distance = PApplet.dist(cx, cy, x + i, y + j);
-            int which = PApplet.min((int) (distance * ACCURACY), interp.length-1);
-
-            data[index++] = interp[which][0];
-            data[index++] = interp[which][1];
-            data[index++] = interp[which][2];
-            data[index++] = interp[which][3];
-          }
-        }
-        raster.setPixels(0, 0, w, h, data);
+            public void dispose() {
+            }
 
-        return raster;
-      }
-    }
-  }
+            public ColorModel getColorModel() {
+                return ColorModel.getRGBdefault();
+            }
 
+            public Raster getRaster(int x, int y, int w, int h) {
+                WritableRaster raster
+                        = getColorModel().createCompatibleWritableRaster(w, h);
+
+                int span = (int) radius * ACCURACY;
+                int[][] interp = new int[span][4];
+                int prev = 0;
+                for (int i = 1; i < count; i++) {
+                    int c0 = color[i - 1];
+                    int c1 = color[i];
+                    int last = (int) (offset[i] * (span - 1));
+                    for (int j = prev; j <= last; j++) {
+                        float btwn = PApplet.norm(j, prev, last);
+                        interp[j][0] = (int) PApplet.lerp((c0 >> 16) & 0xff, (c1 >> 16) & 0xff, btwn);
+                        interp[j][1] = (int) PApplet.lerp((c0 >> 8) & 0xff, (c1 >> 8) & 0xff, btwn);
+                        interp[j][2] = (int) PApplet.lerp(c0 & 0xff, c1 & 0xff, btwn);
+                        interp[j][3] = (int) (PApplet.lerp((c0 >> 24) & 0xff, (c1 >> 24) & 0xff, btwn) * opacity);
+                    }
+                    prev = last;
+                }
+
+                int[] data = new int[w * h * 4];
+                int index = 0;
+                for (int j = 0; j < h; j++) {
+                    for (int i = 0; i < w; i++) {
+                        float distance = PApplet.dist(cx, cy, x + i, y + j);
+                        int which = PApplet.min((int) (distance * ACCURACY), interp.length - 1);
+
+                        data[index++] = interp[which][0];
+                        data[index++] = interp[which][1];
+                        data[index++] = interp[which][2];
+                        data[index++] = interp[which][3];
+                    }
+                }
+                raster.setPixels(0, 0, w, h, data);
+
+                return raster;
+            }
+        }
+    }
 
-  protected Paint calcGradientPaint(Gradient gradient) {
-    if (gradient instanceof LinearGradient) {
+    protected Paint calcGradientPaint(Gradient gradient) {
+        if (gradient instanceof LinearGradient) {
 //      System.out.println("creating linear gradient");
-      LinearGradient grad = (LinearGradient) gradient;
-      return new LinearGradientPaint(grad.x1, grad.y1, grad.x2, grad.y2,
-                                     grad.offset, grad.color, grad.count,
-                                     opacity);
+            LinearGradient grad = (LinearGradient) gradient;
+            return new LinearGradientPaint(grad.x1, grad.y1, grad.x2, grad.y2,
+                    grad.offset, grad.color, grad.count,
+                    opacity);
 
-    } else if (gradient instanceof RadialGradient) {
+        } else if (gradient instanceof RadialGradient) {
 //      System.out.println("creating radial gradient");
-      RadialGradient grad = (RadialGradient) gradient;
-      return new RadialGradientPaint(grad.cx, grad.cy, grad.r,
-                                     grad.offset, grad.color, grad.count,
-                                     opacity);
+            RadialGradient grad = (RadialGradient) gradient;
+            return new RadialGradientPaint(grad.cx, grad.cy, grad.r,
+                    grad.offset, grad.color, grad.count,
+                    opacity);
+        }
+        return null;
     }
-    return null;
-  }
-
 
 //  protected Paint calcGradientPaint(Gradient gradient,
 //                                    float x1, float y1, float x2, float y2) {
@@ -328,8 +332,6 @@ public class PShapeJava2D extends PShapeSVG {
 //    }
 //    throw new RuntimeException("Not a linear gradient.");
 //  }
-
-
 //  protected Paint calcGradientPaint(Gradient gradient,
 //                                    float cx, float cy, float r) {
 //    if (gradient instanceof RadialGradient) {
@@ -340,38 +342,34 @@ public class PShapeJava2D extends PShapeSVG {
 //    }
 //    throw new RuntimeException("Not a radial gradient.");
 //  }
-
-
-  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-
-
-  @Override
-  protected void styles(PGraphics g) {
-    super.styles(g);
-
-    //if (g instanceof PGraphicsJava2D) {
-    PGraphicsJava2D p2d = (PGraphicsJava2D) g;
-
-    if (strokeGradient != null) {
-      p2d.strokeGradient = true;
-      if (strokeGradientPaint == null) {
-        strokeGradientPaint = calcGradientPaint(strokeGradient);
-      }
-      p2d.strokeGradientObject = strokeGradientPaint;
-    } else {
-      // need to shut off, in case parent object has a gradient applied
-      //p2d.strokeGradient = false;
-    }
-    if (fillGradient != null) {
-      p2d.fillGradient = true;
-      if (fillGradientPaint == null) {
-        fillGradientPaint = calcGradientPaint(fillGradient);
-      }
-      p2d.fillGradientObject = fillGradientPaint;
-    } else {
-      // need to shut off, in case parent object has a gradient applied
-      //p2d.fillGradient = false;
+    // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+    @Override
+    protected void styles(PGraphics g) {
+        super.styles(g);
+
+        //if (g instanceof PGraphicsJava2D) {
+        PGraphicsJava2D p2d = (PGraphicsJava2D) g;
+
+        if (strokeGradient != null) {
+            p2d.strokeGradient = true;
+            if (strokeGradientPaint == null) {
+                strokeGradientPaint = calcGradientPaint(strokeGradient);
+            }
+            p2d.strokeGradientObject = strokeGradientPaint;
+        } else {
+            // need to shut off, in case parent object has a gradient applied
+            //p2d.strokeGradient = false;
+        }
+        if (fillGradient != null) {
+            p2d.fillGradient = true;
+            if (fillGradientPaint == null) {
+                fillGradientPaint = calcGradientPaint(fillGradient);
+            }
+            p2d.fillGradientObject = fillGradientPaint;
+        } else {
+            // need to shut off, in case parent object has a gradient applied
+            //p2d.fillGradient = false;
+        }
+        //}
     }
-    //}
-  }
-}
+}