diff options
Diffstat (limited to 'libjava/javax/swing/JToolBar.java')
| -rw-r--r-- | libjava/javax/swing/JToolBar.java | 733 |
1 files changed, 505 insertions, 228 deletions
diff --git a/libjava/javax/swing/JToolBar.java b/libjava/javax/swing/JToolBar.java index e6db8720c2c..7b5121e76fc 100644 --- a/libjava/javax/swing/JToolBar.java +++ b/libjava/javax/swing/JToolBar.java @@ -38,6 +38,7 @@ 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.GridLayout; @@ -46,26 +47,31 @@ import java.awt.LayoutManager; import java.beans.PropertyChangeListener; import java.io.IOException; import java.io.ObjectOutputStream; - import javax.accessibility.Accessible; import javax.accessibility.AccessibleContext; import javax.accessibility.AccessibleRole; import javax.accessibility.AccessibleStateSet; import javax.swing.plaf.ToolBarUI; + /** - * JToolBar - * @author Andrew Selkirk - * @version 1.0 + * 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 +public class JToolBar extends JComponent implements SwingConstants, Accessible { /** * AccessibleJToolBar */ protected class AccessibleJToolBar extends AccessibleJComponent { + /** DOCUMENT ME! */ private static final long serialVersionUID = -5516888265903814215L; /** @@ -77,6 +83,7 @@ public class JToolBar extends JComponent /** * getAccessibleStateSet + * * @return AccessibleStateSet */ public AccessibleStateSet getAccessibleStateSet() @@ -86,6 +93,7 @@ public class JToolBar extends JComponent /** * getAccessibleRole + * * @return AccessibleRole */ public AccessibleRole getAccessibleRole() @@ -95,409 +103,678 @@ public class JToolBar extends JComponent } /** - * Separator + * 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 static class Separator extends JSeparator { + public void addLayoutComponent(String name, Component comp) + { + // Do nothing. + } - private static final long serialVersionUID = -1656745644823105219L; + /** + * 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; - //------------------------------------------------------------- - // Variables -------------------------------------------------- - //------------------------------------------------------------- + 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); + } /** - * separatorSize + * 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. */ - private Dimension size; + public Dimension preferredLayoutSize(Container parent) + { + int orientation = getOrientation(); + Component[] components = getComponents(); + int limit = 0; + int total = 0; + Dimension dims; - //------------------------------------------------------------- - // Initialization --------------------------------------------- - //------------------------------------------------------------- + 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); + } /** - * Constructor Separator + * This method is called when the given component is removed from the + * container. + * + * @param comp The component removed. */ - public Separator() { - // TODO - } // Separator() + public void removeLayoutComponent(Component comp) + { + // Do nothing. + } + } /** - * Constructor Separator - * @param size TODO + * 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 Separator(Dimension size) { - // TODO - } // Separator() + public static class Separator extends JSeparator + { + /** DOCUMENT ME! */ + private static final long serialVersionUID = -1656745644823105219L; + /** + * Creates a new Separator object. + */ + public Separator() + { + super(); + } // Separator() - //------------------------------------------------------------- - // Methods ---------------------------------------------------- - //------------------------------------------------------------- + /** + * Creates a new Separator object with the given size. + * + * @param size The size of the separator. + */ + public Separator(Dimension size) + { + setPreferredSize(size); + } // Separator() /** - * getUIClassID - * @returns String + * This method returns the String ID of the UI class of Separator. + * + * @return The UI class' String ID. */ - public String getUIClassID() { - return null; // TODO + public String getUIClassID() + { + return "ToolBarSeparatorUI"; } // getUIClassID() /** - * getPreferredSize - * @returns Dimension + * This method returns the preferred size of the Separator. + * + * @return The preferred size of the Separator. */ - public Dimension getPreferredSize() { - return null; // TODO + public Dimension getPreferredSize() + { + return super.getPreferredSize(); } // getPreferredSize() /** - * getMaximumSize - * @returns Dimension + * This method returns the maximum size of the Separator. + * + * @return The maximum size of the Separator. */ - public Dimension getMaximumSize() { - return null; // TODO + public Dimension getMaximumSize() + { + return super.getPreferredSize(); } // getMaximumSize() /** - * getMinimumSize - * @returns Dimension + * This method returns the minimum size of the Separator. + * + * @return The minimum size of the Separator. */ - public Dimension getMinimumSize() { - return null; // TODO + public Dimension getMinimumSize() + { + return super.getPreferredSize(); } // getMinimumSize() /** - * getSeparatorSize - * @returns Dimension + * This method returns the size of the Separator. + * + * @return The size of the Separator. */ - public Dimension getSeparatorSize() { - return null; // TODO + public Dimension getSeparatorSize() + { + return super.getPreferredSize(); } // getSeparatorSize() /** - * setSeparatorSize - * @param size TODO + * This method sets the size of the Separator. + * + * @param size The new size of the Separator. */ - public void setSeparatorSize(Dimension size) { - // TODO + public void setSeparatorSize(Dimension size) + { + setPreferredSize(size); } // setSeparatorSize() - - } // Separator -// /** -// * DefaultJToolBarLayout -// */ -// private class DefaultJToolBarLayout { -// -// private void DefaultJToolBarLayout() { -// } -// -// private LayoutManager getLayout() { -// switch (JToolBar.this.getOrientation()) { -// case HORIZONTAL: setLayout(new GridLayout(1, 0, 4, 4)); -// break; -// case VERTICAL: setLayout(new GridLayout(0, 1, 4, 4)); -// break; -// } -// } -// } // DefaultJToolBarLayout - - + /** DOCUMENT ME! */ private static final long serialVersionUID = -1269915519555129643L; - //------------------------------------------------------------- - // Variables -------------------------------------------------- - //------------------------------------------------------------- + /** Whether the JToolBar paints its border. */ + private transient boolean paintBorder = true; - /** - * uiClassID - */ - private static final String uiClassID = "ToolBarUI"; + /** The extra insets around the JToolBar. */ + private transient Insets margin; - /** - * paintBorder - */ - private boolean paintBorder; - - /** - * margin - */ - private Insets margin; + /** Whether the JToolBar can float (and be dragged around). */ + private transient boolean floatable = true; - /** - * floatable - */ - private boolean floatable; + /** Whether the buttons will have rollover borders. */ + private transient boolean rollover; - /** - * orientation - */ + /** The orientation of the JToolBar. */ private int orientation = HORIZONTAL; -// protected transient DefaultJToolBarLayout toolbarLayout; - - /** Fired in a PropertyChangeEvent when the "orientation" property changes. - */ + /** Fired in a PropertyChangeEvent when the orientation property changes. */ public static final String ORIENTATION_CHANGED_PROPERTY = "orientation"; - //------------------------------------------------------------- - // Initialization --------------------------------------------- - //------------------------------------------------------------- + /** Fired in a PropertyChangeEvent when the floatable property changes. */ + public static final String FLOATABLE_CHANGED_PROPERTY = "floatable"; + + /** Fired in a PropertyChangeEvent when the borderPainted property changes. */ + public static final String BORDER_PAINTED_CHANGED_PROPERTY = "borderPainted"; + + /** Fired in a PropertyChangeEvent when the margin property changes. */ + public static final String MARGIN_CHANGED_PROPERTY = "margin"; + + /** Fired in a PropertyChangeEvent when the rollover property changes. */ + public static final String ROLLOVER_CHANGED_PROPERTY = "rollover"; /** - * Constructor JToolBar + * This method creates a new JToolBar object with horizontal orientation + * and no name. */ - public JToolBar() { - this(null); + public JToolBar() + { + this(null, HORIZONTAL); } // JToolBar() /** - * Constructor 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) { + public JToolBar(int orientation) + { this(null, orientation); } // JToolBar() /** - * Constructor 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) { + public JToolBar(String name) + { this(name, HORIZONTAL); } // JToolBar() /** - * Constructor 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) { + public JToolBar(String name, int orientation) + { setName(name); - if (orientation != HORIZONTAL && orientation != VERTICAL) - throw new IllegalArgumentException(orientation + " is not a legal orientation"); - this.orientation = orientation; -// toolbarLayout = new DefaultJToolBarLayout(); + setOrientation(orientation); + setLayout(new DefaultToolBarLayout()); + revalidate(); updateUI(); } // JToolBar() - - //------------------------------------------------------------- - // Methods ---------------------------------------------------- - //------------------------------------------------------------- - - /** - * writeObject - * @param stream TODO - * @exception IOException TODO - */ - private void writeObject(ObjectOutputStream stream) throws IOException { - // TODO - } // writeObject() - /** - * add - * @param action TODO - * @returns JButton + * 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) { - return null; // TODO + public JButton add(Action action) + { + JButton b = createActionComponent(action); + add(b); + return b; } // add() /** - * paintBorder - * @param graphics TODO + * This method paints the border if the borderPainted property is true. + * + * @param graphics The graphics object to paint with. */ - protected void paintBorder(Graphics graphics) { - // TODO + protected void paintBorder(Graphics graphics) + { + if (paintBorder && isFloatable()) + super.paintBorder(graphics); } // paintBorder() /** - * getUI - * @returns ToolBarUI + * This method returns the UI class used to paint this JToolBar. + * + * @return The UI class for this JToolBar. */ - public ToolBarUI getUI() { - System.out.println("ui = " + ui); + public ToolBarUI getUI() + { return (ToolBarUI) ui; } // getUI() /** - * setUI - * @param ui TODO + * This method sets the UI used with the JToolBar. + * + * @param ui The UI used with the JToolBar. */ - public void setUI(ToolBarUI ui) { + public void setUI(ToolBarUI ui) + { super.setUI(ui); } // setUI() /** - * updateUI + * This method resets the UI used to the Look and Feel defaults. */ - public void updateUI() { + public void updateUI() + { setUI((ToolBarUI)UIManager.getUI(this)); + revalidate(); + repaint(); } // updateUI() /** - * getUIClassID - * @returns String + * 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 uiClassID; + public String getUIClassID() + { + return "ToolBarUI"; } // getUIClassID() /** - * getComponentIndex - * @param component TODO - * @returns int + * 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 int getComponentIndex(Component component) { - return 0; // TODO + public void setRollover(boolean b) + { + if (b != rollover) + { + rollover = b; + firePropertyChange(ROLLOVER_CHANGED_PROPERTY, ! 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() /** - * getComponentAtIndex - * @param index TODO - * @returns Component + * 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 null; // TODO + public Component getComponentAtIndex(int index) + { + return getComponent(index); } // getComponentAtIndex() /** - * getMargin - * @returns Insets + * This method returns the margin property. + * + * @return The margin property. */ - public Insets getMargin() { - return null; // TODO + public Insets getMargin() + { + return margin; } // getMargin() /** - * setMargin - * @param margin TODO + * 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) { - // TODO + 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_CHANGED_PROPERTY, oldMargin, this.margin); + revalidate(); + repaint(); + } } // setMargin() /** - * isBorderPainted - * @returns boolean + * This method returns the borderPainted property. + * + * @return The borderPainted property. */ - public boolean isBorderPainted() { - return false; // TODO + public boolean isBorderPainted() + { + return paintBorder; } // isBorderPainted() /** - * setBorderPainted - * @param painted TODO + * 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) { - // TODO + public void setBorderPainted(boolean painted) + { + if (painted != paintBorder) + { + paintBorder = painted; + firePropertyChange(BORDER_PAINTED_CHANGED_PROPERTY, ! paintBorder, + paintBorder); + repaint(); + } } // setBorderPainted() /** - * isFloatable - * @returns boolean + * This method returns the floatable property. + * + * @return The floatable property. */ - public boolean isFloatable() { - return false; // TODO + public boolean isFloatable() + { + return floatable; } // isFloatable() /** - * setFloatable - * @param floatable TODO + * 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) { - // TODO + public void setFloatable(boolean floatable) + { + if (floatable != this.floatable) + { + this.floatable = floatable; + firePropertyChange(FLOATABLE_CHANGED_PROPERTY, ! floatable, floatable); + } } // setFloatable() /** - * getOrientation - * @returns int + * This method returns the orientation of the JToolBar. + * + * @return The orientation of the JToolBar. */ - public int getOrientation() { - return this.orientation; + public int getOrientation() + { + return orientation; } // getOrientation() /** - * setLayout - * @param mgr + * 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) { + public void setLayout(LayoutManager mgr) + { super.setLayout(mgr); + revalidate(); + repaint(); } // setLayout() /** - * setOrientation - * @param orientation + * 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) { + public void setOrientation(int orientation) + { if (orientation != HORIZONTAL && orientation != VERTICAL) - throw new IllegalArgumentException(orientation + " is not a legal orientation"); + throw new IllegalArgumentException(orientation + + " is not a legal orientation"); if (orientation != this.orientation) { int oldOrientation = this.orientation; this.orientation = orientation; firePropertyChange(ORIENTATION_CHANGED_PROPERTY, oldOrientation, this.orientation); + revalidate(); + repaint(); } } // setOrientation() /** - * addSeparator + * This method adds a Separator of default size to the JToolBar. */ - public void addSeparator() { - // TODO + public void addSeparator() + { + add(new Separator()); } // addSeparator() /** - * addSeparator - * @param size TODO + * This method adds a Separator with the given size to the JToolBar. + * + * @param size The size of the Separator. */ - public void addSeparator(Dimension size) { - // TODO + public void addSeparator(Dimension size) + { + add(new Separator(size)); } // addSeparator() /** - * createActionComponent - * @param action TODO - * @returns JButton + * 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 null; // TODO + protected JButton createActionComponent(Action action) + { + return new JButton(action); } // createActionComponent() /** - * createActionChangeListener - * @param button TODO - * @returns PropertyChangeListener + * 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) { - return null; // TODO + 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() /** - * addImpl - * @param component TODO - * @param constraints TODO - * @param index TODO - */ - /* - protected void addImpl(Component component, Object constraints, int index) { - // TODO - } // addImpl() + * 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); + } // addImpl() + /** - * paramString - * @returns String + * This method returns a String description of the JToolBar. + * + * @return A String description of the JToolBar. */ - protected String paramString() { - return null; // TODO + protected String paramString() + { + return "JToolBar"; } // paramString() /** * getAccessibleContext + * * @return AccessibleContext */ public AccessibleContext getAccessibleContext() |