QUICK MAX DUKE DOLLARS!!!

Question

Project.java is a simple drawing program.
Modify the program to draw not only circles, but rectangles,
filled circles, filled rectanges and lines. Modify the program
so the user can change the color of a shape and clear the
drawing.
Use proper object orient techniques in making your modifications.
There is some code that is in the sample program that could
be improved. Make any modifications that you feel are necessary
to improve the code. The code simple shows you how to perform
the drawing operations.
import java.awt.*;
import java.awt.event.*;
import java.util.*;
* This is a simply drawing program which lets the user draw basic shapes
* (lines, ovals and rectangles). This program currently only lets the
* user draw ovals, and the only color displayed is black.
* The drawing program uses rubberbanding so that the user can see the
* shape as they drag it. When the use clicks down on the mouse it
* sets the starting, or anchor, point for the drawing. When they release
* the button the shape is drawn. As the user holds down the button and
* drags the mouse, the shape is constantly displayed.
public class Project extends Panel
Panel controlPanel; // Contains for controls to determine shape and color
ScrollPane drawPane; // A scrollable drawing pane
Label shapeLabel; // A label for the shape drop down list
Label colorLabel; // a label for the color drop down list
Choice shapeChoice; // Drop down list (combbox) for selecting the shape
Choice colorChoice; // drop down lsit for selecting the color
Button clearButton; // For clearing the drawing canvas
Color currentColor = Color.black; // The current color used to draw shapes
DrawCanvas drawCanvas; // a Canva on which we draw the shapes
Vector shapes; // A vector to hold all of the shapes
protected String []shapeTypes = {"circle", "rectangle", "filled circle",
"filled rectangle", "line" };
protected String []colors = {"red", "blue", "green", "yellow", "orange",
"white", "black", "gray", "dark gray", "light gray",
"cyan", "magenta", "pink"};
Point anchorPoint; // The anchor point
Point endPoint; // The point where the mouse was released
Point stretchPoint; // The point where the user dragged the mouse to
Point lastPoint; // The previous drag point
boolean firstTime = true; // first time drawing this shape?
* Add GUI components
public Project()
// GridBagLayout is the most powerful and difficult to
// use Layout manager
// The layout manager determines were components are placed on
// the screen. There is no need to modify it in any way.
GridBagLayout gbl = new GridBagLayout();
GridBagConstraints gc = new GridBagConstraints();
// Create the control panel
setLayout(gbl);
controlPanel = new Panel();
setConstraints(controlPanel, gbl, gc, 0, 0,
GridBagConstraints.REMAINDER, 1, 0, 0,
GridBagConstraints.CENTER,
GridBagConstraints.NONE,
0, 0, 0, 0);
add(controlPanel, gc);
shapeLabel = new Label("Shape"); // The Label for the shape drop down list
controlPanel.add(shapeLabel);
shapeChoice = new Choice(); // The dropdown list
controlPanel.add(shapeChoice);
colorLabel = new Label("Color"); // The label or the color drop down list
controlPanel.add(colorLabel);
colorChoice = new Choice(); // The drop down list
controlPanel.add(colorChoice);
clearButton = new Button("Clear"); // the clear button
controlPanel.add(clearButton); // Doesn't do anything
// Event handelers
// Handle the event when the user selects a new shape
shapeChoice.addItemListener(new ShapeHandler());
// Event when user selects new color
colorChoice.addItemListener(new ColorHandler());
// Event when user click clear button
clearButton.addActionListener(new ClearHandler());
//Create the drawing area
drawPane = new ScrollPane();
setConstraints(drawPane, gbl, gc, 0, 1,
GridBagConstraints.REMAINDER, 1, 1, 1,
GridBagConstraints.CENTER,
GridBagConstraints.BOTH,
5, 0, 5, 0);
add(drawPane, gc);
drawPane.setSize(300,300);
drawCanvas = new DrawCanvas(400,400);
drawPane.add(drawCanvas);
initShapes(); // initialize the shape choice control
initColors(); // initialzie the color choice control
shapes = new Vector();
// Convenience method for GridBagLayout
private void setConstraints(
Component comp,
GridBagLayout gbl,
GridBagConstraints gc,
int gridx,
int gridy,
int gridwidth,
int gridheight,
int weightx,
int weighty,
int anchor,
int fill,
int top,
int left,
int bottom,
int right)
gc.gridx = gridx;
gc.gridy = gridy;
gc.gridwidth = gridwidth;
gc.gridheight = gridheight;
gc.weightx = weightx;
gc.weighty = weighty;
gc.anchor = anchor;
gc.fill = fill;
gc.insets = new Insets(top, left, bottom, right);
gbl.setConstraints(comp, gc);
// Initialize the shape control
private void initShapes()
for(int i = 0; i < shapeTypes.length; i++){
shapeChoice.add(shapeTypes);
// Initialzie the color control
private void initColors()
for(int i = 0; i < colors.length; i++){
colorChoice.add(colors);
* Handle the shape selection
* This doesn't currently do anything
public class ShapeHandler implements ItemListener
public void itemStateChanged(ItemEvent e)
// Use get index method to get the index of the chosen shape
// shapeType = shapeChoice.getSelectedItem();
* Handle the color seclection
* This doesn't do anything either
public class ColorHandler implements ItemListener
public void itemStateChanged(ItemEvent e)
String color = colorChoice.getSelectedItem();
System.out.println("Selected color " + color);
// Handle the clear button
// This doesn't do anything
public class ClearHandler implements ActionListener
public void actionPerformed(ActionEvent e)
* A canvas to draw on
public class DrawCanvas extends Component
int width; // The Width of the Canvas
int height; // The Height of the Canvas
/** Create an area to draw on
*@param width - the width of the drawing area
*@param height - the height of the drawing area
public DrawCanvas(int width, int height)
// Handle mouse press and release events
addMouseListener(new MouseHandler());
// handle mouse drag events
addMouseMotionListener(new MouseDragHandler());
this.width = width;
this.height = height;
* Draw all of the shapes
* Not very efficient
public void paint(Graphics g)
for (Enumeration e = shapes.elements() ; e.hasMoreElements() ;)
Circle c = (Circle )e.nextElement();
System.out.println("drawing Circle " + c.toString());
c.draw(g);
* Let everyone know what the preferred size of the drawing
* canvas is
public Dimension getPreferredSize()
return new Dimension(width, height);
* Used with rubberbanding. The way to erase a shape is
* to draw it again in XOR mode.
private void eraseLast(Graphics g)
int x, y;
int width, height;
if (anchorPoint == null || lastPoint == null)
return;
// The draw methods assume that the width and height are
// not negative so we do the following caculations to
// insure that they are not
if (anchorPoint.x < lastPoint.x)
x = anchorPoint.x;
else
x = lastPoint.x;
if (anchorPoint.y < lastPoint.y)
y = anchorPoint.y;
else
y = lastPoint.y;
width = Math.abs(lastPoint.x - anchorPoint.x);
height = Math.abs(lastPoint.y - anchorPoint.y);
// Draw the circle (or oval) at the rectagle bounded by
// the rectange with the upper left hand corner of x,y
// and with the specified width and height
g.drawOval(x, y, width, height);
// To draw a rectable
//g.drawRect(x, y, width, height);
// To draw a Filled Oval
//g.fillOval(x, y, width, height);
// To draw a Filled Rect
//g.fillRect(x, y, width, height);
// To draw a line
//g.drawLine(anchorPoint.x, anchorPoint.y, lastPoint.x, lastPoint.y);
* Do the rubber band drawing
private void drawRubber(Graphics g)
int x, y;
int width, height;
if (anchorPoint.x < stretchPoint.x)
x = anchorPoint.x;
else
x = stretchPoint.x;
if (anchorPoint.y < stretchPoint.y)
y = anchorPoint.y;
else
y = stretchPoint.y;
width = Math.abs(stretchPoint.x - anchorPoint.x);
height = Math.abs(stretchPoint.y - anchorPoint.y);
g.drawOval(x, y, width, height);
* Handle the start and end of rubberbanding. At the end
* draw the final shape
public class MouseHandler extends MouseAdapter
// Get the starting point
public void mousePressed(MouseEvent e)
anchorPoint = e.getPoint(); // Point where mouse was clickec
firstTime = true; // The first point
// Get the end point
public void mouseReleased(MouseEvent e)
endPoint = e.getPoint(); // Point where mouse was released
Graphics g = getGraphics(); // Get the object to draw on
g.setXORMode(getBackground()); // Set XOR mode
eraseLast(g); // Erase the previous shape
// Add the shape to our vector
//Obviously you will need to do something different here
shapes.addElement( new Circle(anchorPoint, endPoint, currentColor));
repaint(); // Repaint the entire drawing
g.dispose(); // Need to dispose of Graphics objects
* Handle the rubber banding
public class MouseDragHandler extends MouseMotionAdapter
// Every time the mouse is moved while the mouse button is pressed
public void mouseDragged(MouseEvent e)
Graphics g = getGraphics();
g.setXORMode(getBackground());
stretchPoint = e.getPoint(); // Get the point we just dragged to
if (firstTime == true)
firstTime = false; // nothing to erase the first time
else
eraseLast(g); // Erase the last drawing
drawRubber(g); // Draw the new one
g.dispose(); // Anytime we do a getGraphics we must dispose of it
lastPoint = stretchPoint; // Set the lastPoint to lastest last point
* In real program this should extend Shape or implement a Shape
* interface and it should be in it's own file
* Note that even though this is called Circle, it is really an oval
public class Circle
int x, y; // X and Y cooridinates of bounding rectangle (upper left)
int width, height; // width and height of bounding rectangle
Point p2; // opposite corner of bounding retangle
Color color; // color of circle
public Circle(Point p1, Point p2, Color color)
// The width and height cannot be negative.
// x and y must always be the upper left corner
if ( p1.x < p2.x)
x = p1.x;
else
x = p2.x;
if (p1.y < p2.y)
y = p1.y;
else
y = p2.y;
width = Math.abs( p2.x - p1.x);
height = Math.abs(p2.y - p1.y);
this.color = color;
* This method is called automatically by repaint and whenever the
* window needs to be redrawn
public void draw(Graphics g)
Color c = g.getColor(); // Save the current color
g.setColor(color); // Set the color to draw the circle
g.drawOval(x, y, width, height); // draw the circle
g.setColor(c); // set the color back to what is was before
* a toString method is a convienent way of
* displaying the attributes of a class
public String toString()
return "Circle " + color + width + height;
* Main method creates a Frame and adds in our drawing control
public static void main(String []args)
// Create the main window
Frame frame = new Frame();
// add a listener to close the window properly
frame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0); // simply exit
// Create our control
Project panel = new Project();
// add it to our window
frame.add(panel, BorderLayout.CENTER);
// size our window to 640 by 480 pixels
frame.setSize(640, 480);
// display our window
frame.setVisible(true);
}

Answer 1

Sure, I'll do it, no problem... Anything to help a fellow hard working computer science student... I'm just curious what college you attend. Could you tell me? I promise I'll get you the code then.