picrate 0.8.0-java → 0.9.0-java

data/src/main/java/processing/net/Server.java

@@ -0,0 +1,385 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+ /*
+  Server - basic network server implementation
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2004-2007 Ben Fry and Casey Reas
+  The previous version of this code was developed by Hernando Barragan
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+ */
+package processing.net;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+import processing.core.PApplet;
+
+/**
+ * ( begin auto-generated from Server.xml )
+ *
+ * A server sends and receives data to and from its associated clients (other
+ * programs connected to it). When a server is started, it begins listening for
+ * connections on the port specified by the <b>port</b>
+ * parameter. Computers have many ports for transferring data and some are
+ * commonly used so be sure to not select one of these. For example, web servers
+ * usually use port 80 and POP mail uses port 110.
+ *
+ * ( end auto-generated )
+ *
+ * @webref net
+ * @usage application
+ * @brief The server class is used to create server objects which send and
+ * receives data to and from its associated clients (other programs connected to
+ * it).
+ * @instanceName server any variable of type Server
+ */
+public class Server implements Runnable {
+
+    PApplet parent;
+    Method serverEventMethod;
+
+    volatile Thread thread;
+    ServerSocket server;
+    int port;
+
+    protected final Object clientsLock = new Object[0];
+    /**
+     * Number of clients currently connected.
+     */
+    public int clientCount;
+    /**
+     * Array of client objects, useful length is determined by clientCount.
+     */
+    public Client[] clients;
+
+    /**
+     * @param parent typically use "this"
+     * @param port port used to transfer data
+     */
+    public Server(PApplet parent, int port) {
+        this(parent, port, null);
+    }
+
+    /**
+     * @param parent typically use "this"
+     * @param port port used to transfer data
+     * @param host when multiple NICs are in use, the ip (or name) to bind from
+     */
+    public Server(PApplet parent, int port, String host) {
+        this.parent = parent;
+        this.port = port;
+
+        try {
+            if (host == null) {
+                server = new ServerSocket(this.port);
+            } else {
+                server = new ServerSocket(this.port, 10, InetAddress.getByName(host));
+            }
+            //clients = new Vector();
+            clients = new Client[10];
+
+            thread = new Thread(this);
+            thread.start();
+
+            parent.registerMethod("dispose", this);
+
+            // reflection to check whether host applet has a call for
+            // public void serverEvent(Server s, Client c);
+            // which is called when a new guy connects
+            try {
+                serverEventMethod
+                        = parent.getClass().getMethod("serverEvent", Server.class, Client.class);
+            } catch (NoSuchMethodException | SecurityException e) {
+                // no such method, or an error.. which is fine, just ignore
+            }
+
+        } catch (IOException e) {
+            //e.printStackTrace();
+            thread = null;
+            throw new RuntimeException(e);
+            //errorMessage("<init>", e);
+        }
+    }
+
+    /**
+     * ( begin auto-generated from Server_disconnect.xml )
+     *
+     * Disconnect a particular client.
+     *
+     * ( end auto-generated )
+     *
+     * @brief Disconnect a particular client.
+     * @webref server:server
+     * @param client the client to disconnect
+     */
+    public void disconnect(Client client) {
+        client.stop();
+        synchronized (clientsLock) {
+            int index = clientIndex(client);
+            if (index != -1) {
+                removeIndex(index);
+            }
+        }
+    }
+
+    protected void removeIndex(int index) {
+        synchronized (clientsLock) {
+            clientCount--;
+            // shift down the remaining clients
+            for (int i = index; i < clientCount; i++) {
+                clients[i] = clients[i + 1];
+            }
+            // mark last empty var for garbage collection
+            clients[clientCount] = null;
+        }
+    }
+
+    protected void disconnectAll() {
+        synchronized (clientsLock) {
+            for (int i = 0; i < clientCount; i++) {
+                try {
+                    clients[i].stop();
+                } catch (Exception e) {
+                    // ignore
+                }
+                clients[i] = null;
+            }
+            clientCount = 0;
+        }
+    }
+
+    protected void addClient(Client client) {
+        synchronized (clientsLock) {
+            if (clientCount == clients.length) {
+                clients = (Client[]) PApplet.expand(clients);
+            }
+            clients[clientCount++] = client;
+        }
+    }
+
+    protected int clientIndex(Client client) {
+        synchronized (clientsLock) {
+            for (int i = 0; i < clientCount; i++) {
+                if (clients[i] == client) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+    }
+
+    /**
+     * ( begin auto-generated from Server_active.xml )
+     *
+     * Returns true if this server is still active and hasn't run into any
+     * trouble.( end auto-generated )
+     *
+     *
+     * @return
+     * @webref server:server
+     * @brief Return true if this server is still active.
+     */
+    public boolean active() {
+        return thread != null;
+    }
+
+    static public String ip() {
+        try {
+            return InetAddress.getLocalHost().getHostAddress();
+        } catch (UnknownHostException e) {
+            return null;
+        }
+    }
+
+    // the last index used for available. can't just cycle through
+    // the clients in order from 0 each time, because if client 0 won't
+    // shut up, then the rest of the clients will never be heard from.
+    int lastAvailable = -1;
+
+    /**
+     * ( begin auto-generated from Server_available.xml )
+     *
+     * Returns the next client in line with a new message.( end auto-generated )
+     *
+     *
+     * @return
+     * @brief Returns the next client in line with a new message.
+     * @webref server
+     * @usage application
+     */
+    public Client available() {
+        synchronized (clientsLock) {
+            int index = lastAvailable + 1;
+            if (index >= clientCount) {
+                index = 0;
+            }
+
+            for (int i = 0; i < clientCount; i++) {
+                int which = (index + i) % clientCount;
+                Client client = clients[which];
+                //Check for valid client
+                if (!client.active()) {
+                    removeIndex(which);  //Remove dead client
+                    i--;                 //Don't skip the next client
+                    //If the client has data make sure lastAvailable
+                    //doesn't end up skipping the next client
+                    which--;
+                    //fall through to allow data from dead clients
+                    //to be retreived.
+                }
+                if (client.available() > 0) {
+                    lastAvailable = which;
+                    return client;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * ( begin auto-generated from Server_stop.xml )
+     *
+     * Disconnects all clients and stops the server.
+     *
+     * ( end auto-generated )
+     * <h3>Advanced</h3>
+     * Use this to shut down the server if you finish using it while your applet
+     * is still running. Otherwise, it will be automatically be shut down by the
+     * host PApplet using dispose(), which is identical.
+     *
+     * @brief Disconnects all clients and stops the server.
+     * @webref server
+     * @usage application
+     */
+    public void stop() {
+        dispose();
+    }
+
+    /**
+     * Disconnect all clients and stop the server: internal use only.
+     */
+    public void dispose() {
+        thread = null;
+
+        if (clients != null) {
+            disconnectAll();
+            clientCount = 0;
+            clients = null;
+        }
+
+        try {
+            if (server != null) {
+                server.close();
+                server = null;
+            }
+        } catch (IOException e) {
+        }
+    }
+
+    @Override
+    public void run() {
+        while (Thread.currentThread() == thread) {
+            try {
+                Socket socket = server.accept();
+                Client client = new Client(parent, socket);
+                synchronized (clientsLock) {
+                    addClient(client);
+                    if (serverEventMethod != null) {
+                        try {
+                            serverEventMethod.invoke(parent, this, client);
+                        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+                            System.err.println("Disabling serverEvent() for port " + port);
+                            Throwable cause = e;
+                            // unwrap the exception if it came from the user code
+                            if (e instanceof InvocationTargetException && e.getCause() != null) {
+                                cause = e.getCause();
+                            }
+                            serverEventMethod = null;
+                        }
+                    }
+                }
+            } catch (SocketException e) {
+                //thrown when server.close() is called and server is waiting on accept
+                System.err.println("Server SocketException: " + e.getMessage());
+                thread = null;
+            } catch (IOException e) {
+              //errorMessage("run", e);
+                thread = null;
+            }
+        }
+    }
+
+    /**
+     * ( begin auto-generated from Server_write.xml )
+     *
+     * Writes a value to all the connected clients. It sends bytes out from the
+     * Server object.
+     *
+     * ( end auto-generated )
+     *
+     * @webref server
+     * @brief Writes data to all connected clients
+     * @param data data to write
+     */
+    public void write(int data) {  // will also cover char
+        synchronized (clientsLock) {
+            int index = 0;
+            while (index < clientCount) {
+                if (clients[index].active()) {
+                    clients[index].write(data);
+                    index++;
+                } else {
+                    removeIndex(index);
+                }
+            }
+        }
+    }
+
+    public void write(byte data[]) {
+        synchronized (clientsLock) {
+            int index = 0;
+            while (index < clientCount) {
+                if (clients[index].active()) {
+                    clients[index].write(data);
+                    index++;
+                } else {
+                    removeIndex(index);
+                }
+            }
+        }
+    }
+
+    public void write(String data) {
+        synchronized (clientsLock) {
+            int index = 0;
+            while (index < clientCount) {
+                if (clients[index].active()) {
+                    clients[index].write(data);
+                    index++;
+                } else {
+                    removeIndex(index);
+                }
+            }
+        }
+    }
+}

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

@@ -78,260 +78,260 @@ import processing.event.MouseEvent;
  */
 public class PSurfaceJOGL implements PSurface {
 
-  /**
-   * Selected GL profile
-   */
-  public static GLProfile profile;
-
-  /**
-   *
-   */
-  public PJOGL pgl;
-
-  /**
-   *
-   */
-  protected GLWindow window;
-
-  /**
-   *
-   */
-  protected FPSAnimator animator;
-
-  /**
-   *
-   */
-  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;
-  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) {
-    this.graphics = graphics;
-    this.pgl = (PJOGL) ((PGraphicsOpenGL) graphics).pgl;
-  }
-
-  @Override
-  public void initOffscreen(PApplet sketch) {
-    this.sketch = sketch;
-
-    sketchWidth = sketch.sketchWidth();
-    sketchHeight = sketch.sketchHeight();
-
-    if (window != null) {
-      canvas = new NewtCanvasAWT(window);
-      canvas.setBounds(0, 0, window.getWidth(), window.getHeight());
-      canvas.setFocusable(true);
+    /**
+     * Selected GL profile
+     */
+    public static GLProfile profile;
+
+    /**
+     *
+     */
+    public PJOGL pgl;
+
+    /**
+     *
+     */
+    protected GLWindow window;
+
+    /**
+     *
+     */
+    protected FPSAnimator animator;
+
+    /**
+     *
+     */
+    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;
+    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) {
+        this.graphics = graphics;
+        this.pgl = (PJOGL) ((PGraphicsOpenGL) graphics).pgl;
     }
-  }
-
-  @Override
-  public void initFrame(PApplet sketch) {
-    this.sketch = sketch;
-    initIcons();
-    initDisplay();
-    initGL();
-    initWindow();
-    initListeners();
-    initAnimator();
-  }
-
-  @Override
-  public Object getNative() {
-    return window;
-  }
-
-  /**
-   *
-   */
-  protected void initDisplay() {
-    display = NewtFactory.createDisplay(null);
-    display.addReference();
-    screen = NewtFactory.createScreen(display, 0);
-    screen.addReference();
-
-    GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
-    GraphicsDevice[] awtDevices = environment.getScreenDevices();
-
-    GraphicsDevice awtDisplayDevice = null;
-    int displayNum = sketch.sketchDisplay();
-    if (displayNum > 0) {  // if -1, use the default device
-      if (displayNum <= awtDevices.length) {
-        awtDisplayDevice = awtDevices[displayNum - 1];
-      } else {
-        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]);
+
+    @Override
+    public void initOffscreen(PApplet sketch) {
+        this.sketch = sketch;
+
+        sketchWidth = sketch.sketchWidth();
+        sketchHeight = sketch.sketchHeight();
+
+        if (window != null) {
+            canvas = new NewtCanvasAWT(window);
+            canvas.setBounds(0, 0, window.getWidth(), window.getHeight());
+            canvas.setFocusable(true);
         }
-      }
-    } else if (0 < awtDevices.length) {
-      awtDisplayDevice = awtDevices[0];
     }
 
-    if (awtDisplayDevice == null) {
-      awtDisplayDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
+    @Override
+    public void initFrame(PApplet sketch) {
+        this.sketch = sketch;
+        initIcons();
+        initDisplay();
+        initGL();
+        initWindow();
+        initListeners();
+        initAnimator();
     }
 
-    displayRect = awtDisplayDevice.getDefaultConfiguration().getBounds();
-  }
+    @Override
+    public Object getNative() {
+        return window;
+    }
 
-  /**
-   *
-   */
-  protected void initGL() {
-//  System.out.println("*******************************");
-    if (profile == null) {
-      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;
-              }
+    /**
+     *
+     */
+    protected void initDisplay() {
+        display = NewtFactory.createDisplay(null);
+        display.addReference();
+        screen = NewtFactory.createScreen(display, 0);
+        screen.addReference();
+
+        GraphicsEnvironment environment = GraphicsEnvironment.getLocalGraphicsEnvironment();
+        GraphicsDevice[] awtDevices = environment.getScreenDevices();
+
+        GraphicsDevice awtDisplayDevice = null;
+        int displayNum = sketch.sketchDisplay();
+        if (displayNum > 0) {  // if -1, use the default device
+            if (displayNum <= awtDevices.length) {
+                awtDisplayDevice = awtDevices[displayNum - 1];
+            } else {
+                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]);
+                }
             }
+        } else if (0 < awtDevices.length) {
+            awtDisplayDevice = awtDevices[0];
+        }
 
-          } 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);
-      }
+        if (awtDisplayDevice == null) {
+            awtDisplayDevice = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
+        }
+
+        displayRect = awtDisplayDevice.getDefaultConfiguration().getBounds();
     }
 
-    // Setting up the desired capabilities;
-    GLCapabilities caps = new GLCapabilities(profile);
-    caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);
-    caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);
-    caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);
+    /**
+     *
+     */
+    protected void initGL() {
+//  System.out.println("*******************************");
+        if (profile == null) {
+            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;
+                            }
+                        }
+
+                    } 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;
+        GLCapabilities caps = new GLCapabilities(profile);
+        caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);
+        caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);
+        caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);
 
 //  caps.setPBuffer(false);
 //  caps.setFBO(false);
 //    pgl.reqNumSamples = PGL.smoothToSamples(graphics.smooth);
