picrate 0.0.2-java

data/src/main/java/processing/event/Event.java

@@ -0,0 +1,108 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+ /*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 The Processing Foundation
+
+  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.event;
+
+public class Event {
+
+    protected Object nativeObject;
+
+    protected long millis;
+    protected int action;
+
+    // These correspond to the java.awt.Event modifiers (not to be confused with
+    // the newer getModifiersEx), though they're not guaranteed to in the future.
+    static public final int SHIFT = 1;
+    static public final int CTRL = 1 << 1;
+    static public final int META = 1 << 2;
+    static public final int ALT = 1 << 3;
+    protected int modifiers;
+
+    // Types of events. As with all constants in Processing, brevity's preferred.
+    static public final int KEY = 1;
+    static public final int MOUSE = 2;
+    static public final int TOUCH = 3;
+    protected int flavor;
+
+    public Event(Object nativeObject, long millis, int action, int modifiers) {
+        this.nativeObject = nativeObject;
+        this.millis = millis;
+        this.action = action;
+        this.modifiers = modifiers;
+    }
+
+    public int getFlavor() {
+        return flavor;
+    }
+
+    /**
+     * Get the platform-native event object. This might be the java.awt event on
+     * the desktop, though if you're using OpenGL on the desktop it'll be a NEWT
+     * event that JOGL uses. Android events are something else altogether.
+     * Bottom line, use this only if you know what you're doing, and don't make
+     * assumptions about the class type.
+     *
+     * @return
+     */
+    public Object getNative() {
+        return nativeObject;
+    }
+
+//  public void setNative(Object nativeObject) {
+//    this.nativeObject = nativeObject;
+//  }
+    public long getMillis() {
+        return millis;
+    }
+
+//  public void setMillis(long millis) {
+//    this.millis = millis;
+//  }
+    public int getAction() {
+        return action;
+    }
+
+//  public void setAction(int action) {
+//    this.action = action;
+//  }
+    public int getModifiers() {
+        return modifiers;
+    }
+
+//  public void setModifiers(int modifiers) {
+//    this.modifiers = modifiers;
+//  }
+    public boolean isShiftDown() {
+        return (modifiers & SHIFT) != 0;
+    }
+
+    public boolean isControlDown() {
+        return (modifiers & CTRL) != 0;
+    }
+
+    public boolean isMetaDown() {
+        return (modifiers & META) != 0;
+    }
+
+    public boolean isAltDown() {
+        return (modifiers & ALT) != 0;
+    }
+}

data/src/main/java/processing/event/KeyEvent.java

@@ -0,0 +1,70 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 The Processing Foundation
+
+  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.event;
+
+
+public class KeyEvent extends Event {
+  static public final int PRESS = 1;
+  static public final int RELEASE = 2;
+  static public final int TYPE = 3;
+
+  char key;
+  int keyCode;
+
+  boolean isAutoRepeat;
+
+
+  public KeyEvent(Object nativeObject,
+                  long millis, int action, int modifiers,
+                  char key, int keyCode) {
+    super(nativeObject, millis, action, modifiers);
+    this.flavor = KEY;
+    this.key = key;
+    this.keyCode = keyCode;
+  }
+
+  public KeyEvent(Object nativeObject,
+                  long millis, int action, int modifiers,
+                  char key, int keyCode, boolean isAutoRepeat) {
+    super(nativeObject, millis, action, modifiers);
+    this.flavor = KEY;
+    this.key = key;
+    this.keyCode = keyCode;
+    this.isAutoRepeat = isAutoRepeat;
+  }
+
+
+  public char getKey() {
+    return key;
+  }
+
+
+  public int getKeyCode() {
+    return keyCode;
+  }
+
+
+  public boolean isAutoRepeat() {
+    return isAutoRepeat;
+  }
+}

data/src/main/java/processing/event/MouseEvent.java

