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