Force tab closure to be performed by EDT.
[scilab.git] / scilab / modules / gui / src / java / org / scilab / modules / gui / SwingView.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
4  * Copyright (C) 2011 - DIGITEO - Vincent COUVERT
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13 package org.scilab.modules.gui;
14
15 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CALLBACKTYPE__;
16 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CALLBACK__;
17 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CHILDREN__;
18 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_CONSOLE__;
19 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_FIGURE__;
20 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_PARENT__;
21 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_POSITION__;
22 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_PROGRESSIONBAR__;
23 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_SIZE__;
24 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_STYLE__;
25 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_TYPE__;
26 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UICHECKEDMENU__;
27 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UICHILDMENU__;
28 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UICONTEXTMENU__;
29 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UICONTROL__;
30 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UIMENU__;
31 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UIPARENTMENU__;
32 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_BACKGROUNDCOLOR__;
33 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_CHECKBOX__;
34 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_CHECKED__;
35 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_EDIT__;
36 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_ENABLE__;
37 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FONTANGLE__;
38 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FONTNAME__;
39 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FONTSIZE__;
40 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FONTUNITS__;
41 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FONTWEIGHT__;
42 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FOREGROUNDCOLOR__;
43 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_FRAME__;
44 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_HORIZONTALALIGNMENT__;
45 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_ICON__;
46 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_IMAGE__;
47 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_LABEL__;
48 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_LISTBOX__;
49 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_POPUPMENU__;
50 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_PUSHBUTTON__;
51 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_RADIOBUTTON__;
52 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_RELIEF__;
53 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_SEPARATOR__;
54 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_SLIDER__;
55 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_STRING__;
56 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_TABLE__;
57 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_TEXT__;
58 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_UI_VERTICALALIGNMENT__;
59 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_VALID__;
60 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_VISIBLE__;
61 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.__GO_WAITBAR__;
62 import static org.scilab.modules.gui.utils.Debug.DEBUG;
63
64 import java.awt.Component;
65 import java.awt.Container;
66 import java.awt.GraphicsEnvironment;
67 import java.lang.reflect.InvocationTargetException;
68 import java.util.Arrays;
69 import java.util.Collections;
70 import java.util.HashMap;
71 import java.util.HashSet;
72 import java.util.Map;
73 import java.util.Set;
74 import java.util.UUID;
75
76 import javax.swing.JComponent;
77 import javax.swing.JPanel;
78 import javax.swing.JSeparator;
79 import javax.swing.SwingUtilities;
80
81 import org.flexdock.docking.Dockable;
82 import org.flexdock.docking.DockingManager;
83 import org.flexdock.docking.activation.ActiveDockableTracker;
84 import org.flexdock.view.View;
85 import org.scilab.modules.graphic_export.Driver;
86 import org.scilab.modules.graphic_objects.console.Console;
87 import org.scilab.modules.graphic_objects.figure.Figure;
88 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
89 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
90 import org.scilab.modules.graphic_objects.graphicView.GraphicView;
91 import org.scilab.modules.gui.bridge.checkbox.SwingScilabCheckBox;
92 import org.scilab.modules.gui.bridge.checkboxmenuitem.SwingScilabCheckBoxMenuItem;
93 import org.scilab.modules.gui.bridge.console.SwingScilabConsole;
94 import org.scilab.modules.gui.bridge.contextmenu.SwingScilabContextMenu;
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.label.SwingScilabLabel;
98 import org.scilab.modules.gui.bridge.listbox.SwingScilabListBox;
99 import org.scilab.modules.gui.bridge.menu.SwingScilabMenu;
100 import org.scilab.modules.gui.bridge.menuitem.SwingScilabMenuItem;
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.tab.SwingScilabTab;
106 import org.scilab.modules.gui.bridge.uiimage.SwingScilabUiImage;
107 import org.scilab.modules.gui.bridge.uitable.SwingScilabUiTable;
108 import org.scilab.modules.gui.bridge.waitbar.SwingScilabWaitBar;
109 import org.scilab.modules.gui.bridge.window.SwingScilabWindow;
110 import org.scilab.modules.gui.console.ScilabConsole;
111 import org.scilab.modules.gui.menubar.ScilabMenuBar;
112 import org.scilab.modules.gui.textbox.ScilabTextBox;
113 import org.scilab.modules.gui.textbox.TextBox;
114 import org.scilab.modules.gui.toolbar.ToolBar;
115 import org.scilab.modules.gui.utils.ClosingOperationsManager;
116 import org.scilab.modules.gui.utils.ToolBarBuilder;
117 import org.scilab.modules.gui.utils.WindowsConfigurationManager;
118 import org.scilab.modules.gui.widget.Widget;
119
120 /**
121  * @author Bruno JOFRET
122  * @author Vincent COUVERT
123  */
124 public final class SwingView implements GraphicView {
125
126     public static final String NULLUUID = new UUID(0L, 0L).toString();
127     private static SwingView me;
128     private static boolean headless;
129     private Map<String, TypedObject> allObjects;
130
131     /**
132      * Constructor
133      */
134     private SwingView() {
135         GraphicController.getController().register(this);
136         allObjects = Collections.synchronizedMap(new HashMap<String, TypedObject>());
137     }
138
139     public static void registerSwingView() {
140         DEBUG("SwingView", "calling registerSwingView()");
141         if (me == null) {
142             me = new SwingView();
143         }
144     }
145
146     public static void setHeadless(boolean headless) {
147         SwingView.headless = headless;
148     }
149
150     public static boolean isHeadless() {
151         return SwingView.headless;
152     }
153
154     public static SwingViewObject getFromId(String id) {
155         TypedObject typedObject = me.allObjects.get(id);
156
157         if (typedObject == null) {
158             return null;
159         }
160
161         return typedObject.getValue();
162     }
163
164     private enum UielementType {
165         Console,
166         CheckBox,
167         Edit,
168         Frame,
169         Figure,
170         Image,
171         ListBox,
172         PopupMenu,
173         Progressbar,
174         PushButton,
175         RadioButton,
176         Slider,
177         Table,
178         Text,
179         Uimenu,
180         UiParentMenu,
181         UiChildMenu,
182         UiCheckedMenu,
183         UiContextMenu,
184         Waitbar
185     }
186
187     private class TypedObject {
188         private UielementType   _type;
189         private SwingViewObject _value;
190         private Set<String> _children;
191
192         public TypedObject(UielementType _type, SwingViewObject _value) {
193             this._type = _type;
194             this._value = _value;
195             this._children = Collections.synchronizedSet(new HashSet<String>());
196         }
197
198         public UielementType getType() {
199             return _type;
200         }
201
202         public SwingViewObject getValue() {
203             return _value;
204         }
205
206         public Set<String> getChildren() {
207             return _children;
208         }
209
210         public void addChild(String childUID) {
211             _children.add(childUID);
212         }
213
214         public void removeChild(String childUID) {
215             _children.remove(childUID);
216         }
217
218         public boolean hasChild(String childUID) {
219             return _children.contains(childUID);
220         }
221     };
222
223     private static final Set<Integer> managedTypes = new HashSet<Integer>(Arrays.asList(
224             GraphicObjectProperties.__GO_FIGURE__,
225             GraphicObjectProperties.__GO_UICONTEXTMENU__,
226             GraphicObjectProperties.__GO_UIMENU__,
227             GraphicObjectProperties.__GO_CONSOLE__,
228             GraphicObjectProperties.__GO_PROGRESSIONBAR__,
229             GraphicObjectProperties.__GO_WAITBAR__,
230             GraphicObjectProperties.__GO_UICONTROL__
231             ));
232
233     @Override
234     public void createObject(String id) {
235
236         int objectType = (Integer) GraphicController.getController().getProperty(id, __GO_TYPE__);
237
238         if (managedTypes.contains(objectType) == false) {
239             return;
240         }
241         //System.err.println("[SwingWiew] Object Created : " + id + " with type : " + objectType);
242         boolean isValid = (Boolean) GraphicController.getController().getProperty(id, __GO_VALID__);
243         if (!isValid) {
244             return;
245         }
246
247         if (!headless && !GraphicsEnvironment.isHeadless()) {
248             DEBUG("SwingWiew", "Object Created : " + id + "with type : " + objectType);
249             if (objectType == __GO_FIGURE__
250                     || objectType == __GO_UICONTEXTMENU__
251                     || objectType == __GO_UIMENU__
252                     || objectType == __GO_CONSOLE__
253                     || objectType == __GO_PROGRESSIONBAR__
254                     || objectType == __GO_WAITBAR__) {
255                 allObjects.put(id, CreateObjectFromType(objectType, id));
256                 return;
257             }
258
259             if (objectType == __GO_UICONTROL__) {
260                 int style = (Integer) GraphicController.getController().getProperty(id, __GO_STYLE__);
261                 DEBUG("SwingView", "__GO_STYLE__(" + style + ")");
262                 allObjects.put(id, CreateObjectFromType(style, id));
263             }
264         } else {
265             if (objectType == __GO_FIGURE__) {
266                 Driver.setDefaultVisitor(id);
267             }
268         }
269     }
270
271     private UielementType StyleToEnum(int style) {
272         DEBUG("SwingView", "StyleToEnum(" + style + ")");
273         switch (style) {
274         case __GO_FIGURE__ :
275             return UielementType.Figure;
276         case __GO_CONSOLE__ :
277             return UielementType.Console;
278         case __GO_UI_CHECKBOX__ :
279             return UielementType.CheckBox;
280         case __GO_UI_EDIT__ :
281             return UielementType.Edit;
282         case __GO_UI_FRAME__ :
283             return UielementType.Frame;
284         case __GO_UI_IMAGE__ :
285             return UielementType.Image;
286         case __GO_UI_LISTBOX__ :
287             return UielementType.ListBox;
288         case __GO_UI_POPUPMENU__ :
289             return UielementType.PopupMenu;
290         case __GO_UI_PUSHBUTTON__ :
291             return UielementType.PushButton;
292         case __GO_UI_RADIOBUTTON__ :
293             return UielementType.RadioButton;
294         case __GO_UI_SLIDER__ :
295             return UielementType.Slider;
296         case __GO_UI_TABLE__ :
297             return UielementType.Table;
298         case __GO_UI_TEXT__ :
299             return UielementType.Text;
300         case __GO_UIMENU__ :
301             return UielementType.UiChildMenu;
302         case __GO_UIPARENTMENU__ :
303             return UielementType.UiParentMenu;
304         case __GO_UICHILDMENU__ :
305             return UielementType.UiChildMenu;
306         case __GO_UICHECKEDMENU__ :
307             return UielementType.UiCheckedMenu;
308         case __GO_PROGRESSIONBAR__ :
309             return UielementType.Progressbar;
310         case __GO_WAITBAR__ :
311             return UielementType.Waitbar;
312         case __GO_UICONTEXTMENU__ :
313             return UielementType.UiContextMenu;
314         }
315         return null;
316     }
317
318     private TypedObject CreateObjectFromType(final int type, final String id) {
319         final UielementType enumType = StyleToEnum(type);
320         final SwingViewObject newSVObject[] = new SwingViewObject[1];
321         if (SwingUtilities.isEventDispatchThread()) {
322             newSVObject[0] = CreateObjectFromType(enumType, id);
323         } else {
324             try {
325                 SwingUtilities.invokeAndWait(new Runnable() {
326
327                     @Override
328                     public void run() {
329                         newSVObject[0] = CreateObjectFromType(enumType, id);
330
331                     }
332                 });
333             } catch (InterruptedException e) {
334                 // TODO Auto-generated catch block
335                 e.printStackTrace();
336             } catch (InvocationTargetException e) {
337                 // TODO Auto-generated catch block
338                 e.printStackTrace();
339             }
340         }
341         return new TypedObject(enumType, newSVObject[0]);
342     }
343
344     private SwingViewObject CreateObjectFromType(UielementType type, String id) {
345         switch (type) {
346         case CheckBox:
347             SwingScilabCheckBox checkBox = new SwingScilabCheckBox();
348             checkBox.setId(id);
349             setDefaultProperties(checkBox, id);
350             return checkBox;
351         case Console:
352             Console console = (Console) GraphicController.getController().getObjectFromId(id);
353             if (console.getScilabMode() == Console.ScilabMode.STD) {
354                 WindowsConfigurationManager.restoreUUID(NULLUUID);
355                 SwingScilabConsole sciConsole = ((SwingScilabConsole) ScilabConsole.getConsole().getAsSimpleConsole());
356                 SwingScilabTab consoleTab = (SwingScilabTab) sciConsole.getParent();
357                 consoleTab.setId(id);
358                 return consoleTab;
359             } else {
360                 return null;
361             }
362         case Edit:
363             SwingScilabEditBox edit = new SwingScilabEditBox();
364             edit.setId(id);
365             setDefaultProperties(edit, id);
366             return edit;
367         case Figure:
368             Figure figure = (Figure) GraphicController.getController().getObjectFromId(id);
369             String figureTitle = figure.getName();
370             Integer figureId = figure.getId();
371             if ((figureTitle != null) && (figureId != null)) {
372                 figureTitle = figureTitle.replaceFirst("%d", figureId.toString());
373             }
374
375             SwingScilabWindow window = new SwingScilabWindow();
376
377             window.setTitle(figureTitle);
378             /* TOOLBAR */
379             ToolBar toolBar = ToolBarBuilder.buildToolBar(SwingScilabTab.GRAPHICS_TOOLBAR_DESCRIPTOR, figureId);
380             /* INFOBAR */
381             TextBox infoBar = ScilabTextBox.createTextBox();
382
383             SwingScilabTab tab = new SwingScilabTab(figureTitle, figureId, figure);
384             tab.setId(id);
385
386             tab.setMenuBar(ScilabMenuBar.createMenuBar());
387             tab.setToolBar(toolBar);
388             tab.setInfoBar(ScilabTextBox.createTextBox());
389             window.addMenuBar(tab.getMenuBar());
390             window.addToolBar(tab.getToolBar());
391             window.addInfoBar(tab.getInfoBar());
392
393             tab.setWindowIcon("graphic-window");
394
395             tab.setParentWindowId(window.getId());
396
397             tab.setEventHandler(figure.getEventHandlerString());
398             tab.setEventHandlerEnabled(figure.getEventHandlerEnable());
399
400             DockingManager.dock(tab, window.getDockingPort());
401             ActiveDockableTracker.requestDockableActivation(tab);
402
403             window.setVisible(true);
404             tab.setVisible(true);
405             tab.setName(figureTitle);
406
407             String infoMessage = figure.getInfoMessage();
408             if ((infoMessage == null) || (infoMessage.length() == 0)) {
409                 infoBar.setText("");
410             } else {
411                 infoBar.setText(infoMessage);
412             }
413             tab.update(__GO_SIZE__, (Integer[]) GraphicController.getController().getProperty(id, __GO_SIZE__));
414             tab.update(__GO_POSITION__, (Integer[]) GraphicController.getController().getProperty(id, __GO_POSITION__));
415             // TODO set other default properties
416             return tab;
417         case Frame:
418             SwingScilabFrame frame = new SwingScilabFrame();
419             frame.setId(id);
420             setDefaultProperties(frame, id);
421             return frame;
422         case Image:
423             SwingScilabUiImage image = new SwingScilabUiImage();
424             image.setId(id);
425             setDefaultProperties(image, id);
426             return image;
427         case ListBox:
428             SwingScilabListBox listBox = new SwingScilabListBox();
429             listBox.setId(id);
430             setDefaultProperties(listBox, id);
431             return listBox;
432         case PopupMenu:
433             SwingScilabPopupMenu popupMenu = new SwingScilabPopupMenu();
434             popupMenu.setId(id);
435             setDefaultProperties(popupMenu, id);
436             return popupMenu;
437         case Progressbar:
438             SwingScilabWaitBar progressbar = new SwingScilabWaitBar();
439             progressbar.setIndeterminateMode(true);
440             progressbar.setId(id);
441             return progressbar;
442         case PushButton:
443             SwingScilabPushButton pushButton = new SwingScilabPushButton();
444             pushButton.setId(id);
445             setDefaultProperties(pushButton, id);
446             return pushButton;
447         case RadioButton:
448             SwingScilabRadioButton radioButton = new SwingScilabRadioButton();
449             radioButton.setId(id);
450             setDefaultProperties(radioButton, id);
451             return radioButton;
452         case Slider:
453             SwingScilabSlider slider = new SwingScilabSlider();
454             slider.setId(id);
455             setDefaultProperties(slider, id);
456             return slider;
457         case Table:
458             SwingScilabUiTable table = new SwingScilabUiTable();
459             table.setId(id);
460             setDefaultProperties(table, id);
461             return table;
462         case Text:
463             SwingScilabLabel text = new SwingScilabLabel();
464             text.setId(id);
465             setDefaultProperties(text, id);
466             return text;
467         case Uimenu:
468             throw new UnsupportedOperationException();
469         case UiParentMenu: /* SwingView internal type */
470             SwingScilabMenu parentMenu = new SwingScilabMenu();
471             parentMenu.setId(id);
472             setMenuDefaultProperties(parentMenu, id);
473             return parentMenu;
474         case UiChildMenu: /* SwingView internal type */
475             SwingScilabMenuItem childMenu = new SwingScilabMenuItem();
476             childMenu.setId(id);
477             setMenuDefaultProperties(childMenu, id);
478             return childMenu;
479         case UiCheckedMenu: /* SwingView internal type */
480             SwingScilabCheckBoxMenuItem checkedMenu = new SwingScilabCheckBoxMenuItem(false);
481             checkedMenu.setId(id);
482             setMenuDefaultProperties(checkedMenu, id);
483             return checkedMenu;
484         case UiContextMenu:
485             SwingScilabContextMenu contextMenu = new SwingScilabContextMenu();
486             contextMenu.setId(id);
487             return contextMenu;
488         case Waitbar:
489             SwingScilabWaitBar waitbar = new SwingScilabWaitBar();
490             waitbar.setIndeterminateMode(false);
491             waitbar.setId(id);
492             return waitbar;
493         default:
494             return null;
495         }
496     }
497
498     /**
499      * Initialize all poperties according to model
500      * @param uiMenuObject the uimenu
501      * @param id the uimenu id
502      */
503     private void setMenuDefaultProperties(Widget uiMenuObject, String id) {
504         SwingViewMenu.update(uiMenuObject, __GO_CHILDREN__,
505                 (String[]) GraphicController.getController().getProperty(id, __GO_CHILDREN__));
506         SwingViewMenu.update(uiMenuObject, __GO_CALLBACK__,
507                 (String) GraphicController.getController().getProperty(id, __GO_CALLBACK__));
508         SwingViewMenu.update(uiMenuObject, __GO_CALLBACKTYPE__,
509                 (Integer) GraphicController.getController().getProperty(id, __GO_CALLBACKTYPE__));
510         SwingViewMenu.update(uiMenuObject, __GO_UI_CHECKED__,
511                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_CHECKED__));
512         SwingViewMenu.update(uiMenuObject, __GO_UI_ENABLE__,
513                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_ENABLE__));
514         SwingViewMenu.update(uiMenuObject, __GO_UI_FOREGROUNDCOLOR__,
515                 (Double[]) GraphicController.getController().getProperty(id, __GO_UI_FOREGROUNDCOLOR__));
516         SwingViewMenu.update(uiMenuObject, __GO_UI_LABEL__,
517                 (String) GraphicController.getController().getProperty(id, __GO_UI_LABEL__));
518         SwingViewMenu.update(uiMenuObject, __GO_UI_ICON__,
519                 (String) GraphicController.getController().getProperty(id, __GO_UI_ICON__));
520     }
521
522     /**
523      * Initialize all poperties according to model
524      * @param uiControlObject the uicontrol
525      * @param id the uicontrol id
526      */
527     private void setDefaultProperties(Widget uiControlObject, String id) {
528         /* Visible property is set first to avoid to see the object rendered before all its properties to be set (See bug #10346) */
529         SwingViewWidget.update(uiControlObject, __GO_VISIBLE__,
530                 (Boolean) GraphicController.getController().getProperty(id, __GO_VISIBLE__));
531         SwingViewWidget.update(uiControlObject, __GO_UI_BACKGROUNDCOLOR__,
532                 (Double[]) GraphicController.getController().getProperty(id, __GO_UI_BACKGROUNDCOLOR__));
533         SwingViewWidget.update(uiControlObject, __GO_UI_ENABLE__,
534                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_ENABLE__));
535         SwingViewWidget.update(uiControlObject, __GO_UI_ENABLE__,
536                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_ENABLE__));
537         SwingViewWidget.update(uiControlObject, __GO_UI_FONTANGLE__,
538                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTANGLE__));
539         SwingViewWidget.update(uiControlObject, __GO_UI_FONTNAME__,
540                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTNAME__));
541         SwingViewWidget.update(uiControlObject, __GO_UI_FONTUNITS__,
542                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTUNITS__));
543         SwingViewWidget.update(uiControlObject, __GO_UI_FONTSIZE__,
544                 (Double) GraphicController.getController().getProperty(id, __GO_UI_FONTSIZE__));
545         SwingViewWidget.update(uiControlObject, __GO_UI_FONTWEIGHT__,
546                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTWEIGHT__));
547         SwingViewWidget.update(uiControlObject, __GO_UI_FOREGROUNDCOLOR__,
548                 (Double[]) GraphicController.getController().getProperty(id, __GO_UI_FOREGROUNDCOLOR__));
549         SwingViewWidget.update(uiControlObject, __GO_UI_HORIZONTALALIGNMENT__,
550                 (String) GraphicController.getController().getProperty(id, __GO_UI_HORIZONTALALIGNMENT__));
551         SwingViewWidget.update(uiControlObject, __GO_UI_RELIEF__,
552                 (String) GraphicController.getController().getProperty(id, __GO_UI_RELIEF__));
553         SwingViewWidget.update(uiControlObject, __GO_UI_STRING__,
554                 (String[]) GraphicController.getController().getProperty(id, __GO_UI_STRING__));
555         SwingViewWidget.update(uiControlObject, __GO_UI_VERTICALALIGNMENT__,
556                 (String) GraphicController.getController().getProperty(id, __GO_UI_VERTICALALIGNMENT__));
557         SwingViewWidget.update(uiControlObject, __GO_POSITION__,
558                 (Double[]) GraphicController.getController().getProperty(id, __GO_POSITION__));
559     }
560
561     public void deleteObject(String id) {
562         final TypedObject requestedObject = allObjects.get(id);
563         if (requestedObject != null) {
564             switch (requestedObject.getType()) {
565             case Figure:
566                 if (SwingUtilities.isEventDispatchThread()) {
567                     final SwingScilabTab tab = (SwingScilabTab) requestedObject.getValue();
568                     tab.disablePaint();
569                     DockingManager.close(tab);
570                     DockingManager.unregisterDockable((Dockable) tab);
571                     ClosingOperationsManager.unregisterClosingOperation(tab);
572                     ClosingOperationsManager.removeDependency(tab);
573                     ClosingOperationsManager.checkTabForClosing(tab);
574                     tab.close();
575                 } else {
576                     try {
577                         SwingUtilities.invokeAndWait(new Runnable() {
578
579                             @Override
580                             public void run() {
581                                 final SwingScilabTab tab = (SwingScilabTab) requestedObject.getValue();
582                                 tab.disablePaint();
583                                 DockingManager.close(tab);
584                                 DockingManager.unregisterDockable((Dockable) tab);
585                                 ClosingOperationsManager.unregisterClosingOperation(tab);
586                                 ClosingOperationsManager.removeDependency(tab);
587                                 ClosingOperationsManager.checkTabForClosing(tab);
588                                 tab.close();
589                             }
590
591                         });
592                     } catch (InterruptedException e) {
593                         // TODO Auto-generated catch block
594                         e.printStackTrace();
595                     } catch (InvocationTargetException e) {
596                         // TODO Auto-generated catch block
597                         e.printStackTrace();
598                     }
599                 }
600                     break;
601             case Progressbar:
602             case Waitbar:
603                 SwingScilabWaitBar bar = (SwingScilabWaitBar) requestedObject.getValue();
604                 bar.close();
605                 break;
606             default:
607                 // Nothing to do
608                     // uicontrol case: the object is destroyed when its parent updates its children
609                 break;
610             }
611             allObjects.remove(id);
612         }
613     }
614
615     @Override
616     public void updateObject(final String id, final int property) {
617         final TypedObject registeredObject = allObjects.get(id);
618         if (registeredObject == null && property != __GO_STYLE__) {
619             return;
620         }
621         
622         /* On uicontrol style is set after object creation */
623         if (registeredObject == null && property == __GO_STYLE__) {
624             int style = (Integer) GraphicController.getController().getProperty(id, __GO_STYLE__);
625             allObjects.put(id, CreateObjectFromType(style, id));
626             return;
627         }
628        
629         if (SwingUtilities.isEventDispatchThread()) {
630             updateObjectOnEDT(registeredObject, id, property);
631         } else {
632                 try {
633                     SwingUtilities.invokeAndWait(new Runnable() {
634                         @Override
635                         public void run() {
636                             updateObjectOnEDT(registeredObject, id, property);
637                         }
638                     });
639                 } catch (InterruptedException e) {
640                     // TODO Auto-generated catch block
641                     e.printStackTrace();
642                 } catch (InvocationTargetException e) {
643                     // TODO Auto-generated catch block
644                     e.printStackTrace();
645                 }
646         }
647     }
648
649     public void updateObjectOnEDT(TypedObject registeredObject, final String id, final int property) {
650         /* Removes the swing object if its parent is not display */
651         if (registeredObject != null && property == __GO_PARENT__) {
652             String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
653             TypedObject registeredParent = allObjects.get(parentId);
654             if (registeredParent == null) {
655                 allObjects.remove(id);
656             }
657         }
658         
659         int type = (Integer) GraphicController.getController().getProperty(id, __GO_TYPE__);
660         /* Children list update */
661         if (registeredObject != null && property == __GO_CHILDREN__) {
662             final String[] newChildren = (String[]) GraphicController.getController().getProperty(id, __GO_CHILDREN__);
663
664             switch (type) {
665             /*
666              * FIGURE CHILDREN UPDATE
667              */
668             case __GO_FIGURE__ :
669                 updateFigureChildren(registeredObject, newChildren);
670                 break;
671                 /*
672                  * CONSOLE CHILDREN UPDATE
673                  */
674             case __GO_CONSOLE__ :
675                 updateConsoleChildren(registeredObject, newChildren);
676                 break;
677                 /*
678                  * MENU CHILDREN UPDATE
679                  */
680             case __GO_UIMENU__ :
681                 updateMenuChildren(registeredObject, id, newChildren);
682                 break;
683                 /*
684                  * CONTEXTMENU CHILDREN UPDATE
685                  */
686             case __GO_UICONTEXTMENU__ :
687                 updateContextMenuChildren(registeredObject, newChildren);
688                 break;
689                 /*
690                  * UICONTROL "FRAME" CHILDREN UPDATE
691                  */
692             case __GO_UICONTROL__ :
693                 int style = (Integer) GraphicController.getController().getProperty(id, __GO_STYLE__);
694                 if (style == __GO_UI_FRAME__) {
695                     updateFrameChildren(registeredObject, newChildren);
696                 }
697                 break;
698             }
699         }
700
701         /*
702          * When the CHECKED property is updated for a UIMENU,
703          * the object is converted to a SwingScilabCheckBoxMenuItem is not already of this type
704          */
705         if (registeredObject != null && property == __GO_UI_CHECKED__) {
706             if (type == __GO_UIMENU__) {
707                 switch (registeredObject.getType()) {
708                 case UiParentMenu:
709                     SwingScilabMenu meAsAMenu = (SwingScilabMenu) registeredObject.getValue();
710                     Container parent = meAsAMenu.getParent();
711                     parent.remove(meAsAMenu);
712                     registeredObject = CreateObjectFromType(__GO_UICHECKEDMENU__, id);
713                     allObjects.put(id, registeredObject);
714                     SwingScilabCheckBoxMenuItem meAsAMenuItem = (SwingScilabCheckBoxMenuItem) registeredObject.getValue();
715                     parent.add(meAsAMenuItem);
716                     break;
717                 case UiChildMenu:
718                     String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
719                     SwingScilabMenuItem childMenu = (SwingScilabMenuItem) allObjects.get(id).getValue();
720                     SwingScilabMenu parentMenu = (SwingScilabMenu) allObjects.get(parentId).getValue();
721                     
722                     int index = parentMenu.getComponentZOrder(childMenu);
723                     parentMenu.remove(childMenu);
724                     registeredObject = CreateObjectFromType(__GO_UICHECKEDMENU__, id);
725                     allObjects.put(id, registeredObject);
726                     registeredObject = allObjects.get(id);
727                     parentMenu.add((SwingScilabCheckBoxMenuItem) registeredObject.getValue(), index);
728                     return;
729                 default:
730                     break;
731                 }
732             }
733         }
734
735         /*
736          * When the SEPARATOR property is updated for a UIMENU,
737          * When the property is set to TRUE: A separator is added if not already done
738          * When the property is set to FALSE: The previous separator is removed if it exists
739          */
740         if (registeredObject != null && property == __GO_UI_SEPARATOR__) {
741             if (type == __GO_UIMENU__) {
742                 String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
743                 int menuPosition = -1;
744                 Component currentComponent = (Component) registeredObject.getValue();
745                 Component[] allChildren =  ((SwingScilabMenu) allObjects.get(parentId).getValue()).getMenuComponents();
746                 for (int kChild = 0; kChild < allChildren.length; kChild++) {
747                     if (allChildren[kChild] == currentComponent) {
748                         menuPosition = kChild;
749                         break;
750                     }
751                 }
752                 if (menuPosition < 0) {
753                     return;
754                 }
755                 boolean newSeparatorMode = (Boolean) GraphicController.getController().getProperty(id, __GO_UI_SEPARATOR__);
756                 if (newSeparatorMode) { // Add a separator above the menu
757                     ((SwingScilabMenu) allObjects.get(parentId).getValue()).insertSeparator(menuPosition);
758                 } else { // Remove the separator above the menu (if there is one)
759                     if (menuPosition == 0) { // There is no object above the menu
760                         return;
761                     }
762                     if (((SwingScilabMenu) allObjects.get(parentId).getValue()).getComponent(menuPosition - 1) instanceof JSeparator) {
763                         ((SwingScilabMenu) allObjects.get(parentId).getValue()).remove(menuPosition - 1);
764                     }
765                 }
766             }
767         }
768
769         if (registeredObject != null) {
770             final SwingViewObject swingObject = registeredObject.getValue();
771             if (swingObject != null) {
772                 swingObject.update(property, GraphicController.getController().getProperty(id, property));
773             }
774         }
775     }
776
777     /**
778      * Update the figure children (called by generic updateObject method)
779      * @param id the id of the figure
780      * @param newChildren the new children IDs list
781      */
782     private void updateFigureChildren(TypedObject updatedObject, String[] newChildren) {
783         Container updatedComponent = (SwingScilabTab) updatedObject.getValue();
784         boolean needRevalidate = false;
785
786         // Add new children
787         for (String childId : newChildren) {
788             if (!updatedObject.hasChild(childId)) {
789
790                 // Add the child
791                 updatedObject.addChild(childId);
792
793                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
794
795                 /* Add an uicontrol */
796                 if (childType == __GO_UICONTROL__) {
797                     ((SwingScilabTab) updatedComponent).addMember(allObjects.get(childId).getValue());
798                     needRevalidate = true;
799                 }
800
801                 /* Add an uimenu */
802                 if (childType == __GO_UIMENU__) {
803                     TypedObject childAsTypedObject = allObjects.get(childId);
804                     switch (childAsTypedObject.getType()) {
805                     case UiChildMenu:
806                     case UiCheckedMenu:
807                         allObjects.remove(childId);
808                         allObjects.put(childId, CreateObjectFromType(__GO_UIPARENTMENU__, childId));
809                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) allObjects.get(childId).getValue());
810                         break;
811                     default: /* UiParentMenu */
812                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) allObjects.get(childId).getValue());
813                         break;
814                     }
815                     needRevalidate = true;
816                 }
817             }
818         }
819
820         // Remove children which have been deleted
821         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
822         // Clone the children set to avoid concurrent accesses
823         String[] oldChildrenSet = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
824         for (String childId : oldChildrenSet) {
825             if (!newChildrenSet.contains(childId)) {
826
827                 // Remove the child
828                 updatedObject.removeChild(childId);
829
830                 final Object childTypeObject = GraphicController.getController().getProperty(childId, __GO_TYPE__);
831                 if (childTypeObject == null) {
832                     // the child has already been removed from the model
833                     continue;
834                 }
835                 int childType = (Integer) childTypeObject;
836
837                 /* Remove an uicontrol */
838                 if (childType == __GO_UICONTROL__) {
839                     ((SwingScilabTab) updatedComponent).removeMember(allObjects.get(childId).getValue());
840                     needRevalidate = true;
841                 }
842
843                 /* Remove an uimenu */
844                 if (childType == __GO_UIMENU__) {
845                     TypedObject childAsTypedObject = allObjects.get(childId);
846                     switch (childAsTypedObject.getType()) {
847                     case UiCheckedMenu:
848                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
849                         break;
850                     default: /* UiParentMenu */
851                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabMenu) allObjects.get(childId).getValue());
852                         break;
853                     }
854                     needRevalidate = true;
855                 }
856             }
857         }
858         if (needRevalidate && updatedComponent != null) {
859             ((View) updatedComponent).revalidate();
860         }
861     }
862
863     /**
864      * Update the frame children (called by generic updateObject method)
865      * @param id the id of the figure
866      * @param newChildren the new children IDs list
867      */
868     private void updateFrameChildren(TypedObject updatedObject, String[] newChildren) {
869         Container updatedComponent = (SwingScilabFrame) updatedObject.getValue();
870         boolean needRevalidate = false;
871
872         // Add new children
873         for (String childId : newChildren) {
874             if (!updatedObject.hasChild(childId)) {
875
876                 // Add the child
877                 updatedObject.addChild(childId);
878
879                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
880
881                 /* Add an uicontrol */
882                 if (childType == __GO_UICONTROL__) {
883                     ((SwingScilabFrame) updatedComponent).addMember(allObjects.get(childId).getValue());
884                     needRevalidate = true;
885                 }
886             }
887         }
888
889         // Remove children which have been deleted
890         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
891         // Clone the children set to avoid concurrent accesses
892         String[] oldChildrenSet = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
893         for (String childId : oldChildrenSet) {
894             if (!newChildrenSet.contains(childId)) {
895
896                 // Remove the child
897                 updatedObject.removeChild(childId);
898
899                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
900
901                 /* Remove an uicontrol */
902                 if (childType == __GO_UICONTROL__) {
903                     updatedComponent.remove((Component) allObjects.get(childId).getValue());
904                     needRevalidate = true;
905                 }
906             }
907         }
908         if (needRevalidate && updatedComponent != null) {
909             ((JPanel) updatedComponent).revalidate();
910         }
911     }
912
913     /**
914      * Update the Console menus (called by generic updateObject method)
915      * @param id the id of the console object
916      * @param newChildren the new children IDs list
917      */
918     private void updateConsoleChildren(TypedObject updatedObject, String[] newChildren) {
919         Container updatedComponent = (SwingScilabTab) updatedObject.getValue();
920         boolean needRevalidate = false;
921
922         // Add new children
923         for (String childId : newChildren) {
924             if (!updatedObject.hasChild(childId)) {
925
926                 // Add the child
927                 updatedObject.addChild(childId);
928
929                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
930
931                 if (childType == __GO_UIMENU__) {
932                     TypedObject childAsTypedObject = allObjects.get(childId);
933                     switch (childAsTypedObject.getType()) {
934                     case UiChildMenu:
935                     case UiCheckedMenu:
936                         TypedObject newUiParentMenu = CreateObjectFromType(__GO_UIPARENTMENU__, childId);
937                         allObjects.put(childId, newUiParentMenu);
938                         ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) newUiParentMenu.getValue());
939                         break;
940                     default: /* UiParentMenu */
941                         ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) childAsTypedObject.getValue());
942                         break;
943                     }
944                     needRevalidate = true;
945                 }
946             }
947         }
948
949         // Remove children which have been deleted
950         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
951         Object[] updatedObjectChildren = updatedObject.getChildren().toArray();
952         for (int i = 0 ; i < updatedObjectChildren.length ; ++i) {
953             String childId = (String) updatedObjectChildren[i];
954             if (!newChildrenSet.contains(childId)) {
955
956                 // Remove the child
957                 updatedObject.removeChild(childId);
958
959                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
960
961                 if (childType == __GO_UIMENU__) {
962                     ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabMenu) allObjects.get(childId).getValue());
963                     needRevalidate = true;
964                 }
965             }
966         }
967         if (needRevalidate && updatedComponent != null) {
968             updatedComponent.validate();
969         }
970
971     }
972
973     /**
974      * Update the children of a menu menus (called by generic updateObject method)
975      * @param id the id of the menu object
976      * @param newChildren the new children IDs list
977      */
978     private void updateMenuChildren(TypedObject updatedObject, String id, String[] newChildren) {
979         Container updatedComponent = null;
980         boolean needRevalidate = false;
981         int updatedObjectPosition = 0;
982         TypedObject newParent = null;
983
984         // Add new children
985         for (String childId : newChildren) {
986             int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
987             if (childType == __GO_UIMENU__) {
988                 if (!updatedObject.hasChild(childId)) {
989                     // Add the child
990                     updatedObject.addChild(childId);
991
992                     TypedObject childAsTypedObject = allObjects.get(childId);
993                     Object addedChild = allObjects.get(childId).getValue();
994                     JComponent parent = null;
995                     switch (updatedObject.getType()) {
996                     case UiChildMenu:
997                         updatedComponent = (SwingScilabMenuItem) updatedObject.getValue();
998                         parent = (JComponent) updatedComponent.getParent();
999                         switch (childAsTypedObject.getType()) {
1000                         case UiChildMenu:
1001                             /* Replace the item by a parent menu */
1002                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabMenuItem) updatedObject.getValue());
1003                             parent.remove((SwingScilabMenuItem) updatedObject.getValue());
1004                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
1005                             allObjects.put(id, newParent);
1006                             newParent.addChild(childId);
1007                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
1008                             /* Update the created menu */
1009                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabMenuItem) addedChild);
1010                             break;
1011                         case UiCheckedMenu:
1012                             /* Replace the item by a parent menu */
1013                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
1014                             parent.remove((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
1015                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
1016                             allObjects.put(id, newParent);
1017                             newParent.addChild(childId);
1018                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
1019                             /* Update the created menu */
1020                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabCheckBoxMenuItem) addedChild);
1021                             break;
1022                         default: /* UiParentMenu */
1023                             ((SwingScilabMenu) updatedObject.getValue()).add((SwingScilabMenu) addedChild);
1024                             break;
1025                         }
1026                         break;
1027                     case UiCheckedMenu:
1028                         updatedComponent = (SwingScilabCheckBoxMenuItem) updatedObject.getValue();
1029                         parent = (JComponent) updatedComponent.getParent();
1030                         switch (childAsTypedObject.getType()) {
1031                         case UiChildMenu:
1032                             /* Replace the item by a parent menu */
1033                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
1034                             parent.remove((SwingScilabCheckBoxMenuItem) allObjects.get(id).getValue());
1035                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
1036                             allObjects.put(id, newParent);
1037                             newParent.addChild(childId);
1038                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
1039                             /* Update the created menu */
1040                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1041                             break;
1042                         case UiCheckedMenu:
1043                             /* Replace the item by a parent menu */
1044                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
1045                             parent.remove((SwingScilabCheckBoxMenuItem) allObjects.get(id).getValue());
1046                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
1047                             allObjects.put(id, newParent);
1048                             newParent.addChild(childId);
1049                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
1050                             /* Update the created menu */
1051                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1052                             break;
1053                         default: /* UiParentMenu */
1054                             System.out.println("childAsTypedObject.getType() = UiParentMenu");
1055                             ((SwingScilabMenu) updatedObject.getValue()).add((SwingScilabMenu) allObjects.get(childId).getValue());
1056                             break;
1057                         }
1058                         break;
1059                     default: /* UiParentMenu */
1060                         SwingScilabMenu updatedMenu = (SwingScilabMenu) updatedObject.getValue();
1061                         updatedComponent = updatedMenu;
1062                         switch (childAsTypedObject.getType()) {
1063                         case UiChildMenu:
1064                             updatedMenu.add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1065                             break;
1066                         case UiCheckedMenu:
1067                             updatedMenu.add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1068                             break;
1069                         default: /* UiParentMenu */
1070                         /* Java can not add a JMenu in a JMenu */
1071                             /* We need to convert the child into a MenuItem */
1072                             TypedObject newMenu = CreateObjectFromType(__GO_UIMENU__, childId);
1073                             allObjects.put(childId, newMenu);
1074                             updatedMenu.add((SwingScilabMenuItem) newMenu.getValue());
1075                             break;
1076                         }
1077                         break;
1078                     }
1079                     needRevalidate = true;
1080                 }
1081             }
1082         }
1083         // Remove children which have been deleted
1084         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
1085         String[] oldChildren = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
1086         for (int childIndex = 0; childIndex < oldChildren.length; childIndex++) {
1087             String childId = oldChildren[childIndex];
1088             if (!newChildrenSet.contains(childId)) {
1089                 // Remove the child
1090                 updatedObject.removeChild(childId);
1091                 updatedComponent = (SwingScilabMenu) updatedObject.getValue();
1092
1093                 TypedObject childAsTypedObject = allObjects.get(childId);
1094                 Object removedMenu = childAsTypedObject.getValue();
1095
1096                 switch (childAsTypedObject.getType()) {
1097                 case UiChildMenu:
1098                     updatedComponent.remove((SwingScilabMenuItem) removedMenu);
1099                     break;
1100                 case UiCheckedMenu:
1101                     updatedComponent.remove((SwingScilabCheckBoxMenuItem) removedMenu);
1102                     break;
1103                 default:
1104                     updatedComponent.remove((SwingScilabMenu) removedMenu);
1105                     break;
1106                 }
1107                 needRevalidate = true;
1108             }
1109         }
1110         if (needRevalidate && updatedComponent != null) {
1111             updatedComponent.validate();
1112         }
1113     }
1114     /**
1115      * Update the children of a contextmenu (called by generic updateObject method)
1116      * @param id the id of the contextmenu object
1117      * @param newChildren the new children IDs list
1118      */
1119     private void updateContextMenuChildren(TypedObject updatedObject, String[] newChildren) {
1120         Container updatedComponent = null;
1121         boolean needRevalidate = false;
1122
1123         // Add new children
1124         for (String childId : newChildren) {
1125             int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
1126             if (childType == __GO_UIMENU__) {
1127                 if (!updatedObject.hasChild(childId)) {
1128
1129                     // Add the child
1130                     updatedObject.addChild(childId);
1131
1132                     TypedObject childAsTypedObject = allObjects.get(childId);
1133                     SwingScilabContextMenu updatedMenu = (SwingScilabContextMenu) updatedObject.getValue();
1134                     updatedComponent = updatedMenu;
1135                     switch (childAsTypedObject.getType()) {
1136                     case UiChildMenu:
1137                         updatedMenu.add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1138                         break;
1139                     case UiCheckedMenu:
1140                         updatedMenu.add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1141                         break;
1142                     default: /* UiParentMenu */
1143                         updatedMenu.add((SwingScilabMenu) allObjects.get(childId).getValue());
1144                         break;
1145                     }
1146                     needRevalidate = true;
1147                 }
1148             }
1149         }
1150         // Remove children which have been deleted
1151         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
1152         for (String childId : updatedObject.getChildren()) {
1153             if (!newChildrenSet.contains(childId)) {
1154                 // Remove the child
1155                 updatedObject.removeChild(childId);
1156                 updatedComponent = (SwingScilabMenu) updatedObject.getValue();
1157
1158                 TypedObject childAsTypedObject = allObjects.get(childId);
1159                 SwingScilabContextMenu updatedMenu = (SwingScilabContextMenu) updatedObject.getValue();
1160                 Object removedMenu = allObjects.get(childId).getValue();
1161
1162                 switch (childAsTypedObject.getType()) {
1163                 case UiChildMenu:
1164                     updatedMenu.remove((SwingScilabMenuItem) removedMenu);
1165                     break;
1166                 case UiCheckedMenu:
1167                     updatedMenu.remove((SwingScilabCheckBoxMenuItem) removedMenu);
1168                     break;
1169                 default:
1170                     updatedMenu.remove((SwingScilabMenu) removedMenu);
1171                     break;
1172                 }
1173                 needRevalidate = true;
1174             }
1175         }
1176         if (needRevalidate && updatedComponent != null) {
1177             updatedComponent.validate();
1178         }
1179     }
1180 }