propane 3.4.2-java → 3.5.0-java

data/pom.xml

@@ -11,7 +11,7 @@ DO NOT MODIFIY - GENERATED CODE
   <modelVersion>4.0.0</modelVersion>
   <groupId>propane</groupId>
   <artifactId>propane</artifactId>
-  <version>3.4.2</version>
+  <version>3.5.0</version>
   <name>propane</name>
   <description>An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.</description>
   <url>https://github.com/monkstone/propane</url>
@@ -74,7 +74,7 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>org.jruby</groupId>
       <artifactId>jruby</artifactId>
-      <version>9.2.9.0</version>
+      <version>9.2.11.1</version>
       <type>pom</type>
     </dependency>
     <dependency>
@@ -132,7 +132,7 @@ DO NOT MODIFIY - GENERATED CODE
         </plugin>
         <plugin>
           <artifactId>maven-javadoc-plugin</artifactId>
-          <version>3.1.1</version>
+          <version>3.2.0</version>
           <configuration>
             <detectOfflineLinks>false</detectOfflineLinks>
             <links>
@@ -143,7 +143,7 @@ DO NOT MODIFIY - GENERATED CODE
         </plugin>
         <plugin>
           <artifactId>maven-jar-plugin</artifactId>
-          <version>3.1.2</version>
+          <version>3.2.0</version>
           <configuration>
             <archive>
               <manifestEntries>

data/propane.gemspec

@@ -1,5 +1,6 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'propane/version'
 
@@ -8,13 +9,13 @@ Gem::Specification.new do |gem|
   gem.version       = Propane::VERSION
   gem.authors       = ['monkstone']
   gem.email         = ['mamba2928@yahoo.co.uk']
-  gem.licenses     = %w(GPL-3.0 LGPL-2.0)
+  gem.licenses     = %w[GPL-3.0 LGPL-2.0]
   gem.description  = <<-EOS
   A batteries included version of processing in ruby targetting jdk11.
   EOS
-  gem.summary       = %q{ruby implementation of processing-4.0 on MacOS, linux and windows (64bit only)}
+  gem.summary       = 'ruby implementation of processing-4.0 on MacOS, linux and windows (64bit only)'
   gem.homepage      = 'https://ruby-processing.github.io/propane/'
-  gem.files         = `git ls-files`.split($/)
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.files << "lib/propane-#{Propane::VERSION}.jar"
   gem.files << 'lib/gluegen-rt.jar'
   gem.files << 'lib/jogl-all.jar'
@@ -24,10 +25,10 @@ Gem::Specification.new do |gem|
   gem.files << 'lib/jogl-all-natives-linux-amd64.jar'
   gem.files << 'lib/jogl-all-natives-macosx-universal.jar'
   gem.files << 'lib/jogl-all-natives-windows-amd64.jar'
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.add_development_dependency 'rake', '~> 12.3'
   gem.add_development_dependency 'minitest', '~> 5.11'
+  gem.add_development_dependency 'rake', '~> 12.3'
   gem.add_runtime_dependency 'arcball', '~> 1.0', '>= 1.0.0'
   gem.require_paths = ['lib']
   gem.platform      = 'java'

data/src/main/java/monkstone/ColorUtil.java

@@ -3,7 +3,7 @@
  * in their sketches. Includes a method to efficiently convert an array of web
  * strings to an array of color int, and another to convert an array of color
  * int to a string that can be used in ruby code (to generate web color array).
- * Copyright (c) 2015-19 Martin Prout.
+ * Copyright (c) 2015-20 Martin Prout.
  * This utility 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
