home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / JToolBar.java < prev    next >
Text File  |  1998-02-26  |  13KB  |  414 lines
  1. /*
  2.  * @(#)JToolBar.java    1.40 98/02/04
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20.  
  21. package com.sun.java.swing;
  22.  
  23. import java.awt.Color;
  24. import java.awt.Component;
  25. import java.awt.Dimension;
  26. import java.awt.Graphics;
  27. import java.awt.Insets;
  28. import java.awt.event.*;
  29. import java.beans.*;
  30. import java.io.Serializable;
  31.  
  32. import com.sun.java.swing.border.Border;
  33. import com.sun.java.swing.plaf.*;
  34. import com.sun.java.accessibility.*;
  35.  
  36. /**
  37.  * JToolBar provides a component which is useful for displaying commonly
  38.  * used Actions or controls.  It can be dragged out into a seperate window
  39.  * by the user (unless the floatable property is set to false).  In order
  40.  * for drag-out to work correctly, it is recommended that you add JToolBar
  41.  * instances to one of the four 'sides' of a container whose layout manager 
  42.  * is a BorderLayout, and do not add children to any of the other four 'sides'.
  43.  *
  44.  * <p>
  45.  * Warning: serialized objects of this class will not be compatible with
  46.  * future swing releases.  The current serialization support is appropriate
  47.  * for short term storage or RMI between Swing1.0 applications.  It will
  48.  * not be possible to load serialized Swing1.0 objects with future releases
  49.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  50.  * baseline for the serialized form of Swing objects.
  51.  *
  52.  * @version 1.40 02/04/98
  53.  * @author Georges Saab
  54.  * @see Action
  55.  */
  56. public class JToolBar extends JComponent implements Accessible {
  57.     private    boolean   paintBorder              = true;  
  58.     private    Insets    margin                   = null;
  59.     private    boolean   floatable                = true;
  60.  
  61.  
  62.     /**
  63.      * Create a new toolbar.
  64.      */
  65.     public JToolBar() {
  66.         // Create the Popup
  67.         this.setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
  68.         updateUI();
  69.     }
  70.  
  71.     /**
  72.      * Returns the toolbar's current UI.
  73.      * @see setUI
  74.      */
  75.     public ToolBarUI getUI() {
  76.         return (ToolBarUI)ui;
  77.     }
  78.     
  79.     /**
  80.      * Sets the L&F object that renders this component.
  81.      *
  82.      * @param ui  the ToolBarUI L&F object
  83.      * @see UIDefaults#getUI
  84.      * @beaninfo
  85.      * description: The menu item's UI delegate
  86.      *       bound: true
  87.      *      expert: true
  88.      *      hidden: true
  89.      */
  90.     public void setUI(ToolBarUI ui) {
  91.         super.setUI(ui);
  92.     }
  93.     
  94.     /**
  95.      * Notification from the UIFactory that the L&F has changed. 
  96.      * Called to replace the UI with the latest version from the 
  97.      * UIFactory.
  98.      *
  99.      * @see JComponent#updateUI
  100.      */
  101.     public void updateUI() {
  102.         setUI((ToolBarUI)UIManager.getUI(this));
  103.         invalidate();
  104.     }
  105.  
  106.  
  107.  
  108.     /**
  109.      * Returns the name of the L&F class that renders this component.
  110.      *
  111.      * @return "ToolBarUI"
  112.      * @see JComponent#getUIClassID
  113.      * @see UIDefaults#getUI
  114.      */
  115.     public String getUIClassID() {
  116.         return "ToolBarUI";
  117.     }
  118.  
  119.  
  120.     /*
  121.      * Returns the index of the specified component.
  122.      * (Note: Separators occupy index positions.)
  123.      *
  124.      * @param c  the Component to find
  125.      * @return an int indicating the component's position, where 0=first
  126.      */
  127.     public int getComponentIndex(Component c) {
  128.         int ncomponents = this.getComponentCount();
  129.         Component[] component = this.getComponents();
  130.         for (int i = 0 ; i < ncomponents ; i++) {
  131.             Component comp = component[i];
  132.             if (comp == c) 
  133.                 return i;
  134.         }
  135.         return -1;
  136.     }
  137.  
  138.     /*
  139.      * Returns the component at the specified index.
  140.      *
  141.      * @param i  the component's position, where 0=first
  142.      * @return   the Component at that position, or null for an
  143.      *           invalid index or if there is a separator at that
  144.      *           position
  145.      */
  146.     public Component getComponentAtIndex(int i) {
  147.         int ncomponents = this.getComponentCount();
  148.         if (i <= ncomponents) {
  149.             Component[] component = this.getComponents();
  150.             return component[i];
  151.         }
  152.         return null;
  153.     }
  154.  
  155.      /**
  156.       * Sets the margin between the toolbar's border and
  157.       * its buttons. Setting to null causes the toolbar to
  158.       * use the default margins. The toolbar's default Border
  159.       * object uses this value to create the proper margin.
  160.       * However, if a non-default border is set on the toolbar, 
  161.       * it is that Border object's responsibility to create the
  162.       * appropriate margin space (otherwise this property will 
  163.       * effectively be ignored).
  164.       *
  165.       * @param m an Insets object that defines the space between the 
  166.       *          border and the buttons
  167.       * @see Insets
  168.       * @beaninfo
  169.       * description: The margin between the toolbar's border and contents
  170.       *       bound: true
  171.       *      expert: true
  172.       */
  173.      public void setMargin(Insets m) {
  174.          Insets old = margin;
  175.          margin = m;
  176.          firePropertyChange("margin", old, m);
  177.          invalidate();
  178.      }
  179.  
  180.      /**
  181.       * Returns the margin between the toolbar's border and
  182.       * its buttons.
  183.       *
  184.       * @return an Insets object containing the margin values
  185.       * @see Insets
  186.       */
  187.      public Insets getMargin() {
  188.          if(margin == null) {
  189.              return new Insets(0,0,0,0);
  190.          } else {
  191.              return margin;
  192.          }
  193.      }
  194.  
  195.      /**
  196.       * Checks whether the border should be painted.
  197.       *
  198.       * @return true if the border should be painted, else false
  199.       * @see setBorderPainted
  200.       */
  201.      public boolean isBorderPainted() {
  202.          return paintBorder;
  203.      }
  204.      
  205.  
  206.      /**
  207.       * Sets whether the border should be painted.
  208.       *
  209.       * @param b if true, the border is painted.
  210.       * @see isBorderPainted
  211.       * @beaninfo
  212.       * description: Does the toolbar paint its borders?
  213.       *      expert: true
  214.       */
  215.      public void setBorderPainted(boolean b) {
  216.          paintBorder = b;
  217.          invalidate();
  218.      }
  219.  
  220.      /**
  221.       * Paint the toolbar's border if BorderPainted property is true.
  222.       * 
  223.       * @param g  the Graphics context in which the painting is done
  224.       * @see JComponent#paint
  225.       * @see JComponent#setBorder
  226.       */
  227.      protected void paintBorder(Graphics g) {    
  228.          if (isBorderPainted()) {
  229.              super.paintBorder(g);
  230.          }
  231.      }
  232.  
  233.     /** 
  234.      * Return true if the Toolbar can be dragged out by the user.
  235.      *
  236.      * @return true if the Toolbar can be dragged out by the user
  237.      */
  238.     public boolean isFloatable() {
  239.     return floatable;
  240.     }
  241.  
  242.      /**
  243.       * Sets whether the toolbar can be made to float
  244.       *
  245.       * @param b if true, the toolbar can be dragged out
  246.       * @see isFloatable
  247.       * @beaninfo
  248.       * description: Can the toolbar be made to float by the user?
  249.       *       bound: true
  250.       *   preferred: true
  251.       */
  252.     public void setFloatable(boolean b) {
  253.     if (floatable != b) {
  254.         this.floatable = b;
  255.         firePropertyChange("floatable", !floatable, floatable);        
  256.     }
  257.     }
  258.  
  259.     /**
  260.      * Appends a toolbar-specific separator to the end of the toolbar
  261.      * (not a JSeparator).
  262.      */
  263.     public void addSeparator() {
  264.         JToolBar.Separator s = new JToolBar.Separator();
  265.         add(s);
  266.     }
  267.  
  268.     /**
  269.      * Add a new JButton which dispatches the action.
  270.      *
  271.      * @param a the Action object to add as a new menu item
  272.      */
  273.     public JButton add(Action a) {
  274.         JButton b = new JButton((String)a.getValue(Action.NAME),
  275.                 (Icon)a.getValue(Action.SMALL_ICON));
  276.     b.setHorizontalTextPosition(JButton.CENTER);
  277.     b.setVerticalTextPosition(JButton.BOTTOM);
  278.     b.setEnabled(a.isEnabled());
  279.         b.addActionListener(a);
  280.         add(b);
  281.     PropertyChangeListener actionPropertyChangeListener = 
  282.         createActionChangeListener(b);
  283.         a.addPropertyChangeListener(actionPropertyChangeListener);
  284.         return b;
  285.     }
  286.  
  287.     protected PropertyChangeListener createActionChangeListener(JButton b) {
  288.     return new ActionChangedListener(b);
  289.     }
  290.  
  291.     private class ActionChangedListener implements PropertyChangeListener {
  292.         JButton button;
  293.         
  294.         ActionChangedListener(JButton b) {
  295.             super();
  296.             this.button = b;
  297.         }
  298.         public void propertyChange(PropertyChangeEvent e) {
  299.             String propertyName = e.getPropertyName();
  300.             if (e.getPropertyName().equals(Action.NAME)) {
  301.                 String text = (String) e.getNewValue();
  302.                 button.setText(text);
  303.                 button.repaint();
  304.             } else if (propertyName.equals("enabled")) {
  305.                 Boolean enabledState = (Boolean) e.getNewValue();
  306.                 button.setEnabled(enabledState.booleanValue());
  307.                 button.repaint();
  308.             } else if (e.getPropertyName().equals(Action.SMALL_ICON)) {
  309.                 Icon icon = (Icon) e.getNewValue();
  310.                 button.setIcon(icon);
  311.                 button.invalidate();
  312.                 button.repaint();
  313.             } 
  314.         }
  315.     }
  316.  
  317.     /**
  318.      * A toolbar-specific separator. An object with dimension but
  319.      * no contents used to divide buttons on a toolbar into groups.
  320.      * <p>
  321.      * Warning: serialized objects of this class will not be compatible with
  322.      * future swing releases.  The current serialization support is appropriate
  323.      * for short term storage or RMI between Swing1.0 applications.  It will
  324.      * not be possible to load serialized Swing1.0 objects with future releases
  325.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  326.      * baseline for the serialized form of Swing objects.
  327.      */
  328.     public class Separator extends Component {
  329.         /** Create the separator */
  330.         public Separator() {
  331.         }
  332.  
  333.         /** 
  334.          * Return the minimum size for the separator
  335.          *
  336.          * @return the Dimension object containing the separator's
  337.          *         minimum size
  338.          */
  339.         public Dimension getMinimumSize() {
  340.             return new Dimension(10,5);
  341.         }
  342.         /** 
  343.          * Return the maximum size for the separator
  344.          *
  345.          * @return the Dimension object containing the separator's
  346.          *         maximum size
  347.          */
  348.         public Dimension getMaximumSize() {
  349.             return new Dimension(10,5);
  350.         }
  351.         /** 
  352.          * Return the preferred size for the separator
  353.          *
  354.          * @return the Dimension object containing the separator's
  355.          *         preferred size
  356.          */
  357.         public Dimension getPreferredSize() {
  358.             return new Dimension(10,5);
  359.         }
  360.     }
  361.  
  362. /////////////////
  363. // Accessibility support
  364. ////////////////
  365.  
  366.     /**
  367.      * Get the AccessibleContext associated with this JComponent
  368.      *
  369.      * @return the AccessibleContext of this JComponent
  370.      */
  371.     public AccessibleContext getAccessibleContext() {
  372.         if (accessibleContext == null) {
  373.             accessibleContext = new AccessibleJToolBar();
  374.         }
  375.         return accessibleContext;
  376.     }
  377.  
  378.     /**
  379.      * The class used to obtain the accessible role for this object.
  380.      * <p>
  381.      * Warning: serialized objects of this class will not be compatible with
  382.      * future swing releases.  The current serialization support is appropriate
  383.      * for short term storage or RMI between Swing1.0 applications.  It will
  384.      * not be possible to load serialized Swing1.0 objects with future releases
  385.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  386.      * baseline for the serialized form of Swing objects.
  387.      */
  388.     protected class AccessibleJToolBar extends AccessibleJComponent {
  389.  
  390.         /**
  391.          * Get the state of this object.
  392.          *
  393.          * @return an instance of AccessibleStateSet containing the current 
  394.          * state set of the object
  395.          * @see AccessibleState
  396.          */
  397.         public AccessibleStateSet getAccessibleStateSet() {
  398.             AccessibleStateSet states = SwingUtilities.getAccessibleStateSet(JToolBar.this);
  399.             // FIXME:  [[[WDW - need to add orientation from BoxLayout]]]
  400.             // FIXME:  [[[WDW - need to do SELECTABLE if SelectionModel is added]]]
  401.             return states;
  402.         }
  403.     
  404.         /**
  405.          * Get the role of this object.
  406.          *
  407.          * @return an instance of AccessibleRole describing the role of the object
  408.          */
  409.         public AccessibleRole getAccessibleRole() {
  410.             return AccessibleRole.TOOL_BAR;
  411.         }
  412.     } // inner class AccessibleJToolBar
  413. }
  414.