-    caps.setSampleBuffers(true);
-    caps.setNumSamples(PGL.smoothToSamples(graphics.smooth));
-    caps.setBackgroundOpaque(true);
-    caps.setOnscreen(true);
-    pgl.setCaps(caps);
-  }
-
-  /**
-   *
-   */
-  protected void initWindow() {
-    window = GLWindow.create(screen, pgl.getCaps());
-
-    // Make sure that we pass the window close through to exit(), otherwise
-    // we're likely to have OpenGL try to shut down halfway through rendering
-    // a frame. Particularly problematic for complex/slow apps.
-    // https://github.com/processing/processing/issues/4690
-    window.setDefaultCloseOperation(WindowClosingProtocol.WindowClosingMode.DO_NOTHING_ON_CLOSE);
+        caps.setSampleBuffers(true);
+        caps.setNumSamples(PGL.smoothToSamples(graphics.smooth));
+        caps.setBackgroundOpaque(true);
+        caps.setOnscreen(true);
+        pgl.setCaps(caps);
+    }
+
+    /**
+     *
+     */
+    protected void initWindow() {
+        window = GLWindow.create(screen, pgl.getCaps());
+
+        // Make sure that we pass the window close through to exit(), otherwise
+        // we're likely to have OpenGL try to shut down halfway through rendering
+        // a frame. Particularly problematic for complex/slow apps.
+        // https://github.com/processing/processing/issues/4690
+        window.setDefaultCloseOperation(WindowClosingProtocol.WindowClosingMode.DO_NOTHING_ON_CLOSE);
 
 //    if (displayDevice == null) {
 //
@@ -339,25 +339,24 @@ public class PSurfaceJOGL implements PSurface {
 //    } else {
 //      window = GLWindow.create(displayDevice.getScreen(), pgl.getCaps());
 //    }
-    windowScaleFactor = PApplet.platform == PConstants.MACOSX
-      ? 1 : sketch.pixelDensity;
+        windowScaleFactor = 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());
+        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());
 
-    // Set the displayWidth/Height variables inside PApplet, so that they're
-    // usable and can even be returned by the sketchWidth()/Height() methods.
-    sketch.displayWidth = screenRect.width;
-    sketch.displayHeight = screenRect.height;
+        // Set the displayWidth/Height variables inside PApplet, so that they're
+        // usable and can even be returned by the sketchWidth()/Height() methods.
+        sketch.displayWidth = screenRect.width;
+        sketch.displayHeight = screenRect.height;
 
-    sketchWidth0 = sketch.sketchWidth();
-    sketchHeight0 = sketch.sketchHeight();
+        sketchWidth0 = sketch.sketchWidth();
+        sketchHeight0 = sketch.sketchHeight();
 
-    /*
+        /*
     // Trying to fix
     // https://github.com/processing/processing/issues/3401
     if (sketch.displayWidth < sketch.width ||
@@ -374,17 +373,17 @@ 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();
+         */
+        sketchWidth = sketch.sketchWidth();
+        sketchHeight = sketch.sketchHeight();
 //    System.out.println("init: " + sketchWidth + " " + sketchHeight);
 
