processing.core
Class PApplet

java.lang.Object
  java.awt.Component
      java.awt.Container
          java.awt.Panel
              java.applet.Applet
                  processing.core.PApplet

All Implemented Interfaces:

java.awt.event.FocusListener, java.awt.event.KeyListener, java.awt.event.MouseListener, java.awt.event.MouseMotionListener, java.awt.image.ImageObserver, java.awt.MenuContainer, java.io.Serializable, java.lang.Runnable, java.util.EventListener, javax.accessibility.Accessible, PConstants

Direct Known Subclasses:

ColorSelector.ColorRange, ColorSelector.ColorSlider

public class PApplet
extends java.applet.Applet
implements PConstants, java.lang.Runnable, java.awt.event.MouseListener, java.awt.event.MouseMotionListener, java.awt.event.KeyListener, java.awt.event.FocusListener

Base class for all sketches that use processing.core.

Note that you should not use AWT or Swing components inside a Processing applet. The surface is made to automatically update itself, and will cause problems with redraw of components drawn above it. If you'd like to integrate other Java components, see below.

As of release 0145, Processing uses active mode rendering in all cases. All animation tasks happen on the "Processing Animation Thread". The setup() and draw() methods are handled by that thread, and events (like mouse movement and key presses, which are fired by the event dispatch thread or EDT) are queued to be (safely) handled at the end of draw(). For code that needs to run on the EDT, use SwingUtilities.invokeLater(). When doing so, be careful to synchronize between that code (since invokeLater() will make your code run from the EDT) and the Processing animation thread. Use of a callback function or the registerXxx() methods in PApplet can help ensure that your code doesn't do something naughty.

As of release 0136 of Processing, we have discontinued support for versions of Java prior to 1.5. We don't have enough people to support it, and for a project of our size, we should be focusing on the future, rather than working around legacy Java code. In addition, Java 1.5 gives us access to better timing facilities which will improve the steadiness of animation.

This class extends Applet instead of JApplet because 1) historically, we supported Java 1.1, which does not include Swing (without an additional, sizable, download), and 2) Swing is a bloated piece of crap. A Processing applet is a heavyweight AWT component, and can be used the same as any other AWT component, with or without Swing.

Similarly, Processing runs in a Frame and not a JFrame. However, there's nothing to prevent you from embedding a PApplet into a JFrame, it's just that the base version uses a regular AWT frame because there's simply no need for swing in that context. If people want to use Swing, they can embed themselves as they wish.

It is possible to use PApplet, along with core.jar in other projects. In addition to enabling you to use Java 1.5+ features with your sketch, this also allows you to embed a Processing drawing area into another Java application. This means you can use standard GUI controls with a Processing sketch. Because AWT and Swing GUI components cannot be used on top of a PApplet, you can instead embed the PApplet inside another GUI the way you would any other Component.

It is also possible to resize the Processing window by including frame.setResizable(true) inside your setup() method. Note that the Java method frame.setSize() will not work unless you first set the frame to be resizable.

Because the default animation thread will run at 60 frames per second, an embedded PApplet can make the parent sluggish. You can use frameRate() to make it update less often, or you can use noLoop() and loop() to disable and then re-enable looping. If you want to only update the sketch intermittently, use noLoop() inside setup(), and redraw() whenever the screen needs to be updated once (or loop() to re-enable the animation thread). The following example embeds a sketch and also uses the noLoop() and redraw() methods. You need not use noLoop() and redraw() when embedding if you want your application to animate continuously.

 public class ExampleFrame extends Frame {

     public ExampleFrame() {
         super("Embedded PApplet");

         setLayout(new BorderLayout());
         PApplet embed = new Embedded();
         add(embed, BorderLayout.CENTER);

         // important to call this whenever embedding a PApplet.
         // It ensures that the animation thread is started and
         // that other internal variables are properly set.
         embed.init();
     }
 }

 public class Embedded extends PApplet {

     public void setup() {
         // original setup code here ...
         size(400, 400);

         // prevent thread from starving everything else
         noLoop();
     }

     public void draw() {
         // drawing code goes here
     }

     public void mousePressed() {
         // do something based on mouse movement

         // update the screen (run draw once)
         redraw();
     }
 }
 

