propane 3.4.0-java → 3.4.1-java

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

@@ -33,7 +33,7 @@ import processing.core.PApplet;
  * function is used to draw the shape to the display window. The
  * <b>PShape</b> object contain a group of methods, linked below, that can
  * operate on the shape data.
- * <br /><br />
+
  * The <b>loadShape()</b> function supports SVG files created with Inkscape and
  * Adobe Illustrator. It is not a full SVG implementation, but offers some
  * straightforward support for handling vector data.
@@ -2777,7 +2777,7 @@ public class PShape implements PConstants {
      * <b>translate(20, 0)</b> is the same as <b>translate(70, 0)</b>. This
      * transformation is applied directly to the shape, it's not refreshed each
      * time <b>draw()</b> is run.
-     * <br /><br />
+    
      * Using this method with the <b>z</b> parameter requires using the P3D
      * parameter in combination with size.
      *
@@ -2812,14 +2812,14 @@ public class PShape implements PConstants {
      * <b>angle</b> parameter. Angles should be specified in radians (values
      * from 0 to TWO_PI) or converted to radians with the <b>radians()</b>
      * method.
-     * <br /><br />
+    
      * Shapes are always rotated around the upper-left corner of their bounding
      * box. Positive numbers rotate objects in a clockwise direction. Subsequent
      * calls to the method accumulates the effect. For example, calling
      * <b>rotateX(HALF_PI)</b> and then <b>rotateX(HALF_PI)</b> is the same as
      * <b>rotateX(PI)</b>. This transformation is applied directly to the shape,
      * it's not refreshed each time <b>draw()</b> is run.
-     * <br /><br />
+    
      * This method requires a 3D renderer. You need to use P3D as a third
      * parameter for the <b>size()</b> function as shown in the example above.
      *
@@ -2847,14 +2847,14 @@ public class PShape implements PConstants {
      * <b>angle</b> parameter. Angles should be specified in radians (values
      * from 0 to TWO_PI) or converted to radians with the <b>radians()</b>
      * method.
-     * <br /><br />
+    
      * Shapes are always rotated around the upper-left corner of their bounding
      * box. Positive numbers rotate objects in a clockwise direction. Subsequent
      * calls to the method accumulates the effect. For example, calling
      * <b>rotateY(HALF_PI)</b> and then <b>rotateY(HALF_PI)</b> is the same as
      * <b>rotateY(PI)</b>. This transformation is applied directly to the shape,
      * it's not refreshed each time <b>draw()</b> is run.
-     * <br /><br />
+    
      * This method requires a 3D renderer. You need to use P3D as a third
      * parameter for the <b>size()</b> function as shown in the example above.
      *
@@ -2882,14 +2882,14 @@ public class PShape implements PConstants {
      * <b>angle</b> parameter. Angles should be specified in radians (values
      * from 0 to TWO_PI) or converted to radians with the <b>radians()</b>
      * method.
-     * <br /><br />
+    
      * Shapes are always rotated around the upper-left corner of their bounding
      * box. Positive numbers rotate objects in a clockwise direction. Subsequent
      * calls to the method accumulates the effect. For example, calling
      * <b>rotateZ(HALF_PI)</b> and then <b>rotateZ(HALF_PI)</b> is the same as
      * <b>rotateZ(PI)</b>. This transformation is applied directly to the shape,
      * it's not refreshed each time <b>draw()</b> is run.
-     * <br /><br />
+    
      * This method requires a 3D renderer. You need to use P3D as a third
      * parameter for the <b>size()</b> function as shown in the example above.
      *
@@ -2916,7 +2916,7 @@ public class PShape implements PConstants {
      * Rotates a shape the amount specified by the <b>angle</b> parameter.
      * Angles should be specified in radians (values from 0 to TWO_PI) or
      * converted to radians with the <b>radians()</b> method.
-     * <br /><br />
+    
      * Shapes are always rotated around the upper-left corner of their bounding
      * box. Positive numbers rotate objects in a clockwise direction.
      * Transformations apply to everything that happens after and subsequent
@@ -2971,7 +2971,7 @@ public class PShape implements PConstants {
      * <b>scale(2.0)</b> and then <b>scale(1.5)</b> is the same as
      * <b>scale(3.0)</b>. This transformation is applied directly to the shape,
      * it's not refreshed each time <b>draw()</b> is run.
-     * <br /><br />
+    
      * Using this method with the <b>z</b> parameter requires using the P3D
      * parameter in combination with size.
      *

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

@@ -42,8 +42,8 @@ import processing.core.PConstants;
  * cannot simply use traditional addition/multiplication/etc. Instead, we'll
  * need to do some "vector" math, which is made easy by the methods inside the
  * <b>PVector</b>
- * class.<br />
- * <br />
+ * class.
+ * 
  * The methods for this class are extensive. For a complete list, visit the
  * <a
  * href="http://processing.googlecode.com/svn/trunk/processing/build/javadoc/core/">developer's

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

@@ -39,8 +39,8 @@ import java.awt.Taskbar;
  */
 public class ThinkDifferent {
 
-  private static Desktop desktop;
-  private static Taskbar taskbar;
+  private static Desktop desktop; // cached instance
+  private static Taskbar taskbar; // cached instance
 
   // True if user has tried to quit once. Prevents us from canceling the quit
   // call if the sketch is held up for some reason, like an exception that's
@@ -57,9 +57,9 @@ public class ThinkDifferent {
    * @param sketch The sketch whose quit handler callback should be set.
    */
   static public void init(final PApplet sketch) {
-    getDesktop().setQuitHandler((var event, var quitResponse) -> {
-      sketch.exit();      
-      var noKnownCrash = PApplet.uncaughtThrowable == null;      
+    getDesktop().setQuitHandler((event, quitResponse) -> {
+      sketch.exit();
+      boolean noKnownCrash = PApplet.uncaughtThrowable == null;
       if (noKnownCrash && !attemptedQuit) {  // haven't tried yet
         quitResponse.cancelQuit();  // tell OS X we'll handle this
         attemptedQuit = true;
@@ -94,7 +94,6 @@ public class ThinkDifferent {
     if (taskbar == null) {
       taskbar = Taskbar.getTaskbar();
     }
-
     return taskbar;
   }
 
@@ -107,7 +106,6 @@ public class ThinkDifferent {
     if (desktop == null) {
       desktop = Desktop.getDesktop();
     }
-
     return desktop;
   }
 }

data/src/main/java/processing/dxf/RawDXF.java

@@ -0,0 +1,404 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+ * RawDXF - Code to write DXF files with beginRaw/endRaw
+ * An extension for the Processing project - http://processing.org
+ * <p/>
+ * 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.
+ * <p/>
+ * 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.
+ * <p/>
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with the Processing project; if not,
+ * write to the Free Software Foundation, Inc., 59 Temple Place,
+ * Suite 330, Boston, MA  02111-1307  USA
+ */
+
+package processing.dxf;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.FileWriter;
+import java.io.PrintWriter;
+import processing.core.PGraphics;
+
+
+/**
+ * A simple library to write DXF files with Processing.
+ * Because this is used with beginRaw() and endRaw(), only individual
+ * triangles and (discontinuous) line segments will be written to the file.
+ * <p>
+ * Use something like a keyPressed() in PApplet to trigger it,
+ * to avoid writing a bazillion .dxf files.
+ * <p>
+ * Usually, the file will be saved to the sketch's folder.
+ * Use Sketch &rarr; Show Sketch Folder to see it from the PDE.
+ * <p>
+ * A simple example of how to use:
+ * <PRE>
+ * import processing.dxf.*;
+ *
+ * boolean record;
+ *
+ * void setup() {
+ *   size(500, 500, P3D);
+ * }
+ *
+ * void keyPressed() {
+ *   // use a key press so that it doesn't make a million files
+ *   if (key == 'r') record = true;
+ * }
+ *
+ * void draw() {
+ *   if (record) {
+ *     beginRaw(DXF, "output.dxf");
+ *   }
+ *
+ *   // do all your drawing here
+ *
+ *   if (record) {
+ *     endRaw();
+ *     record = false;
+ *   }
+ * }
+ * </PRE>
+ * or to use it and be able to control the current layer:
+ * <PRE>
+ * import processing.dxf.*;
+ *
+ * boolean record;
+ * RawDXF dxf;
+ *
+ * void setup() {
+ *   size(500, 500, P3D);
+ * }
+ *
+ * void keyPressed() {
+ *   // use a key press so that it doesn't make a million files
+ *   if (key == 'r') record = true;
+ * }
+ *
+ * void draw() {
+ *   if (record) {
+ *     dxf = (RawDXF) createGraphics(width, height, DXF, "output.dxf");
+ *     beginRaw(dxf);
+ *   }
+ *
+ *   // do all your drawing here, and to set the layer, call:
+ *   // if (record) {
+ *   //   dxf.setLayer(num);
+ *   // }
+ *   // where 'num' is an integer.
+ *   // the default is zero, or you can set it to whatever.
+ *
+ *   if (record) {
+ *     endRaw();
+ *     record = false;
+ *     dxf = null;
+ *   }
+ * }
+ * </PRE>
+ * Note that even though this class is a subclass of PGraphics, it only
+ * implements the parts of the API that are necessary for beginRaw/endRaw.
+ * <p>
+ * Based on the original DXF writer from Simon Greenwold, February 2004.
+ * Updated for Processing 0070 by Ben Fry in September 2004,
+ * and again for Processing beta in April 2005.
+ * Rewritten to support beginRaw/endRaw by Ben Fry in February 2006.
+ * Updated again for inclusion as a core library in March 2006.
+ * Constructor modifications in September 2008 as we approach 1.0.
+ */
+public class RawDXF extends PGraphics {
+
+  File file;
+  PrintWriter writer;
+  int currentLayer;
+
+
+  public RawDXF() { }
+
+  @Override
+  public void setPath(String path) {
+    this.path = path;
+    if (path != null) {
+      file = new File(path);
+      if (!file.isAbsolute()) file = null;
+    }
+    if (file == null) {
+      throw new RuntimeException("DXF export requires an absolute path " +
+                                 "for the location of the output file.");
+    }
+  }
+
+
+  // ..............................................................
+
+
+  protected void allocate() {
+    /*
+    for (int i = 0; i < MAX_TRI_LAYERS; i++) {
+      layerList[i] = NO_LAYER;
+    }
+    */
+    setLayer(0);
+  }
+
+
+  @Override
+  public void dispose() {
+    writeFooter();
+
+    writer.flush();
+    writer.close();
+    writer = null;
+  }
+
+  @Override
+  public boolean displayable() {
+    return false;  // just in case someone wants to use this on its own
+  }
+
+  @Override
+  public boolean is2D() {
+    return false;
+  }
+
+
+  @Override
+  public boolean is3D() {
+    return true;
+  }
+  // ..............................................................
+
+  @Override
+  public void beginDraw() {
+    // have to create file object here, because the name isn't yet
+    // available in allocate()
+    if (writer == null) {
+      try {
+        writer = new PrintWriter(new FileWriter(file));
+      } catch (IOException e) {
+        throw new RuntimeException(e);  // java 1.4+
+      }
+      writeHeader();
+    }
+  }
+
+  @Override
+  public void endDraw() {
+    writer.flush();
+  }
+
+
+  // ..............................................................
+
+
+  /**
+   * Set the current layer being used in the DXF file.The default is zero.
+   * @param layer
+   */
+  public void setLayer(int layer) {
+    currentLayer = layer;
+  }
+
+
+  // ..............................................................
+
+
+  private void writeHeader() {
+    writer.println("0");
+    writer.println("SECTION");
+    writer.println("2");
+    writer.println("ENTITIES");
+  }
+
+
+  private void writeFooter() {
+    writer.println("0");
+    writer.println("ENDSEC");
+    writer.println("0");
+    writer.println("EOF");
+  }
+
+
+  /**
+   * Write a command on one line (as a String), then start a new line
+   * and write out a formatted float.Available for anyone who wants to
+ insert additional commands into the DXF stream.
+   * @param cmd
+   * @param val
+   */
+  public void write(String cmd, float val) {
+    writer.println(cmd);
+    // Don't number format, will cause trouble on systems that aren't en-US
+    // http://dev.processing.org/bugs/show_bug.cgi?id=495
+    writer.println(val);
+  }
+
+
+  /**
+   * Write a line to the dxf file.Available for anyone who wants to
+ insert additional commands into the DXF stream.
+   * @param what
+   */
+  public void println(String what) {
+    writer.println(what);
+  }
+
+
+  protected void writeLine(int index1, int index2) {
+    writer.println("0");
+    writer.println("LINE");
+
+    // write out the layer
+    writer.println("8");
+    writer.println(String.valueOf(currentLayer));
+
+    write("10", vertices[index1][X]);
+    write("20", vertices[index1][Y]);
+    write("30", vertices[index1][Z]);
+
+    write("11", vertices[index2][X]);
+    write("21", vertices[index2][Y]);
+    write("31", vertices[index2][Z]);
+  }
+
+
+  /*
+  protected void writeLineStrip() {
+    writeLine();
+    // shift the last vertex to be the first vertex
+    System.arraycopy(vertices[1], 0, vertices[0], 0, vertices[1].length);
+    vertexCount = 1;
+  }
+  */
+
+  protected void writeTriangle() {
+    writer.println("0");
+    writer.println("3DFACE");
+
+    // write out the layer
+    writer.println("8");
+    /*
+    if (i < MAX_TRI_LAYERS) {
+      if (layerList[i] >= 0) {
+        currentLayer = layerList[i];
+      }
+    }
+    */
+    writer.println(String.valueOf(currentLayer));
+
+    write("10", vertices[0][X]);
+    write("20", vertices[0][Y]);
+    write("30", vertices[0][Z]);
+
+    write("11", vertices[1][X]);
+    write("21", vertices[1][Y]);
+    write("31", vertices[1][Z]);
+
+    write("12", vertices[2][X]);
+    write("22", vertices[2][Y]);
+    write("32", vertices[2][Z]);
+
+    // Without adding EPSILON, Rhino kinda freaks out.
+    // A face is actually a quad, not a triangle,
+    // so instead kinda fudging the final point here.
+    write("13", vertices[2][X] + EPSILON);
+    write("23", vertices[2][Y] + EPSILON);
+    write("33", vertices[2][Z] + EPSILON);
+
+    vertexCount = 0;
+  }
+  // ..............................................................
+
+  @Override
+  public void beginShape(int kind) {
+    shape = kind;
+
+    if ((shape != LINES) &&
+        (shape != TRIANGLES) &&
+        (shape != POLYGON)) {
+      String err =
+        "RawDXF can only be used with beginRaw(), " +
+        "because it only supports lines and triangles";
+      throw new RuntimeException(err);
+    }
+
+    if ((shape == POLYGON) && fill) {
+      throw new RuntimeException("DXF Export only supports non-filled shapes.");
+    }
+
+    vertexCount = 0;
+  }
+
+  @Override
+  public void vertex(float x, float y) {
+    vertex(x, y, 0);
+  }
+
+  @Override
+  public void vertex(float x, float y, float z) {
+    float vertex[] = vertices[vertexCount];
+    vertex[X] = x;  // note: not mx, my, mz like PGraphics3
+    vertex[Y] = y;
+    vertex[Z] = z;
+
+    if (fill) {
+      vertex[R] = fillR;
+      vertex[G] = fillG;
+      vertex[B] = fillB;
+      vertex[A] = fillA;
+    }
+
+    if (stroke) {
+      vertex[SR] = strokeR;
+      vertex[SG] = strokeG;
+      vertex[SB] = strokeB;
+      vertex[SA] = strokeA;
+      vertex[SW] = strokeWeight;
+    }
+
+    if (textureImage != null) {  // for the future?
+      vertex[U] = textureU;
+      vertex[V] = textureV;
+    }
+    vertexCount++;
+
+    if ((shape == LINES) && (vertexCount == 2)) {
+      writeLine(0, 1);
+      vertexCount = 0;
+
+/*
+    } else if ((shape == LINE_STRIP) && (vertexCount == 2)) {
+      writeLineStrip();
+*/
+
+    } else if ((shape == TRIANGLES) && (vertexCount == 3)) {
+      writeTriangle();
+    }
+  }
+
+  @Override
+  public void endShape(int mode) {
+    if (shape == POLYGON) {
+      for (int i = 0; i < vertexCount - 1; i++) {
+        writeLine(i, i+1);
+      }
+      if (mode == CLOSE) {
+        writeLine(vertexCount - 1, 0);
+      }
+    }
+    /*
+    if ((vertexCount != 0) &&
+        ((shape != LINE_STRIP) && (vertexCount != 1))) {
+      System.err.println("Extra vertex boogers found.");
+    }
+    */
+  }
+}