Grinding3.java

package GUITools;

import java.AWT.*;
import java.AWT.event.*;
import java.util.Vector;

/**
 * The Tooltip class was developed for use by the DockableToolbar class,
 * I chose to make it public since i feel that with slight modification
 * it can be used in other classes.
 * This class doesn't have a simple API (mostly because it was developed
 * for internal use), it has a more generic wrapper (class Hints) which I recommend on using.
 * This class draws a yellow label tooltip (or hint/hovering help...).
 * The Tooltip class only displays a tooltip at a given X,Y location in
 * A container, if that container has Components in it that hide the tooltip
 * it will try to display on them too. The mouse functionality and the full
 * capabilities of a Tooltip are not implemented here, I will probably subclass
 * this class in a later stage to create an automatic Tooltip facility.
 * This class was developed to run under JDK 1.1.1, with very little assistance
 * from VisualAge for Java, most of the work was done using javac.
 * This class was written by Shai Almog 5/4/97. The source is in the public
 * domain and may be modified and used freely. It is not a requirement 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 ;-)
**/

public class Tooltip extends Canvas
// The reason we extend Canvas and not Component
// is due to a bug in VisualAge for Java which did not allow this.
{
     /**
     * The Tooltip constructor takes the following parameters
     * caption - the text of the tooltip.
     * tooltipFont - the font of the tooltip.
     * c - The Container on which the Tooltip will be displayed.
     * x - The x axis on which the Tooltip will be placed. Relative to the container.
     * y - The y asis on which the Tooltip will be placed. Relative to the container.
     */
     public Tooltip(String caption,Font tooltipFont,Container c,int x, int y)
     {
          super(); // Calling the parent class constructor.
          containerOnWhichTheTooltipShows = c;
          containerOnWhichTheTooltipShows.add(this); // Adding ourselves as a component
                                                     // of the container.
          this.tooltipFont = tooltipFont;
          this.caption = caption;
          FontMetrics fontSize = getToolkit().getFontMetrics(tooltipFont); // Checking the
                                                              // size of the font.
          width = fontSize.stringWidth(caption); // Computing the size of the box in which
                                                 // the string
          height = fontSize.getHeight();         // should be shown.
          if (x < 0) x = 0; // Checking the validity of the x and y parameters.
          if (y < 0) y = 0; // This should be the job of the class displaying the Tooltip,
          if (x + width > containerOnWhichTheTooltipShows.getSize().width) // but we want
                                           // robust code!
          x = containerOnWhichTheTooltipShows.getSize().width - width;
          if (y + height > containerOnWhichTheTooltipShows.getSize().height)
          y = containerOnWhichTheTooltipShows.getSize().height - height;
          this.x = x;
          this.y = y;
      }

     /**
     * The dispose method removes the remains of the tooltip from the Container
     * This method must be called to remove the Tooltip!
     */
     public void dispose()
     {
          containerOnWhichTheTooltipShows.remove(this); // Removing the tooltip
                                               // Component from the container.
          if(listOfComponentsToDrawOn != null) // If we drew on any Components
                                               // other than the Container.
           for (int counterOfComponentsToDrawOn = 0;
                   counterOfComponentsToDrawOn < listOfComponentsToDrawOn.length;
                   counterOfComponentsToDrawOn++)
          {
               if ((listOfComponentsToDrawOn[counterOfComponentsToDrawOn] instanceof Button) &&

                   (!(listOfComponentsToDrawOn[counterOfComponentsToDrawOn] instanceof ImageButton)))
               { // This is a patch to prevent buttons from disappearing when you repaint them.
                 // For some reason in windows JDK when I call repaint on a Button it vanishes.
                        Button b =  (Button)
                                       listOfComponentsToDrawOn[counterOfComponentsToDrawOn];
                        b.setLabel(b.getLabel());
                }
               else
               {
                   listOfComponentsToDrawOn[counterOfComponentsToDrawOn].repaint();
                   listOfComponentsToDrawOn[counterOfComponentsToDrawOn].validate();
               }
           }
     }

     public int getHeight() // This method returns the height of the Tooltip.
     {
          return (height);
     }

     public int getWidth() // This method returns the width of the Tooltip.
     {
          return (width);
     }

     public int getX()     // Returns the x axis of the tooltip.
     {
          return (x);
     }

     public int getY()     // Returns the y axis of the tooltip.
     {
          return (y);
     }

     /**
     * This method draws the Tooltip on the Container and then seeks all of the
     * components that overlap the Tooltip in the Container and it draws
     * the parts that were clipped by that Component on every sub Component.
     **/
     public void paint(Graphics g)
     {
         // The paint is called with a clipped graphics. we draw but
         // clipping will probably occur so we must fix it.
         // We don't fix clipping at the end of the Container! That
         // is the applications responsibility.
          g.setColor(Color.black);
          g.fillRect(x,  y, width + 2,height + 2);
          g.setColor(Color.yellow);
          g.fillRect(x + 1,y + 1,width,height);
          g.setColor(Color.black);
          g.setFont(tooltipFont);
          g.drawString(caption,x + 1,y + height - 1);
          if (containerOnWhichTheTooltipShows.getComponentCount() != 0)
          { // if there are any components, check for clipping.
              if(listOfComponentsToDrawOn == null)
              listOfComponentsToDrawOn = getComponentsAt(x,  y, width + 2,height + 2);
              if(listOfComponentsToDrawOn != null)
              for (int componentIterator = 0;
                  componentIterator <  listOfComponentsToDrawOn.length;
                  componentIterator++)
                       drawLabelOnComponent(listOfComponentsToDrawOn[componentIterator],
                                            new Point(x,  y),
                                            new Point(x + width + 2,y + height + 2));
           }
     }

     /**
     * This method draws the fragment of the tooltip that shows on the Component
     * on too a Component. It gets absolute positions relative to the Container and
     * computes the points relative to the Container.
     */
     private void drawLabelOnComponent(Component c, Point topLeft, Point bottomRight)
     {
          // This method computes the X and Y relative to the
          // Component and not the Container.
          computeAbsolutePointsInComponents(c.getLocation(),topLeft, bottomRight);

          Graphics g = c.getGraphics();
          if(g != null)
          {
              g.setColor(Color.black);
              g.fillRect(topLeft.x,  topLeft.y, bottomRight.x - topLeft.x - 2,
                         bottomRight.y - topLeft.y - 2);
              g.setColor(Color.yellow);
              g.fillRect(topLeft.x + 1,topLeft.y + 1,bottomRight.x - 3 - topLeft.x,
                         bottomRight.y - 3 - topLeft.y);
              g.setColor(Color.black);
              g.setFont(tooltipFont);
              g.drawString(caption,topLeft.x + 1,bottomRight.y - 3);
          }
     }

     /**
     * The getComponentsAt method is called by paint and returns an array of
     * Components that are overlapping the boundaries given to it.
     * This is used to determine on which of the Components the Tooltip should be
     * drawn.
     */
     private Component[] getComponentsAt(int x, int y, int width, int height)
     {
          Component[] listOfComponents =
                          containerOnWhichTheTooltipShows.getComponents();
                          // Getting all of the Components in the Container.
          int componentCounter = listOfComponents.length;
          for (int componentIterator = 0 ; componentIterator < listOfComponents.length ;
               componentIterator++)
          { // Filtering out the Components that don't overlap.
            if (!isClipping(listOfComponents[componentIterator],new Point(x,y),
                  new Point(width + x,height + y)))
            {
                  listOfComponents[componentIterator] = null;
                  componentCounter--;
            }
          }
          if(componentCounter > 0) // If any Component overlaps...
          {
              Component[] returnValue = new Component[componentCounter];
              // Allocate space for the overlaping Components.
              int componentIterator = 0, secondaryComponentIterator = 0;
              for (; componentIterator < listOfComponents.length ; componentIterator++)
                 if(listOfComponents[componentIterator] != null)
                 { // Create a new filterd list of Components.
                   returnValue[secondaryComponentIterator] =
                                       listOfComponents[componentIterator];
                   secondaryComponentIterator++;
                 }
              return(returnValue);
          }
          else return(null);
    }

     /**
      * The isClipping method is used by the getComponentsAt method to determine if
      * 2 Components overlap each other.
      * This method returns true if the component will clip the location to bottom
      * rectangle.
     **/
     private boolean isClipping(Component c,Point location,Point bottom)
     {
          Point cLocation = c.getLocation(),
          cBottom = new Point(cLocation.x + c.getSize().width,
                              c.getSize().height + cLocation.y),
          topRight = new Point(bottom.x,location.y),
          bottomLeft = new Point(location.x,bottom.y);

          return(isPointInTheMiddle(location,cLocation,cBottom)
                || isPointInTheMiddle(bottom,cLocation,cBottom)
                || isPointInTheMiddle(topRight,cLocation,cBottom)
                || isPointInTheMiddle(bottomLeft,cLocation,cBottom));
     }

     /**
      * This method is used by the isClipping method to determine if the point
      * p is in the rectangle between points top and bottom.
     **/
     private static boolean isPointInTheMiddle(Point p,Point top,Point bottom)
     {
          return(((p.x >= top.x) && (p.x <= bottom.x) &&
                  (p.y >= top.y) && (p.y <= bottom.y)));
      }

     /**
      * The computeAbsolutePointsInComponents method is used by the
      * drawLabelOnComponent method to convert the Container based point to
      * Component asis points.
     **/
     private void computeAbsolutePointsInComponents(Point origin, Point topLeft,
                                                    Point bottomRight)
     {
          topLeft.x = topLeft.x - origin.x;
          bottomRight.x = bottomRight.x - origin.x;
          topLeft.y = topLeft.y - origin.y;
          bottomRight.y = bottomRight.y - origin.y;
     }

     public static int MINIMUM_SPACE_FOR_TOOLTIP = 50; // These are some
                                                       // constants to help place
     public static int LEFT_SPACE_FOR_TOOLTIP = 100;   // Tooltips in the
                                                       // Correct position.
     public static int RIGHT_SPACE_FOR_TOOLTIP = 10;
     private Component[] listOfComponentsToDrawOn;     // This is the list of Components
                                                       // we are drawing on.
     private Container containerOnWhichTheTooltipShows;// The container on which the
                                                       // Tooltip shows.
     private String caption; // The text of the Tooltip.
     private int x; // The tooltips x asis.
     private int y; // The tooltips y asis.
     private Font tooltipFont; // The tooltips Font.
     private int width;  // The tooltips width.
     private int height; // The tooltips height.
}