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