@@ -13,8 +13,6 @@
  */
 package monkstone;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Random;
 /**
  *

data/src/main/java/monkstone/MathToolModule.java

@@ -2,7 +2,7 @@
 * The purpose of this tool is to allow JRubyArt users to use an alternative
 * to processing.org map, lerp and norm methods in their sketches and to implement
 * JRubyArt convenenience method grid(width, height, stepW, stepH) { |x, y| do stuff }
-* Copyright (c) 2015-19 Martin Prout. This tool is free software; you can
+* Copyright (c) 2015-20 Martin Prout. This tool 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.

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

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,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/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

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
@@ -33,7 +33,6 @@ import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 import monkstone.vecmath.JRender;
 import monkstone.vecmath.vec2.Vec2;
-import org.jruby.RubyNumeric;
 
 /**
  *

data/src/main/java/monkstone/videoevent/CaptureEvent.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/videoevent/MovieEvent.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/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;
@@ -79,8 +82,8 @@ public class PGraphicsJava2D extends PGraphics {
   float[] curveDrawY;
 
   int transformCount;
-  AffineTransform transformStack[]
-    = new AffineTransform[MATRIX_STACK_DEPTH];
+  AffineTransform[] transformStack =
+    new AffineTransform[MATRIX_STACK_DEPTH];
   double[] transform = new double[6];
 
   Line2D.Float line = new Line2D.Float();
@@ -101,14 +104,25 @@ public class PGraphicsJava2D extends PGraphics {
 
   Font fontObject;
 
+
+
   //////////////////////////////////////////////////////////////
+
   // INTERNAL
-  public PGraphicsJava2D() {
-  }
+
+
+  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,11 +138,15 @@ public class PGraphicsJava2D extends PGraphics {
 //    allocate();
 //    reapplySettings();
 //  }
+
+
 //  @Override
 //  protected void allocate() {
 //    //surface.initImage(this, width, height);
 //    surface.initImage(this);
 //  }
+
+
   /*
   @Override
   protected void allocate() {
@@ -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;
 
@@ -223,40 +241,47 @@ 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.
-   *
-   * @return
-   */
-  @Override
-  public Image getImage() {
-    return image;
-  }
 
-  /**
-   * Returns the java.awt.Graphics2D object used by this renderer.
-   *
-   * @return
-   */
+//  /**
+//   * 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
+
+
 //  @Override
 //  public boolean canDraw() {
 //    return true;
 //  }
+
+
 //  @Override
 //  public void requestDraw() {
 ////    EventQueue.invokeLater(new Runnable() {
@@ -265,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) {
+    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
@@ -294,6 +322,7 @@ 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]
@@ -313,6 +342,7 @@ public class PGraphicsJava2D extends PGraphics {
     return (Graphics2D) image.getGraphics();
   }
 
+
   @Override
   public void beginDraw() {
     g2 = checkImage();
@@ -384,12 +414,14 @@ 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().
@@ -397,33 +429,33 @@ public class PGraphicsJava2D extends PGraphics {
   protected void handleSmooth() {
     if (smooth == 0) {
       g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-        RenderingHints.VALUE_ANTIALIAS_OFF);
+                          RenderingHints.VALUE_ANTIALIAS_OFF);
       g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-        RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+                          RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
       g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
-        RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+                          RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
 
     } else {
       g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
-        RenderingHints.VALUE_ANTIALIAS_ON);
+                          RenderingHints.VALUE_ANTIALIAS_ON);
 
       if (smooth == 1 || smooth == 3) {  // default is bicubic
         g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-          RenderingHints.VALUE_INTERPOLATION_BICUBIC);
+                            RenderingHints.VALUE_INTERPOLATION_BICUBIC);
       } else if (smooth == 2) {
         g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+                            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);
+                          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);
+                          RenderingHints.VALUE_FRACTIONALMETRICS_ON);
 //    g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
 //                        RenderingHints.VALUE_TEXT_ANTIALIAS_GASP);
 //    g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
