View source for Grinding2.java

<PRE>
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;
}
</PRE>
[[Category:Grinding Java]]