/*
 * 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;

import java.awt.Color;
import java.awt.Component;
import java.awt.ComponentOrientation;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.LayoutManager2;
import java.awt.event.*;
import java.beans.*;

import javax.swing.border.Border;
import javax.swing.plaf.*;
import javax.accessibility.*;

import java.io.Serializable;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import java.util.Hashtable;


JToolBar provides a component that is useful for displaying commonly used Actions or controls. For examples and information on using tool bars see How to Use Tool Bars, a section in The Java Tutorial.

With most look and feels, the user can drag out a tool bar into a separate window (unless the floatable property is set to false). For drag-out to work correctly, it is recommended that you add JToolBar instances to one of the four "sides" of a container whose layout manager is a BorderLayout, and do not add children to any of the other four "sides".

Warning: Swing is not thread safe. For more information see Swing's Threading Policy.

Warning: Serialized objects of this class will not be compatible with future Swing releases. The current serialization support is appropriate for short term storage or RMI between applications running the same version of Swing. As of 1.4, support for long term storage of all JavaBeans™ has been added to the java.beans package. Please see XMLEncoder.

Author:Georges Saab, Jeff Shapiro
See Also:
@beaninfo attribute: isContainer true description: A component which displays commonly used controls or Actions.
/** * <code>JToolBar</code> provides a component that is useful for * displaying commonly used <code>Action</code>s or controls. * For examples and information on using tool bars see * <a href="https://docs.oracle.com/javase/tutorial/uiswing/components/toolbar.html">How to Use Tool Bars</a>, * a section in <em>The Java Tutorial</em>. * * <p> * With most look and feels, * the user can drag out a tool bar into a separate window * (unless the <code>floatable</code> property is set to <code>false</code>). * For drag-out to work correctly, it is recommended that you add * <code>JToolBar</code> instances to one of the four "sides" of a * container whose layout manager is a <code>BorderLayout</code>, * and do not add children to any of the other four "sides". * <p> * <strong>Warning:</strong> Swing is not thread safe. For more * information see <a * href="package-summary.html#threading">Swing's Threading * Policy</a>. * <p> * <strong>Warning:</strong> * Serialized objects of this class will not be compatible with * future Swing releases. The current serialization support is * appropriate for short term storage or RMI between applications running * the same version of Swing. As of 1.4, support for long term storage * of all JavaBeans&trade; * has been added to the <code>java.beans</code> package. * Please see {@link java.beans.XMLEncoder}. * * @beaninfo * attribute: isContainer true * description: A component which displays commonly used controls or Actions. * * @author Georges Saab * @author Jeff Shapiro * @see Action */
public class JToolBar extends JComponent implements SwingConstants, Accessible {
See Also:
/** * @see #getUIClassID * @see #readObject */
private static final String uiClassID = "ToolBarUI"; private boolean paintBorder = true; private Insets margin = null; private boolean floatable = true; private int orientation = HORIZONTAL;
Creates a new tool bar; orientation defaults to HORIZONTAL.
/** * Creates a new tool bar; orientation defaults to <code>HORIZONTAL</code>. */
public JToolBar() { this( HORIZONTAL ); }
Creates a new tool bar with the specified orientation. The orientation must be either HORIZONTAL or VERTICAL.
Params:
  • orientation – the orientation desired
/** * Creates a new tool bar with the specified <code>orientation</code>. * The <code>orientation</code> must be either <code>HORIZONTAL</code> * or <code>VERTICAL</code>. * * @param orientation the orientation desired */
public JToolBar( int orientation ) { this(null, orientation); }
Creates a new tool bar with the specified name. The name is used as the title of the undocked tool bar. The default orientation is HORIZONTAL.
Params:
  • name – the name of the tool bar
Since:1.3
/** * Creates a new tool bar with the specified <code>name</code>. The * name is used as the title of the undocked tool bar. The default * orientation is <code>HORIZONTAL</code>. * * @param name the name of the tool bar * @since 1.3 */
public JToolBar( String name ) { this(name, HORIZONTAL); }
Creates a new tool bar with a specified name and orientation. All other constructors call this constructor. If orientation is an invalid value, an exception will be thrown.
Params:
  • name – the name of the tool bar
  • orientation – the initial orientation -- it must be either HORIZONTAL or VERTICAL
Throws:
Since:1.3
/** * Creates a new tool bar with a specified <code>name</code> and * <code>orientation</code>. * All other constructors call this constructor. * If <code>orientation</code> is an invalid value, an exception will * be thrown. * * @param name the name of the tool bar * @param orientation the initial orientation -- it must be * either <code>HORIZONTAL</code> or <code>VERTICAL</code> * @exception IllegalArgumentException if orientation is neither * <code>HORIZONTAL</code> nor <code>VERTICAL</code> * @since 1.3 */
public JToolBar( String name , int orientation) { setName(name); checkOrientation( orientation ); this.orientation = orientation; DefaultToolBarLayout layout = new DefaultToolBarLayout( orientation ); setLayout( layout ); addPropertyChangeListener( layout ); updateUI(); }
Returns the tool bar's current UI.
See Also:
  • setUI
/** * Returns the tool bar's current UI. * @see #setUI */
public ToolBarUI getUI() { return (ToolBarUI)ui; }
Sets the L&F object that renders this component.
Params:
  • ui – the ToolBarUI L&F object
See Also:
@beaninfo bound: true hidden: true attribute: visualUpdate true description: The UI object that implements the Component's LookAndFeel.
/** * Sets the L&amp;F object that renders this component. * * @param ui the <code>ToolBarUI</code> L&amp;F object * @see UIDefaults#getUI * @beaninfo * bound: true * hidden: true * attribute: visualUpdate true * description: The UI object that implements the Component's LookAndFeel. */
public void setUI(ToolBarUI ui) { super.setUI(ui); }
Notification from the UIFactory that the L&F has changed. Called to replace the UI with the latest version from the UIFactory.
See Also:
  • updateUI.updateUI
/** * Notification from the <code>UIFactory</code> that the L&amp;F has changed. * Called to replace the UI with the latest version from the * <code>UIFactory</code>. * * @see JComponent#updateUI */
public void updateUI() { setUI((ToolBarUI)UIManager.getUI(this)); // GTKLookAndFeel installs a different LayoutManager, and sets it // to null after changing the look and feel, so, install the default // if the LayoutManager is null. if (getLayout() == null) { setLayout(new DefaultToolBarLayout(getOrientation())); } invalidate(); }
Returns the name of the L&F class that renders this component.
See Also:
Returns:the string "ToolBarUI"
/** * Returns the name of the L&amp;F class that renders this component. * * @return the string "ToolBarUI" * @see JComponent#getUIClassID * @see UIDefaults#getUI */
public String getUIClassID() { return uiClassID; }
Returns the index of the specified component. (Note: Separators occupy index positions.)
Params:
  • c – the Component to find
Returns:an integer indicating the component's position, where 0 is first
/** * Returns the index of the specified component. * (Note: Separators occupy index positions.) * * @param c the <code>Component</code> to find * @return an integer indicating the component's position, * where 0 is first */
public int getComponentIndex(Component c) { int ncomponents = this.getComponentCount(); Component[] component = this.getComponents(); for (int i = 0 ; i < ncomponents ; i++) { Component comp = component[i]; if (comp == c) return i; } return -1; }
Returns the component at the specified index.
Params:
  • i – the component's position, where 0 is first
Returns: the Component at that position, or null for an invalid index
/** * Returns the component at the specified index. * * @param i the component's position, where 0 is first * @return the <code>Component</code> at that position, * or <code>null</code> for an invalid index * */
public Component getComponentAtIndex(int i) { int ncomponents = this.getComponentCount(); if ( i >= 0 && i < ncomponents) { Component[] component = this.getComponents(); return component[i]; } return null; }
Sets the margin between the tool bar's border and its buttons. Setting to null causes the tool bar to use the default margins. The tool bar's default Border object uses this value to create the proper margin. However, if a non-default border is set on the tool bar, it is that Border object's responsibility to create the appropriate margin space (otherwise this property will effectively be ignored).
Params:
  • m – an Insets object that defines the space between the border and the buttons
See Also:
@beaninfo description: The margin between the tool bar's border and contents bound: true expert: true
/** * Sets the margin between the tool bar's border and * its buttons. Setting to <code>null</code> causes the tool bar to * use the default margins. The tool bar's default <code>Border</code> * object uses this value to create the proper margin. * However, if a non-default border is set on the tool bar, * it is that <code>Border</code> object's responsibility to create the * appropriate margin space (otherwise this property will * effectively be ignored). * * @param m an <code>Insets</code> object that defines the space * between the border and the buttons * @see Insets * @beaninfo * description: The margin between the tool bar's border and contents * bound: true * expert: true */
public void setMargin(Insets m) { Insets old = margin; margin = m; firePropertyChange("margin", old, m); revalidate(); repaint(); }
Returns the margin between the tool bar's border and its buttons.
See Also:
Returns:an Insets object containing the margin values
/** * Returns the margin between the tool bar's border and * its buttons. * * @return an <code>Insets</code> object containing the margin values * @see Insets */
public Insets getMargin() { if(margin == null) { return new Insets(0,0,0,0); } else { return margin; } }
Gets the borderPainted property.
See Also:
Returns:the value of the borderPainted property
/** * Gets the <code>borderPainted</code> property. * * @return the value of the <code>borderPainted</code> property * @see #setBorderPainted */
public boolean isBorderPainted() { return paintBorder; }
Sets the borderPainted property, which is true if the border should be painted. The default value for this property is true. Some look and feels might not implement painted borders; they will ignore this property.
Params:
  • b – if true, the border is painted
See Also:
@beaninfo description: Does the tool bar paint its borders? bound: true expert: true
/** * Sets the <code>borderPainted</code> property, which is * <code>true</code> if the border should be painted. * The default value for this property is <code>true</code>. * Some look and feels might not implement painted borders; * they will ignore this property. * * @param b if true, the border is painted * @see #isBorderPainted * @beaninfo * description: Does the tool bar paint its borders? * bound: true * expert: true */
public void setBorderPainted(boolean b) { if ( paintBorder != b ) { boolean old = paintBorder; paintBorder = b; firePropertyChange("borderPainted", old, b); revalidate(); repaint(); } }
Paints the tool bar's border if the borderPainted property is true.
Params:
  • g – the Graphics context in which the painting is done
See Also:
/** * Paints the tool bar's border if the <code>borderPainted</code> property * is <code>true</code>. * * @param g the <code>Graphics</code> context in which the painting * is done * @see JComponent#paint * @see JComponent#setBorder */
protected void paintBorder(Graphics g) { if (isBorderPainted()) { super.paintBorder(g); } }
Gets the floatable property.
See Also:
Returns:the value of the floatable property
/** * Gets the <code>floatable</code> property. * * @return the value of the <code>floatable</code> property * * @see #setFloatable */
public boolean isFloatable() { return floatable; }
Sets the floatable property, which must be true for the user to move the tool bar. Typically, a floatable tool bar can be dragged into a different position within the same container or out into its own window. The default value of this property is true. Some look and feels might not implement floatable tool bars; they will ignore this property.
Params:
  • b – if true, the tool bar can be moved; false otherwise
See Also:
@beaninfo description: Can the tool bar be made to float by the user? bound: true preferred: true
/** * Sets the <code>floatable</code> property, * which must be <code>true</code> for the user to move the tool bar. * Typically, a floatable tool bar can be * dragged into a different position within the same container * or out into its own window. * The default value of this property is <code>true</code>. * Some look and feels might not implement floatable tool bars; * they will ignore this property. * * @param b if <code>true</code>, the tool bar can be moved; * <code>false</code> otherwise * @see #isFloatable * @beaninfo * description: Can the tool bar be made to float by the user? * bound: true * preferred: true */
public void setFloatable( boolean b ) { if ( floatable != b ) { boolean old = floatable; floatable = b; firePropertyChange("floatable", old, b); revalidate(); repaint(); } }
Returns the current orientation of the tool bar. The value is either HORIZONTAL or VERTICAL.
See Also:
Returns:an integer representing the current orientation -- either HORIZONTAL or VERTICAL
/** * Returns the current orientation of the tool bar. The value is either * <code>HORIZONTAL</code> or <code>VERTICAL</code>. * * @return an integer representing the current orientation -- either * <code>HORIZONTAL</code> or <code>VERTICAL</code> * @see #setOrientation */
public int getOrientation() { return this.orientation; }
Sets the orientation of the tool bar. The orientation must have either the value HORIZONTAL or VERTICAL. If orientation is an invalid value, an exception will be thrown.
Params:
  • o – the new orientation -- either HORIZONTAL or VERTICAL
Throws:
See Also:
@beaninfo description: The current orientation of the tool bar bound: true preferred: true enum: HORIZONTAL SwingConstants.HORIZONTAL VERTICAL SwingConstants.VERTICAL
/** * Sets the orientation of the tool bar. The orientation must have * either the value <code>HORIZONTAL</code> or <code>VERTICAL</code>. * If <code>orientation</code> is * an invalid value, an exception will be thrown. * * @param o the new orientation -- either <code>HORIZONTAL</code> or * <code>VERTICAL</code> * @exception IllegalArgumentException if orientation is neither * <code>HORIZONTAL</code> nor <code>VERTICAL</code> * @see #getOrientation * @beaninfo * description: The current orientation of the tool bar * bound: true * preferred: true * enum: HORIZONTAL SwingConstants.HORIZONTAL * VERTICAL SwingConstants.VERTICAL */
public void setOrientation( int o ) { checkOrientation( o ); if ( orientation != o ) { int old = orientation; orientation = o; firePropertyChange("orientation", old, o); revalidate(); repaint(); } }
Sets the rollover state of this toolbar. If the rollover state is true then the border of the toolbar buttons will be drawn only when the mouse pointer hovers over them. The default value of this property is false.

The implementation of a look and feel may choose to ignore this property.

Params:
  • rollover – true for rollover toolbar buttons; otherwise false
Since:1.4
@beaninfo bound: true preferred: true attribute: visualUpdate true description: Will draw rollover button borders in the toolbar.
/** * Sets the rollover state of this toolbar. If the rollover state is true * then the border of the toolbar buttons will be drawn only when the * mouse pointer hovers over them. The default value of this property * is false. * <p> * The implementation of a look and feel may choose to ignore this * property. * * @param rollover true for rollover toolbar buttons; otherwise false * @since 1.4 * @beaninfo * bound: true * preferred: true * attribute: visualUpdate true * description: Will draw rollover button borders in the toolbar. */
public void setRollover(boolean rollover) { putClientProperty("JToolBar.isRollover", rollover ? Boolean.TRUE : Boolean.FALSE); }
Returns the rollover state.
See Also:
Returns:true if rollover toolbar buttons are to be drawn; otherwise false
Since:1.4
/** * Returns the rollover state. * * @return true if rollover toolbar buttons are to be drawn; otherwise false * @see #setRollover(boolean) * @since 1.4 */
public boolean isRollover() { Boolean rollover = (Boolean)getClientProperty("JToolBar.isRollover"); if (rollover != null) { return rollover.booleanValue(); } return false; } private void checkOrientation( int orientation ) { switch ( orientation ) { case VERTICAL: case HORIZONTAL: break; default: throw new IllegalArgumentException( "orientation must be one of: VERTICAL, HORIZONTAL" ); } }
Appends a separator of default size to the end of the tool bar. The default size is determined by the current look and feel.
/** * Appends a separator of default size to the end of the tool bar. * The default size is determined by the current look and feel. */
public void addSeparator() { addSeparator(null); }
Appends a separator of a specified size to the end of the tool bar.
Params:
  • size – the Dimension of the separator
/** * Appends a separator of a specified size to the end * of the tool bar. * * @param size the <code>Dimension</code> of the separator */
public void addSeparator( Dimension size ) { JToolBar.Separator s = new JToolBar.Separator( size ); add(s); }
Adds a new JButton which dispatches the action.
Params:
  • a – the Action object to add as a new menu item
Returns:the new button which dispatches the action
/** * Adds a new <code>JButton</code> which dispatches the action. * * @param a the <code>Action</code> object to add as a new menu item * @return the new button which dispatches the action */
public JButton add(Action a) { JButton b = createActionComponent(a); b.setAction(a); add(b); return b; }
Factory method which creates the JButton for Actions added to the JToolBar. The default name is empty if a null action is passed.
Params:
  • a – the Action for the button to be added
See Also:
Returns:the newly created button
Since:1.3
/** * Factory method which creates the <code>JButton</code> for * <code>Action</code>s added to the <code>JToolBar</code>. * The default name is empty if a <code>null</code> action is passed. * * @param a the <code>Action</code> for the button to be added * @return the newly created button * @see Action * @since 1.3 */
protected JButton createActionComponent(Action a) { JButton b = new JButton() { protected PropertyChangeListener createActionPropertyChangeListener(Action a) { PropertyChangeListener pcl = createActionChangeListener(this); if (pcl==null) { pcl = super.createActionPropertyChangeListener(a); } return pcl; } }; if (a != null && (a.getValue(Action.SMALL_ICON) != null || a.getValue(Action.LARGE_ICON_KEY) != null)) { b.setHideActionText(true); } b.setHorizontalTextPosition(JButton.CENTER); b.setVerticalTextPosition(JButton.BOTTOM); return b; }
Returns a properly configured PropertyChangeListener which updates the control as changes to the Action occur, or null if the default property change listener for the control is desired.
Returns:null
/** * Returns a properly configured <code>PropertyChangeListener</code> * which updates the control as changes to the <code>Action</code> occur, * or <code>null</code> if the default * property change listener for the control is desired. * * @return <code>null</code> */
protected PropertyChangeListener createActionChangeListener(JButton b) { return null; }
If a JButton is being added, it is initially set to be disabled.
Params:
  • comp – the component to be enhanced
  • constraints – the constraints to be enforced on the component
  • index – the index of the component
/** * If a <code>JButton</code> is being added, it is initially * set to be disabled. * * @param comp the component to be enhanced * @param constraints the constraints to be enforced on the component * @param index the index of the component * */
protected void addImpl(Component comp, Object constraints, int index) { if (comp instanceof Separator) { if (getOrientation() == VERTICAL) { ( (Separator)comp ).setOrientation(JSeparator.HORIZONTAL); } else { ( (Separator)comp ).setOrientation(JSeparator.VERTICAL); } } super.addImpl(comp, constraints, index); if (comp instanceof JButton) { ((JButton)comp).setDefaultCapable(false); } }
A toolbar-specific separator. An object with dimension but no contents used to divide buttons on a tool bar into groups.
/** * A toolbar-specific separator. An object with dimension but * no contents used to divide buttons on a tool bar into groups. */
static public class Separator extends JSeparator { private Dimension separatorSize;
Creates a new toolbar separator with the default size as defined by the current look and feel.
/** * Creates a new toolbar separator with the default size * as defined by the current look and feel. */
public Separator() { this( null ); // let the UI define the default size }
Creates a new toolbar separator with the specified size.
Params:
  • size – the Dimension of the separator
/** * Creates a new toolbar separator with the specified size. * * @param size the <code>Dimension</code> of the separator */
public Separator( Dimension size ) { super( JSeparator.HORIZONTAL ); setSeparatorSize(size); }
Returns the name of the L&F class that renders this component.
See Also:
Returns:the string "ToolBarSeparatorUI"
/** * Returns the name of the L&amp;F class that renders this component. * * @return the string "ToolBarSeparatorUI" * @see JComponent#getUIClassID * @see UIDefaults#getUI */
public String getUIClassID() { return "ToolBarSeparatorUI"; }
Sets the size of the separator.
Params:
  • size – the new Dimension of the separator
/** * Sets the size of the separator. * * @param size the new <code>Dimension</code> of the separator */
public void setSeparatorSize( Dimension size ) { if (size != null) { separatorSize = size; } else { super.updateUI(); } this.invalidate(); }
Returns the size of the separator
Returns:the Dimension object containing the separator's size (This is a reference, NOT a copy!)
/** * Returns the size of the separator * * @return the <code>Dimension</code> object containing the separator's * size (This is a reference, NOT a copy!) */
public Dimension getSeparatorSize() { return separatorSize; }
Returns the minimum size for the separator.
Returns:the Dimension object containing the separator's minimum size
/** * Returns the minimum size for the separator. * * @return the <code>Dimension</code> object containing the separator's * minimum size */
public Dimension getMinimumSize() { if (separatorSize != null) { return separatorSize.getSize(); } else { return super.getMinimumSize(); } }
Returns the maximum size for the separator.
Returns:the Dimension object containing the separator's maximum size
/** * Returns the maximum size for the separator. * * @return the <code>Dimension</code> object containing the separator's * maximum size */
public Dimension getMaximumSize() { if (separatorSize != null) { return separatorSize.getSize(); } else { return super.getMaximumSize(); } }
Returns the preferred size for the separator.
Returns:the Dimension object containing the separator's preferred size
/** * Returns the preferred size for the separator. * * @return the <code>Dimension</code> object containing the separator's * preferred size */
public Dimension getPreferredSize() { if (separatorSize != null) { return separatorSize.getSize(); } else { return super.getPreferredSize(); } } }
See readObject and writeObject in JComponent for more information about serialization in Swing.
/** * See <code>readObject</code> and <code>writeObject</code> in * <code>JComponent</code> for more * information about serialization in Swing. */
private void writeObject(ObjectOutputStream s) throws IOException { s.defaultWriteObject(); if (getUIClassID().equals(uiClassID)) { byte count = JComponent.getWriteObjCounter(this); JComponent.setWriteObjCounter(this, --count); if (count == 0 && ui != null) { ui.installUI(this); } } }
Returns a string representation of this JToolBar. This method is intended to be used only for debugging purposes, and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null.
Returns: a string representation of this JToolBar.
/** * Returns a string representation of this <code>JToolBar</code>. * This method * is intended to be used only for debugging purposes, and the * content and format of the returned string may vary between * implementations. The returned string may be empty but may not * be <code>null</code>. * * @return a string representation of this <code>JToolBar</code>. */
protected String paramString() { String paintBorderString = (paintBorder ? "true" : "false"); String marginString = (margin != null ? margin.toString() : ""); String floatableString = (floatable ? "true" : "false"); String orientationString = (orientation == HORIZONTAL ? "HORIZONTAL" : "VERTICAL"); return super.paramString() + ",floatable=" + floatableString + ",margin=" + marginString + ",orientation=" + orientationString + ",paintBorder=" + paintBorderString; } private class DefaultToolBarLayout implements LayoutManager2, Serializable, PropertyChangeListener, UIResource { BoxLayout lm; DefaultToolBarLayout(int orientation) { if (orientation == JToolBar.VERTICAL) { lm = new BoxLayout(JToolBar.this, BoxLayout.PAGE_AXIS); } else { lm = new BoxLayout(JToolBar.this, BoxLayout.LINE_AXIS); } } public void addLayoutComponent(String name, Component comp) { lm.addLayoutComponent(name, comp); } public void addLayoutComponent(Component comp, Object constraints) { lm.addLayoutComponent(comp, constraints); } public void removeLayoutComponent(Component comp) { lm.removeLayoutComponent(comp); } public Dimension preferredLayoutSize(Container target) { return lm.preferredLayoutSize(target); } public Dimension minimumLayoutSize(Container target) { return lm.minimumLayoutSize(target); } public Dimension maximumLayoutSize(Container target) { return lm.maximumLayoutSize(target); } public void layoutContainer(Container target) { lm.layoutContainer(target); } public float getLayoutAlignmentX(Container target) { return lm.getLayoutAlignmentX(target); } public float getLayoutAlignmentY(Container target) { return lm.getLayoutAlignmentY(target); } public void invalidateLayout(Container target) { lm.invalidateLayout(target); } public void propertyChange(PropertyChangeEvent e) { String name = e.getPropertyName(); if( name.equals("orientation") ) { int o = ((Integer)e.getNewValue()).intValue(); if (o == JToolBar.VERTICAL) lm = new BoxLayout(JToolBar.this, BoxLayout.PAGE_AXIS); else { lm = new BoxLayout(JToolBar.this, BoxLayout.LINE_AXIS); } } } } public void setLayout(LayoutManager mgr) { LayoutManager oldMgr = getLayout(); if (oldMgr instanceof PropertyChangeListener) { removePropertyChangeListener((PropertyChangeListener)oldMgr); } super.setLayout(mgr); } ///////////////// // Accessibility support ////////////////
Gets the AccessibleContext associated with this JToolBar. For tool bars, the AccessibleContext takes the form of an AccessibleJToolBar. A new AccessibleJToolBar instance is created if necessary.
Returns:an AccessibleJToolBar that serves as the AccessibleContext of this JToolBar
/** * Gets the AccessibleContext associated with this JToolBar. * For tool bars, the AccessibleContext takes the form of an * AccessibleJToolBar. * A new AccessibleJToolBar instance is created if necessary. * * @return an AccessibleJToolBar that serves as the * AccessibleContext of this JToolBar */
public AccessibleContext getAccessibleContext() { if (accessibleContext == null) { accessibleContext = new AccessibleJToolBar(); } return accessibleContext; }
This class implements accessibility support for the JToolBar class. It provides an implementation of the Java Accessibility API appropriate to toolbar user-interface elements.
/** * This class implements accessibility support for the * <code>JToolBar</code> class. It provides an implementation of the * Java Accessibility API appropriate to toolbar user-interface elements. */
protected class AccessibleJToolBar extends AccessibleJComponent {
Get the state of this object.
See Also:
Returns:an instance of AccessibleStateSet containing the current state set of the object
/** * Get the state of this object. * * @return an instance of AccessibleStateSet containing the current * state set of the object * @see AccessibleState */
public AccessibleStateSet getAccessibleStateSet() { AccessibleStateSet states = super.getAccessibleStateSet(); // FIXME: [[[WDW - need to add orientation from BoxLayout]]] // FIXME: [[[WDW - need to do SELECTABLE if SelectionModel is added]]] return states; }
Get the role of this object.
Returns:an instance of AccessibleRole describing the role of the object
/** * Get the role of this object. * * @return an instance of AccessibleRole describing the role of the object */
public AccessibleRole getAccessibleRole() { return AccessibleRole.TOOL_BAR; } } // inner class AccessibleJToolBar }