Processing on multiple displays

I was asked about Processing with multiple displays, and for lack of a better place to document it, things will go here.

You can address both screens by making a window the width of both, and the height of the maximum of both screens. In this case, do not use present mode, because that's exclusive to one screen. Basically it'll give you a PApplet that spans both screens. If using one half to control and the other half for graphics, you'd just have to put the 'live' stuff on one half of the canvas, the control stuff on the other. This works better in windows because on the mac we can't get rid of the menu bar unless it's running in present mode.

For more control, you need to write straight java code that uses p5. You can create two windows, that are shown on two separate screens, that have their own PApplet. this is just one of the tradeoffs of one of the things that we don't support in p5 from within the environment itself (we must draw the line somewhere), because of how messy it would get to start talking about multiple screens. It's also not that tough to do by hand w/ some Java code.

See Also:

Serialized Form

javaVersionName

public static final java.lang.String javaVersionName

Full name of the Java version (i.e. 1.5.0_11). Prior to 0125, this was only the first three digits.

javaVersion

public static final float javaVersion

Version of Java that's in use, whether 1.1 or 1.3 or whatever, stored as a float.

Note that because this is stored as a float, the values may not be exactly 1.3 or 1.4. Instead, make sure you're comparing against 1.3f or 1.4f, which will have the same amount of error (i.e. 1.40000001). This could just be a double, but since Processing only uses floats, it's safer for this to be a float because there's no good way to specify a double with the preproc.

platform

public static int platform

Current platform in use, one of the PConstants WINDOWS, MACOSX, MACOS9, LINUX or OTHER.

MENU_SHORTCUT

public static final int MENU_SHORTCUT

Modifier flags for the shortcut key used to trigger menus. (Cmd on Mac OS X, Ctrl on Linux and Windows)

g

public PGraphics g

The PGraphics renderer associated with this PApplet

frame

public java.awt.Frame frame

The frame containing this applet (if any)

screen

public java.awt.Dimension screen

The screen size when the applet was started.

Access this via screen.width and screen.height. To make an applet run at full screen, use size(screen.width, screen.height).

If you have multiple displays, this will be the size of the main display. Running full screen across multiple displays isn't particularly supported, and requires more monkeying with the values. This probably can't/won't be fixed until/unless I get a dual head system.

Note that this won't update if you change the resolution of your screen once the the applet is running.

This variable is not static, because future releases need to be better at handling multiple displays.

recorder

public PGraphics recorder

A leech graphics object that is echoing all events.

args

public java.lang.String[] args

Command line options passed in from main().

This does not include the arguments passed in to PApplet itself.

sketchPath

public java.lang.String sketchPath

Path to sketch folder

DEFAULT_WIDTH

public static final int DEFAULT_WIDTH

Default width and height for applet when not specified

See Also:

Constant Field Values

DEFAULT_HEIGHT

public static final int DEFAULT_HEIGHT

See Also:

Constant Field Values

MIN_WINDOW_WIDTH

public static final int MIN_WINDOW_WIDTH

Minimum dimensions for the window holding an applet. This varies between platforms, Mac OS X 10.3 can do any height but requires at least 128 pixels width. Windows XP has another set of limitations. And for all I know, Linux probably lets you make windows with negative sizes.

See Also:

Constant Field Values

MIN_WINDOW_HEIGHT

public static final int MIN_WINDOW_HEIGHT

See Also:

Constant Field Values

defaultSize

public boolean defaultSize

true if no size() command has been executed. This is used to wait until a size has been set before placing in the window and showing it.

pixels

public int[] pixels

Pixel buffer from this applet's PGraphics.

When used with OpenGL or Java2D, this value will be null until loadPixels() has been called.

width

public int width

width of this applet's associated PGraphics

height

public int height

height of this applet's associated PGraphics

mouseX

public int mouseX

current x position of the mouse

mouseY

public int mouseY

current y position of the mouse

pmouseX

public int pmouseX

Previous x/y position of the mouse. This will be a different value when inside a mouse handler (like the mouseMoved() method) versus when inside draw(). Inside draw(), pmouseX is updated once each frame, but inside mousePressed() and friends, it's updated each time an event comes through. Be sure to use only one or the other type of means for tracking pmouseX and pmouseY within your sketch, otherwise you're gonna run into trouble.