@@ -0,0 +1,149 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+ /*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 The Processing Foundation
+
+  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.event;
+
+//import processing.core.PConstants;
+public class MouseEvent extends Event {
+
+    static public final int PRESS = 1;
+    static public final int RELEASE = 2;
+    static public final int CLICK = 3;
+    static public final int DRAG = 4;
+    static public final int MOVE = 5;
+    static public final int ENTER = 6;
+    static public final int EXIT = 7;
+    static public final int WHEEL = 8;
+
+    protected int x, y;
+    protected int button;
+//  protected int clickCount;
+//  protected float amount;
+    protected int count;
+
+//  public MouseEvent(int x, int y) {
+//    this(null,
+//         System.currentTimeMillis(), PRESSED, 0,
+//         x, y, PConstants.LEFT, 1);
+//  }
+    public MouseEvent(Object nativeObject,
+            long millis, int action, int modifiers,
+            int x, int y, int button, int count) {  //float amount) {  //int clickCount) {
+        super(nativeObject, millis, action, modifiers);
+        this.flavor = MOUSE;
+        this.x = x;
+        this.y = y;
+        this.button = button;
+        //this.clickCount = clickCount;
+        //this.amount = amount;
+        this.count = count;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    /**
+     * Which button was pressed, either LEFT, CENTER, or RIGHT.
+     *
+     * @return
+     */
+    public int getButton() {
+        return button;
+    }
+
+//  public void setButton(int button) {
+//    this.button = button;
+//  }
+    /**
+     * Do not use, getCount() is the correct method.
+     *
+     * @return
+     */
+    @Deprecated
+    public int getClickCount() {
+        //return (int) amount; //clickCount;
+        return count;
+    }
+
+    /**
+     * Do not use, getCount() is the correct method.
+     *
+     * @return
+     */
+    @Deprecated
+    public float getAmount() {
+        //return amount;
+        return count;
+    }
+
+    /**
+     * Number of clicks for mouse button events, or the number of steps
+     * (positive or negative depending on direction) for a mouse wheel event.
+     * Wheel events follow Java (see
+     * <a href="http://docs.oracle.com/javase/6/docs/api/java/awt/event/MouseWheelEvent.html#getWheelRotation()">here</a>),
+     * so getAmount() will return "negative values if the mouse wheel was
+     * rotated up or away from the user" and positive values in the other
+     * direction. On Mac OS X, this will be reversed when "natural" scrolling is
+     * enabled in System Preferences &rarr Mouse.
+     *
+     * @return
+     */
+    public int getCount() {
+        return count;
+    }
+
+//  public void setClickCount(int clickCount) {
+//    this.clickCount = clickCount;
+//  }
+    private String actionString() {
+        switch (action) {
+            default:
+                return "UNKNOWN";
+            case CLICK:
+                return "CLICK";
+            case DRAG:
+                return "DRAG";
+            case ENTER:
+                return "ENTER";
+            case EXIT:
+                return "EXIT";
+            case MOVE:
+                return "MOVE";
+            case PRESS:
+                return "PRESS";
+            case RELEASE:
+                return "RELEASE";
+            case WHEEL:
+                return "WHEEL";
+        }
+    }
+
+    @Override
+    public String toString() {
+        return String.format("<MouseEvent %s@%d,%d count:%d button:%d>",
+                actionString(), x, y, count, button);
+    }
+}

data/src/main/java/processing/event/TouchEvent.java

@@ -0,0 +1,57 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012 The Processing Foundation
+
+  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.event;
+
+
+// PLACEHOLDER CLASS: DO NOT USE. IT HAS NOT EVEN DECIDED WHETHER
+// THIS WILL BE CALLED TOUCHEVENT ONCE IT'S FINISHED.
+
+/*
+http://developer.android.com/guide/topics/ui/ui-events.html
+http://developer.android.com/reference/android/view/MotionEvent.html
+http://developer.apple.com/library/safari/#documentation/UserExperience/Reference/TouchEventClassReference/TouchEvent/TouchEvent.html
+http://developer.apple.com/library/ios/#documentation/UIKit/Reference/UIGestureRecognizer_Class/Reference/Reference.html#//apple_ref/occ/cl/UIGestureRecognizer
+
+Apple's high-level gesture names:
+tap
+pinch
+rotate
+swipe
+pan
+longpress
+
+W3C touch events
+http://www.w3.org/TR/touch-events/
+http://www.w3.org/TR/2011/WD-touch-events-20110913/
+
+Pointer and gesture events (Windows)
+http://msdn.microsoft.com/en-US/library/ie/hh673557.aspx
+
+*/
+public class TouchEvent extends Event {
+
+  public TouchEvent(Object nativeObject, long millis, int action, int modifiers) {
+    super(nativeObject, millis, action, modifiers);
+    this.flavor = TOUCH;
+  }
+}

