Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.swing.plaf.basic;

	import javax.swing.*;
	import javax.swing.event.*;
	import java.awt.*;
	import java.awt.event.*;

	import java.beans.*;

	import java.util.Hashtable;
	import java.util.HashMap;

	import javax.swing.border.*;
	import javax.swing.plaf.*;
	import sun.swing.DefaultLookup;
	import sun.swing.UIAction;


	/**
	* A Basic L&F implementation of ToolBarUI. This implementation
	* is a "combined" view/controller.
	* <p>
	*
	* @author Georges Saab
	* @author Jeff Shapiro
	*/
	public class BasicToolBarUI extends ToolBarUI implements SwingConstants
	{
	protected JToolBar toolBar;
	private boolean floating;
	private int floatingX;
	private int floatingY;
	private JFrame floatingFrame;
	private RootPaneContainer floatingToolBar;
	protected DragWindow dragWindow;
	private Container dockingSource;
	private int dockingSensitivity = 0;
	protected int focusedCompIndex = -1;

	protected Color dockingColor = null;
	protected Color floatingColor = null;
	protected Color dockingBorderColor = null;
	protected Color floatingBorderColor = null;

	protected MouseInputListener dockingListener;
	protected PropertyChangeListener propertyListener;

	protected ContainerListener toolBarContListener;
	protected FocusListener toolBarFocusListener;
	private Handler handler;

	protected String constraintBeforeFloating = BorderLayout.NORTH;

	// Rollover button implementation.
	private static String IS_ROLLOVER = "JToolBar.isRollover";
	private static Border rolloverBorder;
	private static Border nonRolloverBorder;
	private static Border nonRolloverToggleBorder;
	private boolean rolloverBorders = false;

	private HashMap<AbstractButton, Border> borderTable = new HashMap<AbstractButton, Border>();
	private Hashtable<AbstractButton, Boolean> rolloverTable = new Hashtable<AbstractButton, Boolean>();


	/**
	* As of Java 2 platform v1.3 this previously undocumented field is no
	* longer used.
	* Key bindings are now defined by the LookAndFeel, please refer to
	* the key bindings specification for further details.
	*
	* @deprecated As of Java 2 platform v1.3.
	*/
	@Deprecated
	protected KeyStroke upKey;
	/**
	* As of Java 2 platform v1.3 this previously undocumented field is no
	* longer used.
	* Key bindings are now defined by the LookAndFeel, please refer to
	* the key bindings specification for further details.
	*
	* @deprecated As of Java 2 platform v1.3.
	*/
	@Deprecated
	protected KeyStroke downKey;
	/**
	* As of Java 2 platform v1.3 this previously undocumented field is no
	* longer used.
	* Key bindings are now defined by the LookAndFeel, please refer to
	* the key bindings specification for further details.
	*
	* @deprecated As of Java 2 platform v1.3.
	*/
	@Deprecated
	protected KeyStroke leftKey;
	/**
	* As of Java 2 platform v1.3 this previously undocumented field is no
	* longer used.
	* Key bindings are now defined by the LookAndFeel, please refer to
	* the key bindings specification for further details.
	*
	* @deprecated As of Java 2 platform v1.3.
	*/
	@Deprecated
	protected KeyStroke rightKey;


	private static String FOCUSED_COMP_INDEX = "JToolBar.focusedCompIndex";

	public static ComponentUI createUI( JComponent c )
	{
	return new BasicToolBarUI();
	}

	public void installUI( JComponent c )
	{
	toolBar = (JToolBar) c;

	// Set defaults
	installDefaults();
	installComponents();
	installListeners();
	installKeyboardActions();

	// Initialize instance vars
	dockingSensitivity = 0;
	floating = false;
	floatingX = floatingY = 0;
	floatingToolBar = null;

	setOrientation( toolBar.getOrientation() );
	LookAndFeel.installProperty(c, "opaque", Boolean.TRUE);

	if ( c.getClientProperty( FOCUSED_COMP_INDEX ) != null )
	{
	focusedCompIndex = ( (Integer) ( c.getClientProperty( FOCUSED_COMP_INDEX ) ) ).intValue();
	}
	}

	public void uninstallUI( JComponent c )
	{

	// Clear defaults
	uninstallDefaults();
	uninstallComponents();
	uninstallListeners();
	uninstallKeyboardActions();

	// Clear instance vars
	if (isFloating())
	setFloating(false, null);

	floatingToolBar = null;
	dragWindow = null;
	dockingSource = null;

	c.putClientProperty( FOCUSED_COMP_INDEX, Integer.valueOf( focusedCompIndex ) );
	}

	protected void installDefaults( )
	{
	LookAndFeel.installBorder(toolBar,"ToolBar.border");
	LookAndFeel.installColorsAndFont(toolBar,
	"ToolBar.background",
	"ToolBar.foreground",
	"ToolBar.font");
	// Toolbar specific defaults
	if ( dockingColor == null \|\| dockingColor instanceof UIResource )
	dockingColor = UIManager.getColor("ToolBar.dockingBackground");
	if ( floatingColor == null \|\| floatingColor instanceof UIResource )
	floatingColor = UIManager.getColor("ToolBar.floatingBackground");
	if ( dockingBorderColor == null \|\|
	dockingBorderColor instanceof UIResource )
	dockingBorderColor = UIManager.getColor("ToolBar.dockingForeground");
	if ( floatingBorderColor == null \|\|
	floatingBorderColor instanceof UIResource )
	floatingBorderColor = UIManager.getColor("ToolBar.floatingForeground");

	// ToolBar rollover button borders
	Object rolloverProp = toolBar.getClientProperty( IS_ROLLOVER );
	if (rolloverProp == null) {
	rolloverProp = UIManager.get("ToolBar.isRollover");
	}
	if ( rolloverProp != null ) {
	rolloverBorders = ((Boolean)rolloverProp).booleanValue();
	}

	if (rolloverBorder == null) {
	rolloverBorder = createRolloverBorder();
	}
	if (nonRolloverBorder == null) {
	nonRolloverBorder = createNonRolloverBorder();
	}
	if (nonRolloverToggleBorder == null) {
	nonRolloverToggleBorder = createNonRolloverToggleBorder();
	}


	setRolloverBorders( isRolloverBorders() );
	}

	protected void uninstallDefaults( )
	{
	LookAndFeel.uninstallBorder(toolBar);
	dockingColor = null;
	floatingColor = null;
	dockingBorderColor = null;
	floatingBorderColor = null;

	installNormalBorders(toolBar);

	rolloverBorder = null;
	nonRolloverBorder = null;
	nonRolloverToggleBorder = null;
	}

	protected void installComponents( )
	{
	}

	protected void uninstallComponents( )
	{
	}

	protected void installListeners( )
	{
	dockingListener = createDockingListener( );

	if ( dockingListener != null )
	{
	toolBar.addMouseMotionListener( dockingListener );
	toolBar.addMouseListener( dockingListener );
	}

	propertyListener = createPropertyListener(); // added in setFloating
	if (propertyListener != null) {
	toolBar.addPropertyChangeListener(propertyListener);
	}

	toolBarContListener = createToolBarContListener();
	if ( toolBarContListener != null ) {
	toolBar.addContainerListener( toolBarContListener );
	}

	toolBarFocusListener = createToolBarFocusListener();

	if ( toolBarFocusListener != null )
	{
	// Put focus listener on all components in toolbar
	Component[] components = toolBar.getComponents();

	for (Component component : components) {
	component.addFocusListener(toolBarFocusListener);
	}
	}
	}

	protected void uninstallListeners( )
	{
	if ( dockingListener != null )
	{
	toolBar.removeMouseMotionListener(dockingListener);
	toolBar.removeMouseListener(dockingListener);

	dockingListener = null;
	}

	if ( propertyListener != null )
	{
	toolBar.removePropertyChangeListener(propertyListener);
	propertyListener = null; // removed in setFloating
	}

	if ( toolBarContListener != null )
	{
	toolBar.removeContainerListener( toolBarContListener );
	toolBarContListener = null;
	}

	if ( toolBarFocusListener != null )
	{
	// Remove focus listener from all components in toolbar
	Component[] components = toolBar.getComponents();

	for (Component component : components) {
	component.removeFocusListener(toolBarFocusListener);
	}

	toolBarFocusListener = null;
	}
	handler = null;
	}

	protected void installKeyboardActions( )
	{
	InputMap km = getInputMap(JComponent.
	WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

	SwingUtilities.replaceUIInputMap(toolBar, JComponent.
	WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
	km);

	LazyActionMap.installLazyActionMap(toolBar, BasicToolBarUI.class,
	"ToolBar.actionMap");
	}

	InputMap getInputMap(int condition) {
	if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
	return (InputMap)DefaultLookup.get(toolBar, this,
	"ToolBar.ancestorInputMap");
	}
	return null;
	}

	static void loadActionMap(LazyActionMap map) {
	map.put(new Actions(Actions.NAVIGATE_RIGHT));
	map.put(new Actions(Actions.NAVIGATE_LEFT));
	map.put(new Actions(Actions.NAVIGATE_UP));
	map.put(new Actions(Actions.NAVIGATE_DOWN));
	}

	protected void uninstallKeyboardActions( )
	{
	SwingUtilities.replaceUIActionMap(toolBar, null);
	SwingUtilities.replaceUIInputMap(toolBar, JComponent.
	WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
	null);
	}

	protected void navigateFocusedComp( int direction )
	{
	int nComp = toolBar.getComponentCount();
	int j;

	switch ( direction )
	{
	case EAST:
	case SOUTH:

	if ( focusedCompIndex < 0 \|\| focusedCompIndex >= nComp ) break;

	j = focusedCompIndex + 1;

	while ( j != focusedCompIndex )
	{
	if ( j >= nComp ) j = 0;
	Component comp = toolBar.getComponentAtIndex( j++ );

	if ( comp != null && comp.isFocusTraversable() && comp.isEnabled() )
	{
	comp.requestFocus();
	break;
	}
	}

	break;

	case WEST:
	case NORTH:

	if ( focusedCompIndex < 0 \|\| focusedCompIndex >= nComp ) break;

	j = focusedCompIndex - 1;

	while ( j != focusedCompIndex )
	{
	if ( j < 0 ) j = nComp - 1;
	Component comp = toolBar.getComponentAtIndex( j-- );

	if ( comp != null && comp.isFocusTraversable() && comp.isEnabled() )
	{
	comp.requestFocus();
	break;
	}
	}

	break;

	default:
	break;
	}
	}

	/**
	* Creates a rollover border for toolbar components. The
	* rollover border will be installed if rollover borders are
	* enabled.
	* <p>
	* Override this method to provide an alternate rollover border.
	*
	* @since 1.4
	*/
	protected Border createRolloverBorder() {
	Object border = UIManager.get("ToolBar.rolloverBorder");
	if (border != null) {
	return (Border)border;
	}
	UIDefaults table = UIManager.getLookAndFeelDefaults();
	return new CompoundBorder(new BasicBorders.RolloverButtonBorder(
	table.getColor("controlShadow"),
	table.getColor("controlDkShadow"),
	table.getColor("controlHighlight"),
	table.getColor("controlLtHighlight")),
	new BasicBorders.RolloverMarginBorder());
	}

	/**
	* Creates the non rollover border for toolbar components. This
	* border will be installed as the border for components added
	* to the toolbar if rollover borders are not enabled.
	* <p>
	* Override this method to provide an alternate rollover border.
	*
	* @since 1.4
	*/
	protected Border createNonRolloverBorder() {
	Object border = UIManager.get("ToolBar.nonrolloverBorder");
	if (border != null) {
	return (Border)border;
	}
	UIDefaults table = UIManager.getLookAndFeelDefaults();
	return new CompoundBorder(new BasicBorders.ButtonBorder(
	table.getColor("Button.shadow"),
	table.getColor("Button.darkShadow"),
	table.getColor("Button.light"),
	table.getColor("Button.highlight")),
	new BasicBorders.RolloverMarginBorder());
	}

	/**
	* Creates a non rollover border for Toggle buttons in the toolbar.
	*/
	private Border createNonRolloverToggleBorder() {
	UIDefaults table = UIManager.getLookAndFeelDefaults();
	return new CompoundBorder(new BasicBorders.RadioButtonBorder(
	table.getColor("ToggleButton.shadow"),
	table.getColor("ToggleButton.darkShadow"),
	table.getColor("ToggleButton.light"),
	table.getColor("ToggleButton.highlight")),
	new BasicBorders.RolloverMarginBorder());
	}

	/**
	* No longer used, use BasicToolBarUI.createFloatingWindow(JToolBar)
	* @see #createFloatingWindow
	*/
	protected JFrame createFloatingFrame(JToolBar toolbar) {
	Window window = SwingUtilities.getWindowAncestor(toolbar);
	JFrame frame = new JFrame(toolbar.getName(),
	(window != null) ? window.getGraphicsConfiguration() : null) {
	// Override createRootPane() to automatically resize
	// the frame when contents change
	protected JRootPane createRootPane() {
	JRootPane rootPane = new JRootPane() {
	private boolean packing = false;

	public void validate() {
	super.validate();
	if (!packing) {
	packing = true;
	pack();
	packing = false;
	}
	}
	};
	rootPane.setOpaque(true);
	return rootPane;
	}
	};
	frame.getRootPane().setName("ToolBar.FloatingFrame");
	frame.setResizable(false);
	WindowListener wl = createFrameListener();
	frame.addWindowListener(wl);
	return frame;
	}

	/**
	* Creates a window which contains the toolbar after it has been
	* dragged out from its container
	* @return a <code>RootPaneContainer</code> object, containing the toolbar.
	* @since 1.4
	*/
	protected RootPaneContainer createFloatingWindow(JToolBar toolbar) {
	class ToolBarDialog extends JDialog {
	public ToolBarDialog(Frame owner, String title, boolean modal) {
	super(owner, title, modal);
	}

	public ToolBarDialog(Dialog owner, String title, boolean modal) {
	super(owner, title, modal);
	}

	// Override createRootPane() to automatically resize
	// the frame when contents change
	protected JRootPane createRootPane() {
	JRootPane rootPane = new JRootPane() {
	private boolean packing = false;

	public void validate() {
	super.validate();
	if (!packing) {
	packing = true;
	pack();
	packing = false;
	}
	}
	};
	rootPane.setOpaque(true);
	return rootPane;
	}
	}

	JDialog dialog;
	Window window = SwingUtilities.getWindowAncestor(toolbar);
	if (window instanceof Frame) {
	dialog = new ToolBarDialog((Frame)window, toolbar.getName(), false);
	} else if (window instanceof Dialog) {
	dialog = new ToolBarDialog((Dialog)window, toolbar.getName(), false);
	} else {
	dialog = new ToolBarDialog((Frame)null, toolbar.getName(), false);
	}

	dialog.getRootPane().setName("ToolBar.FloatingWindow");
	dialog.setTitle(toolbar.getName());
	dialog.setResizable(false);
	WindowListener wl = createFrameListener();
	dialog.addWindowListener(wl);
	return dialog;
	}

	protected DragWindow createDragWindow(JToolBar toolbar) {
	Window frame = null;
	if(toolBar != null) {
	Container p;
	for(p = toolBar.getParent() ; p != null && !(p instanceof Window) ;
	p = p.getParent());
	if(p != null && p instanceof Window)
	frame = (Window) p;
	}
	if(floatingToolBar == null) {
	floatingToolBar = createFloatingWindow(toolBar);
	}
	if (floatingToolBar instanceof Window) frame = (Window) floatingToolBar;
	DragWindow dragWindow = new DragWindow(frame);
	return dragWindow;
	}

	/**
	* Returns a flag to determine whether rollover button borders
	* are enabled.
	*
	* @return true if rollover borders are enabled; false otherwise
	* @see #setRolloverBorders
	* @since 1.4
	*/
	public boolean isRolloverBorders() {
	return rolloverBorders;
	}

	/**
	* Sets the flag for enabling rollover borders on the toolbar and it will
	* also install the appropriate border depending on the state of the flag.
	*
	* @param rollover if true, rollover borders are installed.
	* Otherwise non-rollover borders are installed
	* @see #isRolloverBorders
	* @since 1.4
	*/
	public void setRolloverBorders( boolean rollover ) {
	rolloverBorders = rollover;

	if ( rolloverBorders ) {
	installRolloverBorders( toolBar );
	} else {
	installNonRolloverBorders( toolBar );
	}
	}

	/**
	* Installs rollover borders on all the child components of the JComponent.
	* <p>
	* This is a convenience method to call <code>setBorderToRollover</code>
	* for each child component.
	*
	* @param c container which holds the child components (usually a JToolBar)
	* @see #setBorderToRollover
	* @since 1.4
	*/
	protected void installRolloverBorders ( JComponent c ) {
	// Put rollover borders on buttons
	Component[] components = c.getComponents();

	for (Component component : components) {
	if (component instanceof JComponent) {
	((JComponent) component).updateUI();
	setBorderToRollover(component);
	}
	}
	}

	/**
	* Installs non-rollover borders on all the child components of the JComponent.
	* A non-rollover border is the border that is installed on the child component
	* while it is in the toolbar.
	* <p>
	* This is a convenience method to call <code>setBorderToNonRollover</code>
	* for each child component.
	*
	* @param c container which holds the child components (usually a JToolBar)
	* @see #setBorderToNonRollover
	* @since 1.4
	*/
	protected void installNonRolloverBorders ( JComponent c ) {
	// Put non-rollover borders on buttons. These borders reduce the margin.
	Component[] components = c.getComponents();

	for (Component component : components) {
	if (component instanceof JComponent) {
	((JComponent) component).updateUI();
	setBorderToNonRollover(component);
	}
	}
	}

	/**
	* Installs normal borders on all the child components of the JComponent.
	* A normal border is the original border that was installed on the child
	* component before it was added to the toolbar.
	* <p>
	* This is a convenience method to call <code>setBorderNormal</code>
	* for each child component.
	*
	* @param c container which holds the child components (usually a JToolBar)
	* @see #setBorderToNonRollover
	* @since 1.4
	*/
	protected void installNormalBorders ( JComponent c ) {
	// Put back the normal borders on buttons
	Component[] components = c.getComponents();

	for (Component component : components) {
	setBorderToNormal(component);
	}
	}

	/**
	* Sets the border of the component to have a rollover border which
	* was created by the {@link #createRolloverBorder} method.
	*
	* @param c component which will have a rollover border installed
	* @see #createRolloverBorder
	* @since 1.4
	*/
	protected void setBorderToRollover(Component c) {
	if (c instanceof AbstractButton) {
	AbstractButton b = (AbstractButton)c;

	Border border = borderTable.get(b);
	if (border == null \|\| border instanceof UIResource) {
	borderTable.put(b, b.getBorder());
	}

	// Only set the border if its the default border
	if (b.getBorder() instanceof UIResource) {
	b.setBorder(getRolloverBorder(b));
	}

	rolloverTable.put(b, b.isRolloverEnabled()?
	Boolean.TRUE: Boolean.FALSE);
	b.setRolloverEnabled(true);
	}
	}

	/**
	* Returns a rollover border for the button.
	*
	* @param b the button to calculate the rollover border for
	* @return the rollover border
	* @see #setBorderToRollover
	* @since 1.6
	*/
	protected Border getRolloverBorder(AbstractButton b) {
	return rolloverBorder;
	}

	/**
	* Sets the border of the component to have a non-rollover border which
	* was created by the {@link #createNonRolloverBorder} method.
	*
	* @param c component which will have a non-rollover border installed
	* @see #createNonRolloverBorder
	* @since 1.4
	*/
	protected void setBorderToNonRollover(Component c) {
	if (c instanceof AbstractButton) {
	AbstractButton b = (AbstractButton)c;

	Border border = borderTable.get(b);
	if (border == null \|\| border instanceof UIResource) {
	borderTable.put(b, b.getBorder());
	}

	// Only set the border if its the default border
	if (b.getBorder() instanceof UIResource) {
	b.setBorder(getNonRolloverBorder(b));
	}
	rolloverTable.put(b, b.isRolloverEnabled()?
	Boolean.TRUE: Boolean.FALSE);
	b.setRolloverEnabled(false);
	}
	}

	/**
	* Returns a non-rollover border for the button.
	*
	* @param b the button to calculate the non-rollover border for
	* @return the non-rollover border
	* @see #setBorderToNonRollover
	* @since 1.6
	*/
	protected Border getNonRolloverBorder(AbstractButton b) {
	if (b instanceof JToggleButton) {
	return nonRolloverToggleBorder;
	} else {
	return nonRolloverBorder;
	}
	}

	/**
	* Sets the border of the component to have a normal border.
	* A normal border is the original border that was installed on the child
	* component before it was added to the toolbar.
	*
	* @param c component which will have a normal border re-installed
	* @see #createNonRolloverBorder
	* @since 1.4
	*/
	protected void setBorderToNormal(Component c) {
	if (c instanceof AbstractButton) {
	AbstractButton b = (AbstractButton)c;

	Border border = borderTable.remove(b);
	b.setBorder(border);

	Boolean value = rolloverTable.remove(b);
	if (value != null) {
	b.setRolloverEnabled(value.booleanValue());
	}
	}
	}

	public void setFloatingLocation(int x, int y) {
	floatingX = x;
	floatingY = y;
	}

	public boolean isFloating() {
	return floating;
	}

	public void setFloating(boolean b, Point p) {
	if (toolBar.isFloatable()) {
	boolean visible = false;
	Window ancestor = SwingUtilities.getWindowAncestor(toolBar);
	if (ancestor != null) {
	visible = ancestor.isVisible();
	}
	if (dragWindow != null)
	dragWindow.setVisible(false);
	this.floating = b;
	if (floatingToolBar == null) {
	floatingToolBar = createFloatingWindow(toolBar);
	}
	if (b == true)
	{
	if (dockingSource == null)
	{
	dockingSource = toolBar.getParent();
	dockingSource.remove(toolBar);
	}
	constraintBeforeFloating = calculateConstraint();
	if ( propertyListener != null )
	UIManager.addPropertyChangeListener( propertyListener );
	floatingToolBar.getContentPane().add(toolBar,BorderLayout.CENTER);
	if (floatingToolBar instanceof Window) {
	((Window)floatingToolBar).pack();
	((Window)floatingToolBar).setLocation(floatingX, floatingY);
	if (visible) {
	((Window)floatingToolBar).show();
	} else {
	ancestor.addWindowListener(new WindowAdapter() {
	public void windowOpened(WindowEvent e) {
	((Window)floatingToolBar).show();
	}
	});
	}
	}
	} else {
	if (floatingToolBar == null)
	floatingToolBar = createFloatingWindow(toolBar);
	if (floatingToolBar instanceof Window) ((Window)floatingToolBar).setVisible(false);
	floatingToolBar.getContentPane().remove(toolBar);
	String constraint = getDockingConstraint(dockingSource,
	p);
	if (constraint == null) {
	constraint = BorderLayout.NORTH;
	}
	int orientation = mapConstraintToOrientation(constraint);
	setOrientation(orientation);
	if (dockingSource== null)
	dockingSource = toolBar.getParent();
	if ( propertyListener != null )
	UIManager.removePropertyChangeListener( propertyListener );
	dockingSource.add(constraint, toolBar);
	}
	dockingSource.invalidate();
	Container dockingSourceParent = dockingSource.getParent();
	if (dockingSourceParent != null)
	dockingSourceParent.validate();
	dockingSource.repaint();
	}
	}

	private int mapConstraintToOrientation(String constraint)
	{
	int orientation = toolBar.getOrientation();

	if ( constraint != null )
	{
	if ( constraint.equals(BorderLayout.EAST) \|\| constraint.equals(BorderLayout.WEST) )
	orientation = JToolBar.VERTICAL;
	else if ( constraint.equals(BorderLayout.NORTH) \|\| constraint.equals(BorderLayout.SOUTH) )
	orientation = JToolBar.HORIZONTAL;
	}

	return orientation;
	}

	public void setOrientation(int orientation)
	{
	toolBar.setOrientation( orientation );

	if (dragWindow !=null)
	dragWindow.setOrientation(orientation);
	}

	/**
	* Gets the color displayed when over a docking area
	*/
	public Color getDockingColor() {
	return dockingColor;
	}

	/**
	* Sets the color displayed when over a docking area
	*/
	public void setDockingColor(Color c) {
	this.dockingColor = c;
	}

	/**
	* Gets the color displayed when over a floating area
	*/
	public Color getFloatingColor() {
	return floatingColor;
	}

	/**
	* Sets the color displayed when over a floating area
	*/
	public void setFloatingColor(Color c) {
	this.floatingColor = c;
	}

	private boolean isBlocked(Component comp, Object constraint) {
	if (comp instanceof Container) {
	Container cont = (Container)comp;
	LayoutManager lm = cont.getLayout();
	if (lm instanceof BorderLayout) {
	BorderLayout blm = (BorderLayout)lm;
	Component c = blm.getLayoutComponent(cont, constraint);
	return (c != null && c != toolBar);
	}
	}
	return false;
	}

	public boolean canDock(Component c, Point p) {
	return (p != null && getDockingConstraint(c, p) != null);
	}

	private String calculateConstraint() {
	String constraint = null;
	LayoutManager lm = dockingSource.getLayout();
	if (lm instanceof BorderLayout) {
	constraint = (String)((BorderLayout)lm).getConstraints(toolBar);
	}
	return (constraint != null) ? constraint : constraintBeforeFloating;
	}



	private String getDockingConstraint(Component c, Point p) {
	if (p == null) return constraintBeforeFloating;
	if (c.contains(p)) {
	dockingSensitivity = (toolBar.getOrientation() == JToolBar.HORIZONTAL)
	? toolBar.getSize().height
	: toolBar.getSize().width;
	// North (Base distance on height for now!)
	if (p.y < dockingSensitivity && !isBlocked(c, BorderLayout.NORTH)) {
	return BorderLayout.NORTH;
	}
	// East (Base distance on height for now!)
	if (p.x >= c.getWidth() - dockingSensitivity && !isBlocked(c, BorderLayout.EAST)) {
	return BorderLayout.EAST;
	}
	// West (Base distance on height for now!)
	if (p.x < dockingSensitivity && !isBlocked(c, BorderLayout.WEST)) {
	return BorderLayout.WEST;
	}
	if (p.y >= c.getHeight() - dockingSensitivity && !isBlocked(c, BorderLayout.SOUTH)) {
	return BorderLayout.SOUTH;
	}
	}
	return null;
	}

	protected void dragTo(Point position, Point origin)
	{
	if (toolBar.isFloatable())
	{
	try
	{
	if (dragWindow == null)
	dragWindow = createDragWindow(toolBar);
	Point offset = dragWindow.getOffset();
	if (offset == null) {
	Dimension size = toolBar.getPreferredSize();
	offset = new Point(size.width/2, size.height/2);
	dragWindow.setOffset(offset);
	}
	Point global = new Point(origin.x+ position.x,
	origin.y+position.y);
	Point dragPoint = new Point(global.x- offset.x,
	global.y- offset.y);
	if (dockingSource == null)
	dockingSource = toolBar.getParent();
	constraintBeforeFloating = calculateConstraint();
	Point dockingPosition = dockingSource.getLocationOnScreen();
	Point comparisonPoint = new Point(global.x-dockingPosition.x,
	global.y-dockingPosition.y);
	if (canDock(dockingSource, comparisonPoint)) {
	dragWindow.setBackground(getDockingColor());
	String constraint = getDockingConstraint(dockingSource,
	comparisonPoint);
	int orientation = mapConstraintToOrientation(constraint);
	dragWindow.setOrientation(orientation);
	dragWindow.setBorderColor(dockingBorderColor);
	} else {
	dragWindow.setBackground(getFloatingColor());
	dragWindow.setBorderColor(floatingBorderColor);
	dragWindow.setOrientation(toolBar.getOrientation());
	}

	dragWindow.setLocation(dragPoint.x, dragPoint.y);
	if (dragWindow.isVisible() == false) {
	Dimension size = toolBar.getPreferredSize();
	dragWindow.setSize(size.width, size.height);
	dragWindow.show();
	}
	}
	catch ( IllegalComponentStateException e )
	{
	}
	}
	}

	protected void floatAt(Point position, Point origin)
	{
	if(toolBar.isFloatable())
	{
	try
	{
	Point offset = dragWindow.getOffset();
	if (offset == null) {
	offset = position;
	dragWindow.setOffset(offset);
	}
	Point global = new Point(origin.x+ position.x,
	origin.y+position.y);
	setFloatingLocation(global.x-offset.x,
	global.y-offset.y);
	if (dockingSource != null) {
	Point dockingPosition = dockingSource.getLocationOnScreen();
	Point comparisonPoint = new Point(global.x-dockingPosition.x,
	global.y-dockingPosition.y);
	if (canDock(dockingSource, comparisonPoint)) {
	setFloating(false, comparisonPoint);
	} else {
	setFloating(true, null);
	}
	} else {
	setFloating(true, null);
	}
	dragWindow.setOffset(null);
	}
	catch ( IllegalComponentStateException e )
	{
	}
	}
	}

	private Handler getHandler() {
	if (handler == null) {
	handler = new Handler();
	}
	return handler;
	}

	protected ContainerListener createToolBarContListener( )
	{
	return getHandler();
	}

	protected FocusListener createToolBarFocusListener( )
	{
	return getHandler();
	}

	protected PropertyChangeListener createPropertyListener()
	{
	return getHandler();
	}

	protected MouseInputListener createDockingListener( ) {
	getHandler().tb = toolBar;
	return getHandler();
	}

	protected WindowListener createFrameListener() {
	return new FrameListener();
	}

	/**
	* Paints the contents of the window used for dragging.
	*
	* @param g Graphics to paint to.
	* @throws NullPointerException is <code>g</code> is null
	* @since 1.5
	*/
	protected void paintDragWindow(Graphics g) {
	g.setColor(dragWindow.getBackground());
	int w = dragWindow.getWidth();
	int h = dragWindow.getHeight();
	g.fillRect(0, 0, w, h);
	g.setColor(dragWindow.getBorderColor());
	g.drawRect(0, 0, w - 1, h - 1);
	}


	private static class Actions extends UIAction {
	private static final String NAVIGATE_RIGHT = "navigateRight";
	private static final String NAVIGATE_LEFT = "navigateLeft";
	private static final String NAVIGATE_UP = "navigateUp";
	private static final String NAVIGATE_DOWN = "navigateDown";

	public Actions(String name) {
	super(name);
	}

	public void actionPerformed(ActionEvent evt) {
	String key = getName();
	JToolBar toolBar = (JToolBar)evt.getSource();
	BasicToolBarUI ui = (BasicToolBarUI)BasicLookAndFeel.getUIOfType(
	toolBar.getUI(), BasicToolBarUI.class);

	if (NAVIGATE_RIGHT == key) {
	ui.navigateFocusedComp(EAST);
	} else if (NAVIGATE_LEFT == key) {
	ui.navigateFocusedComp(WEST);
	} else if (NAVIGATE_UP == key) {
	ui.navigateFocusedComp(NORTH);
	} else if (NAVIGATE_DOWN == key) {
	ui.navigateFocusedComp(SOUTH);
	}
	}
	}


	private class Handler implements ContainerListener,
	FocusListener, MouseInputListener, PropertyChangeListener {

	//
	// ContainerListener
	//
	public void componentAdded(ContainerEvent evt) {
	Component c = evt.getChild();

	if (toolBarFocusListener != null) {
	c.addFocusListener(toolBarFocusListener);
	}

	if (isRolloverBorders()) {
	setBorderToRollover(c);
	} else {
	setBorderToNonRollover(c);
	}
	}

	public void componentRemoved(ContainerEvent evt) {
	Component c = evt.getChild();

	if (toolBarFocusListener != null) {
	c.removeFocusListener(toolBarFocusListener);
	}

	// Revert the button border
	setBorderToNormal(c);
	}


	//
	// FocusListener
	//
	public void focusGained(FocusEvent evt) {
	Component c = evt.getComponent();
	focusedCompIndex = toolBar.getComponentIndex(c);
	}

	public void focusLost(FocusEvent evt) { }


	//
	// MouseInputListener (DockingListener)
	//
	JToolBar tb;
	boolean isDragging = false;
	Point origin = null;

	public void mousePressed(MouseEvent evt) {
	if (!tb.isEnabled()) {
	return;
	}
	isDragging = false;
	}

	public void mouseReleased(MouseEvent evt) {
	if (!tb.isEnabled()) {
	return;
	}
	if (isDragging) {
	Point position = evt.getPoint();
	if (origin == null)
	origin = evt.getComponent().getLocationOnScreen();
	floatAt(position, origin);
	}
	origin = null;
	isDragging = false;
	}

	public void mouseDragged(MouseEvent evt) {
	if (!tb.isEnabled()) {
	return;
	}
	isDragging = true;
	Point position = evt.getPoint();
	if (origin == null) {
	origin = evt.getComponent().getLocationOnScreen();
	}
	dragTo(position, origin);
	}

	public void mouseClicked(MouseEvent evt) {}
	public void mouseEntered(MouseEvent evt) {}
	public void mouseExited(MouseEvent evt) {}
	public void mouseMoved(MouseEvent evt) {}


	//
	// PropertyChangeListener
	//
	public void propertyChange(PropertyChangeEvent evt) {
	String propertyName = evt.getPropertyName();
	if (propertyName == "lookAndFeel") {
	toolBar.updateUI();
	} else if (propertyName == "orientation") {
	// Search for JSeparator components and change it's orientation
	// to match the toolbar and flip it's orientation.
	Component[] components = toolBar.getComponents();
	int orientation = ((Integer)evt.getNewValue()).intValue();
	JToolBar.Separator separator;

	for (int i = 0; i < components.length; ++i) {
	if (components[i] instanceof JToolBar.Separator) {
	separator = (JToolBar.Separator)components[i];
	if ((orientation == JToolBar.HORIZONTAL)) {
	separator.setOrientation(JSeparator.VERTICAL);
	} else {
	separator.setOrientation(JSeparator.HORIZONTAL);
	}
	Dimension size = separator.getSeparatorSize();
	if (size != null && size.width != size.height) {
	// Flip the orientation.
	Dimension newSize =
	new Dimension(size.height, size.width);
	separator.setSeparatorSize(newSize);
	}
	}
	}
	} else if (propertyName == IS_ROLLOVER) {
	installNormalBorders(toolBar);
	setRolloverBorders(((Boolean)evt.getNewValue()).booleanValue());
	}
	}
	}

	protected class FrameListener extends WindowAdapter {
	public void windowClosing(WindowEvent w) {
	if (toolBar.isFloatable()) {
	if (dragWindow != null)
	dragWindow.setVisible(false);
	floating = false;
	if (floatingToolBar == null)
	floatingToolBar = createFloatingWindow(toolBar);
	if (floatingToolBar instanceof Window) ((Window)floatingToolBar).setVisible(false);
	floatingToolBar.getContentPane().remove(toolBar);
	String constraint = constraintBeforeFloating;
	if (toolBar.getOrientation() == JToolBar.HORIZONTAL) {
	if (constraint == "West" \|\| constraint == "East") {
	constraint = "North";
	}
	} else {
	if (constraint == "North" \|\| constraint == "South") {
	constraint = "West";
	}
	}
	if (dockingSource == null)
	dockingSource = toolBar.getParent();
	if (propertyListener != null)
	UIManager.removePropertyChangeListener(propertyListener);
	dockingSource.add(toolBar, constraint);
	dockingSource.invalidate();
	Container dockingSourceParent = dockingSource.getParent();
	if (dockingSourceParent != null)
	dockingSourceParent.validate();
	dockingSource.repaint();
	}
	}

	}

	protected class ToolBarContListener implements ContainerListener {
	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.
	public void componentAdded( ContainerEvent e ) {
	getHandler().componentAdded(e);
	}

	public void componentRemoved( ContainerEvent e ) {
	getHandler().componentRemoved(e);
	}

	}

	protected class ToolBarFocusListener implements FocusListener {
	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.
	public void focusGained( FocusEvent e ) {
	getHandler().focusGained(e);
	}

	public void focusLost( FocusEvent e ) {
	getHandler().focusLost(e);
	}
	}

	protected class PropertyListener implements PropertyChangeListener {
	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.
	public void propertyChange( PropertyChangeEvent e ) {
	getHandler().propertyChange(e);
	}
	}

	/**
	* This class should be treated as a "protected" inner class.
	* Instantiate it only within subclasses of BasicToolBarUI.
	*/
	public class DockingListener implements MouseInputListener {
	// NOTE: This class exists only for backward compatibility. All
	// its functionality has been moved into Handler. If you need to add
	// new functionality add it to the Handler, but make sure this
	// class calls into the Handler.
	protected JToolBar toolBar;
	protected boolean isDragging = false;
	protected Point origin = null;

	public DockingListener(JToolBar t) {
	this.toolBar = t;
	getHandler().tb = t;
	}

	public void mouseClicked(MouseEvent e) {
	getHandler().mouseClicked(e);
	}

	public void mousePressed(MouseEvent e) {
	getHandler().tb = toolBar;
	getHandler().mousePressed(e);
	isDragging = getHandler().isDragging;
	}

	public void mouseReleased(MouseEvent e) {
	getHandler().tb = toolBar;
	getHandler().isDragging = isDragging;
	getHandler().origin = origin;
	getHandler().mouseReleased(e);
	isDragging = getHandler().isDragging;
	origin = getHandler().origin;
	}

	public void mouseEntered(MouseEvent e) {
	getHandler().mouseEntered(e);
	}

	public void mouseExited(MouseEvent e) {
	getHandler().mouseExited(e);
	}

	public void mouseDragged(MouseEvent e) {
	getHandler().tb = toolBar;
	getHandler().origin = origin;
	getHandler().mouseDragged(e);
	isDragging = getHandler().isDragging;
	origin = getHandler().origin;
	}

	public void mouseMoved(MouseEvent e) {
	getHandler().mouseMoved(e);
	}
	}

	protected class DragWindow extends Window
	{
	Color borderColor = Color.gray;
	int orientation = toolBar.getOrientation();
	Point offset; // offset of the mouse cursor inside the DragWindow

	DragWindow(Window w) {
	super(w);
	}

	/**
	* Returns the orientation of the toolbar window when the toolbar is
	* floating. The orientation is either one of <code>JToolBar.HORIZONTAL</code>
	* or <code>JToolBar.VERTICAL</code>.
	*
	* @return the orientation of the toolbar window
	* @since 1.6
	*/
	public int getOrientation() {
	return orientation;
	}

	public void setOrientation(int o) {
	if(isShowing()) {
	if (o == this.orientation)
	return;
	this.orientation = o;
	Dimension size = getSize();
	setSize(new Dimension(size.height, size.width));
	if (offset!=null) {
	if( BasicGraphicsUtils.isLeftToRight(toolBar) ) {
	setOffset(new Point(offset.y, offset.x));
	} else if( o == JToolBar.HORIZONTAL ) {
	setOffset(new Point( size.height-offset.y, offset.x));
	} else {
	setOffset(new Point(offset.y, size.width-offset.x));
	}
	}
	repaint();
	}
	}

	public Point getOffset() {
	return offset;
	}

	public void setOffset(Point p) {
	this.offset = p;
	}

	public void setBorderColor(Color c) {
	if (this.borderColor == c)
	return;
	this.borderColor = c;
	repaint();
	}

	public Color getBorderColor() {
	return this.borderColor;
	}

	public void paint(Graphics g) {
	paintDragWindow(g);
	// Paint the children
	super.paint(g);
	}
	public Insets getInsets() {
	return new Insets(1,1,1,1);
	}
	}
	}

Back to index...