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