picrate 0.7.0-java → 0.8.0-java

data/src/main/java/processing/core/PSurfaceNone.java

@@ -1,6 +1,6 @@
 /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 
-/*
+ /*
   Part of the Processing project - http://processing.org
 
   Copyright (c) 2015 The Processing Foundation
@@ -18,175 +18,173 @@
   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.core;
 
-
 /**
  * Surface that's not really visible. Used for PDF and friends, or as a base
  * class for other drawing surfaces. It includes the standard rendering loop.
  */
 public class PSurfaceNone implements PSurface {
 
-    /**
-     *
-     */
-    protected PApplet sketch;
-
-    /**
-     *
-     */
-    protected PGraphics graphics;
-
-    /**
-     *
-     */
-    protected Thread thread;
-
-    /**
-     *
-     */
-    protected boolean paused;
-
-    /**
-     *
-     */
-    protected Object pauseObject = new Object();
-
-    /**
-     *
-     */
-    protected float frameRateTarget = 60;
-
-    /**
-     *
-     */
-    protected long frameRatePeriod = 1000000000L / 60L;
-
-    /**
-     *
-     * @param graphics
-     */
-    public PSurfaceNone(PGraphics graphics) {
+  /**
+   *
+   */
+  protected PApplet sketch;
+
+  /**
+   *
+   */
+  protected PGraphics graphics;
+
+  /**
+   *
+   */
+  protected Thread thread;
+
+  /**
+   *
+   */
+  protected boolean paused;
+
+  /**
+   *
+   */
+  protected Object pauseObject = new Object();
+
+  /**
+   *
+   */
+  protected float frameRateTarget = 60;
+
+  /**
+   *
+   */
+  protected long frameRatePeriod = 1000000000L / 60L;
+
+  /**
+   *
+   * @param graphics
+   */
+  public PSurfaceNone(PGraphics graphics) {
     this.graphics = graphics;
   }
 
-    /**
-     *
-     * @param sketch
-     */
-    @Override
+  /**
+   *
+   * @param sketch
+   */
+  @Override
   public void initOffscreen(PApplet sketch) {
     this.sketch = sketch;
 
     setSize(sketch.sketchWidth(), sketch.sketchHeight());
   }
 
-
 //  public Component initComponent(PApplet sketch) {
 //    return null;
 //  }
-
-    /**
-     *
-     * @param sketch
-     */
-
-
+  /**
+   *
+   * @param sketch
+   */
   @Override
   public void initFrame(PApplet sketch) {/*, int backgroundColor,
                         int deviceIndex, boolean fullScreen,
                         boolean spanDisplays) {*/
     //this.sketch = sketch;
-    throw new IllegalStateException("initFrame() not available with " +
-                                    getClass().getSimpleName());
+    throw new IllegalStateException("initFrame() not available with "
+      + getClass().getSimpleName());
   }
 
-
   public Object getNative() {
     return null;
   }
 
-
-  /** Set the window (and dock, or whatever necessary) title.
-     * @param title */
+  /**
+   * Set the window (and dock, or whatever necessary) title.
+   *
+   * @param title
+   */
   @Override
   public void setTitle(String title) {
     // You're in a utopian PSurface implementation where titles don't exist.
   }
 
-    /**
-     *
-     * @param image
-     */
-    @Override
+  /**
+   *
+   * @param image
+   */
+  @Override
   public void setIcon(PImage image) {
     // I ain't visible, man.
   }
 
-
-  /** Show or hide the window.
-     * @param visible */
+  /**
+   * Show or hide the window.
+   *
+   * @param visible
+   */
   @Override
   public void setVisible(boolean visible) {
     // I'm always invisible. You can't catch me.
   }
 
-
-  /** Set true if we want to resize things (default is not resizable)
-     * @param resizable */
+  /**
+   * Set true if we want to resize things (default is not resizable)
+   *
+   * @param resizable
+   */
   @Override
   public void setResizable(boolean resizable) {
     // I don't need size to know my worth.
   }
 
-    /**
-     *
-     * @param location
-     * @param editorLocation
-     */
-    @Override
-  public void placeWindow(int[] location, int[] editorLocation) { }
-
-    /**
-     *
-     * @param stopColor
-     */
-    @Override
-  public void placePresent(int stopColor) { }
-
-    /**
-     *
-     */
-    @Override
-  public void setupExternalMessages() { }
+  /**
+   *
+   * @param location
+   * @param editorLocation
+   */
+  @Override
+  public void placeWindow(int[] location, int[] editorLocation) {
+  }
 
+  /**
+   *
+   * @param stopColor
+   */
+  @Override
+  public void placePresent(int stopColor) {
+  }
 
+  /**
+   *
+   */
   @Override
-  public void setAlwaysOnTop(boolean always) { }
+  public void setupExternalMessages() {
+  }
 
+  @Override
+  public void setAlwaysOnTop(boolean always) {
+  }
 
   //
-
-    /**
-     *
-     * @param x
-     * @param y
-     */
-
-
+  /**
+   *
+   * @param x
+   * @param y
+   */
   @Override
   public void setLocation(int x, int y) {
     // I'm everywhere, because I'm nowhere.
   }
 
-    /**
-     *
-     * @param wide
-     * @param high
-     */
-    @Override
+  /**
+   *
+   * @param wide
+   * @param high
+   */
+  @Override
   public void setSize(int wide, int high) {
     if (PApplet.DEBUG) {
       //System.out.format("frame visible %b, setSize(%d, %d) %n", frame.isVisible(), wide, high);
@@ -209,78 +207,74 @@ public class PSurfaceNone implements PSurface {
     graphics.setSize(wide, high);
   }
 
-
 //  public void initImage(PGraphics graphics) {
 //    // TODO Auto-generated method stub
 //
 //  }
-
 //  public Component getComponent() {
 //    return null;
 //  }
-
-
 //  public void setSmooth(int level) {
 //    // TODO Auto-generated method stub
 //  }
-
 //  void requestFocus() {
 //  }
-
 //  public void blit() {
 //    // TODO Auto-generated method stub
 //  }
+  /**
+   *
+   * @param kind
+   */
+  @Override
+  public void setCursor(int kind) {
+  }
 
-    /**
-     *
-     * @param kind
-     */
-
-  public void setCursor(int kind) { }
-
-    /**
-     *
-     * @param image
-     * @param hotspotX
-     * @param hotspotY
-     */
-    public void setCursor(PImage image, int hotspotX, int hotspotY) { }
-
-    /**
-     *
-     */
-    public void showCursor() { }
+  /**
+   *
+   * @param image
+   * @param hotspotX
+   * @param hotspotY
+   */
+  @Override
+  public void setCursor(PImage image, int hotspotX, int hotspotY) {
+  }
 
-    /**
-     *
-     */
-    public void hideCursor() { }
+  /**
+   *
+   */
+  @Override
+  public void showCursor() {
+  }
 
+  /**
+   *
+   */
+  @Override
+  public void hideCursor() {
+  }
 
   //
-
-    /**
-     *
-     * @return
-     */
-
-
+  /**
+   *
+   * @return
+   */
   public Thread createThread() {
     return new AnimationThread();
   }
 
-
+  @Override
   public void startThread() {
     if (thread == null) {
       thread = createThread();
       thread.start();
     } else {
-      throw new IllegalStateException("Thread already started in " +
-                                      getClass().getSimpleName());
+      throw new IllegalStateException("Thread already started in "
+        + getClass().getSimpleName());
     }
   }
 
-
+  @Override
   public boolean stopThread() {
     if (thread == null) {
       return false;
@@ -289,27 +283,26 @@ public class PSurfaceNone implements PSurface {
     return true;
   }
 
-    /**
-     *
-     * @return
-     */
-    public boolean isStopped() {
+  /**
+   *
+   * @return
+   */
+  @Override
+  public boolean isStopped() {
     return thread == null || !thread.isAlive();
   }
 
-
   // sets a flag to pause the thread when ready
+  @Override
   public void pauseThread() {
     PApplet.debug("PApplet.run() paused, calling object wait...");
     paused = true;
   }
 
-
   // halts the animation thread if the pause flag is set
-
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected void checkPause() {
     if (paused) {
       synchronized (pauseObject) {
@@ -324,50 +317,52 @@ public class PSurfaceNone implements PSurface {
 //    PApplet.debug("done with pause");
   }
 
-    /**
-     *
-     */
-    public void resumeThread() {
+  /**
+   *
+   */
+  @Override
+  public void resumeThread() {
     paused = false;
     synchronized (pauseObject) {
       pauseObject.notifyAll();  // wake up the animation thread
     }
   }
 
-    /**
-     *
-     * @param fps
-     */
-    public void setFrameRate(float fps) {
+  /**
+   *
+   * @param fps
+   */
+  @Override
+  public void setFrameRate(float fps) {
     frameRateTarget = fps;
     frameRatePeriod = (long) (1000000000.0 / frameRateTarget);
     //g.setFrameRate(fps);
   }
 
+  /**
+   *
+   */
+  public class AnimationThread extends Thread {
+
     /**
      *
      */
-    public class AnimationThread extends Thread {
-
-      /**
-       *
-       */
-      public AnimationThread() {
+    public AnimationThread() {
       super("Animation Thread");
     }
 
     // broken out so it can be overridden by Danger et al
-
-      /**
-       *
-       */
+    /**
+     *
+     */
     public void callDraw() {
       sketch.handleDraw();
     }
 
     /**
      * Main method for the primary animation thread.
-     * <A HREF="http://java.sun.com/products/jfc/tsc/articles/painting/">Painting in AWT and Swing</A>
+     * <A HREF="http://java.sun.com/products/jfc/tsc/articles/painting/">Painting
+     * in AWT and Swing</A>
      */
     @Override
     public void run() {  // not good to make this synchronized, locks things up
@@ -397,8 +392,7 @@ public class PSurfaceNone implements PSurface {
         }
 //        System.out.format("  but now, sketchW/H changed to %d %d%n", sketchWidth, sketchHeight);
       }
-      */
-
+       */
       // un-pause the sketch and get rolling
       sketch.start();
 
@@ -411,7 +405,6 @@ public class PSurfaceNone implements PSurface {
 //        if (currentSize.width != sketchWidth || currentSize.height != sketchHeight) {
 //          System.err.format("need to resize from %s to %d, %d%n", currentSize, sketchWidth, sketchHeight);
 //        }
-
         // render a single frame
 //        try {
 //          EventQueue.invokeAndWait(new Runnable() {
@@ -427,7 +420,6 @@ public class PSurfaceNone implements PSurface {
 //        }
 //          }
 //        });
-
 //            }
 //          });
 //        } catch (InterruptedException ie) {
@@ -435,12 +427,10 @@ public class PSurfaceNone implements PSurface {
 //        } catch (InvocationTargetException ite) {
 //          ite.getTargetException().printStackTrace();
 //        }
-
         // wait for update & paint to happen before drawing next frame
         // this is necessary since the drawing is sometimes in a
         // separate thread, meaning that the next frame will start
         // before the update/paint is completed
-
         long afterTime = System.nanoTime();
         long timeDiff = afterTime - beforeTime;
         //System.out.println("time diff is " + timeDiff);
@@ -450,7 +440,8 @@ public class PSurfaceNone implements PSurface {
           try {
             Thread.sleep(sleepTime / 1000000L, (int) (sleepTime % 1000000L));
             noDelays = 0;  // Got some sleep, not delaying anymore
-          } catch (InterruptedException ex) { }
+          } catch (InterruptedException ex) {
+          }
 
           overSleepTime = (System.nanoTime() - afterTime) - sleepTime;