-    boolean fullScreen = sketch.sketchFullScreen();
-    // Removing the section below because sometimes people want to do the
-    // full screen size in a window, and it also breaks insideSettings().
-    // With 3.x, fullScreen() is so easy, that it's just better that way.
-    // https://github.com/processing/processing/issues/3545
-    /*
+        boolean fullScreen = sketch.sketchFullScreen();
+        // Removing the section below because sometimes people want to do the
+        // full screen size in a window, and it also breaks insideSettings().
+        // With 3.x, fullScreen() is so easy, that it's just better that way.
+        // https://github.com/processing/processing/issues/3545
+        /*
     // Sketch has already requested to be the same as the screen's
     // width and height, so let's roll with full screen mode.
     if (screenRect.width == sketchWidth &&
@@ -392,326 +391,319 @@ public class PSurfaceJOGL implements PSurface {
       fullScreen = true;
       sketch.fullScreen();
     }
-     */
+         */
 
-    if (fullScreen || spanDisplays) {
-      sketchWidth = screenRect.width / windowScaleFactor;
-      sketchHeight = screenRect.height / windowScaleFactor;
-    }
+        if (fullScreen || spanDisplays) {
+            sketchWidth = screenRect.width / windowScaleFactor;
+            sketchHeight = screenRect.height / windowScaleFactor;
+        }
 
-    sketch.setSize(sketchWidth, sketchHeight);
-
-    float[] reqSurfacePixelScale;
-    if (graphics.is2X() && PApplet.platform == PConstants.MACOSX) {
-      // Retina
-      reqSurfacePixelScale = new float[]{ScalableSurface.AUTOMAX_PIXELSCALE,
-        ScalableSurface.AUTOMAX_PIXELSCALE};
-    } else {
-      // Non-retina
-      reqSurfacePixelScale = new float[]{ScalableSurface.IDENTITY_PIXELSCALE,
-        ScalableSurface.IDENTITY_PIXELSCALE};
+        sketch.setSize(sketchWidth, sketchHeight);
+
+        float[] reqSurfacePixelScale = new float[]{
+            ScalableSurface.IDENTITY_PIXELSCALE,
+            ScalableSurface.IDENTITY_PIXELSCALE};
+        window.setSurfaceScale(reqSurfacePixelScale);
+        window.setSize(sketchWidth * windowScaleFactor, sketchHeight * windowScaleFactor);
+        window.setResizable(false);
+        setSize(sketchWidth, sketchHeight);
+        if (fullScreen) {
+            //PApplet.hideMenuBar();
+            if (spanDisplays) {
+                window.setFullscreen(screen.getMonitorDevices());
+            } else {
+                window.setUndecorated(true);
+                window.setTopLevelPosition((int) displayRect.getX(), (int) displayRect.getY());
+                window.setTopLevelSize((int) displayRect.getWidth(), (int) displayRect.getHeight());
+            }
+        }
     }
-    window.setSurfaceScale(reqSurfacePixelScale);
-    window.setSize(sketchWidth * windowScaleFactor, sketchHeight * windowScaleFactor);
-    window.setResizable(false);
-    setSize(sketchWidth, sketchHeight);
-    if (fullScreen) {
-      PApplet.hideMenuBar();
-      if (spanDisplays) {
-        window.setFullscreen(screen.getMonitorDevices());
-      } else {
-        window.setUndecorated(true);
-        window.setTopLevelPosition((int) displayRect.getX(), (int) displayRect.getY());
-        window.setTopLevelSize((int) displayRect.getWidth(), (int) displayRect.getHeight());
-      }
+
+    /**
+     *
+     */
+    protected void initListeners() {
+        NEWTMouseListener mouseListener = new NEWTMouseListener();
+        window.addMouseListener(mouseListener);
+        NEWTKeyListener keyListener = new NEWTKeyListener();
+        window.addKeyListener(keyListener);
+        NEWTWindowListener winListener = new NEWTWindowListener();
+        window.addWindowListener(winListener);
+
+        DrawListener drawlistener = new DrawListener();
+        window.addGLEventListener(drawlistener);
     }
-  }
-
-  /**
-   *
-   */
-  protected void initListeners() {
-    NEWTMouseListener mouseListener = new NEWTMouseListener();
-    window.addMouseListener(mouseListener);
-    NEWTKeyListener keyListener = new NEWTKeyListener();
-    window.addKeyListener(keyListener);
-    NEWTWindowListener winListener = new NEWTWindowListener();
-    window.addWindowListener(winListener);
-
-    DrawListener drawlistener = new DrawListener();
-    window.addGLEventListener(drawlistener);
-  }
-
-  /**
-   *
-   */
-  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.
-      // See section "Clocks and Timers on Windows":
-      //   https://blogs.oracle.com/dholmes/entry/inside_the_hotspot_vm_clocks
-      Thread highResTimerThread = new Thread(() -> {
-        try {
-          Thread.sleep(Long.MAX_VALUE);
-        } catch (InterruptedException ignore) {
+
+    /**
+     *
+     */
+    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.
+            // See section "Clocks and Timers on Windows":
+            //   https://blogs.oracle.com/dholmes/entry/inside_the_hotspot_vm_clocks
+            Thread highResTimerThread = new Thread(() -> {
+                try {
+                    Thread.sleep(Long.MAX_VALUE);
+                } catch (InterruptedException ignore) {
+                }
+            }, "HighResTimerThread");
+            highResTimerThread.setDaemon(true);
+            highResTimerThread.start();
         }
-      }, "HighResTimerThread");
-      highResTimerThread.setDaemon(true);
-      highResTimerThread.start();
-    }
 
-    animator = new FPSAnimator(window, 60);
-    drawException = null;
-    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 {
-            while (drawException == null) {
-              drawExceptionMutex.wait();
+        animator = new FPSAnimator(window, 60);
+        drawException = null;
+        animator.setUncaughtExceptionHandler((final GLAnimatorControl animator1, final GLAutoDrawable drawable, final Throwable cause) -> {
+            synchronized (drawExceptionMutex) {
+                drawException = cause;
+                drawExceptionMutex.notify();
             }
-            // System.err.println("Caught exception: " + drawException.getMessage());
-            if (drawException != null) {
-              Throwable cause = drawException.getCause();
-              if (cause instanceof ThreadDeath) {
-                // System.out.println("caught ThreadDeath");
-                // throw (ThreadDeath)cause;
-              } else if (cause instanceof RuntimeException) {
-                throw (RuntimeException) cause;
-              } else if (cause instanceof UnsatisfiedLinkError) {
-                throw new UnsatisfiedLinkError(cause.getMessage());
-              } else if (cause == null) {
-                throw new RuntimeException(drawException.getMessage());
-              } else {
-                throw new RuntimeException(cause);
-              }
+        });
+
+        drawExceptionHandler = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                synchronized (drawExceptionMutex) {
+                    try {
+                        while (drawException == null) {
+                            drawExceptionMutex.wait();
+                        }
+                        // System.err.println("Caught exception: " + drawException.getMessage());
+                        if (drawException != null) {
+                            Throwable cause = drawException.getCause();
+                            if (cause instanceof ThreadDeath) {
+                                // System.out.println("caught ThreadDeath");
+                                // throw (ThreadDeath)cause;
+                            } else if (cause instanceof RuntimeException) {
+                                throw (RuntimeException) cause;
+                            } else if (cause instanceof UnsatisfiedLinkError) {
+                                throw new UnsatisfiedLinkError(cause.getMessage());
+                            } else if (cause == null) {
+                                throw new RuntimeException(drawException.getMessage());
+                            } else {
+                                throw new RuntimeException(cause);
+                            }
+                        }
+                    } catch (InterruptedException e) {
+                    }
+                }
             }
-          } catch (InterruptedException e) {
-          }
-        }
-      }
-    });
-    drawExceptionHandler.start();
-  }
-
-  @Override
-  public void setTitle(final String title) {
-    display.getEDTUtil().invoke(false, () -> {
-      window.setTitle(title);
-    });
-  }
-
-  @Override
-  public void setVisible(final boolean visible) {
-    display.getEDTUtil().invoke(false, () -> {
-      window.setVisible(visible);
-    });
-  }
-
-  @Override
-  public void setResizable(final boolean 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).");
-  }
-
-  @Override
-  public void setAlwaysOnTop(final boolean always) {
-    display.getEDTUtil().invoke(false, () -> {
-      window.setAlwaysOnTop(always);
-    });
-  }
-
-  /**
-   *
-   */
-  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};
-      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);
-    } else {
-      // Loading custom icons from user-provided files.
-      String[] iconImages = new String[PJOGL.icons.length];
-      for (int i = 0; i < PJOGL.icons.length; i++) {
-        iconImages[i] = resourceFilename(PJOGL.icons[i]);
-      }
+        });
+        drawExceptionHandler.start();
+    }
 
