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