Debian Codegraph @

laf-widget/src/main/java/org/pushingpixels/lafwidget/tabbed/TabOverviewDialog.java

raw
1 /*
2 * Copyright (c) 2005-2010 Laf-Widget Kirill Grouchnikov. All Rights Reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * o Redistributions of source code must retain the above copyright notice,
8 * this list of conditions and the following disclaimer.
9 *
10 * o Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 *
14 * o Neither the name of Laf-Widget Kirill Grouchnikov nor the names of
15 * its contributors may be used to endorse or promote products derived
16 * from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
22 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
28 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30 package org.pushingpixels.lafwidget.tabbed;
31
32 import java.awt.*;
33 import java.awt.event.*;
34 import java.awt.image.BufferedImage;
35 import java.beans.PropertyChangeEvent;
36 import java.beans.PropertyChangeListener;
37 import java.text.MessageFormat;
38
39 import javax.swing.*;
40 import javax.swing.border.*;
41
42 import org.pushingpixels.lafwidget.*;
43 import org.pushingpixels.lafwidget.animation.AnimationConfigurationManager;
44 import org.pushingpixels.lafwidget.contrib.blogofbug.swing.components.*;
45 import org.pushingpixels.lafwidget.tabbed.TabPreviewThread.TabPreviewInfo;
46 import org.pushingpixels.lafwidget.utils.ShadowPopupBorder;
47 import org.pushingpixels.lafwidget.utils.LafConstants.TabOverviewKind;
48 import org.pushingpixels.trident.Timeline;
49 import org.pushingpixels.trident.Timeline.TimelineState;
50 import org.pushingpixels.trident.callback.UIThreadTimelineCallbackAdapter;
51 import org.pushingpixels.trident.swing.SwingRepaintCallback;
52
53 /**
54 * Tab overview dialog.
55 *
56 * @author Kirill Grouchnikov
57 */
58 public class TabOverviewDialog extends JDialog {
59 /**
60 * The associated tabbed pane.
61 */
62 protected JTabbedPane tabPane;
63
64 // /**
65 // * The grid overview panel (with all thumbnails).
66 // */
67 // protected JPanel gridOverviewPanel;
68
69 /**
70 * The associated preview callback.
71 */
72 protected TabPreviewThread.TabPreviewCallback previewCallback;
73
74 /**
75 * Listener on LAF switches.
76 */
77 protected PropertyChangeListener lafSwitchListener;
78
79 /**
80 * Handles mouse events on the tab overview dialog (such as highlighting the
81 * currently rolled-over tab preview, closing the overview when a tab
82 * preview is clicked, tooltips etc.)
83 *
84 * @author Kirill Grouchnikov
85 */
86 protected class TabPreviewMouseHandler extends MouseAdapter {
87 /**
88 * Tab index.
89 */
90 private int index;
91
92 /**
93 * Tab preview control.
94 */
95 private JComponent previewControl;
96
97 /**
98 * If <code>true</code>, the preview uses double click to select the tab
99 * and dismiss the tab overview dialog.
100 */
101 private boolean useDoubleClick;
102
103 /**
104 * If <code>true</code>, the tab preview controls have rollover effects
105 * on borders.
106 */
107 private boolean hasRolloverBorderEffect;
108
109 /**
110 * Creates the mouse handler for a single tab preview control.
111 *
112 * @param index
113 * Tab index.
114 * @param previewControl
115 * Tab preview control.
116 * @param hasRolloverBorderEffect
117 * If <code>true</code>, the preview uses double click to
118 * select the tab and dismiss the tab overview dialog.
119 * @param useDoubleClick
120 * If <code>true</code>, the tab preview controls have
121 * rollover effects on borders.
122 */
123 public TabPreviewMouseHandler(int index, JComponent previewControl,
124 boolean hasRolloverBorderEffect, boolean useDoubleClick) {
125 this.index = index;
126 this.previewControl = previewControl;
127 this.useDoubleClick = useDoubleClick;
128 this.hasRolloverBorderEffect = hasRolloverBorderEffect;
129 }
130
131 @Override
132 public void mouseClicked(MouseEvent e) {
133 if (this.useDoubleClick) {
134 if (e.getClickCount() < 2)
135 return;
136 }
137
138 SwingUtilities.invokeLater(new Runnable() {
139 @Override
140 public void run() {
141 TabOverviewDialog.this.dispose();
142 TabOverviewDialog.this.tabPane
143 .setSelectedIndex(TabPreviewMouseHandler.this.index);
144 }
145 });
146 }
147
148 @Override
149 public void mouseEntered(MouseEvent e) {
150 if (!this.hasRolloverBorderEffect)
151 return;
152 boolean isSelected = (TabOverviewDialog.this.tabPane
153 .getSelectedIndex() == this.index);
154 Border innerBorder = isSelected ? new LineBorder(Color.blue, 2)
155 : new LineBorder(Color.black, 1);
156 this.previewControl.setBorder(new CompoundBorder(
157 new ShadowPopupBorder(), innerBorder));
158 // if (isSelected)
159 // this.previewControl.setBorder(new LineBorder(Color.blue, 2));
160 // else
161 // this.previewControl.setBorder(new CompoundBorder(
162 // new EmptyBorder(1, 1, 1, 1), new LineBorder(
163 // Color.black, 1)));
164 }
165
166 @Override
167 public void mouseExited(MouseEvent e) {
168 if (!this.hasRolloverBorderEffect)
169 return;
170 boolean isSelected = (TabOverviewDialog.this.tabPane
171 .getSelectedIndex() == this.index);
172 Border innerBorder = isSelected ? new LineBorder(Color.black, 2)
173 : new LineBorder(Color.black, 1);
174 this.previewControl.setBorder(new CompoundBorder(
175 new ShadowPopupBorder(), innerBorder));
176 // if (isSelected)
177 // this.previewControl.setBorder(new LineBorder(Color.black, 2));
178 // else
179 // this.previewControl.setBorder(new CompoundBorder(
180 // new EmptyBorder(1, 1, 1, 1), new LineBorder(
181 // Color.black, 1)));
182 }
183 }
184
185 /**
186 * Tab round carousel overview panel. Contains a round carousel of tab
187 * preview widgets. The widgets are created in a separate thread (
188 * {@link TabPreviewThread}) and offered to the tab overview dialog via the
189 * registered implementation of {@link TabPreviewThread.TabPreviewCallback}.
190 * This way the application stays interactive while the tab overview dialog
191 * is being populated.
192 *
193 * @author Kirill Grouchnikov
194 */
195 protected class TabRoundCarouselOverviewPanel extends JPanel {
196 /**
197 * Tab preview controls.
198 */
199 protected ReflectedImageLabel[] previewControls;
200
201 /**
202 * Width of a single tab preview control.
203 */
204 protected int pWidth;
205
206 /**
207 * Height of a single tab preview control.
208 */
209 protected int pHeight;
210
211 /**
212 * Associated carousel.
213 */
214 protected JCarosel carosel;
215
216 /**
217 * Creates a tab overview panel.
218 *
219 * @param dialogWidth
220 * The width of the parent dialog.
221 * @param dialogHeight
222 * The height of the parent dialog.
223 */
224 public TabRoundCarouselOverviewPanel(final int dialogWidth,
225 final int dialogHeight) {
226 // int tabCount = TabOverviewDialog.this.tabPane.getTabCount();
227
228 // this.previewControls = new HashSet<Component>();
229 TabPreviewThread.TabPreviewCallback previewCallback = new TabPreviewThread.TabPreviewCallback() {
230 /*
231 * (non-Javadoc)
232 *
233 * @seeorg.pushingpixels.lafwidget.tabbed.TabPreviewThread.
234 * TabPreviewCallback#start(javax.swing.JTabbedPane, int,
235 * org.pushingpixels
236 * .lafwidget.tabbed.TabPreviewThread.TabPreviewInfo)
237 */
238 @Override
239 public void start(JTabbedPane tabPane, int tabCount,
240 TabPreviewInfo tabPreviewInfo) {
241 // Check if need to reallocate the preview controls.
242 boolean isSame = (previewControls != null)
243 && (previewControls.length == tabCount);
244 if (isSame)
245 return;
246
247 if (previewControls != null) {
248 for (int i = 0; i < previewControls.length; i++) {
249 carosel.remove(previewControls[i]);
250 }
251 }
252
253 double coef = Math.min(3.5, tabCount / 1.5);
254 coef = Math.max(coef, 4.5);
255 pWidth = (int) (dialogWidth / coef);
256 pHeight = (int) (dialogHeight / coef);
257
258 tabPreviewInfo.setPreviewWidth(pWidth - 4);
259 tabPreviewInfo.setPreviewHeight(pHeight - 4);
260
261 previewControls = new ReflectedImageLabel[tabCount];
262 TabPreviewPainter tpp = LafWidgetUtilities2
263 .getTabPreviewPainter(TabOverviewDialog.this.tabPane);
264 for (int i = 0; i < tabCount; i++) {
265 BufferedImage placeHolder = new BufferedImage(pWidth,
266 pHeight, BufferedImage.TYPE_INT_ARGB);
267 Graphics2D g2d = (Graphics2D) placeHolder.getGraphics();
268 g2d.setColor(UIManager.getColor("Label.background"));
269 g2d.fillRect(0, 0, pWidth, pHeight);
270 ReflectedImageLabel ril = (ReflectedImageLabel) carosel
271 .add(placeHolder, tabPane.getTitleAt(i));
272 ril.setForeground(UIManager
273 .getColor("Label.foreground"));
274 ril.setBackground(UIManager
275 .getColor("Label.background"));
276 // TabPreviewControl previewControl = new
277 // TabPreviewControl(
278 // TabOverviewDialog.this.tabPane, i);
279 ril.setPreferredSize(new Dimension(pWidth, pHeight));
280 // fix for issue 177 in Substance (disallowing
281 // selection
282 // of disabled tabs).
283 if (tpp.isSensitiveToEvents(
284 TabOverviewDialog.this.tabPane, i)) {
285 ril.addMouseListener(new TabPreviewMouseHandler(i,
286 ril, false, true));
287 ril
288 .setToolTipText(LafWidgetUtilities
289 .getResourceBundle(tabPane)
290 .getString(
291 "TabbedPane.overviewWidgetTooltip"));
292 }
293 previewControls[i] = ril;
294 // carosel.add(previewControl);
295 }
296 carosel.bringToFront(previewControls[tabPane
297 .getSelectedIndex()]);
298 // System.err.println("Added " + previewControls.length
299 // + " labels");
300 // doLayout();
301 // for (int i = 0; i < tabCount; i++) {
302 // previewControls[i].revalidate();
303 // }
304 // repaint();
305 }
306
307 /*
308 * (non-Javadoc)
309 *
310 * @seeorg.pushingpixels.lafwidget.tabbed.TabPreviewThread.
311 * TabPreviewCallback#offer(javax.swing.JTabbedPane, int,
312 * java.awt.image.BufferedImage)
313 */
314 @Override
315 public void offer(JTabbedPane tabPane, int tabIndex,
316 BufferedImage componentSnap) {
317 int width = componentSnap.getWidth() + 4;
318 int height = componentSnap.getHeight() + 4;
319 BufferedImage result = new BufferedImage(width, height,
320 BufferedImage.TYPE_INT_ARGB);
321 Graphics2D g2d = (Graphics2D) result.getGraphics();
322 g2d.setColor(UIManager.getColor("Label.background"));
323 g2d.fillRect(0, 0, width, height);
324 g2d.setColor(UIManager.getColor("Label.foreground"));
325 g2d.drawRect(0, 0, width - 1, height - 1);
326 g2d.drawImage(componentSnap, 2, 2, null);
327
328 Icon tabIcon = tabPane.getIconAt(tabIndex);
329 if (tabIcon != null) {
330 tabIcon.paintIcon(tabPane, g2d, 2, 2);
331 }
332
333 // Component caroselComponent = carosel.add(result, tabPane
334 // .getTitleAt(tabIndex));
335 // caroselComponent.setForeground(UIManager
336 // .getColor("Label.foreground"));
337
338 // System.err.println("Setting image on " + tabIndex);
339 previewControls[tabIndex].setRichImage(result);
340 // System.err.println("Set image on " + tabIndex);
341 previewControls[tabIndex].repaint();
342 // previewControls.add(caroselComponent);
343 // TabRoundCarouselOverviewPanel.this.previewControls[tabIndex]
344 // .setPreviewImage(componentSnap);
345 }
346 };
347
348 this.carosel = new JCarosel();
349 this.carosel.setDepthBasedAlpha(true);
350 // // carosel.setBackground(Color.BLACK, Color.DARK_GRAY);
351 // carosel
352 // .add(
353 // TabOverviewDialog.class
354 // .getResource(
355 // "/contrib/com/blogofbug/examples/images/Acknowledgements.png")
356 // .toString(), "You Rock", 128, 128);
357 // carosel.add(TabOverviewDialog.class.getResource(
358 // "/contrib/com/blogofbug/examples/images/Dock.png")
359 // .toString(), "Docks Rock", 128, 128);
360 // carosel.add(TabOverviewDialog.class.getResource(
361 // "/contrib/com/blogofbug/examples/images/Cascade.png")
362 // .toString(), "Cascade Icon", 128, 128);
363 // carosel.add(TabOverviewDialog.class.getResource(
364 // "/contrib/com/blogofbug/examples/images/Quit.png")
365 // .toString(), "Quit Bugging", 128, 128);
366 this.setLayout(new BorderLayout());
367 this.add(carosel, BorderLayout.CENTER);
368
369 TabPreviewInfo previewInfo = new TabPreviewInfo();
370 previewInfo.tabPane = TabOverviewDialog.this.tabPane;
371 previewInfo.previewCallback = previewCallback;
372 // previewInfo.previewWidth = this.pWidth - 4;
373 // previewInfo.previewHeight = this.pHeight - 20;
374 previewInfo.toPreviewAllTabs = true;
375 previewInfo.initiator = TabOverviewDialog.this;
376
377 TabPreviewThread.getInstance().queueTabPreviewRequest(previewInfo);
378 }
379 }
380
381 /**
382 * Tab menu carousel overview panel. Contains a menu carousel of tab preview
383 * widgets. The widgets are created in a separate thread (
384 * {@link TabPreviewThread}) and offered to the tab overview dialog via the
385 * registered implementation of {@link TabPreviewThread.TabPreviewCallback}.
386 * This way the application stays interactive while the tab overview dialog
387 * is being populated.
388 *
389 * @author Kirill Grouchnikov
390 */
391 protected class TabMenuCarouselOverviewPanel extends JPanel {
392 /**
393 * Tab preview controls.
394 */
395 protected ReflectedImageLabel[] previewControls;
396
397 /**
398 * Width of a single tab preview control.
399 */
400 protected int pWidth;
401
402 /**
403 * Height of a single tab preview control.
404 */
405 protected int pHeight;
406
407 /**
408 * The associated carousel menu.
409 */
410 protected JCarouselMenu caroselMenu;
411
412 /**
413 * Cell renderer for the carosel menu. Employs a little trick to provide
414 * LAF-consistent painting of the cells.
415 *
416 * @author Kirill Grouchnikov
417 */
418 protected class MenuCarouselListCellRenderer extends JLabel implements
419 ListCellRenderer {
420 /**
421 * The cell renderer from the currently installed LAF.
422 */
423 protected ListCellRenderer lafDefaultCellRenderer;
424
425 /**
426 * Creates the cell renderer for the carosel menu.
427 *
428 * @param lafDefaultCellRenderer
429 * The cell renderer from the currently installed LAF.
430 */
431 public MenuCarouselListCellRenderer(
432 ListCellRenderer lafDefaultCellRenderer) {
433 this.lafDefaultCellRenderer = lafDefaultCellRenderer;
434 // if (lafDefaultCellRenderer instanceof Component) {
435 // JComponent jc = (JComponent) lafDefaultCellRenderer;
436 // jc.setBorder(new EmptyBorder(5, 5, 5, 5));
437 // jc.setFont(super.getFont().deriveFont(Font.BOLD, 14.0f));
438 // }
439 }
440
441 /**
442 * Sets up the component for stamping
443 */
444 @Override
445 public Component getListCellRendererComponent(JList jList,
446 Object object, int i, boolean isSelected,
447 boolean cellHasFocus) {
448 JCarouselMenu.MenuItem item = (JCarouselMenu.MenuItem) object;
449 Component result = this.lafDefaultCellRenderer
450 .getListCellRendererComponent(jList, item.getLabel(),
451 i, isSelected, cellHasFocus);
452
453 if (result instanceof Component) {
454 JComponent jc = (JComponent) result;
455 jc.setBorder(new EmptyBorder(5, 5, 5, 5));
456 jc.setFont(super.getFont().deriveFont(Font.BOLD, 14.0f));
457 }
458
459 return result;
460 }
461 }
462
463 /**
464 * Creates a tab overview panel.
465 *
466 * @param dialogWidth
467 * The width of the parent dialog.
468 * @param dialogHeight
469 * The height of the parent dialog.
470 */
471 public TabMenuCarouselOverviewPanel(final int dialogWidth,
472 final int dialogHeight) {
473 // int tabCount = TabOverviewDialog.this.tabPane.getTabCount();
474
475 // this.previewControls = new HashSet<Component>();
476 TabPreviewThread.TabPreviewCallback previewCallback = new TabPreviewThread.TabPreviewCallback() {
477 /*
478 * (non-Javadoc)
479 *
480 * @seeorg.pushingpixels.lafwidget.tabbed.TabPreviewThread.
481 * TabPreviewCallback#start(javax.swing.JTabbedPane, int,
482 * org.pushingpixels
483 * .lafwidget.tabbed.TabPreviewThread.TabPreviewInfo)
484 */
485 @Override
486 public void start(JTabbedPane tabPane, int tabCount,
487 TabPreviewInfo tabPreviewInfo) {
488 // Check if need to reallocate the preview controls.
489 boolean isSame = (previewControls != null)
490 && (previewControls.length == tabCount);
491 if (isSame)
492 return;
493
494 if (previewControls != null) {
495 for (int i = 0; i < previewControls.length; i++) {
496 caroselMenu.remove(previewControls[i]);
497 }
498 }
499
500 double coef = Math.min(2.8, tabCount / 1.8);
501 coef = Math.max(2.5, coef);
502 pWidth = (int) (dialogWidth / coef);
503 pHeight = (int) (dialogHeight / coef);
504
505 tabPreviewInfo.setPreviewWidth(pWidth - 4);
506 tabPreviewInfo.setPreviewHeight(pHeight - 4);
507
508 previewControls = new ReflectedImageLabel[tabCount];
509 TabPreviewPainter tpp = LafWidgetUtilities2
510 .getTabPreviewPainter(TabOverviewDialog.this.tabPane);
511 for (int i = 0; i < tabCount; i++) {
512 BufferedImage placeHolder = new BufferedImage(pWidth,
513 pHeight, BufferedImage.TYPE_INT_ARGB);
514 Graphics2D g2d = (Graphics2D) placeHolder.getGraphics();
515 g2d.setColor(UIManager.getColor("Label.background"));
516 g2d.fillRect(0, 0, pWidth, pHeight);
517 ReflectedImageLabel ril = (ReflectedImageLabel) caroselMenu
518 .add(placeHolder, tabPane.getTitleAt(i));
519 ril.setForeground(UIManager
520 .getColor("Label.foreground"));
521 ril.setBackground(UIManager
522 .getColor("Label.background"));
523 // TabPreviewControl previewControl = new
524 // TabPreviewControl(
525 // TabOverviewDialog.this.tabPane, i);
526 ril.setPreferredSize(new Dimension(pWidth, pHeight));
527 // fix for issue 177 in Substance (disallowing
528 // selection
529 // of disabled tabs).
530 if (tpp.isSensitiveToEvents(
531 TabOverviewDialog.this.tabPane, i)) {
532 ril.addMouseListener(new TabPreviewMouseHandler(i,
533 ril, false, true));
534 ril
535 .setToolTipText(LafWidgetUtilities
536 .getResourceBundle(tabPane)
537 .getString(
538 "TabbedPane.overviewWidgetTooltip"));
539 }
540 previewControls[i] = ril;
541 // carosel.add(previewControl);
542 }
543 caroselMenu.setSelectedIndex(tabPane.getSelectedIndex());
544 // System.err.println("Added " + previewControls.length
545 // + " labels");
546 // doLayout();
547 // for (int i = 0; i < tabCount; i++) {
548 // previewControls[i].revalidate();
549 // }
550 // repaint();
551 }
552
553 /*
554 * (non-Javadoc)
555 *
556 * @seeorg.pushingpixels.lafwidget.tabbed.TabPreviewThread.
557 * TabPreviewCallback#offer(javax.swing.JTabbedPane, int,
558 * java.awt.image.BufferedImage)
559 */
560 @Override
561 public void offer(JTabbedPane tabPane, int tabIndex,
562 BufferedImage componentSnap) {
563 int width = componentSnap.getWidth() + 4;
564 int height = componentSnap.getHeight() + 4;
565 BufferedImage result = new BufferedImage(width, height,
566 BufferedImage.TYPE_INT_ARGB);
567 Graphics2D g2d = (Graphics2D) result.getGraphics();
568 g2d.setColor(UIManager.getColor("Label.background"));
569 g2d.fillRect(0, 0, width, height);
570 g2d.setColor(UIManager.getColor("Label.foreground"));
571 g2d.drawRect(0, 0, width - 1, height - 1);
572 g2d.drawImage(componentSnap, 2, 2, null);
573
574 Icon tabIcon = tabPane.getIconAt(tabIndex);
575 if (tabIcon != null) {
576 tabIcon.paintIcon(tabPane, g2d, 2, 2);
577 }
578 // Component caroselComponent = carosel.add(result, tabPane
579 // .getTitleAt(tabIndex));
580 // caroselComponent.setForeground(UIManager
581 // .getColor("Label.foreground"));
582
583 // System.err.println("Setting image on " + tabIndex);
584 previewControls[tabIndex].setRichImage(result);
585 // System.err.println("Set image on " + tabIndex);
586 previewControls[tabIndex].repaint();
587 // previewControls.add(caroselComponent);
588 // TabRoundCarouselOverviewPanel.this.previewControls[tabIndex]
589 // .setPreviewImage(componentSnap);
590 }
591 };
592
593 this.caroselMenu = new JCarouselMenu(null);
594 JList dummyList = new JList();
595 ListCellRenderer lcr = dummyList.getCellRenderer();
596 this.caroselMenu.setCellRenderer(new MenuCarouselListCellRenderer(
597 lcr));
598 this.caroselMenu.setMenuScrollColor(UIManager
599 .getColor("Panel.background"));
600 this.caroselMenu.setUpDownColor(UIManager
601 .getColor("Label.foreground"));
602 LafWidgetSupport support = LafWidgetRepository.getRepository()
603 .getLafSupport();
604 if (support != null) {
605 this.caroselMenu.setUpDownIcons(support
606 .getArrowIcon(SwingConstants.NORTH), support
607 .getArrowIcon(SwingConstants.SOUTH));
608 }
609
610 // this.carosel.setDepthBasedAlpha(true);
611 // // carosel.setBackground(Color.BLACK, Color.DARK_GRAY);
612 // carosel
613 // .add(
614 // TabOverviewDialog.class
615 // .getResource(
616 // "/contrib/com/blogofbug/examples/images/Acknowledgements.png")
617 // .toString(), "You Rock", 128, 128);
618 // carosel.add(TabOverviewDialog.class.getResource(
619 // "/contrib/com/blogofbug/examples/images/Dock.png")
620 // .toString(), "Docks Rock", 128, 128);
621 // carosel.add(TabOverviewDialog.class.getResource(
622 // "/contrib/com/blogofbug/examples/images/Cascade.png")
623 // .toString(), "Cascade Icon", 128, 128);
624 // carosel.add(TabOverviewDialog.class.getResource(
625 // "/contrib/com/blogofbug/examples/images/Quit.png")
626 // .toString(), "Quit Bugging", 128, 128);
627 this.setLayout(new BorderLayout());
628 this.add(caroselMenu, BorderLayout.CENTER);
629
630 TabPreviewInfo previewInfo = new TabPreviewInfo();
631 previewInfo.tabPane = TabOverviewDialog.this.tabPane;
632 previewInfo.previewCallback = previewCallback;
633 previewInfo.setPreviewWidth(this.pWidth - 4);
634 previewInfo.setPreviewHeight(this.pHeight - 4);
635 previewInfo.toPreviewAllTabs = true;
636 previewInfo.initiator = TabOverviewDialog.this;
637
638 TabPreviewThread.getInstance().queueTabPreviewRequest(previewInfo);
639 }
640
641 /*
642 * (non-Javadoc)
643 *
644 * @see javax.swing.JPanel#updateUI()
645 */
646 @Override
647 public void updateUI() {
648 super.updateUI();
649 if (this.caroselMenu != null) {
650 JList dummyList = new JList();
651 ListCellRenderer lcr = dummyList.getCellRenderer();
652 this.caroselMenu
653 .setCellRenderer(new MenuCarouselListCellRenderer(lcr));
654 this.caroselMenu.setMenuScrollColor(UIManager
655 .getColor("Panel.background"));
656 this.caroselMenu.setUpDownColor(UIManager
657 .getColor("Label.foreground"));
658 this.caroselMenu.setBackground(UIManager
659 .getColor("Panel.background"));
660 LafWidgetSupport support = LafWidgetRepository.getRepository()
661 .getLafSupport();
662 if (support != null) {
663 this.caroselMenu.setUpDownIcons(support
664 .getArrowIcon(SwingConstants.NORTH), support
665 .getArrowIcon(SwingConstants.SOUTH));
666 }
667 }
668 }
669 }
670
671 /**
672 * Tab grid overview panel. Contains a grid of tab preview widgets. The
673 * widgets are created in a separate thread ({@link TabPreviewThread}) and
674 * offered to the tab overview dialog via the registered implementation of
675 * {@link TabPreviewThread.TabPreviewCallback}. This way the application
676 * stays interactive while the tab overview dialog is being populated.
677 *
678 * @author Kirill Grouchnikov
679 */
680 protected class TabGridOverviewPanel extends JPanel {
681 /**
682 * Tab preview controls.
683 */
684 protected TabPreviewControl[] previewControls;
685
686 /**
687 * Width of a single tab preview control.
688 */
689 protected int pWidth;
690
691 /**
692 * Height of a single tab preview control.
693 */
694 protected int pHeight;
695
696 /**
697 * Number of overview grid columns.
698 */
699 protected int colCount;
700
701 /**
702 * Glass pane for rollover effects.
703 */
704 protected TabGridOverviewGlassPane glassPane;
705
706 /**
707 * Creates a tab overview panel.
708 *
709 * @param dialogWidth
710 * The width of the parent dialog.
711 * @param dialogHeight
712 * The height of the parent dialog.
713 */
714 public TabGridOverviewPanel(final int dialogWidth,
715 final int dialogHeight) {
716 // int tabCount = TabOverviewDialog.this.tabPane.getTabCount();
717
718 TabPreviewThread.TabPreviewCallback previewCallback = new TabPreviewThread.TabPreviewCallback() {
719 /*
720 * (non-Javadoc)
721 *
722 * @seeorg.pushingpixels.lafwidget.tabbed.TabPreviewThread.
723 * TabPreviewCallback#start(javax.swing.JTabbedPane, int,
724 * org.pushingpixels
725 * .lafwidget.tabbed.TabPreviewThread.TabPreviewInfo)
726 */
727 @Override
728 public void start(JTabbedPane tabPane, int tabCount,
729 TabPreviewInfo tabPreviewInfo) {
730 colCount = (int) Math.sqrt(tabCount);
731 if (colCount * colCount < tabCount)
732 colCount++;
733
734 pWidth = (dialogWidth - 8) / colCount;
735 pHeight = (dialogHeight - 32) / colCount;
736
737 tabPreviewInfo.setPreviewWidth(pWidth - 4);
738 tabPreviewInfo.setPreviewHeight(pHeight - 20);
739
740 // Check if need to reallocate the preview controls.
741 boolean isSame = (previewControls != null)
742 && (previewControls.length == tabCount);
743 if (isSame)
744 return;
745
746 if (previewControls != null) {
747 for (int i = 0; i < previewControls.length; i++) {
748 remove(previewControls[i]);
749 }
750 }
751
752 previewControls = new TabPreviewControl[tabCount];
753 TabPreviewPainter tpp = LafWidgetUtilities2
754 .getTabPreviewPainter(TabOverviewDialog.this.tabPane);
755 for (int i = 0; i < tabCount; i++) {
756 TabPreviewControl previewControl = new TabPreviewControl(
757 TabOverviewDialog.this.tabPane, i);
758 // fix for issue 177 in Substance (disallowing selection
759 // of disabled tabs).
760 if (tpp.isSensitiveToEvents(
761 TabOverviewDialog.this.tabPane, i)) {
762 previewControl
763 .addMouseListener(new TabPreviewMouseHandler(
764 i, previewControl, true, false));
765 }
766 previewControls[i] = previewControl;
767 add(previewControl);
768 }
769
770 doLayout();
771 for (int i = 0; i < tabCount; i++) {
772 previewControls[i].revalidate();
773 }
774 repaint();
775
776 JRootPane rp = SwingUtilities
777 .getRootPane(TabGridOverviewPanel.this);
778 glassPane = new TabGridOverviewGlassPane(
779 TabGridOverviewPanel.this);
780 rp.setGlassPane(glassPane);
781 glassPane.setVisible(true);
782 }
783
784 /*
785 * (non-Javadoc)
786 *
787 * @seeorg.pushingpixels.lafwidget.tabbed.TabPreviewThread.
788 * TabPreviewCallback#offer(javax.swing.JTabbedPane, int,
789 * java.awt.image.BufferedImage)
790 */
791 @Override
792 public void offer(JTabbedPane tabPane, int tabIndex,
793 BufferedImage componentSnap) {
794 TabGridOverviewPanel.this.previewControls[tabIndex]
795 .setPreviewImage(componentSnap, true);
796 }
797 };
798
799 this.setLayout(new TabGridOverviewPanelLayout());
800
801 TabPreviewInfo previewInfo = new TabPreviewInfo();
802 previewInfo.tabPane = TabOverviewDialog.this.tabPane;
803 previewInfo.previewCallback = previewCallback;
804 //previewInfo.setPreviewWidth(this.pWidth - 4);
805 //previewInfo.setPreviewHeight(this.pHeight - 20);
806 previewInfo.toPreviewAllTabs = true;
807 previewInfo.initiator = TabOverviewDialog.this;
808
809 TabPreviewThread.getInstance().queueTabPreviewRequest(previewInfo);
810 }
811
812 /**
813 * Layout manager for the tab overview panel.
814 *
815 * @author Kirill Grouchnikov
816 */
817 private class TabGridOverviewPanelLayout implements LayoutManager {
818 /*
819 * (non-Javadoc)
820 *
821 * @see java.awt.LayoutManager#addLayoutComponent(java.lang.String,
822 * java.awt.Component)
823 */
824 @Override
825 public void addLayoutComponent(String name, Component comp) {
826 }
827
828 /*
829 * (non-Javadoc)
830 *
831 * @see
832 * java.awt.LayoutManager#removeLayoutComponent(java.awt.Component)
833 */
834 @Override
835 public void removeLayoutComponent(Component comp) {
836 }
837
838 /*
839 * (non-Javadoc)
840 *
841 * @see java.awt.LayoutManager#layoutContainer(java.awt.Container)
842 */
843 @Override
844 public void layoutContainer(Container parent) {
845 // int width = parent.getWidth();
846 // int height = parent.getHeight();
847 //
848 if (TabGridOverviewPanel.this.previewControls == null)
849 return;
850
851 for (int i = 0; i < TabGridOverviewPanel.this.previewControls.length; i++) {
852 TabPreviewControl previewControl = TabGridOverviewPanel.this.previewControls[i];
853 if (previewControl == null)
854 continue;
855 int rowIndex = i / TabGridOverviewPanel.this.colCount;
856 int colIndex = i % TabGridOverviewPanel.this.colCount;
857
858 previewControl.setBounds(colIndex
859 * TabGridOverviewPanel.this.pWidth, rowIndex
860 * TabGridOverviewPanel.this.pHeight,
861 TabGridOverviewPanel.this.pWidth,
862 TabGridOverviewPanel.this.pHeight);
863 }
864 }
865
866 /*
867 * (non-Javadoc)
868 *
869 * @see java.awt.LayoutManager#minimumLayoutSize(java.awt.Container)
870 */
871 @Override
872 public Dimension minimumLayoutSize(Container parent) {
873 return parent.getSize();
874 }
875
876 /*
877 * (non-Javadoc)
878 *
879 * @see
880 * java.awt.LayoutManager#preferredLayoutSize(java.awt.Container)
881 */
882 @Override
883 public Dimension preferredLayoutSize(Container parent) {
884 return this.minimumLayoutSize(parent);
885 }
886 }
887 }
888
889 /**
890 * Glass pane for the tab grid overview panel. Provides rollover effects,
891 * showing zoomed version of the tab thumbnails.
892 *
893 * @author Kirill Grouchnikov
894 */
895 public class TabGridOverviewGlassPane extends JPanel {
896 private final class RolloverMouseListener extends MouseAdapter {
897 private final int index;
898 private final TabGridOverviewPanel overviewPanel;
899
900 private Timeline rolloverTimeline;
901
902 private RolloverMouseListener(final int index,
903 final TabGridOverviewPanel overviewPanel) {
904 this.index = index;
905 this.overviewPanel = overviewPanel;
906 this.rolloverTimeline = new Timeline(
907 overviewPanel.previewControls[index]);
908 AnimationConfigurationManager.getInstance().configureTimeline(
909 this.rolloverTimeline);
910 this.rolloverTimeline.addPropertyToInterpolate("zoom", 1.0f,
911 1.2f);
912 this.rolloverTimeline.addCallback(new SwingRepaintCallback(
913 SwingUtilities.getRootPane(overviewPanel)));
914 this.rolloverTimeline
915 .addCallback(new UIThreadTimelineCallbackAdapter() {
916 @Override
917 public void onTimelineStateChanged(
918 TimelineState oldState,
919 TimelineState newState,
920 float durationFraction,
921 float timelinePosition) {
922 if ((oldState == TimelineState.DONE)
923 && (newState == TimelineState.IDLE)) {
924 overviewPanel.previewControls[index]
925 .setToolTipText(LafWidgetUtilities
926 .getResourceBundle(tabPane)
927 .getString(
928 "TabbedPane.overviewWidgetTooltip"));
929 }
930 }
931 });
932 }
933
934 @Override
935 public void mouseEntered(MouseEvent e) {
936 currHoverIndex = index;
937 overviewPanel.previewControls[index].setToolTipText(null);
938 this.rolloverTimeline.play();
939 }
940
941 @Override
942 public void mouseExited(MouseEvent e) {
943 if (currHoverIndex == index)
944 currHoverIndex = -1;
945 overviewPanel.previewControls[index].setToolTipText(null);
946 this.rolloverTimeline.playReverse();
947 }
948 }
949
950 /**
951 * Index of the tab thumbnail currently under the mouse pointer.
952 */
953 private int currHoverIndex;
954
955 /**
956 * Mouse listeneres (one for each tab thumbnail).
957 */
958 private MouseListener[] mouseListeners;
959
960 /**
961 * The associated overview panel.
962 */
963 private TabGridOverviewPanel overviewPanel;
964
965 /**
966 * Creates the glass pane.
967 *
968 * @param overviewPanel
969 * The associated overview panel.
970 */
971 public TabGridOverviewGlassPane(final TabGridOverviewPanel overviewPanel) {
972 this.setOpaque(false);
973 this.overviewPanel = overviewPanel;
974
975 int size = this.overviewPanel.previewControls.length;
976 this.mouseListeners = new MouseListener[size];
977 this.currHoverIndex = -1;
978 for (int i = 0; i < size; i++) {
979 final int index = i;
980 this.mouseListeners[i] = new RolloverMouseListener(index,
981 overviewPanel);
982 this.overviewPanel.previewControls[i]
983 .addMouseListener(this.mouseListeners[i]);
984 }
985 }
986
987 /*
988 * (non-Javadoc)
989 *
990 * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
991 */
992 @Override
993 protected void paintComponent(Graphics g) {
994 Graphics2D graphics = (Graphics2D) g.create();
995 for (int i = 0; i < tabPane.getTabCount(); i++) {
996 TabPreviewControl child = overviewPanel.previewControls[i];
997 if (child.getZoom() > 1.0f) {
998 paintSingleTabComponent(graphics, i);
999 }
1000 }
1001 if (currHoverIndex >= 0) {
1002 // paint the currently hovered once again (so it'll be on top)
1003 paintSingleTabComponent(graphics, currHoverIndex);
1004 }
1005 graphics.dispose();
1006 }
1007
1008 /**
1009 * Paints a single tab component.
1010 *
1011 * @param graphics
1012 * Graphics context.
1013 * @param index
1014 * Tab component index.
1015 */
1016 private void paintSingleTabComponent(Graphics2D graphics, int index) {
1017 TabPreviewControl child = overviewPanel.previewControls[index];
1018 Rectangle cBounds = child.getBounds();
1019 int dx = child.getLocationOnScreen().x
1020 - this.getLocationOnScreen().x;
1021 int dy = child.getLocationOnScreen().y
1022 - this.getLocationOnScreen().y;
1023 double factor = child.getZoom();
1024 int bw = (int) (cBounds.width * factor);
1025 int bh = (int) (cBounds.height * factor);
1026 BufferedImage bi = new BufferedImage(bw, bh,
1027 BufferedImage.TYPE_INT_ARGB);
1028 Graphics2D bGraphics = (Graphics2D) bi.getGraphics().create();
1029 bGraphics.scale(factor, factor);
1030
1031 TabPreviewControl tChild = child;
1032
1033 bGraphics.setColor(tChild.getBackground());
1034 bGraphics.fillRect(0, 0, tChild.getWidth(), tChild.getHeight());
1035
1036 Icon icon = tabPane.getIconAt(index);
1037 int iy = (icon == null) ? 16 : icon.getIconHeight();
1038 if (icon != null) {
1039 icon.paintIcon(this, bGraphics, 1, 1);
1040 }
1041 String title = tabPane.getTitleAt(index);
1042 JLabel tempLabel = new JLabel(title);
1043 tempLabel.setBounds(tChild.titleLabel.getBounds());
1044 tempLabel.setFont(tChild.titleLabel.getFont());
1045 int bdx = tempLabel.getX();
1046 int bdy = tempLabel.getY();
1047 bGraphics.translate(bdx, bdy);
1048 tempLabel.paint(bGraphics);
1049 bGraphics.translate(-bdx, -bdy);
1050 bdx = 1;
1051 bdy = iy + 3;
1052 bGraphics.translate(bdx, bdy);
1053 (child).paintTabThumbnail(bGraphics);
1054 bGraphics.translate(-bdx, -bdy);
1055 bGraphics.setColor(Color.black);
1056 bGraphics.drawRect(0, 0, child.getWidth() - 1,
1057 child.getHeight() - 1);
1058 bGraphics.dispose();
1059
1060 dx -= (bw - cBounds.width) / 2;
1061 dy -= (bh - cBounds.height) / 2;
1062 // make sure that the enlarged thumbnail stays inbounds
1063 dx = Math.max(dx, 0);
1064 dy = Math.max(dy, 0);
1065 if (dx + bi.getWidth() > getWidth()) {
1066 dx -= (dx + bi.getWidth() - getWidth());
1067 }
1068 if (dy + bi.getHeight() > getHeight()) {
1069 dy -= (dy + bi.getHeight() - getHeight());
1070 }
1071 graphics.drawImage(bi, dx, dy, null);
1072 }
1073 }
1074
1075 /**
1076 * Creates a new tab overview dialog. Declared private to enforce usage of
1077 * {@link #getOverviewDialog(JTabbedPane)}.
1078 *
1079 * @param tabPane
1080 * Tabbed pane.
1081 * @param overviewKind
1082 * Overview kind.
1083 * @param owner
1084 * Optional owner for the tab overview dialog.
1085 * @param modal
1086 * Modality indication.
1087 * @param dialogWidth
1088 * Tab overview dialog width.
1089 * @param dialogHeight
1090 * Tab overview dialog height.
1091 * @throws HeadlessException
1092 * @see #getOverviewDialog(JTabbedPane)
1093 */
1094 private TabOverviewDialog(final JTabbedPane tabPane,
1095 TabOverviewKind overviewKind, Frame owner, boolean modal,
1096 int dialogWidth, int dialogHeight) throws HeadlessException {
1097 super(owner, modal);
1098 this.tabPane = tabPane;
1099 this.setLayout(new BorderLayout());
1100 if (overviewKind == TabOverviewKind.GRID) {
1101 TabGridOverviewPanel gridOverviewPanel = new TabGridOverviewPanel(
1102 dialogWidth, dialogHeight);
1103 this.add(gridOverviewPanel, BorderLayout.CENTER);
1104 //
1105 // TabGridOverviewGlassPane glassPane = new
1106 // TabGridOverviewGlassPane(
1107 // gridOverviewPanel);
1108 // this.setGlassPane(glassPane);
1109 // glassPane.setVisible(true);
1110 }
1111 if (overviewKind == TabOverviewKind.ROUND_CAROUSEL) {
1112 this.add(new TabRoundCarouselOverviewPanel(dialogWidth,
1113 dialogHeight), BorderLayout.CENTER);
1114 }
1115 if (overviewKind == TabOverviewKind.MENU_CAROUSEL) {
1116 this
1117 .add(new TabMenuCarouselOverviewPanel(dialogWidth,
1118 dialogHeight), BorderLayout.CENTER);
1119 }
1120
1121 this.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
1122 this.setResizable(false);
1123
1124 this.lafSwitchListener = new PropertyChangeListener() {
1125 @Override
1126 public void propertyChange(PropertyChangeEvent evt) {
1127 if ("lookAndFeel".equals(evt.getPropertyName())) {
1128 SwingUtilities.invokeLater(new Runnable() {
1129 @Override
1130 public void run() {
1131 SwingUtilities
1132 .updateComponentTreeUI(TabOverviewDialog.this);
1133 }
1134 });
1135 }
1136 }
1137 };
1138
1139 UIManager.addPropertyChangeListener(this.lafSwitchListener);
1140
1141 // Cancel all pending preview requests issued by this overview
1142 // dialog when it closes.
1143 this.addWindowListener(new WindowAdapter() {
1144 /*
1145 * (non-Javadoc)
1146 *
1147 * @see
1148 * java.awt.event.WindowAdapter#windowClosing(java.awt.event.WindowEvent
1149 * )
1150 */
1151 @Override
1152 public void windowClosing(WindowEvent e) {
1153 this.cancelRequests();
1154 UIManager.removePropertyChangeListener(lafSwitchListener);
1155 }
1156
1157 /*
1158 * (non-Javadoc)
1159 *
1160 * @see
1161 * java.awt.event.WindowAdapter#windowClosed(java.awt.event.WindowEvent
1162 * )
1163 */
1164 @Override
1165 public void windowClosed(WindowEvent e) {
1166 this.cancelRequests();
1167 UIManager.removePropertyChangeListener(lafSwitchListener);
1168 }
1169
1170 /**
1171 * Cancels preview requests issued by <code>this</code> overview
1172 * dialog.
1173 */
1174 private void cancelRequests() {
1175 if (TabPreviewThread.instanceRunning()) {
1176 TabPreviewThread.getInstance().cancelTabPreviewRequests(
1177 TabOverviewDialog.this);
1178 }
1179 }
1180 });
1181 }
1182
1183 /**
1184 * Returns a new instance of a tab overview dialog.
1185 *
1186 * @param tabPane
1187 * Tabbed pane.
1188 * @return Tab overview dialog for the specified tabbed pane.
1189 */
1190 public static TabOverviewDialog getOverviewDialog(JTabbedPane tabPane) {
1191 final TabPreviewPainter previewPainter = LafWidgetUtilities2
1192 .getTabPreviewPainter(tabPane);
1193 String title = previewPainter.toUpdatePeriodically(tabPane) ? MessageFormat
1194 .format(LafWidgetUtilities.getResourceBundle(tabPane)
1195 .getString("TabbedPane.overviewDialogTitleRefresh"),
1196 new Object[] {previewPainter
1197 .getUpdateCycle(tabPane) / 1000})
1198 : LafWidgetUtilities.getResourceBundle(tabPane).getString(
1199 "TabbedPane.overviewDialogTitle");
1200 JFrame frameForModality = previewPainter.getModalOwner(tabPane);
1201 boolean isModal = (frameForModality != null);
1202 Rectangle dialogScreenBounds = previewPainter
1203 .getPreviewDialogScreenBounds(tabPane);
1204 TabOverviewKind overviewKind = previewPainter.getOverviewKind(tabPane);
1205 final TabOverviewDialog overviewDialog = new TabOverviewDialog(tabPane,
1206 overviewKind, frameForModality, isModal,
1207 dialogScreenBounds.width, dialogScreenBounds.height);
1208 overviewDialog.setTitle(title);
1209
1210 overviewDialog.setLocation(dialogScreenBounds.x, dialogScreenBounds.y);
1211 overviewDialog.setSize(dialogScreenBounds.width,
1212 dialogScreenBounds.height);
1213
1214 // make sure that the tab overview dialog is disposed when
1215 // it loses focus
1216 final PropertyChangeListener activeWindowListener = new PropertyChangeListener() {
1217 @Override
1218 public void propertyChange(PropertyChangeEvent evt) {
1219 if ("activeWindow".equals(evt.getPropertyName())) {
1220 if (overviewDialog == evt.getOldValue()) {
1221 if (previewPainter.toDisposeOverviewOnFocusLoss()) {
1222 overviewDialog.dispose();
1223 }
1224 }
1225 }
1226 }
1227 };
1228 KeyboardFocusManager.getCurrentKeyboardFocusManager()
1229 .addPropertyChangeListener(activeWindowListener);
1230
1231 // make sure that when the window with the tabbed pane is
1232 // closed, the tab overview dialog is disposed.
1233 final Window tabWindow = SwingUtilities.getWindowAncestor(tabPane);
1234 final WindowListener tabWindowListener = new WindowAdapter() {
1235 @Override
1236 public void windowClosed(WindowEvent e) {
1237 overviewDialog.dispose();
1238 }
1239 };
1240 tabWindow.addWindowListener(tabWindowListener);
1241 overviewDialog.addWindowListener(new WindowAdapter() {
1242 @Override
1243 public void windowClosed(WindowEvent e) {
1244 tabWindow.removeWindowListener(tabWindowListener);
1245 KeyboardFocusManager.getCurrentKeyboardFocusManager()
1246 .removePropertyChangeListener(activeWindowListener);
1247 }
1248 });
1249
1250 return overviewDialog;
1251 }
1252 }