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