Solution for
Programming Exercise 7.8
THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to
the following exercise from this on-line
Java textbook.
Exercise 7.8:
Turn your applet from the previous exercise into a stand-alone
application that runs as a JFrame. (If you didn't do the
previous exercise, you can do this exercise with the original
SimplePaint3.java.)
To make the exercise
more interesting, remove the JButtons and JComboBoxes
and replace them with a menubar at the top of the frame. You can
design the menus any way you like, but you should have at least the same
functionality as in the original program.
As an improvement, you might add an "Undo" command.
When the user clicks on the "Undo" button, the previous drawing operation will
be undone. This just means returning to the image as it was before the
drawing operation took place. This is easy to implement, as long
as we allow just one operation to be undone. When the off-screen canvas,
OSI, is created, make a second off-screen canvas, undoBuffer,
of the same size. Before starting any drawing operation,
copy the image from OSI to undoBuffer. You can do this with
the commands
Graphics undoGr = undoBuffer.getGraphics();
undoGr.drawImage(OSI, 0, 0, null);
When the user clicks "Undo", just swap the values of OSI
and undoBuffer and repaint. The previous image will appear
on the screen. Clicking on "Undo" again will "undo the undo".
As another improvement, you could make it possible for the user
to select a drawing color using a JColorChooser dialog box.
Here is a button that opens my program in its own window. (You don't have to
write an applet to launch your frame. Just create the frame in the
program's main() routine.)
Discussion
Let's start by discussing the Undo operation, since there is not
much more to say about it beyond what is said in the exercise.
The off-screen canvas for the undo operation, undoBuffer, is created in
the setupOSI() method where OSI is created.
It is filled with the background color, just like OSI.
(Ordinarily, the user won't see the initial contents of the
undo buffer. But if the user clicks the Undo button
before drawing anything, the undo buffer will be swapped in and
displayed. So, it should have some well-defined content. Since,
in fact, both OSI and undoBuffer are initially
filled with the background color, the user won't see any difference
when they are swapped.)
In the actionPerformed method,
in response to the "Undo" command, the values of OSI
and undoBuffer are swapped with the statements
Image temp = OSI;
OSI = undoBuffer;
undoBuffer = temp;
repaint();
The values stored in the variables OSI and undoBuffer
are swapped. But remember that the values are only pointers to the
Image objects. The Images themselves are not
copied. After the swap, the Images themselves have not
moved, but OSI and undoBuffer are pointing to
different images. When the screen is repainted, and OSI is
drawn to the screen, it's the former undo buffer that appears on the
screen. The former OSI is now the new undo buffer.
In the mousePressed() routine, before a drawing operation
starts, the current image is saved in the undo buffer, using the
commands given in the exercise.
In the source code below, all changes having to do with the
Undo command are shown in red.
In changing the program from an applet to a frame, the first line,
which was
public class KaleidaPaint extends JApplet {
is changed to
public class KaleidaPaintFrame extends JFrame {
The init() method of the applet is replace
by a constructor for the frame. Since the frame will use
a menu bar in place of the buttons and JComboBoxes
used in the applet, the constructor is very different from
the applet's init() method. Its main purpose is
to create the menu bar and the menus that it contains.
The design of the menu bars could be very different from
the ones that I used, but techniques for setting up the
menus are pretty standard and straightforward. (They
do require a lot of typing, though!) The techniques
are the same as those used in the ShapeDrawFrame
example from Section 7. I won't
discuss the set up of the menus here.
In my applet, the "Color", "Shape", and "Symmetry" menus control
what type of drawing is done when the user drags the mouse.
Each menu contains a group of JRadioButtonMenuItems.
Java, unfortunately, doesn't have a good way of checking a group
of radio buttons to see which one is selected. You have to
go through and check each button. To make this possible in my
applet, I have instance variables to represent each of the
JRadioButtonMenuItems, and I wrote methods to check
for the currently selected color, shape, and symmetry type.
For example:
private int getSelectedSymmetry() {
// Check the "Symmetry" menu and return the code
// for the type of symmetry that is currently selected.
if (noSymmetry.isSelected())
return NO_SYMMETRY;
else if (twoWay.isSelected())
return SYMMETRY_2;
else if (fourWay.isSelected())
return SYMMETRY_4;
else
return SYMMETRY_8;
}
The method checks the buttons in the "Symmetry" menu and returns a constant
that represents the selected item in the menu. This method,
along with the very similar getSelectedColor() and
getSelectedShape(), are called in mousePressed()
when the user begins drawing. The values they return are used
to determine what to draw when the user drags the mouse.
The other menu, "Control", contains commands that will be carried
out by the actionPerformed() method of the Display
class. Most of this is straightforward. In order to implement
custom colors, an instance variable, customColor, in the
Display class holds the currently selected custom color.
Initially, the color is gray. (It has to have some initial value,
in case the user uses the custom color without first selecting one.)
The value of this variable is changed if the user selects a new
custom color with the "Select Custom Color..." command. The
custom color is used for the background color by the "Fill with Custom"
command in the "Control" menu, and it is used for the drawing color
if "Custom" is selected in the "Color" menu. In my original solution,
the "Select Custom Color..." command did nothing but change the
customColor variable. To draw with this color, the
user also had to select "Custom" from the color menu. After using
the program, I found that this behavior didn't feel right. I wanted
to be able to draw with the new color immediately after using
the "Select Custom Color..." command. So, I changed the program to
select "Custom" in the "Color" menu automatically. This might
surprise the user, but I found it more surprising when the color
wasn't changed. (There is something called the
"Principle of Least Surprise" which is a valuable guideline
for user interface design.)
In addition to setting up the menus, the constructor does some
initialization that any frame needs, either in its constructor
or elsewhere:
pack();
setLocation(75,50);
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
The pack() command sets the frame to its preferred size.
Since I use the pack() command to set the size of the frame,
all the components in the frame must define a reasonable preferred
size. My original display class did not do this, so I added a call to
setPreferredSize() method to the constructor of the display class.
The default size is 450-by-450. Symmetry looks better on a square drawing
area. The frame will be sized so that this is the exact size of the
drawing area. As an alternative to using pack(),
I could have set the size of the frame by calling its setSize()
or setBounds() method.
The setResizable(false) command prevents the user from changing
the size of the window. This is not usually desirable, but I decided to do
it here since changing the window size will erase the current picture,
and I thought that might be too surprising for the user.
The default close operation tells what happens when the user clicks
the close box of the window. For a stand-alone application with a single
window, it's appropriate to call System.exit(), which is what
I do here.
The show() command is important, since without it the frame
would never appear on the screen. The show() command does
not have to occur in the constructor. If the constructor does not
show the frame, then the frame remains invisible until some other
routine calls the frame's show() method. Sometimes it's
good to be able to show and hide a frame at will.
The frame class has a main() routine that makes it possible
to run the frame as a standalone program. The main() routine
just needs to say "new KaleidaPaintFrame()" to create the
frame:
public static void main(String[] args) {
new KaleidaPaintFrame();
}
Note that the main() routine ends immediately after it
opens the frame. It does not wait for the window to close. The main()
routine ends even while the frame continues to exist. The main()
routine is, in fact, a separate thread from the user interface thread
that runs the frame. The main() routine could even go on to
perform other tasks independently of the frame, such as interacting
with the user via TextIO.
The only other change I made was to remove the getInsets()
method from the original program. The frame has its own borders anyway.
In general, there is no reason to use insets on a frame
The Solution
Changes related to the Undo operation are shown in red.
Other significant changes related are shown in blue.
/*
A nifty program where the user can sketch curves and shapes in a
variety of colors on a variety of background colors. The user can
draw symmetric pictures in which shapes are reflected horizontally,
vertically, and diagonally. The user selects the type of symmetry
from a "Symmetry" menu at the top of the frame. The user can
select a color to be used for drawing from a "Color" menu.
The user selects the shape to draw from a "Shape" menu at the
top of the frame. The user can draw free-hand curves, straight
lines, and one of six different types of shapes.
A "Control" menu contains commands for filling the drawing
area with various colors. It also contains commands: "Clear", "Undo",
and "Quit". The "Clear" command will clear the frame to the current
background color. The user can undo only the most recent operation.
The user can close the window by chosing the "Quit" command or
by clicking the Window's close box. Finally, there is a
"Select Custom Color..." command that lets the user set a custom
color for drawing or for the background.
The user's drawing is saved in an off-screen image, which is
used to refresh the screen when repainting. The frame is made
non-resizable, since the way the program is written, the
picture would be lost if the drawing area were to change size.
This file defines two classes, KaleidaPaintFrame.class, and
class, KaleidaPaintFrame$Display.class.
*/
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class KaleidaPaintFrame extends JFrame {
public static void main(String[] args) {
// A main routine that allows this class to be run
// as a stand-alone application. It just opens a frame.
new KaleidaPaintFrame();
}
JRadioButtonMenuItem black, red, green, blue, cyan, magenta,
yellow, white, custom;
// Items for the "Color" menu, which controls the drawing color.
// They form a group in which only one item can be selected.
// When the user starts drawing, the color is determined by
// checking to see which of the items is selected.
JRadioButtonMenuItem curve, straightLine, rectangle, oval,
roundRect, filledRectangle, filledOval, filledRoundRect;
// Items for the "Shape" menu, which determine the shape to be drawn.
JRadioButtonMenuItem noSymmetry, twoWay, fourWay, eightWay;
// Items for the "Symmetry" menu, which determine which
// reflections of the basic figure should be drawn.
public boolean standAlone = true;
// If a frame is created by an applet, the applet should
// set this variable to false. Otherwise, an error will
// be generated when the user selects the "Quit" command,
// since that command will call System.exit() if standalone
// is true. The applet should also call the frame's
// setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE).
public KaleidaPaintFrame() { // replaces init() method.
// Constructor creates a drawing area and uses it as its
// content pane. It also sets up the menu bar.
super("KaleidaPaint"); // Set a title for the window.
Display canvas = new Display(); // The drawing area.
setContentPane(canvas);
// Create menu bar and menus.
JMenuBar menubar = new JMenuBar();
JMenu controlMenu = new JMenu("Control",true);
menubar.add(controlMenu);
JMenu colorMenu = new JMenu("Color",true);
menubar.add(colorMenu);
JMenu shapeMenu = new JMenu("Shape",true);
menubar.add(shapeMenu);
JMenu symmetryMenu = new JMenu("Symmetry",true);
menubar.add(symmetryMenu);
setJMenuBar(menubar);
// Set up the "Control" menu, and set the canvas to respond
// to commands from this menu. Add accelerators for some
// of the commands.
controlMenu.add("Fill with Black").addActionListener(canvas);
controlMenu.add("Fill with Red").addActionListener(canvas);
controlMenu.add("Fill with Green").addActionListener(canvas);
controlMenu.add("Fill with Blue").addActionListener(canvas);
controlMenu.add("Fill with Cyan").addActionListener(canvas);
controlMenu.add("Fill with Magenta").addActionListener(canvas);
controlMenu.add("Fill with Yellow").addActionListener(canvas);
controlMenu.add("Fill with White").addActionListener(canvas);
controlMenu.add("Fill with Custom").addActionListener(canvas);
controlMenu.addSeparator();
JMenuItem customItem = new JMenuItem("Set Custom Color...");
customItem.addActionListener(canvas);
customItem.setAccelerator( KeyStroke.getKeyStroke("ctrl T") );
controlMenu.add(customItem);
JMenuItem clearItem = new JMenuItem("Clear");
clearItem.addActionListener(canvas);
clearItem.setAccelerator( KeyStroke.getKeyStroke("ctrl K") );
controlMenu.add(clearItem);
JMenuItem undoItem = new JMenuItem("Undo");
undoItem.addActionListener(canvas);
undoItem.setAccelerator( KeyStroke.getKeyStroke("ctrl Z") );
controlMenu.add(undoItem);
JMenuItem quitItem = new JMenuItem("Quit");
quitItem.setAccelerator( KeyStroke.getKeyStroke("ctrl Q") );
quitItem.addActionListener(canvas);
controlMenu.add(quitItem);
// Set up the "Color" menu, with all the items in a button group.
ButtonGroup colorGroup = new ButtonGroup();
black = new JRadioButtonMenuItem("Black");
colorGroup.add(black);
colorMenu.add(black);
red = new JRadioButtonMenuItem("Red");
colorGroup.add(red);
colorMenu.add(red);
green = new JRadioButtonMenuItem("Green");
colorGroup.add(green);
colorMenu.add(green);
blue = new JRadioButtonMenuItem("Blue");
colorGroup.add(blue);
colorMenu.add(blue);
cyan = new JRadioButtonMenuItem("Cyan");
colorGroup.add(cyan);
colorMenu.add(cyan);
magenta = new JRadioButtonMenuItem("Magenta");
colorGroup.add(magenta);
colorMenu.add(magenta);
yellow = new JRadioButtonMenuItem("Yellow");
colorGroup.add(yellow);
colorMenu.add(yellow);
white = new JRadioButtonMenuItem("White");
colorGroup.add(white);
colorMenu.add(white);
custom = new JRadioButtonMenuItem("Custom Color");
colorGroup.add(custom);
colorMenu.add(custom);
black.setSelected(true);
// Set up the "Shape" menu.
ButtonGroup shapeGroup = new ButtonGroup();
curve = new JRadioButtonMenuItem("Curve");
shapeGroup.add(curve);
shapeMenu.add(curve);
straightLine = new JRadioButtonMenuItem("Straight Line");
shapeGroup.add(straightLine);
shapeMenu.add(straightLine);
rectangle = new JRadioButtonMenuItem("Rectangle");
shapeGroup.add(rectangle);
shapeMenu.add(rectangle);
oval = new JRadioButtonMenuItem("Oval");
shapeGroup.add(oval);
shapeMenu.add(oval);
roundRect = new JRadioButtonMenuItem("RoundRect");
shapeGroup.add(roundRect);
shapeMenu.add(roundRect);
filledRectangle = new JRadioButtonMenuItem("Filled Rectangle");
shapeGroup.add(filledRectangle);
shapeMenu.add(filledRectangle);
filledOval = new JRadioButtonMenuItem("Filled Oval");
shapeGroup.add(filledOval);
shapeMenu.add(filledOval);
filledRoundRect = new JRadioButtonMenuItem("Filled RoundRect");
shapeGroup.add(filledRoundRect);
shapeMenu.add(filledRoundRect);
curve.setSelected(true);
// Set up the "Symmetry" menu.
ButtonGroup symmetryGroup = new ButtonGroup();
noSymmetry = new JRadioButtonMenuItem("None");
noSymmetry.setAccelerator( KeyStroke.getKeyStroke("ctrl 0") );
symmetryGroup.add(noSymmetry);
symmetryMenu.add(noSymmetry);
twoWay = new JRadioButtonMenuItem("Two-way");
twoWay.setAccelerator( KeyStroke.getKeyStroke("ctrl 2") );
symmetryGroup.add(twoWay);
symmetryMenu.add(twoWay);
fourWay = new JRadioButtonMenuItem("Four-way");
fourWay.setAccelerator( KeyStroke.getKeyStroke("ctrl 4") );
symmetryGroup.add(fourWay);
symmetryMenu.add(fourWay);
eightWay = new JRadioButtonMenuItem("Eight-way");
eightWay.setAccelerator( KeyStroke.getKeyStroke("ctrl 8") );
symmetryGroup.add(eightWay);
symmetryMenu.add(eightWay);
noSymmetry.setSelected(true);
// Set size, etc., of frame and make it visible.
pack();
setLocation(75,50);
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
show();
} // end constructor
private class Display extends JPanel
implements MouseListener, MouseMotionListener, ActionListener {
// Nested class Display represents the drawing surface of the
// applet. It lets the user use the mouse to draw colored curves
// and shapes. The current color is specified by the pop-up menu
// colorChoice. The current shape is specified by another pop-up menu,
// figureChoice. (These are instance variables in the main class.)
// The panel also listens for action events from buttons
// named "Clear" and "Set Background". The "Clear" button fills
// the panel with the current background color. The "Set Background"
// button sets the background color to the current drawing color and
// then clears. These buttons are set up in the main class.
private final static int
CURVE = 0,
LINE = 1,
RECT = 2, // Some constants that code
OVAL = 3, // for the different types of
ROUNDRECT = 4, // figure the program can draw.
FILLED_RECT = 5,
FILLED_OVAL = 6,
FILLED_ROUNDRECT = 7;
private final static int
NO_SYMMETRY = 0, // Some constants that code for
SYMMETRY_2 = 1, // the different symmetry styles.
SYMMETRY_4 = 2,
SYMMETRY_8 = 3;
Color customColor = Color.gray; // The custom color that is used
// when the user selects "Custom Color"
// as the drawing color or "Fill with Custom"
// from the "Control" menu. This color
// is changed when the user selects the
// "Set Custom Color..." command.
/* Some variables used for backing up the contents of the panel. */
Image OSI; // The off-screen image (created in checkOSI()).
int widthOfOSI, heightOfOSI; // Current width and height of OSI. These
// are checked against the size of the applet,
// to detect any change in the panel's size.
// If the size has changed, a new OSI is created.
// The picture in the off-screen image is lost
// when that happens.
Image undoBuffer; // An off-screen image that is used to implement
// the undo operation. When the user begins
// a drawing operation, the OSI is copied to
// undoBuffer. If the user selects the "Undo"
// command, the OSI and the undoBuffer are swapped
// and the panel is repainted to show the previous image.
/* The following variables are used when the user is sketching a
curve while dragging a mouse. */
private int mouseX, mouseY; // The location of the mouse.
private int prevX, prevY; // The previous location of the mouse.
private int startX, startY; // The starting position of the mouse.
// (Not used for drawing curves.)
private boolean dragging; // This is set to true when the user is drawing.
private int figure; // What type of figure is being drawn. This is
// specified by the figureChoice menu.
private int symmetry; // What type of symmetry style is being used. This is
// specified by the symmetryChoice menu.
private Graphics dragGraphics; // A graphics context for the off-screen image,
// to be used while a drag is in progress.
private Color dragColor; // The color that is used for the figure that is
// being drawn.
Display() {
// Constructor. When this component is first created, it is set to
// listen for mouse events and mouse motion events from
// itself. The initial background color is white.
addMouseListener(this);
addMouseMotionListener(this);
setBackground(Color.white);
setPreferredSize( new Dimension(450,450) );
}
private Color getSelectedColor() {
// Check the "Color" menu and return the color
// that is currently selected.
if (black.isSelected())
return Color.black;
else if (red.isSelected())
return Color.red;
else if (green.isSelected())
return Color.green;
else if (blue.isSelected())
return Color.blue;
else if (cyan.isSelected())
return Color.cyan;
else if (magenta.isSelected())
return Color.magenta;
else if (yellow.isSelected())
return Color.yellow;
else if (white.isSelected())
return Color.white;
else
return customColor;
}
private int getSelectedShape() {
// Check the "Shape" menu and return the code
// for the shape that is currently selected.
if (curve.isSelected())
return CURVE;
else if (straightLine.isSelected())
return LINE;
else if (rectangle.isSelected())
return RECT;
else if (oval.isSelected())
return OVAL;
else if (roundRect.isSelected())
return ROUNDRECT;
else if (filledRectangle.isSelected())
return FILLED_RECT;
else if (filledOval.isSelected())
return FILLED_OVAL;
else
return FILLED_ROUNDRECT;
}
private int getSelectedSymmetry() {
// Check the "Symmetry" menu and return the code
// for the type of symmetry that is currently selected.
if (noSymmetry.isSelected())
return NO_SYMMETRY;
else if (twoWay.isSelected())
return SYMMETRY_2;
else if (fourWay.isSelected())
return SYMMETRY_4;
else
return SYMMETRY_8;
}
private void drawFigure(Graphics g, int shape, int x1, int y1, int x2, int y2) {
// This method is called to do ALL drawing in this applet!
// Draws a shape in the graphics context g.
// The shape parameter tells what kind of shape to draw. This
// can be LINE, RECT, OVAL, ROUNTRECT, FILLED_RECT,
// FILLED_OVAL, or FILLED_ROUNDRECT. (Note that a CURVE is
// drawn by drawing multiple LINES, so the shape parameter is
// never equal to CURVE.) For a LINE, a line is drawn from
// the point (x1,y1) to (x2,y2). For other shapes, the
// points (x1,y1) and (x2,y2) give two corners of the shape
// (or of a rectangle that contains the shape).
if (shape == LINE) {
// For a line, just draw the line between the two points.
g.drawLine(x1,y1,x2,y2);
return;
}
int x, y; // Top left corner of rectangle that contains the figure.
int w, h; // Width and height of rectangle that contains the figure.
if (x1 >= x2) { // x2 is left edge
x = x2;
w = x1 - x2;
}
else { // x1 is left edge
x = x1;
w = x2 - x1;
}
if (y1 >= y2) { // y2 is top edge
y = y2;
h = y1 - y2;
}
else { // y1 is top edge.
y = y1;
h = y2 - y1;
}
switch (shape) { // Draw the appropriate figure.
case RECT:
g.drawRect(x, y, w, h);
break;
case OVAL:
g.drawOval(x, y, w, h);
break;
case ROUNDRECT:
g.drawRoundRect(x, y, w, h, 20, 20);
break;
case FILLED_RECT:
g.fillRect(x, y, w, h);
break;
case FILLED_OVAL:
g.fillOval(x, y, w, h);
break;
case FILLED_ROUNDRECT:
g.fillRoundRect(x, y, w, h, 20, 20);
break;
}
}
private void putMultiFigure(Graphics g, int shape, int x1, int y1, int x2, int y2) {
// Draws the shape and possibly some of its reflections.
// The reflections that are drawn depend on the selected
// item in symmetryChoice. The shapes are drawn by calling
// the drawFigure method.
int width = getWidth();
int height = getHeight();
drawFigure(g,shape,x1,y1,x2,y2); // Draw the basic figure
if (symmetry >= SYMMETRY_2) { // Draw the horizontal reflection.
drawFigure(g, shape, width - x1, y1, width - x2, y2);
}
if (symmetry >= SYMMETRY_4) { // Draw the two vertical reflections.
drawFigure(g, shape, x1, height - y1, x2, height - y2);
drawFigure(g, shape, width - x1, height - y1, width - x2, height - y2);
}
if (symmetry == SYMMETRY_8) { // Draw the four diagonal reflections.
int a1 = (int)( ((double)y1 / height) * width );
int b1 = (int)( ((double)x1 / width) * height );
int a2 = (int)( ((double)y2 / height) * width );
int b2 = (int)( ((double)x2 / width) * height );
drawFigure(g, shape, a1, b1, a2, b2);
drawFigure(g, shape, width - a1, b1, width - a2, b2);
drawFigure(g, shape, a1, height - b1, a2, height - b2);
drawFigure(g, shape, width - a1, height - b1, width - a2, height - b2);
}
}
private void repaintRect(int x1, int y1, int x2, int y2) {
// Call repaint on a rectangle that contains the points (x1,y1)
// and (x2,y2). (Add a 1-pixel border along right and bottom
// edges to allow for the pen overhang when drawing a line.)
int x, y; // top left corner of rectangle that contains the figure
int w, h; // width and height of rectangle that contains the figure
if (x2 >= x1) { // x1 is left edge
x = x1;
w = x2 - x1;
}
else { // x2 is left edge
x = x2;
w = x1 - x2;
}
if (y2 >= y1) { // y1 is top edge
y = y1;
h = y2 - y1;
}
else { // y2 is top edge.
y = y2;
h = y1 - y2;
}
repaint(x,y,w+1,h+1);
}
private void repaintMultiRect(int x1, int y1, int x2, int y2) {
// Call repaint on a rectangle that contains the points (x1,y1)
// and (x2,y2). Also call repaint on reflections of this
// rectangle, depending on the type of symmetry. The
// rects are repainted by calling repaintRect().
int width = getWidth();
int height = getHeight();
repaintRect(x1,y1,x2,y2); // repaint the original rect
if (symmetry >= SYMMETRY_2) { // repaint the horizontal reflection.
repaintRect(width - x1, y1, width - x2, y2);
}
if (symmetry >= SYMMETRY_4) { // repaint the two vertical reflections.
repaintRect(x1, height - y1, x2, height - y2);
repaintRect(width - x1, height - y1, width - x2, height - y2);
}
if (symmetry == SYMMETRY_8) { // repaint the four diagonal reflections.
int a1 = (int)( ((double)y1 / height) * width );
int b1 = (int)( ((double)x1 / width) * height );
int a2 = (int)( ((double)y2 / height) * width );
int b2 = (int)( ((double)x2 / width) * height );
repaintRect(a1, b1, a2, b2);
repaintRect(width - a1, b1, width - a2, b2);
repaintRect(a1, height - b1, a2, height - b2);
repaintRect(width - a1, height - b1, width - a2, height - b2);
}
}
private void checkOSI() {
// This method is responsible for creating the off-screen image.
// It should be called before using the OSI. It will make a new OSI if
// the size of the panel changes.
if (OSI == null || widthOfOSI != getSize().width || heightOfOSI != getSize().height) {
// Create the OSI, or make a new one if panel size has changed.
OSI = null; // (If OSI already exists, this frees up the memory.)
undoBuffer = null; // (Free memory.)
widthOfOSI = getWidth();
heightOfOSI = getHeight();
OSI = createImage(widthOfOSI,heightOfOSI);
Graphics OSG = OSI.getGraphics(); // Graphics context for drawing to OSI.
OSG.setColor(getBackground());
OSG.fillRect(0, 0, widthOfOSI, heightOfOSI);
OSG.dispose();
undoBuffer = createImage(widthOfOSI,heightOfOSI);
OSG = undoBuffer.getGraphics(); // Graphics context for drawing to undoBuffer
OSG.setColor(getBackground());
OSG.fillRect(0, 0, widthOfOSI, heightOfOSI);
OSG.dispose();
}
}
public void paintComponent(Graphics g) {
// Copy the off-screen image to the screen,
// after checking to make sure it exists. Then,
// if a shape other than CURVE is being drawn,
// draw it on top of the image from the OSI.
checkOSI();
g.drawImage(OSI, 0, 0, this);
if (dragging && figure != CURVE) {
g.setColor(dragColor);
putMultiFigure(g,figure,startX,startY,mouseX,mouseY);
}
}
public void actionPerformed(ActionEvent evt) {
// Respond when the user selects an item from the "Control" menu.
String command = evt.getActionCommand();
checkOSI();
if (command.equals("Fill with Black"))
clear(Color.black);
else if (command.equals("Fill with Red"))
clear(Color.red);
else if (command.equals("Fill with Green"))
clear(Color.green);
else if (command.equals("Fill with Blue"))
clear(Color.blue);
else if (command.equals("Fill with Cyan"))
clear(Color.cyan);
else if (command.equals("Fill with Magenta"))
clear(Color.magenta);
else if (command.equals("Fill with Yellow"))
clear(Color.yellow);
else if (command.equals("Fill with White"))
clear(Color.white);
else if (command.equals("Fill with Custom"))
clear(customColor);
else if (command.equals("Set Custom Color...")) {
Color c = JColorChooser.showDialog(this,"Select Custom Color",customColor);
if (c != null) {
// Change the custom color and select it for use as
// the drawing color.
customColor = c;
custom.setSelected(true);
}
}
else if (command.equals("Clear")) {
// Clear to current background color.
Graphics g = OSI.getGraphics();
g.setColor(getBackground());
g.fillRect(0,0,getSize().width,getSize().height);
g.dispose();
repaint();
}
else if (command.equals("Undo")) {
// Undo the most recent drawing operation
// by swapping OSI with undoBuffer.
Image temp = OSI;
OSI = undoBuffer;
undoBuffer = temp;
repaint();
}
else if (command.equals("Quit")) {
// Close the window and exit. Note: The
// exit command will cause an error when
// the frame is opened from an applet.
// An applet should set the frame's standAlone
// variable to false after creating the frame.
dispose();
if (standAlone)
System.exit(0);
}
}
private void clear(Color background) {
// Fill with the specified color. If the
// color is equal to the current drawing color, then
// the current drawing color is changed, so that
// drawing operations will not be invisible.
setBackground(background);
if (background.equals(getSelectedColor())) {
if (background.equals(Color.black))
white.setSelected(true); // On a black background, draw in white.
else
black.setSelected(true); // On other backgrounds, use black.
}
Graphics g = OSI.getGraphics();
g.setColor(getBackground());
g.fillRect(0,0,getSize().width,getSize().height);
g.dispose();
repaint();
}
public void mousePressed(MouseEvent evt) {
// This is called when the user presses the mouse on the
// panel. This begins a draw operation in which the user
// sketches a curve or draws a shape. (Note that curves
// are handled differently from other shapes. For CURVE,
// a new segment of the curve is drawn each time the user
// moves the mouse. For the other shapes, a "rubber band
// cursor" is used. That is, the figure is drawn between
// the starting point and the current mouse location.)
if (dragging == true) // Ignore mouse presses that occur
return; // when user is already drawing a curve.
// (This can happen if the user presses
// two mouse buttons at the same time.)
prevX = startX = evt.getX(); // Save mouse coordinates.
prevY = startY = evt.getY();
figure = getSelectedShape(); // Get data from menus for drawing.
symmetry = getSelectedSymmetry();
dragColor = getSelectedColor();
checkOSI();
Graphics undoGraphics = undoBuffer.getGraphics();
undoGraphics.drawImage(OSI,0,0,null); // Remember the current image,
// for "Undo" operations,
// before changing the image.
undoGraphics.dispose();
dragGraphics = OSI.getGraphics();
dragGraphics.setColor(dragColor);
dragging = true; // Start drawing.
} // end mousePressed()
public void mouseReleased(MouseEvent evt) {
// Called whenever the user releases the mouse button.
// If the user was drawing a shape, we make the shape
// permanent by drawing it to the off-screen image.
if (dragging == false)
return; // Nothing to do because the user isn't drawing.
dragging = false;
mouseX = evt.getX();
mouseY = evt.getY();
if (figure == CURVE) {
// A CURVE is drawn as a series of LINEs
putMultiFigure(dragGraphics,LINE,prevX,prevY,mouseX,mouseY);
repaintMultiRect(prevX,prevY,mouseX,mouseY);
}
else if (figure == LINE) {
repaintMultiRect(startX,startY,prevX,prevY);
if (mouseX != startX || mouseY != startY) {
// Draw the line only if it has non-zero length.
putMultiFigure(dragGraphics,figure,startX,startY,mouseX,mouseY);
repaintMultiRect(startX,startY,mouseX,mouseY);
}
}
else {
repaintMultiRect(startX,startY,prevX,prevY);
if (mouseX != startX && mouseY != startY) {
// Draw the shape only if both its height
// and width are both non-zero.
putMultiFigure(dragGraphics,figure,startX,startY,mouseX,mouseY);
repaintMultiRect(startX,startY,mouseX,mouseY);
}
}
dragGraphics.dispose();
dragGraphics = null;
}
public void mouseDragged(MouseEvent evt) {
// Called whenever the user moves the mouse while a mouse button
// is down. If the user is drawing a curve, draw a segment of
// the curve on the off-screen image, and repaint the part
// of the panel that contains the new line segment. Otherwise,
// just call repaint and let paintComponent() draw the shape on
// top of the picture in the off-screen image.
if (dragging == false)
return; // Nothing to do because the user isn't drawing.
mouseX = evt.getX(); // x-coordinate of mouse.
mouseY = evt.getY(); // y=coordinate of mouse.
if (figure == CURVE) {
// A CURVE is drawn as a series of LINEs.
putMultiFigure(dragGraphics,LINE,prevX,prevY,mouseX,mouseY);
repaintMultiRect(prevX,prevY,mouseX,mouseY);
}
else {
// Repaint two rectangles: The one that contains the previous
// version of the figure, and the one that will contain the
// new version. The first repaint is necessary to restore
// the picture from the off-screen image in that rectangle.
repaintMultiRect(startX,startY,prevX,prevY);
repaintMultiRect(startX,startY,mouseX,mouseY);
}
prevX = mouseX; // Save coords for the next call to mouseDragged or mouseReleased.
prevY = mouseY;
} // end mouseDragged.
public void mouseEntered(MouseEvent evt) { } // Some empty routines.
public void mouseExited(MouseEvent evt) { } // (Required by the MouseListener
public void mouseClicked(MouseEvent evt) { } // and MouseMotionListener
public void mouseMoved(MouseEvent evt) { } // interfaces).
} // end nested class Display
} // end class KaleidaPaint
[ Exercises
| Chapter Index
| Main Index
]
