| /* JToolBar.java -- |
| Copyright (C) 2002, 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; |
| |
| import java.awt.Component; |
| import java.awt.Container; |
| import java.awt.Dimension; |
| import java.awt.Graphics; |
| import java.awt.Insets; |
| import java.awt.LayoutManager; |
| import java.beans.PropertyChangeListener; |
| |
| import javax.accessibility.Accessible; |
| import javax.accessibility.AccessibleContext; |
| import javax.accessibility.AccessibleRole; |
| import javax.accessibility.AccessibleStateSet; |
| import javax.swing.plaf.ToolBarUI; |
| |
| /** |
| * JToolBar is a component that provides a toolbar to Swing programs. Users |
| * can add buttons (or actions that will be represented by JButtons) as well |
| * as other components to the JToolBar. JToolBars can be dragged in and out |
| * of their parent components. If the JToolBar is dragged out of the parent, |
| * then it will be displayed in its own RootPaneContainer. For dragging to |
| * work properly, JToolBars need to be placed in a Container that has a |
| * BorderLayout. That parent Container cannot have components in the NORTH, |
| * EAST, SOUTH, or WEST components (that is not the JToolBar). |
| */ |
| public class JToolBar extends JComponent implements SwingConstants, Accessible |
| { |
| /** |
| * Provides the accessibility features for the <code>JToolBar</code> |
| * component. |
| */ |
| protected class AccessibleJToolBar extends AccessibleJComponent |
| { |
| private static final long serialVersionUID = -5516888265903814215L; |
| |
| /** |
| * Creates a new <code>AccessibleJToolBar</code> instance. |
| */ |
| protected AccessibleJToolBar() |
| { |
| // Nothing to do here. |
| } |
| |
| /** |
| * Returns a set containing the current state of the {@link JToolBar} |
| * component. The current implementation simply calls the superclass. |
| * |
| * @return The accessible state set. |
| */ |
| public AccessibleStateSet getAccessibleStateSet() |
| { |
| // running tests against the reference implementation, I was unable |
| // to find any state information that is set specifically by the |
| // tool bar... |
| return super.getAccessibleStateSet(); |
| } |
| |
| /** |
| * Returns the accessible role for the <code>JToolBar</code> component. |
| * |
| * @return {@link AccessibleRole#TOOL_BAR}. |
| */ |
| public AccessibleRole getAccessibleRole() |
| { |
| return AccessibleRole.TOOL_BAR; |
| } |
| } |
| |
| /** |
| * This is the private JToolBar layout manager. |
| */ |
| private class DefaultToolBarLayout implements LayoutManager |
| { |
| /** |
| * This method is called when a new component is added to the container. |
| * |
| * @param name The name of the component added. |
| * @param comp The component that was added. |
| */ |
| public void addLayoutComponent(String name, Component comp) |
| { |
| // Do nothing. |
| } |
| |
| /** |
| * This method is called to lay out the given container to position and |
| * size the child components. |
| * |
| * @param c The container to lay out. |
| * |
| * @throws Error DOCUMENT ME! |
| */ |
| public void layoutContainer(Container c) |
| { |
| if (! (c instanceof JToolBar)) |
| throw new Error("DefaultToolBarLayout can only be used on JToolBars."); |
| Insets insets = getInsets(); |
| Insets margin = getMargin(); |
| int middle; |
| if (margin != null) |
| { |
| insets.left += margin.left; |
| insets.top += margin.top; |
| insets.bottom += margin.bottom; |
| insets.right += margin.right; |
| } |
| Component[] components = c.getComponents(); |
| Dimension tdims = c.getSize(); |
| int start = 0; |
| Dimension pref; |
| |
| if (getOrientation() == SwingUtilities.HORIZONTAL) |
| { |
| start += insets.left; |
| for (int i = 0; i < components.length; i++) |
| { |
| if (components[i] != null && components[i].isVisible()) |
| { |
| pref = components[i].getPreferredSize(); |
| if (pref != null) |
| { |
| middle = (tdims.height - pref.height) / 2; |
| components[i].setBounds(start, middle, pref.width, |
| pref.height); |
| start += pref.width; |
| } |
| } |
| } |
| } |
| else |
| { |
| start += insets.top; |
| for (int i = 0; i < components.length; i++) |
| { |
| if (components[i] != null && components[i].isVisible()) |
| { |
| pref = components[i].getPreferredSize(); |
| if (pref != null) |
| { |
| middle = (tdims.width - pref.width) / 2; |
| components[i].setBounds(middle, start, pref.width, |
| pref.height); |
| start += pref.height; |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * This method returns the minimum size of the given container given the |
| * child components. |
| * |
| * @param parent The container to measure. |
| * |
| * @return The minimum size of the given container. |
| */ |
| public Dimension minimumLayoutSize(Container parent) |
| { |
| return preferredLayoutSize(parent); |
| } |
| |
| /** |
| * This method returns the preferred size of the given container given the |
| * child components. |
| * |
| * @param parent The container to measure. |
| * |
| * @return The preferred size of the given container. |
| */ |
| public Dimension preferredLayoutSize(Container parent) |
| { |
| int orientation = getOrientation(); |
| Component[] components = getComponents(); |
| |
| int limit = 0; |
| int total = 0; |
| Dimension dims; |
| |
| int w = 0; |
| int h = 0; |
| |
| if (orientation == SwingConstants.HORIZONTAL) |
| { |
| for (int i = 0; i < components.length; i++) |
| { |
| dims = components[i].getPreferredSize(); |
| if (dims != null) |
| { |
| if (dims.height > limit) |
| limit = dims.height; |
| total += dims.width; |
| } |
| } |
| w = total; |
| h = limit; |
| } |
| else |
| { |
| for (int i = 0; i < components.length; i++) |
| { |
| dims = components[i].getPreferredSize(); |
| if (dims != null) |
| { |
| if (dims.width > limit) |
| limit = dims.width; |
| total += dims.height; |
| } |
| } |
| w = limit; |
| h = total; |
| } |
| |
| Insets insets = getInsets(); |
| w += insets.left + insets.right; |
| h += insets.top + insets.bottom; |
| |
| Insets margin = getMargin(); |
| if (margin != null) |
| { |
| w += margin.left + margin.right; |
| h += margin.top + margin.bottom; |
| } |
| |
| return new Dimension(w, h); |
| } |
| |
| /** |
| * This method is called when the given component is removed from the |
| * container. |
| * |
| * @param comp The component removed. |
| */ |
| public void removeLayoutComponent(Component comp) |
| { |
| // Do nothing. |
| } |
| } |
| |
| /** |
| * This is an extension of JSeparator used in toolbars. Unlike JSeparator, |
| * nothing is painted for this Separator, it is only blank space that |
| * separates components. |
| */ |
| public static class Separator extends JSeparator |
| { |
| /** DOCUMENT ME! */ |
| private static final long serialVersionUID = -1656745644823105219L; |
| |
| /** |
| * Creates a new Separator object. |
| */ |
| public Separator() |
| { |
| super(); |
| } // Separator() |
| |
| /** |
| * Creates a new Separator object with the given size. |
| * |
| * @param size The size of the separator. |
| */ |
| public Separator(Dimension size) |
| { |
| setPreferredSize(size); |
| } // Separator() |
| |
| /** |
| * This method returns the String ID of the UI class of Separator. |
| * |
| * @return The UI class' String ID. |
| */ |
| public String getUIClassID() |
| { |
| return "ToolBarSeparatorUI"; |
| } // getUIClassID() |
| |
| /** |
| * This method returns the preferred size of the Separator. |
| * |
| * @return The preferred size of the Separator. |
| */ |
| public Dimension getPreferredSize() |
| { |
| return super.getPreferredSize(); |
| } // getPreferredSize() |
| |
| /** |
| * This method returns the maximum size of the Separator. |
| * |
| * @return The maximum size of the Separator. |
| */ |
| public Dimension getMaximumSize() |
| { |
| return super.getPreferredSize(); |
| } // getMaximumSize() |
| |
| /** |
| * This method returns the minimum size of the Separator. |
| * |
| * @return The minimum size of the Separator. |
| */ |
| public Dimension getMinimumSize() |
| { |
| return super.getPreferredSize(); |
| } // getMinimumSize() |
| |
| /** |
| * This method returns the size of the Separator. |
| * |
| * @return The size of the Separator. |
| */ |
| public Dimension getSeparatorSize() |
| { |
| return super.getPreferredSize(); |
| } // getSeparatorSize() |
| |
| /** |
| * This method sets the size of the Separator. |
| * |
| * @param size The new size of the Separator. |
| */ |
| public void setSeparatorSize(Dimension size) |
| { |
| setPreferredSize(size); |
| } // setSeparatorSize() |
| } // Separator |
| |
| /** DOCUMENT ME! */ |
| private static final long serialVersionUID = -1269915519555129643L; |
| |
| /** Whether the JToolBar paints its border. */ |
| private transient boolean paintBorder = true; |
| |
| /** The extra insets around the JToolBar. */ |
| private transient Insets margin; |
| |
| /** Whether the JToolBar can float (and be dragged around). */ |
| private transient boolean floatable = true; |
| |
| /** Whether the buttons will have rollover borders. */ |
| private transient boolean rollover; |
| |
| /** The orientation of the JToolBar. */ |
| private int orientation = HORIZONTAL; |
| |
| /** |
| * This method creates a new JToolBar object with horizontal orientation |
| * and no name. |
| */ |
| public JToolBar() |
| { |
| this(null, HORIZONTAL); |
| } // JToolBar() |
| |
| /** |
| * This method creates a new JToolBar with the given orientation and no |
| * name. |
| * |
| * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL) |
| */ |
| public JToolBar(int orientation) |
| { |
| this(null, orientation); |
| } // JToolBar() |
| |
| /** |
| * This method creates a new JToolBar object with the given name and |
| * horizontal orientation. |
| * |
| * @param name Name assigned to undocked tool bar. |
| */ |
| public JToolBar(String name) |
| { |
| this(name, HORIZONTAL); |
| } // JToolBar() |
| |
| /** |
| * This method creates a new JToolBar object with the given name and |
| * orientation. |
| * |
| * @param name Name assigned to undocked tool bar. |
| * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL) |
| */ |
| public JToolBar(String name, int orientation) |
| { |
| setName(name); |
| setOrientation(orientation); |
| setLayout(new DefaultToolBarLayout()); |
| revalidate(); |
| setOpaque(true); |
| updateUI(); |
| } |
| |
| /** |
| * This method adds a new JButton that performs the given Action to the |
| * JToolBar. |
| * |
| * @param action The Action to add to the JToolBar. |
| * |
| * @return The JButton that wraps the Action. |
| */ |
| public JButton add(Action action) |
| { |
| JButton b = createActionComponent(action); |
| add(b); |
| return b; |
| } // add() |
| |
| /** |
| * This method paints the border if the borderPainted property is true. |
| * |
| * @param graphics The graphics object to paint with. |
| */ |
| protected void paintBorder(Graphics graphics) |
| { |
| if (paintBorder && isFloatable()) |
| super.paintBorder(graphics); |
| } // paintBorder() |
| |
| /** |
| * This method returns the UI class used to paint this JToolBar. |
| * |
| * @return The UI class for this JToolBar. |
| */ |
| public ToolBarUI getUI() |
| { |
| return (ToolBarUI) ui; |
| } // getUI() |
| |
| /** |
| * This method sets the UI used with the JToolBar. |
| * |
| * @param ui The UI used with the JToolBar. |
| */ |
| public void setUI(ToolBarUI ui) |
| { |
| super.setUI(ui); |
| } // setUI() |
| |
| /** |
| * This method resets the UI used to the Look and Feel defaults. |
| */ |
| public void updateUI() |
| { |
| setUI((ToolBarUI) UIManager.getUI(this)); |
| } |
| |
| /** |
| * This method returns the String identifier for the UI class to the used |
| * with the JToolBar. |
| * |
| * @return The String identifier for the UI class. |
| */ |
| public String getUIClassID() |
| { |
| return "ToolBarUI"; |
| } // getUIClassID() |
| |
| /** |
| * This method sets the rollover property for the JToolBar. In rollover |
| * mode, JButtons inside the JToolBar will only display their borders when |
| * the mouse is moving over them. |
| * |
| * @param b The new rollover property. |
| */ |
| public void setRollover(boolean b) |
| { |
| if (b != rollover) |
| { |
| rollover = b; |
| firePropertyChange("rollover", ! rollover, rollover); |
| revalidate(); |
| repaint(); |
| } |
| } |
| |
| /** |
| * This method returns the rollover property. |
| * |
| * @return The rollover property. |
| */ |
| public boolean isRollover() |
| { |
| return rollover; |
| } |
| |
| /** |
| * This method returns the index of the given component. |
| * |
| * @param component The component to find. |
| * |
| * @return The index of the given component. |
| */ |
| public int getComponentIndex(Component component) |
| { |
| Component[] components = getComponents(); |
| if (components == null) |
| return -1; |
| |
| for (int i = 0; i < components.length; i++) |
| if (components[i] == component) |
| return i; |
| |
| return -1; |
| } // getComponentIndex() |
| |
| /** |
| * This method returns the component at the given index. |
| * |
| * @param index The index of the component. |
| * |
| * @return The component at the given index. |
| */ |
| public Component getComponentAtIndex(int index) |
| { |
| return getComponent(index); |
| } // getComponentAtIndex() |
| |
| /** |
| * This method returns the margin property. |
| * |
| * @return The margin property. |
| */ |
| public Insets getMargin() |
| { |
| return margin; |
| } // getMargin() |
| |
| /** |
| * This method sets the margin property. The margin property determines the |
| * extra space between the children components of the JToolBar and the |
| * border. |
| * |
| * @param margin The margin property. |
| */ |
| public void setMargin(Insets margin) |
| { |
| if ((this.margin != null && margin == null) |
| || (this.margin == null && margin != null) |
| || (margin != null && this.margin != null |
| && (margin.left != this.margin.left |
| || margin.right != this.margin.right || margin.top != this.margin.top |
| || margin.bottom != this.margin.bottom))) |
| { |
| Insets oldMargin = this.margin; |
| this.margin = margin; |
| firePropertyChange("margin", oldMargin, this.margin); |
| revalidate(); |
| repaint(); |
| } |
| } // setMargin() |
| |
| /** |
| * This method returns the borderPainted property. |
| * |
| * @return The borderPainted property. |
| */ |
| public boolean isBorderPainted() |
| { |
| return paintBorder; |
| } // isBorderPainted() |
| |
| /** |
| * This method sets the borderPainted property. If set to false, the border |
| * will not be painted. |
| * |
| * @param painted Whether the border will be painted. |
| */ |
| public void setBorderPainted(boolean painted) |
| { |
| if (painted != paintBorder) |
| { |
| paintBorder = painted; |
| firePropertyChange("borderPainted", ! paintBorder, |
| paintBorder); |
| repaint(); |
| } |
| } // setBorderPainted() |
| |
| /** |
| * This method returns the floatable property. |
| * |
| * @return The floatable property. |
| */ |
| public boolean isFloatable() |
| { |
| return floatable; |
| } // isFloatable() |
| |
| /** |
| * This method sets the floatable property. If set to false, the JToolBar |
| * cannot be dragged. |
| * |
| * @param floatable Whether the JToolBar can be dragged. |
| */ |
| public void setFloatable(boolean floatable) |
| { |
| if (floatable != this.floatable) |
| { |
| this.floatable = floatable; |
| firePropertyChange("floatable", ! floatable, floatable); |
| } |
| } // setFloatable() |
| |
| /** |
| * This method returns the orientation of the JToolBar. |
| * |
| * @return The orientation of the JToolBar. |
| */ |
| public int getOrientation() |
| { |
| return orientation; |
| } // getOrientation() |
| |
| /** |
| * This method sets the layout manager to be used with the JToolBar. |
| * |
| * @param mgr The Layout Manager used with the JToolBar. |
| */ |
| public void setLayout(LayoutManager mgr) |
| { |
| super.setLayout(mgr); |
| revalidate(); |
| repaint(); |
| } // setLayout() |
| |
| /** |
| * This method sets the orientation property for JToolBar. |
| * |
| * @param orientation The new orientation for JToolBar. |
| * |
| * @throws IllegalArgumentException If the orientation is not HORIZONTAL or |
| * VERTICAL. |
| */ |
| public void setOrientation(int orientation) |
| { |
| if (orientation != HORIZONTAL && orientation != VERTICAL) |
| throw new IllegalArgumentException(orientation |
| + " is not a legal orientation"); |
| if (orientation != this.orientation) |
| { |
| int oldOrientation = this.orientation; |
| this.orientation = orientation; |
| firePropertyChange("orientation", oldOrientation, this.orientation); |
| revalidate(); |
| repaint(); |
| } |
| } // setOrientation() |
| |
| /** |
| * This method adds a Separator of default size to the JToolBar. |
| */ |
| public void addSeparator() |
| { |
| add(new Separator()); |
| } // addSeparator() |
| |
| /** |
| * This method adds a Separator with the given size to the JToolBar. |
| * |
| * @param size The size of the Separator. |
| */ |
| public void addSeparator(Dimension size) |
| { |
| add(new Separator(size)); |
| } // addSeparator() |
| |
| /** |
| * This method is used to create JButtons which can be added to the JToolBar |
| * for the given action. |
| * |
| * @param action The action to create a JButton for. |
| * |
| * @return The JButton created from the action. |
| */ |
| protected JButton createActionComponent(Action action) |
| { |
| return new JButton(action); |
| } // createActionComponent() |
| |
| /** |
| * This method creates a pre-configured PropertyChangeListener which updates |
| * the control as changes are made to the Action. However, this is no |
| * longer the recommended way of adding Actions to Containers. As such, |
| * this method returns null. |
| * |
| * @param button The JButton to configure a PropertyChangeListener for. |
| * |
| * @return null. |
| */ |
| protected PropertyChangeListener createActionChangeListener(JButton button) |
| { |
| // XXX: As specified, this returns null. But seems kind of strange, usually deprecated methods don't just return null, verify! |
| return null; |
| } // createActionChangeListener() |
| |
| /** |
| * This method overrides Container's addImpl method. If a JButton is added, |
| * it is disabled. |
| * |
| * @param component The Component to add. |
| * @param constraints The Constraints placed on the component. |
| * @param index The index to place the Component at. |
| */ |
| protected void addImpl(Component component, Object constraints, int index) |
| { |
| // XXX: Sun says disable button but test cases show otherwise. |
| super.addImpl(component, constraints, index); |
| |
| // if we added a Swing Button then adjust this a little |
| if (component instanceof AbstractButton) |
| { |
| AbstractButton b = (AbstractButton) component; |
| b.setRolloverEnabled(rollover); |
| } |
| |
| } // addImpl() |
| |
| /** |
| * Returns a string describing the attributes for the <code>JToolBar</code> |
| * component, for use in debugging. The return value is guaranteed to be |
| * non-<code>null</code>, but the format of the string may vary between |
| * implementations. |
| * |
| * @return A string describing the attributes of the <code>JToolBar</code>. |
| */ |
| protected String paramString() |
| { |
| StringBuffer sb = new StringBuffer(super.paramString()); |
| sb.append(",floatable=").append(floatable); |
| sb.append(",margin="); |
| if (margin != null) |
| sb.append(margin); |
| sb.append(",orientation="); |
| if (orientation == HORIZONTAL) |
| sb.append("HORIZONTAL"); |
| else |
| sb.append(VERTICAL); |
| sb.append(",paintBorder=").append(paintBorder); |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns the object that provides accessibility features for this |
| * <code>JToolBar</code> component. |
| * |
| * @return The accessible context (an instance of {@link AccessibleJToolBar}). |
| */ |
| public AccessibleContext getAccessibleContext() |
| { |
| if (accessibleContext == null) |
| accessibleContext = new AccessibleJToolBar(); |
| |
| return accessibleContext; |
| } |
| } |