propane 3.3.1-java → 3.6.0-java

data/src/main/java/monkstone/PropaneLibrary.java

@@ -1,6 +1,6 @@
 /**
  * The purpose of this class is to load the MathTool into ruby-processing runtime
- * Copyright (C) 2015-19 Martin Prout. This code is free software; you can
+ * Copyright (C) 2015-20 Martin Prout. This code is free software; you can
  * redistribute it and/or modify it under the terms of the GNU Lesser General
  * Public License as published by the Free Software Foundation; either version
  * 2.1 of the License, or (at your option) any later version.
@@ -41,6 +41,6 @@ public class PropaneLibrary implements Library {
      */
     @Override
     public void load(final Ruby runtime, boolean wrap) throws IOException {
-        load(runtime);
+        PropaneLibrary.load(runtime);
     }
 }

data/src/main/java/monkstone/fastmath/Deglut.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2015-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/filechooser/Chooser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -32,6 +32,7 @@ import java.io.File;
  *
  * @author Martin Prout
  */
+@FunctionalInterface 
 public interface Chooser {
 
     public void file_selected(File selection);

data/src/main/java/monkstone/noise/SimplexNoise.java

@@ -31,7 +31,7 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         new Grad(1, 1, 1, 0), new Grad(1, 1, -1, 0), new Grad(1, -1, 1, 0), new Grad(1, -1, -1, 0),
         new Grad(-1, 1, 1, 0), new Grad(-1, 1, -1, 0), new Grad(-1, -1, 1, 0), new Grad(-1, -1, -1, 0)};
 