pmouseY

public int pmouseY

Previous x/y position of the mouse. This will be a different value when inside a mouse handler (like the mouseMoved() method) versus when inside draw(). Inside draw(), pmouseX is updated once each frame, but inside mousePressed() and friends, it's updated each time an event comes through. Be sure to use only one or the other type of means for tracking pmouseX and pmouseY within your sketch, otherwise you're gonna run into trouble.

firstMouse

public boolean firstMouse

Used to set pmouseX/Y to mouseX/Y the first time mouseX/Y are used, otherwise pmouseX/Y are always zero, causing a nasty jump.

Just using (frameCount == 0) won't work since mouseXxxxx() may not be called until a couple frames into things.

mouseButton

public int mouseButton

Last mouse button pressed, one of LEFT, CENTER, or RIGHT.

If running on Mac OS, a ctrl-click will be interpreted as the righthand mouse button (unlike Java, which reports it as the left mouse).

mousePressed

public boolean mousePressed

mouseEvent

public java.awt.event.MouseEvent mouseEvent

key

public char key

Last key pressed.

If it's a coded key, i.e. UP/DOWN/CTRL/SHIFT/ALT, this will be set to CODED (0xffff or 65535).

keyCode

public int keyCode

When "key" is set to CODED, this will contain a Java key code.

For the arrow keys, keyCode will be one of UP, DOWN, LEFT and RIGHT. Also available are ALT, CONTROL and SHIFT. A full set of constants can be obtained from java.awt.event.KeyEvent, from the VK_XXXX variables.

keyPressed

public boolean keyPressed

true if the mouse is currently pressed.

keyEvent

public java.awt.event.KeyEvent keyEvent

the last KeyEvent object passed into a mouse function.

focused

public boolean focused

Gets set to true/false as the applet gains/loses focus.

online

public boolean online

true if the applet is online.

This can be used to test how the applet should behave since online situations are different (no file writing, etc).

frameRate

public float frameRate

The current value of frames per second.

