Thom Nichols


Technology is evolution outside the gene pool

Groovy and! is a cool little thing; you can't look at two or three of the demos on their site before you realize it's really neat.  Not to mention it's designed as a compliment to Wiring, the language used to program the Arduino and a number of other DIY hardware platforms. 

So suffice to say, Processing is a compelling alternative to Flash for at least a handful of usage scenarios.  So what if you're a Java/ Groovy programmer who wants access to Processing's coolness, without using their cute IDE?  We're Java programmers after all; if I can't use Eclipse and integrate it with Hibernate and Spring -- well, that would be overkill.  But let's just get to the point: you can use straight from your Java environment.  In fact, here's their JavaDoc.

But, the Processing language is actually kinda nice!  And if you look at all of those functions that Processing provides, they're all in the PApplet class.  Well that's a pain in the ass.  Never fear -- that's where Groovy steps in.  You can use Groovy's language features to Make Processing's API at least as easy to use, and you get all of the cool features of the Groovy language as well!

Enough rambling -- here's an example:

import processing.core.*

 * A group of dots appear and then shrink in size.
 * This sketch uses the Groovy List and uses a second class SpriteEllipse.
 * This main extends PApplet so it can create the window.
class CirclesDemo extends PApplet {

  // setup vars
  def sprites = []
  def renderer = JAVA2D // P2D

  // state
  int nCount = -1
  def animating = true
  int clickX, clickY = 0
  void setup() {
    ellipseMode CENTER
    size 400, 400, renderer
    frameRate 20
    textFont loadFont("TrebuchetMS-20.vlw"), 14
  void draw() {
    background 120
    nCount %= 90 // add additional sprites every so often:
    if ( ! nCount ) (1..20).each {
      sprites &lt;< new SpriteEllipse( this ) 

    def clicked
    sprites.each { s ->
      if ( s.dead ) s.init()
      else if ( clickX &amp;& s.isOver( clickX, clickY ) ) clicked = s
    if ( clicked ) sprites.remove clicked
    clickX = 0
    fill 255 // set text color
    text sprites.size(), 5, height-5 // update sprite count display
  void keyPressed() {
    if ( key == ' ' &amp;& animating ) { noLoop(); animating = false }
    else { loop(); animating = true }
  void mouseClicked() { // get mouse click pos for next draw() call.
    this.clickX = mouseX
    this.clickY = mouseY
//    println " $clickX $clickY"
  static void main(args) {
    PApplet.main( [ "CirclesDemo" ] as String[] );

Now the 'SpriteEllipse' class really could just be rolled up into the above class -- since its functionality all comes from the PApplet anyway. But in Groovy you can easily separate the functionality into a separate class and use Groovy's @Delegate to make it appear that SpriteEllipse extends PApplet.

import processing.core.PApplet

class SpriteEllipse {
  private Float x = 0
  private Float y = 0
  private Float rad = 75
  private Integer color = 20
  private @Delegate PApplet pApplet
  SpriteEllipse(PApplet pApplet) {
    this.pApplet = pApplet // must be set first since it is delegate
  void init() {  /* Initialize fields to random vals */
    this.x = random( 0, width )
    this.y = random( 0, height )
    this.rad = random( (int)( height*0.05 ), (int)( height*0.225 ) )
    this.color = random( 0, 255 )    
  void update() { if ( this.rad ) rad-- }
  void render() {
    fill color
    ellipse x, y, rad, rad

  boolean isOver(int mx, int my) {
    (mx-x)*(mx-x) + (my-y)*(my-y) &lt; rad*rad;
  boolean isDead() { return rad &lt; 1 }  

The full code is up on GitHub. This is a modified version of this guy's work, so he deserves most of the credit. Actually now that I look back at his example, about the only thing I did was make use of the @Delegate feature :)