/* BasicToolBarUI.java --
   Copyright (C) 2004, 2005, 2006  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package javax.swing.plaf.basic;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Hashtable;

import javax.swing.AbstractAction;
import javax.swing.AbstractButton;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JToolBar;
import javax.swing.KeyStroke;
import javax.swing.LookAndFeel;
import javax.swing.RootPaneContainer;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.border.Border;
import javax.swing.border.CompoundBorder;
import javax.swing.event.MouseInputListener;
import javax.swing.plaf.ActionMapUIResource;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.ToolBarUI;
import javax.swing.plaf.UIResource;
import javax.swing.plaf.basic.BasicBorders.ButtonBorder;

/**
 * This is the Basic Look and Feel UI class for JToolBar.
 */
public class BasicToolBarUI extends ToolBarUI implements SwingConstants
{

  /**
   * Implements the keyboard actions for JToolBar.
   */
  static class ToolBarAction
    extends AbstractAction
  {
    /**
     * Performs the action.
     */
    public void actionPerformed(ActionEvent event)
    {
      Object cmd = getValue("__command__");
      JToolBar toolBar = (JToolBar) event.getSource();
      BasicToolBarUI ui = (BasicToolBarUI) toolBar.getUI();

      if (cmd.equals("navigateRight"))
        ui.navigateFocusedComp(EAST);
      else if (cmd.equals("navigateLeft"))
          ui.navigateFocusedComp(WEST);
      else if (cmd.equals("navigateUp"))
          ui.navigateFocusedComp(NORTH);
      else if (cmd.equals("navigateDown"))
        ui.navigateFocusedComp(SOUTH);
      else
        assert false : "Shouldn't reach here";
    }
  }

  /** Static owner of all DragWindows.
   * This is package-private to avoid an accessor method.  */
  static JFrame owner = new JFrame();

  /** The border used when the JToolBar is in nonrollover mode. */
  private static Border nonRolloverBorder;

  /** The border used when the JToolBar is in rollover mode. */
  private static Border rolloverBorder;

  /** The last known BorderLayout constraint before floating. */
  protected String constraintBeforeFloating;

  /** The last known orientation of the JToolBar before floating.
   * This is package-private to avoid an accessor method.  */
  int lastGoodOrientation;

  /** The color of the border when it is dockable. */
  protected Color dockingBorderColor;

  /** The background color of the JToolBar when it is dockable. */
  protected Color dockingColor;

  /** The docking listener responsible for mouse events on the JToolBar. */
  protected MouseInputListener dockingListener;

  /** The window used for dragging the JToolBar. */
  protected BasicToolBarUI.DragWindow dragWindow;

  /** The color of the border when it is not dockable. */
  protected Color floatingBorderColor;

  /** The background color of the JToolBar when it is not dockable. */
  protected Color floatingColor;

  /** The index of the focused component. */
  protected int focusedCompIndex;

  /** The PropertyChangeListener for the JToolBar. */
  protected PropertyChangeListener propertyListener;

  /** The JToolBar this UI delegate is responsible for. */
  protected JToolBar toolBar;

  /** The Container listener for the JToolBar. */
  protected ContainerListener toolBarContListener;

  /** The Focus listener for the JToolBar. */
  protected FocusListener toolBarFocusListener;

  /**
   * @deprecated since JDK1.3.
   */
  protected KeyStroke leftKey;

  /**
   * @deprecated since JDK1.3.
   */
  protected KeyStroke rightKey;

  /**
   * @deprecated since JDK1.3.
   */
  protected KeyStroke upKey;

  /**
   * @deprecated since JDK1.3.
   */
  protected KeyStroke downKey;

  /**
   * The floating window that is responsible for holding the JToolBar when it
   * is dragged outside of its original parent.
   */
  private transient Window floatFrame;

  /** The original parent of the JToolBar.
   * This is package-private to avoid an accessor method.  */
  transient Container origParent;

  /** A hashtable of components and their original borders.
   * This is package-private to avoid an accessor method.  */
  transient Hashtable borders;

  /** A window listener for the floatable frame. */
  private transient WindowListener windowListener;

  /** A set of cached bounds of the JToolBar.
   * This is package-private to avoid an accessor method.  */
  transient Dimension cachedBounds;

  /** The cached orientation of the JToolBar.
   * This is package-private to avoid an accessor method.  */
  transient int cachedOrientation;

  /**
   * This method creates a new <code>BasicToolBarUI</code> object for the given JToolBar.
   */
  public BasicToolBarUI()
  {
    // Do nothing here.
  }

  /**
   * This method returns whether the JToolBar can dock at the given position.
   *
   * @param c The component to try to dock in.
   * @param p The position of the mouse cursor relative to the given
   *        component.
   *
   * @return Whether the JToolBar can dock.
   */
  public boolean canDock(Component c, Point p)
  {
    return areaOfClick(c, p) != -1;
  }

