Processing with objects

The idea

In this lab we are going to design an class representing a pumpkin and use it with the Processing PApplet to design a spooky application. We are not going to use the Processing IDE in this assignment, though I don’t see any reason why this could not be done with Processing by a determined person.

A couple of Processing caveats

Processing programs are transformed into Java before being interpreted by the Java Virtual Machine. (Interpretation by JavaScript is also possible.) However, Processing IDE does a few significant syntactic transformations before passing the code on to Java which surprise experienced programmers.

In Java the literal 3.14 is of type double. But, when the Processing IDE sees 3.14, it transforms 3.14 into a float, in particular 3.14f . Many of the arguments to PApplet methods, such as ellipse, are float’s. In the Processing IDE you can invoke the ellipse method as ellipse(5.0, 5.0, 5.0, 5.0) ; but, if you try this in Java, the compiler will report a compilation error because you are passing a double argument to a float parameter. However, ellipse(5.0f, 5.0f, 5.0f, 5.0f) or even ellipse(5, 5, 5, 5) work fine.

Processing allows literals, such as #FFA500, to be used as colors. While this syntax is familiar to HTML coders, it is not part of the Java standard, In Java, you need to use 0xFFFFA500 in this situation. (The extra FF is the alpha value for the color.) By the way, Processing colors are really just 32-bit int values.

Processing allows some type names, such as int, to be used a prefix operators for converting data types. This means that int(3.14) is 3 in Processing. In Java, int(3.14) is a syntax error. You need to use the more traditional C/C++/Java casting operators, for example (int)(3.14).

Finally, be warned that the PApplet class has lots of public fields and that you will be using them in your program. Because public fields are discouraged in object-oriented programming, you may find this to be a little disconcerting.

Getting started

In this section, we show you how to get Java working with Processing libraries.

Getting the library

Before starting you will need to download the Processing system to get a copy of the Processing library. Be sure to remember where you installed Processing.

This step should not to be done in the RRO223 lab.

Starting the sketch

Next, you need a class that starts the Processing “sketch.” The main method of this class must call the main method of the PApplet class with the name of your sketch. I suggest you accomplish this with a class that performs only this single activity, as shown in the following example:

package edu.unca.cs.csci202;

import processing.core.* ;
// add core.java in the core/library subdirectory of processing

public class Boo {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        PApplet.main(new String[]{"edu.unca.cs.csci202.Halloween"}) ;
    }
}

NetBeans will complain that it has no knowledge of the processing classes. To fix this problem go to the Properties tab for NetBeans and right-click on your project’s name. This will raise a Projects window. Go to the Libraries category and add a jar file core.jar that contains the needed Processing libraries. This library file is located in the core/library subdirectory of your Processing distribution. If you want to distribute your system, you should copy this library into your project’s src folder.

Writing the sketch

Your sketch is similar to an ordinary Processing sketch but it must follow the class syntax of Java, and it must extend PApplet. Also, the name of your class, prefixed with its package name, must match the String passed to PApplet.main in your launcher program. In our preceding example that was "edu.unca.cs.csci202.Halloween" .

Here is a class that satisfies these requirements.

package edu.unca.cs.csci202;

import processing.core.* ;

public class Halloween extends PApplet{
    int pumpkinXPosition ; 
    
    @Override
    public void setup() {
        size(800, 600) ;
        pumpkinXPosition = 0 ;
    }
    
    @Override
    public void draw() {
        clear() ;
        fill(255, 165, 0) ;                   // fill(0xFFFFA500) ;
        ++pumpkinXPosition ;
        if (pumpkinXPosition==width) {        // width is a public field of PApplet
            pumpkinXPosition=0 ;
        }
        ellipse(pumpkinXPosition, height/2, width/8, height/8) ;
    }
}

Doing OOP

Let’s get you started in adding some objects to your program. Do this by creating a Pumpkin class that represents a pumpkin. The Pumpkin class should “know” its position and size. Later it may even learn a little about its eye color and the direction in which it is moving.

Once the Pumpkin knows who to keep up with itself, we can create many Pumpkin’s and leave the details of being a pumpkin to a Pumpkin.

Making a model of the pumpkin

Create a new class called Pumpkin in your project. At a minimum, do the following:

• Create private float fields x, y, width, and height for your Pumpkin class.
• Create appropriate accessor and mutator methods for these four fields.
• Create a method draw that takes a single parameter, a Processing.core.PApplet object. The draw method will use the methods of PApplet to draw a pumpkin centered at x and y.

If you want to make absoultely sure you have the right methods; you can start with an outline of a Pumpkin class, or you can place a ProcessingDrawable2D interface in your project and add implements ProcessingDrawable2D to the header of your own Pumpkin class.

Now the class provides a model of a pumpkin.

Using the pumpkin model

The ultimate result of this next effort will look unimpressive, but it will start the objectification of our pumpkin: We are going to use an instance of the Pumpkin class in our Halloween sketch class.

Making and using a view of the pumpkin

It would be very tedious to call ellipse with all those arguments every time we need to draw a pumpkin. We are going to give Pumpkin the responsibility of drawing itself. It particular, we are going to make the draw method provide a view of the pumpkin.

In a real application of the Model-View-Controller (MVC) paradigm, the view would be handled by a separate class; but that just seems a big too much for our pumpkin. We are just going to assign this task to the draw method of Pumpkin.

There is one twist to this. Normally, Processing sketches are extensions of the PApplet class. This means that a call such as fill(255, 165, 0) is really an invocation of a method of the PApplet superclass, in particular super.fill(255, 165, 0).

Halloween is a subclass of PApplet, but Pumpkin is not; so super.fill is not available. This means you’ll need method calls like pa.fill(255, 165, 0) inside your Pumpkin draw method.

Getting fancy

Improving the view

More pumpkins

Saving the environment

Your program is probably making many side effects on PApplet’s environment. It is certainly changing the fill color, and it may be modifying more obscure settings like the color mode and ellipse mode.

I started my draw method with a few statements to save these settings.

    public void draw(processing.core.PApplet pa) {
        int oldColorMode = pa.g.colorMode ;
        int oldEllipseMode = pa.g.ellipseMode ;
        boolean oldFill = pa.g.fill ;
        int oldFillColor = pa.g.fillColor ;

And I ended my draw with a few statements to restore these settings.

        pa.g.fillColor = oldFillColor ;
        pa.g.fill = oldFill ;
        pa.g.ellipseMode = oldEllipseMode ;
        pa.g.colorMode = oldColorMode ;
    }

Swapping pumpkins

If you have created the suggested set of methods for the pumpkin, you should be able to drop your Pumpkin into someone else’s project.

Adding control

Right now our MVC implementation doesn’t have much C (control). We could ask the Halloween class to provide control by adding variables to keep up with, for example, trajectory information to each Pumpkin. Alternatively, we could add trajectory to each pumpkin. This might (or should) be done in new classes of pumpkins created by extension or aggregation.