@@ -434,6 +466,7 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   @Override
   public void endDraw() {
     // hm, mark pixels as changed, because this will instantly do a full
@@ -469,7 +502,7 @@ 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();
@@ -481,6 +514,7 @@ 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();
@@ -507,7 +541,7 @@ public class PGraphicsJava2D extends PGraphics {
 //        try {
 //          ImageIO.write(image, "jpg", new java.io.File("/Users/fry/Desktop/buff.jpg"));
 //        } catch (IOException e) {
-//          e.printStackTrace();
+//    
 //        }
 //      }
 //        }
@@ -532,10 +566,18 @@ public class PGraphicsJava2D extends PGraphics {
     } while (strategy.contentsLost());
     PApplet.debug("PGraphicsJava2D.redraw() out of do { } block");
   }
-   */
+  */
+
+
+
   //////////////////////////////////////////////////////////////
+
   // SETTINGS
+
+
   //protected void checkSettings()
+
+
   @Override
   protected void defaultSettings() {
 //    if (!useCanvas) {
@@ -552,9 +594,16 @@ public class PGraphicsJava2D extends PGraphics {
     super.defaultSettings();
   }
 
+
   //protected void reapplySettings()
+
+
+
   //////////////////////////////////////////////////////////////
+
   // HINT
+
+
   @Override
   public void hint(int which) {
     // take care of setting the hint
@@ -566,29 +615,38 @@ public class PGraphicsJava2D extends PGraphics {
     // stroke in many standard Processing examples really gross.
     if (which == ENABLE_STROKE_PURE) {
       g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
-        RenderingHints.VALUE_STROKE_PURE);
+                          RenderingHints.VALUE_STROKE_PURE);
     } else if (which == DISABLE_STROKE_PURE) {
       g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
-        RenderingHints.VALUE_STROKE_DEFAULT);
+                          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;
@@ -604,7 +662,9 @@ public class PGraphicsJava2D extends PGraphics {
     return shape;
   }
    */
- /*
+
+
+  /*
   static protected PShape createShapeImpl(PGraphicsJava2D pg,
                                                 int kind, float... p) {
     PShape shape = null;
@@ -676,9 +736,15 @@ public class PGraphicsJava2D extends PGraphics {
 
     return shape;
   }
-   */
+  */
+
+
+
   //////////////////////////////////////////////////////////////
+
   // SHAPES
+
+
   @Override
   public void beginShape(int kind) {
     //super.beginShape(kind);
@@ -695,21 +761,29 @@ public class PGraphicsJava2D extends PGraphics {
     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];
+      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);
@@ -722,98 +796,99 @@ public class PGraphicsJava2D extends PGraphics {
 
     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 POINTS:
+      point(x, 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;
+    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");
@@ -824,16 +899,19 @@ public class PGraphicsJava2D extends PGraphics {
     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");
   }
 
+
   @Override
   public void beginContour() {
     if (openContour) {
@@ -853,6 +931,7 @@ public class PGraphicsJava2D extends PGraphics {
     openContour = true;
   }
 
+
   @Override
   public void endContour() {
     if (!openContour) {
@@ -861,9 +940,7 @@ public class PGraphicsJava2D extends PGraphics {
     }
 
     // close this contour
-    if (gpath != null) {
-      gpath.closePath();
-    }
+    if (gpath != null) gpath.closePath();
 
     // switch back to main path
     GeneralPath contourPath = gpath;
@@ -873,6 +950,7 @@ public class PGraphicsJava2D extends PGraphics {
     openContour = false;
   }
 
+
   @Override
   public void endShape(int mode) {
     if (openContour) { // correct automagically, notify user
@@ -894,24 +972,32 @@ public class PGraphicsJava2D extends PGraphics {
   }
 
   //////////////////////////////////////////////////////////////
+
   // 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 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 )
+   * This is a new reference entry for Processing 2.0.It will be updated shortly.
+   *
+   * 
    *
    * @webref Rendering
    */
@@ -925,11 +1011,11 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   // 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) {
@@ -937,15 +1023,14 @@ public class PGraphicsJava2D extends PGraphics {
     }
 
     @Override
-    public void dispose() {
-    }
+    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) {
+      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.");
       }
 
@@ -966,47 +1051,64 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // BEZIER VERTICES
+
+
   @Override
   public void bezierVertex(float x1, float y1,
-    float x2, float y2,
-    float x3, float y3) {
+                           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) {
+                           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) {
+                         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);
+    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) {
+                         float x4, float y4, float z4) {
     showDepthWarningXYZ("quadVertex");
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // CURVE VERTICES
+
+
   @Override
   protected void curveVertexCheck() {
     super.curveVertexCheck();
@@ -1019,11 +1121,12 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   @Override
   protected void curveVertexSegment(float x1, float y1,
-    float x2, float y2,
-    float x3, float y3,
-    float x4, float y4) {
+                                    float x2, float y2,
+                                    float x3, float y3,
+                                    float x4, float y4) {
     curveCoordX[0] = x1;
     curveCoordY[0] = y1;
 
@@ -1047,20 +1150,32 @@ public class PGraphicsJava2D extends PGraphics {
     }
 
     gpath.curveTo(curveDrawX[1], curveDrawY[1],
-      curveDrawX[2], curveDrawY[2],
-      curveDrawX[3], curveDrawY[3]);
+                  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) {
@@ -1072,15 +1187,17 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   @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) {
+                       float x3, float y3) {
     gpath = new GeneralPath();
     gpath.moveTo(x1, y1);
     gpath.lineTo(x2, y2);
@@ -1089,9 +1206,10 @@ public class PGraphicsJava2D extends PGraphics {
     drawShape(gpath);
   }
 
+
   @Override
   public void quad(float x1, float y1, float x2, float y2,
-    float x3, float y3, float x4, float y4) {
+                   float x3, float y3, float x4, float y4) {
     GeneralPath gp = new GeneralPath();
     gp.moveTo(x1, y1);
     gp.lineTo(x2, y2);
@@ -1101,33 +1219,58 @@ public class PGraphicsJava2D extends PGraphics {
     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);
+    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) {
+                         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?
 
@@ -1180,8 +1323,13 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // JAVA2D SHAPE/PATH HANDLING
+
+
   protected void fillShape(Shape s) {
     if (fillGradient) {
       g2.setPaint(fillGradientObject);
@@ -1192,6 +1340,7 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   protected void strokeShape(Shape s) {
     if (strokeGradient) {
       g2.setPaint(strokeGradientObject);
@@ -1202,6 +1351,7 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   protected void drawShape(Shape s) {
     if (fillGradient) {
       g2.setPaint(fillGradientObject);
@@ -1219,66 +1369,115 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // 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.
-   */
+
+
+  /** 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 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.
-   */
+
+
+  /** 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
@@ -1342,34 +1541,53 @@ 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.
-   *
    * @param who
+   * @param x1
+   * @param y1
+   * @param x2
+   * @param y2
+   * @param u1
+   * @param v1
+   * @param u2
+   * @param v2
    */
   @Override
   protected void imageImpl(PImage who,
-    float x1, float y1, float x2, float y2,
-    int u1, int v1, int u2, int v2) {
+                           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;
-    }
+    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()) {
+      if (who.pixelWidth != cash.image.getWidth() ||
+          who.pixelHeight != cash.image.getHeight()) {
         cash = null;
       }
     }
@@ -1384,9 +1602,9 @@ public class PGraphicsJava2D extends PGraphics {
 
     // 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)) {
+    if ((tint && !cash.tinted) ||
+        (tint && (cash.tintedColor != tintColor)) ||
+        (!tint && cash.tinted)) {
       // For tint change, mark all pixels as needing update.
       who.updatePixels();
     }
@@ -1408,8 +1626,8 @@ public class PGraphicsJava2D extends PGraphics {
     v2 *= who.pixelDensity;
 
     g2.drawImage(((ImageCache) getCache(who)).image,
-      (int) x1, (int) y1, (int) x2, (int) y2,
-      u1, v1, u2, v2, null);
+                 (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:
@@ -1434,8 +1652,8 @@ public class PGraphicsJava2D extends PGraphics {
 //    }
   }
 
-  static class ImageCache {
 
+  static class ImageCache {
     boolean tinted;
     int tintedColor;
     int[] tintedTemp;  // one row of tinted pixels
@@ -1450,10 +1668,11 @@ 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.
+     * 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;
@@ -1474,7 +1693,7 @@ public class PGraphicsJava2D extends PGraphics {
       // https://github.com/processing/processing/issues/2030
       if (image == null) {
         image = new BufferedImage(source.pixelWidth, source.pixelHeight,
-          BufferedImage.TYPE_INT_ARGB);
+                                  BufferedImage.TYPE_INT_ARGB);
       }
 
       WritableRaster wr = image.getRaster();
@@ -1504,10 +1723,10 @@ public class PGraphicsJava2D extends PGraphics {
               // 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);
+              tintedTemp[x] = 0xFF000000 |
+                  (((r2 * r1) & 0xff00) << 8) |
+                  ((g2 * g1) & 0xff00) |
+                  (((b2 * b1) & 0xff00) >> 8);
             }
             wr.setDataElements(0, y, source.pixelWidth, 1, tintedTemp);
           }
@@ -1517,10 +1736,10 @@ public class PGraphicsJava2D extends PGraphics {
 //          RescaleOp op = new RescaleOp(scales, offsets, null);
 //          op.filter(image, image);
 
-          //} else if (bufferType == BufferedImage.TYPE_INT_ARGB) {
+        //} else if (bufferType == BufferedImage.TYPE_INT_ARGB) {
         } else if (targetType == ARGB) {
-          if (source.format == RGB
-            && (tintColor & 0xffffff) == 0xffffff) {
+          if (source.format == RGB &&
+              (tintColor & 0xffffff) == 0xffffff) {
             int hi = tintColor & 0xff000000;
             int index = 0;
             for (int y = 0; y < source.pixelHeight; y++) {
@@ -1540,12 +1759,11 @@ public class PGraphicsJava2D extends PGraphics {
                     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;
+                    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++];
@@ -1553,21 +1771,19 @@ public class PGraphicsJava2D extends PGraphics {
                     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;
+                    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;
+                    tintedTemp[x] =
+                      (((a2 * a1) & 0xff00) << 16) | lower;
+                  } break;
                 default:
                   break;
               }
@@ -1607,15 +1823,33 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // 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);
@@ -1626,10 +1860,19 @@ public class PGraphicsJava2D extends PGraphics {
     return null;
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // TEXT ATTRIBTUES
+
+
   //public void textAlign(int align)
+
+
   //public void textAlign(int alignX, int alignY)
+
+
   @Override
   public float textAscent() {
     if (textFont == null) {
@@ -1644,6 +1887,7 @@ public class PGraphicsJava2D extends PGraphics {
     return super.textAscent();
   }
 
+
   @Override
   public float textDescent() {
     if (textFont == null) {
@@ -1657,20 +1901,30 @@ public class PGraphicsJava2D extends PGraphics {
     return super.textDescent();
   }
 
+
   //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.
+   * 
+   * Called from textFontImpl and textSizeImpl, so the metrics
+   * will get recorded properly.
    */
   @Override
   protected void handleTextSize(float size) {
@@ -1679,11 +1933,11 @@ public class PGraphicsJava2D extends PGraphics {
     // 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<TextAttribute, Object> map =
+          new HashMap<>();
         map.put(TextAttribute.SIZE, size);
         map.put(TextAttribute.KERNING,
-          TextAttribute.KERNING_ON);
+                TextAttribute.KERNING_ON);
 //      map.put(TextAttribute.TRACKING,
 //              TextAttribute.TRACKING_TIGHT);
         font = font.deriveFont(map);
@@ -1697,7 +1951,7 @@ public class PGraphicsJava2D extends PGraphics {
       for (TextAttribute ta : attrs.keySet()) {
         System.out.println(ta + " -> " + attrs.get(ta));
       }
-       */
+      */
     }
 
     // take care of setting the textSize and textLeading vars
@@ -1706,10 +1960,15 @@ public class PGraphicsJava2D extends PGraphics {
     super.handleTextSize(size);
   }
 
+
   //public float textWidth(char c)
+
+
   //public float textWidth(String str)
+
+
   @Override
-  protected float textWidthImpl(char buffer[], int start, int stop) {
+  protected float textWidthImpl(char[] buffer, int start, int stop) {
     if (textFont == null) {
       defaultFontOrDeath("textWidth");
     }
@@ -1742,28 +2001,44 @@ public class PGraphicsJava2D extends PGraphics {
 ////      return m2;
 ////      return metrics.charsWidth(buffer, start, length);
 //      return m2;
-      return (float) metrics.getStringBounds(buffer, start, stop, g2).getWidth();
+      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) {
+  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) {
@@ -1781,9 +2056,9 @@ public class PGraphicsJava2D extends PGraphics {
                           textFont.smooth ?
                           RenderingHints.VALUE_ANTIALIAS_ON :
                           RenderingHints.VALUE_ANTIALIAS_OFF);
-       */
-      Object antialias
-        = g2.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
+      */
+      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;
@@ -1793,22 +2068,23 @@ public class PGraphicsJava2D extends PGraphics {
       // 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);
+                          textFont.isSmooth() ?
+                          RenderingHints.VALUE_ANTIALIAS_ON :
+                          RenderingHints.VALUE_ANTIALIAS_OFF);
 
       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
+      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);
@@ -1823,6 +2099,7 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
 //  /**
 //   * Convenience method to get a legit FontMetrics object. Where possible,
 //   * override this any renderer subclass so that you're not using what's
@@ -1862,121 +2139,161 @@ public class PGraphicsJava2D extends PGraphics {
     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");
+      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()");
+      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) {
+                          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) {
+                          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) {
@@ -1984,37 +2301,49 @@ public class PGraphicsJava2D extends PGraphics {
     }
     g2.getTransform().getMatrix(transform);
     target.set((float) transform[0], (float) transform[2], (float) transform[4],
-      (float) transform[1], (float) transform[3], (float) transform[5]);
+               (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));
+                                        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()
@@ -2022,6 +2351,7 @@ public class PGraphicsJava2D extends PGraphics {
   //                   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,
@@ -2032,64 +2362,93 @@ public class PGraphicsJava2D extends PGraphics {
   //                    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];
+    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];
+    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) {
@@ -2109,9 +2468,15 @@ public class PGraphicsJava2D extends PGraphics {
     g2.setStroke(strokeObject);
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // STROKE
+
   // noStroke() and stroke() inherited from PGraphics.
+
+
   @Override
   protected void strokeFromCalc() {
     super.strokeFromCalc();
@@ -2119,9 +2484,15 @@ public class PGraphicsJava2D extends PGraphics {
     strokeGradient = false;
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // TINT
+
   // noTint() and tint() inherited from PGraphics.
+
+
   @Override
   protected void tintFromCalc() {
     super.tintFromCalc();
@@ -2129,9 +2500,15 @@ public class PGraphicsJava2D extends PGraphics {
     tintColorObject = new Color(tintColor, true);
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // FILL
+
   // noFill() and fill() inherited from PGraphics.
+
+
   @Override
   protected void fillFromCalc() {
     super.fillFromCalc();
@@ -2139,8 +2516,13 @@ public class PGraphicsJava2D extends PGraphics {
     fillGradient = false;
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // MATERIAL PROPERTIES
+
+
   //public void ambient(int rgb)
   //public void ambient(float gray)
   //public void ambient(float x, float y, float z)
@@ -2154,8 +2536,14 @@ public class PGraphicsJava2D extends PGraphics {
   //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)
@@ -2173,8 +2561,14 @@ public class PGraphicsJava2D extends PGraphics {
   //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) {
@@ -2202,7 +2596,11 @@ public class PGraphicsJava2D extends PGraphics {
 
   // 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) {
@@ -2239,45 +2637,98 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // 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");
   }
 
+
   @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) {
@@ -2308,9 +2759,10 @@ public class PGraphicsJava2D extends PGraphics {
     return raster;
   }
 
+
   @Override
   public void loadPixels() {
-    if (pixels == null || (pixels.length != pixelWidth * pixelHeight)) {
+    if (pixels == null || (pixels.length != pixelWidth*pixelHeight)) {
       pixels = new int[pixelWidth * pixelHeight];
     }
 
@@ -2323,11 +2775,12 @@ public class PGraphicsJava2D extends PGraphics {
         pixels[i] = 0xff000000 | pixels[i];
       }
     }
-    //((BufferedImage) image).getRGB(0, 0, width, height, pixels, 0, width);
+      //((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.
 //   * <P>
@@ -2341,11 +2794,15 @@ 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.
+   * 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) {
@@ -2363,6 +2820,7 @@ public class PGraphicsJava2D extends PGraphics {
     modified = true;
   }
 
+
 //  @Override
 //  protected void updatePixelsImpl(int x, int y, int w, int h) {
 //    super.updatePixelsImpl(x, y, w, h);
@@ -2373,15 +2831,20 @@ public class PGraphicsJava2D extends PGraphics {
 //    }
 //    getRaster().setDataElements(0, 0, width, height, pixels);
 //  }
+
+
+
   //////////////////////////////////////////////////////////////
+
   // GET/SET
-  static int getset[] = new int[1];
+
+
+  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;
-    }
+    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();
@@ -2393,11 +2856,14 @@ public class PGraphicsJava2D extends PGraphics {
     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) {
+                         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 =
@@ -2418,7 +2884,7 @@ public class PGraphicsJava2D extends PGraphics {
 
       // Copy the temporary output pixels over to the outgoing image
       int sourceOffset = 0;
-      int targetOffset = targetY * target.pixelWidth + targetX;
+      int targetOffset = targetY*target.pixelWidth + targetX;
       for (int y = 0; y < sourceHeight; y++) {
         if (raster.getNumBands() == 3) {
           for (int i = 0; i < sourceWidth; i++) {
@@ -2435,11 +2901,10 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   @Override
   public void set(int x, int y, int argb) {
-    if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) {
-      return;
-    }
+    if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) return;
 //    ((BufferedImage) image).setRGB(x, y, argb);
     getset[0] = argb;
 //    WritableRaster raster = ((BufferedImage) (useOffscreen && primarySurface ? offscreen : image)).getRaster();
@@ -2447,24 +2912,27 @@ public class PGraphicsJava2D extends PGraphics {
     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) {
+                         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);
+                             sourceImage.pixelWidth, sourceImage.pixelHeight,
+                             sourceImage.pixels);
     } else {
       // TODO optimize, incredibly inefficient to reallocate this much memory
       PImage temp = sourceImage.get(sourceX, sourceY, sourceWidth, sourceHeight);
@@ -2472,10 +2940,16 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // MASK
-  static final String MASK_WARNING
-    = "mask() cannot be used on the main drawing surface";
+
+
+  static final String MASK_WARNING =
+    "mask() cannot be used on the main drawing surface";
+
 
   @Override
   public void mask(int[] alpha) {
@@ -2487,6 +2961,7 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   @Override
   public void mask(PImage alpha) {
     if (primaryGraphics) {
@@ -2497,17 +2972,31 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // 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) {
+                   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);
 
@@ -2518,25 +3007,41 @@ public class PGraphicsJava2D extends PGraphics {
     }
   }
 
+
   @Override
   public void copy(PImage src,
-    int sx, int sy, int sw, int sh,
-    int dx, int dy, int dw, int dh) {
+                   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);
+                 dx, dy, dx + dw, dy + dh,
+                 sx, sy, sx + sw, sy + sh, null);
   }
 
+
+
   //////////////////////////////////////////////////////////////
+
   // 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);