  /**
   * This helper method returns the position of the JToolBar if it can dock.
   *
   * @param c The component to try to dock in.
   * @param p The position of the mouse cursor relative to the given
   *        component.
   *
   * @return One of the SwingConstants directions or -1 if the JToolBar can't
   *         dock.
   */
  private int areaOfClick(Component c, Point p)
  {
    // Has to dock in immediate parent, not eventual root container.
    Rectangle pBounds = c.getBounds();

    // XXX: In Sun's implementation, the space the toolbar has to dock is dependent on the size it had last.
    Dimension d = toolBar.getSize();
    int limit = Math.min(d.width, d.height);

    // The order of checking is 1. top 2. bottom 3. left 4. right
    if (! pBounds.contains(p))
      return -1;

    if (p.y < limit)
      return SwingConstants.NORTH;

    if (p.y > (pBounds.height - limit))
      return SwingConstants.SOUTH;

    if (p.x < limit)
      return SwingConstants.WEST;

    if (p.x > (pBounds.width - limit))
      return SwingConstants.EAST;

    return -1;
  }

  /**
   * This method creates a new DockingListener for the JToolBar.
   *
   * @return A new DockingListener for the JToolBar.
   */
  protected MouseInputListener createDockingListener()
  {
    return new DockingListener(toolBar);
  }

  /**
   * This method creates a new DragWindow for the given JToolBar.
   *
   * @param toolbar The JToolBar to create a DragWindow for.
   *
   * @return A new DragWindow.
   */
  protected BasicToolBarUI.DragWindow createDragWindow(JToolBar toolbar)
  {
    return new DragWindow();
  }

  /**
   * This method creates a new floating frame for the JToolBar. By default,
   * this UI uses createFloatingWindow instead. This method of creating a
   * floating frame is deprecated.
   *
   * @param toolbar The JToolBar to create a floating frame for.
   *
   * @return A new floating frame.
   */
  protected JFrame createFloatingFrame(JToolBar toolbar)
  {
    // FIXME: Though deprecated, this should still work.
    return null;
  }

  /**
   * This method creates a new floating window for the JToolBar. This is the
   * method used by default to create a floating container for the JToolBar.
   *
   * @param toolbar The JToolBar to create a floating window for.
   *
   * @return A new floating window.
   */
  protected RootPaneContainer createFloatingWindow(JToolBar toolbar)
  {
    // This one is used by default though.
    return new ToolBarDialog();
  }

  /**
   * This method creates a new WindowListener for the JToolBar.
   *
   * @return A new WindowListener.
   */
  protected WindowListener createFrameListener()
  {
    return new FrameListener();
  }

  /**
   * This method creates a new nonRolloverBorder for JButtons when the
   * JToolBar's rollover property is set to false.
   *
   * @return A new NonRolloverBorder.
   */
  protected Border createNonRolloverBorder()
  {
    Border b = UIManager.getBorder("ToolBar.nonrolloverBorder");
    
    if (b == null)
      {
        b = new CompoundBorder(
            new ButtonBorder(UIManager.getColor("Button.shadow"),
                             UIManager.getColor("Button.darkShadow"),
                             UIManager.getColor("Button.light"),
                             UIManager.getColor("Button.highlight")),
            BasicBorders.getMarginBorder());
      }
    
    return b;  }

  /**
   * This method creates a new PropertyChangeListener for the JToolBar.
   *
   * @return A new PropertyChangeListener.
   */
  protected PropertyChangeListener createPropertyListener()
  {
    return new PropertyListener();
  }

  /**
   * This method creates a new rollover border for JButtons when the
   * JToolBar's rollover property is set to true.
   *
   * @return A new rollover border.
   */
  protected Border createRolloverBorder()
  {
    Border b = UIManager.getBorder("ToolBar.rolloverBorder");
    
    if (b == null)
      {
        b = new CompoundBorder(
            new ButtonBorder(UIManager.getColor("Button.shadow"),
                             UIManager.getColor("Button.darkShadow"),
                             UIManager.getColor("Button.light"),
                             UIManager.getColor("Button.highlight")),
            BasicBorders.getMarginBorder());
      }
    
    return b;
  }

  /**
   * This method creates a new Container listener for the JToolBar.
   *
   * @return A new Container listener.
   */
  protected ContainerListener createToolBarContListener()
  {
    return new ToolBarContListener();
  }

  /**
   * This method creates a new FocusListener for the JToolBar.
   *
   * @return A new FocusListener for the JToolBar.
   */
  protected FocusListener createToolBarFocusListener()
  {
    return new ToolBarFocusListener();
  }

  /**
   * This method creates a new UI delegate for the given JComponent.
   *
   * @param c The JComponent to create a UI delegate for.
   *
   * @return A new UI delegate.
   */
  public static ComponentUI createUI(JComponent c)
  {
    return new BasicToolBarUI();
  }

