1 /*
2 * Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javax.swing.plaf.basic;
27
28 import javax.swing.*;
29 import javax.swing.event.*;
30 import java.awt.*;
31 import java.awt.event.*;
32
33 import java.beans.*;
34
35 import java.util.Hashtable;
36 import java.util.HashMap;
37
38 import javax.swing.border.*;
39 import javax.swing.plaf.*;
40 import sun.swing.DefaultLookup;
41 import sun.swing.UIAction;
42
43
44 /**
45 * A Basic L&F implementation of ToolBarUI. This implementation
46 * is a "combined" view/controller.
47 * <p>
48 *
49 * @author Georges Saab
50 * @author Jeff Shapiro
51 */
52 public class BasicToolBarUI extends ToolBarUI implements SwingConstants
53 {
54 protected JToolBar toolBar;
55 private boolean floating;
56 private int floatingX;
57 private int floatingY;
58 private JFrame floatingFrame;
59 private RootPaneContainer floatingToolBar;
60 protected DragWindow dragWindow;
61 private Container dockingSource;
62 private int dockingSensitivity = 0;
63 protected int focusedCompIndex = -1;
64
65 protected Color dockingColor = null;
66 protected Color floatingColor = null;
67 protected Color dockingBorderColor = null;
68 protected Color floatingBorderColor = null;
69
70 protected MouseInputListener dockingListener;
71 protected PropertyChangeListener propertyListener;
72
73 protected ContainerListener toolBarContListener;
74 protected FocusListener toolBarFocusListener;
75 private Handler handler;
76
77 protected String constraintBeforeFloating = BorderLayout.NORTH;
78
79 // Rollover button implementation.
80 private static String IS_ROLLOVER = "JToolBar.isRollover";
81 private static Border rolloverBorder;
82 private static Border nonRolloverBorder;
83 private static Border nonRolloverToggleBorder;
84 private boolean rolloverBorders = false;
85
86 private HashMap<AbstractButton, Border> borderTable = new HashMap<AbstractButton, Border>();
87 private Hashtable<AbstractButton, Boolean> rolloverTable = new Hashtable<AbstractButton, Boolean>();
88
89
90 /**
91 * As of Java 2 platform v1.3 this previously undocumented field is no
92 * longer used.
93 * Key bindings are now defined by the LookAndFeel, please refer to
94 * the key bindings specification for further details.
95 *
96 * @deprecated As of Java 2 platform v1.3.
97 */
98 @Deprecated
99 protected KeyStroke upKey;
100 /**
101 * As of Java 2 platform v1.3 this previously undocumented field is no
102 * longer used.
103 * Key bindings are now defined by the LookAndFeel, please refer to
104 * the key bindings specification for further details.
105 *
106 * @deprecated As of Java 2 platform v1.3.
107 */
108 @Deprecated
109 protected KeyStroke downKey;
110 /**
111 * As of Java 2 platform v1.3 this previously undocumented field is no
112 * longer used.
113 * Key bindings are now defined by the LookAndFeel, please refer to
114 * the key bindings specification for further details.
115 *
116 * @deprecated As of Java 2 platform v1.3.
117 */
118 @Deprecated
119 protected KeyStroke leftKey;
120 /**
121 * As of Java 2 platform v1.3 this previously undocumented field is no
122 * longer used.
123 * Key bindings are now defined by the LookAndFeel, please refer to
124 * the key bindings specification for further details.
125 *
126 * @deprecated As of Java 2 platform v1.3.
127 */
128 @Deprecated
129 protected KeyStroke rightKey;
130
131
132 private static String FOCUSED_COMP_INDEX = "JToolBar.focusedCompIndex";
133
134 public static ComponentUI createUI( JComponent c )
135 {
136 return new BasicToolBarUI();
137 }
138
139 public void installUI( JComponent c )
140 {
141 toolBar = (JToolBar) c;
142
143 // Set defaults
144 installDefaults();
145 installComponents();
146 installListeners();
147 installKeyboardActions();
148
149 // Initialize instance vars
150 dockingSensitivity = 0;
151 floating = false;
152 floatingX = floatingY = 0;
153 floatingToolBar = null;
154
155 setOrientation( toolBar.getOrientation() );
156 LookAndFeel.installProperty(c, "opaque", Boolean.TRUE);
157
158 if ( c.getClientProperty( FOCUSED_COMP_INDEX ) != null )
159 {
160 focusedCompIndex = ( (Integer) ( c.getClientProperty( FOCUSED_COMP_INDEX ) ) ).intValue();
161 }
162 }
163
164 public void uninstallUI( JComponent c )
165 {
166
167 // Clear defaults
168 uninstallDefaults();
169 uninstallComponents();
170 uninstallListeners();
171 uninstallKeyboardActions();
172
173 // Clear instance vars
174 if (isFloating())
175 setFloating(false, null);
176
177 floatingToolBar = null;
178 dragWindow = null;
179 dockingSource = null;
180
181 c.putClientProperty( FOCUSED_COMP_INDEX, new Integer( focusedCompIndex ) );
182 }
183
184 protected void installDefaults( )
185 {
186 LookAndFeel.installBorder(toolBar,"ToolBar.border");
187 LookAndFeel.installColorsAndFont(toolBar,
188 "ToolBar.background",
189 "ToolBar.foreground",
190 "ToolBar.font");
191 // Toolbar specific defaults
192 if ( dockingColor == null || dockingColor instanceof UIResource )
193 dockingColor = UIManager.getColor("ToolBar.dockingBackground");
194 if ( floatingColor == null || floatingColor instanceof UIResource )
195 floatingColor = UIManager.getColor("ToolBar.floatingBackground");
196 if ( dockingBorderColor == null ||
197 dockingBorderColor instanceof UIResource )
198 dockingBorderColor = UIManager.getColor("ToolBar.dockingForeground");
199 if ( floatingBorderColor == null ||
200 floatingBorderColor instanceof UIResource )
201 floatingBorderColor = UIManager.getColor("ToolBar.floatingForeground");
202
203 // ToolBar rollover button borders
204 Object rolloverProp = toolBar.getClientProperty( IS_ROLLOVER );
205 if (rolloverProp == null) {
206 rolloverProp = UIManager.get("ToolBar.isRollover");
207 }
208 if ( rolloverProp != null ) {
209 rolloverBorders = ((Boolean)rolloverProp).booleanValue();
210 }
211
212 if (rolloverBorder == null) {
213 rolloverBorder = createRolloverBorder();
214 }
215 if (nonRolloverBorder == null) {
216 nonRolloverBorder = createNonRolloverBorder();
217 }
218 if (nonRolloverToggleBorder == null) {
219 nonRolloverToggleBorder = createNonRolloverToggleBorder();
220 }
221
222
223 setRolloverBorders( isRolloverBorders() );
224 }
225
226 protected void uninstallDefaults( )
227 {
228 LookAndFeel.uninstallBorder(toolBar);
229 dockingColor = null;
230 floatingColor = null;
231 dockingBorderColor = null;
232 floatingBorderColor = null;
233
234 installNormalBorders(toolBar);
235
236 rolloverBorder = null;
237 nonRolloverBorder = null;
238 nonRolloverToggleBorder = null;
239 }
240
241 protected void installComponents( )
242 {
243 }
244
245 protected void uninstallComponents( )
246 {
247 }
248
249 protected void installListeners( )
250 {
251 dockingListener = createDockingListener( );
252
253 if ( dockingListener != null )
254 {
255 toolBar.addMouseMotionListener( dockingListener );
256 toolBar.addMouseListener( dockingListener );
257 }
258
259 propertyListener = createPropertyListener(); // added in setFloating
260 if (propertyListener != null) {
261 toolBar.addPropertyChangeListener(propertyListener);
262 }
263
264 toolBarContListener = createToolBarContListener();
265 if ( toolBarContListener != null ) {
266 toolBar.addContainerListener( toolBarContListener );
267 }
268
269 toolBarFocusListener = createToolBarFocusListener();
270
271 if ( toolBarFocusListener != null )
272 {
273 // Put focus listener on all components in toolbar
274 Component[] components = toolBar.getComponents();
275
276 for (Component component : components) {
277 component.addFocusListener(toolBarFocusListener);
278 }
279 }
280 }
281
282 protected void uninstallListeners( )
283 {
284 if ( dockingListener != null )
285 {
286 toolBar.removeMouseMotionListener(dockingListener);
287 toolBar.removeMouseListener(dockingListener);
288
289 dockingListener = null;
290 }
291
292 if ( propertyListener != null )
293 {
294 toolBar.removePropertyChangeListener(propertyListener);
295 propertyListener = null; // removed in setFloating
296 }
297
298 if ( toolBarContListener != null )
299 {
300 toolBar.removeContainerListener( toolBarContListener );
301 toolBarContListener = null;
302 }
303
304 if ( toolBarFocusListener != null )
305 {
306 // Remove focus listener from all components in toolbar
307 Component[] components = toolBar.getComponents();
308
309 for (Component component : components) {
310 component.removeFocusListener(toolBarFocusListener);
311 }
312
313 toolBarFocusListener = null;
314 }
315 handler = null;
316 }
317
318 protected void installKeyboardActions( )
319 {
320 InputMap km = getInputMap(JComponent.
321 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
322
323 SwingUtilities.replaceUIInputMap(toolBar, JComponent.
324 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
325 km);
326
327 LazyActionMap.installLazyActionMap(toolBar, BasicToolBarUI.class,
328 "ToolBar.actionMap");
329 }
330
331 InputMap getInputMap(int condition) {
332 if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {
333 return (InputMap)DefaultLookup.get(toolBar, this,
334 "ToolBar.ancestorInputMap");
335 }
336 return null;
337 }
338
339 static void loadActionMap(LazyActionMap map) {
340 map.put(new Actions(Actions.NAVIGATE_RIGHT));
341 map.put(new Actions(Actions.NAVIGATE_LEFT));
342 map.put(new Actions(Actions.NAVIGATE_UP));
343 map.put(new Actions(Actions.NAVIGATE_DOWN));
344 }
345
346 protected void uninstallKeyboardActions( )
347 {
348 SwingUtilities.replaceUIActionMap(toolBar, null);
349 SwingUtilities.replaceUIInputMap(toolBar, JComponent.
350 WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
351 null);
352 }
353
354 protected void navigateFocusedComp( int direction )
355 {
356 int nComp = toolBar.getComponentCount();
357 int j;
358
359 switch ( direction )
360 {
361 case EAST:
362 case SOUTH:
363
364 if ( focusedCompIndex < 0 || focusedCompIndex >= nComp ) break;
365
366 j = focusedCompIndex + 1;
367
368 while ( j != focusedCompIndex )
369 {
370 if ( j >= nComp ) j = 0;
371 Component comp = toolBar.getComponentAtIndex( j++ );
372
373 if ( comp != null && comp.isFocusTraversable() && comp.isEnabled() )
374 {
375 comp.requestFocus();
376 break;
377 }
378 }
379
380 break;
381
382 case WEST:
383 case NORTH:
384
385 if ( focusedCompIndex < 0 || focusedCompIndex >= nComp ) break;
386
387 j = focusedCompIndex - 1;
388
389 while ( j != focusedCompIndex )
390 {
391 if ( j < 0 ) j = nComp - 1;
392 Component comp = toolBar.getComponentAtIndex( j-- );
393
394 if ( comp != null && comp.isFocusTraversable() && comp.isEnabled() )
395 {
396 comp.requestFocus();
397 break;
398 }
399 }
400
401 break;
402
403 default:
404 break;
405 }
406 }
407
408 /**
409 * Creates a rollover border for toolbar components. The
410 * rollover border will be installed if rollover borders are
411 * enabled.
412 * <p>
413 * Override this method to provide an alternate rollover border.
414 *
415 * @since 1.4
416 */
417 protected Border createRolloverBorder() {
418 Object border = UIManager.get("ToolBar.rolloverBorder");
419 if (border != null) {
420 return (Border)border;
421 }
422 UIDefaults table = UIManager.getLookAndFeelDefaults();
423 return new CompoundBorder(new BasicBorders.RolloverButtonBorder(
424 table.getColor("controlShadow"),
425 table.getColor("controlDkShadow"),
426 table.getColor("controlHighlight"),
427 table.getColor("controlLtHighlight")),
428 new BasicBorders.RolloverMarginBorder());
429 }
430
431 /**
432 * Creates the non rollover border for toolbar components. This
433 * border will be installed as the border for components added
434 * to the toolbar if rollover borders are not enabled.
435 * <p>
436 * Override this method to provide an alternate rollover border.
437 *
438 * @since 1.4
439 */
440 protected Border createNonRolloverBorder() {
441 Object border = UIManager.get("ToolBar.nonrolloverBorder");
442 if (border != null) {
443 return (Border)border;
444 }
445 UIDefaults table = UIManager.getLookAndFeelDefaults();
446 return new CompoundBorder(new BasicBorders.ButtonBorder(
447 table.getColor("Button.shadow"),
448 table.getColor("Button.darkShadow"),
449 table.getColor("Button.light"),
450 table.getColor("Button.highlight")),
451 new BasicBorders.RolloverMarginBorder());
452 }
453
454 /**
455 * Creates a non rollover border for Toggle buttons in the toolbar.
456 */
457 private Border createNonRolloverToggleBorder() {
458 UIDefaults table = UIManager.getLookAndFeelDefaults();
459 return new CompoundBorder(new BasicBorders.RadioButtonBorder(
460 table.getColor("ToggleButton.shadow"),
461 table.getColor("ToggleButton.darkShadow"),
462 table.getColor("ToggleButton.light"),
463 table.getColor("ToggleButton.highlight")),
464 new BasicBorders.RolloverMarginBorder());
465 }
466
467 /**
468 * No longer used, use BasicToolBarUI.createFloatingWindow(JToolBar)
469 * @see #createFloatingWindow
470 */
471 protected JFrame createFloatingFrame(JToolBar toolbar) {
472 Window window = SwingUtilities.getWindowAncestor(toolbar);
473 JFrame frame = new JFrame(toolbar.getName(),
474 (window != null) ? window.getGraphicsConfiguration() : null) {
475 // Override createRootPane() to automatically resize
476 // the frame when contents change
477 protected JRootPane createRootPane() {
478 JRootPane rootPane = new JRootPane() {
479 private boolean packing = false;
480
481 public void validate() {
482 super.validate();
483 if (!packing) {
484 packing = true;
485 pack();
486 packing = false;
487 }
488 }
489 };
490 rootPane.setOpaque(true);
491 return rootPane;
492 }
493 };
494 frame.getRootPane().setName("ToolBar.FloatingFrame");
495 frame.setResizable(false);
496 WindowListener wl = createFrameListener();
497 frame.addWindowListener(wl);
498 return frame;
499 }
500
501 /**
502 * Creates a window which contains the toolbar after it has been
503 * dragged out from its container
504 * @return a <code>RootPaneContainer</code> object, containing the toolbar.
505 * @since 1.4
506 */
507 protected RootPaneContainer createFloatingWindow(JToolBar toolbar) {
508 class ToolBarDialog extends JDialog {
509 public ToolBarDialog(Frame owner, String title, boolean modal) {
510 super(owner, title, modal);
511 }
512
513 public ToolBarDialog(Dialog owner, String title, boolean modal) {
514 super(owner, title, modal);
515 }
516
517 // Override createRootPane() to automatically resize
518 // the frame when contents change
519 protected JRootPane createRootPane() {
520 JRootPane rootPane = new JRootPane() {
521 private boolean packing = false;
522
523 public void validate() {
524 super.validate();
525 if (!packing) {
526 packing = true;
527 pack();
528 packing = false;
529 }
530 }
531 };
532 rootPane.setOpaque(true);
533 return rootPane;
534 }
535 }
536
537 JDialog dialog;
538 Window window = SwingUtilities.getWindowAncestor(toolbar);
539 if (window instanceof Frame) {
540 dialog = new ToolBarDialog((Frame)window, toolbar.getName(), false);
541 } else if (window instanceof Dialog) {
542 dialog = new ToolBarDialog((Dialog)window, toolbar.getName(), false);
543 } else {
544 dialog = new ToolBarDialog((Frame)null, toolbar.getName(), false);
545 }
546
547 dialog.getRootPane().setName("ToolBar.FloatingWindow");
548 dialog.setTitle(toolbar.getName());
549 dialog.setResizable(false);
550 WindowListener wl = createFrameListener();
551 dialog.addWindowListener(wl);
552 return dialog;
553 }
554
555 protected DragWindow createDragWindow(JToolBar toolbar) {
556 Window frame = null;
557 if(toolBar != null) {
558 Container p;
559 for(p = toolBar.getParent() ; p != null && !(p instanceof Window) ;
560 p = p.getParent());
561 if(p != null && p instanceof Window)
562 frame = (Window) p;
563 }
564 if(floatingToolBar == null) {
565 floatingToolBar = createFloatingWindow(toolBar);
566 }
567 if (floatingToolBar instanceof Window) frame = (Window) floatingToolBar;
568 DragWindow dragWindow = new DragWindow(frame);
569 return dragWindow;
570 }
571
572 /**
573 * Returns a flag to determine whether rollover button borders
574 * are enabled.
575 *
576 * @return true if rollover borders are enabled; false otherwise
577 * @see #setRolloverBorders
578 * @since 1.4
579 */
580 public boolean isRolloverBorders() {
581 return rolloverBorders;
582 }
583
584 /**
585 * Sets the flag for enabling rollover borders on the toolbar and it will
586 * also install the apropriate border depending on the state of the flag.
587 *
588 * @param rollover if true, rollover borders are installed.
589 * Otherwise non-rollover borders are installed
590 * @see #isRolloverBorders
591 * @since 1.4
592 */
593 public void setRolloverBorders( boolean rollover ) {
594 rolloverBorders = rollover;
595
596 if ( rolloverBorders ) {
597 installRolloverBorders( toolBar );
598 } else {
599 installNonRolloverBorders( toolBar );
600 }
601 }
602
603 /**
604 * Installs rollover borders on all the child components of the JComponent.
605 * <p>
606 * This is a convenience method to call <code>setBorderToRollover</code>
607 * for each child component.
608 *
609 * @param c container which holds the child components (usally a JToolBar)
610 * @see #setBorderToRollover
611 * @since 1.4
612 */
613 protected void installRolloverBorders ( JComponent c ) {
614 // Put rollover borders on buttons
615 Component[] components = c.getComponents();
616
617 for (Component component : components) {
618 if (component instanceof JComponent) {
619 ((JComponent) component).updateUI();
620 setBorderToRollover(component);
621 }
622 }
623 }
624
625 /**
626 * Installs non-rollover borders on all the child components of the JComponent.
627 * A non-rollover border is the border that is installed on the child component
628 * while it is in the toolbar.
629 * <p>
630 * This is a convenience method to call <code>setBorderToNonRollover</code>
631 * for each child component.
632 *
633 * @param c container which holds the child components (usally a JToolBar)
634 * @see #setBorderToNonRollover
635 * @since 1.4
636 */
637 protected void installNonRolloverBorders ( JComponent c ) {
638 // Put non-rollover borders on buttons. These borders reduce the margin.
639 Component[] components = c.getComponents();
640
641 for (Component component : components) {
642 if (component instanceof JComponent) {
643 ((JComponent) component).updateUI();
644 setBorderToNonRollover(component);
645 }
646 }
647 }
648
649 /**
650 * Installs normal borders on all the child components of the JComponent.
651 * A normal border is the original border that was installed on the child
652 * component before it was added to the toolbar.
653 * <p>
654 * This is a convenience method to call <code>setBorderNormal</code>
655 * for each child component.
656 *
657 * @param c container which holds the child components (usally a JToolBar)
658 * @see #setBorderToNonRollover
659 * @since 1.4
660 */
661 protected void installNormalBorders ( JComponent c ) {
662 // Put back the normal borders on buttons
663 Component[] components = c.getComponents();
664
665 for (Component component : components) {
666 setBorderToNormal(component);
667 }
668 }
669
670 /**
671 * Sets the border of the component to have a rollover border which
672 * was created by <code>createRolloverBorder</code>.
673 *
674 * @param c component which will have a rollover border installed
675 * @see #createRolloverBorder
676 * @since 1.4
677 */
678 protected void setBorderToRollover(Component c) {
679 if (c instanceof AbstractButton) {
680 AbstractButton b = (AbstractButton)c;
681
682 Border border = borderTable.get(b);
683 if (border == null || border instanceof UIResource) {
684 borderTable.put(b, b.getBorder());
685 }
686
687 // Only set the border if its the default border
688 if (b.getBorder() instanceof UIResource) {
689 b.setBorder(getRolloverBorder(b));
690 }
691
692 rolloverTable.put(b, b.isRolloverEnabled()?
693 Boolean.TRUE: Boolean.FALSE);
694 b.setRolloverEnabled(true);
695 }
696 }
697
698 /**
699 * Returns a rollover border for the button.
700 *
701 * @param b the button to calculate the rollover border for
702 * @return the rollover border
703 * @see #setBorderToRollover
704 * @since 1.6
705 */
706 protected Border getRolloverBorder(AbstractButton b) {
707 return rolloverBorder;
708 }
709
710 /**
711 * Sets the border of the component to have a non-rollover border which
712 * was created by <code>createNonRolloverBorder</code>.
713 *
714 * @param c component which will have a non-rollover border installed
715 * @see #createNonRolloverBorder
716 * @since 1.4
717 */
718 protected void setBorderToNonRollover(Component c) {
719 if (c instanceof AbstractButton) {
720 AbstractButton b = (AbstractButton)c;
721
722 Border border = borderTable.get(b);
723 if (border == null || border instanceof UIResource) {
724 borderTable.put(b, b.getBorder());
725 }
726
727 // Only set the border if its the default border
728 if (b.getBorder() instanceof UIResource) {
729 b.setBorder(getNonRolloverBorder(b));
730 }
731 rolloverTable.put(b, b.isRolloverEnabled()?
732 Boolean.TRUE: Boolean.FALSE);
733 b.setRolloverEnabled(false);
734 }
735 }
736
737 /**
738 * Returns a non-rollover border for the button.
739 *
740 * @param b the button to calculate the non-rollover border for
741 * @return the non-rollover border
742 * @see #setBorderToNonRollover
743 * @since 1.6
744 */
745 protected Border getNonRolloverBorder(AbstractButton b) {
746 if (b instanceof JToggleButton) {
747 return nonRolloverToggleBorder;
748 } else {
749 return nonRolloverBorder;
750 }
751 }
752
753 /**
754 * Sets the border of the component to have a normal border.
755 * A normal border is the original border that was installed on the child
756 * component before it was added to the toolbar.
757 *
758 * @param c component which will have a normal border re-installed
759 * @see #createNonRolloverBorder
760 * @since 1.4
761 */
762 protected void setBorderToNormal(Component c) {
763 if (c instanceof AbstractButton) {
764 AbstractButton b = (AbstractButton)c;
765
766 Border border = borderTable.remove(b);
767 b.setBorder(border);
768
769 Boolean value = rolloverTable.remove(b);
770 if (value != null) {
771 b.setRolloverEnabled(value.booleanValue());
772 }
773 }
774 }
775
776 public void setFloatingLocation(int x, int y) {
777 floatingX = x;
778 floatingY = y;
779 }
780
781 public boolean isFloating() {
782 return floating;
783 }
784
785 public void setFloating(boolean b, Point p) {
786 if (toolBar.isFloatable()) {
787 boolean visible = false;
788 Window ancestor = SwingUtilities.getWindowAncestor(toolBar);
789 if (ancestor != null) {
790 visible = ancestor.isVisible();
791 }
792 if (dragWindow != null)
793 dragWindow.setVisible(false);
794 this.floating = b;
795 if (floatingToolBar == null) {
796 floatingToolBar = createFloatingWindow(toolBar);
797 }
798 if (b == true)
799 {
800 if (dockingSource == null)
801 {
802 dockingSource = toolBar.getParent();
803 dockingSource.remove(toolBar);
804 }
805 constraintBeforeFloating = calculateConstraint();
806 if ( propertyListener != null )
807 UIManager.addPropertyChangeListener( propertyListener );
808 floatingToolBar.getContentPane().add(toolBar,BorderLayout.CENTER);
809 if (floatingToolBar instanceof Window) {
810 ((Window)floatingToolBar).pack();
811 ((Window)floatingToolBar).setLocation(floatingX, floatingY);
812 if (visible) {
813 ((Window)floatingToolBar).show();
814 } else {
815 ancestor.addWindowListener(new WindowAdapter() {
816 public void windowOpened(WindowEvent e) {
817 ((Window)floatingToolBar).show();
818 }
819 });
820 }
821 }
822 } else {
823 if (floatingToolBar == null)
824 floatingToolBar = createFloatingWindow(toolBar);
825 if (floatingToolBar instanceof Window) ((Window)floatingToolBar).setVisible(false);
826 floatingToolBar.getContentPane().remove(toolBar);
827 String constraint = getDockingConstraint(dockingSource,
828 p);
829 if (constraint == null) {
830 constraint = BorderLayout.NORTH;
831 }
832 int orientation = mapConstraintToOrientation(constraint);
833 setOrientation(orientation);
834 if (dockingSource== null)
835 dockingSource = toolBar.getParent();
836 if ( propertyListener != null )
837 UIManager.removePropertyChangeListener( propertyListener );
838 dockingSource.add(constraint, toolBar);
839 }
840 dockingSource.invalidate();
841 Container dockingSourceParent = dockingSource.getParent();
842 if (dockingSourceParent != null)
843 dockingSourceParent.validate();
844 dockingSource.repaint();
845 }
846 }
847
848 private int mapConstraintToOrientation(String constraint)
849 {
850 int orientation = toolBar.getOrientation();
851
852 if ( constraint != null )
853 {
854 if ( constraint.equals(BorderLayout.EAST) || constraint.equals(BorderLayout.WEST) )
855 orientation = JToolBar.VERTICAL;
856 else if ( constraint.equals(BorderLayout.NORTH) || constraint.equals(BorderLayout.SOUTH) )
857 orientation = JToolBar.HORIZONTAL;
858 }
859
860 return orientation;
861 }
862
863 public void setOrientation(int orientation)
864 {
865 toolBar.setOrientation( orientation );
866
867 if (dragWindow !=null)
868 dragWindow.setOrientation(orientation);
869 }
870
871 /**
872 * Gets the color displayed when over a docking area
873 */
874 public Color getDockingColor() {
875 return dockingColor;
876 }
877
878 /**
879 * Sets the color displayed when over a docking area
880 */
881 public void setDockingColor(Color c) {
882 this.dockingColor = c;
883 }
884
885 /**
886 * Gets the color displayed when over a floating area
887 */
888 public Color getFloatingColor() {
889 return floatingColor;
890 }
891
892 /**
893 * Sets the color displayed when over a floating area
894 */
895 public void setFloatingColor(Color c) {
896 this.floatingColor = c;
897 }
898
899 private boolean isBlocked(Component comp, Object constraint) {
900 if (comp instanceof Container) {
901 Container cont = (Container)comp;
902 LayoutManager lm = cont.getLayout();
903 if (lm instanceof BorderLayout) {
904 BorderLayout blm = (BorderLayout)lm;
905 Component c = blm.getLayoutComponent(cont, constraint);
906 return (c != null && c != toolBar);
907 }
908 }
909 return false;
910 }
911
912 public boolean canDock(Component c, Point p) {
913 return (p != null && getDockingConstraint(c, p) != null);
914 }
915
916 private String calculateConstraint() {
917 String constraint = null;
918 LayoutManager lm = dockingSource.getLayout();
919 if (lm instanceof BorderLayout) {
920 constraint = (String)((BorderLayout)lm).getConstraints(toolBar);
921 }
922 return (constraint != null) ? constraint : constraintBeforeFloating;
923 }
924
925
926
927 private String getDockingConstraint(Component c, Point p) {
928 if (p == null) return constraintBeforeFloating;
929 if (c.contains(p)) {
930 dockingSensitivity = (toolBar.getOrientation() == JToolBar.HORIZONTAL)
931 ? toolBar.getSize().height
932 : toolBar.getSize().width;
933 // North (Base distance on height for now!)
934 if (p.y < dockingSensitivity && !isBlocked(c, BorderLayout.NORTH)) {
935 return BorderLayout.NORTH;
936 }
937 // East (Base distance on height for now!)
938 if (p.x >= c.getWidth() - dockingSensitivity && !isBlocked(c, BorderLayout.EAST)) {
939 return BorderLayout.EAST;
940 }
941 // West (Base distance on height for now!)
942 if (p.x < dockingSensitivity && !isBlocked(c, BorderLayout.WEST)) {
943 return BorderLayout.WEST;
944 }
945 if (p.y >= c.getHeight() - dockingSensitivity && !isBlocked(c, BorderLayout.SOUTH)) {
946 return BorderLayout.SOUTH;
947 }
948 }
949 return null;
950 }
951
952 protected void dragTo(Point position, Point origin)
953 {
954 if (toolBar.isFloatable())
955 {
956 try
957 {
958 if (dragWindow == null)
959 dragWindow = createDragWindow(toolBar);
960 Point offset = dragWindow.getOffset();
961 if (offset == null) {
962 Dimension size = toolBar.getPreferredSize();
963 offset = new Point(size.width/2, size.height/2);
964 dragWindow.setOffset(offset);
965 }
966 Point global = new Point(origin.x+ position.x,
967 origin.y+position.y);
968 Point dragPoint = new Point(global.x- offset.x,
969 global.y- offset.y);
970 if (dockingSource == null)
971 dockingSource = toolBar.getParent();
972 constraintBeforeFloating = calculateConstraint();
973 Point dockingPosition = dockingSource.getLocationOnScreen();
974 Point comparisonPoint = new Point(global.x-dockingPosition.x,
975 global.y-dockingPosition.y);
976 if (canDock(dockingSource, comparisonPoint)) {
977 dragWindow.setBackground(getDockingColor());
978 String constraint = getDockingConstraint(dockingSource,
979 comparisonPoint);
980 int orientation = mapConstraintToOrientation(constraint);
981 dragWindow.setOrientation(orientation);
982 dragWindow.setBorderColor(dockingBorderColor);
983 } else {
984 dragWindow.setBackground(getFloatingColor());
985 dragWindow.setBorderColor(floatingBorderColor);
986 dragWindow.setOrientation(toolBar.getOrientation());
987 }
988
989 dragWindow.setLocation(dragPoint.x, dragPoint.y);
990 if (dragWindow.isVisible() == false) {
991 Dimension size = toolBar.getPreferredSize();
992 dragWindow.setSize(size.width, size.height);
993 dragWindow.show();
994 }
995 }
996 catch ( IllegalComponentStateException e )
997 {
998 }
999 }
1000 }
1001
1002 protected void floatAt(Point position, Point origin)
1003 {
1004 if(toolBar.isFloatable())
1005 {
1006 try
1007 {
1008 Point offset = dragWindow.getOffset();
1009 if (offset == null) {
1010 offset = position;
1011 dragWindow.setOffset(offset);
1012 }
1013 Point global = new Point(origin.x+ position.x,
1014 origin.y+position.y);
1015 setFloatingLocation(global.x-offset.x,
1016 global.y-offset.y);
1017 if (dockingSource != null) {
1018 Point dockingPosition = dockingSource.getLocationOnScreen();
1019 Point comparisonPoint = new Point(global.x-dockingPosition.x,
1020 global.y-dockingPosition.y);
1021 if (canDock(dockingSource, comparisonPoint)) {
1022 setFloating(false, comparisonPoint);
1023 } else {
1024 setFloating(true, null);
1025 }
1026 } else {
1027 setFloating(true, null);
1028 }
1029 dragWindow.setOffset(null);
1030 }
1031 catch ( IllegalComponentStateException e )
1032 {
1033 }
1034 }
1035 }
1036
1037 private Handler getHandler() {
1038 if (handler == null) {
1039 handler = new Handler();
1040 }
1041 return handler;
1042 }
1043
1044 protected ContainerListener createToolBarContListener( )
1045 {
1046 return getHandler();
1047 }
1048
1049 protected FocusListener createToolBarFocusListener( )
1050 {
1051 return getHandler();
1052 }
1053
1054 protected PropertyChangeListener createPropertyListener()
1055 {
1056 return getHandler();
1057 }
1058
1059 protected MouseInputListener createDockingListener( ) {
1060 getHandler().tb = toolBar;
1061 return getHandler();
1062 }
1063
1064 protected WindowListener createFrameListener() {
1065 return new FrameListener();
1066 }
1067
1068 /**
1069 * Paints the contents of the window used for dragging.
1070 *
1071 * @param g Graphics to paint to.
1072 * @throws NullPointerException is <code>g</code> is null
1073 * @since 1.5
1074 */
1075 protected void paintDragWindow(Graphics g) {
1076 g.setColor(dragWindow.getBackground());
1077 int w = dragWindow.getWidth();
1078 int h = dragWindow.getHeight();
1079 g.fillRect(0, 0, w, h);
1080 g.setColor(dragWindow.getBorderColor());
1081 g.drawRect(0, 0, w - 1, h - 1);
1082 }
1083
1084
1085 private static class Actions extends UIAction {
1086 private static final String NAVIGATE_RIGHT = "navigateRight";
1087 private static final String NAVIGATE_LEFT = "navigateLeft";
1088 private static final String NAVIGATE_UP = "navigateUp";
1089 private static final String NAVIGATE_DOWN = "navigateDown";
1090
1091 public Actions(String name) {
1092 super(name);
1093 }
1094
1095 public void actionPerformed(ActionEvent evt) {
1096 String key = getName();
1097 JToolBar toolBar = (JToolBar)evt.getSource();
1098 BasicToolBarUI ui = (BasicToolBarUI)BasicLookAndFeel.getUIOfType(
1099 toolBar.getUI(), BasicToolBarUI.class);
1100
1101 if (NAVIGATE_RIGHT == key) {
1102 ui.navigateFocusedComp(EAST);
1103 } else if (NAVIGATE_LEFT == key) {
1104 ui.navigateFocusedComp(WEST);
1105 } else if (NAVIGATE_UP == key) {
1106 ui.navigateFocusedComp(NORTH);
1107 } else if (NAVIGATE_DOWN == key) {
1108 ui.navigateFocusedComp(SOUTH);
1109 }
1110 }
1111 }
1112
1113
1114 private class Handler implements ContainerListener,
1115 FocusListener, MouseInputListener, PropertyChangeListener {
1116
1117 //
1118 // ContainerListener
1119 //
1120 public void componentAdded(ContainerEvent evt) {
1121 Component c = evt.getChild();
1122
1123 if (toolBarFocusListener != null) {
1124 c.addFocusListener(toolBarFocusListener);
1125 }
1126
1127 if (isRolloverBorders()) {
1128 setBorderToRollover(c);
1129 } else {
1130 setBorderToNonRollover(c);
1131 }
1132 }
1133
1134 public void componentRemoved(ContainerEvent evt) {
1135 Component c = evt.getChild();
1136
1137 if (toolBarFocusListener != null) {
1138 c.removeFocusListener(toolBarFocusListener);
1139 }
1140
1141 // Revert the button border
1142 setBorderToNormal(c);
1143 }
1144
1145
1146 //
1147 // FocusListener
1148 //
1149 public void focusGained(FocusEvent evt) {
1150 Component c = evt.getComponent();
1151 focusedCompIndex = toolBar.getComponentIndex(c);
1152 }
1153
1154 public void focusLost(FocusEvent evt) { }
1155
1156
1157 //
1158 // MouseInputListener (DockingListener)
1159 //
1160 JToolBar tb;
1161 boolean isDragging = false;
1162 Point origin = null;
1163
1164 public void mousePressed(MouseEvent evt) {
1165 if (!tb.isEnabled()) {
1166 return;
1167 }
1168 isDragging = false;
1169 }
1170
1171 public void mouseReleased(MouseEvent evt) {
1172 if (!tb.isEnabled()) {
1173 return;
1174 }
1175 if (isDragging) {
1176 Point position = evt.getPoint();
1177 if (origin == null)
1178 origin = evt.getComponent().getLocationOnScreen();
1179 floatAt(position, origin);
1180 }
1181 origin = null;
1182 isDragging = false;
1183 }
1184
1185 public void mouseDragged(MouseEvent evt) {
1186 if (!tb.isEnabled()) {
1187 return;
1188 }
1189 isDragging = true;
1190 Point position = evt.getPoint();
1191 if (origin == null) {
1192 origin = evt.getComponent().getLocationOnScreen();
1193 }
1194 dragTo(position, origin);
1195 }
1196
1197 public void mouseClicked(MouseEvent evt) {}
1198 public void mouseEntered(MouseEvent evt) {}
1199 public void mouseExited(MouseEvent evt) {}
1200 public void mouseMoved(MouseEvent evt) {}
1201
1202
1203 //
1204 // PropertyChangeListener
1205 //
1206 public void propertyChange(PropertyChangeEvent evt) {
1207 String propertyName = evt.getPropertyName();
1208 if (propertyName == "lookAndFeel") {
1209 toolBar.updateUI();
1210 } else if (propertyName == "orientation") {
1211 // Search for JSeparator components and change it's orientation
1212 // to match the toolbar and flip it's orientation.
1213 Component[] components = toolBar.getComponents();
1214 int orientation = ((Integer)evt.getNewValue()).intValue();
1215 JToolBar.Separator separator;
1216
1217 for (int i = 0; i < components.length; ++i) {
1218 if (components[i] instanceof JToolBar.Separator) {
1219 separator = (JToolBar.Separator)components[i];
1220 if ((orientation == JToolBar.HORIZONTAL)) {
1221 separator.setOrientation(JSeparator.VERTICAL);
1222 } else {
1223 separator.setOrientation(JSeparator.HORIZONTAL);
1224 }
1225 Dimension size = separator.getSeparatorSize();
1226 if (size != null && size.width != size.height) {
1227 // Flip the orientation.
1228 Dimension newSize =
1229 new Dimension(size.height, size.width);
1230 separator.setSeparatorSize(newSize);
1231 }
1232 }
1233 }
1234 } else if (propertyName == IS_ROLLOVER) {
1235 installNormalBorders(toolBar);
1236 setRolloverBorders(((Boolean)evt.getNewValue()).booleanValue());
1237 }
1238 }
1239 }
1240
1241 protected class FrameListener extends WindowAdapter {
1242 public void windowClosing(WindowEvent w) {
1243 if (toolBar.isFloatable()) {
1244 if (dragWindow != null)
1245 dragWindow.setVisible(false);
1246 floating = false;
1247 if (floatingToolBar == null)
1248 floatingToolBar = createFloatingWindow(toolBar);
1249 if (floatingToolBar instanceof Window) ((Window)floatingToolBar).setVisible(false);
1250 floatingToolBar.getContentPane().remove(toolBar);
1251 String constraint = constraintBeforeFloating;
1252 if (toolBar.getOrientation() == JToolBar.HORIZONTAL) {
1253 if (constraint == "West" || constraint == "East") {
1254 constraint = "North";
1255 }
1256 } else {
1257 if (constraint == "North" || constraint == "South") {
1258 constraint = "West";
1259 }
1260 }
1261 if (dockingSource == null)
1262 dockingSource = toolBar.getParent();
1263 if (propertyListener != null)
1264 UIManager.removePropertyChangeListener(propertyListener);
1265 dockingSource.add(toolBar, constraint);
1266 dockingSource.invalidate();
1267 Container dockingSourceParent = dockingSource.getParent();
1268 if (dockingSourceParent != null)
1269 dockingSourceParent.validate();
1270 dockingSource.repaint();
1271 }
1272 }
1273
1274 }
1275
1276 protected class ToolBarContListener implements ContainerListener {
1277 // NOTE: This class exists only for backward compatability. All
1278 // its functionality has been moved into Handler. If you need to add
1279 // new functionality add it to the Handler, but make sure this
1280 // class calls into the Handler.
1281 public void componentAdded( ContainerEvent e ) {
1282 getHandler().componentAdded(e);
1283 }
1284
1285 public void componentRemoved( ContainerEvent e ) {
1286 getHandler().componentRemoved(e);
1287 }
1288
1289 }
1290
1291 protected class ToolBarFocusListener implements FocusListener {
1292 // NOTE: This class exists only for backward compatability. All
1293 // its functionality has been moved into Handler. If you need to add
1294 // new functionality add it to the Handler, but make sure this
1295 // class calls into the Handler.
1296 public void focusGained( FocusEvent e ) {
1297 getHandler().focusGained(e);
1298 }
1299
1300 public void focusLost( FocusEvent e ) {
1301 getHandler().focusLost(e);
1302 }
1303 }
1304
1305 protected class PropertyListener implements PropertyChangeListener {
1306 // NOTE: This class exists only for backward compatability. All
1307 // its functionality has been moved into Handler. If you need to add
1308 // new functionality add it to the Handler, but make sure this
1309 // class calls into the Handler.
1310 public void propertyChange( PropertyChangeEvent e ) {
1311 getHandler().propertyChange(e);
1312 }
1313 }
1314
1315 /**
1316 * This class should be treated as a "protected" inner class.
1317 * Instantiate it only within subclasses of BasicToolBarUI.
1318 */
1319 public class DockingListener implements MouseInputListener {
1320 // NOTE: This class exists only for backward compatability. All
1321 // its functionality has been moved into Handler. If you need to add
1322 // new functionality add it to the Handler, but make sure this
1323 // class calls into the Handler.
1324 protected JToolBar toolBar;
1325 protected boolean isDragging = false;
1326 protected Point origin = null;
1327
1328 public DockingListener(JToolBar t) {
1329 this.toolBar = t;
1330 getHandler().tb = t;
1331 }
1332
1333 public void mouseClicked(MouseEvent e) {
1334 getHandler().mouseClicked(e);
1335 }
1336
1337 public void mousePressed(MouseEvent e) {
1338 getHandler().tb = toolBar;
1339 getHandler().mousePressed(e);
1340 isDragging = getHandler().isDragging;
1341 }
1342
1343 public void mouseReleased(MouseEvent e) {
1344 getHandler().tb = toolBar;
1345 getHandler().isDragging = isDragging;
1346 getHandler().origin = origin;
1347 getHandler().mouseReleased(e);
1348 isDragging = getHandler().isDragging;
1349 origin = getHandler().origin;
1350 }
1351
1352 public void mouseEntered(MouseEvent e) {
1353 getHandler().mouseEntered(e);
1354 }
1355
1356 public void mouseExited(MouseEvent e) {
1357 getHandler().mouseExited(e);
1358 }
1359
1360 public void mouseDragged(MouseEvent e) {
1361 getHandler().tb = toolBar;
1362 getHandler().origin = origin;
1363 getHandler().mouseDragged(e);
1364 isDragging = getHandler().isDragging;
1365 origin = getHandler().origin;
1366 }
1367
1368 public void mouseMoved(MouseEvent e) {
1369 getHandler().mouseMoved(e);
1370 }
1371 }
1372
1373 protected class DragWindow extends Window
1374 {
1375 Color borderColor = Color.gray;
1376 int orientation = toolBar.getOrientation();
1377 Point offset; // offset of the mouse cursor inside the DragWindow
1378
1379 DragWindow(Window w) {
1380 super(w);
1381 }
1382
1383 /**
1384 * Returns the orientation of the toolbar window when the toolbar is
1385 * floating. The orientation is either one of <code>JToolBar.HORIZONTAL</code>
1386 * or <code>JToolBar.VERTICAL</code>.
1387 *
1388 * @return the orientation of the toolbar window
1389 * @since 1.6
1390 */
1391 public int getOrientation() {
1392 return orientation;
1393 }
1394
1395 public void setOrientation(int o) {
1396 if(isShowing()) {
1397 if (o == this.orientation)
1398 return;
1399 this.orientation = o;
1400 Dimension size = getSize();
1401 setSize(new Dimension(size.height, size.width));
1402 if (offset!=null) {
1403 if( BasicGraphicsUtils.isLeftToRight(toolBar) ) {
1404 setOffset(new Point(offset.y, offset.x));
1405 } else if( o == JToolBar.HORIZONTAL ) {
1406 setOffset(new Point( size.height-offset.y, offset.x));
1407 } else {
1408 setOffset(new Point(offset.y, size.width-offset.x));
1409 }
1410 }
1411 repaint();
1412 }
1413 }
1414
1415 public Point getOffset() {
1416 return offset;
1417 }
1418
1419 public void setOffset(Point p) {
1420 this.offset = p;
1421 }
1422
1423 public void setBorderColor(Color c) {
1424 if (this.borderColor == c)
1425 return;
1426 this.borderColor = c;
1427 repaint();
1428 }
1429
1430 public Color getBorderColor() {
1431 return this.borderColor;
1432 }
1433
1434 public void paint(Graphics g) {
1435 paintDragWindow(g);
1436 // Paint the children
1437 super.paint(g);
1438 }
1439 public Insets getInsets() {
1440 return new Insets(1,1,1,1);
1441 }
1442 }
1443 }