propane 3.2.0-java → 3.3.0-java

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

@@ -0,0 +1,120 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-2014 The Processing Foundation
+  Copyright (c) 2007-2012 Ben Fry and Casey Reas
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU General Public License
+  version 2, as published by the Free Software Foundation.
+
+  This program 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 General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software Foundation,
+  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+package processing.core;
+
+import java.awt.*;
+
+
+/**
+ * Deal with issues related to Mac OS window behavior.
+ *
+ * We have to register a quit handler to safely shut down the sketch,
+ * otherwise OS X will just kill the sketch when a user hits Cmd-Q.
+ * In addition, we have a method to set the dock icon image so we look more
+ * like a native desktop.
+ *
+ * This is a stripped-down version of what's in processing.app.platform to fix
+ * <a href="https://github.com/processing/processing/issues/3301">3301</a>.
+ */
+public class ThinkDifferent {
+
+  private static Desktop desktop;
+  private static Taskbar taskbar;
+
+  // 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
+  // managed to put the sketch in a bad state.
+  static boolean attemptedQuit;
+
+  /**
+   * Initialize the sketch with the quit handler.
+   *
+   * Initialize the sketch with the quit handler such that, if there is no known
+   * crash, the application will not exit on its own if this is the first quit
+   * attempt.
+   *
+   * @param sketch The sketch whose quit handler callback should be set.
+   */
+  static public void init(final PApplet sketch) {
+    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;
+      } else {
+        quitResponse.performQuit();  // just force it this time
+      }
+    });
+  }
+
+  /**
+   * Remove the quit handler.
+   */
+  static public void cleanup() {
+    getDesktop().setQuitHandler(null);
+  }
+
+  /**
+   * Called via reflection from PSurfaceAWT and others, set the dock icon image.
+   *
+   * @param image The image to provide for Processing icon.
+   */
+  static public void setIconImage(Image image) {
+    getTaskbar().setIconImage(image);
+  }
+
+  /**
+   * Get the taskbar where OS visual settings can be provided.
+   *
+   * @return Cached taskbar singleton instance.
+   */
+  static private Taskbar getTaskbar() {
+    if (taskbar == null) {
+      taskbar = Taskbar.getTaskbar();
+    }
+
+    return taskbar;
+  }
+
+  /**
+   * Get the desktop where OS behavior can be provided.
+   *
+   * @return Cached desktop singleton instance.
+   */
+  static private Desktop getDesktop() {
+    if (desktop == null) {
+      desktop = Desktop.getDesktop();
+    }
+
+    return desktop;
+  }
+
+
+  // Instead, just use Application.getApplication() inside your app
+//  static public Application getApplication() {
+//    return desktop;
+//  }
+}

data/src/main/java/processing/core/util/image/ImageLoadFacade.java