  /**
   * This method is called to drag the DragWindow around when the JToolBar is
   * being dragged around.
   *
   * @param position The mouse cursor coordinates relative to the JToolBar.
   * @param origin The screen position of the JToolBar.
   */
  protected void dragTo(Point position, Point origin)
  {
    int loc = areaOfClick(origParent,
                          SwingUtilities.convertPoint(toolBar, position,
                                                      origParent));

    if (loc != -1)
      {
	dragWindow.setBorderColor(dockingBorderColor);
	dragWindow.setBackground(dockingColor);
      }
    else
      {
	dragWindow.setBorderColor(floatingBorderColor);
	dragWindow.setBackground(floatingColor);
      }

    int w = 0;
    int h = 0;

    boolean tmp = (loc == SwingConstants.NORTH)
                  || (loc == SwingConstants.SOUTH) || (loc == -1);

    cachedOrientation = toolBar.getOrientation();
    cachedBounds = toolBar.getSize();
    if (((cachedOrientation == SwingConstants.HORIZONTAL) && tmp)
        || ((cachedOrientation == VERTICAL) && ! tmp))
      {
	w = cachedBounds.width;
	h = cachedBounds.height;
      }
    else
      {
	w = cachedBounds.height;
	h = cachedBounds.width;
      }

    Point p = dragWindow.getOffset();
    Insets insets = toolBar.getInsets();

    dragWindow.setBounds((origin.x + position.x) - p.x
                         - ((insets.left + insets.right) / 2),
                         (origin.y + position.y) - p.y
                         - ((insets.top + insets.bottom) / 2), w, h);

    if (! dragWindow.isVisible())
      dragWindow.show();
  }

  /**
   * This method is used at the end of a drag session to place the frame in
   * either its original parent as a docked JToolBar or in its floating
   * frame.
   *
   * @param position The position of the mouse cursor relative to the
   *        JToolBar.
   * @param origin The screen position of the JToolBar before the drag session
   *        started.
   */
  protected void floatAt(Point position, Point origin)
  {
    Point p = new Point(position);
    int aoc = areaOfClick(origParent,
                          SwingUtilities.convertPoint(toolBar, p, origParent));

    Container oldParent = toolBar.getParent();

    oldParent.remove(toolBar);
    oldParent.doLayout();
    oldParent.repaint();

    Container newParent;

    if (aoc == -1)
      newParent = ((RootPaneContainer) floatFrame).getContentPane();
    else
      {
	floatFrame.hide();
	newParent = origParent;
      }

    String constraint;
    switch (aoc)
      {
      case SwingConstants.EAST:
	constraint = BorderLayout.EAST;
	break;
      case SwingConstants.NORTH:
	constraint = BorderLayout.NORTH;
	break;
      case SwingConstants.SOUTH:
	constraint = BorderLayout.SOUTH;
	break;
      case SwingConstants.WEST:
	constraint = BorderLayout.WEST;
	break;
      default:
	constraint = BorderLayout.CENTER;
	break;
      }

    int newOrientation = SwingConstants.HORIZONTAL;
    if ((aoc != -1)
        && ((aoc == SwingConstants.EAST) || (aoc == SwingConstants.WEST)))
      newOrientation = SwingConstants.VERTICAL;

    if (aoc != -1)
      {
	constraintBeforeFloating = constraint;
	lastGoodOrientation = newOrientation;
      }

    newParent.add(toolBar, constraint);

    setFloating(aoc == -1, null);
    toolBar.setOrientation(newOrientation);

    Insets insets = floatFrame.getInsets();
    Dimension dims = toolBar.getPreferredSize();
    p = dragWindow.getOffset();
    setFloatingLocation((position.x + origin.x) - p.x
                        - ((insets.left + insets.right) / 2),
                        (position.y + origin.y) - p.y
                        - ((insets.top + insets.bottom) / 2));

    if (aoc == -1)
      {
	floatFrame.pack();
	floatFrame.setSize(dims.width + insets.left + insets.right,
	                   dims.height + insets.top + insets.bottom);
	floatFrame.show();
      }

    newParent.invalidate();
    newParent.validate();
    newParent.repaint();
  }

  /**
   * This method returns the docking color.
   *
   * @return The docking color.
   */
  public Color getDockingColor()
  {
    return dockingColor;
  }

  /**
   * This method returns the Color which is displayed when over a floating
   * area.
   *
   * @return The color which is displayed when over a floating area.
   */
  public Color getFloatingColor()
  {
    return floatingColor;
  }

  /**
   * This method returns the maximum size of the given JComponent for this UI.
   *
   * @param c The JComponent to find the maximum size for.
   *
   * @return The maximum size for this UI.
   */
  public Dimension getMaximumSize(JComponent c)
  {
    return getPreferredSize(c);
  }

  /**
   * This method returns the minimum size of the given JComponent for this UI.
   *
   * @param c The JComponent to find a minimum size for.
   *
   * @return The minimum size for this UI.
   */
  public Dimension getMinimumSize(JComponent c)
  {
    return getPreferredSize(c);
  }

