propane 3.3.1-java → 3.4.0-java

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

@@ -41,42 +41,42 @@ import processing.data.*;
  */
 public class PShapeJava2D extends PShapeSVG {
 
-    Paint strokeGradientPaint;
-    Paint fillGradientPaint;
+  Paint strokeGradientPaint;
+  Paint fillGradientPaint;
 
-    public PShapeJava2D(XML svg) {
-        super(svg);
-    }
+  public PShapeJava2D(XML svg) {
+    super(svg);
+  }
 
-    public PShapeJava2D(PShapeSVG parent, XML properties, boolean parseKids) {
-        super(parent, properties, parseKids);
-    }
+  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);
@@ -88,239 +88,247 @@ 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
-        }
+   */
+  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 class LinearGradientContext implements PaintContext {
+    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());
+    }
 
-            int ACCURACY = 2;
-            float tx1, ty1, tx2, ty2;
+    public int getTransparency() {
+      return TRANSLUCENT;  // why not.. rather than checking each color
+    }
 
-            public LinearGradientContext(float tx1, float ty1, float tx2, float ty2) {
-                this.tx1 = tx1;
-                this.ty1 = ty1;
-                this.tx2 = tx2;
-                this.ty2 = ty2;
-            }
+    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;
+      }
+
+      @Override
+      public void dispose() {
+      }
+
+      @Override
+      public ColorModel getColorModel() {
+        return ColorModel.getRGBdefault();
+      }
+
+      @Override
+      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;
+        }
 
-            public void dispose() {
+        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 ColorModel getColorModel() {
-                return ColorModel.getRGBdefault();
+        } 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 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;
+            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];
             }
+          }
         }
-    }
-
-    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();
-        }
+        raster.setPixels(0, 0, w, h, data);
 
-        public int getTransparency() {
-            return TRANSLUCENT;
-        }
+        return raster;
+      }
+    }
+  }
 
-        public class RadialGradientContext implements PaintContext {
+  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;
+    }
 
-            int ACCURACY = 5;
+    @Override
+    public PaintContext createContext(ColorModel cm,
+      Rectangle deviceBounds, Rectangle2D userBounds,
+      AffineTransform xform, RenderingHints hints) {
+      return new RadialGradientContext();
+    }
 
-            public void dispose() {
-            }
+    @Override
+    public int getTransparency() {
+      return TRANSLUCENT;
+    }
 
-            public ColorModel getColorModel() {
-                return ColorModel.getRGBdefault();
-            }
+    public class RadialGradientContext implements PaintContext {
+
+      int ACCURACY = 5;
+
+      @Override
+      public void dispose() {
+      }
+
+      @Override
+      public ColorModel getColorModel() {
+        return ColorModel.getRGBdefault();
+      }
+
+      @Override
+      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;
+        }
 
-            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;
-            }
+        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);
-        }
-        return null;
+      RadialGradient grad = (RadialGradient) gradient;
+      return new RadialGradientPaint(grad.cx, grad.cy, grad.r,
+        grad.offset, grad.color, grad.count,
+        opacity);
     }
+    return null;
+  }
 
 //  protected Paint calcGradientPaint(Gradient gradient,
 //                                    float x1, float y1, float x2, float y2) {
@@ -342,34 +350,34 @@ public class PShapeJava2D extends PShapeSVG {
 //    }
 //    throw new RuntimeException("Not a radial gradient.");
 //  }
-    // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-    @Override
-    protected void styles(PGraphics g) {
-        super.styles(g);
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+  @Override
+  protected void styles(PGraphics g) {
+    super.styles(g);
 
-        //if (g instanceof PGraphicsJava2D) {
-        PGraphicsJava2D p2d = (PGraphicsJava2D) 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;
-        }
-        //}
+    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;
+    }
+    //}
+  }
 }