hi guys,
im trying to implement the following into my java app code:
Here's my code: first ill post the main class, then the animation panel class, then moving shape and moving rectangle class...the additional files like the shape gif and path gifs are here, youll also find all the info need in here and the code files:
here's the main
/*
* =============================================================
* A1.java : Extends JApplet and contains a panel where
* shapes move around on the screen. Also contains start and stop
* buttons that starts animation and stops animation respectively.
* ==============================================================
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import javax.swing.event.*;
import java.util.Vector;
public class A1 extends JApplet {
AnimationPanel panel; // panel for bouncing area
JButton startButton, stopButton; //buttons to start and stop the animation
/** main method for A1
*/
public static void main(String[] args) {
A1 applet = new A1();
JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().add(applet, BorderLayout.CENTER);
frame.setTitle("Bouncing Application");
applet.init();
applet.start();
frame.setSize(500, 500);
Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = frame.getSize();
frame.setLocation((d.width - frameSize.width) / 2, (d.height - frameSize.height) / 2);
frame.setVisible(true);
}
/** init method to initialise components
*/
public void init() {
panel = new AnimationPanel();
add(panel, BorderLayout.CENTER);
add(setUpToolsPanel(), BorderLayout.NORTH);
add(setUpButtons(), BorderLayout.SOUTH);
addComponentListener(
new ComponentAdapter() { // resize the frame and reset all margins for all shapes
public void componentResized(ComponentEvent componentEvent) {
panel.resetMarginSize();
}
});
}
/** Set up the tools panel
* @return toolsPanel the Panel
*/
public JPanel setUpToolsPanel() {
//Set up the shape combo box
ImageIcon rectangleButtonIcon = createImageIcon("rectangle.gif");
JComboBox<ImageIcon> shapesComboBox = new JComboBox<ImageIcon>(new ImageIcon[] {rectangleButtonIcon} );
shapesComboBox.setToolTipText("Set shape");
shapesComboBox.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
JComboBox cb = (JComboBox)e.getSource();
//set the default shape type based on the selection: 0 for Circle, 1 for Rectangle
panel.setCurrentShapeType(cb.getSelectedIndex());
}
});
//Set up the path combo box
ImageIcon fallingButtonIcon = createImageIcon("falling.gif");
ImageIcon boundaryButtonIcon = createImageIcon("boundary.gif");
JComboBox<ImageIcon> pathComboBox = new JComboBox<ImageIcon>(new ImageIcon[] {boundaryButtonIcon, fallingButtonIcon});
pathComboBox.setToolTipText("Set Path");
pathComboBox.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
JComboBox cb = (JComboBox)e.getSource();
//set the default path type based on the selection from combo box: 0 for Boundary Path, 1 for Falling Path
panel.setCurrentPathType(cb.getSelectedIndex());
}
});
//Set up the height TextField
JTextField heightTxt = new JTextField("20");
heightTxt.setToolTipText("Set Height");
heightTxt.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
JTextField tf = (JTextField)e.getSource();
try {
int newValue = Integer.parseInt(tf.getText());
if (newValue > 0)
panel.setCurrentHeight(newValue);
} catch (Exception ex) {
tf.setText("20");
}
}
});
//Set up the width TextField
JTextField widthTxt = new JTextField("20");
widthTxt.setToolTipText("Set Width");
widthTxt.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
JTextField tf = (JTextField)e.getSource();
try {
int newValue = Integer.parseInt(tf.getText());
if (newValue > 0)
panel.setCurrentWidth(newValue);
} catch (Exception ex) {
tf.setText("20");
}
}
});
JPanel toolsPanel = new JPanel(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.weightx=1;
add(toolsPanel, new JLabel(" Shape: ", JLabel.RIGHT), gbc, 0, 0, 1, 1);
add(toolsPanel, shapesComboBox, gbc, 1, 0, 1, 1);
add(toolsPanel, new JLabel(" Path: ", JLabel.RIGHT), gbc, 2, 0, 1, 1);
add(toolsPanel, pathComboBox, gbc, 3, 0, 1, 1);
add(toolsPanel, new JLabel(" Height: ", JLabel.RIGHT), gbc, 4, 0, 1, 1);
add(toolsPanel, heightTxt, gbc, 5, 0, 1, 1);
add(toolsPanel, new JLabel(" Width: ", JLabel.RIGHT), gbc, 6, 0, 1, 1);
add(toolsPanel, widthTxt, gbc, 7, 0, 1, 1);
return toolsPanel;
}
/** Set up the buttons panel
* @return buttonPanel the Panel
*/
public JPanel setUpButtons() {
JPanel buttonPanel= new JPanel(new FlowLayout());
//Set up the start button
startButton = new JButton("Start");
startButton.setToolTipText("Start Animation");
startButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
startButton.setEnabled(false);
stopButton.setEnabled(true);
panel.start(); //start the animation
}
});
//Set up the stop button
stopButton = new JButton("Stop");
stopButton.setToolTipText("Stop Animation");
stopButton.setEnabled(false);
stopButton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e) {
stopButton.setEnabled(false);
startButton.setEnabled(true); //stop the animation
panel.stop();
}
});
// Slider to adjust the speed of the animation
JSlider slider = new JSlider(JSlider.HORIZONTAL, 0, 200, 30);
slider.setToolTipText("Adjust Speed");
slider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
JSlider source = (JSlider)e.getSource();
if (!source.getValueIsAdjusting()) {
int value = (int) (source.getValue()); // get the value from slider
TitledBorder tb = (TitledBorder) source.getBorder();
tb.setTitle("Anim delay = " + String.valueOf(value) + " ms"); //adjust the tilted border to indicate the speed of the animation
panel.adjustSpeed(value); //set the speed
source.repaint();
}
}
});
TitledBorder title = BorderFactory.createTitledBorder("Anim delay = 30 ms");
slider.setBorder(title);
// Add buttons and slider control
buttonPanel.add(startButton);
buttonPanel.add(stopButton);
buttonPanel.add(slider);
return buttonPanel;
}
/** create the imageIcon
* @param filename the filename of the image
* @return ImageIcon the imageIcon
*/
protected static ImageIcon createImageIcon(String filename) {
java.net.URL imgURL = A1.class.getResource(filename);
return new ImageIcon(imgURL);
}
/** Adds a component to a Panel.
@param p is the panel
@param c is the component to add
@param gbc the grid bag constraints
@param x the grid bag column
@param y the grid bag row
@param w the number of grid bag columns spanned
@param h the number of grid bag rows spanned
*/
private void add(JPanel p, Component c, GridBagConstraints gbc, int x, int y, int w, int h) {
gbc.gridx = x;
gbc.gridy = y;
gbc.gridwidth = w;
gbc.gridheight = h;
p.add(c, gbc);
}
}
Here's the Animation panel class:
/*
* ======================================================================
* AnimationPanel.java : Moves shapes around on the screen according to different paths.
* It is the main drawing area where shapes are added and manipulated.
* It also contains a popup menu to clear all shapes.
* ======================================================================
*/
import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
public class AnimationPanel extends JComponent implements Runnable {
private Thread animationThread = null; // the thread for animation
private ArrayList<MovingShape> shapes; // the arraylist to store all shapes
private int currentShapeType, // the current shape type
currentPath, // the current path type
currentWidth = 20, // the current width of a shape
currentHeight = 20; // the current height of a shape
private int delay = 30; // the current animation speed
JPopupMenu popup; // popup menu
/** Constructor of the AnimationPanel
*/
public AnimationPanel() {
shapes = new ArrayList<MovingShape>(); //create the vector to store shapes
popup = new JPopupMenu(); //create the popup menu
makePopupMenu();
// add the mouse event to handle popup menu and create new shape
addMouseListener( new MouseAdapter() {
public void mousePressed(MouseEvent e) {
maybeShowPopup(e);
}
public void mouseReleased(MouseEvent e) {
maybeShowPopup(e);
}
private void maybeShowPopup(MouseEvent e) {
if (e.isPopupTrigger()) {
popup.show(e.getComponent(), e.getX(), e.getY());
}
}
public void mouseClicked( MouseEvent e ) {
if (animationThread != null) { // if the animation has started, then
boolean found = false;
MovingShape currentShape = null;
for (int i = 0; i < shapes.size(); i++) {
currentShape = shapes.get(i);
if ( currentShape.contains( e.getPoint()) ) { // if the mousepoint is within a shape, then set the shape to be selected/deselected
found = true;
currentShape.setSelected( ! currentShape.isSelected() );
System.out.println(currentShape);
}
}
if (! found) createNewShape(e.getX(), e.getY()); // if the mousepoint is not within a shape, then create a new one according to the mouse position
}
}
});
}
/** create a new shape
* @param x the x-coordinate of the mouse position
* @param y the y-coordinate of the mouse position
*/
protected void createNewShape(int x, int y) {
// get the margin of the frame
Insets insets = getInsets();
int marginWidth = getWidth() - insets.left - insets.right;
int marginHeight = getHeight() - insets.top - insets.bottom;
// create a new shape dependent on all current properties and the mouse position
switch (currentShapeType) {
case 0: { //rectnage
shapes.add( new MovingRectangle(x, y, currentWidth, currentHeight, marginWidth, marginHeight, currentPath));
break;
}
}
}
/** set the current shape type
* @param s the new shape type
*/
public void setCurrentShapeType(int s) {
currentShapeType = s;
}
/** set the current path type and the path type for all currently selected shapes
* @param t the new path type
*/
public void setCurrentPathType(int t) {
currentPath = t;
MovingShape currentShape = null;
for (int i = 0; i < shapes.size(); i++) {
currentShape = shapes.get(i);
if ( currentShape.isSelected()) {
currentShape.setPath(currentPath);
}
}
}
/** set the current width and the width for all currently selected shapes
* @param w the new width value
*/
public void setCurrentWidth(int w) {
MovingShape currentShape = null;
currentWidth = w;
for (int i = 0; i < shapes.size(); i++) {
currentShape = shapes.get(i);
if ( currentShape.isSelected()) {
currentShape.setWidth(currentWidth);
}
}
}
/** set the current height and the height for all currently selected shapes
* @param h the new height value
*/
public void setCurrentHeight(int h) {
MovingShape currentShape = null;
currentHeight = h;
for (int i = 0; i < shapes.size(); i++) {
currentShape = shapes.get(i);
if ( currentShape.isSelected()) {
currentShape.setHeight(currentHeight);
}
}
}
/** remove all shapes from our vector
*/
public void clearAllShapes() {
shapes.clear();
}
// you don't need to make any changes after this line ______________
/** create the popup menu for our animation program
*/
protected void makePopupMenu() {
JMenuItem menuItem;
// clear all
menuItem = new JMenuItem("Clear All");
menuItem.addActionListener( new ActionListener() {
public void actionPerformed(ActionEvent e) {
clearAllShapes();
}
});
popup.add(menuItem);
}
/** reset the margin size of all shapes from our vector
*/
public void resetMarginSize() {
Insets insets = getInsets();
int marginWidth = getWidth() - insets.left - insets.right;
int marginHeight = getHeight() - insets.top - insets.bottom ;
for (int i = 0; i < shapes.size(); i++)
( shapes.get(i)).setMarginSize(marginWidth, marginHeight);
}
/** update the painting area
* @param g the graphics control
*/
public void update(Graphics g){
paint(g);
}
/** move and paint all shapes within the animation area
* @param g the Graphics control
*/
public void paintComponent(Graphics g) {
MovingShape currentShape;
for (int i = 0; i < shapes.size(); i++) {
currentShape = shapes.get(i);
currentShape.move();
currentShape.draw(g);
}
}
/** change the speed of the animation
* @param newValue the speed of the animation in ms
*/
public void adjustSpeed(int newValue) {
if (animationThread != null) {
stop();
delay = newValue;
start();
}
}
/** When the "start" button is pressed, start the thread
*/
public void start() {
animationThread = new Thread(this);
animationThread.start();
}
/** When the "stop" button is pressed, stop the thread
*/
public void stop() {
if (animationThread != null) {
animationThread = null;
}
}
/** run the animation
*/
public void run() {
Thread myThread = Thread.currentThread();
while(animationThread==myThread) {
repaint();
pause(delay);
}
}
/** Sleep for the specified amount of time
*/
private void pause(int milliseconds) {
try {
Thread.sleep((long)milliseconds);
} catch(InterruptedException ie) {}
}
}
Here's the MovingShape Class:
/*
* ===============================================================================
* MovingShape.java : The superclass of all shapes.
* A shape has a point (top-left corner).
* A shape defines various properties, including selected, colour, width and height.
* ===============================================================================
*/
import java.awt.*;
public abstract class MovingShape {
public int marginWidth, marginHeight; // the margin of the animation panel area
protected Point p; // the top left coner of shapes
protected int width; // the width of shapes
protected int height; // the height of shapes
protected MovingPath path; // the moving path of shapes
protected boolean selected = false; // draw handles if selected
/** constuctor to create a shape with default values
*/
public MovingShape() {
this(0, 0, 20, 20, 500, 500, 0); // the default properties
}
/** constuctor to create a shape
* @param x the x-coordinate of the new shape
* @param y the y-coordinate of the new shape
* @param w the width of the new shape
* @param h the height of the new shape
* @param mw the margin width of the animation panel
* @param mh the margin height of the animation panel
* @param typeOfPath the path of the new shape
*/
public MovingShape(int x, int y, int w, int h, int mw, int mh, int pathType) {
p = new Point(x,y);
marginWidth = mw;
marginHeight = mh;
width = w;
height = h;
setPath (pathType);
}
/** Return the x-coordinate of the shape.
* @return the x coordinate
*/
public int getX() { return p.x; }
/** Return the y-coordinate of the shape.
* @return the y coordinate
*/
public int getY() { return p.y;}
/** Return the selected property of the shape.
* @return the selected property
*/
public boolean isSelected() { return selected; }
/** Set the selected property of the shape.
* When the shape is selected, its handles are shown.
* @param s the selected value
*/
public void setSelected(boolean s) { selected = s; }
/** Set the width of the shape.
* @param w the width value
*/
public void setWidth(int w) { width = w; }
/** Set the height of the shape.
* @param h the height value
*/
public void setHeight(int h) { height = h; }
/**
* Return a string representation of the shape, containing
* the String representation of each element.
*/
public String toString() {
return "[" + this.getClass().getName() + "," + p.x + "," + p.y + "]";
}
/** Draw the handles of the shape
* @param g the Graphics control
*/
public void drawHandles(Graphics g) {
// if the shape is selected, then draw the handles
if (isSelected()) {
g.setColor(Color.black);
g.fillRect(p.x -2, p.y-2, 4, 4);
g.fillRect(p.x + width -2, p.y + height -2, 4, 4);
g.fillRect(p.x -2, p.y + height -2, 4, 4);
g.fillRect(p.x + width -2, p.y-2, 4, 4);
}
}
/** Reset the margin for the shape
* @param w the margin width
* @param h the margin height
*/
public void setMarginSize(int w, int h) {
marginWidth = w;
marginHeight = h;
}
/** abstract contains method
* Returns whether the point p is inside the shape or not.
* @param p the mouse point
*/
public abstract boolean contains(Point p);
/** abstract draw method
* draw the shape
* @param g the Graphics control
*/
public abstract void draw(Graphics g);
/** Set the path of the shape.
* @param pathID the integer value of the path
* MovingPath.BOUNDARY is the boundary path
* MovingPath.FALLING is the falling path
*/
public void setPath(int pathID) {
switch (pathID) {
case MovingPath.BOUNDARY : {
path = new BoundaryPath(10, 10);
break;
}
case MovingPath.FALLING : {
path = new FallingPath();
break;
}
}
}
/** move the shape by the path
*/
public void move() {
path.move();
}
// Inner class ===================================================================== Inner class
/*
* ===============================================================================
* MovingPath : The superclass of all paths. It is an inner class.
* A path can change the current position of the shape.
* ===============================================================================
*/
public abstract class MovingPath {
public static final int BOUNDARY = 0; // The Id of the moving path
public static final int FALLING = 1; // The Id of the moving path
protected int deltaX, deltaY; // moving distance
/** constructor
*/
public MovingPath() { }
/** abstract move method
* move the shape according to the path
*/
public abstract void move();
}
/*
* ===============================================================================
* FallingPath : A falling path.
* ===============================================================================
*/
public class FallingPath extends MovingPath {
private double am = 0, stx =0, sinDeltax = 0;
/** constructor to initialise values for a falling path
*/
public FallingPath() {
am = Math.random() * 20; //set amplitude variables
stx = 0.5; //set step variables
deltaY = 5;
sinDeltax = 0;
}
/** move the shape
*/
public void move() {
sinDeltax = sinDeltax + stx;
p.x = (int) Math.round(p.x + am * Math.sin(sinDeltax));
p.y = p.y + deltaY;
if (p.y > marginHeight) // if it reaches the bottom of the frame, start again from the top
p.y = 0;
}
}
/*
* ===============================================================================
* BoundaryPath : A boundary path which moves the shape around the boundary of the frame
* ===============================================================================
*/
public class BoundaryPath extends MovingPath {
private int direction;
/** constructor to initialise values for a boundary path
*/
public BoundaryPath(int speedx, int speedy) {
deltaX = (int) (Math.random() * speedx) + 1;
deltaY = (int) (Math.random() * speedy) + 1;
direction = 0;
}
/** move the shape
*/
public void move() {
int h = marginHeight - height;
int w = marginWidth - width;
switch (direction) {
case 0 : { // move downwards
p.y += deltaY;
if (p.y > h) {
p.y = h - 1;
direction = 90;
}
break;
}
case 90 : { // move to the right
p.x += deltaX;
if (p.x > w) {
p.x = w - 1;
direction = 180;
}
break;
}
case 180 : {
p.y -= deltaY; // move upwards
if (p.y < 0) {
direction = 270;
p.y = 0;
}
break;
}
case 270 : { // move to the left
p.x -= deltaX;
if (p.x < 0) {
direction = 0;
p.x = 0;
}
break;
}
}
}
}
// ========================================================================================
}
and finally here's the moving rectangle class:
/*
* ===============================================================================
* MovingRectangle.java : A shape that is a rectangle.
* A rectangle has 4 handles shown when it is selected (by clicking on it).
* ===============================================================================
*/
import java.awt.*;
public class MovingRectangle extends MovingShape {
/** constuctor to create a rectangle with default values
*/
public MovingRectangle() {
super();
}
/** constuctor to create a rectangle shape
*/
public MovingRectangle(int x, int y, int w, int h, int mw, int mh, int pathType) {
super(x ,y ,w, h ,mw ,mh ,pathType);
}
/** draw the rectangle with the fill colour
* If it is selected, draw the handles
* @param g the Graphics control
*/
public void draw(Graphics g) {
g.setColor(Color.blue);
g.fillRect(p.x, p.y, width, height);
g.setColor(Color.black);
g.drawRect(p.x, p.y, width, height);
drawHandles(g);
}
/** Returns whether the point is in the rectangle or not
* @return true if and only if the point is in the rectangle, false otherwise.
*/
public boolean contains(Point mousePt) {
return (p.x <= mousePt.x && mousePt.x <= (p.x + width + 1) && p.y <= mousePt.y && mousePt.y <= (p.y + height + 1));
}
}