  /**
   * This method installs the needed components for the JToolBar.
   */
  protected void installComponents()
  {
    floatFrame = (Window) createFloatingWindow(toolBar);

    dragWindow = createDragWindow(toolBar);

    nonRolloverBorder = createNonRolloverBorder();
    rolloverBorder = createRolloverBorder();

    borders = new Hashtable();
    setRolloverBorders(toolBar.isRollover());

    fillHashtable();
  }

  /**
   * This method installs the defaults as specified by the look and feel.
   */
  protected void installDefaults()
  {
    LookAndFeel.installBorder(toolBar, "ToolBar.border");
    LookAndFeel.installColorsAndFont(toolBar, "ToolBar.background",
                                     "ToolBar.foreground", "ToolBar.font");

    dockingBorderColor = UIManager.getColor("ToolBar.dockingForeground");
    dockingColor = UIManager.getColor("ToolBar.dockingBackground");

    floatingBorderColor = UIManager.getColor("ToolBar.floatingForeground");
    floatingColor = UIManager.getColor("ToolBar.floatingBackground");
  }

  /**
   * This method installs the keyboard actions for the JToolBar as specified
   * by the look and feel.
   */
  protected void installKeyboardActions()
  {
    // Install the input map.
    InputMap inputMap =
      (InputMap) SharedUIDefaults.get("ToolBar.ancestorInputMap");
    SwingUtilities.replaceUIInputMap(toolBar,
                                 JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
                                 inputMap);

    // FIXME: The JDK uses a LazyActionMap for parentActionMap
    SwingUtilities.replaceUIActionMap(toolBar, getActionMap());
  }

  /**
   * Fetches the action map from  the UI defaults, or create a new one
   * if the action map hasn't been initialized.
   *
   * @return the action map
   */
  private ActionMap getActionMap()
  {
    ActionMap am = (ActionMap) UIManager.get("ToolBar.actionMap");
    if (am == null)
      {
        am = createDefaultActions();
        UIManager.getLookAndFeelDefaults().put("ToolBar.actionMap", am);
      }
    return am;
  }

  private ActionMap createDefaultActions()
  {
    ActionMapUIResource am = new ActionMapUIResource();
    Action action = new ToolBarAction();

    am.put("navigateLeft", action);
    am.put("navigateRight", action);
    am.put("navigateUp", action);
    am.put("navigateDown", action);

    return am;
  }

  /**
   * This method installs listeners for the JToolBar.
   */
  protected void installListeners()
  {
    dockingListener = createDockingListener();
    toolBar.addMouseListener(dockingListener);
    toolBar.addMouseMotionListener(dockingListener);

    propertyListener = createPropertyListener();
    toolBar.addPropertyChangeListener(propertyListener);

    toolBarContListener = createToolBarContListener();
    toolBar.addContainerListener(toolBarContListener);

    windowListener = createFrameListener();
    floatFrame.addWindowListener(windowListener);

    toolBarFocusListener = createToolBarFocusListener();
    if (toolBarFocusListener != null)
      {
        int count = toolBar.getComponentCount();
        for (int i = 0; i < count; i++)
          toolBar.getComponent(i).addFocusListener(toolBarFocusListener);
      }
  }

  /**
   * This method installs non rollover borders for each component inside the
   * given JComponent.
   *
   * @param c The JComponent whose children need to have non rollover borders
   *        installed.
   */
  protected void installNonRolloverBorders(JComponent c)
  {
    Component[] components = toolBar.getComponents();

    for (int i = 0; i < components.length; i++)
      setBorderToNonRollover(components[i]);
  }

  /**
   * This method installs normal (or their original) borders for each
   * component inside the given JComponent.
   *
   * @param c The JComponent whose children need to have their original
   *        borders installed.
   */
  protected void installNormalBorders(JComponent c)
  {
    Component[] components = toolBar.getComponents();

    for (int i = 0; i < components.length; i++)
      setBorderToNormal(components[i]);
  }

  /**
   * This method install rollover borders for each component inside the given
   * JComponent.
   *
   * @param c The JComponent whose children need to have rollover borders
   *        installed.
   */
  protected void installRolloverBorders(JComponent c)
  {
    Component[] components = toolBar.getComponents();

    for (int i = 0; i < components.length; i++)
      setBorderToRollover(components[i]);
  }

  /**
   * This method fills the borders hashtable with a list of components that
   * are JButtons and their borders.
   */
  private void fillHashtable()
  {
    Component[] c = toolBar.getComponents();

    for (int i = 0; i < c.length; i++)
      {
	if (c[i] instanceof JButton)
	  {
	    // Don't really care about anything other than JButtons
	    JButton b = (JButton) c[i];

	    if (b.getBorder() != null)
	      borders.put(b, b.getBorder());
	  }
      }
  }

