1. /*

  2.  * @(#)SynthToolBarUI.java	1.8 03/01/23

  3.  *

  4.  * Copyright 2003 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package com.sun.java.swing.plaf.gtk;

  9. 

  10. import javax.swing.*;

  11. import javax.swing.event.*;

  12. import java.awt.*;

  13. import java.awt.event.*;

  14. 

  15. import java.beans.*;

  16. 

  17. import javax.swing.border.*;

  18. import javax.swing.plaf.*;

  19. 

  20. 

  21. /**

  22.  * A Basic L&F implementation of ToolBarUI.  This implementation 

  23.  * is a "combined" view/controller.

  24.  * <p>

  25.  *

  26.  * @version 1.8, 01/23/03 (based on BasicToolBarUI v 1.83)

  27.  * @author Georges Saab

  28.  * @author Jeff Shapiro

  29.  */

  30. class SynthToolBarUI extends ToolBarUI implements SwingConstants, SynthUI {

  31.     protected JToolBar toolBar;

  32.     private boolean floating;

  33.     private int floatingX;

  34.     private int floatingY;

  35.     private JFrame floatingFrame;

  36.     private RootPaneContainer floatingToolBar;

  37.     protected DragWindow dragWindow;

  38.     private Container dockingSource;

  39.     private int dockingSensitivity = 0;

  40.     protected int focusedCompIndex = -1;

  41.     protected Icon handleIcon = null;

  42.     protected Rectangle contentRect = null;

  43. 

  44.     protected MouseInputListener dockingListener;

  45.     protected PropertyChangeListener propertyListener;

  46. 

  47.     protected ContainerListener toolBarContListener;

  48.     protected FocusListener toolBarFocusListener;

  49. 

  50.     protected String constraintBeforeFloating = BorderLayout.NORTH;

  51. 

  52.     private SynthStyle style;

  53.     private SynthStyle contentStyle;

  54.     private SynthStyle dragWindowStyle;

  55. 

  56.     private static String FOCUSED_COMP_INDEX = "JToolBar.focusedCompIndex";

  57. 

  58.     public static ComponentUI createUI(JComponent c) {

  59. 	return new SynthToolBarUI();

  60.     }

  61. 

  62.     protected String getPropertyPrefix() {

  63.         return "ToolBar";

  64.     }

  65. 

  66.     public static void loadActionMap(ActionMap map) {

  67.         // NOTE: this needs to remain static. If you have a need to

  68.         // have Actions that reference the UI in the ActionMap,

  69.         // then you'll also need to change the registeration of the

  70.         // ActionMap.

  71. 	map.put("navigateRight", new RightAction());

  72. 	map.put("navigateLeft", new LeftAction());

  73. 	map.put("navigateUp", new UpAction());

  74. 	map.put("navigateDown", new DownAction());

  75.     }

  76. 

  77.     public void installUI(JComponent c) {

  78. 	toolBar = (JToolBar)c;

  79.         contentRect = new Rectangle();

  80. 

  81. 	// Set defaults

  82.         installDefaults();

  83. 	installComponents();

  84.         installListeners();

  85. 	installKeyboardActions();

  86. 

  87.         // Initialize instance vars

  88.         dockingSensitivity = 0;

  89.         floating = false;

  90.         floatingX = floatingY = 0;

  91.         floatingToolBar = null;

  92. 

  93. 	setOrientation(toolBar.getOrientation());

  94. 	c.setOpaque(true);

  95. 

  96. 	if (c.getClientProperty(FOCUSED_COMP_INDEX) != null) {

  97. 	    focusedCompIndex =((Integer)(c.getClientProperty(

  98.                             FOCUSED_COMP_INDEX))).intValue();

  99. 	}

  100.     }

  101.     

  102.     public void uninstallUI(JComponent c) {

  103.         // Clear defaults

  104.         uninstallDefaults();

  105. 	uninstallComponents();

  106.         uninstallListeners();

  107. 	uninstallKeyboardActions();

  108. 

  109.         // Clear instance vars

  110. 	if (isFloating() == true)

  111. 	    setFloating(false, null);

  112. 

  113.         floatingToolBar = null;

  114.         dragWindow = null;

  115.         dockingSource = null;

  116. 

  117.         c.putClientProperty(FOCUSED_COMP_INDEX, new Integer(focusedCompIndex));

  118.     }

  119. 

  120.     protected void installDefaults() {

  121.         toolBar.setLayout(createLayout());

  122.         fetchStyle(toolBar);

  123.     }

  124. 

  125.     private void fetchStyle(JToolBar c) {

  126.         SynthContext context = getContext(c, ENABLED);

  127.         SynthStyle oldStyle = style;

  128. 

  129.         style = SynthLookAndFeel.updateStyle(context, this);

  130.         if (oldStyle != style) {

  131.             handleIcon =

  132.                 style.getIcon(context, getPropertyPrefix() + ".handleIcon");

  133.         }

  134.         context.dispose();

  135. 

  136.         context = getContext(c, Region.TOOL_BAR_CONTENT, ENABLED);

  137.         contentStyle = SynthLookAndFeel.updateStyle(context, this);

  138.         context.dispose();

  139. 

  140.         context = getContext(c, Region.TOOL_BAR_DRAG_WINDOW, ENABLED);

  141.         dragWindowStyle = SynthLookAndFeel.updateStyle(context, this);

  142.         context.dispose();

  143.     }

  144. 

  145.     protected void uninstallDefaults() {

  146.         SynthContext context = getContext(toolBar, ENABLED);

  147. 

  148.         style.uninstallDefaults(context);

  149.         context.dispose();

  150.         style = null;

  151. 

  152.         handleIcon = null;

  153. 

  154.         context = getContext(toolBar, Region.TOOL_BAR_CONTENT, ENABLED);

  155.         contentStyle.uninstallDefaults(context);

  156.         context.dispose();

  157.         contentStyle = null;

  158. 

  159.         context = getContext(toolBar, Region.TOOL_BAR_DRAG_WINDOW, ENABLED);

  160.         dragWindowStyle.uninstallDefaults(context);

  161.         context.dispose();

  162.         dragWindowStyle = null;

  163. 

  164.         toolBar.setLayout(null);

  165.     }

  166. 

  167.     protected void installComponents() {

  168.     }

  169. 

  170.     protected void uninstallComponents() {

  171.     }

  172. 

  173.     protected void installListeners() {

  174.         dockingListener = createDockingListener();

  175. 

  176.         if (dockingListener != null) {

  177. 	    toolBar.addMouseMotionListener( dockingListener );

  178. 	    toolBar.addMouseListener( dockingListener );

  179. 	}

  180. 

  181. 	propertyListener = createPropertyListener();  // added in setFloating

  182. 	if (propertyListener != null) {

  183. 	    toolBar.addPropertyChangeListener(propertyListener);

  184. 	}

  185. 

  186. 	toolBarContListener = createToolBarContListener();

  187.         if ( toolBarContListener != null ) {

  188. 	    toolBar.addContainerListener( toolBarContListener );

  189. 	}

  190. 

  191. 	toolBarFocusListener = createToolBarFocusListener();

  192. 

  193.         if ( toolBarFocusListener != null )

  194.         {

  195. 	    // Put focus listener on all components in toolbar

  196. 	    Component[] components = toolBar.getComponents();

  197. 

  198. 	    for ( int i = 0; i < components.length; ++i )

  199. 	    {

  200. 	        components[ i ].addFocusListener( toolBarFocusListener );

  201. 	    }

  202. 	}

  203.     }

  204. 

  205.     protected void uninstallListeners( )

  206.     {

  207.         if ( dockingListener != null )

  208.         {

  209. 	    toolBar.removeMouseMotionListener(dockingListener);

  210. 	    toolBar.removeMouseListener(dockingListener);

  211. 

  212.             dockingListener = null;

  213. 	}

  214. 

  215. 	if ( propertyListener != null )

  216. 	{

  217. 	    toolBar.removePropertyChangeListener(propertyListener);

  218. 	    propertyListener = null;  // removed in setFloating

  219. 	}

  220. 

  221. 	if ( toolBarContListener != null )

  222. 	{

  223. 	    toolBar.removeContainerListener( toolBarContListener );

  224. 	    toolBarContListener = null;

  225. 	}

  226. 

  227.         if ( toolBarFocusListener != null )

  228.         {

  229. 	    // Remove focus listener from all components in toolbar

  230. 	    Component[] components = toolBar.getComponents();

  231. 

  232. 	    for ( int i = 0; i < components.length; ++i )

  233. 	    {

  234. 	        components[ i ].removeFocusListener( toolBarFocusListener );

  235. 	    }

  236. 

  237. 	    toolBarFocusListener = null;

  238. 	}

  239.     }

  240. 

  241.     protected void installKeyboardActions() {

  242. 	InputMap km = getInputMap(JComponent.

  243. 				  WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

  244. 

  245. 	SwingUtilities.replaceUIInputMap(toolBar, JComponent.

  246. 					 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

  247. 					 km);

  248. 	LazyActionMap.installLazyActionMap(toolBar, SynthToolBarUI.class,

  249.                                            "ToolBar.actionMap");

  250.     }

  251. 

  252.     InputMap getInputMap(int condition) {

  253. 	if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {

  254.             SynthContext context = getContext(toolBar, ENABLED);

  255.             InputMap map = (InputMap)context.getStyle().get(context,

  256.                                              "ToolBar.ancestorInputMap");

  257. 

  258.             context.dispose();

  259.             return map;

  260. 	}

  261. 	return null;

  262.     }

  263. 

  264.     protected void uninstallKeyboardActions() {

  265. 	SwingUtilities.replaceUIActionMap(toolBar, null);

  266. 	SwingUtilities.replaceUIInputMap(toolBar, JComponent.

  267. 					 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

  268. 					 null);

  269.     }

  270. 

  271.     protected LayoutManager createLayout() {

  272.         return new SynthToolBarLayoutManager();

  273.     }

  274. 

  275.     public SynthContext getContext(JComponent c) {

  276.         return getContext(c, getComponentState(c));

  277.     }

  278. 

  279.     private SynthContext getContext(JComponent c, int state) {

  280.         return SynthContext.getContext(SynthContext.class, c,

  281.                     SynthLookAndFeel.getRegion(c), style, state);

  282.     }

  283. 

  284.     private SynthContext getContext(JComponent c, Region region) {

  285.         return getContext(c, region, getComponentState(c, region));

  286.     }

  287. 

  288.     private SynthContext getContext(JComponent c, Region region, int state) {

  289.         return SynthContext.getContext(SynthContext.class, c, region,

  290.                                        dragWindowStyle, state);

  291.     }

  292. 

  293.     private Region getRegion(JComponent c) {

  294.         return SynthLookAndFeel.getRegion(c);

  295.     }

  296. 

  297.     private int getComponentState(JComponent c) {

  298.         return SynthLookAndFeel.getComponentState(c);

  299.     }

  300. 

  301.     private int getComponentState(JComponent c, Region region) {

  302.         return SynthLookAndFeel.getComponentState(c);

  303.     }

  304. 

  305.     public void update(Graphics g, JComponent c) {

  306.         SynthContext context = getContext(c);

  307. 

  308.         SynthLookAndFeel.update(context, g);

  309.         paint(context, g);

  310.         context.dispose();

  311.     }

  312. 

  313.     public void paint(Graphics g, JComponent c) {

  314.         SynthContext context = getContext(c);

  315. 

  316.         paint(context, g);

  317.         context.dispose();

  318.     }

  319. 

  320.     protected void paint(SynthContext context, Graphics g) {

  321.         if (handleIcon != null && toolBar.isFloatable()) {

  322.             int startX = toolBar.getComponentOrientation().isLeftToRight() ?

  323.                 0 : toolBar.getWidth() -

  324.                     SynthIcon.getIconWidth(handleIcon, context);

  325.             SynthIcon.paintIcon(handleIcon, context, g, startX, 0,

  326.                     SynthIcon.getIconWidth(handleIcon, context),

  327.                     SynthIcon.getIconHeight(handleIcon, context));

  328.         }

  329. 

  330.         SynthContext subcontext = getContext(toolBar, Region.TOOL_BAR_CONTENT);

  331.         paintContent(subcontext, g, contentRect);

  332.         subcontext.dispose();

  333.     }

  334. 

  335.     public void paintContent(SynthContext context, Graphics g,

  336.             Rectangle bounds) {

  337.         SynthLookAndFeel.updateSubregion(context, g, bounds);

  338.     }

  339. 

  340.     protected void navigateFocusedComp(int direction) {

  341.         int nComp = toolBar.getComponentCount();

  342. 	int j;

  343. 

  344.         switch (direction) {

  345. 	    case EAST:

  346. 	    case SOUTH:

  347. 

  348. 		if (focusedCompIndex < 0 || focusedCompIndex >= nComp) break;

  349. 

  350. 		j = focusedCompIndex + 1;

  351. 

  352. 		while (j != focusedCompIndex) {

  353. 		    if (j >= nComp) j = 0;

  354. 		    Component comp = toolBar.getComponentAtIndex(j++);

  355. 

  356. 		    if (comp != null && comp.isFocusTraversable()) {

  357. 		        comp.requestFocus();

  358. 			break;

  359. 		    }

  360. 		}

  361. 

  362. 	        break;

  363. 

  364. 	    case WEST:

  365. 	    case NORTH:

  366. 

  367. 		if (focusedCompIndex < 0 || focusedCompIndex >= nComp) break;

  368. 

  369. 		j = focusedCompIndex - 1;

  370. 

  371. 		while (j != focusedCompIndex) {

  372. 		    if (j < 0) j = nComp - 1;

  373. 		    Component comp = toolBar.getComponentAtIndex(j--);

  374. 

  375. 		    if (comp != null && comp.isFocusTraversable()) {

  376. 		        comp.requestFocus();

  377. 			break;

  378. 		    }

  379. 		}

  380. 

  381. 	        break;

  382. 

  383. 	    default:

  384. 	        break;

  385. 	}

  386.     }

  387. 

  388.     /**

  389.      * No longer used, use BasicToolBarUI.createFloatingWindow(JToolBar)

  390.      * @see #createFloatingWindow

  391.      */

  392.     protected JFrame createFloatingFrame(JToolBar toolbar) {

  393. 	Window window = SwingUtilities.getWindowAncestor(toolbar);

  394. 	JFrame frame = new JFrame(toolbar.getName(),

  395. 				  (window != null) ? window.getGraphicsConfiguration() : null) {

  396. 	    // Override createRootPane() to automatically resize

  397. 	    // the frame when contents change

  398. 	    protected JRootPane createRootPane() {

  399. 		JRootPane rootPane = new JRootPane() {

  400. 		    private boolean packing = false;

  401. 

  402. 		    public void validate() {

  403. 			super.validate();

  404. 			if (!packing) {

  405. 			    packing = true;

  406. 			    pack();

  407. 			    packing = false;

  408. 			}

  409. 		    }

  410. 		};

  411. 		rootPane.setOpaque(true);

  412. 		return rootPane;

  413. 	    }

  414. 	};

  415.         frame.getRootPane().setName("ToolBar.FloatingFrame");

  416. 	frame.setResizable(false);

  417. 	WindowListener wl = createFrameListener();

  418. 	frame.addWindowListener(wl);

  419.         return frame;

  420.     }

  421. 

  422.     /**

  423.      * Creates a window which contains the toolbar after it has been

  424.      * dragged out from its container

  425.      * @returns a <code>RootPaneContainer</code> object, containing the toolbar.

  426.      */

  427.     protected RootPaneContainer createFloatingWindow(JToolBar toolbar) {

  428. 	class ToolBarDialog extends JDialog {

  429. 	    public ToolBarDialog(Frame owner, String title, boolean modal) {

  430. 		super(owner, title, modal);

  431. 	    }

  432. 

  433. 	    public ToolBarDialog(Dialog owner, String title, boolean modal) {

  434. 		super(owner, title, modal);

  435. 	    }

  436. 

  437. 	    // Override createRootPane() to automatically resize

  438. 	    // the frame when contents change

  439. 	    protected JRootPane createRootPane() {

  440. 		JRootPane rootPane = new JRootPane() {

  441. 		    private boolean packing = false;

  442. 

  443. 		    public void validate() {

  444. 			super.validate();

  445. 			if (!packing) {

  446. 			    packing = true;

  447. 			    pack();

  448. 			    packing = false;

  449. 			}

  450. 		    }

  451. 		};

  452. 		rootPane.setOpaque(true);

  453. 		return rootPane;

  454. 	    }

  455. 	}

  456. 

  457. 	JDialog dialog;

  458. 	Window window = SwingUtilities.getWindowAncestor(toolbar);

  459. 	if (window instanceof Frame) {

  460. 	    dialog = new ToolBarDialog((Frame)window, toolbar.getName(), false);

  461. 	} else if (window instanceof Dialog) {

  462. 	    dialog = new ToolBarDialog((Dialog)window, toolbar.getName(), false);

  463. 	} else {

  464. 	    dialog = new ToolBarDialog((Frame)null, toolbar.getName(), false);

  465. 	}

  466. 

  467.         dialog.getRootPane().setName("ToolBar.FloatingWindow");

  468. 	dialog.setTitle(toolbar.getName());

  469. 	dialog.setResizable(false);

  470. 	WindowListener wl = createFrameListener();

  471. 	dialog.addWindowListener(wl);

  472.         return dialog;

  473.     }

  474. 

  475.     protected DragWindow createDragWindow(JToolBar toolbar) {

  476. 	Window frame = null;

  477. 	if(toolBar != null) {

  478. 	    Container p;

  479. 	    for(p = toolBar.getParent() ; p != null && !(p instanceof Window) ;

  480. 		p = p.getParent());

  481. 	    if(p != null && p instanceof Window)

  482. 		frame = (Window) p;

  483. 	}

  484. 	if(floatingToolBar == null) {

  485. 	    floatingToolBar = createFloatingWindow(toolBar);

  486. 	}

  487. 	if (floatingToolBar instanceof Window) frame = (Window) floatingToolBar;

  488. 	DragWindow dragWindow = new DragWindow(frame);

  489. 	return dragWindow;

  490.     }

  491. 

  492.     public Dimension getMinimumSize(JComponent c) {

  493.         return getPreferredSize(c);

  494.     }

  495. 

  496.     public Dimension getPreferredSize(JComponent c) {

  497. 	return null;

  498.     }

  499. 

  500.     public Dimension getMaximumSize(JComponent c) {

  501.         return getPreferredSize(c);

  502.     }

  503. 

  504.     public void setFloatingLocation(int x, int y) {

  505. 	floatingX = x;

  506. 	floatingY = y;

  507.     }

  508.     

  509.     public boolean isFloating() {

  510. 	return floating;

  511.     }

  512. 

  513.     public void setFloating(boolean b, Point p) {

  514.  	if (toolBar.isFloatable() == true) {

  515. 	    if (dragWindow != null)

  516. 		dragWindow.setVisible(false);

  517. 	    this.floating = b;

  518. 	    if (b == true)

  519. 	    {

  520. 		if (dockingSource == null)

  521. 		{

  522. 		    dockingSource = toolBar.getParent();

  523. 		    dockingSource.remove(toolBar);

  524. 		}

  525. 		Point l = new Point();

  526. 		toolBar.getLocation(l);

  527. 		constraintBeforeFloating = calculateConstraint(dockingSource, l);

  528. 		if ( propertyListener != null )

  529.                     UIManager.addPropertyChangeListener( propertyListener );

  530. 		if (floatingToolBar == null)

  531. 		    floatingToolBar = createFloatingWindow(toolBar);

  532. 		floatingToolBar.getContentPane().add(toolBar,BorderLayout.CENTER);

  533. 		setOrientation( JToolBar.HORIZONTAL );

  534. 		if (floatingToolBar instanceof Window) ((Window)floatingToolBar).pack();

  535. 		if (floatingToolBar instanceof Window) ((Window)floatingToolBar).setLocation(floatingX, floatingY);

  536. 		if (floatingToolBar instanceof Window) ((Window)floatingToolBar).show();

  537. 	    } else {

  538. 		if (floatingToolBar == null)

  539. 		    floatingToolBar = createFloatingWindow(toolBar);

  540. 		if (floatingToolBar instanceof Window) ((Window)floatingToolBar).setVisible(false);

  541. 		floatingToolBar.getContentPane().remove(toolBar);

  542. 		String constraint = getDockingConstraint(dockingSource,

  543. 							 p);

  544. 		int orientation = mapConstraintToOrientation(constraint);

  545. 		setOrientation(orientation);

  546. 		if (dockingSource== null)

  547. 		    dockingSource = toolBar.getParent();

  548. 		if ( propertyListener != null )

  549. 		    UIManager.removePropertyChangeListener( propertyListener );

  550. 		dockingSource.add(constraint, toolBar);

  551. 	    }

  552.  	    dockingSource.invalidate();

  553.  	    Container dockingSourceParent = dockingSource.getParent();

  554. 	    if (dockingSourceParent != null) 

  555. 		dockingSourceParent.validate();

  556. 	    dockingSource.repaint();

  557. 	}

  558.     }

  559. 

  560.     private int mapConstraintToOrientation(String constraint) {

  561. 	int orientation = toolBar.getOrientation();

  562. 

  563. 	if (constraint != null) {

  564. 	    if (constraint.equals(BorderLayout.EAST) ||

  565.                     constraint.equals(BorderLayout.WEST))

  566. 	        orientation = JToolBar.VERTICAL;

  567. 	    else if (constraint.equals(BorderLayout.NORTH) ||

  568.                     constraint.equals(BorderLayout.SOUTH))

  569. 	        orientation = JToolBar.HORIZONTAL;

  570. 	}

  571. 

  572. 	return orientation;

  573.     }

  574.     

  575.     public void setOrientation(int orientation) {	

  576.         toolBar.setOrientation(orientation);

  577. 

  578. 	if (dragWindow != null)

  579. 	    dragWindow.setOrientation(orientation);

  580.     }

  581.     

  582.     public boolean canDock(Component c, Point p) {

  583. 	boolean b = false;

  584. 	if (c.contains(p)) {

  585. 	    dockingSensitivity = (toolBar.getOrientation() == JToolBar.HORIZONTAL) ? toolBar.getSize().height : toolBar.getSize().width;

  586. 	    // North

  587. 	    if (p.y < dockingSensitivity)

  588. 		b = true;

  589. 	    // South

  590. 	    if (p.y > c.getSize().height-dockingSensitivity)

  591. 		b = true;

  592. 	    // West  (Base distance on height for now!)

  593. 	    if (p.x < dockingSensitivity)

  594. 		b = true;

  595. 	    // East  (Base distance on height for now!)

  596. 	    if (p.x > c.getSize().width-dockingSensitivity)

  597. 		b = true;

  598. 	}

  599. 	return b;

  600.     }

  601. 

  602.     private String calculateConstraint(Component c, Point p) {

  603. 	if (p == null) return constraintBeforeFloating;

  604. 	String s = BorderLayout.NORTH;

  605. 	if (c.contains(p)) {

  606. 	    dockingSensitivity = (toolBar.getOrientation() == JToolBar.HORIZONTAL) ? toolBar.getSize().height : toolBar.getSize().width;

  607. 	    if (p.y >= dockingSource.getSize().height-dockingSensitivity)

  608. 		s = BorderLayout.SOUTH;

  609. 	    // West  (Base distance on height for now!)

  610. 	    else if (p.x < dockingSensitivity && (toolBar.getOrientation() == JToolBar.VERTICAL))

  611. 		s = BorderLayout.WEST;

  612. 	    // East  (Base distance on height for now!)

  613. 	    else if (p.x >= dockingSource.getSize().width-dockingSensitivity && (toolBar.getOrientation() == JToolBar.VERTICAL))

  614. 		s = BorderLayout.EAST;

  615. 	    // North  (Base distance on height for now!)

  616. 	    else if (p.y < dockingSensitivity)

  617. 		s = BorderLayout.NORTH;

  618. 	}

  619. 	return s;

  620.     }

  621. 

  622. 

  623. 

  624.     private String getDockingConstraint(Component c, Point p) {

  625. 	if (p == null) return constraintBeforeFloating;

  626. 	String s = BorderLayout.NORTH;

  627. 	if (c.contains(p)) {

  628. 	    dockingSensitivity = (toolBar.getOrientation() == JToolBar.HORIZONTAL) ? toolBar.getSize().height : toolBar.getSize().width;

  629. 	    if (p.y >= dockingSource.getSize().height-dockingSensitivity)

  630. 		s = BorderLayout.SOUTH;

  631. 	    // West  (Base distance on height for now!)

  632. 	    if (p.x < dockingSensitivity)

  633. 		s = BorderLayout.WEST;

  634. 	    // East  (Base distance on height for now!)

  635. 	    if (p.x >= dockingSource.getSize().width-dockingSensitivity)

  636. 		s = BorderLayout.EAST;

  637. 	    // North  (Base distance on height for now!)

  638. 	    if (p.y < dockingSensitivity)

  639. 		s = BorderLayout.NORTH;

  640. 	}

  641. 	return s;

  642.     }

  643. 

  644.     protected void dragTo(Point position, Point origin)

  645.     {

  646. 	if (toolBar.isFloatable() == true)

  647. 	{

  648. 	  try

  649. 	  {

  650. 	    if (dragWindow == null)

  651. 		dragWindow = createDragWindow(toolBar);

  652. 	    Point offset = dragWindow.getOffset();

  653. 	    if (offset == null) {

  654. 		Dimension size = toolBar.getPreferredSize();

  655. 		offset = new Point(size.width2, size.height2);

  656. 		dragWindow.setOffset(offset);

  657. 	    }

  658. 	    Point global = new Point(origin.x+ position.x,

  659. 				     origin.y+position.y);

  660. 	    Point dragPoint = new Point(global.x- offset.x, 

  661. 					global.y- offset.y);

  662. 	    if (dockingSource == null)

  663. 		dockingSource = toolBar.getParent();

  664. 

  665. 

  666. 		Point p = new Point(origin);

  667. 		SwingUtilities.convertPointFromScreen(p,toolBar.getParent());

  668. 		constraintBeforeFloating = calculateConstraint(dockingSource, p);	    

  669. 	    Point dockingPosition = dockingSource.getLocationOnScreen();

  670. 	    Point comparisonPoint = new Point(global.x-dockingPosition.x,

  671. 					      global.y-dockingPosition.y);

  672. 	    if (canDock(dockingSource, comparisonPoint)) {

  673. 		String constraint = getDockingConstraint(dockingSource,

  674. 							 comparisonPoint);

  675. 		int orientation = mapConstraintToOrientation(constraint);

  676. 		dragWindow.setOrientation(orientation);

  677. 	    } else {

  678. 		dragWindow.setOrientation( JToolBar.HORIZONTAL );

  679. 	    }

  680. 	    

  681. 	    dragWindow.setLocation(dragPoint.x, dragPoint.y);

  682. 	    if (dragWindow.isVisible() == false) {

  683. 		Dimension size = toolBar.getPreferredSize();

  684. 		dragWindow.setSize(size.width, size.height);

  685. 		dragWindow.show();

  686. 	    }

  687. 	  }

  688. 	  catch ( IllegalComponentStateException e )

  689. 	  {

  690. 	  }

  691. 	}

  692.     }

  693. 

  694.     protected void floatAt(Point position, Point origin)

  695.     {

  696. 	if(toolBar.isFloatable() == true)

  697. 	{

  698. 	  try

  699. 	  {

  700. 	    Point offset = dragWindow.getOffset();

  701. 	    if (offset == null) {

  702. 		offset = position;

  703. 		dragWindow.setOffset(offset);

  704. 	    }

  705. 	    Point global = new Point(origin.x+ position.x,

  706. 				     origin.y+position.y);

  707. 	    setFloatingLocation(global.x-offset.x, 

  708. 				global.y-offset.y);

  709. 	    if (dockingSource != null) { 

  710. 		Point dockingPosition = dockingSource.getLocationOnScreen();

  711. 		Point comparisonPoint = new Point(global.x-dockingPosition.x,

  712. 						  global.y-dockingPosition.y);

  713. 		if (canDock(dockingSource, comparisonPoint)) {

  714. 		    setFloating(false, comparisonPoint);

  715. 		} else {

  716. 		    setFloating(true, null);

  717. 		}

  718. 	    } else {

  719. 		setFloating(true, null);

  720. 	    }

  721. 	    dragWindow.setOffset(null);

  722. 	  }

  723. 	  catch ( IllegalComponentStateException e )

  724. 	  {

  725. 	  }

  726. 	}

  727.     }

  728. 

  729.     protected ContainerListener createToolBarContListener( )

  730.     {

  731. 	return new ToolBarContListener( );

  732.     }

  733. 

  734.     protected FocusListener createToolBarFocusListener( )

  735.     {

  736. 	return new ToolBarFocusListener( );

  737.     }

  738. 

  739.     protected PropertyChangeListener createPropertyListener()

  740.     {

  741.         return new PropertyListener();

  742.     }

  743. 

  744.     protected MouseInputListener createDockingListener( ) {

  745. 	return new DockingListener(toolBar);

  746.     }

  747.     

  748.     protected WindowListener createFrameListener() {

  749. 	return new FrameListener();

  750.     }

  751. 

  752.     // The private inner classes below should be changed to protected the

  753.     // next time API changes are allowed.

  754.   

  755.     private static abstract class KeyAction extends AbstractAction {

  756.         public boolean isEnabled() { 

  757.             return true;

  758.         }

  759.     };

  760. 

  761.     private static class RightAction extends KeyAction {

  762.         public void actionPerformed(ActionEvent e) {

  763. 	    JToolBar toolBar = (JToolBar)e.getSource();

  764.             // PENDING:

  765. 	    SynthToolBarUI ui = (SynthToolBarUI)toolBar.getUI();

  766.             ui.navigateFocusedComp(EAST);

  767.         }

  768.     };

  769.     

  770.     private static class LeftAction extends KeyAction {

  771.         public void actionPerformed(ActionEvent e) {

  772. 	    JToolBar toolBar = (JToolBar)e.getSource();

  773. 	    SynthToolBarUI ui = (SynthToolBarUI)toolBar.getUI();

  774.             ui.navigateFocusedComp(WEST);

  775.         }

  776.     };

  777. 

  778.     private static class UpAction extends KeyAction {

  779.         public void actionPerformed(ActionEvent e) {

  780. 	    JToolBar toolBar = (JToolBar)e.getSource();

  781. 	    SynthToolBarUI ui = (SynthToolBarUI)toolBar.getUI();

  782.             ui.navigateFocusedComp(NORTH);

  783.         }

  784.     };

  785. 

  786.     private static class DownAction extends KeyAction {

  787.         public void actionPerformed(ActionEvent e) {

  788. 	    JToolBar toolBar = (JToolBar)e.getSource();

  789. 	    SynthToolBarUI ui = (SynthToolBarUI)toolBar.getUI();

  790.             ui.navigateFocusedComp(SOUTH);

  791.         }

  792.     };

  793. 

  794.     protected class FrameListener extends WindowAdapter {

  795. 	public void windowClosing(WindowEvent w) {	    

  796. 	    if (toolBar.isFloatable() == true) {

  797. 		if (dragWindow != null)

  798. 		    dragWindow.setVisible(false);

  799. 		floating = false;

  800. 		if (floatingToolBar == null)

  801. 		    floatingToolBar = createFloatingWindow(toolBar);

  802. 		if (floatingToolBar instanceof Window) ((Window)floatingToolBar).setVisible(false);

  803. 		floatingToolBar.getContentPane().remove(toolBar);

  804. 		String constraint = constraintBeforeFloating;

  805. 		int orientation = mapConstraintToOrientation(constraint);

  806. 		setOrientation(orientation);

  807. 		if (dockingSource == null)

  808. 		    dockingSource = toolBar.getParent();

  809. 		if (propertyListener != null)

  810. 		    UIManager.removePropertyChangeListener(propertyListener);

  811. 		dockingSource.add(constraint, toolBar);

  812. 		dockingSource.invalidate();

  813. 		Container dockingSourceParent = dockingSource.getParent();

  814. 		if (dockingSourceParent != null)

  815. 			dockingSourceParent.validate();

  816. 		dockingSource.repaint();

  817. 		setFloating(false,null);

  818. 	    }

  819. 	}

  820. 

  821.     } 

  822. 

  823.     protected class ToolBarContListener implements ContainerListener

  824.     {

  825.         public void componentAdded( ContainerEvent e )	{

  826. 	    Component c = e.getChild();

  827. 

  828. 	    if ( toolBarFocusListener != null ) {

  829. 	        c.addFocusListener( toolBarFocusListener );

  830. 	    }

  831. 	}

  832. 

  833.         public void componentRemoved( ContainerEvent e ) {

  834. 	    Component c = e.getChild();

  835. 

  836. 	    if ( toolBarFocusListener != null ) {

  837. 	        c.removeFocusListener( toolBarFocusListener );

  838. 	    }

  839. 	}

  840. 

  841.     } // end class ToolBarContListener

  842. 

  843.     protected class ToolBarFocusListener implements FocusListener

  844.     {

  845.         public void focusGained( FocusEvent e )

  846. 	{

  847. 	    Component c = e.getComponent();

  848. 

  849. 	    focusedCompIndex = toolBar.getComponentIndex( c );

  850. 	}

  851. 

  852.         public void focusLost( FocusEvent e )

  853. 	{

  854. 	}

  855. 

  856.     } // end class ToolBarFocusListener

  857. 

  858.     protected class PropertyListener implements PropertyChangeListener

  859.     {

  860.         public void propertyChange( PropertyChangeEvent e ) {

  861. 	    String propertyName = e.getPropertyName();

  862. 

  863.             if (SynthLookAndFeel.shouldUpdateStyle(e)) {

  864.                 fetchStyle(toolBar);

  865.             }

  866. 	    if ( propertyName.equals("lookAndFeel") ) {

  867. 	        toolBar.updateUI();

  868.             } else if (propertyName.equals("orientation")) {

  869. 		// Search for JSeparator components and change it's orientation

  870. 		// to match the toolbar and flip it's orientation.

  871. 		Component[] components = toolBar.getComponents();

  872. 		int orientation = ((Integer)e.getNewValue()).intValue();

  873. 		JToolBar.Separator separator;

  874. 

  875. 		for( int i = 0; i < components.length; ++i ) {

  876. 		    if (components[i] instanceof JToolBar.Separator) {

  877. 			separator = (JToolBar.Separator)components[i];

  878. 			separator.setOrientation(orientation);

  879. 			Dimension size = separator.getSize();

  880. 			if (size.width != size.height) {

  881. 			    // Flip the orientation.

  882. 			    Dimension newSize = new Dimension(size.height, size.width);

  883. 			    separator.setSeparatorSize(newSize);

  884. 			}

  885. 		    }

  886. 		}

  887. 	    }

  888. 	}

  889.     }

  890. 

  891.     class SynthToolBarLayoutManager implements LayoutManager {

  892.         public void addLayoutComponent(String name, Component comp) {}

  893. 

  894.         public void removeLayoutComponent(Component comp) {}

  895. 

  896.         public Dimension minimumLayoutSize(Container parent) {

  897.             JToolBar tb = (JToolBar)parent;

  898.             Dimension dim = new Dimension();

  899.             SynthContext context = getContext(tb);

  900. 

  901.             if (tb.getOrientation() == JToolBar.HORIZONTAL) {

  902.                 dim.width = SynthIcon.getIconWidth(handleIcon, context);

  903.                 Dimension compDim;

  904.                 for (int i = 0; i < tb.getComponentCount(); i++) {

  905.                     compDim = tb.getComponent(i).getMinimumSize();

  906.                     dim.width += compDim.width;

  907.                     dim.height = Math.max(dim.height, compDim.height);

  908.                 }

  909.             } else {

  910.                 dim.height =

  911.                     SynthIcon.getIconHeight(handleIcon, context);

  912.                 Dimension compDim;

  913.                 for (int i = 0; i < tb.getComponentCount(); i++) {

  914.                     compDim = tb.getComponent(i).getMinimumSize();

  915.                     dim.width = Math.max(dim.width, compDim.width);

  916.                     dim.height += compDim.height;

  917.                 }

  918.             }

  919.             context.dispose();

  920.             return dim;

  921.         }

  922. 

  923.         public Dimension preferredLayoutSize(Container parent) {

  924.             JToolBar tb = (JToolBar)parent;

  925.             Dimension dim = new Dimension();

  926.             SynthContext context = getContext(tb);

  927. 

  928.             if (tb.getOrientation() == JToolBar.HORIZONTAL) {

  929.                 dim.width = SynthIcon.getIconWidth(handleIcon, context);

  930.                 Dimension compDim;

  931.                 for (int i = 0; i < tb.getComponentCount(); i++) {

  932.                     compDim = tb.getComponent(i).getPreferredSize();

  933.                     dim.width += compDim.width;

  934.                     dim.height = Math.max(dim.height, compDim.height);

  935.                 }

  936.             } else {

  937.                 dim.height =

  938.                     SynthIcon.getIconHeight(handleIcon, context);

  939.                 Dimension compDim;

  940.                 for (int i = 0; i < tb.getComponentCount(); i++) {

  941.                     compDim = tb.getComponent(i).getPreferredSize();

  942.                     dim.width = Math.max(dim.width, compDim.width);

  943.                     dim.height += compDim.height;

  944.                 }

  945.             }

  946.             context.dispose();

  947.             return dim;

  948.         }

  949. 

  950.         public void layoutContainer(Container parent) {

  951.             JToolBar tb = (JToolBar)parent;

  952.             boolean ltr = tb.getComponentOrientation().isLeftToRight();

  953.             SynthContext context = getContext(tb);

  954.             int handleWidth = SynthIcon.getIconWidth(handleIcon, context);

  955. 

  956.             Component c;

  957.             Dimension d;

  958.             if (tb.getOrientation() == JToolBar.HORIZONTAL) {

  959.                 int x = ltr ? handleWidth : tb.getWidth() - handleWidth;

  960.                 for (int i = 0; i < tb.getComponentCount(); i++) {

  961.                     c = tb.getComponent(i);

  962.                     d = c.getPreferredSize();

  963.                     c.setBounds(ltr ? x : x - d.width, 0, d.width, d.height);

  964.                     x = ltr ? x + d.width : x - d.width;

  965.                 }

  966.                 contentRect.x = ltr ?

  967.                         SynthIcon.getIconWidth(handleIcon, context) : 0;

  968.                 contentRect.y = 0;

  969.                 contentRect.width = tb.getWidth() - contentRect.x;

  970.                 contentRect.height = tb.getHeight();

  971.             } else {

  972.                 int y = SynthIcon.getIconHeight(handleIcon, context);

  973.                 for (int i = 0; i < tb.getComponentCount(); i++) {

  974.                     c = tb.getComponent(i);

  975.                     d = c.getPreferredSize();

  976.                     c.setBounds(0, y, d.width, d.height);

  977.                     y += d.height;

  978.                 }

  979.                 contentRect.x = 0;

  980.                 contentRect.y =

  981.                     SynthIcon.getIconHeight(handleIcon, context);

  982.                 contentRect.width = tb.getWidth();

  983.                 contentRect.height = tb.getHeight() - contentRect.y;

  984.             }

  985.             context.dispose();

  986.         }

  987.     }

  988. 

  989.     class DockingListener implements MouseInputListener {

  990. 	protected JToolBar toolBar;

  991. 	protected boolean isDragging = false;

  992. 	protected Point origin = null;

  993. 

  994. 	public DockingListener(JToolBar t) {

  995. 	    this.toolBar = t;

  996. 	} 

  997. 

  998. 	public void mouseClicked(MouseEvent e) {}

  999. 	public void mousePressed(MouseEvent e) { 

  1000.             if (!toolBar.isEnabled()) {

  1001.                 return;

  1002.             }

  1003. 	    isDragging = false;

  1004. 	}

  1005. 	public void mouseReleased(MouseEvent e) {

  1006.             if (!toolBar.isEnabled()) {

  1007.                 return;

  1008.             }

  1009. 	    if (isDragging == true) {

  1010. 		Point position = e.getPoint();

  1011. 		if (origin == null)

  1012. 		    origin = e.getComponent().getLocationOnScreen();

  1013. 		floatAt(position, origin);

  1014. 	    }

  1015. 	    origin = null;

  1016. 	    isDragging = false;

  1017. 	}

  1018. 	public void mouseEntered(MouseEvent e) { }

  1019. 	public void mouseExited(MouseEvent e) { }

  1020. 

  1021. 	public void mouseDragged(MouseEvent e) {

  1022.             if (!toolBar.isEnabled()) {

  1023.                 return;

  1024.             }

  1025. 	    isDragging = true;

  1026. 	    Point position = e.getPoint();

  1027. 	    if (origin == null)

  1028. 		origin = e.getComponent().getLocationOnScreen();

  1029. 	    dragTo(position, origin);

  1030. 	}

  1031. 	public void mouseMoved(MouseEvent e) {

  1032. 	}

  1033.     }

  1034. 

  1035.     protected class DragWindow extends Window

  1036.     {

  1037. 	int orientation = toolBar.getOrientation();

  1038. 	Point offset; // offset of the mouse cursor inside the DragWindow

  1039. 

  1040. 	DragWindow(Window w) {

  1041. 	    super(w);

  1042. 	}

  1043. 

  1044. 	public void setOrientation(int o) {

  1045. 	    if(isShowing()) {

  1046. 		if (o == this.orientation)

  1047. 		    return;	    

  1048. 		this.orientation = o;

  1049. 		Dimension size = getSize();

  1050. 		setSize(new Dimension(size.height, size.width));

  1051. 		if (offset!=null) {

  1052.                     if( SynthLookAndFeel.isLeftToRight(toolBar) ) {

  1053.                         setOffset(new Point(offset.y, offset.x));

  1054.                     } else if( o == JToolBar.HORIZONTAL ) {

  1055.                         setOffset(new Point( size.height-offset.y, offset.x));

  1056.                     } else {

  1057.                         setOffset(new Point(offset.y, size.width-offset.x));

  1058.                     }

  1059.                 }

  1060. 		repaint();

  1061. 	    }

  1062. 	}

  1063. 

  1064. 	public Point getOffset() {

  1065. 	    return offset;

  1066. 	}

  1067. 

  1068. 	public void setOffset(Point p) {

  1069. 	    this.offset = p;

  1070. 	}

  1071. 	

  1072. 	public void paint(Graphics g) {

  1073.             SynthContext context = getContext(toolBar,

  1074.                                               Region.TOOL_BAR_DRAG_WINDOW);

  1075. 

  1076.             SynthLookAndFeel.updateSubregion(context, g, new Rectangle(

  1077.                                              0, 0, getWidth(), getHeight()));

  1078.             context.dispose();

  1079. 	}

  1080. 

  1081. 	public Insets getInsets() {

  1082. 	    return new Insets(1,1,1,1);

  1083. 	}

  1084.     }

  1085. }