data/src/main/java/processing/javafx/PGraphicsFX2D.java

@@ -0,0 +1,354 @@
+package processing.javafx;
+
+import processing.core.PGraphics;
+import processing.core.PImage;
+import processing.core.PMatrix;
+import processing.core.PMatrix2D;
+import processing.core.PMatrix3D;
+import processing.core.PShape;
+import processing.core.PSurface;
+
+public class PGraphicsFX2D extends PGraphics{
+    final String message = "FX2D renderer not supported in this version of propane";
+    public PGraphicsFX2D(){
+    }
+
+    
+    public void applyMatrix(float n00, float n01, float n02, float n10, float n11, float n12) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void applyMatrix(float n00, float n01, float n02, float n03, float n10, float n11, float n12, float n13, float n20, float n21, float n22, float n23, float n30, float n31, float n32, float n33) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    protected void backgroundImpl(){
+        throw new UnsupportedOperationException(message); 
+    }
+    
+    public void beginContour() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void beginDraw() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void beginShape(int kind) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void bezierDetail(int detail) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void bezierVertex(float x1, float y1, float x2, float y2, float x3, float y3) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void bezierVertex(float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void box(float w, float h, float d) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public PSurface createSurface() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void curveDetail(int detail) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void curveVertex(float x, float y, float z) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void endContour() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void endDraw() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void endShape(int mode) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void flush() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public int get(int x, int y) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public PMatrix getMatrix() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public PMatrix2D getMatrix(PMatrix2D target) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public PMatrix3D getMatrix(PMatrix3D target) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public Object getNative() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void line(float x1, float y1, float x2, float y2) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void loadPixels() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public PShape loadShape(String filename) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public PShape loadShape(String filename, String options) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void mask(PImage alpha) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void noClip() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void point(float x, float y) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void popMatrix() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void printMatrix() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void pushMatrix() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void quad(float x1, float y1, float x2, float y2, float x3, float y3, float x4, float y4) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void quadraticVertex(float ctrlX, float ctrlY, float endX, float endY) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void quadraticVertex(float x2, float y2, float z2, float x4, float y4, float z4) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void resetMatrix() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void rotate(float angle) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void rotate(float angle, float vx, float vy, float vz) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void rotateX(float angle) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void rotateY(float angle) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void rotateZ(float angle) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void scale(float s) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void scale(float sx, float sy) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void scale(float sx, float sy, float sz) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public float screenX(float x, float y) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public float screenX(float x, float y, float z) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public float screenY(float x, float y) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public float screenY(float x, float y, float z) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public float screenZ(float x, float y, float z) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void set(int x, int y, int argb) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void setMatrix(PMatrix2D source) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void setMatrix(PMatrix3D source) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void shearX(float angle) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void shearY(float angle) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void sphere(float r) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void strokeCap(int cap) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void strokeJoin(int join) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void strokeWeight(float weight) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public float textAscent() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public float textDescent() {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void texture(PImage image) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void translate(float tx, float ty) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void triangle(float x1, float y1, float x2, float y2, float x3, float y3) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void vertex(float x, float y) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void vertex(float x, float y, float z) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void vertex(float[] v) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void vertex(float x, float y, float u, float v) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+    
+    public void vertex(float x, float y, float z, float u, float v) {
+        throw new UnsupportedOperationException(message); 
+    }
+
+}