-      res = new ClassResources(iconImages,
-        sketch.getClass().getClassLoader(),
-        sketch.getClass());
+    @Override
+    public void setTitle(final String title) {
+        display.getEDTUtil().invoke(false, () -> {
+            window.setTitle(title);
+        });
     }
-    NewtFactory.setWindowIcons(res);
-  }
-
-  @SuppressWarnings("resource")
-  private String resourceFilename(String filename) {
-    // The code below comes from PApplet.createInputRaw() with a few adaptations
-    InputStream stream = null;
-    try {
-      // First see if it's in a data folder. This may fail by throwing
-      // a SecurityException. If so, this whole block will be skipped.
-      File file = new File(sketch.dataPath(filename));
-      if (!file.exists()) {
-        // next see if it's just in the sketch folder
-        file = sketch.sketchFile(filename);
-      }
 
-      if (file.exists() && !file.isDirectory()) {
-        try {
-          // handle case sensitivity check
-          String filePath = file.getCanonicalPath();
-          String filenameActual = new File(filePath).getName();
-          // make sure there isn't a subfolder prepended to the name
-          String filenameShort = new File(filename).getName();
-          // if the actual filename is the same, but capitalized
-          // differently, warn the user.
-          //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.");
-          }
-        } catch (IOException e) {
-        }
-      }
+    @Override
+    public void setVisible(final boolean visible) {
+        display.getEDTUtil().invoke(false, () -> {
+            window.setVisible(visible);
+        });
+    }
 
-      stream = new FileInputStream(file);
-      if (stream != null) {
-        stream.close();
-        return file.getCanonicalPath();
-      }
+    @Override
+    public void setResizable(final boolean resizable) {
+        display.getEDTUtil().invoke(false, () -> {
+            window.setResizable(resizable);
+        });
+    }
 
-      // have to break these out because a general Exception might
-      // catch the RuntimeException being thrown above
-    } catch (IOException | SecurityException ioe) {
+    @Override
+    public void setIcon(PImage icon) {
+        PGraphics.showWarning("Window icons for OpenGL sketches can only be set in settings()\n"
+                + "using PJOGL.setIcon(filename).");
     }
 
-    ClassLoader cl = sketch.getClass().getClassLoader();
-
-    try {
-      // by default, data files are exported to the root path of the jar.
-      // (not the data folder) so check there first.
-      stream = cl.getResourceAsStream("data/" + filename);
-      if (stream != null) {
-        String cn = stream.getClass().getName();
-        // this is an irritation of sun's java plug-in, which will return
-        // a non-null stream for an object that doesn't exist. like all good
-        // things, this is probably introduced in java 1.5. awesome!
-        // http://dev.processing.org/bugs/show_bug.cgi?id=359
-        if (!cn.equals("sun.plugin.cache.EmptyInputStream")) {
-          stream.close();
-          return "data/" + filename;
-        }
-      }
+    @Override
+    public void setAlwaysOnTop(final boolean always) {
+        display.getEDTUtil().invoke(false, () -> {
+            window.setAlwaysOnTop(always);
+        });
+    }
+
+    /**
+     *
+     */
+    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};
+            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);
+        } else {
+            // Loading custom icons from user-provided files.
+            String[] iconImages = new String[PJOGL.icons.length];
+            for (int i = 0; i < PJOGL.icons.length; i++) {
+                iconImages[i] = resourceFilename(PJOGL.icons[i]);
+            }
 
-      // When used with an online script, also need to check without the
-      // data folder, in case it's not in a subfolder called 'data'.
-      // http://dev.processing.org/bugs/show_bug.cgi?id=389
-      stream = cl.getResourceAsStream(filename);
-      if (stream != null) {
-        String cn = stream.getClass().getName();
-        if (!cn.equals("sun.plugin.cache.EmptyInputStream")) {
-          stream.close();
-          return filename;
+            res = new ClassResources(iconImages,
+                    sketch.getClass().getClassLoader(),
+                    sketch.getClass());
         }
-      }
-    } catch (IOException e) {
+        NewtFactory.setWindowIcons(res);
     }
 
-    try {
-      // attempt to load from a local file, used when running as
-      // an application, or as a signed applet
-      try {  // first try to catch any security exceptions
+    @SuppressWarnings("resource")
+    private String resourceFilename(String filename) {
+        // The code below comes from PApplet.createInputRaw() with a few adaptations
+        InputStream stream = null;
         try {
-          String path = sketch.dataPath(filename);
-          stream = new FileInputStream(path);
-          if (stream != null) {
-            stream.close();
-            return path;
-          }
-        } catch (IOException e2) {
+            // First see if it's in a data folder. This may fail by throwing
+            // a SecurityException. If so, this whole block will be skipped.
+            File file = new File(sketch.dataPath(filename));
+            if (!file.exists()) {
+                // next see if it's just in the sketch folder
+                file = sketch.sketchFile(filename);
+            }
+
+            if (file.exists() && !file.isDirectory()) {
+                try {
+                    // handle case sensitivity check
+                    String filePath = file.getCanonicalPath();
+                    String filenameActual = new File(filePath).getName();
+                    // make sure there isn't a subfolder prepended to the name
+                    String filenameShort = new File(filename).getName();
+                    // if the actual filename is the same, but capitalized
+                    // differently, warn the user.
+                    //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.");
+                    }
+                } catch (IOException e) {
+                }
+            }
+
+            stream = new FileInputStream(file);
+            if (stream != null) {
+                stream.close();
+                return file.getCanonicalPath();
+            }
+
+            // have to break these out because a general Exception might
+            // catch the RuntimeException being thrown above
+        } catch (IOException | SecurityException ioe) {
         }
 
+        ClassLoader cl = sketch.getClass().getClassLoader();
+
         try {
-          String path = sketch.sketchPath(filename);
-          stream = new FileInputStream(path);
-          if (stream != null) {
-            stream.close();
-            return path;
-          }
+            // by default, data files are exported to the root path of the jar.
+            // (not the data folder) so check there first.
+            stream = cl.getResourceAsStream("data/" + filename);
+            if (stream != null) {
+                String cn = stream.getClass().getName();
+                // this is an irritation of sun's java plug-in, which will return
+                // a non-null stream for an object that doesn't exist. like all good
+                // things, this is probably introduced in java 1.5. awesome!
+                // http://dev.processing.org/bugs/show_bug.cgi?id=359
+                if (!cn.equals("sun.plugin.cache.EmptyInputStream")) {
+                    stream.close();
+                    return "data/" + filename;
+                }
+            }
+
+            // When used with an online script, also need to check without the
+            // data folder, in case it's not in a subfolder called 'data'.
+            // http://dev.processing.org/bugs/show_bug.cgi?id=389
+            stream = cl.getResourceAsStream(filename);
+            if (stream != null) {
+                String cn = stream.getClass().getName();
+                if (!cn.equals("sun.plugin.cache.EmptyInputStream")) {
+                    stream.close();
+                    return filename;
+                }
+            }
         } catch (IOException e) {
-        }  // ignored
+        }
 
         try {
-          stream = new FileInputStream(filename);
-          if (stream != null) {
-            stream.close();
-            return filename;
-          }
-        } catch (IOException e1) {
+            // attempt to load from a local file, used when running as
+            // an application, or as a signed applet
+            try {  // first try to catch any security exceptions
+                try {
+                    String path = sketch.dataPath(filename);
+                    stream = new FileInputStream(path);
+                    if (stream != null) {
+                        stream.close();
+                        return path;
+                    }
+                } catch (IOException e2) {
+                }
+
+                try {
+                    String path = sketch.sketchPath(filename);
+                    stream = new FileInputStream(path);
+                    if (stream != null) {
+                        stream.close();
+                        return path;
+                    }
+                } catch (IOException e) {
+                }  // ignored
+
+                try {
+                    stream = new FileInputStream(filename);
+                    if (stream != null) {
+                        stream.close();
+                        return filename;
+                    }
+                } catch (IOException e1) {
+                }
+
+            } catch (SecurityException se) {
+            }  // online, whups
+
+        } catch (Exception e) {
+            //die(e.getMessage(), e);
         }
 
-      } catch (SecurityException se) {
-      }  // online, whups
-
-    } catch (Exception e) {
-      //die(e.getMessage(), e);
+        return "";
     }
 
