picrate 0.7.0-java → 0.8.0-java

data/src/main/java/processing/opengl/PSurfaceJOGL.java

@@ -1,6 +1,6 @@
 /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 
-/*
+ /*
   Part of the Processing project - http://processing.org
 
   Copyright (c) 2012-15 The Processing Foundation
@@ -20,8 +20,7 @@
   Public License along with this library; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   Boston, MA  02111-1307  USA
-*/
-
+ */
 package processing.opengl;
 
 import java.awt.Component;
@@ -65,7 +64,6 @@ import com.jogamp.newt.event.InputEvent;
 import com.jogamp.newt.opengl.GLWindow;
 import com.jogamp.opengl.util.FPSAnimator;
 
-
 import processing.core.PApplet;
 import processing.core.PConstants;
 import processing.core.PGraphics;
@@ -79,112 +77,115 @@ import processing.event.MouseEvent;
  * @author Martin Prout
  */
 public class PSurfaceJOGL implements PSurface {
-  /** Selected GL profile */
+
+  /**
+   * Selected GL profile
+   */
   public static GLProfile profile;
 
-    /**
-     *
-     */
-    public PJOGL pgl;
+  /**
+   *
+   */
+  public PJOGL pgl;
 
-    /**
-     *
-     */
-    protected GLWindow window;
+  /**
+   *
+   */
+  protected GLWindow window;
 
-    /**
-     *
-     */
-    protected FPSAnimator animator;
+  /**
+   *
+   */
+  protected FPSAnimator animator;
 
-    /**
-     *
-     */
-    protected Rectangle screenRect;
+  /**
+   *
+   */
+  protected Rectangle screenRect;
 
   private Thread drawExceptionHandler;
 
-    /**
-     *
-     */
-    protected PApplet sketch;
-
-    /**
-     *
-     */
-    protected PGraphics graphics;
-
-    /**
-     *
-     */
-    protected int sketchWidth0;
-
-    /**
-     *
-     */
-    protected int sketchHeight0;
-
-    /**
-     *
-     */
-    protected int sketchWidth;
-
-    /**
-     *
-     */
-    protected int sketchHeight;
-
-    /**
-     *
-     */
-    protected Display display;
-
-    /**
-     *
-     */
-    protected Screen screen;
-
-    /**
-     *
-     */
-    protected Rectangle displayRect;
-
-    /**
-     *
-     */
-    protected Throwable drawException;
+  /**
+   *
+   */
+  protected PApplet sketch;
+
+  /**
+   *
+   */
+  protected PGraphics graphics;
+
+  /**
+   *
+   */
+  protected int sketchWidth0;
+
+  /**
+   *
+   */
+  protected int sketchHeight0;
+
+  /**
+   *
+   */
+  protected int sketchWidth;
+
+  /**
+   *
+   */
+  protected int sketchHeight;
+
+  /**
+   *
+   */
+  protected Display display;
+
+  /**
+   *
+   */
+  protected Screen screen;
+
+  /**
+   *
+   */
+  protected Rectangle displayRect;
+
+  /**
+   *
+   */
+  protected Throwable drawException;
   private final Object drawExceptionMutex = new Object();
 
-    /**
-     *
-     */
-    protected NewtCanvasAWT canvas;
-
-    /**
-     *
-     */
-    protected int windowScaleFactor;
-
-    /**
-     *
-     */
-    protected float[] currentPixelScale = {0, 0};
-
-    /**
-     *
-     */
-    protected boolean external = false;
-
-    /**
-     *
-     * @param graphics
-     */
-    public PSurfaceJOGL(PGraphics graphics) {
+  /**
+   *
+   */
+  protected NewtCanvasAWT canvas;
+
+  /**
+   *
+   */
+  protected int windowScaleFactor;
+
+  /**
+   *
+   */
+  protected float[] currentPixelScale = {0, 0};
+
+  /**
+   *
+   */
+  protected boolean external = false;
+
+  /**
+   *
+   * @param graphics
+   */
+  public PSurfaceJOGL(PGraphics graphics) {
     this.graphics = graphics;
-    this.pgl = (PJOGL) ((PGraphicsOpenGL)graphics).pgl;
+    this.pgl = (PJOGL) ((PGraphicsOpenGL) graphics).pgl;
   }
 
-
+  @Override
   public void initOffscreen(PApplet sketch) {
     this.sketch = sketch;
 
@@ -198,7 +199,7 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-
+  @Override
   public void initFrame(PApplet sketch) {
     this.sketch = sketch;
     initIcons();
@@ -209,15 +210,15 @@ public class PSurfaceJOGL implements PSurface {
     initAnimator();
   }
 
-
+  @Override
   public Object getNative() {
     return window;
   }
 
-    /**
-     *
-     */
-    protected void initDisplay() {
+  /**
+   *
+   */
+  protected void initDisplay() {
     display = NewtFactory.createDisplay(null);
     display.addReference();
     screen = NewtFactory.createScreen(display, 0);
@@ -230,12 +231,12 @@ public class PSurfaceJOGL implements PSurface {
     int displayNum = sketch.sketchDisplay();
     if (displayNum > 0) {  // if -1, use the default device
       if (displayNum <= awtDevices.length) {
-        awtDisplayDevice = awtDevices[displayNum-1];
+        awtDisplayDevice = awtDevices[displayNum - 1];
       } else {
-        System.err.format("Display %d does not exist, " +
-          "using the default display instead.%n", displayNum);
+        System.err.format("Display %d does not exist, "
+          + "using the default display instead.%n", displayNum);
         for (int i = 0; i < awtDevices.length; i++) {
-          System.err.format("Display %d is %s%n", i+1, awtDevices[i]);
+          System.err.format("Display %d is %s%n", i + 1, awtDevices[i]);
         }
       }
     } else if (0 < awtDevices.length) {
@@ -249,52 +250,59 @@ public class PSurfaceJOGL implements PSurface {
     displayRect = awtDisplayDevice.getDefaultConfiguration().getBounds();
   }
 
-    /**
-     *
-     */
-    protected void initGL() {
+  /**
+   *
+   */
+  protected void initGL() {
 //  System.out.println("*******************************");
     if (profile == null) {
-      if (PJOGL.profile == 1) {
-        try {
-          profile = GLProfile.getGL2ES1();
-        } catch (GLException ex) {
-          profile = GLProfile.getMaxFixedFunc(true);
-        }
-      } else if (PJOGL.profile == 2) {
-        try {
-          profile = GLProfile.getGL2ES2();
+      switch (PJOGL.profile) {
+        case 1:
+          try {
+            profile = GLProfile.getGL2ES1();
+          } catch (GLException ex) {
+            profile = GLProfile.getMaxFixedFunc(true);
+          }
+          break;
+        case 2:
+          try {
+            profile = GLProfile.getGL2ES2();
 
-          // workaround for https://jogamp.org/bugzilla/show_bug.cgi?id=1347
-          if (!profile.isHardwareRasterizer()) {
-            GLProfile hardware = GLProfile.getMaxProgrammable(true);
-            if (hardware.isGL2ES2()) {
-              profile = hardware;
+            // workaround for https://jogamp.org/bugzilla/show_bug.cgi?id=1347
+            if (!profile.isHardwareRasterizer()) {
+              GLProfile hardware = GLProfile.getMaxProgrammable(true);
+              if (hardware.isGL2ES2()) {
+                profile = hardware;
+              }
             }
-          }
 
-        } catch (GLException ex) {
-          profile = GLProfile.getMaxProgrammable(true);
-        }
-      } else if (PJOGL.profile == 3) {
-        try {
-          profile = GLProfile.getGL2GL3();
-        } catch (GLException ex) {
-          profile = GLProfile.getMaxProgrammable(true);
-        }
-        if (!profile.isGL3()) {
-          PGraphics.showWarning("Requested profile GL3 but is not available, got: " + profile);
-        }
-      } else if (PJOGL.profile == 4) {
-        try {
-          profile = GLProfile.getGL4ES3();
-        } catch (GLException ex) {
-          profile = GLProfile.getMaxProgrammable(true);
-        }
-        if (!profile.isGL4()) {
-          PGraphics.showWarning("Requested profile GL4 but is not available, got: " + profile);
-        }
-      } else throw new RuntimeException(PGL.UNSUPPORTED_GLPROF_ERROR);
+          } catch (GLException ex) {
+            profile = GLProfile.getMaxProgrammable(true);
+          }
+          break;
+        case 3:
+          try {
+            profile = GLProfile.getGL2GL3();
+          } catch (GLException ex) {
+            profile = GLProfile.getMaxProgrammable(true);
+          }
+          if (!profile.isGL3()) {
+            PGraphics.showWarning("Requested profile GL3 but is not available, got: " + profile);
+          }
+          break;
+        case 4:
+          try {
+            profile = GLProfile.getGL4ES3();
+          } catch (GLException ex) {
+            profile = GLProfile.getMaxProgrammable(true);
+          }
+          if (!profile.isGL4()) {
+            PGraphics.showWarning("Requested profile GL4 but is not available, got: " + profile);
+          }
+          break;
+        default:
+          throw new RuntimeException(PGL.UNSUPPORTED_GLPROF_ERROR);
+      }
     }
 
     // Setting up the desired capabilities;
@@ -305,7 +313,6 @@ public class PSurfaceJOGL implements PSurface {
 
 //  caps.setPBuffer(false);
 //  caps.setFBO(false);
-
 //    pgl.reqNumSamples = PGL.smoothToSamples(graphics.smooth);
     caps.setSampleBuffers(true);
     caps.setNumSamples(PGL.smoothToSamples(graphics.smooth));
@@ -314,10 +321,10 @@ public class PSurfaceJOGL implements PSurface {
     pgl.setCaps(caps);
   }
 
-    /**
-     *
-     */
-    protected void initWindow() {
+  /**
+   *
+   */
+  protected void initWindow() {
     window = GLWindow.create(screen, pgl.getCaps());
 
     // Make sure that we pass the window close through to exit(), otherwise
@@ -332,16 +339,15 @@ public class PSurfaceJOGL implements PSurface {
 //    } else {
 //      window = GLWindow.create(displayDevice.getScreen(), pgl.getCaps());
 //    }
-
-    windowScaleFactor = PApplet.platform == PConstants.MACOSX ?
-        1 : sketch.pixelDensity;
+    windowScaleFactor = PApplet.platform == PConstants.MACOSX
+      ? 1 : sketch.pixelDensity;
 
     boolean spanDisplays = sketch.sketchDisplay() == PConstants.SPAN;
-    screenRect = spanDisplays ?
-      new Rectangle(screen.getX(), screen.getY(), screen.getWidth(), screen.getHeight()) :
-      new Rectangle((int) displayRect.getX(), (int) displayRect.getY(),
-                    (int) displayRect.getWidth(),
-                    (int) displayRect.getHeight());
+    screenRect = spanDisplays
+      ? new Rectangle(screen.getX(), screen.getY(), screen.getWidth(), screen.getHeight())
+      : new Rectangle((int) displayRect.getX(), (int) displayRect.getY(),
+        (int) displayRect.getWidth(),
+        (int) displayRect.getHeight());
 
     // Set the displayWidth/Height variables inside PApplet, so that they're
     // usable and can even be returned by the sketchWidth()/Height() methods.
@@ -368,8 +374,7 @@ public class PSurfaceJOGL implements PSurface {
 //      graphics.setSize(w, h - 22 - 22);
       System.err.println("setting width/height to " + w + " "  + h);
     }
-    */
-
+     */
     sketchWidth = sketch.sketchWidth();
     sketchHeight = sketch.sketchHeight();
 //    System.out.println("init: " + sketchWidth + " " + sketchHeight);
@@ -387,7 +392,7 @@ public class PSurfaceJOGL implements PSurface {
       fullScreen = true;
       sketch.fullScreen();
     }
-    */
+     */
 
     if (fullScreen || spanDisplays) {
       sketchWidth = screenRect.width / windowScaleFactor;
@@ -398,13 +403,13 @@ public class PSurfaceJOGL implements PSurface {
 
     float[] reqSurfacePixelScale;
     if (graphics.is2X() && PApplet.platform == PConstants.MACOSX) {
-       // Retina
-       reqSurfacePixelScale = new float[] { ScalableSurface.AUTOMAX_PIXELSCALE,
-                                            ScalableSurface.AUTOMAX_PIXELSCALE };
+      // Retina
+      reqSurfacePixelScale = new float[]{ScalableSurface.AUTOMAX_PIXELSCALE,
+        ScalableSurface.AUTOMAX_PIXELSCALE};
     } else {
       // Non-retina
-      reqSurfacePixelScale = new float[] { ScalableSurface.IDENTITY_PIXELSCALE,
-                                           ScalableSurface.IDENTITY_PIXELSCALE };
+      reqSurfacePixelScale = new float[]{ScalableSurface.IDENTITY_PIXELSCALE,
+        ScalableSurface.IDENTITY_PIXELSCALE};
     }
     window.setSurfaceScale(reqSurfacePixelScale);
     window.setSize(sketchWidth * windowScaleFactor, sketchHeight * windowScaleFactor);
@@ -422,10 +427,10 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-    /**
-     *
-     */
-    protected void initListeners() {
+  /**
+   *
+   */
+  protected void initListeners() {
     NEWTMouseListener mouseListener = new NEWTMouseListener();
     window.addMouseListener(mouseListener);
     NEWTKeyListener keyListener = new NEWTKeyListener();
@@ -437,10 +442,10 @@ public class PSurfaceJOGL implements PSurface {
     window.addGLEventListener(drawlistener);
   }
 
-    /**
-     *
-     */
-    protected void initAnimator() {
+  /**
+   *
+   */
+  protected void initAnimator() {
     if (PApplet.platform == PConstants.WINDOWS) {
       // Force Windows to keep timer resolution high by
       // sleeping for time which is not a multiple of 10 ms.
@@ -449,7 +454,8 @@ public class PSurfaceJOGL implements PSurface {
       Thread highResTimerThread = new Thread(() -> {
         try {
           Thread.sleep(Long.MAX_VALUE);
-        } catch (InterruptedException ignore) { }
+        } catch (InterruptedException ignore) {
+        }
       }, "HighResTimerThread");
       highResTimerThread.setDaemon(true);
       highResTimerThread.start();
@@ -457,19 +463,15 @@ public class PSurfaceJOGL implements PSurface {
 
     animator = new FPSAnimator(window, 60);
     drawException = null;
-    animator.setUncaughtExceptionHandler(new GLAnimatorControl.UncaughtExceptionHandler() {
-      @Override
-      public void uncaughtException(final GLAnimatorControl animator,
-                                    final GLAutoDrawable drawable,
-                                    final Throwable cause) {
-        synchronized (drawExceptionMutex) {
-          drawException = cause;
-          drawExceptionMutex.notify();
-        }
+    animator.setUncaughtExceptionHandler((final GLAnimatorControl animator1, final GLAutoDrawable drawable, final Throwable cause) -> {
+      synchronized (drawExceptionMutex) {
+        drawException = cause;
+        drawExceptionMutex.notify();
       }
     });
 
     drawExceptionHandler = new Thread(new Runnable() {
+      @Override
       public void run() {
         synchronized (drawExceptionMutex) {
           try {
@@ -493,7 +495,6 @@ public class PSurfaceJOGL implements PSurface {
               }
             }
           } catch (InterruptedException e) {
-            return;
           }
         }
       }
@@ -501,71 +502,55 @@ public class PSurfaceJOGL implements PSurface {
     drawExceptionHandler.start();
   }
 
-
   @Override
   public void setTitle(final String title) {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setTitle(title);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setTitle(title);
     });
   }
 
-
   @Override
   public void setVisible(final boolean visible) {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setVisible(visible);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setVisible(visible);
     });
   }
 
-
   @Override
   public void setResizable(final boolean resizable) {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setResizable(resizable);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setResizable(resizable);
     });
   }
 
-
+  @Override
   public void setIcon(PImage icon) {
-    PGraphics.showWarning("Window icons for OpenGL sketches can only be set in settings()\n" +
-                          "using PJOGL.setIcon(filename).");
+    PGraphics.showWarning("Window icons for OpenGL sketches can only be set in settings()\n"
+      + "using PJOGL.setIcon(filename).");
   }
 
-
   @Override
   public void setAlwaysOnTop(final boolean always) {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setAlwaysOnTop(always);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setAlwaysOnTop(always);
     });
   }
 
-    /**
-     *
-     */
-    protected void initIcons() {
+  /**
+   *
+   */
+  protected void initIcons() {
     IOUtil.ClassResources res = null;
     if (PJOGL.icons == null || PJOGL.icons.length == 0) {
       // Default Processing icons
-      final int[] sizes = { 16, 32, 48, 64, 128, 256, 512 };
+      final int[] sizes = {16, 32, 48, 64, 128, 256, 512};
       String[] iconImages = new String[sizes.length];
       for (int i = 0; i < sizes.length; i++) {
-         iconImages[i] = "/icon/icon-" + sizes[i] + ".png";
-       }
-       res = new ClassResources(iconImages,
-                                PApplet.class.getClassLoader(),
-                                PApplet.class);
+        iconImages[i] = "/icon/icon-" + sizes[i] + ".png";
+      }
+      res = new ClassResources(iconImages,
+        PApplet.class.getClassLoader(),
+        PApplet.class);
     } else {
       // Loading custom icons from user-provided files.
       String[] iconImages = new String[PJOGL.icons.length];
@@ -574,13 +559,12 @@ public class PSurfaceJOGL implements PSurface {
       }
 
       res = new ClassResources(iconImages,
-                               sketch.getClass().getClassLoader(),
-                               sketch.getClass());
+        sketch.getClass().getClassLoader(),
+        sketch.getClass());
     }
     NewtFactory.setWindowIcons(res);
   }
 
-
   @SuppressWarnings("resource")
   private String resourceFilename(String filename) {
     // The code below comes from PApplet.createInputRaw() with a few adaptations
@@ -606,12 +590,13 @@ public class PSurfaceJOGL implements PSurface {
           //if (filenameActual.equalsIgnoreCase(filenameShort) &&
           //!filenameActual.equals(filenameShort)) {
           if (!filenameActual.equals(filenameShort)) {
-            throw new RuntimeException("This file is named " +
-                                       filenameActual + " not " +
-                                       filename + ". Rename the file " +
-                                       "or change your code.");
+            throw new RuntimeException("This file is named "
+              + filenameActual + " not "
+              + filename + ". Rename the file "
+              + "or change your code.");
           }
-        } catch (IOException e) { }
+        } catch (IOException e) {
+        }
       }
 
       stream = new FileInputStream(file);
@@ -622,8 +607,8 @@ public class PSurfaceJOGL implements PSurface {
 
       // have to break these out because a general Exception might
       // catch the RuntimeException being thrown above
-    } catch (IOException ioe) {
-    } catch (SecurityException se) { }
+    } catch (IOException | SecurityException ioe) {
+    }
 
     ClassLoader cl = sketch.getClass().getClassLoader();
 
@@ -654,7 +639,8 @@ public class PSurfaceJOGL implements PSurface {
           return filename;
         }
       }
-    } catch (IOException e) { }
+    } catch (IOException e) {
+    }
 
     try {
       // attempt to load from a local file, used when running as
@@ -667,7 +653,8 @@ public class PSurfaceJOGL implements PSurface {
             stream.close();
             return path;
           }
-        } catch (IOException e2) { }
+        } catch (IOException e2) {
+        }
 
         try {
           String path = sketch.sketchPath(filename);
@@ -676,7 +663,8 @@ public class PSurfaceJOGL implements PSurface {
             stream.close();
             return path;
           }
-        } catch (Exception e) { }  // ignored
+        } catch (IOException e) {
+        }  // ignored
 
         try {
           stream = new FileInputStream(filename);
@@ -684,19 +672,19 @@ public class PSurfaceJOGL implements PSurface {
             stream.close();
             return filename;
           }
-        } catch (IOException e1) { }
+        } catch (IOException e1) {
+        }
 
-      } catch (SecurityException se) { }  // online, whups
+      } catch (SecurityException se) {
+      }  // online, whups
 
     } catch (Exception e) {
       //die(e.getMessage(), e);
-      e.printStackTrace();
     }
 
     return "";
   }
 
-
   @Override
   public void placeWindow(int[] location, int[] editorLocation) {
 
@@ -733,19 +721,19 @@ public class PSurfaceJOGL implements PSurface {
         if ((locationX + w > sketch.displayWidth - 33) ||
             (locationY + h > sketch.displayHeight - 33)) {
           // otherwise center on screen
-        */
+         */
         locationX = (sketch.displayWidth - w) / 2;
         locationY = (sketch.displayHeight - h) / 2;
         /*
         }
-        */
+         */
         window.setTopLevelPosition(locationX, locationY);
       }
     } else {  // just center on screen
       // Can't use frame.setLocationRelativeTo(null) because it sends the
       // frame to the main display, which undermines the --display setting.
       window.setTopLevelPosition(screenRect.x + (screenRect.width - sketchWidth) / 2,
-                                 screenRect.y + (screenRect.height - sketchHeight) / 2);
+        screenRect.y + (screenRect.height - sketchHeight) / 2);
     }
 
     Point frameLoc = new Point(x, y);
@@ -756,11 +744,11 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-
+  @Override
   public void placePresent(int stopColor) {
     float scale = getPixelScale();
-    pgl.initPresentMode(0.5f * (screenRect.width/scale - sketchWidth),
-                        0.5f * (screenRect.height/scale - sketchHeight), stopColor);
+    pgl.initPresentMode(0.5f * (screenRect.width / scale - sketchWidth),
+      0.5f * (screenRect.height / scale - sketchHeight), stopColor);
     PApplet.hideMenuBar();
 
     window.setUndecorated(true);
@@ -768,33 +756,33 @@ public class PSurfaceJOGL implements PSurface {
     window.setTopLevelSize((int) displayRect.getWidth(), (int) displayRect.getHeight());
   }
 
-
+  @Override
   public void setupExternalMessages() {
     external = true;
   }
 
-
+  @Override
   public void startThread() {
     if (animator != null) {
       animator.start();
     }
   }
 
-
+  @Override
   public void pauseThread() {
     if (animator != null) {
       animator.pause();
     }
   }
 
-
+  @Override
   public void resumeThread() {
     if (animator != null) {
       animator.resume();
     }
   }
 
-
+  @Override
   public boolean stopThread() {
     if (drawExceptionHandler != null) {
       drawExceptionHandler.interrupt();
@@ -807,7 +795,11 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-
+  /**
+   *
+   * @return
+   */
+  @Override
   public boolean isStopped() {
     if (animator != null) {
       return !animator.isAnimating();
@@ -816,19 +808,18 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-
+  @Override
   public void setLocation(final int x, final int y) {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setTopLevelPosition(x, y);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setTopLevelPosition(x, y);
     });
   }
 
-
+  @Override
   public void setSize(int wide, int high) {
-    if (pgl.presentMode()) return;
+    if (pgl.presentMode()) {
+      return;
+    }
 
     // When the surface is set to resizable via surface.setResizable(true),
     // a crash may occur if the user sets the window to size zero.
@@ -853,11 +844,11 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-    /**
-     *
-     * @return
-     */
-    public float getPixelScale() {
+  /**
+   *
+   * @return
+   */
+  public float getPixelScale() {
     if (graphics.pixelDensity == 1) {
       return 1;
     }
@@ -876,19 +867,19 @@ public class PSurfaceJOGL implements PSurface {
     return currentPixelScale[0];
   }
 
-    /**
-     *
-     * @return
-     */
-    public Component getComponent() {
+  /**
+   *
+   * @return
+   */
+  public Component getComponent() {
     return canvas;
   }
 
-    /**
-     *
-     * @param level
-     */
-    public void setSmooth(int level) {
+  /**
+   *
+   * @param level
+   */
+  public void setSmooth(int level) {
     pgl.reqNumSamples = level;
     GLCapabilities caps = new GLCapabilities(profile);
     caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);
@@ -903,41 +894,39 @@ public class PSurfaceJOGL implements PSurface {
     config.setChosenCapabilities(caps);
   }
 
-
+  @Override
   public void setFrameRate(float fps) {
     if (fps < 1) {
       PGraphics.showWarning(
-        "The OpenGL renderer cannot have a frame rate lower than 1.\n" +
-        "Your sketch will run at 1 frame per second.");
+        "The OpenGL renderer cannot have a frame rate lower than 1.\n"
+        + "Your sketch will run at 1 frame per second.");
       fps = 1;
     } else if (fps > 1000) {
       PGraphics.showWarning(
-        "The OpenGL renderer cannot have a frame rate higher than 1000.\n" +
-        "Your sketch will run at 1000 frames per second.");
+        "The OpenGL renderer cannot have a frame rate higher than 1000.\n"
+        + "Your sketch will run at 1000 frames per second.");
       fps = 1000;
     }
     if (animator != null) {
       animator.stop();
-      animator.setFPS((int)fps);
+      animator.setFPS((int) fps);
       pgl.setFps(fps);
       animator.start();
     }
   }
 
-    /**
-     *
-     */
-    public void requestFocus() {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.requestFocus();
-      }
+  /**
+   *
+   */
+  public void requestFocus() {
+    display.getEDTUtil().invoke(false, () -> {
+      window.requestFocus();
     });
   }
 
-
   class DrawListener implements GLEventListener {
+
+    @Override
     public void display(GLAutoDrawable drawable) {
       if (display.getEDTUtil().isCurrentThreadEDT()) {
         // For some reason, the first two frames of the animator are run on the
@@ -974,9 +963,13 @@ public class PSurfaceJOGL implements PSurface {
         sketch.exitActual();
       }
     }
+
+    @Override
     public void dispose(GLAutoDrawable drawable) {
 //      sketch.dispose();
     }
+
+    @Override
     public void init(GLAutoDrawable drawable) {
       pgl.getGL(drawable);
       pgl.init(drawable);
@@ -984,244 +977,241 @@ public class PSurfaceJOGL implements PSurface {
 
       int c = graphics.backgroundColor;
       pgl.clearColor(((c >> 16) & 0xff) / 255f,
-                     ((c >>  8) & 0xff) / 255f,
-                     ((c >>  0) & 0xff) / 255f,
-                     ((c >> 24) & 0xff) / 255f);
+        ((c >> 8) & 0xff) / 255f,
+        ((c) & 0xff) / 255f,
+        ((c >> 24) & 0xff) / 255f);
       pgl.clear(PGL.COLOR_BUFFER_BIT);
     }
 
+    @Override
     public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
       pgl.resetFBOLayer();
       pgl.getGL(drawable);
-      float scale = PApplet.platform == PConstants.MACOSX ?
-          getCurrentPixelScale() : getPixelScale();
+      float scale = PApplet.platform == PConstants.MACOSX
+        ? getCurrentPixelScale() : getPixelScale();
       setSize((int) (w / scale), (int) (h / scale));
     }
   }
 
+  /**
+   *
+   */
+  protected class NEWTWindowListener implements com.jogamp.newt.event.WindowListener {
+
     /**
      *
      */
-    protected class NEWTWindowListener implements com.jogamp.newt.event.WindowListener {
-
-      /**
-       *
-       */
-      public NEWTWindowListener() {
+    public NEWTWindowListener() {
       super();
     }
 
-      /**
-       *
-       * @param arg0
-       */
-      @Override
+    /**
+     *
+     * @param arg0
+     */
+    @Override
     public void windowGainedFocus(com.jogamp.newt.event.WindowEvent arg0) {
       sketch.focused = true;
       sketch.focusGained();
     }
 
-      /**
-       *
-       * @param arg0
-       */
-      @Override
+    /**
+     *
+     * @param arg0
+     */
+    @Override
     public void windowLostFocus(com.jogamp.newt.event.WindowEvent arg0) {
       sketch.focused = false;
       sketch.focusLost();
     }
 
-      /**
-       *
-       * @param arg0
-       */
-      @Override
+    /**
+     *
+     * @param arg0
+     */
+    @Override
     public void windowDestroyNotify(com.jogamp.newt.event.WindowEvent arg0) {
       sketch.exit();
     }
 
-      /**
-       *
-       * @param arg0
-       */
-      @Override
+    /**
+     *
+     * @param arg0
+     */
+    @Override
     public void windowDestroyed(com.jogamp.newt.event.WindowEvent arg0) {
       sketch.exit();
     }
 
-      /**
-       *
-       * @param arg0
-       */
-      @Override
+    /**
+     *
+     * @param arg0
+     */
+    @Override
     public void windowMoved(com.jogamp.newt.event.WindowEvent arg0) {
       if (external) {
         sketch.frameMoved(window.getX(), window.getY());
       }
     }
 
-      /**
-       *
-       * @param arg0
-       */
-      @Override
+    /**
+     *
+     * @param arg0
+     */
+    @Override
     public void windowRepaint(com.jogamp.newt.event.WindowUpdateEvent arg0) {
     }
 
-      /**
-       *
-       * @param arg0
-       */
-      @Override
+    /**
+     *
+     * @param arg0
+     */
+    @Override
     public void windowResized(com.jogamp.newt.event.WindowEvent arg0) {
     }
   }
 
-
   // NEWT mouse listener
+  /**
+   *
+   */
+  protected class NEWTMouseListener extends com.jogamp.newt.event.MouseAdapter {
 
     /**
      *
      */
-  protected class NEWTMouseListener extends com.jogamp.newt.event.MouseAdapter {
-
-      /**
-       *
-       */
-      public NEWTMouseListener() {
+    public NEWTMouseListener() {
       super();
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mousePressed(com.jogamp.newt.event.MouseEvent e) {
       nativeMouseEvent(e, MouseEvent.PRESS);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mouseReleased(com.jogamp.newt.event.MouseEvent e) {
       nativeMouseEvent(e, MouseEvent.RELEASE);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mouseClicked(com.jogamp.newt.event.MouseEvent e) {
       nativeMouseEvent(e, MouseEvent.CLICK);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mouseDragged(com.jogamp.newt.event.MouseEvent e) {
       nativeMouseEvent(e, MouseEvent.DRAG);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mouseMoved(com.jogamp.newt.event.MouseEvent e) {
       nativeMouseEvent(e, MouseEvent.MOVE);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mouseWheelMoved(com.jogamp.newt.event.MouseEvent e) {
       nativeMouseEvent(e, MouseEvent.WHEEL);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mouseEntered(com.jogamp.newt.event.MouseEvent e) {
 //      System.out.println("enter");
       nativeMouseEvent(e, MouseEvent.ENTER);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void mouseExited(com.jogamp.newt.event.MouseEvent e) {
 //      System.out.println("exit");
       nativeMouseEvent(e, MouseEvent.EXIT);
     }
   }
 
-
   // NEWT key listener
+  /**
+   *
+   */
+  protected class NEWTKeyListener extends com.jogamp.newt.event.KeyAdapter {
 
     /**
      *
      */
-  protected class NEWTKeyListener extends com.jogamp.newt.event.KeyAdapter {
-
-      /**
-       *
-       */
-      public NEWTKeyListener() {
+    public NEWTKeyListener() {
       super();
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void keyPressed(com.jogamp.newt.event.KeyEvent e) {
       nativeKeyEvent(e, KeyEvent.PRESS);
     }
 
-      /**
-       *
-       * @param e
-       */
-      @Override
+    /**
+     *
+     * @param e
+     */
+    @Override
     public void keyReleased(com.jogamp.newt.event.KeyEvent e) {
       nativeKeyEvent(e, KeyEvent.RELEASE);
     }
 
-      /**
-       *
-       * @param e
-       */
-      public void keyTyped(com.jogamp.newt.event.KeyEvent e)  {
+    /**
+     *
+     * @param e
+     */
+    public void keyTyped(com.jogamp.newt.event.KeyEvent e) {
       nativeKeyEvent(e, KeyEvent.TYPE);
     }
   }
 
-    /**
-     *
-     * @param nativeEvent
-     * @param peAction
-     */
-    protected void nativeMouseEvent(com.jogamp.newt.event.MouseEvent nativeEvent,
-                                  int peAction) {
+  /**
+   *
+   * @param nativeEvent
+   * @param peAction
+   */
+  protected void nativeMouseEvent(com.jogamp.newt.event.MouseEvent nativeEvent,
+    int peAction) {
     int modifiers = nativeEvent.getModifiers();
-    int peModifiers = modifiers &
-                      (InputEvent.SHIFT_MASK |
-                       InputEvent.CTRL_MASK |
-                       InputEvent.META_MASK |
-                       InputEvent.ALT_MASK);
+    int peModifiers = modifiers
+      & (InputEvent.SHIFT_MASK
+      | InputEvent.CTRL_MASK
+      | InputEvent.META_MASK
+      | InputEvent.ALT_MASK);
 
     int peButton = 0;
     switch (nativeEvent.getButton()) {
@@ -1247,8 +1237,8 @@ public class PSurfaceJOGL implements PSurface {
     if (peAction == MouseEvent.WHEEL) {
       // Invert wheel rotation count so it matches JAVA2D's
       // https://github.com/processing/processing/issues/3840
-      peCount = -(nativeEvent.isShiftDown() ? (int)nativeEvent.getRotation()[0]:
-                                              (int)nativeEvent.getRotation()[1]);
+      peCount = -(nativeEvent.isShiftDown() ? (int) nativeEvent.getRotation()[0]
+        : (int) nativeEvent.getRotation()[1]);
     } else {
       peCount = nativeEvent.getClickCount();
     }
@@ -1265,10 +1255,10 @@ public class PSurfaceJOGL implements PSurface {
     int my = sy;
 
     if (pgl.presentMode()) {
-      mx -= (int)pgl.presentX;
-      my -= (int)pgl.presentY;
-      if (peAction == KeyEvent.RELEASE &&
-          pgl.insideStopButton(sx, sy - screenRect.height / windowScaleFactor)) {
+      mx -= (int) pgl.presentX;
+      my -= (int) pgl.presentY;
+      if (peAction == KeyEvent.RELEASE
+        && pgl.insideStopButton(sx, sy - screenRect.height / windowScaleFactor)) {
         sketch.exit();
       }
       if (mx < 0 || sketchWidth < mx || my < 0 || sketchHeight < my) {
@@ -1277,26 +1267,26 @@ public class PSurfaceJOGL implements PSurface {
     }
 
     MouseEvent me = new MouseEvent(nativeEvent, nativeEvent.getWhen(),
-                                   peAction, peModifiers,
-                                   mx, my,
-                                   peButton,
-                                   peCount);
+      peAction, peModifiers,
+      mx, my,
+      peButton,
+      peCount);
 
     sketch.postEvent(me);
   }
 
-    /**
-     *
-     * @param nativeEvent
-     * @param peAction
-     */
-    protected void nativeKeyEvent(com.jogamp.newt.event.KeyEvent nativeEvent,
-                                int peAction) {
-    int peModifiers = nativeEvent.getModifiers() &
-                      (InputEvent.SHIFT_MASK |
-                       InputEvent.CTRL_MASK |
-                       InputEvent.META_MASK |
-                       InputEvent.ALT_MASK);
+  /**
+   *
+   * @param nativeEvent
+   * @param peAction
+   */
+  protected void nativeKeyEvent(com.jogamp.newt.event.KeyEvent nativeEvent,
+    int peAction) {
+    int peModifiers = nativeEvent.getModifiers()
+      & (InputEvent.SHIFT_MASK
+      | InputEvent.CTRL_MASK
+      | InputEvent.META_MASK
+      | InputEvent.ALT_MASK);
 
     short code = nativeEvent.getKeyCode();
     char keyChar;
@@ -1306,8 +1296,8 @@ public class PSurfaceJOGL implements PSurface {
       keyChar = PConstants.CODED;
     } else if (isHackyKey(code)) {
       // we can return only one char for ENTER, let it be \n everywhere
-      keyCode = code == com.jogamp.newt.event.KeyEvent.VK_ENTER ?
-          PConstants.ENTER : code;
+      keyCode = code == com.jogamp.newt.event.KeyEvent.VK_ENTER
+        ? PConstants.ENTER : code;
       keyChar = hackToChar(code, nativeEvent.getKeyChar());
     } else {
       keyCode = code;
@@ -1322,10 +1312,10 @@ public class PSurfaceJOGL implements PSurface {
     // In contrast to key symbol, key code uses a fixed US keyboard layout and therefore is keyboard layout independent.
     // E.g. virtual key code VK_Y denotes the same physical key regardless whether keyboard layout QWERTY or QWERTZ is active. The key symbol of the former is VK_Y, where the latter produces VK_Y.
     KeyEvent ke = new KeyEvent(nativeEvent, nativeEvent.getWhen(),
-                               peAction, peModifiers,
-                               keyChar,
-                               keyCode,
-                               nativeEvent.isAutoRepeat());
+      peAction, peModifiers,
+      keyChar,
+      keyCode,
+      nativeEvent.isAutoRepeat());
 
     sketch.postEvent(ke);
 
@@ -1334,29 +1324,27 @@ public class PSurfaceJOGL implements PSurface {
         // Create key typed event
         // TODO: combine dead keys with the following key
         KeyEvent tke = new KeyEvent(nativeEvent, nativeEvent.getWhen(),
-                                    KeyEvent.TYPE, peModifiers,
-                                    keyChar,
-                                    0,
-                                    nativeEvent.isAutoRepeat());
+          KeyEvent.TYPE, peModifiers,
+          keyChar,
+          0,
+          nativeEvent.isAutoRepeat());
 
         sketch.postEvent(tke);
       }
     }
   }
 
-
   private static boolean isPCodedKey(short code) {
-    return code == com.jogamp.newt.event.KeyEvent.VK_UP ||
-           code == com.jogamp.newt.event.KeyEvent.VK_DOWN ||
-           code == com.jogamp.newt.event.KeyEvent.VK_LEFT ||
-           code == com.jogamp.newt.event.KeyEvent.VK_RIGHT ||
-           code == com.jogamp.newt.event.KeyEvent.VK_ALT ||
-           code == com.jogamp.newt.event.KeyEvent.VK_CONTROL ||
-           code == com.jogamp.newt.event.KeyEvent.VK_SHIFT ||
-           code == com.jogamp.newt.event.KeyEvent.VK_WINDOWS;
+    return code == com.jogamp.newt.event.KeyEvent.VK_UP
+      || code == com.jogamp.newt.event.KeyEvent.VK_DOWN
+      || code == com.jogamp.newt.event.KeyEvent.VK_LEFT
+      || code == com.jogamp.newt.event.KeyEvent.VK_RIGHT
+      || code == com.jogamp.newt.event.KeyEvent.VK_ALT
+      || code == com.jogamp.newt.event.KeyEvent.VK_CONTROL
+      || code == com.jogamp.newt.event.KeyEvent.VK_SHIFT
+      || code == com.jogamp.newt.event.KeyEvent.VK_WINDOWS;
   }
 
-
   // Why do we need this mapping?
   // Relevant discussion and links here:
   // http://forum.jogamp.org/Newt-wrong-keycode-for-key-td4033690.html#a4033697
@@ -1384,7 +1372,6 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-
   private static boolean isHackyKey(short code) {
     switch (code) {
       case com.jogamp.newt.event.KeyEvent.VK_BACK_SPACE:
@@ -1397,7 +1384,6 @@ public class PSurfaceJOGL implements PSurface {
     return false;
   }
 
-
   private static char hackToChar(short code, char def) {
     switch (code) {
       case com.jogamp.newt.event.KeyEvent.VK_BACK_SPACE:
@@ -1414,11 +1400,9 @@ public class PSurfaceJOGL implements PSurface {
     return def;
   }
 
-
   // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-
-
   class CursorInfo {
+
     PImage image;
     int x, y;
 
@@ -1435,6 +1419,7 @@ public class PSurfaceJOGL implements PSurface {
 
   static Map<Integer, CursorInfo> cursors = new HashMap<>();
   static Map<Integer, String> cursorNames = new HashMap<>();
+
   static {
     cursorNames.put(PConstants.ARROW, "arrow");
     cursorNames.put(PConstants.CROSS, "cross");
@@ -1444,7 +1429,7 @@ public class PSurfaceJOGL implements PSurface {
     cursorNames.put(PConstants.TEXT, "text");
   }
 
-
+  @Override
   public void setCursor(int kind) {
     if (!cursorNames.containsKey(kind)) {
       PGraphics.showWarning("Unknown cursor type: " + kind);
@@ -1454,19 +1439,28 @@ public class PSurfaceJOGL implements PSurface {
     if (cursor == null) {
       String name = cursorNames.get(kind);
       if (name != null) {
-        ImageIcon icon =
-          new ImageIcon(getClass().getResource("cursors/" + name + ".png"));
+        ImageIcon icon
+          = new ImageIcon(getClass().getResource("cursors/" + name + ".png"));
         PImage img = new PImage(icon.getImage());
         // Most cursors just use the center as the hotspot...
         int x = img.width / 2;
         int y = img.height / 2;
         // ...others are more specific
-        if (kind == PConstants.ARROW) {
-          x = 10; y = 7;
-        } else if (kind == PConstants.HAND) {
-          x = 12; y = 8;
-        } else if (kind == PConstants.TEXT) {
-          x = 16; y = 22;
+        switch (kind) {
+          case PConstants.ARROW:
+            x = 10;
+            y = 7;
+            break;
+          case PConstants.HAND:
+            x = 12;
+            y = 8;
+            break;
+          case PConstants.TEXT:
+            x = 16;
+            y = 22;
+            break;
+          default:
+            break;
         }
         cursor = new CursorInfo(img, x, y);
         cursors.put(kind, cursor);
@@ -1479,11 +1473,11 @@ public class PSurfaceJOGL implements PSurface {
     }
   }
 
-
+  @Override
   public void setCursor(PImage image, int hotspotX, int hotspotY) {
     Display disp = window.getScreen().getDisplay();
-    BufferedImage bimg = (BufferedImage)image.getNative();
-    DataBufferInt dbuf = (DataBufferInt)bimg.getData().getDataBuffer();
+    BufferedImage bimg = (BufferedImage) image.getNative();
+    DataBufferInt dbuf = (DataBufferInt) bimg.getData().getDataBuffer();
     int[] ipix = dbuf.getData();
     ByteBuffer pixels = ByteBuffer.allocate(ipix.length * 4);
     pixels.asIntBuffer().put(ipix);
@@ -1491,32 +1485,23 @@ public class PSurfaceJOGL implements PSurface {
     final Dimension size = new Dimension(bimg.getWidth(), bimg.getHeight());
     PixelRectangle pixelrect = new PixelRectangle.GenericPixelRect(format, size, 0, false, pixels);
     final PointerIcon pi = disp.createPointerIcon(pixelrect, hotspotX, hotspotY);
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setPointerVisible(true);
-        window.setPointerIcon(pi);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setPointerVisible(true);
+      window.setPointerIcon(pi);
     });
   }
 
-
+  @Override
   public void showCursor() {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setPointerVisible(true);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setPointerVisible(true);
     });
   }
 
-
+  @Override
   public void hideCursor() {
-    display.getEDTUtil().invoke(false, new Runnable() {
-      @Override
-      public void run() {
-        window.setPointerVisible(false);
-      }
+    display.getEDTUtil().invoke(false, () -> {
+      window.setPointerVisible(false);
     });
   }
 }