propane 3.9.0-java → 3.10.0-java

data/lib/java/processing/awt/PImageAWT.java

@@ -0,0 +1,377 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2015 The Processing Foundation
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.awt;
+
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBuffer;
+import java.awt.image.DataBufferInt;
+import java.awt.image.PixelGrabber;
+import java.awt.image.WritableRaster;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.util.Iterator;
+
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
+import javax.imageio.metadata.IIOInvalidTreeException;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+
+import processing.core.PApplet;
+import processing.core.PImage;
+
+
+public class PImageAWT extends PImage {
+
+  /**
+   * Construct a new PImage from a java.awt.Image. This constructor assumes
+   * that you've done the work of making sure a MediaTracker has been used
+   * to fully download the data and that the img is valid.
+   *
+   * @nowebref
+   * @param img assumes a MediaTracker has been used to fully download
+   * the data and the img is valid
+   */
+  public PImageAWT(Image img) {
+    format = RGB;
+    if (img instanceof BufferedImage) {
+      BufferedImage bi = (BufferedImage) img;
+      width = bi.getWidth();
+      height = bi.getHeight();
+      int type = bi.getType();
+      if (type == BufferedImage.TYPE_3BYTE_BGR ||
+          type == BufferedImage.TYPE_4BYTE_ABGR) {
+        pixels = new int[width * height];
+        bi.getRGB(0, 0, width, height, pixels, 0, width);
+        if (type == BufferedImage.TYPE_4BYTE_ABGR) {
+          format = ARGB;
+        } else {
+          opaque();
+        }
+      } else {
+        DataBuffer db = bi.getRaster().getDataBuffer();
+        if (db instanceof DataBufferInt) {
+          pixels = ((DataBufferInt) db).getData();
+          if (type == BufferedImage.TYPE_INT_ARGB) {
+            format = ARGB;
+          } else if (type == BufferedImage.TYPE_INT_RGB) {
+            opaque();
+          }
+        }
+      }
+    }
+    // Implements fall-through if not DataBufferInt above, or not a
+    // known type, or not DataBufferInt for the data itself.
+    if (pixels == null) {  // go the old school Java 1.0 route
+      width = img.getWidth(null);
+      height = img.getHeight(null);
+      pixels = new int[width * height];
+      PixelGrabber pg =
+        new PixelGrabber(img, 0, 0, width, height, pixels, 0, width);
+      try {
+        pg.grabPixels();
+      } catch (InterruptedException e) { }
+    }
+    pixelDensity = 1;
+    pixelWidth = width;
+    pixelHeight = height;
+  }
+
+
+  /**
+   * Use the getNative() method instead, which allows library interfaces to be
+   * written in a cross-platform fashion for desktop, Android, and others.
+   * This is still included for PGraphics objects, which may need the image.
+   */
+  public Image getImage() {  // ignore
+    return (Image) getNative();
+  }
+
+
+  /**
+   * Returns a native BufferedImage from this PImage.
+   */
+  @Override
+  public Object getNative() {  // ignore
+    loadPixels();
+    int type = (format == RGB) ?
+      BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
+    BufferedImage image = new BufferedImage(pixelWidth, pixelHeight, type);
+    WritableRaster wr = image.getRaster();
+    wr.setDataElements(0, 0, pixelWidth, pixelHeight, pixels);
+    return image;
+  }
+
+
+  @Override
+  public void resize(int w, int h) {  // ignore
+    if (w <= 0 && h <= 0) {
+      throw new IllegalArgumentException("width or height must be > 0 for resize");
+    }
+
+    if (w == 0) {  // Use height to determine relative size
+      float diff = (float) h / (float) height;
+      w = (int) (width * diff);
+    } else if (h == 0) {  // Use the width to determine relative size
+      float diff = (float) w / (float) width;
+      h = (int) (height * diff);
+    }
+
+    BufferedImage img =
+      shrinkImage((BufferedImage) getNative(), w*pixelDensity, h*pixelDensity);
+
+    PImage temp = new PImageAWT(img);
+    this.pixelWidth = temp.width;
+    this.pixelHeight = temp.height;
+
+    // Get the resized pixel array
+    this.pixels = temp.pixels;
+
+    this.width = pixelWidth / pixelDensity;
+    this.height = pixelHeight / pixelDensity;
+
+    // Mark the pixels array as altered
+    updatePixels();
+  }
+
+
+  // Adapted from getFasterScaledInstance() method from page 111 of
+  // "Filthy Rich Clients" by Chet Haase and Romain Guy
+  // Additional modifications and simplifications have been added,
+  // plus a fix to deal with an infinite loop if images are expanded.
+  // http://code.google.com/p/processing/issues/detail?id=1463
+  static private BufferedImage shrinkImage(BufferedImage img,
+                                           int targetWidth, int targetHeight) {
+    int type = (img.getTransparency() == Transparency.OPAQUE) ?
+      BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
+    BufferedImage outgoing = img;
+    BufferedImage scratchImage = null;
+    Graphics2D g2 = null;
+    int prevW = outgoing.getWidth();
+    int prevH = outgoing.getHeight();
+    boolean isTranslucent = img.getTransparency() != Transparency.OPAQUE;
+
+    // Use multi-step technique: start with original size, then scale down in
+    // multiple passes with drawImage() until the target size is reached
+    int w = img.getWidth();
+    int h = img.getHeight();
+
+    do {
+      if (w > targetWidth) {
+        w /= 2;
+        // if this is the last step, do the exact size
+        if (w < targetWidth) {
+          w = targetWidth;
+        }
+      } else if (targetWidth >= w) {
+        w = targetWidth;
+      }
+      if (h > targetHeight) {
+        h /= 2;
+        if (h < targetHeight) {
+          h = targetHeight;
+        }
+      } else if (targetHeight >= h) {
+        h = targetHeight;
+      }
+      if (scratchImage == null || isTranslucent) {
+        // Use a single scratch buffer for all iterations and then copy
+        // to the final, correctly-sized image before returning
+        scratchImage = new BufferedImage(w, h, type);
+        g2 = scratchImage.createGraphics();
+      }
+      g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+      g2.drawImage(outgoing, 0, 0, w, h, 0, 0, prevW, prevH, null);
+      prevW = w;
+      prevH = h;
+      outgoing = scratchImage;
+    } while (w != targetWidth || h != targetHeight);
+    g2.dispose();
+
+
+    // If we used a scratch buffer that is larger than our target size,
+    // create an image of the right size and copy the results into it
+    if (targetWidth != outgoing.getWidth() ||
+        targetHeight != outgoing.getHeight()) {
+      scratchImage = new BufferedImage(targetWidth, targetHeight, type);
+      g2 = scratchImage.createGraphics();
+      g2.drawImage(outgoing, 0, 0, null);
+      g2.dispose();
+      outgoing = scratchImage;
+    }
+    return outgoing;
+  }
+
+
+  @Override
+  protected boolean saveImpl(String filename) {
+    if (saveImageFormats == null) {
+      saveImageFormats = javax.imageio.ImageIO.getWriterFormatNames();
+    }
+    try {
+      if (saveImageFormats != null) {
+        for (String saveImageFormat : saveImageFormats) {
+          if (filename.endsWith("." + saveImageFormat)) {
+            if (!saveImageIO(filename)) {
+              System.err.println("Error while saving image.");
+              return false;
+            }
+            return true;
+          }
+        }
+      }
+    } catch (IOException e) {
+    }
+    return false;
+  }
+
+
+  protected String[] saveImageFormats;
+
+
+  /**
+   * Use ImageIO functions from Java 1.4 and later to handle image save.
+   * Various formats are supported, typically jpeg, png, bmp, and wbmp.
+   * To get a list of the supported formats for writing, use: <BR>
+   * <TT>println(javax.imageio.ImageIO.getReaderFormatNames())</TT>
+   *
+   * @path The path to which the file should be written.
+   */
+  protected boolean saveImageIO(String path) throws IOException {
+    try {
+      int outputFormat = (format == ARGB) ?
+        BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB;
+
+      String extension =
+        path.substring(path.lastIndexOf('.') + 1).toLowerCase();
+
+      // JPEG and BMP images that have an alpha channel set get pretty unhappy.
+      // BMP just doesn't write, and JPEG writes it as a CMYK image.
+      // http://code.google.com/p/processing/issues/detail?id=415
+      if (extension.equals("bmp") || extension.equals("jpg") || extension.equals("jpeg")) {
+        outputFormat = BufferedImage.TYPE_INT_RGB;
+      }
+
+      BufferedImage bimage = new BufferedImage(pixelWidth, pixelHeight, outputFormat);
+      bimage.setRGB(0, 0, pixelWidth, pixelHeight, pixels, 0, pixelWidth);
+
+      File file = new File(path);
+
+      ImageWriter writer = null;
+      ImageWriteParam param = null;
+      IIOMetadata metadata = null;
+
+      if (extension.equals("jpg") || extension.equals("jpeg")) {
+        if ((writer = imageioWriter("jpeg")) != null) {
+          // Set JPEG quality to 90% with baseline optimization. Setting this
+          // to 1 was a huge jump (about triple the size), so this seems good.
+          // Oddly, a smaller file size than Photoshop at 90%, but I suppose
+          // it's a completely different algorithm.
+          param = writer.getDefaultWriteParam();
+          param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+          param.setCompressionQuality(0.9f);
+        }
+      }
+
+      if (extension.equals("png")) {
+        if ((writer = imageioWriter("png")) != null) {
+          param = writer.getDefaultWriteParam();
+          if (false) {
+            metadata = imageioDPI(writer, param, 100);
+          }
+        }
+      }
+
+      if (writer != null) {
+        try (BufferedOutputStream output = new BufferedOutputStream(PApplet.createOutput(file))) {
+          writer.setOutput(ImageIO.createImageOutputStream(output));
+//        writer.write(null, new IIOImage(bimage, null, null), param);
+          writer.write(metadata, new IIOImage(bimage, null, metadata), param);
+          writer.dispose();
+
+          output.flush();
+        }
+        return true;
+      }
+      // If iter.hasNext() somehow fails up top, it falls through to here
+      return javax.imageio.ImageIO.write(bimage, extension, file);
+
+    } catch (IOException e) {
+      throw new IOException("image save failed.");
+    }
+  }
+
+
+  private ImageWriter imageioWriter(String extension) {
+    Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName(extension);
+    if (iter.hasNext()) {
+      return iter.next();
+    }
+    return null;
+  }
+
+
+  private IIOMetadata imageioDPI(ImageWriter writer, ImageWriteParam param, double dpi) {
+    // http://stackoverflow.com/questions/321736/how-to-set-dpi-information-in-an-image
+    ImageTypeSpecifier typeSpecifier =
+      ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
+    IIOMetadata metadata =
+      writer.getDefaultImageMetadata(typeSpecifier, param);
+
+    if (!metadata.isReadOnly() && metadata.isStandardMetadataFormatSupported()) {
+      // for PNG, it's dots per millimeter
+      double dotsPerMilli = dpi / 25.4;
+
+      IIOMetadataNode horiz = new IIOMetadataNode("HorizontalPixelSize");
+      horiz.setAttribute("value", Double.toString(dotsPerMilli));
+
+      IIOMetadataNode vert = new IIOMetadataNode("VerticalPixelSize");
+      vert.setAttribute("value", Double.toString(dotsPerMilli));
+
+      IIOMetadataNode dim = new IIOMetadataNode("Dimension");
+      dim.appendChild(horiz);
+      dim.appendChild(vert);
+
+      IIOMetadataNode root = new IIOMetadataNode("javax_imageio_1.0");
+      root.appendChild(dim);
+
+      try {
+        metadata.mergeTree("javax_imageio_1.0", root);
+        return metadata;
+
+      } catch (IIOInvalidTreeException e) {
+        System.err.println("Could not set the DPI of the output image");
+      }
+    }
+    return null;
+  }
+}

