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