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