6fb61b6e2ba55854f4bb8ee38af5abe94db04d2a
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / bridge / tab / SwingScilabDockablePanel.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2007-2008 - INRIA - Vincent Couvert
4  * Copyright (C) 2007 - INRIA - Bruno JOFRET
5  * Copyright (C) 2007 - INRIA - Marouane BEN JELLOUL
6  * Copyright (C) 2011 - DIGITEO - Vincent Couvert
7  * Copyright (C) 2014 - Scilab Enterprises - Bruno JOFRET
8  *
9  * This file must be used under the terms of the CeCILL.
10  * This source file is licensed as described in the file COPYING, which
11  * you should have received as part of this distribution.  The terms
12  * are also available at
13  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
14  *
15  */
16
17 package org.scilab.modules.gui.bridge.tab;
18
19 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_AUTORESIZE__;
20 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_AXES_SIZE__;
21 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CLOSEREQUESTFCN__;
22 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_POSITION__;
23 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_SIZE__;
24
25 import java.awt.Color;
26 import java.awt.Component;
27 import java.awt.Container;
28 import java.awt.Dimension;
29 import java.awt.Graphics;
30 import java.awt.Image;
31 import java.awt.event.ComponentEvent;
32 import java.awt.event.ComponentListener;
33 import java.awt.event.FocusEvent;
34 import java.awt.event.FocusListener;
35 import java.awt.event.HierarchyBoundsListener;
36 import java.awt.event.HierarchyEvent;
37 import java.awt.event.KeyEvent;
38 import java.awt.event.KeyListener;
39 import java.lang.reflect.InvocationTargetException;
40 import java.util.Iterator;
41 import java.util.List;
42 import java.util.ListIterator;
43
44 import javax.swing.Action;
45 import javax.swing.ImageIcon;
46 import javax.swing.JLayeredPane;
47 import javax.swing.JTextPane;
48 import javax.swing.KeyStroke;
49 import javax.swing.SwingUtilities;
50
51 import org.flexdock.docking.DockingConstants;
52 import org.flexdock.docking.DockingManager;
53 import org.flexdock.docking.DockingPort;
54 import org.flexdock.docking.activation.ActiveDockableTracker;
55 import org.flexdock.docking.event.DockingEvent;
56 import org.flexdock.docking.props.PropertyChangeListenerFactory;
57 import org.flexdock.view.Titlebar;
58 import org.flexdock.view.View;
59 import org.scilab.modules.action_binding.InterpreterManagement;
60 import org.scilab.modules.commons.ScilabConstants;
61 import org.scilab.modules.graphic_objects.figure.Figure;
62 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
63 import org.scilab.modules.gui.SwingViewObject;
64 import org.scilab.modules.gui.bridge.canvas.SwingScilabCanvas;
65 import org.scilab.modules.gui.bridge.checkbox.SwingScilabCheckBox;
66 import org.scilab.modules.gui.bridge.console.SwingScilabConsole;
67 import org.scilab.modules.gui.bridge.editbox.SwingScilabEditBox;
68 import org.scilab.modules.gui.bridge.frame.SwingScilabFrame;
69 import org.scilab.modules.gui.bridge.helpbrowser.SwingScilabHelpBrowser;
70 import org.scilab.modules.gui.bridge.label.SwingScilabLabel;
71 import org.scilab.modules.gui.bridge.listbox.SwingScilabListBox;
72 import org.scilab.modules.gui.bridge.menubar.SwingScilabMenuBar;
73 import org.scilab.modules.gui.bridge.popupmenu.SwingScilabPopupMenu;
74 import org.scilab.modules.gui.bridge.pushbutton.SwingScilabPushButton;
75 import org.scilab.modules.gui.bridge.radiobutton.SwingScilabRadioButton;
76 import org.scilab.modules.gui.bridge.slider.SwingScilabSlider;
77 import org.scilab.modules.gui.bridge.toolbar.SwingScilabToolBar;
78 import org.scilab.modules.gui.bridge.tree.SwingScilabTree;
79 import org.scilab.modules.gui.bridge.uidisplaytree.SwingScilabUiDisplayTree;
80 import org.scilab.modules.gui.bridge.uiimage.SwingScilabUiImage;
81 import org.scilab.modules.gui.bridge.uitable.SwingScilabUiTable;
82 import org.scilab.modules.gui.bridge.window.SwingScilabWindow;
83 import org.scilab.modules.gui.canvas.Canvas;
84 import org.scilab.modules.gui.checkbox.CheckBox;
85 import org.scilab.modules.gui.console.Console;
86 import org.scilab.modules.gui.console.ScilabConsole;
87 import org.scilab.modules.gui.dockable.Dockable;
88 import org.scilab.modules.gui.editbox.EditBox;
89 import org.scilab.modules.gui.editor.EditorEventListener;
90 import org.scilab.modules.gui.events.GlobalEventWatcher;
91 import org.scilab.modules.gui.events.ScilabEventListener;
92 import org.scilab.modules.gui.events.callback.CommonCallBack;
93 import org.scilab.modules.gui.frame.Frame;
94 import org.scilab.modules.gui.helpbrowser.HelpBrowser;
95 import org.scilab.modules.gui.label.Label;
96 import org.scilab.modules.gui.listbox.ListBox;
97 import org.scilab.modules.gui.menubar.MenuBar;
98 import org.scilab.modules.gui.popupmenu.PopupMenu;
99 import org.scilab.modules.gui.pushbutton.PushButton;
100 import org.scilab.modules.gui.radiobutton.RadioButton;
101 import org.scilab.modules.gui.slider.Slider;
102 import org.scilab.modules.gui.tab.SimpleTab;
103 import org.scilab.modules.gui.textbox.TextBox;
104 import org.scilab.modules.gui.toolbar.ToolBar;
105 import org.scilab.modules.gui.tree.Tree;
106 import org.scilab.modules.gui.uidisplaytree.UiDisplayTree;
107 import org.scilab.modules.gui.uitable.UiTable;
108 import org.scilab.modules.gui.utils.BarUpdater;
109 import org.scilab.modules.gui.utils.ClosingOperationsManager;
110 import org.scilab.modules.gui.utils.Position;
111 import org.scilab.modules.gui.utils.SciClosingAction;
112 import org.scilab.modules.gui.utils.SciHelpOnComponentAction;
113 import org.scilab.modules.gui.utils.SciUndockingAction;
114 import org.scilab.modules.gui.utils.ScilabSwingUtilities;
115 import org.scilab.modules.gui.utils.Size;
116
117 /**
118  * Swing implementation for Scilab tabs in GUIs
119  * This implementation uses FlexDock package
120  * @author Bruno JOFRET
121  * @author Vincent COUVERT
122  * @author Marouane BEN JELLOUL
123  * @author Jean-Baptiste SILVY
124  */
125
126 public class SwingScilabDockablePanel extends View implements SimpleTab, FocusListener, KeyListener, SwingScilabPanel {
127
128     
129
130     private static final Image SCILAB_ICON = new ImageIcon(ScilabSwingUtilities.findIcon("scilab", "256x256")).getImage();
131
132     private static final long serialVersionUID = 1L;
133
134     private static final String UNDOCK = "undock";
135     private static final String HELP = "help";
136
137     private Integer id;
138
139     private boolean eventEnabled = false;
140
141     static {
142         PropertyChangeListenerFactory.addFactory(new BarUpdater.UpdateBarFactory());
143     }
144
145     private String parentWindowId;
146     private MenuBar menuBar;
147     private ToolBar toolBar;
148     private TextBox infoBar;
149     private String helpID;
150     private boolean paintEnable = true;
151
152     /** Contains the canvas and widgets */
153     private SwingScilabAxes contentPane;
154     private JLayeredPane uiContentPane;
155     private JLayeredPane layerdPane;
156
157     /** Scroll the axes */
158     private SwingScilabScrollPane scrolling;
159
160     private Image icon;
161
162     private Action closeAction;
163
164     /** The listener for event handling */
165     private ScilabEventListener eventHandler;
166     private EditorEventListener editorEventHandler = null;
167
168     /** A reference to the canvas used for event handling management */
169     SwingScilabCanvas contentCanvas;
170
171     /**
172      * Constructor
173      * @param name the name of the tab
174      * @param uuid an uuid to identify the tab
175      */
176     public SwingScilabDockablePanel(String name, String uuid) {
177         super(uuid, name, name);
178         //This button is "overloaded" when we add a callback
179         //this.addAction(DockingConstants.CLOSE_ACTION);
180         // Removed because make JOGL crash when "Unpin"
181         //this.addAction(DockingConstants.PIN_ACTION);
182         this.addAction(DockingConstants.ACTIVE_WINDOW);
183
184         // no need for an axes
185         contentPane = null;
186         uiContentPane = null;
187         scrolling = null;
188
189         this.setVisible(true);
190
191         getTitlebar().addFocusListener(this);
192         addFocusListener(this);
193         setCallback(null);
194
195         getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("shift F6"), ACTION_TOGGLE_PREVIOUS);
196     }
197
198     /**
199      * Create a graphic tab used to display a figure with 3D graphics and/or UIcontrols
200      * @param name name of the tab
201      * @param figureId id of the displayed figure
202      */
203     public SwingScilabDockablePanel(String name, int figureId) {
204         super(name, name, name);
205
206         // This button is "overloaded" when we add a callback
207         //this.addAction(DockingConstants.CLOSE_ACTION);
208         // Removed because make JOGL crash when "Unpin"
209         //this.addAction(DockingConstants.PIN_ACTION);
210         this.addAction(DockingConstants.ACTIVE_WINDOW);
211
212         // create the panel in which all the uiobjects will lie.
213         //contentPane = new SwingScilabAxes(figureId);
214
215         // add it inside a JSCrollPane
216         //scrolling = new SwingScilabScrollPane(contentPane);
217         //scrolling.setBackground(1, 0, 0);
218         // put in in the back of the tab
219         //setContentPane(scrolling.getAsContainer());
220
221         this.setVisible(true);
222
223         getTitlebar().addFocusListener(this);
224         addFocusListener(this);
225         setCallback(null);
226
227         getInputMap(WHEN_IN_FOCUSED_WINDOW).put(KeyStroke.getKeyStroke("shift F6"), ACTION_TOGGLE_PREVIOUS);
228     }
229
230     /**
231      * Constructor
232      * @param name the name of the tab (used to identify it)
233      */
234     public SwingScilabDockablePanel(String name) {
235         this(name, name);
236     }
237
238     /**
239      * Set the associated help page
240      * @param helpID the xml id of the associated help page
241      */
242     public void setAssociatedXMLIDForHelp(String helpID) {
243         this.helpID = helpID;
244     }
245
246     /**
247      * Get the associated help page
248      * @return the xml id of the associated help page
249      */
250     public String getAssociatedXMLIDForHelp() {
251         return helpID;
252     }
253
254     public static void removeActions(SwingScilabDockablePanel tab) {
255         tab.setActionBlocked(DockingConstants.CLOSE_ACTION, true);
256         tab.setActionBlocked(UNDOCK, true);
257         if (tab.getTitlebar() != null) {
258             tab.getTitlebar().revalidate();
259         }
260     }
261
262     public static void addActions(SwingScilabDockablePanel tab) {
263         tab.setActionBlocked(DockingConstants.CLOSE_ACTION, false);
264         tab.setActionBlocked(UNDOCK, false);
265         tab.getTitlebar().revalidate();
266     }
267
268     public SwingScilabDockablePanel(String figureTitle, int figureId, final Figure figure) {
269         this(figureTitle, figureId);
270         /* OpenGL context */
271         SwingScilabCanvas canvas = new SwingScilabCanvas(figureId, figure);
272         contentCanvas = canvas;
273
274         editorEventHandler = new EditorEventListener(figure.getIdentifier());
275         contentCanvas.addEventHandlerKeyListener(editorEventHandler);
276         contentCanvas.addEventHandlerMouseListener(editorEventHandler);
277         contentCanvas.addEventHandlerMouseMotionListener(editorEventHandler);
278
279         layerdPane = new JLayeredPane();
280         layerdPane.setLayout(null);
281         layerdPane.add(canvas, JLayeredPane.FRAME_CONTENT_LAYER);
282         uiContentPane = new JLayeredPane();
283         uiContentPane.setOpaque(false);
284         uiContentPane.setLayout(null);
285         layerdPane.add(uiContentPane, JLayeredPane.DEFAULT_LAYER + 1, 0);
286
287         scrolling = new SwingScilabScrollPane(layerdPane, uiContentPane, figure);
288         scrolling.setCanvas(canvas);
289
290         contentCanvas.addKeyListener(this);
291
292         setContentPane(scrolling.getAsContainer());
293         //setContentPane(uiContentPane);
294         canvas.setVisible(true);
295         uiContentPane.setVisible(true);
296
297         /* Manage figure_position property */
298         addHierarchyBoundsListener(new HierarchyBoundsListener() {
299             public void ancestorResized(HierarchyEvent arg0) {
300             }
301
302             public void ancestorMoved(HierarchyEvent e) {
303                 if (e.getChanged() instanceof SwingScilabWindow) {
304                     Position parentPosition = SwingScilabWindow.allScilabWindows.get(parentWindowId).getPosition();
305                     Integer[] newPosition = new Integer[] {parentPosition.getX(), parentPosition.getY()};
306                     GraphicController.getController().setProperty(id, __GO_POSITION__, newPosition);
307                 }
308             }
309         });
310
311         /* Manage figure_size property */
312         addComponentListener(new ComponentListener() {
313
314             public void componentShown(ComponentEvent arg0) {
315             }
316
317             public void componentResized(ComponentEvent arg0) {
318
319                 /* Update the figure_size property */
320                 Size parentSize =  SwingScilabWindow.allScilabWindows.get(parentWindowId).getDims();
321                 Integer[] newSize = new Integer[] {parentSize.getWidth(), parentSize.getHeight()};
322
323                 GraphicController.getController().setProperty(id, __GO_SIZE__, newSize);
324
325                 Boolean autoreSize = (Boolean) GraphicController.getController().getProperty(id, __GO_AUTORESIZE__);
326
327                 if (autoreSize != null && autoreSize) {
328                     /* Update the axes_size property */
329                     Integer[] newAxesSize = new Integer[] {getContentPane().getWidth(), getContentPane().getHeight()};
330                     GraphicController.getController().setProperty(id, __GO_AXES_SIZE__, newAxesSize);
331                 }
332             }
333
334             public void componentMoved(ComponentEvent arg0) {
335             }
336
337             public void componentHidden(ComponentEvent arg0) {
338             }
339         });
340
341         /* Manage closerequestfcn */
342         ClosingOperationsManager.registerClosingOperation(SwingScilabDockablePanel.this, new ClosingOperationsManager.ClosingOperation() {
343
344             public int canClose() {
345                 String closeRequestFcn = (String) GraphicController.getController().getProperty(getId(), __GO_CLOSEREQUESTFCN__);
346                 if (!closeRequestFcn.equals("")) {
347                     String closeCommand = "if exists(\"gcbo\") then %oldgcbo = gcbo; end;"
348                                           + "gcbo = getcallbackobject(" + getId() + ");"
349                                           + closeRequestFcn + ";fire_closing_finished();"
350                                           + ";if exists(\"%oldgcbo\") then gcbo = %oldgcbo; else clear gcbo; end;";
351                     InterpreterManagement.requestScilabExec(closeCommand);
352                     return -1;
353                 } else {
354                     closeAction.actionPerformed(null);
355                     return 1;
356                 }
357             }
358
359             public void destroy() {
360             }
361
362             public String askForClosing(final List<SwingScilabDockablePanel> list) {
363                 return null;
364             }
365
366             @Override
367             public void updateDependencies(List<SwingScilabDockablePanel> list, ListIterator<SwingScilabDockablePanel> it) {
368
369             }
370         });
371         ClosingOperationsManager.addDependencyWithRoot(this);
372     }
373
374     /**
375      * @param e the FocusEvent
376      */
377     @Override
378     public void focusGained(FocusEvent e) {
379         //ActiveDockableTracker.requestDockableActivation(this);
380         if (contentPane != null) {
381             contentPane.requestFocus();
382         } else if (getContentPane() != null) {
383             getContentPane().requestFocus();
384         } else {
385             SwingScilabDockablePanel.this.requestFocusInWindow();
386         }
387     }
388
389     /**
390      * Call when the tab restoration is ended.
391      */
392     public void endedRestoration() { }
393
394     /**
395      * @return the window icon associated with this tab
396      */
397     public Image getWindowIcon() {
398         if (icon == null) {
399             return SCILAB_ICON;
400         } else {
401             return icon;
402         }
403     }
404
405     /**
406      * @param icon the window icon associated with this tab
407      */
408     public void setWindowIcon(Image icon) {
409         this.icon = icon;
410     }
411
412     /**
413      * @param iconName window icon associated with this tab
414      */
415     public void setWindowIcon(String iconName) {
416         setWindowIcon(new ImageIcon(ScilabSwingUtilities.findIcon(iconName, "256x256")).getImage());
417     }
418
419     /**
420      * @param e the FocusEvent
421      */
422     @Override
423     public void focusLost(FocusEvent e) { }
424
425     /**
426      * {@inheritDoc}
427      */
428     @Override
429     public void dockingComplete(DockingEvent evt) {
430         super.dockingComplete(evt);
431
432         DockingPort port = evt.getNewDockingPort();
433         SwingScilabWindow win = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, (Component) port);
434         Iterator iter = port.getDockables().iterator();
435
436         if (port.getDockables().size() > 1) {
437             while (iter.hasNext()) {
438                 Object d = iter.next();
439                 if (d instanceof SwingScilabDockablePanel) {
440                     SwingScilabDockablePanel view = (SwingScilabDockablePanel) d;
441                     addActions(view);
442                 }
443             }
444         } else {
445             removeActions(this);
446         }
447
448         if (win != null) {
449             setParentWindowId(win.getId());
450         } else {
451             // Should not occur
452             SwingUtilities.invokeLater(new Runnable() {
453                 public void run() {
454                     if (getParentWindow() != null) {
455                         setParentWindowId(getParentWindow().getId());
456                     } else {
457                         System.err.println("No window for tab:" + SwingScilabDockablePanel.this.getClass().getName() + " after docking complete");
458                     }
459                 }
460             });
461         }
462     }
463
464     /**
465      * Sets the Name of a swing Scilab tab
466      * @param newTabName the Name of the tab
467      * @see org.scilab.modules.gui.tab.ScilabTab#setName(String)
468      */
469     @Override
470     public void setName(String newTabName) {
471         setTitle(newTabName, true);
472         getTitlePane().repaint();
473         SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this).setName(newTabName);
474     }
475
476     /**
477      * @return the UUID of the parent window
478      */
479     public String getParentWindowUUID() {
480         return ((SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this)).getUUID();
481     }
482
483     /**
484      * @return the UUID of the parent window
485      */
486     public SwingScilabWindow getParentWindow() {
487         return (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this);
488     }
489
490     /**
491      * Gets the title of a swing Scilab tab
492      * @return the title of the tab
493      * @see org.scilab.modules.gui.tab.ScilabTab#getName()
494      */
495     @Override
496     public String getName() {
497         return this.getTitle();
498     }
499
500     /**
501      * Paint immediately this component
502      */
503     public void paintImmediately() {
504         // paint all
505         paintImmediately(0, 0, getWidth(), getHeight());
506     }
507
508     /**
509      * Draws a swing Scilab tab
510      * @see org.scilab.modules.gui.uielement.UIElement#draw()
511      */
512     @Override
513     public void draw() {
514         if (SwingUtilities.isEventDispatchThread()) {
515             setVisible(true);
516             paintImmediately();
517         } else {
518             try {
519                 SwingUtilities.invokeAndWait(new Runnable() {
520                     @Override
521                     public void run() {
522                         setVisible(true);
523                         paintImmediately();
524                     }
525                 });
526             } catch (InterruptedException e) {
527                 e.printStackTrace();
528             } catch (InvocationTargetException e) {
529                 e.printStackTrace();
530             }
531         }
532
533     }
534
535     /**
536      * Gets the dimensions (width and height) of a swing Scilab tab
537      * @return the dimensions of the tab
538      * @see org.scilab.modules.gui.uielement.UIElement#getDims()
539      */
540     @Override
541     public Size getDims() {
542         return new Size(this.getSize().width, this.getSize().height);
543     }
544
545     /**
546      * Get the size for the axes
547      * @return size of the axes in pixels
548      */
549     @Override
550     public Size getAxesSize() {
551         return new Size(contentPane.getWidth(), contentPane.getHeight());
552     }
553
554     /**
555      * @param newSize new size to set for the axes
556      */
557     @Override
558     public void setAxesSize(Size newSize) {
559         contentPane.setSize(new Dimension(newSize.getWidth(), newSize.getHeight()));
560         uiContentPane.setSize(new Dimension(newSize.getWidth(), newSize.getHeight()));
561     }
562
563     /**
564      * Gets the position (X-coordinate and Y-coordinate) of a swing Scilab tab
565      * @return the position of the tab
566      * @see org.scilab.modules.gui.uielement.UIElement#getPosition()
567      */
568     @Override
569     public Position getPosition() {
570         return new Position(this.getX(), this.getY());
571     }
572
573     /**
574      * Sets the dimensions (width and height) of a swing Scilab tab
575      * @param newSize the dimensions we want to set to the tab
576      * @see org.scilab.modules.gui.uielement.UIElement#setDims(org.scilab.modules.gui.utils.Size)
577      */
578     @Override
579     public void setDims(Size newSize) {
580         this.setSize(newSize.getWidth(), newSize.getHeight());
581     }
582
583     /**
584      * Sets the position (X-coordinate and Y-coordinate) of a swing Scilab tab
585      * @param newPosition the position we want to set to the tab
586      * @see org.scilab.modules.gui.uielement.UIElement#setPosition(org.scilab.modules.gui.utils.Position)
587      */
588     @Override
589     public void setPosition(Position newPosition) {
590         this.setLocation(newPosition.getX(), newPosition.getY());
591     }
592
593     /**
594      * Add a member (dockable element) to container and returns its index
595      * @param member the member to add
596      * @return index of member in ArrayList
597      */
598     @Override
599     public int addMember(Canvas member) {
600         return 0;
601     }
602
603     /**
604      * We want to be able to remove directly a Canvas from a Tab.
605      * @param member canvas to remove
606      */
607     @Override
608     public void removeMember(Canvas member) {
609     }
610
611     /**
612      * Add a SwingViewObject (from SwingView.java) to container and returns its index
613      * @param member the member to add
614      */
615     public void addMember(SwingViewObject member) {
616         SwingScilabCommonPanel.addMember(this, member);
617     }
618
619     /**
620      * Remove a SwingViewObject (from SwingView.java)
621      * @param member the member to remove
622      */
623     public void removeMember(SwingViewObject member) {
624         uiContentPane.remove((Component) member);
625     }
626
627     /**
628      * Add a member (dockable element) to container and returns its index
629      * @param member the member to add
630      * @return index of member in ArrayList
631      */
632     @Override
633     public int addMember(Console member) {
634         return this.addMember((SwingScilabConsole) member.getAsSimpleConsole());
635     }
636
637     /**
638      * Add a member (dockable element) to container and returns its index
639      * @param member the member to add
640      * @return index of member in ArrayList
641      */
642     private int addMember(SwingScilabConsole member) {
643         // replace the current content pane
644         this.setContentPane(member);
645         return this.getComponentZOrder(member);
646     }
647
648     /**
649      * Add a member (dockable element) to container and returns its index
650      * @param member the member to add
651      * @return index of member in ArrayList
652      */
653     @Override
654     public int addMember(HelpBrowser member) {
655         return this.addMember((SwingScilabHelpBrowser) member.getAsSimpleHelpBrowser());
656     }
657
658     /**
659      * Add a member (dockable element) to container and returns its index
660      * @param member the member to add
661      * @return index of member in ArrayList
662      */
663     private int addMember(SwingScilabHelpBrowser member) {
664         // replace the current content pane
665         this.setContentPane(member);
666         return this.getComponentZOrder(member);
667     }
668
669     /**
670      * Add a member (dockable element) to container and returns its index
671      * @param member the member to add
672      * @return index of member in ArrayList
673      */
674     @Override
675     public int addMember(Frame member) {
676         return this.addMember((SwingScilabFrame) member.getAsSimpleFrame());
677     }
678
679     /**
680      * Add a member (dockable element) to container and returns its index
681      * @param member the member to add
682      * @return index of member in ArrayList
683      */
684     private int addMember(SwingScilabFrame member) {
685         return contentPane.addFrame(member);
686     }
687
688     /**
689      * Remove a Frame from its container
690      * @param member the Frame to remove
691      */
692     @Override
693     public void removeMember(Frame member) {
694         this.removeMember((SwingScilabFrame) member.getAsSimpleFrame());
695     }
696
697     /**
698      * Remove a Frame from its container
699      * @param member the Frame to remove
700      */
701     private void removeMember(SwingScilabFrame member) {
702         contentPane.removeFrame(member);
703     }
704
705     /**
706      * Add a member (dockable element) to container and returns its index
707      * @param member the member to add
708      * @return index of member in ArrayList
709      */
710     @Override
711     public int addMember(PushButton member) {
712         return this.addMember((SwingScilabPushButton) member.getAsSimplePushButton());
713     }
714
715     /**
716      * Add a member (dockable element) to container and returns its index
717      * @param member the member to add
718      * @return index of member in ArrayList
719      */
720     private int addMember(SwingScilabPushButton member) {
721         int res = contentPane.addWidget(member);
722         repaint();
723         return res;
724     }
725
726     /**
727      * Remove a PushButton from its container
728      * @param member the PushButton to remove
729      */
730     @Override
731     public void removeMember(PushButton member) {
732         this.removeMember((SwingScilabPushButton) member.getAsSimplePushButton());
733     }
734
735     /**
736      * Remove a PushButton from its container
737      * @param member the PushButton to remove
738      */
739     private void removeMember(SwingScilabPushButton member) {
740         contentPane.remove(member);
741     }
742
743     /**
744      * Add a member (dockable element) to container and returns its index
745      * @param member the member to add
746      * @return index of member in ArrayList
747      */
748     @Override
749     public int addMember(EditBox member) {
750         return this.addMember((SwingScilabEditBox) member.getAsSimpleEditBox());
751     }
752
753     /**
754      * Add a member (dockable element) to container and returns its index
755      * @param member the member to add
756      * @return index of member in ArrayList
757      */
758     private int addMember(SwingScilabEditBox member) {
759         return contentPane.addWidget(member);
760     }
761
762     /**
763      * Remove an EditBox from its container
764      * @param member the EditBox to remove
765      */
766     @Override
767     public void removeMember(EditBox member) {
768         this.removeMember((SwingScilabEditBox) member.getAsSimpleEditBox());
769     }
770
771     /**
772      * Remove an EditBox from its container
773      * @param member the EditBox to remove
774      */
775     private void removeMember(SwingScilabEditBox member) {
776         contentPane.removeWidget(member);
777     }
778
779     /**
780      * Add a member (dockable element) to container and returns its index
781      * @param member the member to add
782      * @return index of member in ArrayList
783      */
784     @Override
785     public int addMember(Label member) {
786         return this.addMember((SwingScilabLabel) member.getAsSimpleLabel());
787     }
788
789     /**
790      * Add a member (dockable element) to container and returns its index
791      * @param member the member to add
792      * @return index of member in ArrayList
793      */
794     private int addMember(SwingScilabLabel member) {
795         return contentPane.addWidget(member);
796     }
797
798     /**
799      * Remove a Label from its container
800      * @param member the Label to remove
801      */
802     @Override
803     public void removeMember(Label member) {
804         this.removeMember((SwingScilabLabel) member.getAsSimpleLabel());
805     }
806
807     /**
808      * Remove a Label from its container
809      * @param member the Label to remove
810      */
811     private void removeMember(SwingScilabLabel member) {
812         contentPane.removeWidget(member);
813     }
814
815     /**
816      * Add a member (dockable element) to container and returns its index
817      * @param member the member to add
818      * @return index of member in ArrayList
819      */
820     @Override
821     public int addMember(CheckBox member) {
822         return this.addMember((SwingScilabCheckBox) member.getAsSimpleCheckBox());
823     }
824
825     /**
826      * Add a member (dockable element) to container and returns its index
827      * @param member the member to add
828      * @return index of member in ArrayList
829      */
830     private int addMember(SwingScilabCheckBox member) {
831         return contentPane.addWidget(member);
832     }
833
834     /**
835      * Remove a CheckBox from its container
836      * @param member the CheckBox to remove
837      */
838     @Override
839     public void removeMember(CheckBox member) {
840         this.removeMember((SwingScilabCheckBox) member.getAsSimpleCheckBox());
841     }
842
843     /**
844      * Remove a CheckBox from its container
845      * @param member the CheckBox to remove
846      */
847     private void removeMember(SwingScilabCheckBox member) {
848         contentPane.removeWidget(member);
849     }
850
851     /**
852      * Add a member (dockable element) to container and returns its index
853      * @param member the member to add
854      * @return index of member in ArrayList
855      */
856     @Override
857     public int addMember(RadioButton member) {
858         return this.addMember((SwingScilabRadioButton) member.getAsSimpleRadioButton());
859     }
860
861     /**
862      * Add a member (dockable element) to container and returns its index
863      * @param member the member to add
864      * @return index of member in ArrayList
865      */
866     private int addMember(SwingScilabRadioButton member) {
867         return contentPane.addWidget(member);
868     }
869
870     /**
871      * Remove a RadioButton from its container
872      * @param member the RadioButton to remove
873      */
874     @Override
875     public void removeMember(RadioButton member) {
876         this.removeMember((SwingScilabRadioButton) member.getAsSimpleRadioButton());
877     }
878
879     /**
880      * Remove a RadioButton from its container
881      * @param member the RadioButton to remove
882      */
883     private void removeMember(SwingScilabRadioButton member) {
884         contentPane.removeWidget(member);
885     }
886
887     /**
888      * Add a member (dockable element) to container and returns its index
889      * @param member the member to add
890      * @return index of member in ArrayList
891      */
892     private int addMember(SwingScilabUiImage member) {
893         return contentPane.addWidget(member);
894     }
895
896     /**
897      * Remove a Image from its container
898      * @param member the Image to remove
899      */
900     private void removeMember(SwingScilabUiImage member) {
901         contentPane.removeWidget(member);
902     }
903
904     /**
905      * Add a member (dockable element) to container and returns its index
906      * @param member the member to add
907      * @return index of member in ArrayList
908      */
909     public int addMember(UiDisplayTree member) {
910         return this.addMember((SwingScilabUiDisplayTree) member.getAsSimpleUiDisplayTree());
911     }
912
913     /**
914      * Add a member (dockable element) to container and returns its index
915      * @param member the member to add
916      * @return index of member in ArrayList
917      */
918     private int addMember(SwingScilabUiDisplayTree member) {
919         return contentPane.addWidget(member);
920     }
921
922     /**
923      * Remove a Tree from its container
924      * @param member the Tree to remove
925      */
926     public void removeMember(UiDisplayTree member) {
927         this.removeMember((SwingScilabUiDisplayTree) member.getAsSimpleUiDisplayTree());
928     }
929
930     /**
931      * Remove a Tree from its container
932      * @param member the Tree to remove
933      */
934     private void removeMember(SwingScilabUiDisplayTree member) {
935         contentPane.removeWidget(member);
936     }
937
938     /**
939      * Add a member (dockable element) to container and returns its index
940      * @param member the member to add
941      * @return index of member in ArrayList
942      */
943     public int addMember(UiTable member) {
944         return this.addMember((SwingScilabUiTable) member.getAsSimpleUiTable());
945     }
946
947     /**
948      * Add a member (dockable element) to container and returns its index
949      * @param member the member to add
950      * @return index of member in ArrayList
951      */
952     private int addMember(SwingScilabUiTable member) {
953         return contentPane.addWidget(member);
954     }
955
956     /**
957      * Remove a UiTable from its container
958      * @param member the UiTable to remove
959      */
960     public void removeMember(UiTable member) {
961         this.removeMember((SwingScilabUiTable) member.getAsSimpleUiTable());
962     }
963
964     /**
965      * Remove a UiTable from its container
966      * @param member the UiTable to remove
967      */
968     private void removeMember(SwingScilabUiTable member) {
969         contentPane.removeWidget(member);
970     }
971
972     /**
973      * Add a member (dockable element) to container and returns its index
974      * @param member the member to add
975      * @return index of member in ArrayList
976      */
977     public int addMember(Slider member) {
978         return this.addMember((SwingScilabSlider) member.getAsSimpleSlider());
979     }
980
981     /**
982      * Add a member (dockable element) to container and returns its index
983      * @param member the member to add
984      * @return index of member in ArrayList
985      */
986     private int addMember(SwingScilabSlider member) {
987         return contentPane.addWidget(member);
988     }
989
990     /**
991      * Remove a Slider from its container
992      * @param member the Slider to remove
993      */
994     @Override
995     public void removeMember(Slider member) {
996         this.removeMember((SwingScilabSlider) member.getAsSimpleSlider());
997     }
998
999     /**
1000      * Remove a Slider from its container
1001      * @param member the Slider to remove
1002      */
1003     private void removeMember(SwingScilabSlider member) {
1004         contentPane.removeWidget(member);
1005     }
1006
1007     /**
1008      * Add a member (dockable element) to container and returns its index
1009      * @param member the member to add
1010      * @return index of member in ArrayList
1011      */
1012     @Override
1013     public int addMember(ListBox member) {
1014         return this.addMember((SwingScilabListBox) member.getAsSimpleListBox());
1015     }
1016
1017     /**
1018      * Add a member (dockable element) to container and returns its index
1019      * @param member the member to add
1020      * @return index of member in ArrayList
1021      */
1022     private int addMember(SwingScilabListBox member) {
1023         return contentPane.addWidget(member);
1024     }
1025
1026     /**
1027      * Remove a ListBox from its container
1028      * @param member the ListBox to remove
1029      */
1030     @Override
1031     public void removeMember(ListBox member) {
1032         this.removeMember((SwingScilabListBox) member.getAsSimpleListBox());
1033     }
1034
1035     /**
1036      * Remove a ListBox from its container
1037      * @param member the ListBox to remove
1038      */
1039     private void removeMember(SwingScilabListBox member) {
1040         contentPane.removeWidget(member);
1041     }
1042
1043     /**
1044      * Add a member (dockable element) to container and returns its index
1045      * @param member the member to add
1046      * @return index of member in ArrayList
1047      */
1048     @Override
1049     public int addMember(PopupMenu member) {
1050         return this.addMember((SwingScilabPopupMenu) member.getAsSimplePopupMenu());
1051     }
1052
1053     /**
1054      * Add a member (dockable element) to container and returns its index
1055      * @param member the member to add
1056      * @return index of member in ArrayList
1057      */
1058     private int addMember(SwingScilabPopupMenu member) {
1059         return contentPane.addWidget(member);
1060     }
1061
1062     /**
1063      * Remove a PopupMenu from its container
1064      * @param member the PopupMenu to remove
1065      */
1066     @Override
1067     public void removeMember(PopupMenu member) {
1068         this.removeMember((SwingScilabPopupMenu) member.getAsSimplePopupMenu());
1069     }
1070
1071     /**
1072      * Remove a PopupMenu from its container
1073      * @param member the PopupMenu to remove
1074      */
1075     private void removeMember(SwingScilabPopupMenu member) {
1076         contentPane.removeWidget(member);
1077     }
1078
1079     /**
1080      * Add a Tree member (dockable element) to container and returns its index
1081      * @param member the member to add
1082      * @return index of member in ArrayList
1083      */
1084     @Override
1085     public int addMember(Tree member) {
1086         return this.addMember((SwingScilabTree) member.getAsSimpleTree());
1087     }
1088
1089     /**
1090      * Add a Tree member (dockable element) to container and returns its index
1091      * @param member the member to add
1092      * @return index of member in ArrayList
1093      */
1094     public int addMember(SwingScilabTree member) {
1095         return contentPane.addWidget(member.getAsComponent());
1096     }
1097
1098     /**
1099      * Add a Tree member (dockable element) to container and returns its index
1100      * @param member the member to add
1101      * @return index of member in ArrayList
1102      */
1103     public int addTree(SwingScilabTree member) {
1104         this.setContentPane(member.getAsComponent());
1105         return this.getComponentZOrder(member.getAsComponent());
1106     }
1107
1108     /**
1109      * Remove a PopupMenu from its container
1110      * @param member the PopupMenu to remove
1111      */
1112     @Override
1113     public void removeMember(Tree member) {
1114         this.removeMember((SwingScilabTree) member.getAsSimpleTree());
1115     }
1116
1117     /**
1118      * Remove a PopupMenu from its container
1119      * @param member the PopupMenu to remove
1120      */
1121     private void removeMember(SwingScilabTree member) {
1122         contentPane.removeTree(member);
1123     }
1124
1125     /**
1126      * Add a member (dockable element) to container and returns its index
1127      * @param member the member to add
1128      * @return index of member in ArrayList
1129      */
1130     public int addMember(Dockable member) {
1131         // TODO Auto-generated method stub
1132         return 0;
1133     }
1134
1135     /**
1136      * Get the current status of the Tab in its parent
1137      * @return true is the tab is the tab currently "on top" in its parent
1138      */
1139     @Override
1140     public boolean isCurrentTab() {
1141         // TODO should not always return TRUE
1142         return true;
1143     }
1144
1145     /**
1146      * Get the parent window id for this tab
1147      * @return the id of the parent window
1148      */
1149     @Override
1150     public String getParentWindowId() {
1151         return this.parentWindowId;
1152     }
1153
1154     /**
1155      * Get the canvas
1156      * @return the canvas
1157      */
1158     public SwingScilabCanvas getContentCanvas() {
1159         return contentCanvas;
1160     }
1161
1162     /**
1163      * Set the parent window id for this tab
1164      * @param id the id of the parent window
1165      */
1166     @Override
1167     public void setParentWindowId(String id) {
1168         this.parentWindowId = id;
1169     }
1170
1171     /**
1172      * Setter for MenuBar
1173      * @param newMenuBar : the MenuBar to set.
1174      * @see org.scilab.modules.gui.tab.SimpleTab#setMenuBar(org.scilab.modules.gui.menubar.MenuBar)
1175      */
1176     @Override
1177     public void setMenuBar(MenuBar newMenuBar) {
1178         if (this.menuBar != newMenuBar) {
1179             if (this.menuBar != null) {
1180                 ((SwingScilabMenuBar) this.menuBar.getAsSimpleMenuBar()).close();
1181             }
1182             this.menuBar = newMenuBar;
1183         }
1184     }
1185
1186     /**
1187      * Getter for MenuBar
1188      * @return MenuBar : the MenuBar associated to the Tab.
1189      * @see org.scilab.modules.gui.tab.SimpleTab#getMenuBar()
1190      */
1191     @Override
1192     public MenuBar getMenuBar() {
1193         return this.menuBar;
1194     }
1195
1196     /**
1197      * Setter for ToolBar
1198      * @param newToolBar : the ToolBar to set.
1199      * @see org.scilab.modules.gui.tab.SimpleTab#setToolBar(org.scilab.modules.gui.toolbar.ToolBar)
1200      */
1201     @Override
1202     public void setToolBar(ToolBar newToolBar) {
1203         if (this.toolBar != newToolBar) {
1204             if (this.toolBar != null) {
1205                 ((SwingScilabToolBar) this.toolBar.getAsSimpleToolBar()).close();
1206             }
1207             this.toolBar = newToolBar;
1208         }
1209     }
1210
1211     /**
1212      * Getter for ToolBar
1213      * @return ToolBar : the ToolBar associated to the Tab.
1214      * @see org.scilab.modules.gui.tab.SimpleTab#getToolBar()
1215      */
1216     @Override
1217     public ToolBar getToolBar() {
1218         return this.toolBar;
1219     }
1220
1221     /**
1222      * Setter for InfoBar
1223      * @param newInfoBar the InfoBar to set.
1224      */
1225     @Override
1226     public void setInfoBar(TextBox newInfoBar) {
1227         this.infoBar = newInfoBar;
1228     }
1229
1230     /**
1231      * Getter for InfoBar
1232      * @return the InfoBar associated to the Tab.
1233      */
1234     @Override
1235     public TextBox getInfoBar() {
1236         return this.infoBar;
1237     }
1238
1239     /**
1240      * Set the callback of the tab
1241      * @param callback the callback to set.
1242      */
1243     @Override
1244     public void setCallback(CommonCallBack callback) {
1245
1246         if (closeAction != null) {
1247             this.getTitlebar().removeAction(closeAction);
1248         }
1249
1250         if (callback != null) {
1251             closeAction = new SciClosingAction(this, callback);
1252         } else {
1253             closeAction = new SciClosingAction(this);
1254         }
1255
1256         closeAction.putValue(Action.NAME, DockingConstants.CLOSE_ACTION);
1257         ((Titlebar) getTitlePane()).removeAction(DockingConstants.CLOSE_ACTION);
1258         addAction(closeAction);
1259
1260         /* Undock button */
1261         SciUndockingAction undockAction = new SciUndockingAction(this);
1262         undockAction.putValue(Action.NAME, UNDOCK);
1263         ((Titlebar) getTitlePane()).removeAction(UNDOCK);
1264         addAction(undockAction);
1265
1266         /* Help button */
1267         SciHelpOnComponentAction helpAction = new SciHelpOnComponentAction(this);
1268         helpAction.putValue(Action.NAME, HELP);
1269         ((Titlebar) getTitlePane()).removeAction(HELP);
1270         addAction(helpAction);
1271     }
1272
1273     /**
1274      * Set this tab as the current tab of its parent Window
1275      */
1276     @Override
1277     public void setCurrent() {
1278         ActiveDockableTracker.requestDockableActivation(this);
1279     }
1280
1281     /**
1282      * Set the background color of the tab.
1283      * @param red red channel of the color
1284      * @param green green channel
1285      * @param blue blue channel
1286      */
1287     @Override
1288     public void setBackground(double red, double green, double blue) {
1289         Color newColor = new Color((float) red, (float) green, (float) blue);
1290         contentPane.setBackground(red, green, blue);
1291         uiContentPane.setBackground(newColor);
1292         scrolling.setBackground(red, green, blue);
1293         setBackground(newColor);
1294     }
1295
1296     /**
1297      * Get the part of the axes which is currently viewed
1298      * @return [x,y,w,h] array
1299      */
1300     @Override
1301     public int[] getViewingRegion() {
1302         return scrolling.getViewingRegion();
1303     }
1304
1305     /**
1306      * Specify a new viewport for the axes
1307      * For SwingScilabCanvas viewport can not be modified
1308      * since it match the parent tab size
1309      * @param posX X coordinate of upper left point of the viewport within the axes
1310      * @param posY Y coordinate of upper left point of the viewport within the axes
1311      * @param width width of the viewport
1312      * @param height height of the viewport
1313      */
1314     @Override
1315     public void setViewingRegion(int posX, int posY, int width, int height) {
1316     }
1317
1318     /**
1319      * Set the event handler of the Canvas
1320      * @param funName the name of the Scilab function to call
1321      */
1322     public void setEventHandler(String funName) {
1323         disableEventHandler();
1324         eventHandler = new ScilabEventListener(funName, getId());
1325         if (eventEnabled) {
1326             editorEventHandler.setEnable(false);
1327             enableEventHandler();
1328         }
1329     }
1330
1331     /**
1332      * Set the status of the event handler of the Canvas
1333      * @param status is true to set the event handler active
1334      */
1335     public void setEventHandlerEnabled(boolean status) {
1336         if (status && eventEnabled) {
1337             return;
1338         }
1339
1340         if (status) {
1341             editorEventHandler.setEnable(false);
1342             enableEventHandler();
1343             eventEnabled = true;
1344         } else {
1345             editorEventHandler.setEnable(true);
1346             disableEventHandler();
1347             eventEnabled = false;
1348         }
1349     }
1350
1351     /**
1352      * Specify whether the canvas should fit the parent tab size
1353      * (and consequently the scrollpane size) or not
1354      * @param onOrOff true to enable autoresize mode
1355      */
1356     @Override
1357     public void setAutoResizeMode(boolean onOrOff) {
1358     }
1359
1360     /**
1361      * @return whether the resize mode is on or off
1362      */
1363     @Override
1364     public boolean getAutoResizeMode() {
1365         return true;
1366     }
1367
1368     /**
1369      * Close the tab and disable it.
1370      */
1371     public void close() {
1372         if (getTitlePane() != null) {
1373             ((Titlebar) getTitlePane()).removeAction(DockingConstants.CLOSE_ACTION);
1374             ((Titlebar) getTitlePane()).removeAction(UNDOCK);
1375             ((Titlebar) getTitlePane()).removeAction(HELP);
1376         }
1377
1378         setMenuBar(null);
1379         setToolBar(null);
1380         setInfoBar(null);
1381         setTitlebar(null);
1382         removeAll();
1383         //setActive(false);
1384
1385         scrolling = null;
1386         contentPane = null;
1387         DockingManager.unregisterDockable((Component) this);
1388
1389         // without this children canvas are not released.
1390         Container dummyContainer = new Container();
1391         this.setContentPane(dummyContainer);
1392         if (editorEventHandler != null) {
1393             editorEventHandler.onExit();
1394         }
1395     }
1396
1397     public void disablePaint() {
1398         paintEnable = false;
1399     }
1400
1401     /**
1402      * Redefine paint children to be sure that AWT components are well painted.
1403      *  @param g a Graphics
1404      */
1405     @Override
1406     public void paintChildren(Graphics g) {
1407         if (paintEnable) {
1408             Component[] children = getComponents();
1409             for (int i = 0; i < children.length; i++) {
1410                 // AWT children don't draw themselves automatically
1411                 // so force their draw
1412                 if (!children[i].isLightweight()) {
1413                     children[i].paint(g);
1414                 }
1415             }
1416             super.paintChildren(g);
1417         }
1418     }
1419
1420     /**
1421      * Update the tab after a modification of its properties
1422      * @param property the property name
1423      * @param value the property value
1424      * @see org.scilab.modules.gui.SwingViewObject#update(java.lang.String, java.lang.Object)
1425      */
1426     public void update(int property, Object value) {
1427         SwingScilabCommonPanel.update(this, property, value);
1428     }
1429
1430     /**
1431      * Get the tab UID
1432      * @return the UID
1433      * @see org.scilab.modules.gui.SwingViewObject#getId()
1434      */
1435     public Integer getId() {
1436         return id;
1437     }
1438
1439     /**
1440      * Set the tab UID
1441      * @param id the UID
1442      * @see org.scilab.modules.gui.SwingViewObject#setId(java.lang.String)
1443      */
1444     public void setId(Integer id) {
1445         this.id = id;
1446     }
1447
1448     /**
1449      * Turn on event handling.
1450      */
1451     private void enableEventHandler() {
1452         contentCanvas.addEventHandlerKeyListener(eventHandler);
1453         contentCanvas.addEventHandlerMouseListener(eventHandler);
1454         contentCanvas.addEventHandlerMouseMotionListener(eventHandler);
1455     }
1456
1457     /**
1458      * Turn off event handling.
1459      */
1460     private void disableEventHandler() {
1461         if (eventHandler != null) {
1462             contentCanvas.removeEventHandlerKeyListener(eventHandler);
1463             contentCanvas.removeEventHandlerMouseListener(eventHandler);
1464             contentCanvas.removeEventHandlerMouseMotionListener(eventHandler);
1465         }
1466     }
1467
1468     public void keyPressed(KeyEvent e) {
1469
1470     }
1471
1472     public void keyReleased(KeyEvent e) {
1473     }
1474
1475     public void keyTyped(KeyEvent e) {
1476         if (ScilabConstants.isGUI() && (eventHandler == null || !eventEnabled) && !GlobalEventWatcher.isActivated() && !editorEventHandler.isDatatipEnable() && Character.isLetterOrDigit(e.getKeyChar())) {
1477             SwingScilabConsole console = (SwingScilabConsole) ScilabConsole.getConsole().getAsSimpleConsole();
1478             JTextPane input = (JTextPane) console.getConfiguration().getInputCommandView();
1479             input.requestFocus();
1480             SwingScilabWindow win = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, console);
1481             win.toFront();
1482             input.dispatchEvent(new KeyEvent(input, KeyEvent.KEY_TYPED, System.currentTimeMillis(), e.getModifiers(), e.getKeyCode(), e.getKeyChar(), e.getKeyLocation()));
1483         }
1484     }
1485     
1486     public JLayeredPane getWidgetPane() {
1487         return uiContentPane;
1488     }
1489 }