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