DrawingApplet is used for a drawing panel and it is associated
* with a DrawingStuff object that provides automatic repaint, using
* an off-screen image.
* The DrawingStuff also implements listeners for handling keyboard
* and mouse events that concern the DrawingApplet.
*
* A subclass of DrawingApplet may be instanciated directly as an
* applet.
* In this case, a GrafPort object is also allocated and it provides an
* interface for QuickDraw-like drawing and event routines.
* This GrafPort is available by a call to the getPort()
* method.
* Any subclass of DrawingApplet that overrides the
* init(), destroy() or paint(Graphics)
* methods, should call these in turn to provides suitable working.
* The start() method does nothing and any subclass of
* DrawingApplet should override it.
*
* A DrawingApplet object is also instanciated during the explicit
* initialization of a GrafPort.
* In that case the DrawingApplet is set as the component of a
* DrawingFrame and it doesn't need direct control.
*
* @version 22 mar 2004
* @author Philippe Chassignet, Ecole Polytechnique
* @see DrawingStuff
* @see GrafPort
* @see DrawingFrame
*/
public class DrawingApplet extends Applet
implements ComponentListener {
// the GrafPort object is available through a call to getPort.
private GrafPort port;
// the DrawingFrame object is available through a call to getFrame.
private DummyFrame frame;
// the DrawingStuff object is available through a call to getStuff.
private DrawingStuff stuff;
private Dimension size;
private boolean isApplet;
/**
* The default constructor for a DrawingApplet used as an applet.
* A GrafPort will be later allocated during the call to the
* init() method.
*
* @see #init()
*/
public DrawingApplet() {
port = null;
frame = new DummyFrame(this); // A DummyFrame is allocated in place of a real DrawingFrame.
isApplet = true; // An AppletStub is already allocated.
}
/**
* The constructor for a DrawingApplet when put inside a
* DrawingFrame.
* A GrafPort and the parent DrawingFrame are already
* allocated, the init(int, int) method will be later explicitely
* called by the DrawingFrame constructor.
*
* @param the already allocated GrafPort.
* @param width the initial width of the panel
* @param height the initial height of the panel
*/
DrawingApplet(GrafPort g, int width, int height) {
port = g;
frame = null;
isApplet = false;
setStub(new DrawingStub(this));
prefSize(new Dimension(width, height));
}
/**
* Called by init() or explicitely called from a
* DrawingFrame constructor.
* The given parameters are the final dimensions for the off-screen image.
* It returns the DrawingStuff object.
*
* @param width the final width of the off-screen image
* @param height the final height of the off-screen image
*/
DrawingStuff init(int width, int height) {
if ( getParent() != null )
setName(getParent().getName()+"."+getName());
setBackground(Color.white);
setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
stuff = new DrawingStuff(this, width, height, getParameter("MACLIB_DEBUG"));
addMouseListener(stuff);
addMouseMotionListener(stuff);
addKeyListener(stuff);
if ( port == null )
port = new GrafPort(this);
addComponentListener(this);
return stuff;
}
/**
* The init method as for any applet.
* It is called by the browser or applet viewer to inform this applet
* that it has been loaded into the system. It is always called before
* the first time that the start() method is called.
*
* Any subclass of DrawingApplet that overrides this method,
* should call this in turn to provides suitable initialization.
*
* @see java.applet.Applet#init()
*/
public void init() {
init(DrawingStuff.DEFAULT_SCREEN_WIDTH, DrawingStuff.DEFAULT_SCREEN_HEIGHT);
((DummyFrame)frame).setStuff(stuff);
}
/**
* The start method as for any applet.
* Called by the browser or applet viewer to inform this applet
* that it should start its execution. It is called after
* the init() method and each time the applet is revisited
* in a Web page.
*
* This method does nothing and any subclass of DrawingApplet should
* override it, to perform any drawings each time the Web page containing it is
* visited.
*
* @see java.applet.Applet#start()
*/
public void start() {
trace_if_verbose("starting DrawingApplet") ;
}
/**
* The stop method as for any applet.
* Called by the browser or applet viewer to inform this applet
* that it should stop its execution. It is called when
* the Web page that contains this applet has been replaced by
* another page, and also just before the applet is to be destroyed.
*
* This method does nothing and any subclass of DrawingApplet has
* to override it, when stop processing is needed.
*
* @see java.applet.Applet#stop()
*/
public void stop() {
trace_if_verbose("stopping DrawingApplet") ;
}
/**
* The destroy method as for any applet.
* Called by the browser or applet viewer to inform this applet
* that it is being reclaimed and that it should destroy any resources
* that it has allocated. The stop() method will always
* be called before destroy().
*
* Any subclass of DrawingApplet that overrides this method,
* should call this in turn to provides suitable memory cleaning.
*
* @see java.applet.Applet#destroy()
*/
public void destroy() {
if ( stuff != null ) {
trace_if_verbose("destroying DrawingApplet") ;
dispose();
}
}
/**
* Returns a string giving informations about this DrawingApplet.
*
* Any subclass of DrawingApplet that overrides this method,
* should include this one.
*
* @return the string of informations
*/
public String getAppletInfo() {
return "DrawingApplet implements QuickDraw-like drawing routines\n"
+ "P.Chassignet, Ecole Polytechnique, 2001-2003";
}
/**
* Returns the DrawingFrame attached to this DrawingApplet.
* for true applet
*/
DummyFrame getFrame() {
return frame;
}
/**
* Returns the attached DrawingStuff object that provides
* drawings with automatic repaint and interfaces for keyboard and mouse
* events.
*
* @return the DrawingStuff object
*/
public DrawingStuff getStuff() {
return stuff;
}
/**
* Returns the GrafPort object that provides QuickDraw-like
* drawing and event routines onto this panel.
*
* @return the GrafPort object
*/
public GrafPort getPort() {
// port.reset();
return port;
}
/**
* Disposes of this DrawingApplet.
* This method must be called to release the resources.
*/
public synchronized void dispose() {
trace_if_verbose("disposing "+isApplet+" DrawingApplet");
setVisible(false);
if ( isApplet && port != null ) {
port.dispose();
port = null;
}
removeKeyListener(stuff);
removeMouseMotionListener(stuff);
removeMouseListener(stuff);
if ( stuff != null ) {
stuff.dispose();
stuff = null;
}
trace_if_verbose("DrawingApplet disposed");
}
/**
* Called by the garbage collector when there are no more reference to
* this DrawingApplet.
*/
public synchronized void finalize() {
if ( stuff != null )
dispose();
// else dispose() is assumed to have been already explicitely called
}
public void prefSize(Dimension size) {
trace_if_verbose("setPreferredSize -> "+size);
this.size = size;
}
public Dimension getPreferredSize() {
trace_if_verbose("getPreferredSize -> "+size);
// return preferredSize();
return size;
}
/**
* Invoked by the event handler when this panel needs to be repaint.
* It results in copying the content of the attached off-screen image.
*
* Any subclass of DrawingApplet that overrides this method,
* should call this in turn to provides suitable update.
*
* @param g the specified Graphics object for painting onto
* this panel
*/
public void paint(Graphics g) {
if ( stuff != null )
stuff.paint(g);
}
public void update(Graphics g) {
paint(g);
}
// ComponentListener
/**
* Invoked when the panel has been resized.
*/
public void componentResized(ComponentEvent e) {
prefSize(getSize());
trace_if_verbose("panel resized "+getBounds());
}
/**
* Invoked when the panel has been moved.
*/
public void componentMoved(ComponentEvent e) {
trace_if_verbose("panel moved "+getBounds());
}
/**
* Invoked when the panel has been made visible.
*/
public void componentShown(ComponentEvent e) {
trace_if_verbose("panel shown "+getBounds());
}
/**
* Invoked when the panel has been hidden.
*/
public void componentHidden(ComponentEvent e) {
trace_if_verbose("panel hidden "+getBounds());
}
/**
* Returns a string representation of the state of this DrawingApplet.
* Invoked by the inherited method toString().
*
* @return the string representation of internal parameters.
*/
protected String paramString() {
return super.paramString() + "," + stuff;
}
/**
* Prints a string when verbose mode is enabled.
* For internal debug purpose only.
*/
void trace_if_verbose(String str) {
if ( stuff != null )
stuff.trace_if_verbose(str);
}
} // end class DrawingApplet
// A DrawingStub is used when the DrawingApplet is instanciated inside a DrawingFrame.
class DrawingStub implements AppletStub {
private DrawingApplet panel;
public DrawingStub(DrawingApplet panel) {
this.panel = panel;
}
public AppletContext getAppletContext() {
System.err.println("getAppletContext");
return null;
}
public URL getDocumentBase() {
System.err.println("getDocumentBase");
return null;
}
public URL getCodeBase() {
System.err.println("getCodeBase");
return null;
}
public void appletResize(int width, int height) {
panel.trace_if_verbose("appletResize "+width+" "+height);
panel.prefSize(new Dimension(width, height));
}
public String getParameter(String name) {
String value;
try {
value = System.getProperty(name);
} catch (SecurityException e) { value = null; }
if ( !name.equals("MACLIB_DEBUG") )
System.err.println("getParameter "+name);
return value;
}
public boolean isActive() {
System.err.println("isActive");
return false;
}
} // end class DrawingStub
// A DummyFrame is used when the DrawingApplet is instanciated as an applet.
class DummyFrame extends DrawingFrame {
private DrawingApplet applet;
private DrawingStuff stuff;
DummyFrame(DrawingApplet applet) {
super(false);
this.applet = applet;
}
void setStuff(DrawingStuff stuff) {
this.stuff = stuff;
}
/**
* Prints a string in status line.
*
* @param s the string to be printed.
*/
public void showStatus(String s) {
applet.showStatus(s);
}
/**
* Shows or hides the applet panel depending on the parameter.
*
* @param b if true, shows,
* if false, hides.
*/
public void setVisible(boolean b) {
applet.setVisible(b);
}
/**
* Returns a string representation of the state of this DummyFrame.
*
* @return the string representation of internal parameters.
*/
public String toString() {
return "DummyFrame applet=" + applet + "}";
}
} // end class DummyFrame