-    private static short p[] = {151, 160, 137, 91, 90, 15,
+    private final static short p[] = {151, 160, 137, 91, 90, 15,
         131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23,
         190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
         88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166,
@@ -45,7 +45,7 @@ public class SimplexNoise {  // Simplex noise in 2D, 3D and 4D
         49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254,
         138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180};
     // To remove the need for index wrapping, double the permutation table length
-    static short[] PERM = new short[512];
+    final static short[] PERM = new short[512];
     static short[] PERM_MOD_12 = new short[512];
 
     static {

data/src/main/java/monkstone/slider/CustomHorizontalSlider.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/slider/CustomVerticalSlider.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/slider/SimpleHorizontalSlider.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/slider/SimpleVerticalSlider.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/slider/SliderBar.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/slider/SliderGroup.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2016-19 Martin Prout
+ * Copyright (c) 2015-20 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/slider/WheelHandler.java

@@ -1,18 +1,18 @@
-/* 
- * Copyright (c) 2016-19 Martin Prout
- * 
+/*
+ * Copyright (c) 2015-20 Martin Prout
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
- * 
+ *
  * http://creativecommons.org/licenses/LGPL/2.1/
- * 
+ *
  * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
@@ -24,6 +24,7 @@ package monkstone.slider;
  * Peasycam when I was struggling with non functioning browser applet, probably
  * superfluous here.
  */
+@FunctionalInterface 
 public interface WheelHandler {
 
     /**

data/src/main/java/monkstone/vecmath/package-info.java

@@ -1,5 +1,5 @@
 /* 
-* Copyright (c) 2015-19 Martin Prout
+* Copyright (c) 2015-20 Martin Prout
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/vecmath/vec2/Vec2.java

@@ -1,7 +1,7 @@
 package monkstone.vecmath.vec2;
 
 /*
-* Copyright (c) 2015-19 Martin Prout
+* Copyright (c) 2015-20 Martin Prout
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
@@ -399,7 +399,7 @@ public class Vec2 extends RubyObject {
     @JRubyMethod(name = "set_mag")
 
     public IRubyObject set_mag(ThreadContext context, IRubyObject scalar, Block block) {
-        double new_mag = (Double) scalar.toJava(Double.class);
+        double new_mag = scalar.toJava(Double.class);
         if (block.isGiven()) {
             if (!(boolean) block.yield(context, scalar).toJava(Boolean.class)) {
                 return this;

data/src/main/java/monkstone/vecmath/vec3/Vec3.java

@@ -1,7 +1,7 @@
 package monkstone.vecmath.vec3;
 
 /*
-* Copyright (c) 2015-19 Martin Prout
+* Copyright (c) 2015-20 Martin Prout
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public

data/src/main/java/monkstone/videoevent/CaptureEvent.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2015-20 Martin Prout
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+package monkstone.videoevent;
+import processing.video.Capture;
+
+@FunctionalInterface
+public interface CaptureEvent{
+    public void captureEvent(Capture capture);
+}

data/src/main/java/monkstone/videoevent/{VideoInterface.java → MovieEvent.java}

@@ -1,48 +1,32 @@
-/* 
- * Copyright (c) 2015-19 Martin Prout
- * 
+/*
+ * Copyright (c) 2015-20 Martin Prout
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
- * 
+ *
  * http://creativecommons.org/licenses/LGPL/2.1/
- * 
+ *
  * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
-package monkstone.videoevent;
 
+package monkstone.videoevent;
 import processing.video.Movie;
-import processing.video.Capture;
 
 /**
- * This interface makes it easier/possible to use the reflection methods from
- * Movie and Capture classes in Propane::App in propane
- *
+ * This interface makes it easier/possible to use the reflection methods
+ * from Movie and Capture classes in Processing::App in JRubyArt
  * @author Martin Prout
  */
-public interface VideoInterface {
-
-    /**
-     * Used to implement reflection method in PApplet
-     *
-     * @see processing.video.Movie
-     * @param movie Movie
-     */
+@FunctionalInterface
+public interface MovieEvent {
     public void movieEvent(Movie movie);
-
-    /**
-     * Used to implement reflection method in PApplet
-     *
-     * @see processing.video.Capture
-     * @param capture Capture
-     */
-    public void captureEvent(Capture capture);
 }

data/src/main/java/monkstone/videoevent/package-info.java

@@ -1,5 +1,5 @@
 /* 
-* Copyright (c) 2015-19 Martin Prout
+* Copyright (c) 2015-20 Martin Prout
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public

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

@@ -1,3 +1,5 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
 /*
   Part of the Processing project - http://processing.org
 
@@ -18,7 +20,8 @@
   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.*;
@@ -31,20 +34,20 @@ import java.util.Map;
 
 import processing.core.*;
 
+
 /**
  * Subclass for PGraphics that implements the graphics API using Java2D.
  * <p>
- * To get access to the Java 2D "Graphics2D" object for the default renderer,
- * use:
+ * To get access to the Java 2D "Graphics2D" object for the default
+ * renderer, use:
  * <PRE>
  * Graphics2D g2 = (Graphics2D) g.getNative();
- * </PRE> This will let you do Graphics2D calls directly, but is not supported
- * in any way shape or form. Which just means "have fun, but don't complain if
- * it breaks."
+ * </PRE>
+ * This will let you do Graphics2D calls directly, but is not supported
+ * in any way shape or form. Which just means "have fun, but don't complain
+ * if it breaks."
  * <p>
- * Advanced
- * <a href="http://docs.oracle.com/javase/7/docs/webnotes/tsg/TSG-Desktop/html/java2d.html">debugging
- * notes</a> for Java2D.
+ * Advanced <a href="http://docs.oracle.com/javase/7/docs/webnotes/tsg/TSG-Desktop/html/java2d.html">debugging notes</a> for Java2D.
  */
 public class PGraphicsJava2D extends PGraphics {
 ////  BufferStrategy strategy;
@@ -57,58 +60,69 @@ public class PGraphicsJava2D extends PGraphics {
 ////  boolean useOffscreen = true;  // ~40fps
 //  boolean useOffscreen = false;
 
-    public Graphics2D g2;
+  public Graphics2D g2;
 //  protected BufferedImage offscreen;
 
-    Composite defaultComposite;
+  Composite defaultComposite;
 
-    GeneralPath gpath;
+  GeneralPath gpath;
 
-    // path for contours so gpath can be closed
-    GeneralPath auxPath;
+  // path for contours so gpath can be closed
+  GeneralPath auxPath;
 
-    boolean openContour;
+  boolean openContour;
 
-    /// break the shape at the next vertex (next vertex() call is a moveto())
-    boolean breakShape;
+  /// break the shape at the next vertex (next vertex() call is a moveto())
+  boolean breakShape;
 
-    /// coordinates for internal curve calculation
-    float[] curveCoordX;
-    float[] curveCoordY;
-    float[] curveDrawX;
-    float[] curveDrawY;
+  /// coordinates for internal curve calculation
+  float[] curveCoordX;
+  float[] curveCoordY;
+  float[] curveDrawX;
+  float[] curveDrawY;
 
-    int transformCount;
-    AffineTransform transformStack[]
-            = new AffineTransform[MATRIX_STACK_DEPTH];
-    double[] transform = new double[6];
+  int transformCount;
+  AffineTransform[] transformStack =
+    new AffineTransform[MATRIX_STACK_DEPTH];
+  double[] transform = new double[6];
 
-    Line2D.Float line = new Line2D.Float();
-    Ellipse2D.Float ellipse = new Ellipse2D.Float();
-    Rectangle2D.Float rect = new Rectangle2D.Float();
-    Arc2D.Float arc = new Arc2D.Float();
+  Line2D.Float line = new Line2D.Float();
+  Ellipse2D.Float ellipse = new Ellipse2D.Float();
+  Rectangle2D.Float rect = new Rectangle2D.Float();
+  Arc2D.Float arc = new Arc2D.Float();
 
-    protected Color tintColorObject;
+  protected Color tintColorObject;
 
-    protected Color fillColorObject;
-    public boolean fillGradient;
-    public Paint fillGradientObject;
+  protected Color fillColorObject;
+  public boolean fillGradient;
+  public Paint fillGradientObject;
 
-    protected Stroke strokeObject;
-    protected Color strokeColorObject;
-    public boolean strokeGradient;
-    public Paint strokeGradientObject;
+  protected Stroke strokeObject;
+  protected Color strokeColorObject;
+  public boolean strokeGradient;
+  public Paint strokeGradientObject;
 
-    Font fontObject;
+  Font fontObject;
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // INTERNAL
+
+
+  public PGraphicsJava2D() { }
+
+
+  //public void setParent(PApplet parent)
+
+
+  //public void setPrimary(boolean primary)
+
+
+  //public void setPath(String path)
 
-    //////////////////////////////////////////////////////////////
-    // INTERNAL
-    public PGraphicsJava2D() {
-    }
 
-    //public void setParent(PApplet parent)
-    //public void setPrimary(boolean primary)
-    //public void setPath(String path)
 //  /**
 //   * Called in response to a resize event, handles setting the
 //   * new width and height internally, as well as re-allocating
@@ -124,12 +138,16 @@ public class PGraphicsJava2D extends PGraphics {
 //    allocate();
 //    reapplySettings();
 //  }
+
+
 //  @Override
 //  protected void allocate() {
 //    //surface.initImage(this, width, height);
 //    surface.initImage(this);
 //  }
-    /*
+
+
+  /*
   @Override
   protected void allocate() {
     // Tried this with RGB instead of ARGB for the primarySurface version,
@@ -201,9 +219,9 @@ public class PGraphicsJava2D extends PGraphics {
       image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
       g2 = (Graphics2D) image.getGraphics();
     }
-     */
+    */
 
- /*
+    /*
     if (primarySurface) {
       Canvas canvas = ((PSurfaceAWT) surface).canvas;
 
@@ -224,35 +242,46 @@ public class PGraphicsJava2D extends PGraphics {
     g2 = (Graphics2D) image.getGraphics();
   }
      */
-    //public void dispose()
-    @Override
-    public PSurface createSurface() {
-        return surface = new PSurfaceAWT(this);
-    }
 
-    /**
-     * Still need a means to get the java.awt.Image object, since getNative() is
-     * going to return the {@link Graphics2D} object.
-     */
-    @Override
-    public Image getImage() {
-        return image;
-    }
 
-    /**
-     * Returns the java.awt.Graphics2D object used by this renderer.
-     */
-    @Override
-    public Object getNative() {
-        return g2;
-    }
+  //public void dispose()
+
+
+  @Override
+  public PSurface createSurface() {
+    return surface = new PSurfaceAWT(this);
+  }
+
+
+//  /**
+//   * Still need a means to get the java.awt.Image object, since getNative()
+//   * is going to return the {@link Graphics2D} object.
+//   */
+//  @Override
+//  public Image getImage() {
+//    return image;
+//  }
+
+
+  /** Returns the java.awt.Graphics2D object used by this renderer.
+   * @return  */
+  @Override
+  public Object getNative() {
+    return g2;
+  }
+
+
+  //////////////////////////////////////////////////////////////
+
+  // FRAME
+
 
-    //////////////////////////////////////////////////////////////
-    // FRAME
 //  @Override
 //  public boolean canDraw() {
 //    return true;
 //  }
+
+
 //  @Override
 //  public void requestDraw() {
 ////    EventQueue.invokeLater(new Runnable() {
@@ -261,11 +290,14 @@ public class PGraphicsJava2D extends PGraphics {
 ////      }
 ////    });
 //  }
+
+
 //  Graphics2D g2old;
-    public Graphics2D checkImage() {
-        if (image == null
-                || ((BufferedImage) image).getWidth() != width * pixelDensity
-                || ((BufferedImage) image).getHeight() != height * pixelDensity) {
+
+  public Graphics2D checkImage() {
+    if (image == null ||
+      ((BufferedImage) image).getWidth() != width*pixelDensity ||
+      ((BufferedImage) image).getHeight() != height*pixelDensity) {
 //      ((VolatileImage) image).getWidth() != width ||
 //      ((VolatileImage) image).getHeight() != height) {
 //        image = new BufferedImage(width * pixelFactor, height * pixelFactor
@@ -290,46 +322,48 @@ public class PGraphicsJava2D extends PGraphics {
 //        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
 //        gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
 //      }
-            // Formerly this was broken into separate versions based on offscreen or
-            // not, but we may as well create a compatible image; it won't hurt, right?
-            // P.S.: Three years later, I'm happy to report it did in fact hurt [jv 2018-06-01]
-            int wide = width * pixelDensity;
-            int high = height * pixelDensity;
+
+      // Formerly this was broken into separate versions based on offscreen or
+      // not, but we may as well create a compatible image; it won't hurt, right?
+      // P.S.: Three years later, I'm happy to report it did in fact hurt [jv 2018-06-01]
+      int wide = width * pixelDensity;
+      int high = height * pixelDensity;
 //      System.out.println("re-creating image");
 
-            // For now we expect non-premultiplied INT ARGB and the compatible image
-            // might not be it... create the image directly. It's important that the
-            // image has all four bands, otherwise we get garbage alpha during blending
-            // (see https://github.com/processing/processing/pull/2645,
-            //      https://github.com/processing/processing/pull/3523)
-            //
-            // image = gc.createCompatibleImage(wide, high, Transparency.TRANSLUCENT);
-            image = new BufferedImage(wide, high, BufferedImage.TYPE_INT_ARGB);
-        }
-        return (Graphics2D) image.getGraphics();
+      // For now we expect non-premultiplied INT ARGB and the compatible image
+      // might not be it... create the image directly. It's important that the
+      // image has all four bands, otherwise we get garbage alpha during blending
+      // (see https://github.com/processing/processing/pull/2645,
+      //      https://github.com/processing/processing/pull/3523)
+      //
+      // image = gc.createCompatibleImage(wide, high, Transparency.TRANSLUCENT);
+      image = new BufferedImage(wide, high, BufferedImage.TYPE_INT_ARGB);
     }
+    return (Graphics2D) image.getGraphics();
+  }
 
-    @Override
-    public void beginDraw() {
-        g2 = checkImage();
-
-        // Calling getGraphics() seems to nuke several settings.
-        // It seems to be re-creating a new Graphics2D object each time.
-        // https://github.com/processing/processing/issues/3331
-        if (strokeObject != null) {
-            g2.setStroke(strokeObject);
-        }
-        // https://github.com/processing/processing/issues/2617
-        if (fontObject != null) {
-            g2.setFont(fontObject);
-        }
-        // https://github.com/processing/processing/issues/4019
-        if (blendMode != 0) {
-            blendMode(blendMode);
-        }
-        handleSmooth();
 
-        /*
+  @Override
+  public void beginDraw() {
+    g2 = checkImage();
+
+    // Calling getGraphics() seems to nuke several settings.
+    // It seems to be re-creating a new Graphics2D object each time.
+    // https://github.com/processing/processing/issues/3331
+    if (strokeObject != null) {
+      g2.setStroke(strokeObject);
+    }
+    // https://github.com/processing/processing/issues/2617
+    if (fontObject != null) {
+      g2.setFont(fontObject);
+    }
+    // https://github.com/processing/processing/issues/4019
+    if (blendMode != 0) {
+      blendMode(blendMode);
+    }
+    handleSmooth();
+
+    /*
     // NOTE: Calling image.getGraphics() will create a new Graphics context,
     // even if it's for the same image that's already had a context created.
     // Seems like a speed/memory issue, and also requires that all smoothing,
@@ -380,46 +414,48 @@ public class PGraphicsJava2D extends PGraphics {
         reapplySettings = true;
       }
     }
-         */
-        checkSettings();
-        resetMatrix(); // reset model matrix
-        vertexCount = 0;
-    }
+    */
 
-    /**
-     * Smoothing for Java2D is 2 for bilinear, and 3 for bicubic (the default).
-     * Internally, smooth(1) is the default, smooth(0) is noSmooth().
-     */
-    protected void handleSmooth() {
-        if (smooth == 0) {
-            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_OFF);
-            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                    RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
-            g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
-                    RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+    checkSettings();
+    resetMatrix(); // reset model matrix
+    vertexCount = 0;
+  }
 
-        } else {
-            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    RenderingHints.VALUE_ANTIALIAS_ON);
-
-            if (smooth == 1 || smooth == 3) {  // default is bicubic
-                g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                        RenderingHints.VALUE_INTERPOLATION_BICUBIC);
-            } else if (smooth == 2) {
-                g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-                        RenderingHints.VALUE_INTERPOLATION_BILINEAR);
-            }
 
-            // http://docs.oracle.com/javase/tutorial/2d/text/renderinghints.html
-            // Oracle Java text anti-aliasing on OS X looks like s*t compared to the
-            // text rendering with Apple's old Java 6. Below, several attempts to fix:
-            g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
-                    RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-            // Turns out this is the one that actually makes things work.
-            // Kerning is still screwed up, however.
-            g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
-                    RenderingHints.VALUE_FRACTIONALMETRICS_ON);
+  /**
+   * Smoothing for Java2D is 2 for bilinear, and 3 for bicubic (the default).
+   * Internally, smooth(1) is the default, smooth(0) is noSmooth().
+   */
+  protected void handleSmooth() {
+    if (smooth == 0) {
+      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                          RenderingHints.VALUE_ANTIALIAS_OFF);
+      g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                          RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+      g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
+                          RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+
+    } else {
+      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                          RenderingHints.VALUE_ANTIALIAS_ON);
+
+      if (smooth == 1 || smooth == 3) {  // default is bicubic
+        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                            RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+      } else if (smooth == 2) {
+        g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                            RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+      }
+
+      // http://docs.oracle.com/javase/tutorial/2d/text/renderinghints.html
+      // Oracle Java text anti-aliasing on OS X looks like s*t compared to the
+      // text rendering with Apple's old Java 6. Below, several attempts to fix:
+      g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
+                          RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+      // Turns out this is the one that actually makes things work.
+      // Kerning is still screwed up, however.
+      g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
+                          RenderingHints.VALUE_FRACTIONALMETRICS_ON);
 //    g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
 //                        RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
 //    g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
@@ -427,17 +463,18 @@ public class PGraphicsJava2D extends PGraphics {
 
 //    g2.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
 //                        RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
-        }
     }
+  }
 
-    @Override
-    public void endDraw() {
-        // hm, mark pixels as changed, because this will instantly do a full
-        // copy of all the pixels to the surface.. so that's kind of a mess.
-        //updatePixels();
 
-        if (primaryGraphics) {
-            /*
+  @Override
+  public void endDraw() {
+    // hm, mark pixels as changed, because this will instantly do a full
+    // copy of all the pixels to the surface.. so that's kind of a mess.
+    //updatePixels();
+
+    if (primaryGraphics) {
+      /*
       //if (canvas != null) {
       if (useCanvas) {
         //System.out.println(canvas);
@@ -465,11 +502,11 @@ public class PGraphicsJava2D extends PGraphics {
 //        g2.dispose();
 //        System.out.println("not doing anything special in endDraw()");
       }
-             */
-        } else {
-            // TODO this is probably overkill for most tasks...
-            loadPixels();
-        }
+      */
+    } else {
+      // TODO this is probably overkill for most tasks...
+      loadPixels();
+    }
 
 //    // Marking as modified, and then calling updatePixels() in
 //    // the super class, which just sets the mx1, my1, mx2, my2
@@ -477,15 +514,16 @@ public class PGraphicsJava2D extends PGraphics {
 //    // full copy of the pixels to the surface in this.updatePixels().
 //    setModified();
 //    super.updatePixels();
-        // Marks pixels as modified so that the pixels will be updated.
-        // Also sets mx1/y1/x2/y2 so that OpenGL will pick it up.
-        setModified();
 
-        g2.dispose();
-    }
+    // Marks pixels as modified so that the pixels will be updated.
+    // Also sets mx1/y1/x2/y2 so that OpenGL will pick it up.
+    setModified();
 
+    g2.dispose();
+  }
 
-    /*
+
+  /*
   private void redraw() {
     // only need this check if the validate() call will use redraw()
 //    if (strategy == null) return;
@@ -528,12 +566,20 @@ public class PGraphicsJava2D extends PGraphics {
     } while (strategy.contentsLost());
     PApplet.debug("PGraphicsJava2D.redraw() out of do { } block");
   }
-     */
-    //////////////////////////////////////////////////////////////
-    // SETTINGS
-    //protected void checkSettings()
-    @Override
-    protected void defaultSettings() {
+  */
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SETTINGS
+
+
+  //protected void checkSettings()
+
+
+  @Override
+  protected void defaultSettings() {
 //    if (!useCanvas) {
 //      // Papered over another threading issue...
 //      // See if this comes back now that the other issue is fixed.
@@ -543,49 +589,65 @@ public class PGraphicsJava2D extends PGraphics {
 ////          Thread.sleep(5);
 ////        } catch (InterruptedException e) { }
 ////      }
-        defaultComposite = g2.getComposite();
+    defaultComposite = g2.getComposite();
 //    }
-        super.defaultSettings();
-    }
+    super.defaultSettings();
+  }
 
-    //protected void reapplySettings()
-    //////////////////////////////////////////////////////////////
-    // HINT
-    @Override
-    public void hint(int which) {
-        // take care of setting the hint
-        super.hint(which);
-
-        // Avoid badness when drawing shorter strokes.
-        // http://code.google.com/p/processing/issues/detail?id=1068
-        // Unfortunately cannot always be enabled, because it makes the
-        // stroke in many standard Processing examples really gross.
-        if (which == ENABLE_STROKE_PURE) {
-            g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
-                    RenderingHints.VALUE_STROKE_PURE);
-        } else if (which == DISABLE_STROKE_PURE) {
-            g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
-                    RenderingHints.VALUE_STROKE_DEFAULT);
-        }
-    }
 
-    //////////////////////////////////////////////////////////////
-    // SHAPE CREATION
-    @Override
-    protected PShape createShapeFamily(int type) {
-        return new PShape(this, type);
-    }
+  //protected void reapplySettings()
 
-    @Override
-    protected PShape createShapePrimitive(int kind, float... p) {
-        return new PShape(this, kind, p);
+
+
+  //////////////////////////////////////////////////////////////
+
+  // HINT
+
+
+  @Override
+  public void hint(int which) {
+    // take care of setting the hint
+    super.hint(which);
+
+    // Avoid badness when drawing shorter strokes.
+    // http://code.google.com/p/processing/issues/detail?id=1068
+    // Unfortunately cannot always be enabled, because it makes the
+    // stroke in many standard Processing examples really gross.
+    if (which == ENABLE_STROKE_PURE) {
+      g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
+                          RenderingHints.VALUE_STROKE_PURE);
+    } else if (which == DISABLE_STROKE_PURE) {
+      g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
+                          RenderingHints.VALUE_STROKE_DEFAULT);
     }
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE CREATION
+
+
+  @Override
+  protected PShape createShapeFamily(int type) {
+    return new PShape(this, type);
+  }
+
+
+  @Override
+  protected PShape createShapePrimitive(int kind, float... p) {
+    return new PShape(this, kind, p);
+  }
+
 
 //  @Override
 //  public PShape createShape(PShape source) {
 //    return PShapeOpenGL.createShape2D(this, source);
 //  }
-    /*
+
+
+  /*
   protected PShape createShapeImpl(PGraphicsJava2D pg, int type) {
     PShape shape = null;
     if (type == PConstants.GROUP) {
@@ -599,8 +661,10 @@ public class PGraphicsJava2D extends PGraphics {
     //shape.set3D(false);
     return shape;
   }
-     */
- /*
+   */
+
+
+  /*
   static protected PShape createShapeImpl(PGraphicsJava2D pg,
                                                 int kind, float... p) {
     PShape shape = null;
@@ -672,475 +736,548 @@ public class PGraphicsJava2D extends PGraphics {
 
     return shape;
   }
-     */
-    //////////////////////////////////////////////////////////////
-    // SHAPES
-    @Override
-    public void beginShape(int kind) {
-        //super.beginShape(kind);
-        shape = kind;
-        vertexCount = 0;
-        curveVertexCount = 0;
-
-        // set gpath to null, because when mixing curves and straight
-        // lines, vertexCount will be set back to zero, so vertexCount == 1
-        // is no longer a good indicator of whether the shape is new.
-        // this way, just check to see if gpath is null, and if it isn't
-        // then just use it to continue the shape.
-        gpath = null;
-        auxPath = null;
-    }
-
-    //public boolean edge(boolean e)
-    //public void normal(float nx, float ny, float nz) {
-    //public void textureMode(int mode)
-    @Override
-    public void texture(PImage image) {
-        showMethodWarning("texture");
-    }
-
-    @Override
-    public void vertex(float x, float y) {
-        curveVertexCount = 0;
-        //float vertex[];
-
-        if (vertexCount == vertices.length) {
-            float temp[][] = new float[vertexCount << 1][VERTEX_FIELD_COUNT];
-            System.arraycopy(vertices, 0, temp, 0, vertexCount);
-            vertices = temp;
-            //message(CHATTER, "allocating more vertices " + vertices.length);
-        }
-        // not everyone needs this, but just easier to store rather
-        // than adding another moving part to the code...
-        vertices[vertexCount][X] = x;
-        vertices[vertexCount][Y] = y;
-        vertexCount++;
-
-        switch (shape) {
-
-            case POINTS:
-                point(x, y);
-                break;
-
-            case LINES:
-                if ((vertexCount % 2) == 0) {
-                    line(vertices[vertexCount - 2][X],
-                            vertices[vertexCount - 2][Y], x, y);
-                }
-                break;
-
-            case TRIANGLES:
-                if ((vertexCount % 3) == 0) {
-                    triangle(vertices[vertexCount - 3][X],
-                            vertices[vertexCount - 3][Y],
-                            vertices[vertexCount - 2][X],
-                            vertices[vertexCount - 2][Y],
-                            x, y);
-                }
-                break;
-
-            case TRIANGLE_STRIP:
-                if (vertexCount >= 3) {
-                    triangle(vertices[vertexCount - 2][X],
-                            vertices[vertexCount - 2][Y],
-                            vertices[vertexCount - 1][X],
-                            vertices[vertexCount - 1][Y],
-                            vertices[vertexCount - 3][X],
-                            vertices[vertexCount - 3][Y]);
-                }
-                break;
-
-            case TRIANGLE_FAN:
-                if (vertexCount >= 3) {
-                    // This is an unfortunate implementation because the stroke for an
-                    // adjacent triangle will be repeated. However, if the stroke is not
-                    // redrawn, it will replace the adjacent line (when it lines up
-                    // perfectly) or show a faint line (when off by a small amount).
-                    // The alternative would be to wait, then draw the shape as a
-                    // polygon fill, followed by a series of vertices. But that's a
-                    // poor method when used with PDF, DXF, or other recording objects,
-                    // since discrete triangles would likely be preferred.
-                    triangle(vertices[0][X],
-                            vertices[0][Y],
-                            vertices[vertexCount - 2][X],
-                            vertices[vertexCount - 2][Y],
-                            x, y);
-                }
-                break;
-
-            case QUAD:
-            case QUADS:
-                if ((vertexCount % 4) == 0) {
-                    quad(vertices[vertexCount - 4][X],
-                            vertices[vertexCount - 4][Y],
-                            vertices[vertexCount - 3][X],
-                            vertices[vertexCount - 3][Y],
-                            vertices[vertexCount - 2][X],
-                            vertices[vertexCount - 2][Y],
-                            x, y);
-                }
-                break;
-
-            case QUAD_STRIP:
-                // 0---2---4
-                // |   |   |
-                // 1---3---5
-                if ((vertexCount >= 4) && ((vertexCount % 2) == 0)) {
-                    quad(vertices[vertexCount - 4][X],
-                            vertices[vertexCount - 4][Y],
-                            vertices[vertexCount - 2][X],
-                            vertices[vertexCount - 2][Y],
-                            x, y,
-                            vertices[vertexCount - 3][X],
-                            vertices[vertexCount - 3][Y]);
-                }
-                break;
-
-            case POLYGON:
-                if (gpath == null) {
-                    gpath = new GeneralPath();
-                    gpath.moveTo(x, y);
-                } else if (breakShape) {
-                    gpath.moveTo(x, y);
-                    breakShape = false;
-                } else {
-                    gpath.lineTo(x, y);
-                }
-                break;
-        }
-    }
+  */
 
-    @Override
-    public void vertex(float x, float y, float z) {
-        showDepthWarningXYZ("vertex");
-    }
 
-    @Override
-    public void vertex(float[] v) {
-        vertex(v[X], v[Y]);
-    }
 
-    @Override
-    public void vertex(float x, float y, float u, float v) {
-        showVariationWarning("vertex(x, y, u, v)");
-    }
+  //////////////////////////////////////////////////////////////
 
-    @Override
-    public void vertex(float x, float y, float z, float u, float v) {
-        showDepthWarningXYZ("vertex");
-    }
+  // SHAPES
 
-    @Override
-    public void beginContour() {
-        if (openContour) {
-            PGraphics.showWarning("Already called beginContour()");
-            return;
-        }
 
-        // draw contours to auxiliary path so main path can be closed later
-        GeneralPath contourPath = auxPath;
-        auxPath = gpath;
-        gpath = contourPath;
+  @Override
+  public void beginShape(int kind) {
+    //super.beginShape(kind);
+    shape = kind;
+    vertexCount = 0;
+    curveVertexCount = 0;
+
+    // set gpath to null, because when mixing curves and straight
+    // lines, vertexCount will be set back to zero, so vertexCount == 1
+    // is no longer a good indicator of whether the shape is new.
+    // this way, just check to see if gpath is null, and if it isn't
+    // then just use it to continue the shape.
+    gpath = null;
+    auxPath = null;
+  }
 
-        if (contourPath != null) {  // first contour does not break
-            breakShape = true;
-        }
 
-        openContour = true;
-    }
+  //public boolean edge(boolean e)
 
-    @Override
-    public void endContour() {
-        if (!openContour) {
-            PGraphics.showWarning("Need to call beginContour() first");
-            return;
-        }
 
-        // close this contour
-        if (gpath != null) {
-            gpath.closePath();
-        }
+  //public void normal(float nx, float ny, float nz) {
 
-        // switch back to main path
-        GeneralPath contourPath = gpath;
-        gpath = auxPath;
-        auxPath = contourPath;
 
-        openContour = false;
-    }
+  //public void textureMode(int mode)
 
-    @Override
-    public void endShape(int mode) {
-        if (openContour) { // correct automagically, notify user
-            endContour();
-            PGraphics.showWarning("Missing endContour() before endShape()");
-        }
-        if (gpath != null) {  // make sure something has been drawn
-            if (shape == POLYGON) {
-                if (mode == CLOSE) {
-                    gpath.closePath();
-                }
-                if (auxPath != null) {
-                    gpath.append(auxPath, false);
-                }
-                drawShape(gpath);
-            }
-        }
-        shape = 0;
-    }
 
-    //////////////////////////////////////////////////////////////
-    // CLIPPING
-    @Override
-    protected void clipImpl(float x1, float y1, float x2, float y2) {
-        g2.setClip(new Rectangle2D.Float(x1, y1, x2 - x1, y2 - y1));
-    }
+  @Override
+  public void texture(PImage image) {
+    showMethodWarning("texture");
+  }
 
-    @Override
-    public void noClip() {
-        g2.setClip(null);
-    }
 
-    //////////////////////////////////////////////////////////////
-    // BLEND
-    /**
-     * ( begin auto-generated from blendMode.xml )
-     *
-     * This is a new reference entry for Processing 2.0. It will be updated
-     * shortly.
-     *
-     * ( end auto-generated )
-     *
-     * @webref Rendering
-     * @param mode the blending mode to use
-     */
-    @Override
-    protected void blendModeImpl() {
-        if (blendMode == BLEND) {
-            g2.setComposite(defaultComposite);
+  @Override
+  public void vertex(float x, float y) {
+    curveVertexCount = 0;
+    //float vertex[];
+
+    if (vertexCount == vertices.length) {
+      float[][] temp = new float[vertexCount<<1][VERTEX_FIELD_COUNT];
+      System.arraycopy(vertices, 0, temp, 0, vertexCount);
+      vertices = temp;
+      //message(CHATTER, "allocating more vertices " + vertices.length);
+    }
+    // not everyone needs this, but just easier to store rather
+    // than adding another moving part to the code...
+    vertices[vertexCount][X] = x;
+    vertices[vertexCount][Y] = y;
+    vertexCount++;
+
+    switch (shape) {
+
+    case POINTS:
+      point(x, y);
+      break;
+
+    case LINES:
+      if ((vertexCount % 2) == 0) {
+        line(vertices[vertexCount-2][X],
+             vertices[vertexCount-2][Y], x, y);
+      }
+      break;
+
+    case TRIANGLES:
+      if ((vertexCount % 3) == 0) {
+        triangle(vertices[vertexCount - 3][X],
+                 vertices[vertexCount - 3][Y],
+                 vertices[vertexCount - 2][X],
+                 vertices[vertexCount - 2][Y],
+                 x, y);
+      }
+      break;
+
+    case TRIANGLE_STRIP:
+      if (vertexCount >= 3) {
+        triangle(vertices[vertexCount - 2][X],
+                 vertices[vertexCount - 2][Y],
+                 vertices[vertexCount - 1][X],
+                 vertices[vertexCount - 1][Y],
+                 vertices[vertexCount - 3][X],
+                 vertices[vertexCount - 3][Y]);
+      }
+      break;
+
+    case TRIANGLE_FAN:
+      if (vertexCount >= 3) {
+        // This is an unfortunate implementation because the stroke for an
+        // adjacent triangle will be repeated. However, if the stroke is not
+        // redrawn, it will replace the adjacent line (when it lines up
+        // perfectly) or show a faint line (when off by a small amount).
+        // The alternative would be to wait, then draw the shape as a
+        // polygon fill, followed by a series of vertices. But that's a
+        // poor method when used with PDF, DXF, or other recording objects,
+        // since discrete triangles would likely be preferred.
+        triangle(vertices[0][X],
+                 vertices[0][Y],
+                 vertices[vertexCount - 2][X],
+                 vertices[vertexCount - 2][Y],
+                 x, y);
+      }
+      break;
+
+    case QUAD:
+    case QUADS:
+      if ((vertexCount % 4) == 0) {
+        quad(vertices[vertexCount - 4][X],
+             vertices[vertexCount - 4][Y],
+             vertices[vertexCount - 3][X],
+             vertices[vertexCount - 3][Y],
+             vertices[vertexCount - 2][X],
+             vertices[vertexCount - 2][Y],
+             x, y);
+      }
+      break;
+
+    case QUAD_STRIP:
+      // 0---2---4
+      // |   |   |
+      // 1---3---5
+      if ((vertexCount >= 4) && ((vertexCount % 2) == 0)) {
+        quad(vertices[vertexCount - 4][X],
+             vertices[vertexCount - 4][Y],
+             vertices[vertexCount - 2][X],
+             vertices[vertexCount - 2][Y],
+             x, y,
+             vertices[vertexCount - 3][X],
+             vertices[vertexCount - 3][Y]);
+      }
+      break;
 
-        } else {
-            g2.setComposite(new Composite() {
-
-                @Override
-                public CompositeContext createContext(ColorModel srcColorModel,
-                        ColorModel dstColorModel,
-                        RenderingHints hints) {
-                    return new BlendingContext(blendMode);
-                }
-            });
-        }
+    case POLYGON:
+      if (gpath == null) {
+        gpath = new GeneralPath();
+        gpath.moveTo(x, y);
+      } else if (breakShape) {
+        gpath.moveTo(x, y);
+        breakShape = false;
+      } else {
+        gpath.lineTo(x, y);
+      }
+      break;
     }
+  }
 
-    // Blending implementation cribbed from portions of Romain Guy's
-    // demo and terrific writeup on blending modes in Java 2D.
-    // http://www.curious-creature.org/2006/09/20/new-blendings-modes-for-java2d/
-    private static final class BlendingContext implements CompositeContext {
 
-        private int mode;
+  @Override
+  public void vertex(float x, float y, float z) {
+    showDepthWarningXYZ("vertex");
+  }
 
-        private BlendingContext(int mode) {
-            this.mode = mode;
-        }
+  @Override
+  public void vertex(float[] v) {
+    vertex(v[X], v[Y]);
+  }
 
-        public void dispose() {
-        }
 
-        public void compose(Raster src, Raster dstIn, WritableRaster dstOut) {
-            // not sure if this is really necessary, since we control our buffers
-            if (src.getSampleModel().getDataType() != DataBuffer.TYPE_INT
-                    || dstIn.getSampleModel().getDataType() != DataBuffer.TYPE_INT
-                    || dstOut.getSampleModel().getDataType() != DataBuffer.TYPE_INT) {
-                throw new IllegalStateException("Source and destination must store pixels as INT.");
-            }
+  @Override
+  public void vertex(float x, float y, float u, float v) {
+    showVariationWarning("vertex(x, y, u, v)");
+  }
 
-            int width = Math.min(src.getWidth(), dstIn.getWidth());
-            int height = Math.min(src.getHeight(), dstIn.getHeight());
 
-            int[] srcPixels = new int[width];
-            int[] dstPixels = new int[width];
+  @Override
+  public void vertex(float x, float y, float z, float u, float v) {
+    showDepthWarningXYZ("vertex");
+  }
+
 
-            for (int y = 0; y < height; y++) {
-                src.getDataElements(0, y, width, 1, srcPixels);
-                dstIn.getDataElements(0, y, width, 1, dstPixels);
-                for (int x = 0; x < width; x++) {
-                    dstPixels[x] = blendColor(dstPixels[x], srcPixels[x], mode);
-                }
-                dstOut.setDataElements(0, y, width, 1, dstPixels);
-            }
-        }
+  @Override
+  public void beginContour() {
+    if (openContour) {
+      PGraphics.showWarning("Already called beginContour()");
+      return;
     }
 
-    //////////////////////////////////////////////////////////////
-    // BEZIER VERTICES
-    @Override
-    public void bezierVertex(float x1, float y1,
-            float x2, float y2,
-            float x3, float y3) {
-        bezierVertexCheck();
-        gpath.curveTo(x1, y1, x2, y2, x3, y3);
-    }
+    // draw contours to auxiliary path so main path can be closed later
+    GeneralPath contourPath = auxPath;
+    auxPath = gpath;
+    gpath = contourPath;
 
-    @Override
-    public void bezierVertex(float x2, float y2, float z2,
-            float x3, float y3, float z3,
-            float x4, float y4, float z4) {
-        showDepthWarningXYZ("bezierVertex");
+    if (contourPath != null) {  // first contour does not break
+      breakShape = true;
     }
 
-    //////////////////////////////////////////////////////////////
-    // QUADRATIC BEZIER VERTICES
-    @Override
-    public void quadraticVertex(float ctrlX, float ctrlY,
-            float endX, float endY) {
-        bezierVertexCheck();
-        Point2D cur = gpath.getCurrentPoint();
+    openContour = true;
+  }
 
-        float x1 = (float) cur.getX();
-        float y1 = (float) cur.getY();
 
-        bezierVertex(x1 + ((ctrlX - x1) * 2 / 3.0f), y1 + ((ctrlY - y1) * 2 / 3.0f),
-                endX + ((ctrlX - endX) * 2 / 3.0f), endY + ((ctrlY - endY) * 2 / 3.0f),
-                endX, endY);
+  @Override
+  public void endContour() {
+    if (!openContour) {
+      PGraphics.showWarning("Need to call beginContour() first");
+      return;
     }
 
-    @Override
-    public void quadraticVertex(float x2, float y2, float z2,
-            float x4, float y4, float z4) {
-        showDepthWarningXYZ("quadVertex");
-    }
+    // close this contour
+    if (gpath != null) gpath.closePath();
 
-    //////////////////////////////////////////////////////////////
-    // CURVE VERTICES
-    @Override
-    protected void curveVertexCheck() {
-        super.curveVertexCheck();
-
-        if (curveCoordX == null) {
-            curveCoordX = new float[4];
-            curveCoordY = new float[4];
-            curveDrawX = new float[4];
-            curveDrawY = new float[4];
-        }
-    }
+    // switch back to main path
+    GeneralPath contourPath = gpath;
+    gpath = auxPath;
+    auxPath = contourPath;
 
-    @Override
-    protected void curveVertexSegment(float x1, float y1,
-            float x2, float y2,
-            float x3, float y3,
-            float x4, float y4) {
-        curveCoordX[0] = x1;
-        curveCoordY[0] = y1;
-
-        curveCoordX[1] = x2;
-        curveCoordY[1] = y2;
-
-        curveCoordX[2] = x3;
-        curveCoordY[2] = y3;
-
-        curveCoordX[3] = x4;
-        curveCoordY[3] = y4;
-
-        curveToBezierMatrix.mult(curveCoordX, curveDrawX);
-        curveToBezierMatrix.mult(curveCoordY, curveDrawY);
-
-        // since the paths are continuous,
-        // only the first point needs the actual moveto
-        if (gpath == null) {
-            gpath = new GeneralPath();
-            gpath.moveTo(curveDrawX[0], curveDrawY[0]);
-        }
+    openContour = false;
+  }
 
-        gpath.curveTo(curveDrawX[1], curveDrawY[1],
-                curveDrawX[2], curveDrawY[2],
-                curveDrawX[3], curveDrawY[3]);
-    }
 
-    @Override
-    public void curveVertex(float x, float y, float z) {
-        showDepthWarningXYZ("curveVertex");
+  @Override
+  public void endShape(int mode) {
+    if (openContour) { // correct automagically, notify user
+      endContour();
+      PGraphics.showWarning("Missing endContour() before endShape()");
     }
-
-    //////////////////////////////////////////////////////////////
-    // RENDERER
-    //public void flush()
-    //////////////////////////////////////////////////////////////
-    // POINT, LINE, TRIANGLE, QUAD
-    @Override
-    public void point(float x, float y) {
-        if (stroke) {
-//      if (strokeWeight > 1) {
-            line(x, y, x + EPSILON, y + EPSILON);
-//      } else {
-//        set((int) screenX(x, y), (int) screenY(x, y), strokeColor);
-//      }
+    if (gpath != null) {  // make sure something has been drawn
+      if (shape == POLYGON) {
+        if (mode == CLOSE) {
+          gpath.closePath();
+        }
+        if (auxPath != null) {
+          gpath.append(auxPath, false);
         }
+        drawShape(gpath);
+      }
     }
+    shape = 0;
+  }
 
-    @Override
-    public void line(float x1, float y1, float x2, float y2) {
-        line.setLine(x1, y1, x2, y2);
-        strokeShape(line);
-    }
+  //////////////////////////////////////////////////////////////
 
-    @Override
-    public void triangle(float x1, float y1, float x2, float y2,
-            float x3, float y3) {
-        gpath = new GeneralPath();
-        gpath.moveTo(x1, y1);
-        gpath.lineTo(x2, y2);
-        gpath.lineTo(x3, y3);
-        gpath.closePath();
-        drawShape(gpath);
-    }
+  // CLIPPING
 
-    @Override
-    public void quad(float x1, float y1, float x2, float y2,
-            float x3, float y3, float x4, float y4) {
-        GeneralPath gp = new GeneralPath();
-        gp.moveTo(x1, y1);
-        gp.lineTo(x2, y2);
-        gp.lineTo(x3, y3);
-        gp.lineTo(x4, y4);
-        gp.closePath();
-        drawShape(gp);
-    }
-
-    //////////////////////////////////////////////////////////////
-    // RECT
-    //public void rectMode(int mode)
-    //public void rect(float a, float b, float c, float d)
-    @Override
-    protected void rectImpl(float x1, float y1, float x2, float y2) {
-        rect.setFrame(x1, y1, x2 - x1, y2 - y1);
-        drawShape(rect);
-    }
 
-    //////////////////////////////////////////////////////////////
-    // ELLIPSE
-    //public void ellipseMode(int mode)
-    //public void ellipse(float a, float b, float c, float d)
-    @Override
-    protected void ellipseImpl(float x, float y, float w, float h) {
-        ellipse.setFrame(x, y, w, h);
-        drawShape(ellipse);
-    }
+  @Override
+  protected void clipImpl(float x1, float y1, float x2, float y2) {
+    g2.setClip(new Rectangle2D.Float(x1, y1, x2 - x1, y2 - y1));
+  }
 
-    //////////////////////////////////////////////////////////////
-    // ARC
-    //public void arc(float a, float b, float c, float d,
-    //                float start, float stop)
-    @Override
-    protected void arcImpl(float x, float y, float w, float h,
-            float start, float stop, int mode) {
-        // 0 to 90 in java would be 0 to -90 for p5 renderer
-        // but that won't work, so -90 to 0?
 
-        start = -start * RAD_TO_DEG;
-        stop = -stop * RAD_TO_DEG;
+  @Override
+  public void noClip() {
+    g2.setClip(null);
+  }
 
-        // ok to do this because already checked for NaN
-//    while (start < 0) {
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BLEND
+
+  /**
+   * ( begin auto-generated from blendMode.xml )
+   *
+   * This is a new reference entry for Processing 2.0.It will be updated shortly. ( end auto-generated )
+   *
+   * @webref Rendering
+   */
+  @Override
+  protected void blendModeImpl() {
+    if (blendMode == BLEND) {
+      g2.setComposite(defaultComposite);
+
+    } else {
+      g2.setComposite((ColorModel srcColorModel, ColorModel dstColorModel, RenderingHints hints1) -> new BlendingContext(blendMode));
+    }
+  }
+
+
+  // Blending implementation cribbed from portions of Romain Guy's
+  // demo and terrific writeup on blending modes in Java 2D.
+  // http://www.curious-creature.org/2006/09/20/new-blendings-modes-for-java2d/
+  private static final class BlendingContext implements CompositeContext {
+    private final int mode;
+
+    private BlendingContext(int mode) {
+      this.mode = mode;
+    }
+
+    @Override
+    public void dispose() { }
+
+    @Override
+    public void compose(Raster src, Raster dstIn, WritableRaster dstOut) {
+      // not sure if this is really necessary, since we control our buffers
+      if (src.getSampleModel().getDataType() != DataBuffer.TYPE_INT ||
+          dstIn.getSampleModel().getDataType() != DataBuffer.TYPE_INT ||
+          dstOut.getSampleModel().getDataType() != DataBuffer.TYPE_INT) {
+        throw new IllegalStateException("Source and destination must store pixels as INT.");
+      }
+
+      int width = Math.min(src.getWidth(), dstIn.getWidth());
+      int height = Math.min(src.getHeight(), dstIn.getHeight());
+
+      int[] srcPixels = new int[width];
+      int[] dstPixels = new int[width];
+
+      for (int y = 0; y < height; y++) {
+        src.getDataElements(0, y, width, 1, srcPixels);
+        dstIn.getDataElements(0, y, width, 1, dstPixels);
+        for (int x = 0; x < width; x++) {
+          dstPixels[x] = blendColor(dstPixels[x], srcPixels[x], mode);
+        }
+        dstOut.setDataElements(0, y, width, 1, dstPixels);
+      }
+    }
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BEZIER VERTICES
+
+
+  @Override
+  public void bezierVertex(float x1, float y1,
+                           float x2, float y2,
+                           float x3, float y3) {
+    bezierVertexCheck();
+    gpath.curveTo(x1, y1, x2, y2, x3, y3);
+  }
+
+
+  @Override
+  public void bezierVertex(float x2, float y2, float z2,
+                           float x3, float y3, float z3,
+                           float x4, float y4, float z4) {
+    showDepthWarningXYZ("bezierVertex");
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // QUADRATIC BEZIER VERTICES
+
+
+  @Override
+  public void quadraticVertex(float ctrlX, float ctrlY,
+                         float endX, float endY) {
+    bezierVertexCheck();
+    Point2D cur = gpath.getCurrentPoint();
+
+    float x1 = (float) cur.getX();
+    float y1 = (float) cur.getY();
+
+    bezierVertex(x1 + ((ctrlX-x1)*2/3.0f), y1 + ((ctrlY-y1)*2/3.0f),
+                 endX + ((ctrlX-endX)*2/3.0f), endY + ((ctrlY-endY)*2/3.0f),
+                 endX, endY);
+  }
+
+
+  @Override
+  public void quadraticVertex(float x2, float y2, float z2,
+                         float x4, float y4, float z4) {
+    showDepthWarningXYZ("quadVertex");
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CURVE VERTICES
+
+
+  @Override
+  protected void curveVertexCheck() {
+    super.curveVertexCheck();
+
+    if (curveCoordX == null) {
+      curveCoordX = new float[4];
+      curveCoordY = new float[4];
+      curveDrawX = new float[4];
+      curveDrawY = new float[4];
+    }
+  }
+
+
+  @Override
+  protected void curveVertexSegment(float x1, float y1,
+                                    float x2, float y2,
+                                    float x3, float y3,
+                                    float x4, float y4) {
+    curveCoordX[0] = x1;
+    curveCoordY[0] = y1;
+
+    curveCoordX[1] = x2;
+    curveCoordY[1] = y2;
+
+    curveCoordX[2] = x3;
+    curveCoordY[2] = y3;
+
+    curveCoordX[3] = x4;
+    curveCoordY[3] = y4;
+
+    curveToBezierMatrix.mult(curveCoordX, curveDrawX);
+    curveToBezierMatrix.mult(curveCoordY, curveDrawY);
+
+    // since the paths are continuous,
+    // only the first point needs the actual moveto
+    if (gpath == null) {
+      gpath = new GeneralPath();
+      gpath.moveTo(curveDrawX[0], curveDrawY[0]);
+    }
+
+    gpath.curveTo(curveDrawX[1], curveDrawY[1],
+                  curveDrawX[2], curveDrawY[2],
+                  curveDrawX[3], curveDrawY[3]);
+  }
+
+
+  @Override
+  public void curveVertex(float x, float y, float z) {
+    showDepthWarningXYZ("curveVertex");
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // RENDERER
+
+
+  //public void flush()
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // POINT, LINE, TRIANGLE, QUAD
+
+
+  @Override
+  public void point(float x, float y) {
+    if (stroke) {
+//      if (strokeWeight > 1) {
+      line(x, y, x + EPSILON, y + EPSILON);
+//      } else {
+//        set((int) screenX(x, y), (int) screenY(x, y), strokeColor);
+//      }
+    }
+  }
+
+
+  @Override
+  public void line(float x1, float y1, float x2, float y2) {
+    line.setLine(x1, y1, x2, y2);
+    strokeShape(line);
+  }
+
+
+  @Override
+  public void triangle(float x1, float y1, float x2, float y2,
+                       float x3, float y3) {
+    gpath = new GeneralPath();
+    gpath.moveTo(x1, y1);
+    gpath.lineTo(x2, y2);
+    gpath.lineTo(x3, y3);
+    gpath.closePath();
+    drawShape(gpath);
+  }
+
+
+  @Override
+  public void quad(float x1, float y1, float x2, float y2,
+                   float x3, float y3, float x4, float y4) {
+    GeneralPath gp = new GeneralPath();
+    gp.moveTo(x1, y1);
+    gp.lineTo(x2, y2);
+    gp.lineTo(x3, y3);
+    gp.lineTo(x4, y4);
+    gp.closePath();
+    drawShape(gp);
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // RECT
+
+
+  //public void rectMode(int mode)
+
+
+  //public void rect(float a, float b, float c, float d)
+
+
+  @Override
+  protected void rectImpl(float x1, float y1, float x2, float y2) {
+    rect.setFrame(x1, y1, x2-x1, y2-y1);
+    drawShape(rect);
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // ELLIPSE
+
+
+  //public void ellipseMode(int mode)
+
+
+  //public void ellipse(float a, float b, float c, float d)
+
+
+  @Override
+  protected void ellipseImpl(float x, float y, float w, float h) {
+    ellipse.setFrame(x, y, w, h);
+    drawShape(ellipse);
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // ARC
+
+
+  //public void arc(float a, float b, float c, float d,
+  //                float start, float stop)
+
+
+  @Override
+  protected void arcImpl(float x, float y, float w, float h,
+                         float start, float stop, int mode) {
+    // 0 to 90 in java would be 0 to -90 for p5 renderer
+    // but that won't work, so -90 to 0?
+
+    start = -start * RAD_TO_DEG;
+    stop = -stop * RAD_TO_DEG;
+
+    // ok to do this because already checked for NaN
+//    while (start < 0) {
 //      start += 360;
 //      stop += 360;
 //    }
@@ -1149,137 +1286,197 @@ public class PGraphicsJava2D extends PGraphics {
 //      start = stop;
 //      stop = temp;
 //    }
-        float sweep = stop - start;
+    float sweep = stop - start;
+
+    // The defaults, before 2.0b7, were to stroke as Arc2D.OPEN, and then fill
+    // using Arc2D.PIE. That's a little wonky, but it's here for compatability.
+    int fillMode = Arc2D.PIE;
+    int strokeMode = Arc2D.OPEN;
+
+    switch (mode) {
+      case OPEN:
+        fillMode = Arc2D.OPEN;
+        //strokeMode = Arc2D.OPEN;
+        break;
+      case PIE:
+        //fillMode = Arc2D.PIE;
+        strokeMode = Arc2D.PIE;
+        break;
+      case CHORD:
+        fillMode = Arc2D.CHORD;
+        strokeMode = Arc2D.CHORD;
+        break;
+      default:
+        break;
+    }
+
+    if (fill) {
+      //System.out.println("filla");
+      arc.setArc(x, y, w, h, start, sweep, fillMode);
+      fillShape(arc);
+    }
+    if (stroke) {
+      //System.out.println("strokey");
+      arc.setArc(x, y, w, h, start, sweep, strokeMode);
+      strokeShape(arc);
+    }
+  }
 
-        // The defaults, before 2.0b7, were to stroke as Arc2D.OPEN, and then fill
-        // using Arc2D.PIE. That's a little wonky, but it's here for compatability.
-        int fillMode = Arc2D.PIE;
-        int strokeMode = Arc2D.OPEN;
 
-        if (mode == OPEN) {
-            fillMode = Arc2D.OPEN;
-            //strokeMode = Arc2D.OPEN;
 
-        } else if (mode == PIE) {
-            //fillMode = Arc2D.PIE;
-            strokeMode = Arc2D.PIE;
+  //////////////////////////////////////////////////////////////
 
-        } else if (mode == CHORD) {
-            fillMode = Arc2D.CHORD;
-            strokeMode = Arc2D.CHORD;
-        }
+  // JAVA2D SHAPE/PATH HANDLING
 
-        if (fill) {
-            //System.out.println("filla");
-            arc.setArc(x, y, w, h, start, sweep, fillMode);
-            fillShape(arc);
-        }
-        if (stroke) {
-            //System.out.println("strokey");
-            arc.setArc(x, y, w, h, start, sweep, strokeMode);
-            strokeShape(arc);
-        }
-    }
 
-    //////////////////////////////////////////////////////////////
-    // JAVA2D SHAPE/PATH HANDLING
-    protected void fillShape(Shape s) {
-        if (fillGradient) {
-            g2.setPaint(fillGradientObject);
-            g2.fill(s);
-        } else if (fill) {
-            g2.setColor(fillColorObject);
-            g2.fill(s);
-        }
+  protected void fillShape(Shape s) {
+    if (fillGradient) {
+      g2.setPaint(fillGradientObject);
+      g2.fill(s);
+    } else if (fill) {
+      g2.setColor(fillColorObject);
+      g2.fill(s);
     }
+  }
 
-    protected void strokeShape(Shape s) {
-        if (strokeGradient) {
-            g2.setPaint(strokeGradientObject);
-            g2.draw(s);
-        } else if (stroke) {
-            g2.setColor(strokeColorObject);
-            g2.draw(s);
-        }
-    }
 
-    protected void drawShape(Shape s) {
-        if (fillGradient) {
-            g2.setPaint(fillGradientObject);
-            g2.fill(s);
-        } else if (fill) {
-            g2.setColor(fillColorObject);
-            g2.fill(s);
-        }
-        if (strokeGradient) {
-            g2.setPaint(strokeGradientObject);
-            g2.draw(s);
-        } else if (stroke) {
-            g2.setColor(strokeColorObject);
-            g2.draw(s);
-        }
+  protected void strokeShape(Shape s) {
+    if (strokeGradient) {
+      g2.setPaint(strokeGradientObject);
+      g2.draw(s);
+    } else if (stroke) {
+      g2.setColor(strokeColorObject);
+      g2.draw(s);
     }
+  }
 
-    //////////////////////////////////////////////////////////////
-    // BOX
-    //public void box(float size)
-    @Override
-    public void box(float w, float h, float d) {
-        showMethodWarning("box");
-    }
 
-    //////////////////////////////////////////////////////////////
-    // SPHERE
-    //public void sphereDetail(int res)
-    //public void sphereDetail(int ures, int vres)
-    @Override
-    public void sphere(float r) {
-        showMethodWarning("sphere");
+  protected void drawShape(Shape s) {
+    if (fillGradient) {
+      g2.setPaint(fillGradientObject);
+      g2.fill(s);
+    } else if (fill) {
+      g2.setColor(fillColorObject);
+      g2.fill(s);
+    }
+    if (strokeGradient) {
+      g2.setPaint(strokeGradientObject);
+      g2.draw(s);
+    } else if (stroke) {
+      g2.setColor(strokeColorObject);
+      g2.draw(s);
     }
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BOX
+
+
+  //public void box(float size)
+
+
+  @Override
+  public void box(float w, float h, float d) {
+    showMethodWarning("box");
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SPHERE
+
+
+  //public void sphereDetail(int res)
+
+
+  //public void sphereDetail(int ures, int vres)
+
+
+  @Override
+  public void sphere(float r) {
+    showMethodWarning("sphere");
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BEZIER
+
+
+  //public float bezierPoint(float a, float b, float c, float d, float t)
+
+
+  //public float bezierTangent(float a, float b, float c, float d, float t)
+
+
+  //protected void bezierInitCheck()
+
+
+  //protected void bezierInit()
+
+
+  /** Ignored (not needed) in Java 2D. */
+  @Override
+  public void bezierDetail(int detail) {
+  }
+
+
+  //public void bezier(float x1, float y1,
+  //                   float x2, float y2,
+  //                   float x3, float y3,
+  //                   float x4, float y4)
+
+
+  //public void bezier(float x1, float y1, float z1,
+  //                   float x2, float y2, float z2,
+  //                   float x3, float y3, float z3,
+  //                   float x4, float y4, float z4)
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CURVE
+
+
+  //public float curvePoint(float a, float b, float c, float d, float t)
+
+
+  //public float curveTangent(float a, float b, float c, float d, float t)
+
+
+  /** Ignored (not needed) in Java 2D. */
+  @Override
+  public void curveDetail(int detail) {
+  }
+
+  //public void curveTightness(float tightness)
+
+
+  //protected void curveInitCheck()
+
+
+  //protected void curveInit()
+
+
+  //public void curve(float x1, float y1,
+  //                  float x2, float y2,
+  //                  float x3, float y3,
+  //                  float x4, float y4)
+
+
+  //public void curve(float x1, float y1, float z1,
+  //                  float x2, float y2, float z2,
+  //                  float x3, float y3, float z3,
+  //                  float x4, float y4, float z4)
+
+
 
-    //////////////////////////////////////////////////////////////
-    // BEZIER
-    //public float bezierPoint(float a, float b, float c, float d, float t)
-    //public float bezierTangent(float a, float b, float c, float d, float t)
-    //protected void bezierInitCheck()
-    //protected void bezierInit()
-    /**
-     * Ignored (not needed) in Java 2D.
-     */
-    @Override
-    public void bezierDetail(int detail) {
-    }
-
-    //public void bezier(float x1, float y1,
-    //                   float x2, float y2,
-    //                   float x3, float y3,
-    //                   float x4, float y4)
-    //public void bezier(float x1, float y1, float z1,
-    //                   float x2, float y2, float z2,
-    //                   float x3, float y3, float z3,
-    //                   float x4, float y4, float z4)
-    //////////////////////////////////////////////////////////////
-    // CURVE
-    //public float curvePoint(float a, float b, float c, float d, float t)
-    //public float curveTangent(float a, float b, float c, float d, float t)
-    /**
-     * Ignored (not needed) in Java 2D.
-     */
-    @Override
-    public void curveDetail(int detail) {
-    }
-
-    //public void curveTightness(float tightness)
-    //protected void curveInitCheck()
-    //protected void curveInit()
-    //public void curve(float x1, float y1,
-    //                  float x2, float y2,
-    //                  float x3, float y3,
-    //                  float x4, float y4)
-    //public void curve(float x1, float y1, float z1,
-    //                  float x2, float y2, float z2,
-    //                  float x3, float y3, float z3,
-    //                  float x4, float y4, float z4)
 //  //////////////////////////////////////////////////////////////
 //
 //  // SMOOTH
@@ -1343,102 +1540,114 @@ public class PGraphicsJava2D extends PGraphics {
 //    g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
 //                        RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
 //  }
-    //////////////////////////////////////////////////////////////
-    // IMAGE
-    //public void imageMode(int mode)
-    //public void image(PImage image, float x, float y)
-    //public void image(PImage image, float x, float y, float c, float d)
-    //public void image(PImage image,
-    //                  float a, float b, float c, float d,
-    //                  int u1, int v1, int u2, int v2)
-    /**
-     * Handle renderer-specific image drawing.
-     */
-    @Override
-    protected void imageImpl(PImage who,
-            float x1, float y1, float x2, float y2,
-            int u1, int v1, int u2, int v2) {
-        // Image not ready yet, or an error
-        if (who.width <= 0 || who.height <= 0) {
-            return;
-        }
 
-        ImageCache cash = (ImageCache) getCache(who);
 
-        // Nuke the cache if the image was resized
-        if (cash != null) {
-            if (who.pixelWidth != cash.image.getWidth()
-                    || who.pixelHeight != cash.image.getHeight()) {
-                cash = null;
-            }
-        }
 
-        if (cash == null) {
-            //System.out.println("making new image cache");
-            cash = new ImageCache(); //who);
-            setCache(who, cash);
-            who.updatePixels();  // mark the whole thing for update
-            who.setModified();
-        }
+  //////////////////////////////////////////////////////////////
 
-        // If image previously was tinted, or the color changed
-        // or the image was tinted, and tint is now disabled
-        if ((tint && !cash.tinted)
-                || (tint && (cash.tintedColor != tintColor))
-                || (!tint && cash.tinted)) {
-            // For tint change, mark all pixels as needing update.
-            who.updatePixels();
-        }
+  // IMAGE
 
-        if (who.isModified()) {
-            if (who.pixels == null) {
-                // This might be a PGraphics that hasn't been drawn to yet.
-                // Can't just bail because the cache has been created above.
-                // https://github.com/processing/processing/issues/2208
-                who.pixels = new int[who.pixelWidth * who.pixelHeight];
-            }
-            cash.update(who, tint, tintColor);
-            who.setModified(false);
-        }
 
-        u1 *= who.pixelDensity;
-        v1 *= who.pixelDensity;
-        u2 *= who.pixelDensity;
-        v2 *= who.pixelDensity;
+  //public void imageMode(int mode)
 
-        g2.drawImage(((ImageCache) getCache(who)).image,
-                (int) x1, (int) y1, (int) x2, (int) y2,
-                u1, v1, u2, v2, null);
 
-        // Every few years I think "nah, Java2D couldn't possibly be that f*king
-        // slow, why are we doing this by hand?" then comes the affirmation:
-//    Composite oldComp = null;
-//    if (false && tint) {
-//      oldComp = g2.getComposite();
-//      int alpha = (tintColor >> 24) & 0xff;
-//      System.out.println("using alpha composite");
-//      Composite alphaComp =
-//        AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha / 255f);
-//      g2.setComposite(alphaComp);
-//    }
-//
-//    long t = System.currentTimeMillis();
-//    g2.drawImage(who.getImage(),
-//                 (int) x1, (int) y1, (int) x2, (int) y2,
-//                 u1, v1, u2, v2, null);
+  //public void image(PImage image, float x, float y)
+
+
+  //public void image(PImage image, float x, float y, float c, float d)
+
+
+  //public void image(PImage image,
+  //                  float a, float b, float c, float d,
+  //                  int u1, int v1, int u2, int v2)
+
+
+  /**
+   * Handle renderer-specific image drawing.
+   */
+  @Override
+  protected void imageImpl(PImage who,
+                           float x1, float y1, float x2, float y2,
+                           int u1, int v1, int u2, int v2) {
+    // Image not ready yet, or an error
+    if (who.width <= 0 || who.height <= 0) return;
+
+    ImageCache cash = (ImageCache) getCache(who);
+
+    // Nuke the cache if the image was resized
+    if (cash != null) {
+      if (who.pixelWidth != cash.image.getWidth() ||
+          who.pixelHeight != cash.image.getHeight()) {
+        cash = null;
+      }
+    }
+
+    if (cash == null) {
+      //System.out.println("making new image cache");
+      cash = new ImageCache(); //who);
+      setCache(who, cash);
+      who.updatePixels();  // mark the whole thing for update
+      who.setModified();
+    }
+
+    // If image previously was tinted, or the color changed
+    // or the image was tinted, and tint is now disabled
+    if ((tint && !cash.tinted) ||
+        (tint && (cash.tintedColor != tintColor)) ||
+        (!tint && cash.tinted)) {
+      // For tint change, mark all pixels as needing update.
+      who.updatePixels();
+    }
+
+    if (who.isModified()) {
+      if (who.pixels == null) {
+        // This might be a PGraphics that hasn't been drawn to yet.
+        // Can't just bail because the cache has been created above.
+        // https://github.com/processing/processing/issues/2208
+        who.pixels = new int[who.pixelWidth * who.pixelHeight];
+      }
+      cash.update(who, tint, tintColor);
+      who.setModified(false);
+    }
+
+    u1 *= who.pixelDensity;
+    v1 *= who.pixelDensity;
+    u2 *= who.pixelDensity;
+    v2 *= who.pixelDensity;
+
+    g2.drawImage(((ImageCache) getCache(who)).image,
+                 (int) x1, (int) y1, (int) x2, (int) y2,
+                 u1, v1, u2, v2, null);
+
+    // Every few years I think "nah, Java2D couldn't possibly be that f*king
+    // slow, why are we doing this by hand?" then comes the affirmation:
+//    Composite oldComp = null;
+//    if (false && tint) {
+//      oldComp = g2.getComposite();
+//      int alpha = (tintColor >> 24) & 0xff;
+//      System.out.println("using alpha composite");
+//      Composite alphaComp =
+//        AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha / 255f);
+//      g2.setComposite(alphaComp);
+//    }
+//
+//    long t = System.currentTimeMillis();
+//    g2.drawImage(who.getImage(),
+//                 (int) x1, (int) y1, (int) x2, (int) y2,
+//                 u1, v1, u2, v2, null);
 //    System.out.println(System.currentTimeMillis() - t);
 //
 //    if (oldComp != null) {
 //      g2.setComposite(oldComp);
 //    }
-    }
+  }
 
-    static class ImageCache {
 
-        boolean tinted;
-        int tintedColor;
-        int[] tintedTemp;  // one row of tinted pixels
-        BufferedImage image;
+  static class ImageCache {
+    boolean tinted;
+    int tintedColor;
+    int[] tintedTemp;  // one row of tinted pixels
+    BufferedImage image;
 //    BufferedImage compat;
 
 //    public ImageCache(PImage source) {
@@ -1449,145 +1658,149 @@ public class PGraphicsJava2D extends PGraphics {
 //      //System.out.println("making new buffered image");
 ////      image = new BufferedImage(source.width, source.height, type);
 //    }
-        /**
-         * Update the pixels of the cache image. Already determined that the
-         * tint has changed, or the pixels have changed, so should just go
-         * through with the update without further checks.
-         */
-        public void update(PImage source, boolean tint, int tintColor) {
-            //int bufferType = BufferedImage.TYPE_INT_ARGB;
-            int targetType = ARGB;
-            boolean opaque = (tintColor & 0xFF000000) == 0xFF000000;
-            if (source.format == RGB) {
-                if (!tint || (tint && opaque)) {
-                    //bufferType = BufferedImage.TYPE_INT_RGB;
-                    targetType = RGB;
-                }
-            }
+
+    /**
+     * Update the pixels of the cache image. Already determined that the tint
+     * has changed, or the pixels have changed, so should just go through
+     * with the update without further checks.
+     */
+    public void update(PImage source, boolean tint, int tintColor) {
+      //int bufferType = BufferedImage.TYPE_INT_ARGB;
+      int targetType = ARGB;
+      boolean opaque = (tintColor & 0xFF000000) == 0xFF000000;
+      if (source.format == RGB) {
+        if (!tint || (tint && opaque)) {
+          //bufferType = BufferedImage.TYPE_INT_RGB;
+          targetType = RGB;
+        }
+      }
 //      boolean wrongType = (image != null) && (image.getType() != bufferType);
 //      if ((image == null) || wrongType) {
 //        image = new BufferedImage(source.width, source.height, bufferType);
 //      }
-            // Must always use an ARGB image, otherwise will write zeros
-            // in the alpha channel when drawn to the screen.
-            // https://github.com/processing/processing/issues/2030
-            if (image == null) {
-                image = new BufferedImage(source.pixelWidth, source.pixelHeight,
-                        BufferedImage.TYPE_INT_ARGB);
-            }
+      // Must always use an ARGB image, otherwise will write zeros
+      // in the alpha channel when drawn to the screen.
+      // https://github.com/processing/processing/issues/2030
+      if (image == null) {
+        image = new BufferedImage(source.pixelWidth, source.pixelHeight,
+                                  BufferedImage.TYPE_INT_ARGB);
+      }
 
-            WritableRaster wr = image.getRaster();
-            if (tint) {
-                if (tintedTemp == null || tintedTemp.length != source.pixelWidth) {
-                    tintedTemp = new int[source.pixelWidth];
-                }
-                int a2 = (tintColor >> 24) & 0xff;
+      WritableRaster wr = image.getRaster();
+      if (tint) {
+        if (tintedTemp == null || tintedTemp.length != source.pixelWidth) {
+          tintedTemp = new int[source.pixelWidth];
+        }
+        int a2 = (tintColor >> 24) & 0xff;
 //        System.out.println("tint color is " + a2);
 //        System.out.println("source.pixels[0] alpha is " + (source.pixels[0] >>> 24));
-                int r2 = (tintColor >> 16) & 0xff;
-                int g2 = (tintColor >> 8) & 0xff;
-                int b2 = (tintColor) & 0xff;
-
-                //if (bufferType == BufferedImage.TYPE_INT_RGB) {
-                if (targetType == RGB) {
-                    // The target image is opaque, meaning that the source image has no
-                    // alpha (is not ARGB), and the tint has no alpha.
-                    int index = 0;
-                    for (int y = 0; y < source.pixelHeight; y++) {
-                        for (int x = 0; x < source.pixelWidth; x++) {
-                            int argb1 = source.pixels[index++];
-                            int r1 = (argb1 >> 16) & 0xff;
-                            int g1 = (argb1 >> 8) & 0xff;
-                            int b1 = (argb1) & 0xff;
-
-                            // Prior to 2.1, the alpha channel was commented out here,
-                            // but can't remember why (just thought unnecessary b/c of RGB?)
-                            // https://github.com/processing/processing/issues/2030
-                            tintedTemp[x] = 0xFF000000
-                                    | (((r2 * r1) & 0xff00) << 8)
-                                    | ((g2 * g1) & 0xff00)
-                                    | (((b2 * b1) & 0xff00) >> 8);
-                        }
-                        wr.setDataElements(0, y, source.pixelWidth, 1, tintedTemp);
-                    }
-                    // could this be any slower?
+        int r2 = (tintColor >> 16) & 0xff;
+        int g2 = (tintColor >> 8) & 0xff;
+        int b2 = (tintColor) & 0xff;
+
+        //if (bufferType == BufferedImage.TYPE_INT_RGB) {
+        if (targetType == RGB) {
+          // The target image is opaque, meaning that the source image has no
+          // alpha (is not ARGB), and the tint has no alpha.
+          int index = 0;
+          for (int y = 0; y < source.pixelHeight; y++) {
+            for (int x = 0; x < source.pixelWidth; x++) {
+              int argb1 = source.pixels[index++];
+              int r1 = (argb1 >> 16) & 0xff;
+              int g1 = (argb1 >> 8) & 0xff;
+              int b1 = (argb1) & 0xff;
+
+              // Prior to 2.1, the alpha channel was commented out here,
+              // but can't remember why (just thought unnecessary b/c of RGB?)
+              // https://github.com/processing/processing/issues/2030
+              tintedTemp[x] = 0xFF000000 |
+                  (((r2 * r1) & 0xff00) << 8) |
+                  ((g2 * g1) & 0xff00) |
+                  (((b2 * b1) & 0xff00) >> 8);
+            }
+            wr.setDataElements(0, y, source.pixelWidth, 1, tintedTemp);
+          }
+          // could this be any slower?
 //          float[] scales = { tintR, tintG, tintB };
 //          float[] offsets = new float[3];
 //          RescaleOp op = new RescaleOp(scales, offsets, null);
 //          op.filter(image, image);
 
-                    //} else if (bufferType == BufferedImage.TYPE_INT_ARGB) {
-                } else if (targetType == ARGB) {
-                    if (source.format == RGB
-                            && (tintColor & 0xffffff) == 0xffffff) {
-                        int hi = tintColor & 0xff000000;
-                        int index = 0;
-                        for (int y = 0; y < source.pixelHeight; y++) {
-                            for (int x = 0; x < source.pixelWidth; x++) {
-                                tintedTemp[x] = hi | (source.pixels[index++] & 0xFFFFFF);
-                            }
-                            wr.setDataElements(0, y, source.pixelWidth, 1, tintedTemp);
-                        }
-                    } else {
-                        int index = 0;
-                        for (int y = 0; y < source.pixelHeight; y++) {
-                            if (source.format == RGB) {
-                                int alpha = tintColor & 0xFF000000;
-                                for (int x = 0; x < source.pixelWidth; x++) {
-                                    int argb1 = source.pixels[index++];
-                                    int r1 = (argb1 >> 16) & 0xff;
-                                    int g1 = (argb1 >> 8) & 0xff;
-                                    int b1 = (argb1) & 0xff;
-                                    tintedTemp[x] = alpha
-                                            | (((r2 * r1) & 0xff00) << 8)
-                                            | ((g2 * g1) & 0xff00)
-                                            | (((b2 * b1) & 0xff00) >> 8);
-                                }
-                            } else if (source.format == ARGB) {
-                                for (int x = 0; x < source.pixelWidth; x++) {
-                                    int argb1 = source.pixels[index++];
-                                    int a1 = (argb1 >> 24) & 0xff;
-                                    int r1 = (argb1 >> 16) & 0xff;
-                                    int g1 = (argb1 >> 8) & 0xff;
-                                    int b1 = (argb1) & 0xff;
-                                    tintedTemp[x]
-                                            = (((a2 * a1) & 0xff00) << 16)
-                                            | (((r2 * r1) & 0xff00) << 8)
-                                            | ((g2 * g1) & 0xff00)
-                                            | (((b2 * b1) & 0xff00) >> 8);
-                                }
-                            } else if (source.format == ALPHA) {
-                                int lower = tintColor & 0xFFFFFF;
-                                for (int x = 0; x < source.pixelWidth; x++) {
-                                    int a1 = source.pixels[index++];
-                                    tintedTemp[x]
-                                            = (((a2 * a1) & 0xff00) << 16) | lower;
-                                }
-                            }
-                            wr.setDataElements(0, y, source.pixelWidth, 1, tintedTemp);
-                        }
-                    }
-                    // Not sure why ARGB images take the scales in this order...
+        //} else if (bufferType == BufferedImage.TYPE_INT_ARGB) {
+        } else if (targetType == ARGB) {
+          if (source.format == RGB &&
+              (tintColor & 0xffffff) == 0xffffff) {
+            int hi = tintColor & 0xff000000;
+            int index = 0;
+            for (int y = 0; y < source.pixelHeight; y++) {
+              for (int x = 0; x < source.pixelWidth; x++) {
+                tintedTemp[x] = hi | (source.pixels[index++] & 0xFFFFFF);
+              }
+              wr.setDataElements(0, y, source.pixelWidth, 1, tintedTemp);
+            }
+          } else {
+            int index = 0;
+            for (int y = 0; y < source.pixelHeight; y++) {
+              switch (source.format) {
+                case RGB:
+                  int alpha = tintColor & 0xFF000000;
+                  for (int x = 0; x < source.pixelWidth; x++) {
+                    int argb1 = source.pixels[index++];
+                    int r1 = (argb1 >> 16) & 0xff;
+                    int g1 = (argb1 >> 8) & 0xff;
+                    int b1 = (argb1) & 0xff;
+                    tintedTemp[x] = alpha |
+                      (((r2 * r1) & 0xff00) << 8) |
+                      ((g2 * g1) & 0xff00) |
+                      (((b2 * b1) & 0xff00) >> 8);
+                  } break;
+                case ARGB:
+                  for (int x = 0; x < source.pixelWidth; x++) {
+                    int argb1 = source.pixels[index++];
+                    int a1 = (argb1 >> 24) & 0xff;
+                    int r1 = (argb1 >> 16) & 0xff;
+                    int g1 = (argb1 >> 8) & 0xff;
+                    int b1 = (argb1) & 0xff;
+                    tintedTemp[x] =
+                      (((a2 * a1) & 0xff00) << 16) |
+                      (((r2 * r1) & 0xff00) << 8) |
+                      ((g2 * g1) & 0xff00) |
+                      (((b2 * b1) & 0xff00) >> 8);
+                  } break;
+                case ALPHA:
+                  int lower = tintColor & 0xFFFFFF;
+                  for (int x = 0; x < source.pixelWidth; x++) {
+                    int a1 = source.pixels[index++];
+                    tintedTemp[x] =
+                      (((a2 * a1) & 0xff00) << 16) | lower;
+                  } break;
+                default:
+                  break;
+              }
+              wr.setDataElements(0, y, source.pixelWidth, 1, tintedTemp);
+            }
+          }
+          // Not sure why ARGB images take the scales in this order...
 //          float[] scales = { tintR, tintG, tintB, tintA };
 //          float[] offsets = new float[4];
 //          RescaleOp op = new RescaleOp(scales, offsets, null);
 //          op.filter(image, image);
-                }
-            } else {  // !tint
-                if (targetType == RGB && (source.pixels[0] >> 24 == 0)) {
-                    // If it's an RGB image and the high bits aren't set, need to set
-                    // the high bits to opaque because we're drawing ARGB images.
-                    source.filter(OPAQUE);
-                    // Opting to just manipulate the image here, since it shouldn't
-                    // affect anything else (and alpha(get(x, y)) should return 0xff).
-                    // Wel also make no guarantees about the values of the pixels array
-                    // in a PImage and how the high bits will be set.
-                }
-                // If no tint, just shove the pixels on in there verbatim
-                wr.setDataElements(0, 0, source.pixelWidth, source.pixelHeight, source.pixels);
-            }
-            this.tinted = tint;
-            this.tintedColor = tintColor;
+        }
+      } else {  // !tint
+        if (targetType == RGB && (source.pixels[0] >> 24 == 0)) {
+          // If it's an RGB image and the high bits aren't set, need to set
+          // the high bits to opaque because we're drawing ARGB images.
+          source.filter(OPAQUE);
+          // Opting to just manipulate the image here, since it shouldn't
+          // affect anything else (and alpha(get(x, y)) should return 0xff).
+          // Wel also make no guarantees about the values of the pixels array
+          // in a PImage and how the high bits will be set.
+        }
+        // If no tint, just shove the pixels on in there verbatim
+        wr.setDataElements(0, 0, source.pixelWidth, source.pixelHeight, source.pixels);
+      }
+      this.tinted = tint;
+      this.tintedColor = tintColor;
 
 //      GraphicsConfiguration gc = parent.getGraphicsConfiguration();
 //      compat = gc.createCompatibleImage(image.getWidth(),
@@ -1597,132 +1810,175 @@ public class PGraphicsJava2D extends PGraphics {
 //      Graphics2D g = compat.createGraphics();
 //      g.drawImage(image, 0, 0, null);
 //      g.dispose();
-        }
     }
+  }
 
-    //////////////////////////////////////////////////////////////
-    // SHAPE
-    //public void shapeMode(int mode)
-    //public void shape(PShape shape)
-    //public void shape(PShape shape, float x, float y)
-    //public void shape(PShape shape, float x, float y, float c, float d)
-    //////////////////////////////////////////////////////////////
-    // SHAPE I/O
-    //public PShape loadShape(String filename)
-    @Override
-    public PShape loadShape(String filename, String options) {
-        String extension = PApplet.getExtension(filename);
-        if (extension.equals("svg") || extension.equals("svgz")) {
-            return new PShapeJava2D(parent.loadXML(filename));
-        }
-        PGraphics.showWarning("Unsupported format: " + filename);
-        return null;
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE
+
+
+  //public void shapeMode(int mode)
+
+
+  //public void shape(PShape shape)
+
+
+  //public void shape(PShape shape, float x, float y)
+
+
+  //public void shape(PShape shape, float x, float y, float c, float d)
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SHAPE I/O
+
+
+  //public PShape loadShape(String filename)
+
+
+  @Override
+  public PShape loadShape(String filename, String options) {
+    String extension = PApplet.getExtension(filename);
+    if (extension.equals("svg") || extension.equals("svgz")) {
+      return new PShapeJava2D(parent.loadXML(filename));
     }
+    PGraphics.showWarning("Unsupported format: " + filename);
+    return null;
+  }
 
-    //////////////////////////////////////////////////////////////
-    // TEXT ATTRIBTUES
-    //public void textAlign(int align)
-    //public void textAlign(int alignX, int alignY)
-    @Override
-    public float textAscent() {
-        if (textFont == null) {
-            defaultFontOrDeath("textAscent");
-        }
 
-        Font font = (Font) textFont.getNative();
-        if (font != null) {
-            //return getFontMetrics(font).getAscent();
-            return g2.getFontMetrics(font).getAscent();
-        }
-        return super.textAscent();
+
+  //////////////////////////////////////////////////////////////
+
+  // TEXT ATTRIBTUES
+
+
+  //public void textAlign(int align)
+
+
+  //public void textAlign(int alignX, int alignY)
+
+
+  @Override
+  public float textAscent() {
+    if (textFont == null) {
+      defaultFontOrDeath("textAscent");
     }
 
-    @Override
-    public float textDescent() {
-        if (textFont == null) {
-            defaultFontOrDeath("textDescent");
-        }
-        Font font = (Font) textFont.getNative();
-        if (font != null) {
-            //return getFontMetrics(font).getDescent();
-            return g2.getFontMetrics(font).getDescent();
-        }
-        return super.textDescent();
+    Font font = (Font) textFont.getNative();
+    if (font != null) {
+      //return getFontMetrics(font).getAscent();
+      return g2.getFontMetrics(font).getAscent();
     }
+    return super.textAscent();
+  }
 
-    //public void textFont(PFont which)
-    //public void textFont(PFont which, float size)
-    //public void textLeading(float leading)
-    //public void textMode(int mode)
-    @Override
-    protected boolean textModeCheck(int mode) {
-        return mode == MODEL;
+
+  @Override
+  public float textDescent() {
+    if (textFont == null) {
+      defaultFontOrDeath("textDescent");
+    }
+    Font font = (Font) textFont.getNative();
+    if (font != null) {
+      //return getFontMetrics(font).getDescent();
+      return g2.getFontMetrics(font).getDescent();
     }
+    return super.textDescent();
+  }
 
-    /**
-     * Same as parent, but override for native version of the font.
-     * <p/>
-     * Called from textFontImpl and textSizeImpl, so the metrics will get
-     * recorded properly.
-     */
-    @Override
-    protected void handleTextSize(float size) {
-        // if a native version available, derive this font
-        Font font = (Font) textFont.getNative();
-        // don't derive again if the font size has not changed
-        if (font != null) {
-            if (font.getSize2D() != size) {
-                Map<TextAttribute, Object> map
-                        = new HashMap<>();
-                map.put(TextAttribute.SIZE, size);
-                map.put(TextAttribute.KERNING,
-                        TextAttribute.KERNING_ON);
+
+  //public void textFont(PFont which)
+
+
+  //public void textFont(PFont which, float size)
+
+
+  //public void textLeading(float leading)
+
+
+  //public void textMode(int mode)
+
+
+  @Override
+  protected boolean textModeCheck(int mode) {
+    return mode == MODEL;
+  }
+
+
+  /**
+   * Same as parent, but override for native version of the font.
+   * 
+   * Called from textFontImpl and textSizeImpl, so the metrics
+   * will get recorded properly.
+   */
+  @Override
+  protected void handleTextSize(float size) {
+    // if a native version available, derive this font
+    Font font = (Font) textFont.getNative();
+    // don't derive again if the font size has not changed
+    if (font != null) {
+      if (font.getSize2D() != size) {
+        Map<TextAttribute, Object> map =
+          new HashMap<>();
+        map.put(TextAttribute.SIZE, size);
+        map.put(TextAttribute.KERNING,
+                TextAttribute.KERNING_ON);
 //      map.put(TextAttribute.TRACKING,
 //              TextAttribute.TRACKING_TIGHT);
-                font = font.deriveFont(map);
-            }
-            g2.setFont(font);
-            textFont.setNative(font);
-            fontObject = font;
+        font = font.deriveFont(map);
+      }
+      g2.setFont(font);
+      textFont.setNative(font);
+      fontObject = font;
 
-            /*
+      /*
       Map<TextAttribute, ?> attrs = font.getAttributes();
       for (TextAttribute ta : attrs.keySet()) {
         System.out.println(ta + " -> " + attrs.get(ta));
       }
-             */
-        }
-
-        // take care of setting the textSize and textLeading vars
-        // this has to happen second, because it calls textAscent()
-        // (which requires the native font metrics to be set)
-        super.handleTextSize(size);
+      */
     }
 
-    //public float textWidth(char c)
-    //public float textWidth(String str)
-    @Override
-    protected float textWidthImpl(char buffer[], int start, int stop) {
-        if (textFont == null) {
-            defaultFontOrDeath("textWidth");
-        }
-        // Avoid "Zero length string passed to TextLayout constructor" error
-        if (start == stop) {
-            return 0;
-        }
+    // take care of setting the textSize and textLeading vars
+    // this has to happen second, because it calls textAscent()
+    // (which requires the native font metrics to be set)
+    super.handleTextSize(size);
+  }
+
+
+  //public float textWidth(char c)
+
+
+  //public float textWidth(String str)
 
-        Font font = (Font) textFont.getNative();
+
+  @Override
+  protected float textWidthImpl(char[] buffer, int start, int stop) {
+    if (textFont == null) {
+      defaultFontOrDeath("textWidth");
+    }
+    // Avoid "Zero length string passed to TextLayout constructor" error
+    if (start == stop) {
+      return 0;
+    }
+
+    Font font = (Font) textFont.getNative();
 //    System.out.println(font);
-        //if (font != null && (textFont.isStream() || hints[ENABLE_NATIVE_FONTS])) {
-        if (font != null) {
+    //if (font != null && (textFont.isStream() || hints[ENABLE_NATIVE_FONTS])) {
+    if (font != null) {
 //      System.out.println("using charswidth for " + new String(buffer, start, stop-start));
-            // maybe should use one of the newer/fancier functions for this?
+      // maybe should use one of the newer/fancier functions for this?
 //      int length = stop - start;
 //      FontMetrics metrics = getFontMetrics(font);
-            FontMetrics metrics = g2.getFontMetrics(font);
-            // Using fractional metrics makes the measurement worse, not better,
-            // at least on OS X 10.6 (November, 2010).
-            // TextLayout returns the same value as charsWidth().
+      FontMetrics metrics = g2.getFontMetrics(font);
+      // Using fractional metrics makes the measurement worse, not better,
+      // at least on OS X 10.6 (November, 2010).
+      // TextLayout returns the same value as charsWidth().
 //      System.err.println("using native");
 //      g2.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
 //                          RenderingHints.VALUE_FRACTIONALMETRICS_ON);
@@ -1735,32 +1991,48 @@ public class PGraphicsJava2D extends PGraphics {
 ////      return m2;
 ////      return metrics.charsWidth(buffer, start, length);
 //      return m2;
-            return (float) metrics.getStringBounds(buffer, start, stop, g2).getWidth();
-        }
-//    System.err.println("not native");
-        return super.textWidthImpl(buffer, start, stop);
+      return (float)
+        metrics.getStringBounds(buffer, start, stop, g2).getWidth();
     }
+//    System.err.println("not native");
+    return super.textWidthImpl(buffer, start, stop);
+  }
+
 
 //  protected void beginTextScreenMode() {
 //    loadPixels();
 //  }
+
+
 //  protected void endTextScreenMode() {
 //    updatePixels();
 //  }
-    //////////////////////////////////////////////////////////////
-    // TEXT
-    // None of the variations of text() are overridden from PGraphics.
-    //////////////////////////////////////////////////////////////
-    // TEXT IMPL
-    //protected void textLineAlignImpl(char buffer[], int start, int stop,
-    //                                 float x, float y)
-    @Override
-    protected void textLineImpl(char buffer[], int start, int stop,
-            float x, float y) {
-        Font font = (Font) textFont.getNative();
+
+
+  //////////////////////////////////////////////////////////////
+
+  // TEXT
+
+  // None of the variations of text() are overridden from PGraphics.
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // TEXT IMPL
+
+
+  //protected void textLineAlignImpl(char buffer[], int start, int stop,
+  //                                 float x, float y)
+
+
+  @Override
+  protected void textLineImpl(char[] buffer, int start, int stop,
+                              float x, float y) {
+    Font font = (Font) textFont.getNative();
 //    if (font != null && (textFont.isStream() || hints[ENABLE_NATIVE_FONTS])) {
-        if (font != null) {
-            /*
+    if (font != null) {
+      /*
       // save the current setting for text smoothing. note that this is
       // different from the smooth() function, because the font smoothing
       // is controlled when the font is created, not now as it's drawn.
@@ -1774,47 +2046,49 @@ public class PGraphicsJava2D extends PGraphics {
                           textFont.smooth ?
                           RenderingHints.VALUE_ANTIALIAS_ON :
                           RenderingHints.VALUE_ANTIALIAS_OFF);
-             */
-            Object antialias
-                    = g2.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
-            if (antialias == null) {
-                // if smooth() and noSmooth() not called, this will be null (0120)
-                antialias = RenderingHints.VALUE_ANTIALIAS_DEFAULT;
-            }
+      */
+      Object antialias =
+        g2.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
+      if (antialias == null) {
+        // if smooth() and noSmooth() not called, this will be null (0120)
+        antialias = RenderingHints.VALUE_ANTIALIAS_DEFAULT;
+      }
 
-            // override the current smoothing setting based on the font
-            // also changes global setting for antialiasing, but this is because it's
-            // not possible to enable/disable them independently in some situations.
-            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-                    textFont.isSmooth()
-                    ? RenderingHints.VALUE_ANTIALIAS_ON
-                    : RenderingHints.VALUE_ANTIALIAS_OFF);
+      // override the current smoothing setting based on the font
+      // also changes global setting for antialiasing, but this is because it's
+      // not possible to enable/disable them independently in some situations.
+      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+                          textFont.isSmooth() ?
+                          RenderingHints.VALUE_ANTIALIAS_ON :
+                          RenderingHints.VALUE_ANTIALIAS_OFF);
 
-            g2.setColor(fillColorObject);
+      g2.setColor(fillColorObject);
 
-            int length = stop - start;
-            if (length != 0) {
-                g2.drawChars(buffer, start, length, (int) (x + 0.5f), (int) (y + 0.5f));
-                // better to use round here? also, drawChars now just calls drawString
+      int length = stop - start;
+      if (length != 0) {
+      g2.drawChars(buffer, start, length, (int) (x + 0.5f), (int) (y + 0.5f));
+      // better to use round here? also, drawChars now just calls drawString
 //      g2.drawString(new String(buffer, start, stop - start), Math.round(x), Math.round(y));
 
-                // better to use drawString() with floats? (nope, draws the same)
-                //g2.drawString(new String(buffer, start, length), x, y);
-                // this didn't seem to help the scaling issue, and creates garbage
-                // because of a fairly heavyweight new temporary object
+      // better to use drawString() with floats? (nope, draws the same)
+      //g2.drawString(new String(buffer, start, length), x, y);
+
+      // this didn't seem to help the scaling issue, and creates garbage
+      // because of a fairly heavyweight new temporary object
 //      java.awt.font.GlyphVector gv =
 //        font.createGlyphVector(g2.getFontRenderContext(), new String(buffer, start, stop - start));
 //      g2.drawGlyphVector(gv, x, y);
-            }
+      }
 
-            // return to previous smoothing state if it was changed
-            //g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, textAntialias);
-            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antialias);
+      // return to previous smoothing state if it was changed
+      //g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, textAntialias);
+      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, antialias);
 
-        } else {  // otherwise just do the default
-            super.textLineImpl(buffer, start, stop, x, y);
-        }
+    } else {  // otherwise just do the default
+      super.textLineImpl(buffer, start, stop, x, y);
     }
+  }
+
 
 //  /**
 //   * Convenience method to get a legit FontMetrics object. Where possible,
@@ -1838,7 +2112,7 @@ public class PGraphicsJava2D extends PGraphics {
 //    return getFontMetrics(font).getFontRenderContext();
 //  }
 
-    /*
+  /*
   Toolkit toolkit;
 
   @SuppressWarnings("deprecation")
@@ -1852,474 +2126,650 @@ public class PGraphicsJava2D extends PGraphics {
         toolkit = Toolkit.getDefaultToolkit();
       }
     }
-    return toolkit.getFontMetrics(font);
-    //return (g2 != null) ? g2.getFontMetrics(font) : super.getFontMetrics(font);
+    return toolkit.getFontMetrics(font);
+    //return (g2 != null) ? g2.getFontMetrics(font) : super.getFontMetrics(font);
+  }
+  */
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX STACK
+
+
+  @Override
+  public void pushMatrix() {
+    if (transformCount == transformStack.length) {
+      throw new RuntimeException("pushMatrix() cannot use push more than " +
+                                 transformStack.length + " times");
+    }
+    transformStack[transformCount] = g2.getTransform();
+    transformCount++;
+  }
+
+
+  @Override
+  public void popMatrix() {
+    if (transformCount == 0) {
+      throw new RuntimeException("missing a pushMatrix() " +
+                                 "to go with that popMatrix()");
+    }
+    transformCount--;
+    g2.setTransform(transformStack[transformCount]);
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX TRANSFORMS
+
+
+  @Override
+  public void translate(float tx, float ty) {
+    g2.translate(tx, ty);
+  }
+
+
+  //public void translate(float tx, float ty, float tz)
+
+
+  @Override
+  public void rotate(float angle) {
+    g2.rotate(angle);
+  }
+
+
+  @Override
+  public void rotateX(float angle) {
+    showDepthWarning("rotateX");
+  }
+
+
+  @Override
+  public void rotateY(float angle) {
+    showDepthWarning("rotateY");
+  }
+
+
+  @Override
+  public void rotateZ(float angle) {
+    showDepthWarning("rotateZ");
+  }
+
+
+  @Override
+  public void rotate(float angle, float vx, float vy, float vz) {
+    showVariationWarning("rotate");
+  }
+
+
+  @Override
+  public void scale(float s) {
+    g2.scale(s, s);
+  }
+
+
+  @Override
+  public void scale(float sx, float sy) {
+    g2.scale(sx, sy);
+  }
+
+
+  @Override
+  public void scale(float sx, float sy, float sz) {
+    showDepthWarningXYZ("scale");
+  }
+
+
+  @Override
+  public void shearX(float angle) {
+    g2.shear(Math.tan(angle), 0);
+  }
+
+
+  @Override
+  public void shearY(float angle) {
+    g2.shear(0, Math.tan(angle));
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX MORE
+
+
+  @Override
+  public void resetMatrix() {
+    g2.setTransform(new AffineTransform());
+    g2.scale(pixelDensity, pixelDensity);
+  }
+
+
+  //public void applyMatrix(PMatrix2D source)
+
+
+  @Override
+  public void applyMatrix(float n00, float n01, float n02,
+                          float n10, float n11, float n12) {
+    //System.out.println("PGraphicsJava2D.applyMatrix()");
+    //System.out.println(new AffineTransform(n00, n10, n01, n11, n02, n12));
+    g2.transform(new AffineTransform(n00, n10, n01, n11, n02, n12));
+    //g2.transform(new AffineTransform(n00, n01, n02, n10, n11, n12));
+  }
+
+
+  //public void applyMatrix(PMatrix3D source)
+
+
+  @Override
+  public void applyMatrix(float n00, float n01, float n02, float n03,
+                          float n10, float n11, float n12, float n13,
+                          float n20, float n21, float n22, float n23,
+                          float n30, float n31, float n32, float n33) {
+    showVariationWarning("applyMatrix");
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATRIX GET/SET
+
+
+  @Override
+  public PMatrix getMatrix() {
+    return getMatrix((PMatrix2D) null);
+  }
+
+
+  @Override
+  public PMatrix2D getMatrix(PMatrix2D target) {
+    if (target == null) {
+      target = new PMatrix2D();
+    }
+    g2.getTransform().getMatrix(transform);
+    target.set((float) transform[0], (float) transform[2], (float) transform[4],
+               (float) transform[1], (float) transform[3], (float) transform[5]);
+    return target;
+  }
+
+
+  @Override
+  public PMatrix3D getMatrix(PMatrix3D target) {
+    showVariationWarning("getMatrix");
+    return target;
+  }
+
+
+  //public void setMatrix(PMatrix source)
+
+
+  @Override
+  public void setMatrix(PMatrix2D source) {
+    g2.setTransform(new AffineTransform(source.m00, source.m10,
+                                        source.m01, source.m11,
+                                        source.m02, source.m12));
+  }
+
+
+  @Override
+  public void setMatrix(PMatrix3D source) {
+    showVariationWarning("setMatrix");
+  }
+
+
+  @Override
+  public void printMatrix() {
+    getMatrix((PMatrix2D) null).print();
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // CAMERA and PROJECTION
+
+  // Inherit the plaintive warnings from PGraphics
+
+
+  //public void beginCamera()
+  //public void endCamera()
+  //public void camera()
+  //public void camera(float eyeX, float eyeY, float eyeZ,
+  //                   float centerX, float centerY, float centerZ,
+  //                   float upX, float upY, float upZ)
+  //public void printCamera()
+
+  //public void ortho()
+  //public void ortho(float left, float right,
+  //                  float bottom, float top,
+  //                  float near, float far)
+  //public void perspective()
+  //public void perspective(float fov, float aspect, float near, float far)
+  //public void frustum(float left, float right,
+  //                    float bottom, float top,
+  //                    float near, float far)
+  //public void printProjection()
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SCREEN and MODEL transforms
+
+
+  @Override
+  public float screenX(float x, float y) {
+    g2.getTransform().getMatrix(transform);
+    return (float)transform[0]*x + (float)transform[2]*y + (float)transform[4];
+  }
+
+
+  @Override
+  public float screenY(float x, float y) {
+    g2.getTransform().getMatrix(transform);
+    return (float)transform[1]*x + (float)transform[3]*y + (float)transform[5];
+  }
+
+
+  @Override
+  public float screenX(float x, float y, float z) {
+    showDepthWarningXYZ("screenX");
+    return 0;
+  }
+
+
+  @Override
+  public float screenY(float x, float y, float z) {
+    showDepthWarningXYZ("screenY");
+    return 0;
+  }
+
+
+  @Override
+  public float screenZ(float x, float y, float z) {
+    showDepthWarningXYZ("screenZ");
+    return 0;
+  }
+
+
+  //public float modelX(float x, float y, float z)
+
+
+  //public float modelY(float x, float y, float z)
+
+
+  //public float modelZ(float x, float y, float z)
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // STYLE
+
+  // pushStyle(), popStyle(), style() and getStyle() inherited.
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // STROKE CAP/JOIN/WEIGHT
+
+
+  @Override
+  public void strokeCap(int cap) {
+    super.strokeCap(cap);
+    strokeImpl();
+  }
+
+
+  @Override
+  public void strokeJoin(int join) {
+    super.strokeJoin(join);
+    strokeImpl();
+  }
+
+
+  @Override
+  public void strokeWeight(float weight) {
+    super.strokeWeight(weight);
+    strokeImpl();
+  }
+
+
+  protected void strokeImpl() {
+    int cap = BasicStroke.CAP_BUTT;
+    if (strokeCap == ROUND) {
+      cap = BasicStroke.CAP_ROUND;
+    } else if (strokeCap == PROJECT) {
+      cap = BasicStroke.CAP_SQUARE;
+    }
+
+    int join = BasicStroke.JOIN_BEVEL;
+    if (strokeJoin == MITER) {
+      join = BasicStroke.JOIN_MITER;
+    } else if (strokeJoin == ROUND) {
+      join = BasicStroke.JOIN_ROUND;
+    }
+
+    strokeObject = new BasicStroke(strokeWeight, cap, join);
+    g2.setStroke(strokeObject);
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // STROKE
+
+  // noStroke() and stroke() inherited from PGraphics.
+
+
+  @Override
+  protected void strokeFromCalc() {
+    super.strokeFromCalc();
+    strokeColorObject = new Color(strokeColor, true);
+    strokeGradient = false;
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // TINT
+
+  // noTint() and tint() inherited from PGraphics.
+
+
+  @Override
+  protected void tintFromCalc() {
+    super.tintFromCalc();
+    // TODO actually implement tinted images
+    tintColorObject = new Color(tintColor, true);
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // FILL
+
+  // noFill() and fill() inherited from PGraphics.
+
+
+  @Override
+  protected void fillFromCalc() {
+    super.fillFromCalc();
+    fillColorObject = new Color(fillColor, true);
+    fillGradient = false;
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // MATERIAL PROPERTIES
+
+
+  //public void ambient(int rgb)
+  //public void ambient(float gray)
+  //public void ambient(float x, float y, float z)
+  //protected void ambientFromCalc()
+  //public void specular(int rgb)
+  //public void specular(float gray)
+  //public void specular(float x, float y, float z)
+  //protected void specularFromCalc()
+  //public void shininess(float shine)
+  //public void emissive(int rgb)
+  //public void emissive(float gray)
+  //public void emissive(float x, float y, float z )
+  //protected void emissiveFromCalc()
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // LIGHTS
+
+
+  //public void lights()
+  //public void noLights()
+  //public void ambientLight(float red, float green, float blue)
+  //public void ambientLight(float red, float green, float blue,
+  //                         float x, float y, float z)
+  //public void directionalLight(float red, float green, float blue,
+  //                             float nx, float ny, float nz)
+  //public void pointLight(float red, float green, float blue,
+  //                       float x, float y, float z)
+  //public void spotLight(float red, float green, float blue,
+  //                      float x, float y, float z,
+  //                      float nx, float ny, float nz,
+  //                      float angle, float concentration)
+  //public void lightFalloff(float constant, float linear, float quadratic)
+  //public void lightSpecular(float x, float y, float z)
+  //protected void lightPosition(int num, float x, float y, float z)
+  //protected void lightDirection(int num, float x, float y, float z)
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BACKGROUND
+
+
+  int[] clearPixels;
+
+  protected void clearPixels(int color) {
+    // On a hi-res display, image may be larger than width/height
+    int imageWidth = image.getWidth(null);
+    int imageHeight = image.getHeight(null);
+
+    // Create a small array that can be used to set the pixels several times.
+    // Using a single-pixel line of length 'width' is a tradeoff between
+    // speed (setting each pixel individually is too slow) and memory
+    // (an array for width*height would waste lots of memory if it stayed
+    // resident, and would terrify the gc if it were re-created on each trip
+    // to background().
+//    WritableRaster raster = ((BufferedImage) image).getRaster();
+//    WritableRaster raster = image.getRaster();
+    WritableRaster raster = getRaster();
+    if ((clearPixels == null) || (clearPixels.length < imageWidth)) {
+      clearPixels = new int[imageWidth];
+    }
+    Arrays.fill(clearPixels, 0, imageWidth, backgroundColor);
+    for (int i = 0; i < imageHeight; i++) {
+      raster.setDataElements(0, i, imageWidth, 1, clearPixels);
+    }
+  }
+
+  // background() methods inherited from PGraphics, along with the
+  // PImage version of backgroundImpl(), since it just calls set().
+
+
+  //public void backgroundImpl(PImage image)
+
+
+  @Override
+  public void backgroundImpl() {
+    if (backgroundAlpha) {
+      clearPixels(backgroundColor);
+
+    } else {
+      Color bgColor = new Color(backgroundColor);
+      // seems to fire an additional event that causes flickering,
+      // like an extra background erase on OS X
+//      if (canvas != null) {
+//        canvas.setBackground(bgColor);
+//      }
+      //new Exception().printStackTrace(System.out);
+      // in case people do transformations before background(),
+      // need to handle this with a push/reset/pop
+      Composite oldComposite = g2.getComposite();
+      g2.setComposite(defaultComposite);
+
+      pushMatrix();
+      resetMatrix();
+      g2.setColor(bgColor); //, backgroundAlpha));
+//      g2.fillRect(0, 0, width, height);
+      // On a hi-res display, image may be larger than width/height
+      if (image != null) {
+        // image will be null in subclasses (i.e. PDF)
+        g2.fillRect(0, 0, image.getWidth(null), image.getHeight(null));
+      } else {
+        // hope for the best if image is null
+        g2.fillRect(0, 0, width, height);
+      }
+      popMatrix();
+
+      g2.setComposite(oldComposite);
+    }
   }
-     */
-    //////////////////////////////////////////////////////////////
-    // MATRIX STACK
-    @Override
-    public void pushMatrix() {
-        if (transformCount == transformStack.length) {
-            throw new RuntimeException("pushMatrix() cannot use push more than "
-                    + transformStack.length + " times");
-        }
-        transformStack[transformCount] = g2.getTransform();
-        transformCount++;
-    }
 
-    @Override
-    public void popMatrix() {
-        if (transformCount == 0) {
-            throw new RuntimeException("missing a pushMatrix() "
-                    + "to go with that popMatrix()");
-        }
-        transformCount--;
-        g2.setTransform(transformStack[transformCount]);
-    }
 
-    //////////////////////////////////////////////////////////////
-    // MATRIX TRANSFORMS
-    @Override
-    public void translate(float tx, float ty) {
-        g2.translate(tx, ty);
-    }
 
-    //public void translate(float tx, float ty, float tz)
-    @Override
-    public void rotate(float angle) {
-        g2.rotate(angle);
-    }
+  //////////////////////////////////////////////////////////////
 
-    @Override
-    public void rotateX(float angle) {
-        showDepthWarning("rotateX");
-    }
+  // COLOR MODE
 
-    @Override
-    public void rotateY(float angle) {
-        showDepthWarning("rotateY");
-    }
+  // All colorMode() variations are inherited from PGraphics.
 
-    @Override
-    public void rotateZ(float angle) {
-        showDepthWarning("rotateZ");
-    }
 
-    @Override
-    public void rotate(float angle, float vx, float vy, float vz) {
-        showVariationWarning("rotate");
-    }
 
-    @Override
-    public void scale(float s) {
-        g2.scale(s, s);
-    }
+  //////////////////////////////////////////////////////////////
 
-    @Override
-    public void scale(float sx, float sy) {
-        g2.scale(sx, sy);
-    }
+  // COLOR CALC
 
-    @Override
-    public void scale(float sx, float sy, float sz) {
-        showDepthWarningXYZ("scale");
-    }
+  // colorCalc() and colorCalcARGB() inherited from PGraphics.
 
-    @Override
-    public void shearX(float angle) {
-        g2.shear(Math.tan(angle), 0);
-    }
 
-    @Override
-    public void shearY(float angle) {
-        g2.shear(0, Math.tan(angle));
-    }
 
-    //////////////////////////////////////////////////////////////
-    // MATRIX MORE
-    @Override
-    public void resetMatrix() {
-        g2.setTransform(new AffineTransform());
-        g2.scale(pixelDensity, pixelDensity);
-    }
+  //////////////////////////////////////////////////////////////
 
-    //public void applyMatrix(PMatrix2D source)
-    @Override
-    public void applyMatrix(float n00, float n01, float n02,
-            float n10, float n11, float n12) {
-        //System.out.println("PGraphicsJava2D.applyMatrix()");
-        //System.out.println(new AffineTransform(n00, n10, n01, n11, n02, n12));
-        g2.transform(new AffineTransform(n00, n10, n01, n11, n02, n12));
-        //g2.transform(new AffineTransform(n00, n01, n02, n10, n11, n12));
-    }
+  // COLOR DATATYPE STUFFING
 
-    //public void applyMatrix(PMatrix3D source)
-    @Override
-    public void applyMatrix(float n00, float n01, float n02, float n03,
-            float n10, float n11, float n12, float n13,
-            float n20, float n21, float n22, float n23,
-            float n30, float n31, float n32, float n33) {
-        showVariationWarning("applyMatrix");
-    }
+  // final color() variations inherited.
 
-    //////////////////////////////////////////////////////////////
-    // MATRIX GET/SET
-    @Override
-    public PMatrix getMatrix() {
-        return getMatrix((PMatrix2D) null);
-    }
 
-    @Override
-    public PMatrix2D getMatrix(PMatrix2D target) {
-        if (target == null) {
-            target = new PMatrix2D();
-        }
-        g2.getTransform().getMatrix(transform);
-        target.set((float) transform[0], (float) transform[2], (float) transform[4],
-                (float) transform[1], (float) transform[3], (float) transform[5]);
-        return target;
-    }
 
-    @Override
-    public PMatrix3D getMatrix(PMatrix3D target) {
-        showVariationWarning("getMatrix");
-        return target;
-    }
+  //////////////////////////////////////////////////////////////
 
-    //public void setMatrix(PMatrix source)
-    @Override
-    public void setMatrix(PMatrix2D source) {
-        g2.setTransform(new AffineTransform(source.m00, source.m10,
-                source.m01, source.m11,
-                source.m02, source.m12));
-    }
+  // COLOR DATATYPE EXTRACTION
 
-    @Override
-    public void setMatrix(PMatrix3D source) {
-        showVariationWarning("setMatrix");
-    }
+  // final methods alpha, red, green, blue,
+  // hue, saturation, and brightness all inherited.
 
-    @Override
-    public void printMatrix() {
-        getMatrix((PMatrix2D) null).print();
-    }
-
-    //////////////////////////////////////////////////////////////
-    // CAMERA and PROJECTION
-    // Inherit the plaintive warnings from PGraphics
-    //public void beginCamera()
-    //public void endCamera()
-    //public void camera()
-    //public void camera(float eyeX, float eyeY, float eyeZ,
-    //                   float centerX, float centerY, float centerZ,
-    //                   float upX, float upY, float upZ)
-    //public void printCamera()
-    //public void ortho()
-    //public void ortho(float left, float right,
-    //                  float bottom, float top,
-    //                  float near, float far)
-    //public void perspective()
-    //public void perspective(float fov, float aspect, float near, float far)
-    //public void frustum(float left, float right,
-    //                    float bottom, float top,
-    //                    float near, float far)
-    //public void printProjection()
-    //////////////////////////////////////////////////////////////
-    // SCREEN and MODEL transforms
-    @Override
-    public float screenX(float x, float y) {
-        g2.getTransform().getMatrix(transform);
-        return (float) transform[0] * x + (float) transform[2] * y + (float) transform[4];
-    }
 
-    @Override
-    public float screenY(float x, float y) {
-        g2.getTransform().getMatrix(transform);
-        return (float) transform[1] * x + (float) transform[3] * y + (float) transform[5];
-    }
 
-    @Override
-    public float screenX(float x, float y, float z) {
-        showDepthWarningXYZ("screenX");
-        return 0;
-    }
+  //////////////////////////////////////////////////////////////
 
-    @Override
-    public float screenY(float x, float y, float z) {
-        showDepthWarningXYZ("screenY");
-        return 0;
-    }
+  // COLOR DATATYPE INTERPOLATION
 
-    @Override
-    public float screenZ(float x, float y, float z) {
-        showDepthWarningXYZ("screenZ");
-        return 0;
-    }
-
-    //public float modelX(float x, float y, float z)
-    //public float modelY(float x, float y, float z)
-    //public float modelZ(float x, float y, float z)
-    //////////////////////////////////////////////////////////////
-    // STYLE
-    // pushStyle(), popStyle(), style() and getStyle() inherited.
-    //////////////////////////////////////////////////////////////
-    // STROKE CAP/JOIN/WEIGHT
-    @Override
-    public void strokeCap(int cap) {
-        super.strokeCap(cap);
-        strokeImpl();
-    }
+  // both lerpColor variants inherited.
 
-    @Override
-    public void strokeJoin(int join) {
-        super.strokeJoin(join);
-        strokeImpl();
-    }
 
-    @Override
-    public void strokeWeight(float weight) {
-        super.strokeWeight(weight);
-        strokeImpl();
-    }
 
-    protected void strokeImpl() {
-        int cap = BasicStroke.CAP_BUTT;
-        if (strokeCap == ROUND) {
-            cap = BasicStroke.CAP_ROUND;
-        } else if (strokeCap == PROJECT) {
-            cap = BasicStroke.CAP_SQUARE;
-        }
+  //////////////////////////////////////////////////////////////
 
-        int join = BasicStroke.JOIN_BEVEL;
-        if (strokeJoin == MITER) {
-            join = BasicStroke.JOIN_MITER;
-        } else if (strokeJoin == ROUND) {
-            join = BasicStroke.JOIN_ROUND;
-        }
+  // BEGIN/END RAW
 
-        strokeObject = new BasicStroke(strokeWeight, cap, join);
-        g2.setStroke(strokeObject);
-    }
 
-    //////////////////////////////////////////////////////////////
-    // STROKE
-    // noStroke() and stroke() inherited from PGraphics.
-    @Override
-    protected void strokeFromCalc() {
-        super.strokeFromCalc();
-        strokeColorObject = new Color(strokeColor, true);
-        strokeGradient = false;
-    }
+  @Override
+  public void beginRaw(PGraphics recorderRaw) {
+    showMethodWarning("beginRaw");
+  }
 
-    //////////////////////////////////////////////////////////////
-    // TINT
-    // noTint() and tint() inherited from PGraphics.
-    @Override
-    protected void tintFromCalc() {
-        super.tintFromCalc();
-        // TODO actually implement tinted images
-        tintColorObject = new Color(tintColor, true);
-    }
 
-    //////////////////////////////////////////////////////////////
-    // FILL
-    // noFill() and fill() inherited from PGraphics.
-    @Override
-    protected void fillFromCalc() {
-        super.fillFromCalc();
-        fillColorObject = new Color(fillColor, true);
-        fillGradient = false;
-    }
-
-    //////////////////////////////////////////////////////////////
-    // MATERIAL PROPERTIES
-    //public void ambient(int rgb)
-    //public void ambient(float gray)
-    //public void ambient(float x, float y, float z)
-    //protected void ambientFromCalc()
-    //public void specular(int rgb)
-    //public void specular(float gray)
-    //public void specular(float x, float y, float z)
-    //protected void specularFromCalc()
-    //public void shininess(float shine)
-    //public void emissive(int rgb)
-    //public void emissive(float gray)
-    //public void emissive(float x, float y, float z )
-    //protected void emissiveFromCalc()
-    //////////////////////////////////////////////////////////////
-    // LIGHTS
-    //public void lights()
-    //public void noLights()
-    //public void ambientLight(float red, float green, float blue)
-    //public void ambientLight(float red, float green, float blue,
-    //                         float x, float y, float z)
-    //public void directionalLight(float red, float green, float blue,
-    //                             float nx, float ny, float nz)
-    //public void pointLight(float red, float green, float blue,
-    //                       float x, float y, float z)
-    //public void spotLight(float red, float green, float blue,
-    //                      float x, float y, float z,
-    //                      float nx, float ny, float nz,
-    //                      float angle, float concentration)
-    //public void lightFalloff(float constant, float linear, float quadratic)
-    //public void lightSpecular(float x, float y, float z)
-    //protected void lightPosition(int num, float x, float y, float z)
-    //protected void lightDirection(int num, float x, float y, float z)
-    //////////////////////////////////////////////////////////////
-    // BACKGROUND
-    int[] clearPixels;
-
-    protected void clearPixels(int color) {
-        // On a hi-res display, image may be larger than width/height
-        int imageWidth = image.getWidth(null);
-        int imageHeight = image.getHeight(null);
-
-        // Create a small array that can be used to set the pixels several times.
-        // Using a single-pixel line of length 'width' is a tradeoff between
-        // speed (setting each pixel individually is too slow) and memory
-        // (an array for width*height would waste lots of memory if it stayed
-        // resident, and would terrify the gc if it were re-created on each trip
-        // to background().
-//    WritableRaster raster = ((BufferedImage) image).getRaster();
-//    WritableRaster raster = image.getRaster();
-        WritableRaster raster = getRaster();
-        if ((clearPixels == null) || (clearPixels.length < imageWidth)) {
-            clearPixels = new int[imageWidth];
-        }
-        Arrays.fill(clearPixels, 0, imageWidth, backgroundColor);
-        for (int i = 0; i < imageHeight; i++) {
-            raster.setDataElements(0, i, imageWidth, 1, clearPixels);
-        }
-    }
+  @Override
+  public void endRaw() {
+    showMethodWarning("endRaw");
+  }
 
-    // background() methods inherited from PGraphics, along with the
-    // PImage version of backgroundImpl(), since it just calls set().
-    //public void backgroundImpl(PImage image)
-    @Override
-    public void backgroundImpl() {
-        if (backgroundAlpha) {
-            clearPixels(backgroundColor);
 
-        } else {
-            Color bgColor = new Color(backgroundColor);
-            // seems to fire an additional event that causes flickering,
-            // like an extra background erase on OS X
-//      if (canvas != null) {
-//        canvas.setBackground(bgColor);
-//      }
-            //new Exception().printStackTrace(System.out);
-            // in case people do transformations before background(),
-            // need to handle this with a push/reset/pop
-            Composite oldComposite = g2.getComposite();
-            g2.setComposite(defaultComposite);
-
-            pushMatrix();
-            resetMatrix();
-            g2.setColor(bgColor); //, backgroundAlpha));
-//      g2.fillRect(0, 0, width, height);
-            // On a hi-res display, image may be larger than width/height
-            if (image != null) {
-                // image will be null in subclasses (i.e. PDF)
-                g2.fillRect(0, 0, image.getWidth(null), image.getHeight(null));
-            } else {
-                // hope for the best if image is null
-                g2.fillRect(0, 0, width, height);
-            }
-            popMatrix();
 
-            g2.setComposite(oldComposite);
-        }
-    }
+  //////////////////////////////////////////////////////////////
 
-    //////////////////////////////////////////////////////////////
-    // COLOR MODE
-    // All colorMode() variations are inherited from PGraphics.
-    //////////////////////////////////////////////////////////////
-    // COLOR CALC
-    // colorCalc() and colorCalcARGB() inherited from PGraphics.
-    //////////////////////////////////////////////////////////////
-    // COLOR DATATYPE STUFFING
-    // final color() variations inherited.
-    //////////////////////////////////////////////////////////////
-    // COLOR DATATYPE EXTRACTION
-    // final methods alpha, red, green, blue,
-    // hue, saturation, and brightness all inherited.
-    //////////////////////////////////////////////////////////////
-    // COLOR DATATYPE INTERPOLATION
-    // both lerpColor variants inherited.
-    //////////////////////////////////////////////////////////////
-    // BEGIN/END RAW
-    @Override
-    public void beginRaw(PGraphics recorderRaw) {
-        showMethodWarning("beginRaw");
-    }
+  // WARNINGS and EXCEPTIONS
 
-    @Override
-    public void endRaw() {
-        showMethodWarning("endRaw");
-    }
-
-    //////////////////////////////////////////////////////////////
-    // WARNINGS and EXCEPTIONS
-    // showWarning and showException inherited.
-    //////////////////////////////////////////////////////////////
-    // RENDERER SUPPORT QUERIES
-    //public boolean displayable()  // true
-    //public boolean is2D()  // true
-    //public boolean is3D()  // false
-    //////////////////////////////////////////////////////////////
-    // PIMAGE METHODS
-    // getImage, setCache, getCache, removeCache, isModified, setModified
-    protected WritableRaster getRaster() {
-        WritableRaster raster = null;
-        if (primaryGraphics) {
-            /*
+  // showWarning and showException inherited.
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // RENDERER SUPPORT QUERIES
+
+
+  //public boolean displayable()  // true
+
+
+  //public boolean is2D()  // true
+
+
+  //public boolean is3D()  // false
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // PIMAGE METHODS
+
+
+  // getImage, setCache, getCache, removeCache, isModified, setModified
+
+
+  protected WritableRaster getRaster() {
+    WritableRaster raster = null;
+    if (primaryGraphics) {
+      /*
       // 'offscreen' will probably be removed in the next release
       if (useOffscreen) {
         raster = offscreen.getRaster();
       } else*/ if (image instanceof VolatileImage) {
-                // when possible, we'll try VolatileImage
-                raster = ((VolatileImage) image).getSnapshot().getRaster();
-            }
-        }
-        if (raster == null) {
-            raster = ((BufferedImage) image).getRaster();
-        }
+        // when possible, we'll try VolatileImage
+        raster = ((VolatileImage) image).getSnapshot().getRaster();
+      }
+    }
+    if (raster == null) {
+      raster = ((BufferedImage) image).getRaster();
+    }
 
-        // On Raspberry Pi (and perhaps other platforms, the color buffer won't
-        // necessarily be the int array that we'd like. Need to convert it here.
-        // Not that this would probably mean getRaster() would need to work more
-        // like loadRaster/updateRaster because the pixels will need to be
-        // temporarily moved to (and later from) a buffer that's understood by
-        // the rest of the Processing source.
-        // https://github.com/processing/processing/issues/2010
-        if (raster.getTransferType() != DataBuffer.TYPE_INT) {
-            System.err.println("See https://github.com/processing/processing/issues/2010");
-            throw new RuntimeException("Pixel operations are not supported on this device.");
-        }
-        return raster;
+    // On Raspberry Pi (and perhaps other platforms, the color buffer won't
+    // necessarily be the int array that we'd like. Need to convert it here.
+    // Not that this would probably mean getRaster() would need to work more
+    // like loadRaster/updateRaster because the pixels will need to be
+    // temporarily moved to (and later from) a buffer that's understood by
+    // the rest of the Processing source.
+    // https://github.com/processing/processing/issues/2010
+    if (raster.getTransferType() != DataBuffer.TYPE_INT) {
+      System.err.println("See https://github.com/processing/processing/issues/2010");
+      throw new RuntimeException("Pixel operations are not supported on this device.");
     }
+    return raster;
+  }
 
-    @Override
-    public void loadPixels() {
-        if (pixels == null || (pixels.length != pixelWidth * pixelHeight)) {
-            pixels = new int[pixelWidth * pixelHeight];
-        }
 
-        WritableRaster raster = getRaster();
-        raster.getDataElements(0, 0, pixelWidth, pixelHeight, pixels);
-        if (raster.getNumBands() == 3) {
-            // Java won't set the high bits when RGB, returns 0 for alpha
-            // https://github.com/processing/processing/issues/2030
-            for (int i = 0; i < pixels.length; i++) {
-                pixels[i] = 0xff000000 | pixels[i];
-            }
-        }
-        //((BufferedImage) image).getRGB(0, 0, width, height, pixels, 0, width);
+  @Override
+  public void loadPixels() {
+    if (pixels == null || (pixels.length != pixelWidth*pixelHeight)) {
+      pixels = new int[pixelWidth * pixelHeight];
+    }
+
+    WritableRaster raster = getRaster();
+    raster.getDataElements(0, 0, pixelWidth, pixelHeight, pixels);
+    if (raster.getNumBands() == 3) {
+      // Java won't set the high bits when RGB, returns 0 for alpha
+      // https://github.com/processing/processing/issues/2030
+      for (int i = 0; i < pixels.length; i++) {
+        pixels[i] = 0xff000000 | pixels[i];
+      }
+    }
+      //((BufferedImage) image).getRGB(0, 0, width, height, pixels, 0, width);
 //    WritableRaster raster = ((BufferedImage) (useOffscreen && primarySurface ? offscreen : image)).getRaster();
 //    WritableRaster raster = image.getRaster();
-    }
+  }
+
 
 //  /**
 //   * Update the pixels[] buffer to the PGraphics image.
@@ -2334,27 +2784,32 @@ public class PGraphicsJava2D extends PGraphics {
 ////    WritableRaster raster = image.getRaster();
 //    updatePixels(0, 0, width, height);
 //  }
-    /**
-     * Update the pixels[] buffer to the PGraphics image.
-     * <P>
-     * Unlike in PImage, where updatePixels() only requests that the update
-     * happens, in PGraphicsJava2D, this will happen immediately.
-     */
-    @Override
-    public void updatePixels(int x, int y, int c, int d) {
-        //if ((x == 0) && (y == 0) && (c == width) && (d == height)) {
+
+
+  /**
+   * Update the pixels[] buffer to the PGraphics image.
+   * <P>
+   * Unlike in PImage, where updatePixels() only requests that the
+   * update happens, in PGraphicsJava2D, this will happen immediately.
+   * @param c
+   * @param d
+   */
+  @Override
+  public void updatePixels(int x, int y, int c, int d) {
+    //if ((x == 0) && (y == 0) && (c == width) && (d == height)) {
 //    System.err.format("%d %d %d %d .. w/h = %d %d .. pw/ph = %d %d %n", x, y, c, d, width, height, pixelWidth, pixelHeight);
-        if ((x != 0) || (y != 0) || (c != pixelWidth) || (d != pixelHeight)) {
-            // Show a warning message, but continue anyway.
-            showVariationWarning("updatePixels(x, y, w, h)");
+    if ((x != 0) || (y != 0) || (c != pixelWidth) || (d != pixelHeight)) {
+      // Show a warning message, but continue anyway.
+      showVariationWarning("updatePixels(x, y, w, h)");
 //      new Exception().printStackTrace(System.out);
-        }
+    }
 //    updatePixels();
-        if (pixels != null) {
-            getRaster().setDataElements(0, 0, pixelWidth, pixelHeight, pixels);
-        }
-        modified = true;
+    if (pixels != null) {
+      getRaster().setDataElements(0, 0, pixelWidth, pixelHeight, pixels);
     }
+    modified = true;
+  }
+
 
 //  @Override
 //  protected void updatePixelsImpl(int x, int y, int w, int h) {
@@ -2366,172 +2821,220 @@ public class PGraphicsJava2D extends PGraphics {
 //    }
 //    getRaster().setDataElements(0, 0, width, height, pixels);
 //  }
-    //////////////////////////////////////////////////////////////
-    // GET/SET
-    static int getset[] = new int[1];
 
-    @Override
-    public int get(int x, int y) {
-        if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) {
-            return 0;
-        }
-        //return ((BufferedImage) image).getRGB(x, y);
+
+
+  //////////////////////////////////////////////////////////////
+
+  // GET/SET
+
+
+  static int[] getset = new int[1];
+
+
+  @Override
+  public int get(int x, int y) {
+    if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) return 0;
+    //return ((BufferedImage) image).getRGB(x, y);
 //    WritableRaster raster = ((BufferedImage) (useOffscreen && primarySurface ? offscreen : image)).getRaster();
-        WritableRaster raster = getRaster();
-        raster.getDataElements(x, y, getset);
-        if (raster.getNumBands() == 3) {
-            // https://github.com/processing/processing/issues/2030
-            return getset[0] | 0xff000000;
-        }
-        return getset[0];
+    WritableRaster raster = getRaster();
+    raster.getDataElements(x, y, getset);
+    if (raster.getNumBands() == 3) {
+      // https://github.com/processing/processing/issues/2030
+      return getset[0] | 0xff000000;
     }
+    return getset[0];
+  }
 
-    //public PImage get(int x, int y, int w, int h)
-    @Override
-    protected void getImpl(int sourceX, int sourceY,
-            int sourceWidth, int sourceHeight,
-            PImage target, int targetX, int targetY) {
-        // last parameter to getRGB() is the scan size of the *target* buffer
-        //((BufferedImage) image).getRGB(x, y, w, h, output.pixels, 0, w);
+
+  //public PImage get(int x, int y, int w, int h)
+
+
+  @Override
+  protected void getImpl(int sourceX, int sourceY,
+                         int sourceWidth, int sourceHeight,
+                         PImage target, int targetX, int targetY) {
+    // last parameter to getRGB() is the scan size of the *target* buffer
+    //((BufferedImage) image).getRGB(x, y, w, h, output.pixels, 0, w);
 //    WritableRaster raster =
 //      ((BufferedImage) (useOffscreen && primarySurface ? offscreen : image)).getRaster();
-        WritableRaster raster = getRaster();
+    WritableRaster raster = getRaster();
 
-        if (sourceWidth == target.pixelWidth && sourceHeight == target.pixelHeight) {
-            raster.getDataElements(sourceX, sourceY, sourceWidth, sourceHeight, target.pixels);
-            // https://github.com/processing/processing/issues/2030
-            if (raster.getNumBands() == 3) {
-                target.filter(OPAQUE);
-            }
+    if (sourceWidth == target.pixelWidth && sourceHeight == target.pixelHeight) {
+      raster.getDataElements(sourceX, sourceY, sourceWidth, sourceHeight, target.pixels);
+      // https://github.com/processing/processing/issues/2030
+      if (raster.getNumBands() == 3) {
+        target.filter(OPAQUE);
+      }
 
+    } else {
+      // TODO optimize, incredibly inefficient to reallocate this much memory
+      int[] temp = new int[sourceWidth * sourceHeight];
+      raster.getDataElements(sourceX, sourceY, sourceWidth, sourceHeight, temp);
+
+      // Copy the temporary output pixels over to the outgoing image
+      int sourceOffset = 0;
+      int targetOffset = targetY*target.pixelWidth + targetX;
+      for (int y = 0; y < sourceHeight; y++) {
+        if (raster.getNumBands() == 3) {
+          for (int i = 0; i < sourceWidth; i++) {
+            // Need to set the high bits for this feller
+            // https://github.com/processing/processing/issues/2030
+            target.pixels[targetOffset + i] = 0xFF000000 | temp[sourceOffset + i];
+          }
         } else {
-            // TODO optimize, incredibly inefficient to reallocate this much memory
-            int[] temp = new int[sourceWidth * sourceHeight];
-            raster.getDataElements(sourceX, sourceY, sourceWidth, sourceHeight, temp);
-
-            // Copy the temporary output pixels over to the outgoing image
-            int sourceOffset = 0;
-            int targetOffset = targetY * target.pixelWidth + targetX;
-            for (int y = 0; y < sourceHeight; y++) {
-                if (raster.getNumBands() == 3) {
-                    for (int i = 0; i < sourceWidth; i++) {
-                        // Need to set the high bits for this feller
-                        // https://github.com/processing/processing/issues/2030
-                        target.pixels[targetOffset + i] = 0xFF000000 | temp[sourceOffset + i];
-                    }
-                } else {
-                    System.arraycopy(temp, sourceOffset, target.pixels, targetOffset, sourceWidth);
-                }
-                sourceOffset += sourceWidth;
-                targetOffset += target.pixelWidth;
-            }
+          System.arraycopy(temp, sourceOffset, target.pixels, targetOffset, sourceWidth);
         }
+        sourceOffset += sourceWidth;
+        targetOffset += target.pixelWidth;
+      }
     }
+  }
 
-    @Override
-    public void set(int x, int y, int argb) {
-        if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) {
-            return;
-        }
+
+  @Override
+  public void set(int x, int y, int argb) {
+    if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) return;
 //    ((BufferedImage) image).setRGB(x, y, argb);
-        getset[0] = argb;
+    getset[0] = argb;
 //    WritableRaster raster = ((BufferedImage) (useOffscreen && primarySurface ? offscreen : image)).getRaster();
 //    WritableRaster raster = image.getRaster();
-        getRaster().setDataElements(x, y, getset);
-    }
+    getRaster().setDataElements(x, y, getset);
+  }
 
-    //public void set(int x, int y, PImage img)
-    @Override
-    protected void setImpl(PImage sourceImage,
-            int sourceX, int sourceY,
-            int sourceWidth, int sourceHeight,
-            int targetX, int targetY) {
-        WritableRaster raster = getRaster();
+
+  //public void set(int x, int y, PImage img)
+
+
+  @Override
+  protected void setImpl(PImage sourceImage,
+                         int sourceX, int sourceY,
+                         int sourceWidth, int sourceHeight,
+                         int targetX, int targetY) {
+    WritableRaster raster = getRaster();
 //      ((BufferedImage) (useOffscreen && primarySurface ? offscreen : image)).getRaster();
 
-        if ((sourceX == 0) && (sourceY == 0)
-                && (sourceWidth == sourceImage.pixelWidth)
-                && (sourceHeight == sourceImage.pixelHeight)) {
+    if ((sourceX == 0) && (sourceY == 0) &&
+        (sourceWidth == sourceImage.pixelWidth) &&
+        (sourceHeight == sourceImage.pixelHeight)) {
 //      System.out.format("%d %d  %dx%d  %d%n", targetX, targetY,
 //                             sourceImage.width, sourceImage.height,
 //                             sourceImage.pixels.length);
-            raster.setDataElements(targetX, targetY,
-                    sourceImage.pixelWidth, sourceImage.pixelHeight,
-                    sourceImage.pixels);
-        } else {
-            // TODO optimize, incredibly inefficient to reallocate this much memory
-            PImage temp = sourceImage.get(sourceX, sourceY, sourceWidth, sourceHeight);
-            raster.setDataElements(targetX, targetY, temp.pixelWidth, temp.pixelHeight, temp.pixels);
-        }
+      raster.setDataElements(targetX, targetY,
+                             sourceImage.pixelWidth, sourceImage.pixelHeight,
+                             sourceImage.pixels);
+    } else {
+      // TODO optimize, incredibly inefficient to reallocate this much memory
+      PImage temp = sourceImage.get(sourceX, sourceY, sourceWidth, sourceHeight);
+      raster.setDataElements(targetX, targetY, temp.pixelWidth, temp.pixelHeight, temp.pixels);
     }
+  }
 
-    //////////////////////////////////////////////////////////////
-    // MASK
-    static final String MASK_WARNING
-            = "mask() cannot be used on the main drawing surface";
 
-    @Override
-    public void mask(int[] alpha) {
-        if (primaryGraphics) {
-            showWarning(MASK_WARNING);
 
-        } else {
-            super.mask(alpha);
-        }
-    }
+  //////////////////////////////////////////////////////////////
 
-    @Override
-    public void mask(PImage alpha) {
-        if (primaryGraphics) {
-            showWarning(MASK_WARNING);
+  // MASK
 
-        } else {
-            super.mask(alpha);
-        }
+
+  static final String MASK_WARNING =
+    "mask() cannot be used on the main drawing surface";
+
+
+  @Override
+  public void mask(int[] alpha) {
+    if (primaryGraphics) {
+      showWarning(MASK_WARNING);
+
+    } else {
+      super.mask(alpha);
     }
+  }
 
-    //////////////////////////////////////////////////////////////
-    // FILTER
-    // Because the PImage versions call loadPixels() and
-    // updatePixels(), no need to override anything here.
-    //public void filter(int kind)
-    //public void filter(int kind, float param)
-    //////////////////////////////////////////////////////////////
-    // COPY
-    @Override
-    public void copy(int sx, int sy, int sw, int sh,
-            int dx, int dy, int dw, int dh) {
-        if ((sw != dw) || (sh != dh)) {
-            g2.drawImage(image, dx, dy, dx + dw, dy + dh, sx, sy, sx + sw, sy + sh, null);
 
-        } else {
-            dx = dx - sx;  // java2d's "dx" is the delta, not dest
-            dy = dy - sy;
-            g2.copyArea(sx, sy, sw, sh, dx, dy);
-        }
+  @Override
+  public void mask(PImage alpha) {
+    if (primaryGraphics) {
+      showWarning(MASK_WARNING);
+
+    } else {
+      super.mask(alpha);
     }
+  }
 
-    @Override
-    public void copy(PImage src,
-            int sx, int sy, int sw, int sh,
-            int dx, int dy, int dw, int dh) {
-        g2.drawImage((Image) src.getNative(),
-                dx, dy, dx + dw, dy + dh,
-                sx, sy, sx + sw, sy + sh, null);
+
+
+  //////////////////////////////////////////////////////////////
+
+  // FILTER
+
+  // Because the PImage versions call loadPixels() and
+  // updatePixels(), no need to override anything here.
+
+
+  //public void filter(int kind)
+
+
+  //public void filter(int kind, float param)
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // COPY
+
+
+  @Override
+  public void copy(int sx, int sy, int sw, int sh,
+                   int dx, int dy, int dw, int dh) {
+    if ((sw != dw) || (sh != dh)) {
+      g2.drawImage(image, dx, dy, dx + dw, dy + dh, sx, sy, sx + sw, sy + sh, null);
+
+    } else {
+      dx = dx - sx;  // java2d's "dx" is the delta, not dest
+      dy = dy - sy;
+      g2.copyArea(sx, sy, sw, sh, dx, dy);
     }
+  }
+
+
+  @Override
+  public void copy(PImage src,
+                   int sx, int sy, int sw, int sh,
+                   int dx, int dy, int dw, int dh) {
+    g2.drawImage((Image) src.getNative(),
+                 dx, dy, dx + dw, dy + dh,
+                 sx, sy, sx + sw, sy + sh, null);
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // BLEND
+
 
-    //////////////////////////////////////////////////////////////
-    // BLEND
 //  static public int blendColor(int c1, int c2, int mode)
+
+
 //  public void blend(int sx, int sy, int sw, int sh,
 //                    int dx, int dy, int dw, int dh, int mode)
+
+
 //  public void blend(PImage src,
 //                    int sx, int sy, int sw, int sh,
 //                    int dx, int dy, int dw, int dh, int mode)
-    //////////////////////////////////////////////////////////////
-    // SAVE
-//  public void save(String filename) {
-//    loadPixels();
-//    super.save(filename);
-//  }
+
+
+
+  //////////////////////////////////////////////////////////////
+
+  // SAVE
+
+
+  @Override
+  public boolean save(String filename) {
+    PImageAWT outImage = new PImageAWT(image);
+    return outImage.save(filename);
+  }
 }