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