Refactor SwingScilabWindow and SwingScilabPanel
[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, canvas, uiContentPane, figure);
288
289         contentCanvas.addKeyListener(this);
290
291         setContentPane(scrolling.getAsContainer());
292         //setContentPane(uiContentPane);
293         canvas.setVisible(true);
294         uiContentPane.setVisible(true);
295
296         /* Manage figure_position property */
297         addHierarchyBoundsListener(new HierarchyBoundsListener() {
298             public void ancestorResized(HierarchyEvent arg0) {
299             }
300
301             public void ancestorMoved(HierarchyEvent e) {
302                 if (e.getChanged() instanceof SwingScilabWindow) {
303                     Position parentPosition = SwingScilabWindow.allScilabWindows.get(parentWindowId).getPosition();
304                     Integer[] newPosition = new Integer[] {parentPosition.getX(), parentPosition.getY()};
305                     GraphicController.getController().setProperty(id, __GO_POSITION__, newPosition);
306                 }
307             }
308         });
309
310         /* Manage figure_size property */
311         addComponentListener(new ComponentListener() {
312
313             public void componentShown(ComponentEvent arg0) {
314             }
315
316             public void componentResized(ComponentEvent arg0) {
317
318                 /* Update the figure_size property */
319                 Size parentSize =  SwingScilabWindow.allScilabWindows.get(parentWindowId).getDims();
320                 Integer[] newSize = new Integer[] {parentSize.getWidth(), parentSize.getHeight()};
321
322                 GraphicController.getController().setProperty(id, __GO_SIZE__, newSize);
323
324                 Boolean autoreSize = (Boolean) GraphicController.getController().getProperty(id, __GO_AUTORESIZE__);
325
326                 if (autoreSize != null && autoreSize) {
327                     /* Update the axes_size property */
328                     Integer[] newAxesSize = new Integer[] {getContentPane().getWidth(), getContentPane().getHeight()};
329                     GraphicController.getController().setProperty(id, __GO_AXES_SIZE__, newAxesSize);
330                 }
331             }
332
333             public void componentMoved(ComponentEvent arg0) {
334             }
335
336             public void componentHidden(ComponentEvent arg0) {
337             }
338         });
339
340         /* Manage closerequestfcn */
341         ClosingOperationsManager.registerClosingOperation(SwingScilabDockablePanel.this, new ClosingOperationsManager.ClosingOperation() {
342
343             public int canClose() {
344                 String closeRequestFcn = (String) GraphicController.getController().getProperty(getId(), __GO_CLOSEREQUESTFCN__);
345                 if (!closeRequestFcn.equals("")) {
346                     String closeCommand = "if exists(\"gcbo\") then %oldgcbo = gcbo; end;"
347                                           + "gcbo = getcallbackobject(" + getId() + ");"
348                                           + closeRequestFcn + ";fire_closing_finished();"
349                                           + ";if exists(\"%oldgcbo\") then gcbo = %oldgcbo; else clear gcbo; end;";
350                     InterpreterManagement.requestScilabExec(closeCommand);
351                     return -1;
352                 } else {
353                     closeAction.actionPerformed(null);
354                     return 1;
355                 }
356             }
357
358             public void destroy() {
359             }
360
361             public String askForClosing(final List<SwingScilabDockablePanel> list) {
362                 return null;
363             }
364
365             @Override
366             public void updateDependencies(List<SwingScilabDockablePanel> list, ListIterator<SwingScilabDockablePanel> it) {
367
368             }
369         });
370         ClosingOperationsManager.addDependencyWithRoot(this);
371     }
372
373     /**
374      * @param e the FocusEvent
375      */
376     @Override
377     public void focusGained(FocusEvent e) {
378         //ActiveDockableTracker.requestDockableActivation(this);
379         if (contentPane != null) {
380             contentPane.requestFocus();
381         } else if (getContentPane() != null) {
382             getContentPane().requestFocus();
383         } else {
384             SwingScilabDockablePanel.this.requestFocusInWindow();
385         }
386     }
387
388     /**
389      * Call when the tab restoration is ended.
390      */
391     public void endedRestoration() { }
392
393     /**
394      * @return the window icon associated with this tab
395      */
396     public Image getWindowIcon() {
397         if (icon == null) {
398             return SCILAB_ICON;
399         } else {
400             return icon;
401         }
402     }
403
404     /**
405      * @param icon the window icon associated with this tab
406      */
407     public void setWindowIcon(Image icon) {
408         this.icon = icon;
409     }
410
411     /**
412      * @param iconName window icon associated with this tab
413      */
414     public void setWindowIcon(String iconName) {
415         setWindowIcon(new ImageIcon(ScilabSwingUtilities.findIcon(iconName, "256x256")).getImage());
416     }
417
418     /**
419      * @param e the FocusEvent
420      */
421     @Override
422     public void focusLost(FocusEvent e) { }
423
424     /**
425      * {@inheritDoc}
426      */
427     @Override
428     public void dockingComplete(DockingEvent evt) {
429         super.dockingComplete(evt);
430
431         DockingPort port = evt.getNewDockingPort();
432         SwingScilabWindow win = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, (Component) port);
433         Iterator iter = port.getDockables().iterator();
434
435         if (port.getDockables().size() > 1) {
436             while (iter.hasNext()) {
437                 Object d = iter.next();
438                 if (d instanceof SwingScilabDockablePanel) {
439                     SwingScilabDockablePanel view = (SwingScilabDockablePanel) d;
440                     addActions(view);
441                 }
442             }
443         } else {
444             removeActions(this);
445         }
446
447         if (win != null) {
448             setParentWindowId(win.getId());
449         } else {
450             // Should not occur
451             SwingUtilities.invokeLater(new Runnable() {
452                 public void run() {
453                     if (getParentWindow() != null) {
454                         setParentWindowId(getParentWindow().getId());
455                     } else {
456                         System.err.println("No window for tab:" + SwingScilabDockablePanel.this.getClass().getName() + " after docking complete");
457                     }
458                 }
459             });
460         }
461     }
462
463     /**
464      * Sets the Name of a swing Scilab tab
465      * @param newTabName the Name of the tab
466      * @see org.scilab.modules.gui.tab.ScilabTab#setName(String)
467      */
468     @Override
469     public void setName(String newTabName) {
470         setTitle(newTabName, true);
471         getTitlePane().repaint();
472         SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this).setName(newTabName);
473     }
474
475     /**
476      * @return the UUID of the parent window
477      */
478     public String getParentWindowUUID() {
479         return ((SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this)).getUUID();
480     }
481
482     /**
483      * @return the UUID of the parent window
484      */
485     public SwingScilabWindow getParentWindow() {
486         return (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, this);
487     }
488
489     /**
490      * Gets the title of a swing Scilab tab
491      * @return the title of the tab
492      * @see org.scilab.modules.gui.tab.ScilabTab#getName()
493      */
494     @Override
495     public String getName() {
496         return this.getTitle();
497     }
498
499     /**
500      * Paint immediately this component
501      */
502     public void paintImmediately() {
503         // paint all
504         paintImmediately(0, 0, getWidth(), getHeight());
505     }
506
507     /**
508      * Draws a swing Scilab tab
509      * @see org.scilab.modules.gui.uielement.UIElement#draw()
510      */
511     @Override
512     public void draw() {
513         if (SwingUtilities.isEventDispatchThread()) {
514             setVisible(true);
515             paintImmediately();
516         } else {
517             try {
518                 SwingUtilities.invokeAndWait(new Runnable() {
519                     @Override
520                     public void run() {
521                         setVisible(true);
522                         paintImmediately();
523                     }
524                 });
525             } catch (InterruptedException e) {
526                 e.printStackTrace();
527             } catch (InvocationTargetException e) {
528                 e.printStackTrace();
529             }
530         }
531
532     }
533
534     /**
535      * Gets the dimensions (width and height) of a swing Scilab tab
536      * @return the dimensions of the tab
537      * @see org.scilab.modules.gui.uielement.UIElement#getDims()
538      */
539     @Override
540     public Size getDims() {
541         return new Size(this.getSize().width, this.getSize().height);
542     }
543
544     /**
545      * Get the size for the axes
546      * @return size of the axes in pixels
547      */
548     @Override
549     public Size getAxesSize() {
550         return new Size(contentPane.getWidth(), contentPane.getHeight());
551     }
552
553     /**
554      * @param newSize new size to set for the axes
555      */
556     @Override
557     public void setAxesSize(Size newSize) {
558         contentPane.setSize(new Dimension(newSize.getWidth(), newSize.getHeight()));
559         uiContentPane.setSize(new Dimension(newSize.getWidth(), newSize.getHeight()));
560     }
561
562     /**
563      * Gets the position (X-coordinate and Y-coordinate) of a swing Scilab tab
564      * @return the position of the tab
565      * @see org.scilab.modules.gui.uielement.UIElement#getPosition()
566      */
567     @Override
568     public Position getPosition() {
569         return new Position(this.getX(), this.getY());
570     }
571
572     /**
573      * Sets the dimensions (width and height) of a swing Scilab tab
574      * @param newSize the dimensions we want to set to the tab
575      * @see org.scilab.modules.gui.uielement.UIElement#setDims(org.scilab.modules.gui.utils.Size)
576      */
577     @Override
578     public void setDims(Size newSize) {
579         this.setSize(newSize.getWidth(), newSize.getHeight());
580     }
581
582     /**
583      * Sets the position (X-coordinate and Y-coordinate) of a swing Scilab tab
584      * @param newPosition the position we want to set to the tab
585      * @see org.scilab.modules.gui.uielement.UIElement#setPosition(org.scilab.modules.gui.utils.Position)
586      */
587     @Override
588     public void setPosition(Position newPosition) {
589         this.setLocation(newPosition.getX(), newPosition.getY());
590     }
591
592     /**
593      * Add a member (dockable element) to container and returns its index
594      * @param member the member to add
595      * @return index of member in ArrayList
596      */
597     @Override
598     public int addMember(Canvas member) {
599         return 0;
600     }
601
602     /**
603      * We want to be able to remove directly a Canvas from a Tab.
604      * @param member canvas to remove
605      */
606     @Override
607     public void removeMember(Canvas member) {
608     }
609
610     /**
611      * Add a SwingViewObject (from SwingView.java) to container and returns its index
612      * @param member the member to add
613      */
614     public void addMember(SwingViewObject member) {
615         SwingScilabCommonPanel.addMember(this, member);
616     }
617
618     /**
619      * Remove a SwingViewObject (from SwingView.java)
620      * @param member the member to remove
621      */
622     public void removeMember(SwingViewObject member) {
623         uiContentPane.remove((Component) member);
624     }
625
626     /**
627      * Add a member (dockable element) to container and returns its index
628      * @param member the member to add
629      * @return index of member in ArrayList
630      */
631     @Override
632     public int addMember(Console member) {
633         return this.addMember((SwingScilabConsole) member.getAsSimpleConsole());
634     }
635
636     /**
637      * Add a member (dockable element) to container and returns its index
638      * @param member the member to add
639      * @return index of member in ArrayList
640      */
641     private int addMember(SwingScilabConsole member) {
642         // replace the current content pane
643         this.setContentPane(member);
644         return this.getComponentZOrder(member);
645     }
646
647     /**
648      * Add a member (dockable element) to container and returns its index
649      * @param member the member to add
650      * @return index of member in ArrayList
651      */
652     @Override
653     public int addMember(HelpBrowser member) {
654         return this.addMember((SwingScilabHelpBrowser) member.getAsSimpleHelpBrowser());
655     }
656
657     /**
658      * Add a member (dockable element) to container and returns its index
659      * @param member the member to add
660      * @return index of member in ArrayList
661      */
662     private int addMember(SwingScilabHelpBrowser member) {
663         // replace the current content pane
664         this.setContentPane(member);
665         return this.getComponentZOrder(member);
666     }
667
668     /**
669      * Add a member (dockable element) to container and returns its index
670      * @param member the member to add
671      * @return index of member in ArrayList
672      */
673     @Override
674     public int addMember(Frame member) {
675         return this.addMember((SwingScilabFrame) member.getAsSimpleFrame());
676     }
677
678     /**
679      * Add a member (dockable element) to container and returns its index
680      * @param member the member to add
681      * @return index of member in ArrayList
682      */
683     private int addMember(SwingScilabFrame member) {
684         return contentPane.addFrame(member);
685     }
686
687     /**
688      * Remove a Frame from its container
689      * @param member the Frame to remove
690      */
691     @Override
692     public void removeMember(Frame member) {
693         this.removeMember((SwingScilabFrame) member.getAsSimpleFrame());
694     }
695
696     /**
697      * Remove a Frame from its container
698      * @param member the Frame to remove
699      */
700     private void removeMember(SwingScilabFrame member) {
701         contentPane.removeFrame(member);
702     }
703
704     /**
705      * Add a member (dockable element) to container and returns its index
706      * @param member the member to add
707      * @return index of member in ArrayList
708      */
709     @Override
710     public int addMember(PushButton member) {
711         return this.addMember((SwingScilabPushButton) member.getAsSimplePushButton());
712     }
713
714     /**
715      * Add a member (dockable element) to container and returns its index
716      * @param member the member to add
717      * @return index of member in ArrayList
718      */
719     private int addMember(SwingScilabPushButton member) {
720         int res = contentPane.addWidget(member);
721         repaint();
722         return res;
723     }
724
725     /**
726      * Remove a PushButton from its container
727      * @param member the PushButton to remove
728      */
729     @Override
730     public void removeMember(PushButton member) {
731         this.removeMember((SwingScilabPushButton) member.getAsSimplePushButton());
732     }
733
734     /**
735      * Remove a PushButton from its container
736      * @param member the PushButton to remove
737      */
738     private void removeMember(SwingScilabPushButton member) {
739         contentPane.remove(member);
740     }
741
742     /**
743      * Add a member (dockable element) to container and returns its index
744      * @param member the member to add
745      * @return index of member in ArrayList
746      */
747     @Override
748     public int addMember(EditBox member) {
749         return this.addMember((SwingScilabEditBox) member.getAsSimpleEditBox());
750     }
751
752     /**
753      * Add a member (dockable element) to container and returns its index
754      * @param member the member to add
755      * @return index of member in ArrayList
756      */
757     private int addMember(SwingScilabEditBox member) {
758         return contentPane.addWidget(member);
759     }
760
761     /**
762      * Remove an EditBox from its container
763      * @param member the EditBox to remove
764      */
765     @Override
766     public void removeMember(EditBox member) {
767         this.removeMember((SwingScilabEditBox) member.getAsSimpleEditBox());
768     }
769
770     /**
771      * Remove an EditBox from its container
772      * @param member the EditBox to remove
773      */
774     private void removeMember(SwingScilabEditBox member) {
775         contentPane.removeWidget(member);
776     }
777
778     /**
779      * Add a member (dockable element) to container and returns its index
780      * @param member the member to add
781      * @return index of member in ArrayList
782      */
783     @Override
784     public int addMember(Label member) {
785         return this.addMember((SwingScilabLabel) member.getAsSimpleLabel());
786     }
787
788     /**
789      * Add a member (dockable element) to container and returns its index
790      * @param member the member to add
791      * @return index of member in ArrayList
792      */
793     private int addMember(SwingScilabLabel member) {
794         return contentPane.addWidget(member);
795     }
796
797     /**
798      * Remove a Label from its container
799      * @param member the Label to remove
800      */
801     @Override
802     public void removeMember(Label member) {
803         this.removeMember((SwingScilabLabel) member.getAsSimpleLabel());
804     }
805
806     /**
807      * Remove a Label from its container
808      * @param member the Label to remove
809      */
810     private void removeMember(SwingScilabLabel member) {
811         contentPane.removeWidget(member);
812     }
813
814     /**
815      * Add a member (dockable element) to container and returns its index
816      * @param member the member to add
817      * @return index of member in ArrayList
818      */
819     @Override
820     public int addMember(CheckBox member) {
821         return this.addMember((SwingScilabCheckBox) member.getAsSimpleCheckBox());
822     }
823
824     /**
825      * Add a member (dockable element) to container and returns its index
826      * @param member the member to add
827      * @return index of member in ArrayList
828      */
829     private int addMember(SwingScilabCheckBox member) {
830         return contentPane.addWidget(member);
831     }
832
833     /**
834      * Remove a CheckBox from its container
835      * @param member the CheckBox to remove
836      */
837     @Override
838     public void removeMember(CheckBox member) {
839         this.removeMember((SwingScilabCheckBox) member.getAsSimpleCheckBox());
840     }
841
842     /**
843      * Remove a CheckBox from its container
844      * @param member the CheckBox to remove
845      */
846     private void removeMember(SwingScilabCheckBox member) {
847         contentPane.removeWidget(member);
848     }
849
850     /**
851      * Add a member (dockable element) to container and returns its index
852      * @param member the member to add
853      * @return index of member in ArrayList
854      */
855     @Override
856     public int addMember(RadioButton member) {
857         return this.addMember((SwingScilabRadioButton) member.getAsSimpleRadioButton());
858     }
859
860     /**
861      * Add a member (dockable element) to container and returns its index
862      * @param member the member to add
863      * @return index of member in ArrayList
864      */
865     private int addMember(SwingScilabRadioButton member) {
866         return contentPane.addWidget(member);
867     }
868
869     /**
870      * Remove a RadioButton from its container
871      * @param member the RadioButton to remove
872      */
873     @Override
874     public void removeMember(RadioButton member) {
875         this.removeMember((SwingScilabRadioButton) member.getAsSimpleRadioButton());
876     }
877
878     /**
879      * Remove a RadioButton from its container
880      * @param member the RadioButton to remove
881      */
882     private void removeMember(SwingScilabRadioButton member) {
883         contentPane.removeWidget(member);
884     }
885
886     /**
887      * Add a member (dockable element) to container and returns its index
888      * @param member the member to add
889      * @return index of member in ArrayList
890      */
891     private int addMember(SwingScilabUiImage member) {
892         return contentPane.addWidget(member);
893     }
894
895     /**
896      * Remove a Image from its container
897      * @param member the Image to remove
898      */
899     private void removeMember(SwingScilabUiImage member) {
900         contentPane.removeWidget(member);
901     }
902
903     /**
904      * Add a member (dockable element) to container and returns its index
905      * @param member the member to add
906      * @return index of member in ArrayList
907      */
908     public int addMember(UiDisplayTree member) {
909         return this.addMember((SwingScilabUiDisplayTree) member.getAsSimpleUiDisplayTree());
910     }
911
912     /**
913      * Add a member (dockable element) to container and returns its index
914      * @param member the member to add
915      * @return index of member in ArrayList
916      */
917     private int addMember(SwingScilabUiDisplayTree member) {
918         return contentPane.addWidget(member);
919     }
920
921     /**
922      * Remove a Tree from its container
923      * @param member the Tree to remove
924      */
925     public void removeMember(UiDisplayTree member) {
926         this.removeMember((SwingScilabUiDisplayTree) member.getAsSimpleUiDisplayTree());
927     }
928
929     /**
930      * Remove a Tree from its container
931      * @param member the Tree to remove
932      */
933     private void removeMember(SwingScilabUiDisplayTree member) {
934         contentPane.removeWidget(member);
935     }
936
937     /**
938      * Add a member (dockable element) to container and returns its index
939      * @param member the member to add
940      * @return index of member in ArrayList
941      */
942     public int addMember(UiTable member) {
943         return this.addMember((SwingScilabUiTable) member.getAsSimpleUiTable());
944     }
945
946     /**
947      * Add a member (dockable element) to container and returns its index
948      * @param member the member to add
949      * @return index of member in ArrayList
950      */
951     private int addMember(SwingScilabUiTable member) {
952         return contentPane.addWidget(member);
953     }
954
955     /**
956      * Remove a UiTable from its container
957      * @param member the UiTable to remove
958      */
959     public void removeMember(UiTable member) {
960         this.removeMember((SwingScilabUiTable) member.getAsSimpleUiTable());
961     }
962
963     /**
964      * Remove a UiTable from its container
965      * @param member the UiTable to remove
966      */
967     private void removeMember(SwingScilabUiTable member) {
968         contentPane.removeWidget(member);
969     }
970
971     /**
972      * Add a member (dockable element) to container and returns its index
973      * @param member the member to add
974      * @return index of member in ArrayList
975      */
976     public int addMember(Slider member) {
977         return this.addMember((SwingScilabSlider) member.getAsSimpleSlider());
978     }
979
980     /**
981      * Add a member (dockable element) to container and returns its index
982      * @param member the member to add
983      * @return index of member in ArrayList
984      */
985     private int addMember(SwingScilabSlider member) {
986         return contentPane.addWidget(member);
987     }
988
989     /**
990      * Remove a Slider from its container
991      * @param member the Slider to remove
992      */
993     @Override
994     public void removeMember(Slider member) {
995         this.removeMember((SwingScilabSlider) member.getAsSimpleSlider());
996     }
997
998     /**
999      * Remove a Slider from its container
1000      * @param member the Slider to remove
1001      */
1002     private void removeMember(SwingScilabSlider member) {
1003         contentPane.removeWidget(member);
1004     }
1005
1006     /**
1007      * Add a member (dockable element) to container and returns its index
1008      * @param member the member to add
1009      * @return index of member in ArrayList
1010      */
1011     @Override
1012     public int addMember(ListBox member) {
1013         return this.addMember((SwingScilabListBox) member.getAsSimpleListBox());
1014     }
1015
1016     /**
1017      * Add a member (dockable element) to container and returns its index
1018      * @param member the member to add
1019      * @return index of member in ArrayList
1020      */
1021     private int addMember(SwingScilabListBox member) {
1022         return contentPane.addWidget(member);
1023     }
1024
1025     /**
1026      * Remove a ListBox from its container
1027      * @param member the ListBox to remove
1028      */
1029     @Override
1030     public void removeMember(ListBox member) {
1031         this.removeMember((SwingScilabListBox) member.getAsSimpleListBox());
1032     }
1033
1034     /**
1035      * Remove a ListBox from its container
1036      * @param member the ListBox to remove
1037      */
1038     private void removeMember(SwingScilabListBox member) {
1039         contentPane.removeWidget(member);
1040     }
1041
1042     /**
1043      * Add a member (dockable element) to container and returns its index
1044      * @param member the member to add
1045      * @return index of member in ArrayList
1046      */
1047     @Override
1048     public int addMember(PopupMenu member) {
1049         return this.addMember((SwingScilabPopupMenu) member.getAsSimplePopupMenu());
1050     }
1051
1052     /**
1053      * Add a member (dockable element) to container and returns its index
1054      * @param member the member to add
1055      * @return index of member in ArrayList
1056      */
1057     private int addMember(SwingScilabPopupMenu member) {
1058         return contentPane.addWidget(member);
1059     }
1060
1061     /**
1062      * Remove a PopupMenu from its container
1063      * @param member the PopupMenu to remove
1064      */
1065     @Override
1066     public void removeMember(PopupMenu member) {
1067         this.removeMember((SwingScilabPopupMenu) member.getAsSimplePopupMenu());
1068     }
1069
1070     /**
1071      * Remove a PopupMenu from its container
1072      * @param member the PopupMenu to remove
1073      */
1074     private void removeMember(SwingScilabPopupMenu member) {
1075         contentPane.removeWidget(member);
1076     }
1077
1078     /**
1079      * Add a Tree member (dockable element) to container and returns its index
1080      * @param member the member to add
1081      * @return index of member in ArrayList
1082      */
1083     @Override
1084     public int addMember(Tree member) {
1085         return this.addMember((SwingScilabTree) member.getAsSimpleTree());
1086     }
1087
1088     /**
1089      * Add a Tree member (dockable element) to container and returns its index
1090      * @param member the member to add
1091      * @return index of member in ArrayList
1092      */
1093     public int addMember(SwingScilabTree member) {
1094         return contentPane.addWidget(member.getAsComponent());
1095     }
1096
1097     /**
1098      * Add a Tree member (dockable element) to container and returns its index
1099      * @param member the member to add
1100      * @return index of member in ArrayList
1101      */
1102     public int addTree(SwingScilabTree member) {
1103         this.setContentPane(member.getAsComponent());
1104         return this.getComponentZOrder(member.getAsComponent());
1105     }
1106
1107     /**
1108      * Remove a PopupMenu from its container
1109      * @param member the PopupMenu to remove
1110      */
1111     @Override
1112     public void removeMember(Tree member) {
1113         this.removeMember((SwingScilabTree) member.getAsSimpleTree());
1114     }
1115
1116     /**
1117      * Remove a PopupMenu from its container
1118      * @param member the PopupMenu to remove
1119      */
1120     private void removeMember(SwingScilabTree member) {
1121         contentPane.removeTree(member);
1122     }
1123
1124     /**
1125      * Add a member (dockable element) to container and returns its index
1126      * @param member the member to add
1127      * @return index of member in ArrayList
1128      */
1129     public int addMember(Dockable member) {
1130         // TODO Auto-generated method stub
1131         return 0;
1132     }
1133
1134     /**
1135      * Get the current status of the Tab in its parent
1136      * @return true is the tab is the tab currently "on top" in its parent
1137      */
1138     @Override
1139     public boolean isCurrentTab() {
1140         // TODO should not always return TRUE
1141         return true;
1142     }
1143
1144     /**
1145      * Get the parent window id for this tab
1146      * @return the id of the parent window
1147      */
1148     @Override
1149     public String getParentWindowId() {
1150         return this.parentWindowId;
1151     }
1152
1153     /**
1154      * Get the canvas
1155      * @return the canvas
1156      */
1157     public SwingScilabCanvas getContentCanvas() {
1158         return contentCanvas;
1159     }
1160
1161     /**
1162      * Set the parent window id for this tab
1163      * @param id the id of the parent window
1164      */
1165     @Override
1166     public void setParentWindowId(String id) {
1167         this.parentWindowId = id;
1168     }
1169
1170     /**
1171      * Setter for MenuBar
1172      * @param newMenuBar : the MenuBar to set.
1173      * @see org.scilab.modules.gui.tab.SimpleTab#setMenuBar(org.scilab.modules.gui.menubar.MenuBar)
1174      */
1175     @Override
1176     public void setMenuBar(MenuBar newMenuBar) {
1177         if (this.menuBar != newMenuBar) {
1178             if (this.menuBar != null) {
1179                 ((SwingScilabMenuBar) this.menuBar.getAsSimpleMenuBar()).close();
1180             }
1181             this.menuBar = newMenuBar;
1182         }
1183     }
1184
1185     /**
1186      * Getter for MenuBar
1187      * @return MenuBar : the MenuBar associated to the Tab.
1188      * @see org.scilab.modules.gui.tab.SimpleTab#getMenuBar()
1189      */
1190     @Override
1191     public MenuBar getMenuBar() {
1192         return this.menuBar;
1193     }
1194
1195     /**
1196      * Setter for ToolBar
1197      * @param newToolBar : the ToolBar to set.
1198      * @see org.scilab.modules.gui.tab.SimpleTab#setToolBar(org.scilab.modules.gui.toolbar.ToolBar)
1199      */
1200     @Override
1201     public void setToolBar(ToolBar newToolBar) {
1202         if (this.toolBar != newToolBar) {
1203             if (this.toolBar != null) {
1204                 ((SwingScilabToolBar) this.toolBar.getAsSimpleToolBar()).close();
1205             }
1206             this.toolBar = newToolBar;
1207         }
1208     }
1209
1210     /**
1211      * Getter for ToolBar
1212      * @return ToolBar : the ToolBar associated to the Tab.
1213      * @see org.scilab.modules.gui.tab.SimpleTab#getToolBar()
1214      */
1215     @Override
1216     public ToolBar getToolBar() {
1217         return this.toolBar;
1218     }
1219
1220     /**
1221      * Setter for InfoBar
1222      * @param newInfoBar the InfoBar to set.
1223      */
1224     @Override
1225     public void setInfoBar(TextBox newInfoBar) {
1226         this.infoBar = newInfoBar;
1227     }
1228
1229     /**
1230      * Getter for InfoBar
1231      * @return the InfoBar associated to the Tab.
1232      */
1233     @Override
1234     public TextBox getInfoBar() {
1235         return this.infoBar;
1236     }
1237
1238     /**
1239      * Set the callback of the tab
1240      * @param callback the callback to set.
1241      */
1242     @Override
1243     public void setCallback(CommonCallBack callback) {
1244
1245         if (closeAction != null) {
1246             this.getTitlebar().removeAction(closeAction);
1247         }
1248
1249         if (callback != null) {
1250             closeAction = new SciClosingAction(this, callback);
1251         } else {
1252             closeAction = new SciClosingAction(this);
1253         }
1254
1255         closeAction.putValue(Action.NAME, DockingConstants.CLOSE_ACTION);
1256         ((Titlebar) getTitlePane()).removeAction(DockingConstants.CLOSE_ACTION);
1257         addAction(closeAction);
1258
1259         /* Undock button */
1260         SciUndockingAction undockAction = new SciUndockingAction(this);
1261         undockAction.putValue(Action.NAME, UNDOCK);
1262         ((Titlebar) getTitlePane()).removeAction(UNDOCK);
1263         addAction(undockAction);
1264
1265         /* Help button */
1266         SciHelpOnComponentAction helpAction = new SciHelpOnComponentAction(this);
1267         helpAction.putValue(Action.NAME, HELP);
1268         ((Titlebar) getTitlePane()).removeAction(HELP);
1269         addAction(helpAction);
1270     }
1271
1272     /**
1273      * Set this tab as the current tab of its parent Window
1274      */
1275     @Override
1276     public void setCurrent() {
1277         ActiveDockableTracker.requestDockableActivation(this);
1278     }
1279
1280     /**
1281      * Set the background color of the tab.
1282      * @param red red channel of the color
1283      * @param green green channel
1284      * @param blue blue channel
1285      */
1286     @Override
1287     public void setBackground(double red, double green, double blue) {
1288         Color newColor = new Color((float) red, (float) green, (float) blue);
1289         contentPane.setBackground(red, green, blue);
1290         uiContentPane.setBackground(newColor);
1291         scrolling.setBackground(red, green, blue);
1292         setBackground(newColor);
1293     }
1294
1295     /**
1296      * Get the part of the axes which is currently viewed
1297      * @return [x,y,w,h] array
1298      */
1299     @Override
1300     public int[] getViewingRegion() {
1301         return scrolling.getViewingRegion();
1302     }
1303
1304     /**
1305      * Specify a new viewport for the axes
1306      * For SwingScilabCanvas viewport can not be modified
1307      * since it match the parent tab size
1308      * @param posX X coordinate of upper left point of the viewport within the axes
1309      * @param posY Y coordinate of upper left point of the viewport within the axes
1310      * @param width width of the viewport
1311      * @param height height of the viewport
1312      */
1313     @Override
1314     public void setViewingRegion(int posX, int posY, int width, int height) {
1315     }
1316
1317     /**
1318      * Set the event handler of the Canvas
1319      * @param funName the name of the Scilab function to call
1320      */
1321     public void setEventHandler(String funName) {
1322         disableEventHandler();
1323         eventHandler = new ScilabEventListener(funName, getId());
1324         if (eventEnabled) {
1325             editorEventHandler.setEnable(false);
1326             enableEventHandler();
1327         }
1328     }
1329
1330     /**
1331      * Set the status of the event handler of the Canvas
1332      * @param status is true to set the event handler active
1333      */
1334     public void setEventHandlerEnabled(boolean status) {
1335         if (status && eventEnabled) {
1336             return;
1337         }
1338
1339         if (status) {
1340             editorEventHandler.setEnable(false);
1341             enableEventHandler();
1342             eventEnabled = true;
1343         } else {
1344             editorEventHandler.setEnable(true);
1345             disableEventHandler();
1346             eventEnabled = false;
1347         }
1348     }
1349
1350     /**
1351      * Specify whether the canvas should fit the parent tab size
1352      * (and consequently the scrollpane size) or not
1353      * @param onOrOff true to enable autoresize mode
1354      */
1355     @Override
1356     public void setAutoResizeMode(boolean onOrOff) {
1357     }
1358
1359     /**
1360      * @return whether the resize mode is on or off
1361      */
1362     @Override
1363     public boolean getAutoResizeMode() {
1364         return true;
1365     }
1366
1367     /**
1368      * Close the tab and disable it.
1369      */
1370     public void close() {
1371         if (getTitlePane() != null) {
1372             ((Titlebar) getTitlePane()).removeAction(DockingConstants.CLOSE_ACTION);
1373             ((Titlebar) getTitlePane()).removeAction(UNDOCK);
1374             ((Titlebar) getTitlePane()).removeAction(HELP);
1375         }
1376
1377         setMenuBar(null);
1378         setToolBar(null);
1379         setInfoBar(null);
1380         setTitlebar(null);
1381         removeAll();
1382         //setActive(false);
1383
1384         scrolling = null;
1385         contentPane = null;
1386         DockingManager.unregisterDockable((Component) this);
1387
1388         // without this children canvas are not released.
1389         Container dummyContainer = new Container();
1390         this.setContentPane(dummyContainer);
1391         if (editorEventHandler != null) {
1392             editorEventHandler.onExit();
1393         }
1394     }
1395
1396     public void disablePaint() {
1397         paintEnable = false;
1398     }
1399
1400     /**
1401      * Redefine paint children to be sure that AWT components are well painted.
1402      *  @param g a Graphics
1403      */
1404     @Override
1405     public void paintChildren(Graphics g) {
1406         if (paintEnable) {
1407             Component[] children = getComponents();
1408             for (int i = 0; i < children.length; i++) {
1409                 // AWT children don't draw themselves automatically
1410                 // so force their draw
1411                 if (!children[i].isLightweight()) {
1412                     children[i].paint(g);
1413                 }
1414             }
1415             super.paintChildren(g);
1416         }
1417     }
1418
1419     /**
1420      * Update the tab after a modification of its properties
1421      * @param property the property name
1422      * @param value the property value
1423      * @see org.scilab.modules.gui.SwingViewObject#update(java.lang.String, java.lang.Object)
1424      */
1425     public void update(int property, Object value) {
1426         SwingScilabCommonPanel.update(this, property, value);
1427     }
1428
1429     /**
1430      * Get the tab UID
1431      * @return the UID
1432      * @see org.scilab.modules.gui.SwingViewObject#getId()
1433      */
1434     public Integer getId() {
1435         return id;
1436     }
1437
1438     /**
1439      * Set the tab UID
1440      * @param id the UID
1441      * @see org.scilab.modules.gui.SwingViewObject#setId(java.lang.String)
1442      */
1443     public void setId(Integer id) {
1444         this.id = id;
1445     }
1446
1447     /**
1448      * Turn on event handling.
1449      */
1450     private void enableEventHandler() {
1451         contentCanvas.addEventHandlerKeyListener(eventHandler);
1452         contentCanvas.addEventHandlerMouseListener(eventHandler);
1453         contentCanvas.addEventHandlerMouseMotionListener(eventHandler);
1454     }
1455
1456     /**
1457      * Turn off event handling.
1458      */
1459     private void disableEventHandler() {
1460         if (eventHandler != null) {
1461             contentCanvas.removeEventHandlerKeyListener(eventHandler);
1462             contentCanvas.removeEventHandlerMouseListener(eventHandler);
1463             contentCanvas.removeEventHandlerMouseMotionListener(eventHandler);
1464         }
1465     }
1466
1467     public void keyPressed(KeyEvent e) {
1468
1469     }
1470
1471     public void keyReleased(KeyEvent e) {
1472     }
1473
1474     public void keyTyped(KeyEvent e) {
1475         if (ScilabConstants.isGUI() && (eventHandler == null || !eventEnabled) && !GlobalEventWatcher.isActivated() && !editorEventHandler.isDatatipEnable() && Character.isLetterOrDigit(e.getKeyChar())) {
1476             SwingScilabConsole console = (SwingScilabConsole) ScilabConsole.getConsole().getAsSimpleConsole();
1477             JTextPane input = (JTextPane) console.getConfiguration().getInputCommandView();
1478             input.requestFocus();
1479             SwingScilabWindow win = (SwingScilabWindow) SwingUtilities.getAncestorOfClass(SwingScilabWindow.class, console);
1480             win.toFront();
1481             input.dispatchEvent(new KeyEvent(input, KeyEvent.KEY_TYPED, System.currentTimeMillis(), e.getModifiers(), e.getKeyCode(), e.getKeyChar(), e.getKeyLocation()));
1482         }
1483     }
1484     
1485     public JLayeredPane getWidgetPane() {
1486         return uiContentPane;
1487     }
1488 }