  /**
   * This method installs the UI for the given JComponent.
   *
   * @param c The JComponent to install a UI for.
   */
  public void installUI(JComponent c)
  {
    super.installUI(c);

    if (c instanceof JToolBar)
      {
	toolBar = (JToolBar) c;
    installDefaults();
    installComponents();
	installListeners();
	installKeyboardActions();
      }
  }

  /**
   * This method returns whether the JToolBar is floating.
   *
   * @return Whether the JToolBar is floating.
   */
  public boolean isFloating()
  {
    return floatFrame.isVisible();
  }

  /**
   * This method returns whether rollover borders have been set.
   *
   * @return Whether rollover borders have been set.
   */
  public boolean isRolloverBorders()
  {
    return toolBar.isRollover();
  }

  /**
   * This method navigates in the given direction giving focus to the next
   * component in the given direction.
   *
   * @param direction The direction to give focus to.
   */
  protected void navigateFocusedComp(int direction)
  {
    int count = toolBar.getComponentCount();
    switch (direction)
    {
      case EAST:
      case SOUTH:
        if (focusedCompIndex >= 0 && focusedCompIndex < count)
          {
            int i = focusedCompIndex + 1;
            boolean focusRequested = false;
            // Find component to focus and request focus on it.
            while (i != focusedCompIndex && ! focusRequested)
              {
                if (i >= count)
                  i = 0;
                Component comp = toolBar.getComponentAtIndex(i++);
                if (comp != null && comp.isFocusable()
                    && comp.isEnabled())
                  {
                    comp.requestFocus();
                    focusRequested = true;
                  }
              }
          }
        break;
      case WEST:
      case NORTH:
        if (focusedCompIndex >= 0 && focusedCompIndex < count)
          {
            int i = focusedCompIndex - 1;
            boolean focusRequested = false;
            // Find component to focus and request focus on it.
            while (i != focusedCompIndex && ! focusRequested)
              {
                if (i < 0)
                  i = count - 1;
                Component comp = toolBar.getComponentAtIndex(i--);
                if (comp != null && comp.isFocusable()
                    && comp.isEnabled())
                  {
                    comp.requestFocus();
                    focusRequested = true;
                  }
              }
          }
        break;
      default:
        break;
    }
  }

  /**
   * This method sets the border of the given component to a non rollover
   * border.
   *
   * @param c The Component whose border needs to be set.
   */
  protected void setBorderToNonRollover(Component c)
  {
    if (c instanceof AbstractButton)
      {
	AbstractButton b = (AbstractButton) c;
	b.setRolloverEnabled(false);

        // Save old border in hashtable.
	if (b.getBorder() != null)
          borders.put(b, b.getBorder());
        
	b.setBorder(nonRolloverBorder);
      }
  }

  /**
   * This method sets the border of the given component to its original value.
   *
   * @param c The Component whose border needs to be set.
   */
  protected void setBorderToNormal(Component c)
  {
    if (c instanceof AbstractButton)
      {
        AbstractButton b = (AbstractButton) c;
        b.setRolloverEnabled(true);
        b.setBorder((Border) borders.remove(b));
      }
  }

  /**
   * This method sets the border of the given component to a rollover border.
   *
   * @param c The Component whose border needs to be set.
   */
  protected void setBorderToRollover(Component c)
  {
    if (c instanceof AbstractButton)
      {
        AbstractButton b = (AbstractButton) c;
        b.setRolloverEnabled(false);
        
        // Save old border in hashtable.
        if (b.getBorder() != null)
	  borders.put(b, b.getBorder());
        
        b.setBorder(rolloverBorder);
      }
  }

  /**
   * This method sets the docking color.
   *
   * @param c The docking color.
   */
  public void setDockingColor(Color c)
  {
    dockingColor = c;
  }

  /**
   * This method sets the floating property for the JToolBar.
   *
   * @param b Whether the JToolBar is floating.
   * @param p FIXME
   */
  public void setFloating(boolean b, Point p)
  {
    // FIXME: use p for something. It's not location
    // since we already have setFloatingLocation.
    floatFrame.setVisible(b);
  }

  /**
   * This method sets the color displayed when the JToolBar is not in a
   * dockable area.
   *
   * @param c The floating color.
   */
  public void setFloatingColor(Color c)
  {
    floatingColor = c;
  }

  /**
   * This method sets the floating location of the JToolBar.
   *
   * @param x The x coordinate for the floating frame.
   * @param y The y coordinate for the floating frame.
   */
  public void setFloatingLocation(int x, int y)
  {
    // x,y are the coordinates of the new JFrame created to store the toolbar
    // XXX: The floating location is bogus is not floating.
    floatFrame.setLocation(x, y);
    floatFrame.invalidate();
    floatFrame.validate();
    floatFrame.repaint();
  }

  /**
   * This is a convenience method for changing the orientation of the
   * JToolBar.
   *
   * @param orientation The new orientation.
   */
  public void setOrientation(int orientation)
  {
    toolBar.setOrientation(orientation);
  }