data/lib/java/processing/awt/PShapeJava2D.java

@@ -0,0 +1,387 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2015 The Processing Foundation
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.awt;
+
+import java.awt.Paint;
+import java.awt.PaintContext;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.ColorModel;
+import java.awt.image.Raster;
+import java.awt.image.WritableRaster;
+
+import processing.core.PApplet;
+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.
+ */
+public class PShapeJava2D extends PShapeSVG {
+  Paint strokeGradientPaint;
+  Paint fillGradientPaint;
+
+
+  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);
+
+    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;
+    }
+  }
+
+
+  /** 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);
+
+    if (fillGradient != null) {
+      fillGradientPaint = calcGradientPaint(fillGradient);
+    }
+    if (strokeGradient != null) {
+      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;
+    }
+
+    @Override
+    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());
+    }
+
+    @Override
+    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;
+      }
+
+      @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;
+        }
+
+        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;
+      }
+    }
+  }
+
+
+  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;
+    }
+
+    @Override
+    public PaintContext createContext(ColorModel cm,
+                                      Rectangle deviceBounds, Rectangle2D userBounds,
+                                      AffineTransform xform, RenderingHints hints) {
+      return new RadialGradientContext();
+    }
+
+    @Override
+    public int getTransparency() {
+      return TRANSLUCENT;
+    }
+
+    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;
+        }
+
+        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) {
+//      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);
+
+    } 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;
+  }
+
+
+//  protected Paint calcGradientPaint(Gradient gradient,
+//                                    float x1, float y1, float x2, float y2) {
+//    if (gradient instanceof LinearGradient) {
+//      LinearGradient grad = (LinearGradient) gradient;
+//      return new LinearGradientPaint(x1, y1, x2, y2,
+//                                     grad.offset, grad.color, grad.count,
+//                                     opacity);
+//    }
+//    throw new RuntimeException("Not a linear gradient.");
+//  }
+
+
+//  protected Paint calcGradientPaint(Gradient gradient,
+//                                    float cx, float cy, float r) {
+//    if (gradient instanceof RadialGradient) {
+//      RadialGradient grad = (RadialGradient) gradient;
+//      return new RadialGradientPaint(cx, cy, r,
+//                                     grad.offset, grad.color, grad.count,
+//                                     opacity);
+//    }
+//    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;
+    }
+    //}
+  }
+}