-    return "";
-  }
-
-  @Override
-  public void placeWindow(int[] location, int[] editorLocation) {
+    @Override
+    public void placeWindow(int[] location, int[] editorLocation) {
 
-    if (sketch.sketchFullScreen()) {
-      return;
-    }
+        if (sketch.sketchFullScreen()) {
+            return;
+        }
 
-    int x = window.getX() - window.getInsets().getLeftWidth();
-    int y = window.getY() - window.getInsets().getTopHeight();
-    int w = window.getWidth() + window.getInsets().getTotalWidth();
-    int h = window.getHeight() + window.getInsets().getTotalHeight();
+        int x = window.getX() - window.getInsets().getLeftWidth();
+        int y = window.getY() - window.getInsets().getTopHeight();
+        int w = window.getWidth() + window.getInsets().getTotalWidth();
+        int h = window.getHeight() + window.getInsets().getTotalHeight();
 
-    if (location != null) {
+        if (location != null) {
 //      System.err.println("place window at " + location[0] + ", " + location[1]);
-      window.setTopLevelPosition(location[0], location[1]);
+            window.setTopLevelPosition(location[0], location[1]);
 
-    } else if (editorLocation != null) {
+        } else if (editorLocation != null) {
 //      System.err.println("place window at editor location " + editorLocation[0] + ", " + editorLocation[1]);
-      int locationX = editorLocation[0] - 20;
-      int locationY = editorLocation[1];
+            int locationX = editorLocation[0] - 20;
+            int locationY = editorLocation[1];
 
-      if (locationX - w > 10) {
-        // if it fits to the left of the window
-        window.setTopLevelPosition(locationX - w, locationY);
+            if (locationX - w > 10) {
+                // if it fits to the left of the window
+                window.setTopLevelPosition(locationX - w, locationY);
 
-      } else {  // doesn't fit
-        /*
+            } else {  // doesn't fit
+                /*
         // if it fits inside the editor window,
         // offset slightly from upper lefthand corner
         // so that it's plunked inside the text area
@@ -721,787 +713,766 @@ 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;
-        /*
+                 */
+                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);
         }
-         */
-        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);
-    }
-
-    Point frameLoc = new Point(x, y);
-    if (frameLoc.y < 0) {
-      // Windows actually allows you to place frames where they can't be
-      // closed. Awesome. http://dev.processing.org/bugs/show_bug.cgi?id=1508
-      window.setTopLevelPosition(frameLoc.x, 30);
-    }
-  }
-
-  @Override
-  public void placePresent(int stopColor) {
-    float scale = getPixelScale();
-    pgl.initPresentMode(0.5f * (screenRect.width / scale - sketchWidth),
-      0.5f * (screenRect.height / scale - sketchHeight), stopColor);
-    PApplet.hideMenuBar();
-
-    window.setUndecorated(true);
-    window.setTopLevelPosition((int) displayRect.getX(), (int) displayRect.getY());
-    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();
-      drawExceptionHandler = null;
-    }
-    if (animator != null) {
-      return animator.stop();
-    } else {
-      return false;
-    }
-  }
-
-  /**
-   *
-   * @return
-   */
-  @Override
-  public boolean isStopped() {
-    if (animator != null) {
-      return !animator.isAnimating();
-    } else {
-      return true;
-    }
-  }
-
-  @Override
-  public void setLocation(final int x, final int y) {
-    display.getEDTUtil().invoke(false, () -> {
-      window.setTopLevelPosition(x, y);
-    });
-  }
-
-  @Override
-  public void setSize(int wide, int high) {
-    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.
-    // https://github.com/processing/processing/issues/5052
-    if (high <= 0) {
-      high = 1;
-    }
-    if (wide <= 0) {
-      wide = 1;
-    }
-
-    boolean changed = sketch.width != wide || sketch.height != high;
-
-    sketchWidth = wide;
-    sketchHeight = high;
-
-    sketch.setSize(wide, high);
-    graphics.setSize(wide, high);
 
-    if (changed) {
-      window.setSize(wide * windowScaleFactor, high * windowScaleFactor);
-    }
-  }
-
-  /**
-   *
-   * @return
-   */
-  public float getPixelScale() {
-    if (graphics.pixelDensity == 1) {
-      return 1;
+        Point frameLoc = new Point(x, y);
+        if (frameLoc.y < 0) {
+            // Windows actually allows you to place frames where they can't be
+            // closed. Awesome. http://dev.processing.org/bugs/show_bug.cgi?id=1508
+            window.setTopLevelPosition(frameLoc.x, 30);
+        }
     }
 
-    if (PApplet.platform == PConstants.MACOSX) {
-      return getCurrentPixelScale();
+    @Override
+    public void placePresent(int stopColor) {
+        float scale = getPixelScale();
+        pgl.initPresentMode(0.5f * (screenRect.width / scale - sketchWidth),
+                0.5f * (screenRect.height / scale - sketchHeight), stopColor);
+        window.setUndecorated(true);
+        window.setTopLevelPosition((int) displayRect.getX(), (int) displayRect.getY());
+        window.setTopLevelSize((int) displayRect.getWidth(), (int) displayRect.getHeight());
     }
 
-    return 2;
-  }
-
-  private float getCurrentPixelScale() {
-    // Even if the graphics are retina, the user might have moved the window
-    // into a non-retina monitor, so we need to check
-    window.getCurrentSurfaceScale(currentPixelScale);
-    return currentPixelScale[0];
-  }
-
-  /**
-   *
-   * @return
-   */
-  public Component getComponent() {
-    return canvas;
-  }
-
-  /**
-   *
-   * @param level
-   */
-  public void setSmooth(int level) {
-    pgl.reqNumSamples = level;
-    GLCapabilities caps = new GLCapabilities(profile);
-    caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);
-    caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);
-    caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);
-    caps.setSampleBuffers(true);
-    caps.setNumSamples(pgl.reqNumSamples);
-    caps.setBackgroundOpaque(true);
-    caps.setOnscreen(true);
-    NativeSurface target = window.getNativeSurface();
-    MutableGraphicsConfiguration config = (MutableGraphicsConfiguration) target.getGraphicsConfiguration();
-    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.");
-      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.");
-      fps = 1000;
-    }
-    if (animator != null) {
-      animator.stop();
-      animator.setFPS((int) fps);
-      pgl.setFps(fps);
-      animator.start();
+    @Override
+    public void setupExternalMessages() {
+        external = true;
     }
-  }
-
-  /**
-   *
-   */
-  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
-        // EDT, skipping rendering Processing's frame in that case.
-        return;
-      }
-
-      if (sketch.frameCount == 0) {
-        if (sketchWidth < sketchWidth0 || sketchHeight < sketchHeight0) {
-          PGraphics.showWarning("The sketch has been automatically resized to fit the screen resolution");
+    public void startThread() {
+        if (animator != null) {
+            animator.start();
         }
-//        System.out.println("display: " + window.getWidth() + " "+ window.getHeight() + " - " + sketchWidth + " " + sketchHeight);
-        requestFocus();
-      }
-
-      if (!sketch.finished) {
-        pgl.getGL(drawable);
-        int pframeCount = sketch.frameCount;
-        sketch.handleDraw();
-        if (pframeCount == sketch.frameCount || sketch.finished) {
-          // This hack allows the FBO layer to be swapped normally even if
-          // the sketch is no looping or finished because it does not call draw(),
-          // otherwise background artifacts may occur (depending on the hardware/drivers).
-          pgl.beginRender();
-          pgl.endRender(sketch.sketchWindowColor());
-        }
-        PGraphicsOpenGL.completeFinishedPixelTransfers();
-      }
-
-      if (sketch.exitCalled()) {
-        PGraphicsOpenGL.completeAllPixelTransfers();
-
-        sketch.dispose(); // calls stopThread(), which stops the animator.
-        sketch.exitActual();
-      }
     }
 
     @Override
-    public void dispose(GLAutoDrawable drawable) {
-//      sketch.dispose();
+    public void pauseThread() {
+        if (animator != null) {
+            animator.pause();
+        }
     }
 
     @Override
-    public void init(GLAutoDrawable drawable) {
-      pgl.getGL(drawable);
-      pgl.init(drawable);
-      sketch.start();
-
-      int c = graphics.backgroundColor;
-      pgl.clearColor(((c >> 16) & 0xff) / 255f,
-        ((c >> 8) & 0xff) / 255f,
-        ((c) & 0xff) / 255f,
-        ((c >> 24) & 0xff) / 255f);
-      pgl.clear(PGL.COLOR_BUFFER_BIT);
+    public void resumeThread() {
+        if (animator != null) {
+            animator.resume();
+        }
     }
 
     @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();
-      setSize((int) (w / scale), (int) (h / scale));
-    }
-  }
-
-  /**
-   *
-   */
-  protected class NEWTWindowListener implements com.jogamp.newt.event.WindowListener {
-
-    /**
-     *
-     */
-    public NEWTWindowListener() {
-      super();
+    public boolean stopThread() {
+        if (drawExceptionHandler != null) {
+            drawExceptionHandler.interrupt();
+            drawExceptionHandler = null;
+        }
+        if (animator != null) {
+            return animator.stop();
+        } else {
+            return false;
+        }
     }
 
     /**
      *
-     * @param arg0
+     * @return
      */
     @Override
-    public void windowGainedFocus(com.jogamp.newt.event.WindowEvent arg0) {
-      sketch.focused = true;
-      sketch.focusGained();
+    public boolean isStopped() {
+        if (animator != null) {
+            return !animator.isAnimating();
+        } else {
+            return true;
+        }
     }
 
-    /**
-     *
-     * @param arg0
-     */
     @Override
-    public void windowLostFocus(com.jogamp.newt.event.WindowEvent arg0) {
-      sketch.focused = false;
-      sketch.focusLost();
+    public void setLocation(final int x, final int y) {
+        display.getEDTUtil().invoke(false, () -> {
+            window.setTopLevelPosition(x, y);
+        });
     }
 
-    /**
-     *
-     * @param arg0
-     */
     @Override
-    public void windowDestroyNotify(com.jogamp.newt.event.WindowEvent arg0) {
-      sketch.exit();
-    }
+    public void setSize(int wide, int high) {
+        if (pgl.presentMode()) {
+            return;
+        }
 
-    /**
-     *
-     * @param arg0
-     */
-    @Override
-    public void windowDestroyed(com.jogamp.newt.event.WindowEvent arg0) {
-      sketch.exit();
-    }
+        // When the surface is set to resizable via surface.setResizable(true),
+        // a crash may occur if the user sets the window to size zero.
+        // https://github.com/processing/processing/issues/5052
+        if (high <= 0) {
+            high = 1;
+        }
+        if (wide <= 0) {
+            wide = 1;
+        }
 
-    /**
-     *
-     * @param arg0
-     */
-    @Override
-    public void windowMoved(com.jogamp.newt.event.WindowEvent arg0) {
-      if (external) {
-        sketch.frameMoved(window.getX(), window.getY());
-      }
-    }
+        boolean changed = sketch.width != wide || sketch.height != high;
 
-    /**
-     *
-     * @param arg0
-     */
-    @Override
-    public void windowRepaint(com.jogamp.newt.event.WindowUpdateEvent arg0) {
+        sketchWidth = wide;
+        sketchHeight = high;
+
+        sketch.setSize(wide, high);
+        graphics.setSize(wide, high);
+
+        if (changed) {
+            window.setSize(wide * windowScaleFactor, high * windowScaleFactor);
+        }
     }
 
     /**
      *
-     * @param arg0
+     * @return
      */
-    @Override
-    public void windowResized(com.jogamp.newt.event.WindowEvent arg0) {
+    public float getPixelScale() {
+        if (graphics.pixelDensity == 1) {
+            return 1;
+        }
+        return 2;
     }
-  }
 
-  // NEWT mouse listener
-  /**
-   *
-   */
-  protected class NEWTMouseListener extends com.jogamp.newt.event.MouseAdapter {
-
-    /**
-     *
-     */
-    public NEWTMouseListener() {
-      super();
+    private float getCurrentPixelScale() {
+        // Even if the graphics are retina, the user might have moved the window
+        // into a non-retina monitor, so we need to check
+        window.getCurrentSurfaceScale(currentPixelScale);
+        return currentPixelScale[0];
     }
 
     /**
      *
-     * @param e
+     * @return
      */
-    @Override
-    public void mousePressed(com.jogamp.newt.event.MouseEvent e) {
-      nativeMouseEvent(e, MouseEvent.PRESS);
+    public Component getComponent() {
+        return canvas;
     }
 
     /**
      *
-     * @param e
+     * @param level
      */
-    @Override
-    public void mouseReleased(com.jogamp.newt.event.MouseEvent e) {
-      nativeMouseEvent(e, MouseEvent.RELEASE);
+    public void setSmooth(int level) {
+        pgl.reqNumSamples = level;
+        GLCapabilities caps = new GLCapabilities(profile);
+        caps.setAlphaBits(PGL.REQUESTED_ALPHA_BITS);
+        caps.setDepthBits(PGL.REQUESTED_DEPTH_BITS);
+        caps.setStencilBits(PGL.REQUESTED_STENCIL_BITS);
+        caps.setSampleBuffers(true);
+        caps.setNumSamples(pgl.reqNumSamples);
+        caps.setBackgroundOpaque(true);
+        caps.setOnscreen(true);
+        NativeSurface target = window.getNativeSurface();
+        MutableGraphicsConfiguration config = (MutableGraphicsConfiguration) target.getGraphicsConfiguration();
+        config.setChosenCapabilities(caps);
     }
 
-    /**
-     *
-     * @param e
-     */
     @Override
-    public void mouseClicked(com.jogamp.newt.event.MouseEvent e) {
-      nativeMouseEvent(e, MouseEvent.CLICK);
+    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.");
+            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.");
+            fps = 1000;
+        }
+        if (animator != null) {
+            animator.stop();
+            animator.setFPS((int) fps);
+            pgl.setFps(fps);
+            animator.start();
+        }
     }
 
     /**
      *
-     * @param e
      */
-    @Override
-    public void mouseDragged(com.jogamp.newt.event.MouseEvent e) {
-      nativeMouseEvent(e, MouseEvent.DRAG);
+    public void requestFocus() {
+        display.getEDTUtil().invoke(false, () -> {
+            window.requestFocus();
+        });
     }
 
-    /**
-     *
-     * @param e
-     */
-    @Override
-    public void mouseMoved(com.jogamp.newt.event.MouseEvent e) {
-      nativeMouseEvent(e, MouseEvent.MOVE);
+    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
+                // EDT, skipping rendering Processing's frame in that case.
+                return;
+            }
+
+            if (sketch.frameCount == 0) {
+                if (sketchWidth < sketchWidth0 || sketchHeight < sketchHeight0) {
+                    PGraphics.showWarning("The sketch has been automatically resized to fit the screen resolution");
+                }
+//        System.out.println("display: " + window.getWidth() + " "+ window.getHeight() + " - " + sketchWidth + " " + sketchHeight);
+                requestFocus();
+            }
+
+            if (!sketch.finished) {
+                pgl.getGL(drawable);
+                int pframeCount = sketch.frameCount;
+                sketch.handleDraw();
+                if (pframeCount == sketch.frameCount || sketch.finished) {
+                    // This hack allows the FBO layer to be swapped normally even if
+                    // the sketch is no looping or finished because it does not call draw(),
+                    // otherwise background artifacts may occur (depending on the hardware/drivers).
+                    pgl.beginRender();
+                    pgl.endRender(sketch.sketchWindowColor());
+                }
+                PGraphicsOpenGL.completeFinishedPixelTransfers();
+            }
+
+            if (sketch.exitCalled()) {
+                PGraphicsOpenGL.completeAllPixelTransfers();
+
+                sketch.dispose(); // calls stopThread(), which stops the animator.
+                sketch.exitActual();
+            }
+        }
+
+        @Override
+        public void dispose(GLAutoDrawable drawable) {
+//      sketch.dispose();
+        }
+
+        @Override
+        public void init(GLAutoDrawable drawable) {
+            pgl.getGL(drawable);
+            pgl.init(drawable);
+            sketch.start();
+
+            int c = graphics.backgroundColor;
+            pgl.clearColor(((c >> 16) & 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 = getPixelScale();
+            setSize((int) (w / scale), (int) (h / scale));
+        }
     }
 
     /**
      *
-     * @param e
      */
-    @Override
-    public void mouseWheelMoved(com.jogamp.newt.event.MouseEvent e) {
-      nativeMouseEvent(e, MouseEvent.WHEEL);
+    protected class NEWTWindowListener implements com.jogamp.newt.event.WindowListener {
+
+        /**
+         *
+         */
+        public NEWTWindowListener() {
+            super();
+        }
+
+        /**
+         *
+         * @param arg0
+         */
+        @Override
+        public void windowGainedFocus(com.jogamp.newt.event.WindowEvent arg0) {
+            sketch.focused = true;
+            sketch.focusGained();
+        }
+
+        /**
+         *
+         * @param arg0
+         */
+        @Override
+        public void windowLostFocus(com.jogamp.newt.event.WindowEvent arg0) {
+            sketch.focused = false;
+            sketch.focusLost();
+        }
+
+        /**
+         *
+         * @param arg0
+         */
+        @Override
+        public void windowDestroyNotify(com.jogamp.newt.event.WindowEvent arg0) {
+            sketch.exit();
+        }
+
+        /**
+         *
+         * @param arg0
+         */
+        @Override
+        public void windowDestroyed(com.jogamp.newt.event.WindowEvent arg0) {
+            sketch.exit();
+        }
+
+        /**
+         *
+         * @param arg0
+         */
+        @Override
+        public void windowMoved(com.jogamp.newt.event.WindowEvent arg0) {
+            if (external) {
+                sketch.frameMoved(window.getX(), window.getY());
+            }
+        }
+
+        /**
+         *
+         * @param arg0
+         */
+        @Override
+        public void windowRepaint(com.jogamp.newt.event.WindowUpdateEvent arg0) {
+        }
+
+        /**
+         *
+         * @param arg0
+         */
+        @Override
+        public void windowResized(com.jogamp.newt.event.WindowEvent arg0) {
+        }
     }
 
+    // NEWT mouse listener
     /**
      *
-     * @param e
      */
-    @Override
-    public void mouseEntered(com.jogamp.newt.event.MouseEvent e) {
+    protected class NEWTMouseListener extends com.jogamp.newt.event.MouseAdapter {
+
+        /**
+         *
+         */
+        public NEWTMouseListener() {
+            super();
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mousePressed(com.jogamp.newt.event.MouseEvent e) {
+            nativeMouseEvent(e, MouseEvent.PRESS);
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mouseReleased(com.jogamp.newt.event.MouseEvent e) {
+            nativeMouseEvent(e, MouseEvent.RELEASE);
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mouseClicked(com.jogamp.newt.event.MouseEvent e) {
+            nativeMouseEvent(e, MouseEvent.CLICK);
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mouseDragged(com.jogamp.newt.event.MouseEvent e) {
+            nativeMouseEvent(e, MouseEvent.DRAG);
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mouseMoved(com.jogamp.newt.event.MouseEvent e) {
+            nativeMouseEvent(e, MouseEvent.MOVE);
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mouseWheelMoved(com.jogamp.newt.event.MouseEvent e) {
+            nativeMouseEvent(e, MouseEvent.WHEEL);
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mouseEntered(com.jogamp.newt.event.MouseEvent e) {
 //      System.out.println("enter");
-      nativeMouseEvent(e, MouseEvent.ENTER);
-    }
+            nativeMouseEvent(e, MouseEvent.ENTER);
+        }
 
-    /**
-     *
-     * @param e
-     */
-    @Override
-    public void mouseExited(com.jogamp.newt.event.MouseEvent e) {
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void mouseExited(com.jogamp.newt.event.MouseEvent e) {
 //      System.out.println("exit");
-      nativeMouseEvent(e, MouseEvent.EXIT);
+            nativeMouseEvent(e, MouseEvent.EXIT);
+        }
     }
-  }
-
-  // NEWT key listener
-  /**
-   *
-   */
-  protected class NEWTKeyListener extends com.jogamp.newt.event.KeyAdapter {
 
+    // NEWT key listener
     /**
      *
      */
-    public NEWTKeyListener() {
-      super();
-    }
+    protected class NEWTKeyListener extends com.jogamp.newt.event.KeyAdapter {
 
-    /**
-     *
-     * @param e
-     */
-    @Override
-    public void keyPressed(com.jogamp.newt.event.KeyEvent e) {
-      nativeKeyEvent(e, KeyEvent.PRESS);
+        /**
+         *
+         */
+        public NEWTKeyListener() {
+            super();
+        }
+
+        /**
+         *
+         * @param e
+         */
+        @Override
+        public void keyPressed(com.jogamp.newt.event.KeyEvent e) {
+            nativeKeyEvent(e, KeyEvent.PRESS);
+        }
+
+        /**
+         *
+         * @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) {
+            nativeKeyEvent(e, KeyEvent.TYPE);
+        }
     }
 
     /**
      *
-     * @param e
+     * @param nativeEvent
+     * @param peAction
      */
-    @Override
-    public void keyReleased(com.jogamp.newt.event.KeyEvent e) {
-      nativeKeyEvent(e, KeyEvent.RELEASE);
+    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 peButton = 0;
+        switch (nativeEvent.getButton()) {
+            case com.jogamp.newt.event.MouseEvent.BUTTON1:
+                peButton = PConstants.LEFT;
+                break;
+            case com.jogamp.newt.event.MouseEvent.BUTTON2:
+                peButton = PConstants.CENTER;
+                break;
+            case com.jogamp.newt.event.MouseEvent.BUTTON3:
+                peButton = PConstants.RIGHT;
+                break;
+        }
+        int peCount = 0;
+        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]);
+        } else {
+            peCount = nativeEvent.getClickCount();
+        }
+
+        int scale = (int) getPixelScale();
+        int sx = nativeEvent.getX() / scale;
+        int sy = nativeEvent.getY() / scale;
+        int mx = sx;
+        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)) {
+                sketch.exit();
+            }
+            if (mx < 0 || sketchWidth < mx || my < 0 || sketchHeight < my) {
+                return;
+            }
+        }
+
+        MouseEvent me = new MouseEvent(nativeEvent, nativeEvent.getWhen(),
+                peAction, peModifiers,
+                mx, my,
+                peButton,
+                peCount);
+
+        sketch.postEvent(me);
     }
 
     /**
      *
-     * @param e
+     * @param nativeEvent
+     * @param peAction
      */
-    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) {
-    int modifiers = nativeEvent.getModifiers();
-    int peModifiers = modifiers
-      & (InputEvent.SHIFT_MASK
-      | InputEvent.CTRL_MASK
-      | InputEvent.META_MASK
-      | InputEvent.ALT_MASK);
-
-    int peButton = 0;
-    switch (nativeEvent.getButton()) {
-      case com.jogamp.newt.event.MouseEvent.BUTTON1:
-        peButton = PConstants.LEFT;
-        break;
-      case com.jogamp.newt.event.MouseEvent.BUTTON2:
-        peButton = PConstants.CENTER;
-        break;
-      case com.jogamp.newt.event.MouseEvent.BUTTON3:
-        peButton = PConstants.RIGHT;
-        break;
-    }
+    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;
+        int keyCode;
+        if (isPCodedKey(code)) {
+            keyCode = mapToPConst(code);
+            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;
+            keyChar = hackToChar(code, nativeEvent.getKeyChar());
+        } else {
+            keyCode = code;
+            keyChar = nativeEvent.getKeyChar();
+        }
 
-    if (PApplet.platform == PConstants.MACOSX) {
-      //if (nativeEvent.isPopupTrigger()) {
-      if ((modifiers & InputEvent.CTRL_MASK) != 0) {
-        peButton = PConstants.RIGHT;
-      }
+        // From http://jogamp.org/deployment/v2.1.0/javadoc/jogl/javadoc/com/jogamp/newt/event/KeyEvent.html
+        // public final short getKeySymbol()
+        // Returns the virtual key symbol reflecting the current keyboard layout.
+        // public final short getKeyCode()
+        // Returns the virtual key code using a fixed mapping to the US keyboard layout.
+        // 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());
+
+        sketch.postEvent(ke);
+
+        if (!isPCodedKey(code) && !isHackyKey(code)) {
+            if (peAction == KeyEvent.PRESS) {
+                // 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());
+
+                sketch.postEvent(tke);
+            }
+        }
     }
 
-    int peCount = 0;
-    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]);
-    } else {
-      peCount = nativeEvent.getClickCount();
+    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;
+    }
+
+    // Why do we need this mapping?
+    // Relevant discussion and links here:
+    // http://forum.jogamp.org/Newt-wrong-keycode-for-key-td4033690.html#a4033697
+    // (I don't think this is a complete solution).
+    private static int mapToPConst(short code) {
+        switch (code) {
+            case com.jogamp.newt.event.KeyEvent.VK_UP:
+                return PConstants.UP;
+            case com.jogamp.newt.event.KeyEvent.VK_DOWN:
+                return PConstants.DOWN;
+            case com.jogamp.newt.event.KeyEvent.VK_LEFT:
+                return PConstants.LEFT;
+            case com.jogamp.newt.event.KeyEvent.VK_RIGHT:
+                return PConstants.RIGHT;
+            case com.jogamp.newt.event.KeyEvent.VK_ALT:
+                return PConstants.ALT;
+            case com.jogamp.newt.event.KeyEvent.VK_CONTROL:
+                return PConstants.CONTROL;
+            case com.jogamp.newt.event.KeyEvent.VK_SHIFT:
+                return PConstants.SHIFT;
+            case com.jogamp.newt.event.KeyEvent.VK_WINDOWS:
+                return java.awt.event.KeyEvent.VK_META;
+            default:
+                return code;
+        }
     }
 
-    int scale;
-    if (PApplet.platform == PConstants.MACOSX) {
-      scale = (int) getCurrentPixelScale();
-    } else {
-      scale = (int) getPixelScale();
-    }
-    int sx = nativeEvent.getX() / scale;
-    int sy = nativeEvent.getY() / scale;
-    int mx = sx;
-    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)) {
-        sketch.exit();
-      }
-      if (mx < 0 || sketchWidth < mx || my < 0 || sketchHeight < my) {
-        return;
-      }
+    private static boolean isHackyKey(short code) {
+        switch (code) {
+            case com.jogamp.newt.event.KeyEvent.VK_BACK_SPACE:
+            case com.jogamp.newt.event.KeyEvent.VK_TAB:
+            case com.jogamp.newt.event.KeyEvent.VK_ENTER:
+            case com.jogamp.newt.event.KeyEvent.VK_ESCAPE:
+            case com.jogamp.newt.event.KeyEvent.VK_DELETE:
+                return true;
+        }
+        return false;
+    }
+
+    private static char hackToChar(short code, char def) {
+        switch (code) {
+            case com.jogamp.newt.event.KeyEvent.VK_BACK_SPACE:
+                return PConstants.BACKSPACE;
+            case com.jogamp.newt.event.KeyEvent.VK_TAB:
+                return PConstants.TAB;
+            case com.jogamp.newt.event.KeyEvent.VK_ENTER:
+                return PConstants.ENTER;
+            case com.jogamp.newt.event.KeyEvent.VK_ESCAPE:
+                return PConstants.ESC;
+            case com.jogamp.newt.event.KeyEvent.VK_DELETE:
+                return PConstants.DELETE;
+        }
+        return def;
     }
 
-    MouseEvent me = new MouseEvent(nativeEvent, nativeEvent.getWhen(),
-      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);
-
-    short code = nativeEvent.getKeyCode();
-    char keyChar;
-    int keyCode;
-    if (isPCodedKey(code)) {
-      keyCode = mapToPConst(code);
-      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;
-      keyChar = hackToChar(code, nativeEvent.getKeyChar());
-    } else {
-      keyCode = code;
-      keyChar = nativeEvent.getKeyChar();
-    }
+    // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+    class CursorInfo {
 
-    // From http://jogamp.org/deployment/v2.1.0/javadoc/jogl/javadoc/com/jogamp/newt/event/KeyEvent.html
-    // public final short getKeySymbol()
-    // Returns the virtual key symbol reflecting the current keyboard layout.
-    // public final short getKeyCode()
-    // Returns the virtual key code using a fixed mapping to the US keyboard layout.
-    // 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());
-
-    sketch.postEvent(ke);
-
-    if (!isPCodedKey(code) && !isHackyKey(code)) {
-      if (peAction == KeyEvent.PRESS) {
-        // 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());
-
-        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;
-  }
-
-  // Why do we need this mapping?
-  // Relevant discussion and links here:
-  // http://forum.jogamp.org/Newt-wrong-keycode-for-key-td4033690.html#a4033697
-  // (I don't think this is a complete solution).
-  private static int mapToPConst(short code) {
-    switch (code) {
-      case com.jogamp.newt.event.KeyEvent.VK_UP:
-        return PConstants.UP;
-      case com.jogamp.newt.event.KeyEvent.VK_DOWN:
-        return PConstants.DOWN;
-      case com.jogamp.newt.event.KeyEvent.VK_LEFT:
-        return PConstants.LEFT;
-      case com.jogamp.newt.event.KeyEvent.VK_RIGHT:
-        return PConstants.RIGHT;
-      case com.jogamp.newt.event.KeyEvent.VK_ALT:
-        return PConstants.ALT;
-      case com.jogamp.newt.event.KeyEvent.VK_CONTROL:
-        return PConstants.CONTROL;
-      case com.jogamp.newt.event.KeyEvent.VK_SHIFT:
-        return PConstants.SHIFT;
-      case com.jogamp.newt.event.KeyEvent.VK_WINDOWS:
-        return java.awt.event.KeyEvent.VK_META;
-      default:
-        return code;
-    }
-  }
-
-  private static boolean isHackyKey(short code) {
-    switch (code) {
-      case com.jogamp.newt.event.KeyEvent.VK_BACK_SPACE:
-      case com.jogamp.newt.event.KeyEvent.VK_TAB:
-      case com.jogamp.newt.event.KeyEvent.VK_ENTER:
-      case com.jogamp.newt.event.KeyEvent.VK_ESCAPE:
-      case com.jogamp.newt.event.KeyEvent.VK_DELETE:
-        return true;
-    }
-    return false;
-  }
-
-  private static char hackToChar(short code, char def) {
-    switch (code) {
-      case com.jogamp.newt.event.KeyEvent.VK_BACK_SPACE:
-        return PConstants.BACKSPACE;
-      case com.jogamp.newt.event.KeyEvent.VK_TAB:
-        return PConstants.TAB;
-      case com.jogamp.newt.event.KeyEvent.VK_ENTER:
-        return PConstants.ENTER;
-      case com.jogamp.newt.event.KeyEvent.VK_ESCAPE:
-        return PConstants.ESC;
-      case com.jogamp.newt.event.KeyEvent.VK_DELETE:
-        return PConstants.DELETE;
-    }
-    return def;
-  }
+        PImage image;
+        int x, y;
 
-  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
-  class CursorInfo {
+        CursorInfo(PImage image, int x, int y) {
+            this.image = image;
+            this.x = x;
+            this.y = y;
+        }
+
+        void set() {
+            setCursor(image, x, y);
+        }
+    }
 
-    PImage image;
-    int x, y;
+    static Map<Integer, CursorInfo> cursors = new HashMap<>();
+    static Map<Integer, String> cursorNames = new HashMap<>();
 
-    CursorInfo(PImage image, int x, int y) {
-      this.image = image;
-      this.x = x;
-      this.y = y;
+    static {
+        cursorNames.put(PConstants.ARROW, "arrow");
+        cursorNames.put(PConstants.CROSS, "cross");
+        cursorNames.put(PConstants.WAIT, "wait");
+        cursorNames.put(PConstants.MOVE, "move");
+        cursorNames.put(PConstants.HAND, "hand");
+        cursorNames.put(PConstants.TEXT, "text");
     }
 
-    void set() {
-      setCursor(image, x, y);
+    @Override
+    public void setCursor(int kind) {
+        if (!cursorNames.containsKey(kind)) {
+            PGraphics.showWarning("Unknown cursor type: " + kind);
+            return;
+        }
+        CursorInfo cursor = cursors.get(kind);
+        if (cursor == null) {
+            String name = cursorNames.get(kind);
+            if (name != null) {
+                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
+                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);
+            }
+        }
+        if (cursor != null) {
+            cursor.set();
+        } else {
+            PGraphics.showWarning("Cannot load cursor type: " + kind);
+        }
     }
-  }
-
-  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");
-    cursorNames.put(PConstants.WAIT, "wait");
-    cursorNames.put(PConstants.MOVE, "move");
-    cursorNames.put(PConstants.HAND, "hand");
-    cursorNames.put(PConstants.TEXT, "text");
-  }
-
-  @Override
-  public void setCursor(int kind) {
-    if (!cursorNames.containsKey(kind)) {
-      PGraphics.showWarning("Unknown cursor type: " + kind);
-      return;
+
+    @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();
+        int[] ipix = dbuf.getData();
+        ByteBuffer pixels = ByteBuffer.allocate(ipix.length * 4);
+        pixels.asIntBuffer().put(ipix);
+        PixelFormat format = PixelFormat.ARGB8888;
+        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, () -> {
+            window.setPointerVisible(true);
+            window.setPointerIcon(pi);
+        });
     }
-    CursorInfo cursor = cursors.get(kind);
-    if (cursor == null) {
-      String name = cursorNames.get(kind);
-      if (name != null) {
-        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
-        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);
-      }
+
+    @Override
+    public void showCursor() {
+        display.getEDTUtil().invoke(false, () -> {
+            window.setPointerVisible(true);
+        });
     }
-    if (cursor != null) {
-      cursor.set();
-    } else {
-      PGraphics.showWarning("Cannot load cursor type: " + kind);
+
+    @Override
+    public void hideCursor() {
+        display.getEDTUtil().invoke(false, () -> {
+            window.setPointerVisible(false);
+        });
     }
-  }
-
-  @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();
-    int[] ipix = dbuf.getData();
-    ByteBuffer pixels = ByteBuffer.allocate(ipix.length * 4);
-    pixels.asIntBuffer().put(ipix);
-    PixelFormat format = PixelFormat.ARGB8888;
-    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, () -> {
-      window.setPointerVisible(true);
-      window.setPointerIcon(pi);
-    });
-  }
-
-  @Override
-  public void showCursor() {
-    display.getEDTUtil().invoke(false, () -> {
-      window.setPointerVisible(true);
-    });
-  }
-
-  @Override
-  public void hideCursor() {
-    display.getEDTUtil().invoke(false, () -> {
-      window.setPointerVisible(false);
-    });
-  }
 }