Programming Assignment
The program will create a "mass" of jiggling amoebas. Each amoeba will be drawn as a ellipses of random size and location. After all the amoebas are placed initially, you will be able to drag a circle around the screen with the mouse.
Get Started
Under Eclipse, create a new project called Amoebas.
The Circle Class
Create a new class called Circle inside of the project
Make sure to select as its superclass, "JComponent".
Do not put the main function here.
Make sure you fully comment this code (to start you may well want to select "Generate Comments" when you build the class.
A Circle should have the following instance variables (fields):
selected - true if this circle has been clicked on
fill - Should the amoeba be solid or just an outline
offset - A Point that holds where the mouse was pressed. This is only for use when dragging
A Circle should have the following methods:
The Constructor
Constructor- Take in the x,y location for this object and the width,height of the object. It should optionally take in a "name" allowing you to name your circles.
The constructor should then "initialize the GUI element", half of the time, make this object filled in (and half of the time just outlined), half of the time, set the color to red (and half of the time blue). Additionally the constructor should "inform" java that a circle can listen to the mouse motion and dragged events.
public void paintComponent(Graphics graphics)
In order for an GUI object to "show up" on the screen Java needs to know what to do with it when it comes its time to "be drawn". The paintComponent method is invoked on ALL objects (which have been added to the main window (i.e., all Components)) by the GUI thread, whenever Java decides it is time to draw the objects (e.g., after a repaint is asked for).
This method should draw a circle (filled or hollow, as previously determined) on the "graphics" object.
public void mousePressed(MouseEvent event)
public void mouseDragged(MouseEvent event)
These are some of the last methods you should work on once you have all of your "amoebas" showing on the screen.
The functionality that we are looking for is to allow the user of the GUI to drag an object around the screen.
This can be accomplished by using the setLocation method (which is inherited from JComponent).
Note: for a more effective program, the dragged circle should be placed on top of the other circles.
All those other required Mouse Methods
We are simply going to "ignore" all the other mouse interaction (at least for this base requirements of this program). You should place comments inside the body of each method saying that the method has no use in your program.
Why can't we just remove those methods then? Answer: Because the mouse interfaces that we are implementing require them to be there... Even if they don't do anything.
The Main Program
Create a class called Main which sole purpose is to hold the main program.
The main method
The main method is a static method who merely exists to get the program running. Your main method should do the following:
create the GUI window (i.e., a JFrame),
create X circle objects and add them to the GUI window
start the jiggling
The Jiggler Class
(Or putting the jiggle where it matters)
Create a new class called Jiggler. This class should be a child (or sub) class of the Thread class. It should be in the same Project, and the same Package as the Circle class.
A Thread is a separate independent executing sub-program. We will be using our thread to "jiggle" the amoebas. The main program will also be in a thread, but that thread will end as soon as the main function ends. Finally the GUI windows, drawing, events, etc are all in their own threads.
The Jiggler class should keep track of the following information:
drawables - this should be an array (list) of our circles, but because we may draw other things in the future, do not make the type ArrayList, make it ArrayList
fps - this should be a Jlabel that will show the frames per second
spread_out - true/false if the program is pushing objects apart
The Jiggler should have at least the following methods:
The Constructor
Constructor- Take in a FPS label (created by the main program but stored here) and the list of drawables (circles) which were also created by the main program but need to be stored here.
The run method, "public void run()"
The run method is the main method of a thread. Interestingly enough a thread beings, not by directly calling something like: thread.run(), but by calling: thread.start()!
In this method, your code should loop forever!
Inside of this infinite loop, randomly set the location of each component (stored in some array/list) to a new location plus or minus 1 pixel in the X and Y directions.