@@ -0,0 +1,161 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-18 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  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, version 2.1.
+
+  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.core.util.image;
+
+import processing.core.PApplet;
+import processing.core.PImage;
+import processing.core.util.image.load.*;
+import processing.core.util.io.PathUtil;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+
+/**
+ * Utility for loading images either from file system or string encoding using a set of strategies.
+ */
+public class ImageLoadFacade {
+
+  private static final AtomicReference<ImageLoadFacade> instance = new AtomicReference<>(null);
+
+  private static final String PREFIX_BASE64_STRING_IMAGE = "data:image";
+  private static final String PREFIX_FILE_PATH = "file://";
+
+  private final Map<String, ImageLoadStrategy> loadStrategies;
+  private final ImageLoadStrategy defaultImageLoadStrategy;
+
+  /**
+   * Get a shared instance of this singleton.
+   *
+   * @return Shared instance of this singleton.
+   */
+  public static ImageLoadFacade get() {
+    instance.compareAndSet(null, new ImageLoadFacade());
+    return instance.get();
+  }
+
+  /**
+   * Hidden constructor. Clients should use get().
+   */
+  private ImageLoadFacade() {
+    loadStrategies = new HashMap<>();
+
+    loadStrategies.put("base64", new Base64StringImageLoadStrategy());
+
+    loadStrategies.put("tga", new TgaImageLoadStrategy());
+
+    ImageLoadStrategy tifImageLoadStrategy = new TiffImageLoadStrategy();
+    loadStrategies.put("tif", tifImageLoadStrategy);
+    loadStrategies.put("tiff", tifImageLoadStrategy);
+
+    ImageLoadStrategy awtImageLoadStrategy = new AwtImageLoadStrategy();
+    defaultImageLoadStrategy = new ImageIoImageLoadStrategy();
+
+    ImageLoadStrategy awtFallbackStrategy = new FallbackImageLoadStrategy(
+        awtImageLoadStrategy,
+        defaultImageLoadStrategy
+    );
+    loadStrategies.put("jpg", awtFallbackStrategy);
+    loadStrategies.put("jpeg", awtFallbackStrategy);
+    loadStrategies.put("gif", awtFallbackStrategy);
+    loadStrategies.put("png", awtFallbackStrategy);
+    loadStrategies.put("unknown", awtFallbackStrategy);
+  }
+
+  /**
+   * Load an image embedded within an SVG string.
+   *
+   * @param pApplet The PApplet on whose behalf an SVG is being parsed. This must be given so that
+   *                image can be retrieved in the case of sketch relative file.
+   * @param svgImageStr The SVG string to load which can be data:image or file://.
+   * @return The image loaded as a PImage.
+   */
+  public PImage loadFromSvg(PApplet pApplet, String svgImageStr) {
+    if (svgImageStr == null) {
+      return null;
+    }
+
+    if (svgImageStr.startsWith(PREFIX_BASE64_STRING_IMAGE)) {
+      String[] parts = svgImageStr.split(";base64,");
+      String extension = parts[0].substring(11);
+      String encodedData = parts[1];
+      return loadStrategies.get("base64").load(pApplet, encodedData, extension);
+    } else if (svgImageStr.startsWith(PREFIX_FILE_PATH)) {
+      String filePath = svgImageStr.substring(PREFIX_FILE_PATH.length());
+      return loadFromFile(pApplet, filePath);
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Load an image from a file.
+   *
+   * @param pApplet The PApplet through which the image should be retrieved in the case of sketch
+   *     relative file (data folder for example).
+   * @param path The path to the file to be opened.
+   * @return The image loaded.
+   */
+  public PImage loadFromFile(PApplet pApplet, String path) {
+    return loadFromFile(pApplet, path, null);
+  }
+
+  /**
+   * Load an image from a file using the given file extension.
+   *
+   * @param pApplet The PApplet through which the image should be retrieved in the case of sketch
+   *     relative file (data folder for example).
+   * @param path The path to the file to be opened.
+   * @param extension The extension with which the image should be loaded like "png".
+   * @return The image loaded.
+   */
+  public PImage loadFromFile(PApplet pApplet, String path, String extension) {
+    if (extension == null) {
+      extension = PathUtil.parseExtension(path);
+    }
+
+    // just in case. them users will try anything!
+    extension = PathUtil.cleanExtension(extension);
+
+    // Find strategy for loading
+    ImageLoadStrategy imageLoadStrategy = loadStrategies.getOrDefault(
+        extension,
+        defaultImageLoadStrategy
+    );
+
+    // Load image
+    PImage resultImage = imageLoadStrategy.load(pApplet, path, extension);
+
+    // Report error or return
+    if (resultImage == null) {
+      System.err.println("Could not find a method to load " + path);
+      return null;
+    } else {
+      return resultImage;
+    }
+  }
+
+}

data/src/main/java/processing/core/util/image/ImageSaveFacade.java

@@ -0,0 +1,169 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-18 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  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, version 2.1.
+
+  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.core.util.image;
+
+import processing.core.PApplet;
+import processing.core.PGraphics;
+import processing.core.util.image.save.*;
+import processing.core.util.io.PathUtil;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+
+/**
+ * Facade to load PImages from various sources.
+ */
+public class ImageSaveFacade {
+
+  private static final AtomicReference<ImageSaveFacade> instance = new AtomicReference<>(null);
+
+  private final Map<String, ImageSaveStrategy> saveStrategies;
+  private final ImageSaveStrategy defaultImageSaveStrategy;
+
+  /**
+   * Get a shared instance of this singleton.
+   *
+   * @return Shared instance of ImageSaveFacade.
+   */
+  public static ImageSaveFacade get() {
+    instance.compareAndSet(null, new ImageSaveFacade());
+    return instance.get();
+  }
+
+  /**
+   * Private hidden constructor requiring clients to use get().
+   */
+  private ImageSaveFacade() {
+    saveStrategies = new HashMap<>();
+
+    ImageSaveStrategy imageWriterImageSaveStrategy = new ImageWriterImageSaveStrategy();
+    for (String format : javax.imageio.ImageIO.getWriterFormatNames()) {
+      saveStrategies.put(format.toLowerCase(), imageWriterImageSaveStrategy);
+    }
+
+    ImageSaveStrategy tgaImageSaveStrategy = new TgaImageSaveStrategy();
+    saveStrategies.put("tga", tgaImageSaveStrategy);
+
+    ImageSaveStrategy tiffImageSaveStrategy = new TiffImageSaveStrategy();
+    saveStrategies.put("tiff", tiffImageSaveStrategy);
+
+    defaultImageSaveStrategy = new TiffNakedFilenameImageSaveStrategy();
+  }
+
+  /**
+   * Save a raw representation of pixel values to a file given that file's path.
+   *
+   * @param pixels The raw representation of the image to save.
+   * @param pixelWidth Width of the image in pixels.
+   * @param pixelheight Height of the image in pixels.
+   * @param format Format corresponding to value in PConstants like PConstants.ARGB.
+   * @param filename The path at which the file should be saved like "test/path/output.png".
+   */
+  public boolean save(int[] pixels, int pixelWidth, int pixelHeight, int format, String filename) {
+    return save(
+        pixels,
+        pixelWidth,
+        pixelHeight,
+        format,
+        filename,
+        null
+    );
+  }
+
+  /**
+   * Save a raw representation of pixel values to a file given that file's path.
+   *
+   * @param pixels The raw representation of the image to save.
+   * @param pixelWidth Width of the image in pixels.
+   * @param pixelheight Height of the image in pixels.
+   * @param format Format corresponding to value in PConstants like PConstants.ARGB.
+   * @param filename The path at which the file should be saved like "test/path/output.png".
+   * @param pApplet The applet through which files should be saved when using sketch relative paths.
+   *    Can pass null if using absolute paths.
+   */
+  public boolean save(int[] pixels, int pixelWidth, int pixelHeight, int format, String filename,
+      PApplet pApplet) {
+
+    filename = preparePath(pApplet, filename);
+
+    String extension = PathUtil.parseExtension(filename);
+
+    ImageSaveStrategy imageSaveStrategy = saveStrategies.getOrDefault(
+        extension,
+        defaultImageSaveStrategy
+    );
+
+    try {
+      return imageSaveStrategy.save(
+          pixels,
+          pixelWidth,
+          pixelHeight,
+          format,
+          filename
+      );
+    } catch (IOException e) {
+      System.err.println("Error while saving image.");
+      e.printStackTrace();
+      return false;
+    } catch (SaveImageException e) {
+      PGraphics.showException(e.getMessage());
+      return false;
+    }
+
+  }
+
+  /**
+   * Ensure that the path is ready so that a file can be saved.
+   *
+   * @param pApplet The applet through which files should be saved when using sketch relative paths.
+   *    Can pass null if using absolute paths.
+   * @param filename The filename that will be written and for which a path needs to be prepared.
+   * @return Completed path useable for writing like a file path that has been made relative to
+   *    the sketch folder.
+   */
+  private String preparePath(PApplet pApplet, String filename) {
+    if (pApplet != null) {
+      return pApplet.savePath(filename);
+    } else {
+      File file = new File(filename);
+      if (file.isAbsolute()) {
+        // make sure that the intermediate folders have been created
+        PathUtil.createPath(file);
+        return filename;
+      } else {
+        String msg =
+            "PImage.save() requires an absolute path. " +
+                "Use createImage(), or pass savePath() to save().";
+
+        throw new SaveImageException(msg);
+      }
+    }
+  }
+
+}