  /**
   * This method changes the child components to have rollover borders if the
   * given parameter is true. Otherwise, the components are set to have non
   * rollover borders.
   *
   * @param rollover Whether the children will have rollover borders.
   */
  public void setRolloverBorders(boolean rollover)
  {
    if (rollover)
      installRolloverBorders(toolBar);
    else
      installNonRolloverBorders(toolBar);
  }

  /**
   * This method uninstall UI installed components from the JToolBar.
   */
  protected void uninstallComponents()
  {
    installNormalBorders(toolBar);
    borders = null;
    cachedBounds = null;

    floatFrame = null;
    dragWindow = null;
  }

  /**
   * This method removes the defaults installed by the Look and Feel.
   */
  protected void uninstallDefaults()
  {
    toolBar.setBackground(null);
    toolBar.setForeground(null);
    toolBar.setFont(null);

    dockingBorderColor = null;
    dockingColor = null;
    floatingBorderColor = null;
    floatingColor = null;
  }

  /**
   * This method uninstalls keyboard actions installed by the UI.
   */
  protected void uninstallKeyboardActions()
  {
    SwingUtilities.replaceUIInputMap(toolBar, JComponent.
                                     WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
    SwingUtilities.replaceUIActionMap(toolBar, null);
  }

  /**
   * This method uninstalls listeners installed by the UI.
   */
  protected void uninstallListeners()
  {
    if (toolBarFocusListener != null)
      {
        int count = toolBar.getComponentCount();
        for (int i = 0; i < count; i++)
          toolBar.getComponent(i).removeFocusListener(toolBarFocusListener);
        toolBarFocusListener = null;
      }

    floatFrame.removeWindowListener(windowListener);
    windowListener = null;

    toolBar.removeContainerListener(toolBarContListener);
    toolBarContListener = null;

    toolBar.removeMouseMotionListener(dockingListener);
    toolBar.removeMouseListener(dockingListener);
    dockingListener = null;
  }

  /**
   * This method uninstalls the UI.
   *
   * @param c The JComponent that is having this UI removed.
   */
  public void uninstallUI(JComponent c)
  {
    uninstallKeyboardActions();
    uninstallListeners();
    uninstallComponents();
    uninstallDefaults();
    toolBar = null;
  }

  /**
   * This is the MouseHandler class that allows the user to drag the JToolBar
   * in and out of the parent and dock it if it can.
   */
  public class DockingListener implements MouseInputListener
  {
    /** Whether the JToolBar is being dragged. */
    protected boolean isDragging;

    /**
     * The origin point. This point is saved from the beginning press and is
     * used until the end of the drag session.
     */
    protected Point origin;

    /** The JToolBar being dragged. */
    protected JToolBar toolBar;

    /**
     * Creates a new DockingListener object.
     *
     * @param t The JToolBar this DockingListener is being used for.
     */
    public DockingListener(JToolBar t)
    {
      toolBar = t;
    }

    /**
     * This method is called when the mouse is clicked.
     *
     * @param e The MouseEvent.
     */
    public void mouseClicked(MouseEvent e)
    {
      // Nothing to do here.
    }

    /**
     * This method is called when the mouse is dragged. It delegates the drag
     * painting to the dragTo method.
     *
     * @param e The MouseEvent.
     */
    public void mouseDragged(MouseEvent e)
    {
      if (isDragging)
	dragTo(e.getPoint(), origin);
    }

    /**
     * This method is called when the mouse enters the JToolBar.
     *
     * @param e The MouseEvent.
     */
    public void mouseEntered(MouseEvent e)
    {
      // Nothing to do here.
    }

    /**
     * This method is called when the mouse exits the JToolBar.
     *
     * @param e The MouseEvent.
     */
    public void mouseExited(MouseEvent e)
    {
      // Nothing to do here.
    }

    /**
     * This method is called when the mouse is moved in the JToolBar.
     *
     * @param e The MouseEvent.
     */
    public void mouseMoved(MouseEvent e)
    {
      // Nothing to do here.
    }

    /**
     * This method is called when the mouse is pressed in the JToolBar. If the
     * press doesn't occur in a place where it causes the JToolBar to be
     * dragged, it returns. Otherwise, it starts a drag session.
     *
     * @param e The MouseEvent.
     */
    public void mousePressed(MouseEvent e)
    {
      if (! toolBar.isFloatable())
	return;

      Point ssd = e.getPoint();
      Insets insets = toolBar.getInsets();

      // Verify that this click occurs in the top inset.
      if (toolBar.getOrientation() == SwingConstants.HORIZONTAL)
        {
	  if (e.getX() > insets.left)
	    return;
        }
      else
        {
	  if (e.getY() > insets.top)
	    return;
        }

      origin = new Point(0, 0);
      if (toolBar.isShowing())
        SwingUtilities.convertPointToScreen(ssd, toolBar);

      if (! (SwingUtilities.getAncestorOfClass(Window.class, toolBar) instanceof UIResource))
	// Need to know who keeps the toolBar if it gets dragged back into it.
	origParent = toolBar.getParent();
      
      if (toolBar.isShowing())
        SwingUtilities.convertPointToScreen(origin, toolBar);

      isDragging = true;

      if (dragWindow != null)
	dragWindow.setOffset(new Point(cachedBounds.width / 2, 
            cachedBounds.height / 2));

      dragTo(e.getPoint(), origin);
    }

    /**
     * This method is called when the mouse is released from the JToolBar.
     *
     * @param e The MouseEvent.
     */
    public void mouseReleased(MouseEvent e)
    {
      if (! isDragging || ! toolBar.isFloatable())
	return;

      isDragging = false;
      floatAt(e.getPoint(), origin);
      dragWindow.hide();
    }
  }

  /**
   * This is the window that appears when the JToolBar is being dragged
   * around.
   */
  protected class DragWindow extends Window
  {
    /**
     * The current border color. It changes depending on whether the JToolBar
     * is over a place that allows it to dock.
     */
    private Color borderColor;

    /** The between the mouse and the top left corner of the window. */
    private Point offset;

    /**
     * Creates a new DragWindow object.
     * This is package-private to avoid an accessor method.
     */
    DragWindow()
    {
      super(owner);
    }

    /**
     * The color that the border should be.
     *
     * @return The border color.
     */
    public Color getBorderColor()
    {
      if (borderColor == null)
	return Color.BLACK;

      return borderColor;
    }

    /**
     * This method returns the insets for the DragWindow.
     *
     * @return The insets for the DragWindow.
     */
    public Insets getInsets()
    {
      // This window has no decorations, so insets are empty.
      return new Insets(0, 0, 0, 0);
    }

    /**
     * This method returns the mouse offset from the top left corner of the
     * DragWindow.
     *
     * @return The mouse offset.
     */
    public Point getOffset()
    {
      return offset;
    }

    /**
     * This method paints the DragWindow.
     *
     * @param g The Graphics object to paint with.
     */
    public void paint(Graphics g)
    {
      //  No visiting children necessary.
      Color saved = g.getColor();
      Rectangle b = getBounds();

      g.setColor(getBorderColor());
      g.drawRect(0, 0, b.width - 1, b.height - 1);

      g.setColor(saved);
    }

    /**
     * This method changes the border color.
     *
     * @param c The new border color.
     */
    public void setBorderColor(Color c)
    {
      borderColor = c;
    }

    /**
     * This method changes the mouse offset.
     *
     * @param p The new mouse offset.
     */
    public void setOffset(Point p)
    {
      offset = p;
    }

    /**
     * Sets the orientation of the toolbar and the
     * drag window.
     *
     * @param o - the new orientation of the toolbar and drag
     * window.
     */
    public void setOrientation(int o)
    {
      toolBar.setOrientation(o);
      if (dragWindow != null) 
        dragWindow.setOrientation(o);
    }
  }

  /**
   * This helper class listens for Window events from the floatable window and
   * if it is closed, returns the JToolBar to the last known good location.
   */
  protected class FrameListener extends WindowAdapter
  {
    /**
     * This method is called when the floating window is closed.
     *
     * @param e The WindowEvent.
     */
    public void windowClosing(WindowEvent e)
    {
      Container parent = toolBar.getParent();
      parent.remove(toolBar);

      if (origParent != null)
        {
	  origParent.add(toolBar,
	                 (constraintBeforeFloating != null)
	                 ? constraintBeforeFloating : BorderLayout.NORTH);
	  toolBar.setOrientation(lastGoodOrientation);
        }

      origParent.invalidate();
      origParent.validate();
      origParent.repaint();
    }
  }

  /**
   * This helper class listens for PropertyChangeEvents from the JToolBar.
   */
  protected class PropertyListener implements PropertyChangeListener
  {
    /**
     * This method is called when a property from the JToolBar is changed.
     *
     * @param e The PropertyChangeEvent.
     */
    public void propertyChange(PropertyChangeEvent e)
    {
      // FIXME: need name properties so can change floatFrame title.
      if (e.getPropertyName().equals("rollover") && toolBar != null)
        setRolloverBorders(toolBar.isRollover());
    }
  }

  /**
   * This helper class listens for components added to and removed from the
   * JToolBar.
   */
  protected class ToolBarContListener implements ContainerListener
  {
    /**
     * This method is responsible for setting rollover or non rollover for new
     * buttons added to the JToolBar.
     *
     * @param e The ContainerEvent.
     */
    public void componentAdded(ContainerEvent e)
    {
      if (e.getChild() instanceof JButton)
        {
	  JButton b = (JButton) e.getChild();

	  if (b.getBorder() != null)
	    borders.put(b, b.getBorder());
        }

      if (isRolloverBorders())
	setBorderToRollover(e.getChild());
      else
	setBorderToNonRollover(e.getChild());

      cachedBounds = toolBar.getPreferredSize();
      cachedOrientation = toolBar.getOrientation();

      Component c = e.getChild();
      if (toolBarFocusListener != null)
        c.addFocusListener(toolBarFocusListener);
    }

    /**
     * This method is responsible for giving the child components their
     * original borders when they are removed.
     *
     * @param e The ContainerEvent.
     */
    public void componentRemoved(ContainerEvent e)
    {
      setBorderToNormal(e.getChild());
      cachedBounds = toolBar.getPreferredSize();
      cachedOrientation = toolBar.getOrientation();

      Component c = e.getChild();
      if (toolBarFocusListener != null)
        c.removeFocusListener(toolBarFocusListener);
    }
  }

  /**
   * This is the floating window that is returned when getFloatingWindow is
   * called.
   */
  private class ToolBarDialog extends JDialog implements UIResource
  {
    /**
     * Creates a new ToolBarDialog object with the name given by the JToolBar.
     */
    public ToolBarDialog()
    {
      super();
      setName((toolBar.getName() != null) ? toolBar.getName() : "");
    }
  }

  /**
   * DOCUMENT ME!
   */
  protected class ToolBarFocusListener implements FocusListener
  {
    /**
     * Creates a new ToolBarFocusListener object.
     */
    protected ToolBarFocusListener()
    {
      // Nothing to do here.
    }

    /**
     * Receives notification when the toolbar or one of it's component
     * receives the keyboard input focus.
     * 
     * @param e the focus event
     */
    public void focusGained(FocusEvent e)
    {
      Component c = e.getComponent();
      focusedCompIndex = toolBar.getComponentIndex(c);
    }

    /**
     * Receives notification when the toolbar or one of it's component
     * looses the keyboard input focus.
     * 
     * @param e the focus event
     */
    public void focusLost(FocusEvent e)
    {
      // Do nothing here.
    }
  }

  /**
   * This helper class acts as the border for the JToolBar.
   */
  private static class ToolBarBorder implements Border
  {
    /** The size of the larger, draggable side of the border. */
    private static final int offset = 10;

    /** The other sides. */
    private static final int regular = 2;

    /**
     * This method returns the border insets for the JToolBar.
     *
     * @param c The Component to find insets for.
     *
     * @return The border insets.
     */
    public Insets getBorderInsets(Component c)
    {
      if (c instanceof JToolBar)
        {
	  JToolBar tb = (JToolBar) c;
	  int orientation = tb.getOrientation();

	  if (! tb.isFloatable())
	    return new Insets(regular, regular, regular, regular);
	  else if (orientation == SwingConstants.HORIZONTAL)
	    return new Insets(regular, offset, regular, regular);
	  else
	    return new Insets(offset, regular, regular, regular);
        }

      return new Insets(0, 0, 0, 0);
    }

    /**
     * This method returns whether the border is opaque.
     *
     * @return Whether the border is opaque.
     */
    public boolean isBorderOpaque()
    {
      return false;
    }

    /**
     * This method paints the ribbed area of the border.
     *
     * @param g The Graphics object to paint with.
     * @param x The x coordinate of the area.
     * @param y The y coordinate of the area.
     * @param w The width of the area.
     * @param h The height of the area.
     * @param size The size of the bump.
     * @param c The color of the bumps.
     */
    private void paintBumps(Graphics g, int x, int y, int w, int h, int size,
                            Color c)
    {
      Color saved = g.getColor();
      g.setColor(c);

      int hgap = 2 * size;
      int vgap = 4 * size;
      int count = 0;

      for (int i = x; i < (w + x); i += hgap)
	for (int j = ((count++ % 2) == 0) ? y : (y + (2 * size)); j < (h + y);
	     j += vgap)
	  g.fillRect(i, j, size, size);

      g.setColor(saved);
    }

    /**
     * This method paints the border around the given Component.
     *
     * @param c The Component whose border is being painted.
     * @param g The Graphics object to paint with.
     * @param x The x coordinate of the component.
     * @param y The y coordinate of the component.
     * @param width The width of the component.
     * @param height The height of the component.
     */
    public void paintBorder(Component c, Graphics g, int x, int y, int width,
                            int height)
    {
      if (c instanceof JToolBar)
        {
	  JToolBar tb = (JToolBar) c;

	  int orientation = tb.getOrientation();

	  if (orientation == SwingConstants.HORIZONTAL)
	    {
	      paintBumps(g, x, y, offset, height, 1, Color.WHITE);
	      paintBumps(g, x + 1, y + 1, offset - 1, height - 1, 1, Color.GRAY);
	    }
	  else
	    {
	      paintBumps(g, x, y, width, offset, 1, Color.WHITE);
	      paintBumps(g, x + 1, y + 1, width - 1, offset - 1, 1, Color.GRAY);
	    }
        }
    }
  }
}
