1. /*
  2. * @(#)MetalToolBarUI.java 1.19 00/02/02
  3. *
  4. * Copyright 1998-2000 Sun Microsystems, Inc. All Rights Reserved.
  5. *
  6. * This software is the proprietary information of Sun Microsystems, Inc.
  7. * Use is subject to license terms.
  8. *
  9. */
  10. package javax.swing.plaf.metal;
  11. import javax.swing.*;
  12. import java.awt.Color;
  13. import java.awt.Component;
  14. import java.awt.Container;
  15. import java.awt.Dimension;
  16. import java.awt.Frame;
  17. import java.awt.Graphics;
  18. import java.awt.Insets;
  19. import java.awt.Point;
  20. import java.awt.Rectangle;
  21. import java.awt.event.*;
  22. import java.util.*;
  23. import java.beans.PropertyChangeListener;
  24. import java.beans.PropertyChangeEvent;
  25. import java.beans.PropertyVetoException;
  26. import javax.swing.event.*;
  27. import javax.swing.border.*;
  28. import javax.swing.plaf.*;
  29. import javax.swing.plaf.basic.*;
  30. /**
  31. * A Metal Look and Feel implementation of ToolBarUI. This implementation
  32. * is a "combined" view/controller.
  33. * <p>
  34. *
  35. * @version 1.19 02/02/00
  36. * @author Jeff Shapiro
  37. */
  38. public class MetalToolBarUI extends BasicToolBarUI
  39. {
  40. private static Border rolloverBorder = new CompoundBorder(
  41. new MetalBorders.RolloverButtonBorder(), new BasicBorders.MarginBorder() );
  42. private static Border nonRolloverBorder = new CompoundBorder(
  43. new MetalBorders.ButtonBorder(), new BasicBorders.MarginBorder() );
  44. protected ContainerListener contListener;
  45. protected PropertyChangeListener rolloverListener;
  46. private Hashtable borderTable = new Hashtable();
  47. private Hashtable marginTable = new Hashtable();
  48. private boolean rolloverBorders = false;
  49. private static String IS_ROLLOVER = "JToolBar.isRollover";
  50. private final static Insets insets0 = new Insets( 0, 0, 0, 0 );
  51. public static ComponentUI createUI( JComponent c )
  52. {
  53. return new MetalToolBarUI();
  54. }
  55. public void installUI( JComponent c )
  56. {
  57. super.installUI( c );
  58. Object rolloverProp = c.getClientProperty( IS_ROLLOVER );
  59. if ( rolloverProp != null )
  60. {
  61. rolloverBorders = ((Boolean)rolloverProp).booleanValue();
  62. }
  63. else
  64. {
  65. rolloverBorders = false;
  66. }
  67. SwingUtilities.invokeLater( new Runnable()
  68. {
  69. public void run()
  70. {
  71. setRolloverBorders( isRolloverBorders() );
  72. }
  73. });
  74. }
  75. public void uninstallUI( JComponent c )
  76. {
  77. super.uninstallUI( c );
  78. installNormalBorders( c );
  79. }
  80. protected void installListeners( )
  81. {
  82. super.installListeners( );
  83. contListener = createContainerListener( );
  84. if ( contListener != null ) toolBar.addContainerListener( contListener );
  85. rolloverListener = createRolloverListener( );
  86. if ( rolloverListener != null ) toolBar.addPropertyChangeListener( rolloverListener );
  87. }
  88. protected void uninstallListeners( )
  89. {
  90. super.uninstallListeners( );
  91. if ( contListener != null ) toolBar.removeContainerListener( contListener );
  92. contListener = null;
  93. if ( rolloverListener != null ) toolBar.removePropertyChangeListener( rolloverListener );
  94. rolloverListener = null;
  95. }
  96. protected ContainerListener createContainerListener( )
  97. {
  98. return new MetalContainerListener( );
  99. }
  100. protected PropertyChangeListener createRolloverListener( )
  101. {
  102. return new MetalRolloverListener( );
  103. }
  104. protected MouseInputListener createDockingListener( )
  105. {
  106. return new MetalDockingListener( toolBar );
  107. }
  108. protected void setDragOffset( Point p )
  109. {
  110. if (dragWindow == null)
  111. dragWindow = createDragWindow(toolBar);
  112. dragWindow.setOffset( p );
  113. }
  114. public boolean isRolloverBorders()
  115. {
  116. return rolloverBorders;
  117. }
  118. public void setRolloverBorders( boolean rollover )
  119. {
  120. rolloverBorders = rollover;
  121. if ( rolloverBorders )
  122. {
  123. installRolloverBorders( toolBar );
  124. }
  125. else
  126. {
  127. installNonRolloverBorders( toolBar );
  128. }
  129. }
  130. protected void installRolloverBorders ( JComponent c )
  131. {
  132. // Put rollover borders on buttons
  133. Component[] components = c.getComponents();
  134. for ( int i = 0; i < components.length; ++i )
  135. {
  136. if ( components[ i ] instanceof JComponent )
  137. {
  138. ( (JComponent)components[ i ] ).updateUI();
  139. setBorderToRollover( components[ i ] );
  140. }
  141. }
  142. }
  143. protected void installNonRolloverBorders ( JComponent c )
  144. {
  145. // Put nonrollover borders on buttons
  146. Component[] components = c.getComponents();
  147. for ( int i = 0; i < components.length; ++i )
  148. {
  149. if ( components[ i ] instanceof JComponent )
  150. {
  151. ( (JComponent)components[ i ] ).updateUI();
  152. setBorderToNonRollover( components[ i ] );
  153. }
  154. }
  155. }
  156. protected void installNormalBorders ( JComponent c )
  157. {
  158. // Put back the normal borders on buttons
  159. Component[] components = c.getComponents();
  160. for ( int i = 0; i < components.length; ++i )
  161. {
  162. setBorderToNormal( components[ i ] );
  163. }
  164. }
  165. protected void setBorderToRollover( Component c )
  166. {
  167. if ( c instanceof JButton )
  168. {
  169. JButton b = (JButton)c;
  170. if ( b.getUI() instanceof MetalButtonUI )
  171. {
  172. if ( b.getBorder() instanceof UIResource )
  173. {
  174. borderTable.put( b, b.getBorder() );
  175. }
  176. if ( b.getBorder() instanceof UIResource || b.getBorder() == nonRolloverBorder )
  177. {
  178. b.setBorder( rolloverBorder );
  179. }
  180. if ( b.getMargin() == null || b.getMargin() instanceof UIResource )
  181. {
  182. marginTable.put( b, b.getMargin() );
  183. b.setMargin( insets0 );
  184. }
  185. b.setRolloverEnabled( true );
  186. }
  187. }
  188. }
  189. protected void setBorderToNonRollover( Component c )
  190. {
  191. if ( c instanceof JButton )
  192. {
  193. JButton b = (JButton)c;
  194. if ( b.getUI() instanceof MetalButtonUI )
  195. {
  196. if ( b.getBorder() instanceof UIResource )
  197. {
  198. borderTable.put( b, b.getBorder() );
  199. }
  200. if ( b.getBorder() instanceof UIResource || b.getBorder() == rolloverBorder )
  201. {
  202. b.setBorder( nonRolloverBorder );
  203. }
  204. if ( b.getMargin() == null || b.getMargin() instanceof UIResource )
  205. {
  206. marginTable.put( b, b.getMargin() );
  207. b.setMargin( insets0 );
  208. }
  209. b.setRolloverEnabled( false );
  210. }
  211. }
  212. }
  213. protected void setBorderToNormal( Component c )
  214. {
  215. if ( c instanceof JButton )
  216. {
  217. JButton b = (JButton)c;
  218. if ( b.getUI() instanceof MetalButtonUI )
  219. {
  220. if ( b.getBorder() == rolloverBorder || b.getBorder() == nonRolloverBorder )
  221. {
  222. b.setBorder( (Border)borderTable.remove( b ) );
  223. }
  224. if ( b.getMargin() == insets0 )
  225. {
  226. b.setMargin( (Insets)marginTable.remove( b ) );
  227. }
  228. b.setRolloverEnabled( false );
  229. }
  230. }
  231. }
  232. protected class MetalContainerListener implements ContainerListener
  233. {
  234. public void componentAdded( ContainerEvent e )
  235. {
  236. Component c = e.getChild();
  237. if ( rolloverBorders )
  238. {
  239. setBorderToRollover( c );
  240. }
  241. else
  242. {
  243. setBorderToNonRollover( c );
  244. }
  245. }
  246. public void componentRemoved( ContainerEvent e )
  247. {
  248. Component c = e.getChild();
  249. setBorderToNormal( c );
  250. }
  251. } // end class MetalContainerListener
  252. protected class MetalRolloverListener implements PropertyChangeListener
  253. {
  254. public void propertyChange( PropertyChangeEvent e )
  255. {
  256. String name = e.getPropertyName();
  257. if ( name.equals( IS_ROLLOVER ) )
  258. {
  259. if ( e.getNewValue() != null )
  260. {
  261. setRolloverBorders( ((Boolean)e.getNewValue()).booleanValue() );
  262. }
  263. else
  264. {
  265. setRolloverBorders( false );
  266. }
  267. }
  268. }
  269. } // end class MetalRolloverListener
  270. protected class MetalDockingListener extends DockingListener
  271. {
  272. private boolean pressedInBumps = false;
  273. public MetalDockingListener( JToolBar t )
  274. {
  275. super( t );
  276. }
  277. public void mousePressed( MouseEvent e )
  278. {
  279. super.mousePressed( e );
  280. if (!toolBar.isEnabled()) {
  281. return;
  282. }
  283. pressedInBumps = false;
  284. Rectangle bumpRect = new Rectangle();
  285. if ( toolBar.getSize().height <= toolBar.getSize().width ) // horizontal
  286. {
  287. if( MetalUtils.isLeftToRight(toolBar) ) {
  288. bumpRect.setBounds( 0, 0, 14, toolBar.getSize().height );
  289. } else {
  290. bumpRect.setBounds( toolBar.getSize().width-14, 0,
  291. 14, toolBar.getSize().height );
  292. }
  293. }
  294. else // vertical
  295. {
  296. bumpRect.setBounds( 0, 0, toolBar.getSize().width, 14 );
  297. }
  298. if ( bumpRect.contains( e.getPoint() ) )
  299. {
  300. pressedInBumps = true;
  301. Point dragOffset = e.getPoint();
  302. if( !MetalUtils.isLeftToRight(toolBar) ) {
  303. dragOffset.x -= toolBar.getSize().width
  304. - toolBar.getPreferredSize().width;
  305. }
  306. setDragOffset( dragOffset );
  307. }
  308. }
  309. public void mouseDragged( MouseEvent e )
  310. {
  311. if ( pressedInBumps )
  312. {
  313. super.mouseDragged( e );
  314. }
  315. }
  316. } // end class MetalDockingListener
  317. }