implements PConstants, Runnable,

MouseListener, MouseMotionListener, KeyListener, FocusListener

{

/**

public static final String javaVersionName =

System.getProperty("java.version");

/**

public static final float javaVersion =

new Float(javaVersionName.substring(0, 3)).floatValue();

/**

/**

static public int platform;

/**

//static public String platformName;

static {

String osname = System.getProperty("os.name");

if (osname.indexOf("Mac") != -1) {

platform = MACOSX;

} else if (osname.indexOf("Windows") != -1) {

platform = WINDOWS;

} else if (osname.equals("Linux")) { // true for the ibm vm

platform = LINUX;

} else {

platform = OTHER;

}

}

/**

static public String useQuartz = "true";

/**

static public final int MENU_SHORTCUT =

Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();

/** The PGraphics renderer associated with this PApplet */

public PGraphics g;

//protected Object glock = new Object(); // for sync

/** The frame containing this applet (if any) */

public Frame frame;

/**

public int screenWidth, screenHeight;

/**

public Dimension screen =

Toolkit.getDefaultToolkit().getScreenSize();

/**

public PGraphics recorder;

/**

public String args[];

/** Path to sketch folder */

public String sketchPath; //folder;

/** When debugging headaches */

static final boolean THREAD_DEBUG = false;

/** Default width and height for applet when not specified */

static public final int DEFAULT_WIDTH = 100;

static public final int DEFAULT_HEIGHT = 100;

/**

static public final int MIN_WINDOW_WIDTH = 128;

static public final int MIN_WINDOW_HEIGHT = 128;

/**

static public class RendererChangeException extends RuntimeException { }

/**

public boolean defaultSize;

volatile boolean resizeRequest;

volatile int resizeWidth;

volatile int resizeHeight;

/**

public int pixels[];

/** width of this applet's associated PGraphics

public int width;

/** height of this applet's associated PGraphics

public int height;

/**

public int mouseX;

/**

public int mouseY;

/**

public int pmouseX;

/**

public int pmouseY;

/**

protected int dmouseX, dmouseY;

/**

protected int emouseX, emouseY;

/**

public boolean firstMouse;

/**

public int mouseButton;

/**

public boolean mousePressed;

public MouseEvent mouseEvent;

/**

public char key;

/**

public int keyCode;

/**

public boolean keyPressed;

/**

public KeyEvent keyEvent;

/**

public boolean focused = false;

/**

public boolean online = false;

/**

long millisOffset;

/**

public float frameRate = 10;

/** Last time in nanoseconds that frameRate was checked */

protected long frameRateLastNanos = 0;

/** As of release 0116, frameRate(60) is called as a default */

protected float frameRateTarget = 60;

protected long frameRatePeriod = 1000000000L / 60L;

protected boolean looping;

/** flag set to true when a redraw is asked for by the user */

protected boolean redraw;

/**

public int frameCount;

/**

public boolean finished;

/**

protected boolean exitCalled;

Thread thread;

protected RegisteredMethods sizeMethods;

protected RegisteredMethods preMethods, drawMethods, postMethods;

protected RegisteredMethods mouseEventMethods, keyEventMethods;

protected RegisteredMethods disposeMethods;

// messages to send if attached as an external vm

/**

static public final String ARGS_EDITOR_LOCATION = "--editor-location";

/**

static public final String ARGS_EXTERNAL = "--external";

static public final String ARGS_LOCATION = "--location";

static public final String ARGS_DISPLAY = "--display";

static public final String ARGS_BGCOLOR = "--bgcolor";

static public final String ARGS_PRESENT = "--present";

static public final String ARGS_EXCLUSIVE = "--exclusive";

static public final String ARGS_STOP_COLOR = "--stop-color";

static public final String ARGS_HIDE_STOP = "--hide-stop";

/**

static public final String ARGS_SKETCH_FOLDER = "--sketch-path";

/**

//static public final String EXTERNAL_QUIT = "__QUIT__";

static public final String EXTERNAL_STOP = "__STOP__";

/**

static public final String EXTERNAL_MOVE = "__MOVE__";

/** true if this sketch is being run by the PDE */

boolean external = false;

static final String ERROR_MIN_MAX =

"Cannot use min() or max() on an empty array.";

// during rev 0100 dev cycle, working on new threading model,

// but need to disable and go conservative with changes in order

// to get pdf and audio working properly first.

// for 0116, the CRUSTY_THREADS are being disabled to fix lots of bugs.

//static final boolean CRUSTY_THREADS = false; //true;

public void init() {

Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();

screenWidth = screen.width;

screenHeight = screen.height;

// send tab keys through to the PApplet

setFocusTraversalKeysEnabled(false);

millisOffset = System.currentTimeMillis();

finished = false; // just for clarity

// this will be cleared by draw() if it is not overridden

looping = true;

redraw = true; // draw this guy once

firstMouse = true;

// these need to be inited before setup

sizeMethods = new RegisteredMethods();

preMethods = new RegisteredMethods();

drawMethods = new RegisteredMethods();

postMethods = new RegisteredMethods();

mouseEventMethods = new RegisteredMethods();

keyEventMethods = new RegisteredMethods();

disposeMethods = new RegisteredMethods();

try {

getAppletContext();

online = true;

} catch (NullPointerException e) {

online = false;

}

try {

if (sketchPath == null) {

sketchPath = System.getProperty("user.dir");

}

} catch (Exception e) { } // may be a security problem

Dimension size = getSize();

if ((size.width != 0) && (size.height != 0)) {

// When this PApplet is embedded inside a Java application with other

// Component objects, its size() may already be set externally (perhaps

// by a LayoutManager). In this case, honor that size as the default.

// Size of the component is set, just create a renderer.

g = makeGraphics(size.width, size.height, getSketchRenderer(), null, true);

// This doesn't call setSize() or setPreferredSize() because the fact

// that a size was already set means that someone is already doing it.

} else {

// Set the default size, until the user specifies otherwise

this.defaultSize = true;

int w = getSketchWidth();

int h = getSketchHeight();

g = makeGraphics(w, h, getSketchRenderer(), null, true);

// Fire component resize event

setSize(w, h);

setPreferredSize(new Dimension(w, h));

}

width = g.width;

height = g.height;

addListeners();

// this is automatically called in applets

// though it's here for applications anyway

start();

}

public int getSketchWidth() {

return DEFAULT_WIDTH;

}

public int getSketchHeight() {

return DEFAULT_HEIGHT;

}

public String getSketchRenderer() {

return JAVA2D;

}

/**

public void start() {

// When running inside a browser, start() will be called when someone

// returns to a page containing this applet.

// http://dev.processing.org/bugs/show_bug.cgi?id=581

finished = false;

if (thread != null) return;

thread = new Thread(this, "Animation Thread");

thread.start();

}

/**

public void stop() {

// bringing this back for 0111, hoping it'll help opengl shutdown

finished = true; // why did i comment this out?

// don't run stop and disposers twice

if (thread == null) return;

thread = null;

// call to shut down renderer, in case it needs it (pdf does)

if (g != null) g.dispose();

// maybe this should be done earlier? might help ensure it gets called

// before the vm just craps out since 1.5 craps out so aggressively.

disposeMethods.handle();

}

/**

public void destroy() {

((PApplet)this).stop();

}

/**

//////////////////////////////////////////////////////////////

public class RegisteredMethods {

int count;

Object objects[];

Method methods[];

// convenience version for no args

public void handle() {

handle(new Object[] { });

}

public void handle(Object oargs[]) {

for (int i = 0; i < count; i++) {

try {

//System.out.println(objects[i] + " " + args);

methods[i].invoke(objects[i], oargs);

} catch (Exception e) {

e.printStackTrace();

}

}

}

public void add(Object object, Method method) {

if (objects == null) {

objects = new Object[5];

methods = new Method[5];

}

if (count == objects.length) {

objects = (Object[]) PApplet.expand(objects);

methods = (Method[]) PApplet.expand(methods);

}

objects[count] = object;

methods[count] = method;

count++;

}

/**

public void remove(Object object, Method method) {

int index = findIndex(object, method);

if (index != -1) {

// shift remaining methods by one to preserve ordering

count--;

for (int i = index; i < count; i++) {

objects[i] = objects[i+1];

methods[i] = methods[i+1];

}

// clean things out for the gc's sake

objects[count] = null;

methods[count] = null;

}

}

protected int findIndex(Object object, Method method) {

for (int i = 0; i < count; i++) {

if (objects[i] == object && methods[i].equals(method)) {

//objects[i].equals() might be overridden, so use == for safety

// since here we do care about actual object identity

//methods[i]==method is never true even for same method, so must use

// equals(), this should be safe because of object identity

return i;

}

}

return -1;

}

}

public void registerSize(Object o) {

Class<?> methodArgs[] = new Class[] { Integer.TYPE, Integer.TYPE };

registerWithArgs(sizeMethods, "size", o, methodArgs);

}

public void registerPre(Object o) {

registerNoArgs(preMethods, "pre", o);

}

public void registerDraw(Object o) {

registerNoArgs(drawMethods, "draw", o);

}

public void registerPost(Object o) {

registerNoArgs(postMethods, "post", o);

}

public void registerMouseEvent(Object o) {

Class<?> methodArgs[] = new Class[] { MouseEvent.class };

registerWithArgs(mouseEventMethods, "mouseEvent", o, methodArgs);

}

public void registerKeyEvent(Object o) {

Class<?> methodArgs[] = new Class[] { KeyEvent.class };

registerWithArgs(keyEventMethods, "keyEvent", o, methodArgs);

}

public void registerDispose(Object o) {

registerNoArgs(disposeMethods, "dispose", o);

}

protected void registerNoArgs(RegisteredMethods meth,

String name, Object o) {

Class<?> c = o.getClass();

try {

Method method = c.getMethod(name, new Class[] {});

meth.add(o, method);

} catch (NoSuchMethodException nsme) {

die("There is no public " + name + "() method in the class " +

o.getClass().getName());

} catch (Exception e) {

die("Could not register " + name + " + () for " + o, e);

}

}

protected void registerWithArgs(RegisteredMethods meth,

String name, Object o, Class<?> cargs[]) {

Class<?> c = o.getClass();

try {

Method method = c.getMethod(name, cargs);

meth.add(o, method);

} catch (NoSuchMethodException nsme) {

die("There is no public " + name + "() method in the class " +

o.getClass().getName());

} catch (Exception e) {

die("Could not register " + name + " + () for " + o, e);

}

}

public void unregisterSize(Object o) {

Class<?> methodArgs[] = new Class[] { Integer.TYPE, Integer.TYPE };

unregisterWithArgs(sizeMethods, "size", o, methodArgs);

}

public void unregisterPre(Object o) {

unregisterNoArgs(preMethods, "pre", o);

}

public void unregisterDraw(Object o) {

unregisterNoArgs(drawMethods, "draw", o);

}

public void unregisterPost(Object o) {

unregisterNoArgs(postMethods, "post", o);

}

public void unregisterMouseEvent(Object o) {

Class<?> methodArgs[] = new Class[] { MouseEvent.class };

unregisterWithArgs(mouseEventMethods, "mouseEvent", o, methodArgs);

}