libjava/classpath/javax/swing/JToolBar.java

   1 /* JToolBar.java --
   2    Copyright (C) 2002, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing;
  40
  41 import java.awt.Component;
  42 import java.awt.Container;
  43 import java.awt.Dimension;
  44 import java.awt.Graphics;
  45 import java.awt.Insets;
  46 import java.awt.LayoutManager;
  47 import java.beans.PropertyChangeListener;
  48
  49 import javax.accessibility.Accessible;
  50 import javax.accessibility.AccessibleContext;
  51 import javax.accessibility.AccessibleRole;
  52 import javax.accessibility.AccessibleStateSet;
  53 import javax.swing.plaf.ToolBarUI;
  54
  55 /**
  56  * JToolBar is a component that provides a toolbar to Swing programs. Users
  57  * can add buttons (or actions that will be represented by JButtons) as well
  58  * as other components to the JToolBar. JToolBars can be dragged in and out
  59  * of their parent components. If the JToolBar is dragged out of the parent,
  60  * then it will be displayed in its own RootPaneContainer. For dragging to
  61  * work properly, JToolBars need to be placed in a Container that has a
  62  * BorderLayout. That parent Container cannot have components in the NORTH,
  63  * EAST, SOUTH,  or WEST components (that is not the JToolBar).
  64  */
  65 public class JToolBar extends JComponent implements SwingConstants, Accessible
  66 {
  67   /**
  68    * Provides the accessibility features for the <code>JToolBar</code>
  69    * component.
  70    */
  71   protected class AccessibleJToolBar extends AccessibleJComponent
  72   {
  73     private static final long serialVersionUID = -5516888265903814215L;
  74
  75     /**
  76      * Creates a new <code>AccessibleJToolBar</code> instance.
  77      */
  78     protected AccessibleJToolBar()
  79     {
  80       // Nothing to do here.
  81     }
  82
  83     /**
  84      * Returns a set containing the current state of the {@link JToolBar}
  85      * component.  The current implementation simply calls the superclass.
  86      *
  87      * @return The accessible state set.
  88      */
  89     public AccessibleStateSet getAccessibleStateSet()
  90     {
  91       // running tests against the reference implementation, I was unable
  92       // to find any state information that is set specifically by the
  93       // tool bar...
  94       return super.getAccessibleStateSet();
  95     }
  96
  97     /**
  98      * Returns the accessible role for the <code>JToolBar</code> component.
  99      *
 100      * @return {@link AccessibleRole#TOOL_BAR}.
 101      */
 102     public AccessibleRole getAccessibleRole()
 103     {
 104       return AccessibleRole.TOOL_BAR;
 105     }
 106   }
 107
 108   /**
 109    * This is the private JToolBar layout manager.
 110    */
 111   private class DefaultToolBarLayout implements LayoutManager
 112   {
 113     /**
 114      * This method is called when a new component is added to the container.
 115      *
 116      * @param name The name of the component added.
 117      * @param comp The component that was added.
 118      */
 119     public void addLayoutComponent(String name, Component comp)
 120     {
 121       // Do nothing.
 122     }
 123
 124     /**
 125      * This method is called to lay out the given container  to position and
 126      * size the child components.
 127      *
 128      * @param c The container to lay out.
 129      *
 130      * @throws Error DOCUMENT ME!
 131      */
 132     public void layoutContainer(Container c)
 133     {
 134       if (! (c instanceof JToolBar))
 135         throw new Error("DefaultToolBarLayout can only be used on JToolBars.");
 136       Insets insets = getInsets();
 137       Insets margin = getMargin();
 138       int middle;
 139       if (margin != null)
 140         {
 141           insets.left += margin.left;
 142           insets.top += margin.top;
 143           insets.bottom += margin.bottom;
 144           insets.right += margin.right;
 145         }
 146       Component[] components = c.getComponents();
 147       Dimension tdims = c.getSize();
 148       int start = 0;
 149       Dimension pref;
 150
 151       if (getOrientation() == SwingUtilities.HORIZONTAL)
 152         {
 153           start += insets.left;
 154           for (int i = 0; i < components.length; i++)
 155             {
 156               if (components[i] != null && components[i].isVisible())
 157                 {
 158                   pref = components[i].getPreferredSize();
 159                   if (pref != null)
 160                     {
 161                       middle = (tdims.height - pref.height) / 2;
 162                       components[i].setBounds(start, middle, pref.width,
 163                                               pref.height);
 164                       start += pref.width;
 165                     }
 166                 }
 167             }
 168         }
 169       else
 170         {
 171           start += insets.top;
 172           for (int i = 0; i < components.length; i++)
 173             {
 174               if (components[i] != null && components[i].isVisible())
 175                 {
 176                   pref = components[i].getPreferredSize();
 177                   if (pref != null)
 178                     {
 179                       middle = (tdims.width - pref.width) / 2;
 180                       components[i].setBounds(middle, start, pref.width,
 181                                               pref.height);
 182                       start += pref.height;
 183                     }
 184                 }
 185             }
 186         }
 187     }
 188
 189     /**
 190      * This method returns the minimum size of the given container given the
 191      * child components.
 192      *
 193      * @param parent The container to measure.
 194      *
 195      * @return The minimum size of the given container.
 196      */
 197     public Dimension minimumLayoutSize(Container parent)
 198     {
 199       return preferredLayoutSize(parent);
 200     }
 201
 202     /**
 203      * This method returns the preferred size of the given container given the
 204      * child components.
 205      *
 206      * @param parent The container to measure.
 207      *
 208      * @return The preferred size of the given container.
 209      */
 210     public Dimension preferredLayoutSize(Container parent)
 211     {
 212       int orientation = getOrientation();
 213       Component[] components = getComponents();
 214
 215       int limit = 0;
 216       int total = 0;
 217       Dimension dims;
 218
 219       int w = 0;
 220       int h = 0;
 221
 222       if (orientation == SwingConstants.HORIZONTAL)
 223         {
 224           for (int i = 0; i < components.length; i++)
 225             {
 226               dims = components[i].getPreferredSize();
 227               if (dims != null)
 228                 {
 229                   if (dims.height > limit)
 230                     limit = dims.height;
 231                   total += dims.width;
 232                 }
 233             }
 234           w = total;
 235           h = limit;
 236         }
 237       else
 238         {
 239           for (int i = 0; i < components.length; i++)
 240             {
 241               dims = components[i].getPreferredSize();
 242               if (dims != null)
 243                 {
 244                   if (dims.width > limit)
 245                     limit = dims.width;
 246                   total += dims.height;
 247                 }
 248             }
 249           w = limit;
 250           h = total;
 251         }
 252
 253       Insets insets = getInsets();
 254       w += insets.left + insets.right;
 255       h += insets.top + insets.bottom;
 256
 257       Insets margin = getMargin();
 258       if (margin != null)
 259         {
 260           w += margin.left + margin.right;
 261           h += margin.top + margin.bottom;
 262         }
 263
 264       return new Dimension(w, h);
 265     }
 266
 267     /**
 268      * This method is called when the given component  is removed from the
 269      * container.
 270      *
 271      * @param comp The component removed.
 272      */
 273     public void removeLayoutComponent(Component comp)
 274     {
 275       // Do nothing.
 276     }
 277   }
 278
 279   /**
 280    * This is an extension of JSeparator used in toolbars. Unlike JSeparator,
 281    * nothing is painted for this Separator, it is only blank space that
 282    * separates components.
 283    */
 284   public static class Separator extends JSeparator
 285   {
 286     /** DOCUMENT ME! */
 287     private static final long serialVersionUID = -1656745644823105219L;
 288
 289     /**
 290      * Creates a new Separator object.
 291      */
 292     public Separator()
 293     {
 294       super();
 295     } // Separator()
 296
 297     /**
 298      * Creates a new Separator object with the given size.
 299      *
 300      * @param size The size of the separator.
 301      */
 302     public Separator(Dimension size)
 303     {
 304       setPreferredSize(size);
 305     } // Separator()
 306
 307     /**
 308      * This method returns the String ID of the UI class of  Separator.
 309      *
 310      * @return The UI class' String ID.
 311      */
 312     public String getUIClassID()
 313     {
 314       return "ToolBarSeparatorUI";
 315     } // getUIClassID()
 316
 317     /**
 318      * This method returns the preferred size of the Separator.
 319      *
 320      * @return The preferred size of the Separator.
 321      */
 322     public Dimension getPreferredSize()
 323     {
 324       return super.getPreferredSize();
 325     } // getPreferredSize()
 326
 327     /**
 328      * This method returns the maximum size of the Separator.
 329      *
 330      * @return The maximum size of the Separator.
 331      */
 332     public Dimension getMaximumSize()
 333     {
 334       return super.getPreferredSize();
 335     } // getMaximumSize()
 336
 337     /**
 338      * This method returns the minimum size of the Separator.
 339      *
 340      * @return The minimum size of the Separator.
 341      */
 342     public Dimension getMinimumSize()
 343     {
 344       return super.getPreferredSize();
 345     } // getMinimumSize()
 346
 347     /**
 348      * This method returns the size of the Separator.
 349      *
 350      * @return The size of the Separator.
 351      */
 352     public Dimension getSeparatorSize()
 353     {
 354       return super.getPreferredSize();
 355     } // getSeparatorSize()
 356
 357     /**
 358      * This method sets the size of the Separator.
 359      *
 360      * @param size The new size of the Separator.
 361      */
 362     public void setSeparatorSize(Dimension size)
 363     {
 364       setPreferredSize(size);
 365     } // setSeparatorSize()
 366   } // Separator
 367
 368   /** DOCUMENT ME! */
 369   private static final long serialVersionUID = -1269915519555129643L;
 370
 371   /** Whether the JToolBar paints its border. */
 372   private transient boolean paintBorder = true;
 373
 374   /** The extra insets around the JToolBar. */
 375   private transient Insets margin;
 376
 377   /** Whether the JToolBar can float (and be dragged around). */
 378   private transient boolean floatable = true;
 379
 380   /** Whether the buttons will have rollover borders. */
 381   private transient boolean rollover;
 382
 383   /** The orientation of the JToolBar. */
 384   private int orientation = HORIZONTAL;
 385
 386   /**
 387    * This method creates a new JToolBar object with horizontal orientation
 388    * and no name.
 389    */
 390   public JToolBar()
 391   {
 392     this(null, HORIZONTAL);
 393   } // JToolBar()
 394
 395   /**
 396    * This method creates a new JToolBar with the given orientation and  no
 397    * name.
 398    *
 399    * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL)
 400    */
 401   public JToolBar(int orientation)
 402   {
 403     this(null, orientation);
 404   } // JToolBar()
 405
 406   /**
 407    * This method creates a new JToolBar object with the given name and
 408    * horizontal orientation.
 409    *
 410    * @param name Name assigned to undocked tool bar.
 411    */
 412   public JToolBar(String name)
 413   {
 414     this(name, HORIZONTAL);
 415   } // JToolBar()
 416
 417   /**
 418    * This method creates a new JToolBar object with the given name and
 419    * orientation.
 420    *
 421    * @param name Name assigned to undocked tool bar.
 422    * @param orientation JToolBar orientation (HORIZONTAL or VERTICAL)
 423    */
 424   public JToolBar(String name, int orientation)
 425   {
 426     setName(name);
 427     setOrientation(orientation);
 428     setLayout(new DefaultToolBarLayout());
 429     revalidate();
 430     setOpaque(true);
 431     updateUI();
 432   }
 433
 434   /**
 435    * This method adds a new JButton that performs the given Action to the
 436    * JToolBar.
 437    *
 438    * @param action The Action to add to the JToolBar.
 439    *
 440    * @return The JButton that wraps the Action.
 441    */
 442   public JButton add(Action action)
 443   {
 444     JButton b = createActionComponent(action);
 445     add(b);
 446     return b;
 447   } // add()
 448
 449   /**
 450    * This method paints the border if the borderPainted property is true.
 451    *
 452    * @param graphics The graphics object to paint with.
 453    */
 454   protected void paintBorder(Graphics graphics)
 455   {
 456     if (paintBorder && isFloatable())
 457       super.paintBorder(graphics);
 458   } // paintBorder()
 459
 460   /**
 461    * This method returns the UI class used to paint this JToolBar.
 462    *
 463    * @return The UI class for this JToolBar.
 464    */
 465   public ToolBarUI getUI()
 466   {
 467     return (ToolBarUI) ui;
 468   } // getUI()
 469
 470   /**
 471    * This method sets the UI used with the JToolBar.
 472    *
 473    * @param ui The UI used with the JToolBar.
 474    */
 475   public void setUI(ToolBarUI ui)
 476   {
 477     super.setUI(ui);
 478   } // setUI()
 479
 480   /**
 481    * This method resets the UI used to the Look and Feel defaults.
 482    */
 483   public void updateUI()
 484   {
 485     setUI((ToolBarUI) UIManager.getUI(this));
 486   }
 487
 488   /**
 489    * This method returns the String identifier for the UI class to the used
 490    * with the JToolBar.
 491    *
 492    * @return The String identifier for the UI class.
 493    */
 494   public String getUIClassID()
 495   {
 496     return "ToolBarUI";
 497   } // getUIClassID()
 498
 499   /**
 500    * This method sets the rollover property for the JToolBar. In rollover
 501    * mode, JButtons inside the JToolBar will only display their borders when
 502    * the mouse is moving over them.
 503    *
 504    * @param b The new rollover property.
 505    */
 506   public void setRollover(boolean b)
 507   {
 508     if (b != rollover)
 509       {
 510         rollover = b;
 511         firePropertyChange("rollover", ! rollover, rollover);
 512         revalidate();
 513         repaint();
 514       }
 515   }
 516
 517   /**
 518    * This method returns the rollover property.
 519    *
 520    * @return The rollover property.
 521    */
 522   public boolean isRollover()
 523   {
 524     return rollover;
 525   }
 526
 527   /**
 528    * This method returns the index of the given component.
 529    *
 530    * @param component The component to find.
 531    *
 532    * @return The index of the given component.
 533    */
 534   public int getComponentIndex(Component component)
 535   {
 536     Component[] components = getComponents();
 537     if (components == null)
 538       return -1;
 539
 540     for (int i = 0; i < components.length; i++)
 541       if (components[i] == component)
 542         return i;
 543
 544     return -1;
 545   } // getComponentIndex()
 546
 547   /**
 548    * This method returns the component at the given index.
 549    *
 550    * @param index The index of the component.
 551    *
 552    * @return The component at the given index.
 553    */
 554   public Component getComponentAtIndex(int index)
 555   {
 556     return getComponent(index);
 557   } // getComponentAtIndex()
 558
 559   /**
 560    * This method returns the margin property.
 561    *
 562    * @return The margin property.
 563    */
 564   public Insets getMargin()
 565   {
 566     return margin;
 567   } // getMargin()
 568
 569   /**
 570    * This method sets the margin property. The margin property determines the
 571    * extra space between the children components of the JToolBar and the
 572    * border.
 573    *
 574    * @param margin The margin property.
 575    */
 576   public void setMargin(Insets margin)
 577   {
 578     if ((this.margin != null && margin == null)
 579         || (this.margin == null && margin != null)
 580         || (margin != null && this.margin != null
 581         && (margin.left != this.margin.left
 582         || margin.right != this.margin.right || margin.top != this.margin.top
 583         || margin.bottom != this.margin.bottom)))
 584       {
 585         Insets oldMargin = this.margin;
 586         this.margin = margin;
 587         firePropertyChange("margin", oldMargin, this.margin);
 588         revalidate();
 589         repaint();
 590       }
 591   } // setMargin()
 592
 593   /**
 594    * This method returns the borderPainted property.
 595    *
 596    * @return The borderPainted property.
 597    */
 598   public boolean isBorderPainted()
 599   {
 600     return paintBorder;
 601   } // isBorderPainted()
 602
 603   /**
 604    * This method sets the borderPainted property. If set to false, the border
 605    * will not be painted.
 606    *
 607    * @param painted Whether the border will be painted.
 608    */
 609   public void setBorderPainted(boolean painted)
 610   {
 611     if (painted != paintBorder)
 612       {
 613         paintBorder = painted;
 614         firePropertyChange("borderPainted", ! paintBorder,
 615                            paintBorder);
 616         repaint();
 617       }
 618   } // setBorderPainted()
 619
 620   /**
 621    * This method returns the floatable property.
 622    *
 623    * @return The floatable property.
 624    */
 625   public boolean isFloatable()
 626   {
 627     return floatable;
 628   } // isFloatable()
 629
 630   /**
 631    * This method sets the floatable property. If set to false, the JToolBar
 632    * cannot be dragged.
 633    *
 634    * @param floatable Whether the JToolBar can be dragged.
 635    */
 636   public void setFloatable(boolean floatable)
 637   {
 638     if (floatable != this.floatable)
 639       {
 640         this.floatable = floatable;
 641         firePropertyChange("floatable", ! floatable, floatable);
 642       }
 643   } // setFloatable()
 644
 645   /**
 646    * This method returns the orientation of the JToolBar.
 647    *
 648    * @return The orientation of the JToolBar.
 649    */
 650   public int getOrientation()
 651   {
 652     return orientation;
 653   } // getOrientation()
 654
 655   /**
 656    * This method sets the layout manager to be used with the JToolBar.
 657    *
 658    * @param mgr The Layout Manager used with the JToolBar.
 659    */
 660   public void setLayout(LayoutManager mgr)
 661   {
 662     super.setLayout(mgr);
 663     revalidate();
 664     repaint();
 665   } // setLayout()
 666
 667   /**
 668    * This method sets the orientation property for JToolBar.
 669    *
 670    * @param orientation The new orientation for JToolBar.
 671    *
 672    * @throws IllegalArgumentException If the orientation is not HORIZONTAL or
 673    *         VERTICAL.
 674    */
 675   public void setOrientation(int orientation)
 676   {
 677     if (orientation != HORIZONTAL && orientation != VERTICAL)
 678       throw new IllegalArgumentException(orientation
 679                                          + " is not a legal orientation");
 680     if (orientation != this.orientation)
 681       {
 682         int oldOrientation = this.orientation;
 683         this.orientation = orientation;
 684         firePropertyChange("orientation", oldOrientation, this.orientation);
 685         revalidate();
 686         repaint();
 687       }
 688   } // setOrientation()
 689
 690   /**
 691    * This method adds a Separator of default size to the JToolBar.
 692    */
 693   public void addSeparator()
 694   {
 695     add(new Separator());
 696   } // addSeparator()
 697
 698   /**
 699    * This method adds a Separator with the given size to the JToolBar.
 700    *
 701    * @param size The size of the Separator.
 702    */
 703   public void addSeparator(Dimension size)
 704   {
 705     add(new Separator(size));
 706   } // addSeparator()
 707
 708   /**
 709    * This method is used to create JButtons which can be added to the JToolBar
 710    * for the given action.
 711    *
 712    * @param action The action to create a JButton for.
 713    *
 714    * @return The JButton created from the action.
 715    */
 716   protected JButton createActionComponent(Action action)
 717   {
 718     return new JButton(action);
 719   } // createActionComponent()
 720
 721   /**
 722    * This method creates a pre-configured PropertyChangeListener which updates
 723    * the control as changes are made to the Action. However, this is no
 724    * longer the recommended way of adding Actions to Containers. As such,
 725    * this method returns null.
 726    *
 727    * @param button The JButton to configure a PropertyChangeListener for.
 728    *
 729    * @return null.
 730    */
 731   protected PropertyChangeListener createActionChangeListener(JButton button)
 732   {
 733     // XXX: As specified, this returns null. But seems kind of strange, usually deprecated methods don't just return null, verify!
 734     return null;
 735   } // createActionChangeListener()
 736
 737   /**
 738    * This method overrides Container's addImpl method. If a JButton is added,
 739    * it is disabled.
 740    *
 741    * @param component The Component to add.
 742    * @param constraints The Constraints placed on the component.
 743    * @param index The index to place the Component at.
 744    */
 745   protected void addImpl(Component component, Object constraints, int index)
 746   {
 747     // XXX: Sun says disable button but test cases show otherwise.
 748     super.addImpl(component, constraints, index);
 749
 750     // if we added a Swing Button then adjust this a little
 751     if (component instanceof AbstractButton)
 752       {
 753         AbstractButton b = (AbstractButton) component;
 754         b.setRolloverEnabled(rollover);
 755       }
 756
 757   } // addImpl()
 758
 759   /**
 760    * This method returns a String description of the JToolBar.
 761    *
 762    * @return A String description of the JToolBar.
 763    */
 764   protected String paramString()
 765   {
 766     return "JToolBar";
 767   } // paramString()
 768
 769   /**
 770    * Returns the object that provides accessibility features for this
 771    * <code>JToolBar</code> component.
 772    *
 773    * @return The accessible context (an instance of {@link AccessibleJToolBar}).
 774    */
 775   public AccessibleContext getAccessibleContext()
 776   {
 777     if (accessibleContext == null)
 778       accessibleContext = new AccessibleJToolBar();
 779
 780     return accessibleContext;
 781   }
 782 }