The initial value will be 10 fps, and will be updated with each frame thereafter. The value is not instantaneous (since that wouldn't be very useful since it would jump around so much), but is instead averaged (integrated) over several frames. As such, this value won't be valid until after 5-10 frames.

frameCount

public int frameCount

How many frames have been displayed since the applet started.

This value is read-only do not attempt to set it, otherwise bad things will happen.

Inside setup(), frameCount is 0. For the first iteration of draw(), frameCount will equal 1.

finished

public boolean finished

true if this applet has had it.

ARGS_EDITOR_LOCATION

public static final java.lang.String ARGS_EDITOR_LOCATION

Position of the upper-lefthand corner of the editor window that launched this applet.

See Also:

Constant Field Values

ARGS_EXTERNAL

public static final java.lang.String ARGS_EXTERNAL

Location for where to position the applet window on screen.

This is used by the editor to when saving the previous applet location, or could be used by other classes to launch at a specific position on-screen.

See Also:

Constant Field Values

ARGS_LOCATION

public static final java.lang.String ARGS_LOCATION

See Also:

Constant Field Values

ARGS_DISPLAY

public static final java.lang.String ARGS_DISPLAY

See Also:

Constant Field Values

ARGS_BGCOLOR

public static final java.lang.String ARGS_BGCOLOR

See Also:

Constant Field Values

ARGS_PRESENT

public static final java.lang.String ARGS_PRESENT

See Also:

Constant Field Values

ARGS_EXCLUSIVE

public static final java.lang.String ARGS_EXCLUSIVE

See Also:

Constant Field Values

ARGS_STOP_COLOR

public static final java.lang.String ARGS_STOP_COLOR

See Also:

Constant Field Values

ARGS_HIDE_STOP

public static final java.lang.String ARGS_HIDE_STOP

See Also:

Constant Field Values

ARGS_SKETCH_FOLDER

public static final java.lang.String ARGS_SKETCH_FOLDER

Allows the user or PdeEditor to set a specific sketch folder path.

Used by PdeEditor to pass in the location where saveFrame() and all that stuff should write things.

See Also:

Constant Field Values

EXTERNAL_STOP

public static final java.lang.String EXTERNAL_STOP

When run externally to a PdeEditor, this is sent by the applet when it quits.

See Also:

Constant Field Values

EXTERNAL_MOVE

public static final java.lang.String EXTERNAL_MOVE

When run externally to a PDE Editor, this is sent by the applet whenever the window is moved.

This is used so that the editor can re-open the sketch window in the same position as the user last left it.

See Also:

Constant Field Values

requestImageMax

public int requestImageMax

By trial and error, four image loading threads seem to work best when loading images from online. This is consistent with the number of open connections that web browsers will maintain. The variable is made public (however no accessor has been added since it's esoteric) if you really want to have control over the value used. For instance, when loading local files, it might be better to only have a single thread (or two) loading images so that you're disk isn't simply jumping around.

selectedFile

public java.io.File selectedFile

ICON_IMAGE

public static final byte[] ICON_IMAGE

GIF image of the Processing logo.

PApplet

public PApplet()

init

public void init()

Overrides:

init in class java.applet.Applet

getSketchWidth

public int getSketchWidth()

getSketchHeight

public int getSketchHeight()

getSketchRenderer

public java.lang.String getSketchRenderer()

start

public void start()

Called by the browser or applet viewer to inform this applet that it should start its execution. It is called after the init method and each time the applet is revisited in a Web page.

Called explicitly via the first call to PApplet.paint(), because PAppletGL needs to have a usable screen before getting things rolling.

Overrides:

start in class java.applet.Applet

stop

public void stop()

Called by the browser or applet viewer to inform this applet that it should stop its execution.

Unfortunately, there are no guarantees from the Java spec when or if stop() will be called (i.e. on browser quit, or when moving between web pages), and it's not always called.

Overrides:

stop in class java.applet.Applet

destroy

public void destroy()

Called by the browser or applet viewer to inform this applet that it is being reclaimed and that it should destroy any resources that it has allocated.

This also attempts to call PApplet.stop(), in case there was an inadvertent override of the stop() function by a user.

destroy() supposedly gets called as the applet viewer is shutting down the applet. stop() is called first, and then destroy() to really get rid of things. no guarantees on when they're run (on browser quit, or when moving between pages), though.

Overrides:

destroy in class java.applet.Applet

registerSize

public void registerSize(java.lang.Object o)

registerPre

public void registerPre(java.lang.Object o)

registerDraw

public void registerDraw(java.lang.Object o)

registerPost

public void registerPost(java.lang.Object o)

registerMouseEvent

public void registerMouseEvent(java.lang.Object o)

registerKeyEvent

public void registerKeyEvent(java.lang.Object o)

registerDispose

public void registerDispose(java.lang.Object o)

unregisterSize

public void unregisterSize(java.lang.Object o)

unregisterPre

public void unregisterPre(java.lang.Object o)

unregisterDraw

public void unregisterDraw(java.lang.Object o)

unregisterPost

public void unregisterPost(java.lang.Object o)

unregisterMouseEvent

public void unregisterMouseEvent(java.lang.Object o)

unregisterKeyEvent

public void unregisterKeyEvent(java.lang.Object o)

unregisterDispose

public void unregisterDispose(java.lang.Object o)

setup

public void setup()

draw

public void draw()

size

public void size(int iwidth,
                 int iheight)

Starts up and creates a two-dimensional drawing surface, or resizes the current drawing surface.

This should be the first thing called inside of setup().

If using Java 1.3 or later, this will default to using PGraphics2, the Java2D-based renderer. If using Java 1.1, or if PGraphics2 is not available, then PGraphics will be used. To set your own renderer, use the other version of the size() method that takes a renderer as its last parameter.

If called once a renderer has already been set, this will use the previous renderer and simply resize it.

size

public void size(int iwidth,
                 int iheight,
                 java.lang.String irenderer)

size

public void size(int iwidth,
                 int iheight,
                 java.lang.String irenderer,
                 java.lang.String ipath)

Creates a new PGraphics object and sets it to the specified size. Note that you cannot change the renderer once outside of setup(). In most cases, you can call size() to give it a new size, but you need to always ask for the same renderer, otherwise you're gonna run into trouble. The size() method should *only* be called from inside the setup() or draw() methods, so that it is properly run on the main animation thread. To change the size of a PApplet externally, use setSize(), which will update the component size, and queue a resize of the renderer as well.

createGraphics

public PGraphics createGraphics(int iwidth,
                                int iheight,
                                java.lang.String irenderer)

Create an offscreen PGraphics object for drawing. This can be used for bitmap or vector images drawing or rendering.

• Do not use "new PGraphicsXxxx()", use this method. This method ensures that internal variables are set up properly that tie the new graphics context back to its parent PApplet.
• The basic way to create bitmap images is to use the saveFrame() function.
• If you want to create a really large scene and write that, first make sure that you've allocated a lot of memory in the Preferences.
• If you want to create images that are larger than the screen, you should create your own PGraphics object, draw to that, and use save(). For now, it's best to use P3D in this scenario. P2D is currently disabled, and the JAVA2D default will give mixed results. An example of using P3D:

  
   PGraphics big;
  
   void setup() {
     big = createGraphics(3000, 3000, P3D);
  
     big.beginDraw();
     big.background(128);
     big.line(20, 1800, 1800, 900);
     // etc..
     big.endDraw();
  
     // make sure the file is written to the sketch folder
     big.save("big.tif");
   }
  
   

• It's important to always wrap drawing to createGraphics() with beginDraw() and endDraw() (beginFrame() and endFrame() prior to revision 0115). The reason is that the renderer needs to know when drawing has stopped, so that it can update itself internally. This also handles calling the defaults() method, for people familiar with that.
• It's not possible to use createGraphics() with the OPENGL renderer, because it doesn't allow offscreen use.
• With Processing 0115 and later, it's possible to write images in formats other than the default .tga and .tiff. The exact formats and background information can be found in the developer's reference for PImage.save().

createGraphics

public PGraphics createGraphics(int iwidth,
                                int iheight,
                                java.lang.String irenderer,
                                java.lang.String ipath)

Create an offscreen graphics surface for drawing, in this case for a renderer that writes to a file (such as PDF or DXF).

Parameters:

ipath - can be an absolute or relative path

createImage

public PImage createImage(int wide,
                          int high,
                          int format)

Preferred method of creating new PImage objects, ensures that a reference to the parent PApplet is included, which makes save() work without needing an absolute path.

update

public void update(java.awt.Graphics screen)

Overrides:

update in class java.awt.Container

paint

public void paint(java.awt.Graphics screen)

Overrides:

paint in class java.awt.Container

run

public void run()

Main method for the primary animation thread. Painting in AWT and Swing

Specified by:

run in interface java.lang.Runnable

handleDraw

public void handleDraw()

redraw

public void redraw()

loop

public void loop()

noLoop

public void noLoop()

addListeners

public void addListeners()

mousePressed

public void mousePressed(java.awt.event.MouseEvent e)

If you override this or any function that takes a "MouseEvent e" without calling its super.mouseXxxx() then mouseX, mouseY, mousePressed, and mouseEvent will no longer be set.

Specified by:

mousePressed in interface java.awt.event.MouseListener

mouseReleased

public void mouseReleased(java.awt.event.MouseEvent e)

Specified by:

mouseReleased in interface java.awt.event.MouseListener

mouseClicked

public void mouseClicked(java.awt.event.MouseEvent e)

Specified by:

mouseClicked in interface java.awt.event.MouseListener

mouseEntered

public void mouseEntered(java.awt.event.MouseEvent e)

Specified by:

mouseEntered in interface java.awt.event.MouseListener

mouseExited

public void mouseExited(java.awt.event.MouseEvent e)

Specified by:

mouseExited in interface java.awt.event.MouseListener

mouseDragged

public void mouseDragged(java.awt.event.MouseEvent e)

Specified by:

mouseDragged in interface java.awt.event.MouseMotionListener

mouseMoved

public void mouseMoved(java.awt.event.MouseEvent e)

Specified by:

mouseMoved in interface java.awt.event.MouseMotionListener

mousePressed

public void mousePressed()

Mouse has been pressed, and should be considered "down" until mouseReleased() is called. If you must, use int button = mouseEvent.getButton(); to figure out which button was clicked. It will be one of: MouseEvent.BUTTON1, MouseEvent.BUTTON2, MouseEvent.BUTTON3 Note, however, that this is completely inconsistent across platforms.

mouseReleased

public void mouseReleased()

Mouse button has been released.

mouseClicked

public void mouseClicked()

When the mouse is clicked, mousePressed() will be called, then mouseReleased(), then mouseClicked(). Note that mousePressed is already false inside of mouseClicked().

mouseDragged

public void mouseDragged()

Mouse button is pressed and the mouse has been dragged.

mouseMoved

public void mouseMoved()

Mouse button is not pressed but the mouse has changed locations.

keyPressed

public void keyPressed(java.awt.event.KeyEvent e)

Overriding keyXxxxx(KeyEvent e) functions will cause the 'key', 'keyCode', and 'keyEvent' variables to no longer work; key events will no longer be queued until the end of draw(); and the keyPressed(), keyReleased() and keyTyped() methods will no longer be called.

Specified by:

keyPressed in interface java.awt.event.KeyListener

keyReleased

public void keyReleased(java.awt.event.KeyEvent e)

Specified by:

keyReleased in interface java.awt.event.KeyListener

keyTyped

public void keyTyped(java.awt.event.KeyEvent e)

Specified by:

keyTyped in interface java.awt.event.KeyListener

keyPressed

public void keyPressed()

Called each time a single key on the keyboard is pressed. Because of how operating systems handle key repeats, holding down a key will cause multiple calls to keyPressed(), because the OS repeat takes over.

Examples for key handling: (Tested on Windows XP, please notify if different on other platforms, I have a feeling Mac OS and Linux may do otherwise)

 1. Pressing 'a' on the keyboard:
    keyPressed  with key == 'a' and keyCode == 'A'
    keyTyped    with key == 'a' and keyCode ==  0
    keyReleased with key == 'a' and keyCode == 'A'

 2. Pressing 'A' on the keyboard:
    keyPressed  with key == 'A' and keyCode == 'A'
    keyTyped    with key == 'A' and keyCode ==  0
    keyReleased with key == 'A' and keyCode == 'A'

 3. Pressing 'shift', then 'a' on the keyboard (caps lock is off):
    keyPressed  with key == CODED and keyCode == SHIFT
    keyPressed  with key == 'A'   and keyCode == 'A'
    keyTyped    with key == 'A'   and keyCode == 0
    keyReleased with key == 'A'   and keyCode == 'A'
    keyReleased with key == CODED and keyCode == SHIFT

 4. Holding down the 'a' key.
    The following will happen several times,
    depending on your machine's "key repeat rate" settings:
    keyPressed  with key == 'a' and keyCode == 'A'
    keyTyped    with key == 'a' and keyCode ==  0
    When you finally let go, you'll get:
    keyReleased with key == 'a' and keyCode == 'A'

 5. Pressing and releasing the 'shift' key
    keyPressed  with key == CODED and keyCode == SHIFT
    keyReleased with key == CODED and keyCode == SHIFT
    (note there is no keyTyped)

 6. Pressing the tab key in an applet with Java 1.4 will
    normally do nothing, but PApplet dynamically shuts
    this behavior off if Java 1.4 is in use (tested 1.4.2_05 Windows).
    Java 1.1 (Microsoft VM) passes the TAB key through normally.
    Not tested on other platforms or for 1.3.
 

keyReleased

public void keyReleased()

See keyPressed().

keyTyped

public void keyTyped()

Only called for "regular" keys like letters, see keyPressed() for full documentation.

focusGained

public void focusGained()

focusGained

public void focusGained(java.awt.event.FocusEvent e)

Specified by:

focusGained in interface java.awt.event.FocusListener

focusLost

public void focusLost()

focusLost

public void focusLost(java.awt.event.FocusEvent e)

Specified by:

focusLost in interface java.awt.event.FocusListener

millis

public int millis()

Get the number of milliseconds since the applet started.

This is a function, rather than a variable, because it may change multiple times per frame.

second

public static int second()

Seconds position of the current time.

minute

public static int minute()

Minutes position of the current time.

hour

public static int hour()

Hour position of the current time in international format (0-23).

To convert this value to American time:

int yankeeHour = (hour() % 12);
 if (yankeeHour == 0) yankeeHour = 12;

day

public static int day()

Get the current day of the month (1 through 31).

If you're looking for the day of the week (M-F or whatever) or day of the year (1..365) then use java's Calendar.get()

month

public static int month()

Get the current month in range 1 through 12.

year

public static int year()

Get the current year.

delay

public void delay(int napTime)

The delay() function causes the program to halt for a specified time. Delay times are specified in thousandths of a second. For example, running delay(3000) will stop the program for three seconds and delay(500) will stop the program for a half-second. Remember: the display window is updated only at the end of draw(), so putting more than one delay() inside draw() will simply add them together and the new frame will be drawn when the total delay is over.

I'm not sure if this is even helpful anymore, as the screen isn't updated before or after the delay, meaning which means it just makes the app lock up temporarily.

frameRate

public void frameRate(float newRateTarget)

Set a target frameRate. This will cause delay() to be called after each frame so that the sketch synchronizes to a particular speed. Note that this only sets the maximum frame rate, it cannot be used to make a slow sketch go faster. Sketches have no default frame rate setting, and will attempt to use maximum processor power to achieve maximum speed.

param

public java.lang.String param(java.lang.String what)

Get a param from the web page, or (eventually) from a properties file.

status

public void status(java.lang.String what)

Show status in the status bar of a web browser, or in the System.out console. Eventually this might show status in the p5 environment itself, rather than relying on the console.

link

public void link(java.lang.String here)

link

public void link(java.lang.String url,
                 java.lang.String frameTitle)

Link to an external page without all the muss.

When run with an applet, uses the browser to open the url, for applications, attempts to launch a browser with the url.

Works on Mac OS X and Windows. For Linux, use:

open(new String[] { "firefox", url });

or whatever you want as your browser, since Linux doesn't yet have a standard method for launching URLs.

open

public static void open(java.lang.String filename)

Attempt to open a file using the platform's shell.

open

public static java.lang.Process open(java.lang.String[] argv)

Launch a process using a platforms shell. This version uses an array to make it easier to deal with spaces in the individual elements. (This avoids the situation of trying to put single or double quotes around different bits).

exec

public static java.lang.Process exec(java.lang.String[] argv)

die

public void die(java.lang.String what)

Function for an applet/application to kill itself and display an error. Mostly this is here to be improved later.

die

public void die(java.lang.String what,
                java.lang.Exception e)

Same as above but with an exception. Also needs work.

exit

public void exit()

Call to safely exit the sketch when finished. For instance, to render a single frame, save it, and quit.

save

public void save(java.lang.String filename)

Intercepts any relative paths to make them absolute (relative to the sketch folder) before passing to save() in PImage. (Changed in 0100)

saveFrame

public void saveFrame()

Grab an image of what's currently in the drawing area and save it as a .tif or .tga file.

Best used just before endDraw() at the end of your draw(). This can only create .tif or .tga images, so if neither extension is specified it defaults to writing a tiff and adds a .tif suffix.

saveFrame

public void saveFrame(java.lang.String what)

Save the current frame as a .tif or .tga image.

The String passed in can contain a series of # signs that will be replaced with the screengrab number.

 i.e. saveFrame("blah-####.tif");
      // saves a numbered tiff image, replacing the
      // #### signs with zeros and the frame number 

cursor

public void cursor(int cursorType)

Set the cursor type

cursor

public void cursor(PImage image)

Replace the cursor with the specified PImage. The x- and y- coordinate of the center will be the center of the image.

cursor

public void cursor(PImage image,
                   int hotspotX,
                   int hotspotY)

Set a custom cursor to an image with a specific hotspot. Only works with JDK 1.2 and later. Currently seems to be broken on Java 1.4 for Mac OS X

Based on code contributed by Amit Pitaru, plus additional code to handle Java versions via reflection by Jonathan Feinberg. Reflection removed for release 0128 and later.

cursor

public void cursor()

Show the cursor after noCursor() was called. Notice that the program remembers the last set cursor type

noCursor

public void noCursor()

Hide the cursor by creating a transparent image and using it as a custom cursor.

print

public static void print(byte what)

print

public static void print(boolean what)

print

public static void print(char what)

print

public static void print(int what)

print

public static void print(float what)

print

public static void print(java.lang.String what)

print

public static void print(java.lang.Object what)