Alternatives to action

As

noted previously,

isn’t the only method that’s automatically called by

You

can see that each method receives an

object along with some information that you’ll typically need when

you’re handling that particular situation – with a mouse event, for

example, it’s likely that you’ll want to know the coordinates where

the mouse event occurred. It’s interesting to note that when

’s

calls any of these methods (the typical case), the extra arguments are always

redundant as they are contained within the

object. In fact, if you look at the source code for

you can see that it explicitly plucks the additional arguments out of the

object. (This might be considered inefficient coding in some languages, but

remember that Java’s focus is on safety, not necessarily speed.)

To

prove to yourself that these events are in fact being called and as an

interesting experiment, it’s worth creating an applet that overrides each

of the methods above (except for

which

is overridden in many other places in this chapter) and displays data about

each of the events as they happen.

This

example also shows you how to make your own button object because that’s

what is used as the target of all the events of interest. You might first

(naturally) assume that to make a new button, you’d inherit from

The

class is specific: it works only with an

“parent window” (not a base class, but the window in which this

button is created and lives). With this knowledge,

can reach into the parent window and manipulate its text fields, which is

what’s necessary to be able to write the status information into the

fields of the parent. Of course this is a much more limited solution, since

can be used only in conjunction with

.

This kind of code is sometimes called “highly coupled.” However, to

make

more generic requires a lot more effort that isn’t warranted for this

example (and possibly for many of the applets that you will write). Again, keep

in mind that the following code uses APIs that are deprecated in Java 1.1

//: AutoEvent.java
// Alternatives to action()
import java.awt.*;
import java.applet.*;
import java.util.*;
 
class MyButton extends Canvas {
  AutoEvent parent;
  Color color;
  String label;
  MyButton(AutoEvent parent,
           Color color, String label) {
    this.label = label;
    this.parent = parent;
    this.color = color;
  }
  public void paint(Graphics  g) {
    g.setColor(color);
    int rnd = 30;
    g.fillRoundRect(0, 0, size().width,
                    size().height, rnd, rnd);
    g.setColor(Color.black);
    g.drawRoundRect(0, 0, size().width,
                    size().height, rnd, rnd);
    FontMetrics fm = g.getFontMetrics();
    int width = fm.stringWidth(label);
    int height = fm.getHeight();
    int ascent = fm.getAscent();
    int leading = fm.getLeading();
    int horizMargin = (size().width - width)/2;
    int verMargin = (size().height - height)/2;
    g.setColor(Color.white);
    g.drawString(label, horizMargin,
                 verMargin + ascent + leading);
  }
  public boolean keyDown(Event evt, int key) {
    TextField t =
      (TextField)parent.h.get("keyDown");
    t.setText(evt.toString());
    return true;
  }
  public boolean keyUp(Event evt, int key) {
    TextField t =
      (TextField)parent.h.get("keyUp");
    t.setText(evt.toString());
    return true;
  }
  public boolean lostFocus(Event evt, Object w) {
    TextField t =
      (TextField)parent.h.get("lostFocus");
    t.setText(evt.toString());
    return true;
  }
  public boolean gotFocus(Event evt, Object w) {
    TextField t =
      (TextField)parent.h.get("gotFocus");
    t.setText(evt.toString());
    return true;
  }
  public boolean
  mouseDown(Event evt,int x,int y) {
    TextField t =
      (TextField)parent.h.get("mouseDown");
    t.setText(evt.toString());
    return true;
  }
  public boolean
  mouseDrag(Event evt,int x,int y) {
    TextField t =
      (TextField)parent.h.get("mouseDrag");
    t.setText(evt.toString());
    return true;
  }
  public boolean
  mouseEnter(Event evt,int x,int y) {
    TextField t =
      (TextField)parent.h.get("mouseEnter");
    t.setText(evt.toString());
    return true;
  }
  public boolean
  mouseExit(Event evt,int x,int y) {
    TextField t =
      (TextField)parent.h.get("mouseExit");
    t.setText(evt.toString());
    return true;
  }
  public boolean
  mouseMove(Event evt,int x,int y) {
    TextField t =
      (TextField)parent.h.get("mouseMove");
    t.setText(evt.toString());
    return true;
  }
  public boolean mouseUp(Event evt,int x,int y) {
    TextField t =
      (TextField)parent.h.get("mouseUp");
    t.setText(evt.toString());
    return true;
  }
}
 
public class AutoEvent extends Applet {
  Hashtable h = new Hashtable();
  String[] event = {
    "keyDown", "keyUp", "lostFocus",
    "gotFocus", "mouseDown", "mouseUp",
    "mouseMove", "mouseDrag", "mouseEnter",
    "mouseExit"
  };
  MyButton
    b1 = new MyButton(this, Color.blue, "test1"),
    b2 = new MyButton(this, Color.red, "test2");
  public void init() {
    setLayout(new GridLayout(event.length+1,2));
    for(int i = 0; i < event.length; i++) {
      TextField t = new TextField();
      t.setEditable(false);
      add(new Label(event[i], Label.CENTER));
      add(t);
      h.put(event[i], t);
    }
    add(b1);
    add(b2);
  }
} ///:~ 

You

can see the constructor uses the technique of using the same name for the

argument as what it’s assigned to, and differentiating between the two

using

:

The

method starts out simple: it fills a “round rectangle” with the

button’s color, and then draws a black line around it. Notice the use of

to determine the width and height of the component (in pixels, of course).

After this,

seems

quite complicated because there’s a lot of calculation going on to figure

out how to center the button’s label inside the button using the

“font metrics.” You can get a pretty good idea of what’s

going on by looking at the method call, and it turns out that this is pretty

stock code, so you can just cut and paste it when you want to center a label

inside any component.

You

can’t understand exactly how the

,

etc. methods work until you look down at the

class. This contains a

The

place where you look up the strings is in the

,

etc. methods back in

.

Each of these methods uses the

handle to reach back to the parent window. Since that parent is an

it contains the

,

and the

method, when provided with the appropriate

,

will produce a handle to an

that we happen to know is a

– so it is cast to that. Then the

object is converted to its

representation, which is displayed in the

.

It

turns out this example is rather fun to play with since you can really see

what’s going on with the events in your program.

|

|