home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / MetalToolBarUI.java < prev    next >
Text File  |  1998-02-26  |  8KB  |  318 lines
  1. /*
  2.  * @(#)MetalToolBarUI.java    1.4 98/02/06
  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.plaf.metal;
  22.  
  23. import com.sun.java.swing.*;
  24. import java.awt.Color;
  25. import java.awt.Component;
  26. import java.awt.Container;
  27. import java.awt.Dimension;
  28. import java.awt.Frame;
  29. import java.awt.Graphics;
  30. import java.awt.Insets;
  31. import java.awt.Point;
  32. import java.awt.Rectangle;
  33. import java.awt.event.*;
  34. import java.util.*;
  35.  
  36. import java.io.Serializable;
  37.  
  38. import java.beans.PropertyChangeListener;
  39. import java.beans.PropertyChangeEvent;
  40. import java.beans.PropertyVetoException;
  41.  
  42. import com.sun.java.swing.border.*;
  43. import com.sun.java.swing.plaf.*;
  44. import com.sun.java.swing.plaf.basic.*;
  45.  
  46. /**
  47.  * A Metal Look and Feel implementation of ToolBarUI.  This implementation 
  48.  * is a "combined" view/controller.
  49.  * <p>
  50.  * Warning: serialized objects of this class will not be compatible with
  51.  * future swing releases.  The current serialization support is appropriate
  52.  * for short term storage or RMI between Swing1.0 applications.  It will
  53.  * not be possible to load serialized Swing1.0 objects with future releases
  54.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  55.  * baseline for the serialized form of Swing objects.
  56.  *
  57.  * @version 1.4 02/06/98
  58.  * @author Jeff Shapiro
  59.  */
  60. public class MetalToolBarUI extends BasicToolBarUI implements ContainerListener
  61. {
  62.     protected static Border rolloverBorder =
  63.                                 new CompoundBorder( new MetalRolloverButtonBorder(),
  64.                             new ToolBarButtonMargin() );
  65.  
  66. /* PENDING(jshapiro) - this is the border to use when button border and
  67.                        focus drawing is fixed.
  68.  
  69.     protected static Border nonRolloverBorder =
  70.                 new CompoundBorder( new ToolBarButtonMargin(),
  71.                             new MetalButtonBorder() );
  72. */
  73.     protected static Border nonRolloverBorder = new MetalButtonBorder();
  74.  
  75.     protected Hashtable borderTable = new Hashtable();
  76.  
  77.     protected ContainerListener contListener;
  78.  
  79.     private boolean rolloverBorders = false;
  80.  
  81.     private PropertyChangeListener rolloverListener;
  82.  
  83.     protected static String IS_ROLLOVER = "JToolBar.isRollover";
  84.  
  85.     public static ComponentUI createUI( JComponent c )
  86.     {
  87.     return new MetalToolBarUI();
  88.     }
  89.  
  90.     public void installUI( JComponent c )
  91.     {
  92.         rolloverListener = new RolloverListener();
  93.     c.addPropertyChangeListener( rolloverListener );
  94.  
  95.         super.installUI( c );
  96.  
  97.     Object rolloverProp = c.getClientProperty( IS_ROLLOVER );
  98.  
  99.     if ( rolloverProp != null )
  100.     {
  101.         setRolloverBorders( ((Boolean)rolloverProp).booleanValue() );
  102.     }
  103.     else
  104.     {
  105.         setRolloverBorders( false );
  106.     }
  107.     }
  108.  
  109.     public void uninstallUI( JComponent c )
  110.     {
  111.         c.removePropertyChangeListener( rolloverListener );
  112.  
  113.         super.uninstallUI( c );
  114.  
  115.     installNormalBorders( c );
  116.    }
  117.  
  118.     protected void installListeners( JComponent c )
  119.     {
  120.         super.installListeners( c );
  121.  
  122.         if ( (contListener = createContainerListener(c)) != null )
  123.     {
  124.             c.addContainerListener( contListener );
  125.         }
  126.     }
  127.  
  128.     protected void uninstallListeners( JComponent c )
  129.     {
  130.         super.uninstallListeners( c );
  131.  
  132.         if ( contListener != null )
  133.     {
  134.             c.removeContainerListener( contListener );
  135.             contListener = null;
  136.         }
  137.     }
  138.  
  139.     protected ContainerListener createContainerListener( JComponent c )
  140.     {
  141.         return this;
  142.     }
  143.  
  144.     public boolean isRolloverBorders()
  145.     {
  146.         return rolloverBorders;
  147.     }
  148.  
  149.     public void setRolloverBorders( boolean rollover )
  150.     {
  151.         rolloverBorders = rollover;
  152.         
  153.     if ( rolloverBorders )
  154.     {
  155.         installRolloverBorders( toolBar );
  156.     }
  157.     else
  158.     {
  159.         installNonRolloverBorders( toolBar );
  160.     }
  161.     }
  162.  
  163.     protected void installRolloverBorders ( JComponent c )
  164.     {
  165.     // Put rollover borders on buttons
  166.     Component[] components = c.getComponents();
  167.  
  168.     for ( int i = 0; i < components.length; ++i )
  169.     {
  170.       if ( components[ i ] instanceof JComponent )
  171.       {
  172.           ( (JComponent)components[ i ] ).updateUI();
  173.  
  174.           setBorderToRollover( components[ i ] );
  175.       }
  176.     }
  177.     }
  178.  
  179.     protected void installNonRolloverBorders ( JComponent c )
  180.     {
  181.     // Put nonrollover borders on buttons
  182.     Component[] components = c.getComponents();
  183.  
  184.     for ( int i = 0; i < components.length; ++i )
  185.     {
  186.       if ( components[ i ] instanceof JComponent )
  187.       {
  188.           ( (JComponent)components[ i ] ).updateUI();
  189.  
  190.           setBorderToNonRollover( components[ i ] );
  191.       }
  192.     }
  193.     }
  194.  
  195.     protected void installNormalBorders ( JComponent c )
  196.     {
  197.     // Put back the normal borders on buttons
  198.     Component[] components = c.getComponents();
  199.  
  200.     for ( int i = 0; i < components.length; ++i )
  201.     {
  202.         setBorderToNormal( components[ i ] );
  203.     }
  204.     }
  205.  
  206.     protected void setBorderToRollover( Component c )
  207.     {
  208.         if ( c instanceof JButton )
  209.     {
  210.         JButton b = (JButton)c;
  211.  
  212.         if ( b.getUI() instanceof MetalButtonUI )
  213.         {
  214.             if ( b.getBorder() instanceof UIResource )
  215.         {
  216.             borderTable.put( b, b.getBorder() );
  217.         }
  218.  
  219.         if ( b.getBorder() instanceof UIResource || b.getBorder() == nonRolloverBorder )
  220.         {
  221.             b.setBorder( rolloverBorder );
  222.         }
  223.         }
  224.     }
  225.     }
  226.  
  227.     protected void setBorderToNonRollover( Component c )
  228.     {
  229.         if ( c instanceof JButton )
  230.     {
  231.         JButton b = (JButton)c;
  232.  
  233.         if ( b.getUI() instanceof MetalButtonUI )
  234.         {
  235.             if ( b.getBorder() instanceof UIResource )
  236.         {
  237.             borderTable.put( b, b.getBorder() );
  238.         }
  239.  
  240.         if ( b.getBorder() instanceof UIResource || b.getBorder() == rolloverBorder )
  241.         {
  242.             b.setBorder( nonRolloverBorder );
  243.         }
  244.         }
  245.     }
  246.     }
  247.  
  248.     protected void setBorderToNormal( Component c )
  249.     {
  250.         if ( c instanceof JButton )
  251.     {
  252.         JButton b = (JButton)c;
  253.  
  254.         if ( b.getUI() instanceof MetalButtonUI )
  255.         {
  256.             if ( b.getBorder() == rolloverBorder || b.getBorder() == nonRolloverBorder )
  257.         {
  258.             b.setBorder( (Border)borderTable.remove( b ) );
  259.         }
  260.         }
  261.     }
  262.     }
  263.  
  264.     // ContainerListener overrides
  265.  
  266.     public void componentAdded( ContainerEvent e )
  267.     {
  268.         Component c = e.getChild();
  269.  
  270.         if ( rolloverBorders )
  271.     {
  272.         setBorderToRollover( c );
  273.     }
  274.     else
  275.     {
  276.         setBorderToNonRollover( c );
  277.     }
  278.     }
  279.  
  280.     public void componentRemoved( ContainerEvent e )
  281.     {
  282.         Component c = e.getChild();
  283.     setBorderToNormal( c );
  284.     }
  285.  
  286.   class RolloverListener implements PropertyChangeListener, Serializable
  287.   {
  288.     public void propertyChange( PropertyChangeEvent e )
  289.     {
  290.     String name = e.getPropertyName();
  291.  
  292.     if ( name.equals( IS_ROLLOVER ) )
  293.     {
  294.         if ( e.getNewValue() != null )
  295.         {
  296.             setRolloverBorders( ((Boolean)e.getNewValue()).booleanValue() );
  297.         }
  298.         else
  299.         {
  300.         setRolloverBorders( false );
  301.         }
  302.         }
  303.     }
  304.   } // end class RolloverListener
  305.  
  306. }
  307.  
  308.  
  309. class ToolBarButtonMargin extends AbstractBorder
  310. {
  311.     public Insets getBorderInsets( Component c )
  312.     {
  313.         return new Insets( 2, 2, 2, 2 );
  314.     }
  315. }
  316.  
  317.  
  318.