package GUITools;
import java.AWT.*;
import java.AWT.event.*;
import java.util.Vector;
/**
* Docable toolbar class written by Shai Almog 1996.
* revised for JDK 1.1 in 4/97.
* The source is in the public domain and may be modified and used freely.
* It is not a requirment but I would consider it good manners if you credit me
* and EDM/2 (www.edm2.com) in applications in which this code was used ;-)
* The Dockable toolbar class creats a toolbar container that can be torn
* off the Frame holding it and left to hover above it.
* It's based on the panel and Window classes and it must be put
* on a frame.
* A problem with the Dockable toolbar is the way different implementations
* of the JDK treat the Window class. This creates a highly unportable
* implementation, the solution was to abstract everything and hope that
* a future implementation of the JDK solves this problem.
**/
public class DockableToolbar extends
java.AWT.Panel
implements java.AWT.event.ActionListener
{
public DockableToolbar(Frame Owner) // Owner is the component who owns the Toolbar.
{
this.Owner = Owner; // This is an easy trick to avoid confusion with parameters
// This way you don't have to invent a name for every parameter.
setLayout(new FlowLayout()); // The flow layout just puts the Components
// one after the other as best as it can. No better is needed here.
addToolbarToOwner(); // This method will add the panel and the frame to
}
public void actionPerformed(ActionEvent E) // This method get calls by the action listener.
{
if(E.getSource() instanceof Button) // If the event source is a button
sendEvent(whichButtonGotPressed((Button)E.getSource())); // Send an event with the
// serial numeber of the button.This enables us to create the buttons in the
// toolbar and not in the program, to further simplify the programmers life ....
}
/**
* This method allows an object to listen to events dispatched by the toolbar,
* in a similar way to listening to events dispatched by buttons.
**/
public void addActionListener(ActionListener listener)
{
listOfActionListeners.addElement(listener);
}
public void addButton(Button B) // This method add's a button object to the toolbar.
{
add(B); // Add the button to the Panel.
listOfButtons.addElement((Object)B);
B.addActionListener(this); // Listen to button related events.
}
public void addButton(String caption) // This method creats a new button and adds it.
{
addButton(new Button(caption));
}
private void addToolbarToOwner() // This method add's the panel to the Frame.
{
Owner.add(this);
}
/**
* This method, removes the toolbar from the docking position and makes it
* hover in the air above the toolbar.
**/
public void detachToolbar()
{
detachedToolbar = new Window(Owner); // Here we create a window object
// above the Frame.
detachedToolbar.setLayout(new BorderLayout()); // We will only have one
// component in the frame (the Panel), but it's best to do it this way.
detachedToolbar.add("South", this); // We add this (the Panel) to the frame yet keep
// it hidden.
Owner.remove(this); // We remove the Panel from the Frame.
systemSpecificToolbarCalibration(); // This part was moved to a separate
// function do to problems with VA-Java.
detachedToolbar.show(); // Show the toolbar.
Owner.pack(); // Sort the items in the window where the toolbar was removed from.
}
/**
* This method takes a Toolbar that is hovering and
* dock's it into place.
**/
public void dockToolbar()
{
Owner.add(this); // Return the Panel into the frame.
Owner.pack(); // Sort the items in the Frame.
detachedToolbar.removeAll(); // Remove the panel from the toolbar.
detachedToolbar.dispose(); // Destroy the toolbar.
}
/**
* This method sends button events to all of the listeners.
**/
private void sendEvent(int idOfTheButtonPressed)
{
ActionListener currentListener;
ActionEvent E = new
ActionEvent(listOfButtons.elementAt(idOfTheButtonPressed),
ActionEvent.ACTION_PERFORMED,
Integer.toString(idOfTheButtonPressed));
for (int counter = 0; counter < listOfActionListeners.size() ; counter++)
{
currentListener = (ActionListener)listOfActionListeners.elementAt(counter);
currentListener.actionPerformed(E);
}
}
private int whichButtonGotPressed(Button B)
{ // This method returns the Buttons offset in the vector.
for (int counter = 0; counter < listOfButtons.size() ; counter++)
if(listOfButtons.elementAt(counter).equals(B)) return(counter);
return(-1);
}
private void systemSpecificToolbarCalibration()
{
Dimension windowSize = detachedToolbar.getSize();
buttonSize = ((Component)listOfButtons.elementAt(0)).getSize();
detachedToolbarTitleBar = new ToolbarTitleBar(windowSize.width,3);
detachedToolbar.add("North", detachedToolbarTitleBar);
detachedToolbar.pack();
}
private Window detachedToolbar;
private ToolbarTitleBar detachedToolbarTitleBar;
private Button exitButton = new Button("Exit");
private Label helloAWTLabel = new Label("Hello AWT");
private Vector listOfActionListeners = new Vector();
private Vector listOfButtons = new Vector();
private Frame Owner;
}
/**
* This class is for internal use only. It paints the title on top of
* the detached window.
**/
class ToolbarTitleBar extends Canvas
{
ToolbarTitleBar(int width, int height)
{
super();
setSize(width,height); // Canvas on the window top in 3 pixel height.
this.height = height;
this.width = width;
}
public void paint(Graphics g)
{
g.setColor(SystemColor.activeCaption); // The SystemColor class
// contains colors specific to this system.
g.fillRect(0,0,width,i);
}
private int height,width;
}