Force SwingView update to be done through 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         UielementType enumType = StyleToEnum(type);
320         return new TypedObject(enumType, CreateObjectFromType(enumType, id));
321     }
322
323     private SwingViewObject CreateObjectFromType(UielementType type, String id) {
324         switch (type) {
325         case CheckBox:
326             SwingScilabCheckBox checkBox = new SwingScilabCheckBox();
327             checkBox.setId(id);
328             setDefaultProperties(checkBox, id);
329             return checkBox;
330         case Console:
331             Console console = (Console) GraphicController.getController().getObjectFromId(id);
332             if (console.getScilabMode() == Console.ScilabMode.STD) {
333                 WindowsConfigurationManager.restoreUUID(NULLUUID);
334                 SwingScilabConsole sciConsole = ((SwingScilabConsole) ScilabConsole.getConsole().getAsSimpleConsole());
335                 SwingScilabTab consoleTab = (SwingScilabTab) sciConsole.getParent();
336                 consoleTab.setId(id);
337                 return consoleTab;
338             } else {
339                 return null;
340             }
341         case Edit:
342             SwingScilabEditBox edit = new SwingScilabEditBox();
343             edit.setId(id);
344             setDefaultProperties(edit, id);
345             return edit;
346         case Figure:
347             Figure figure = (Figure) GraphicController.getController().getObjectFromId(id);
348             String figureTitle = figure.getName();
349             Integer figureId = figure.getId();
350             if ((figureTitle != null) && (figureId != null)) {
351                 figureTitle = figureTitle.replaceFirst("%d", figureId.toString());
352             }
353
354             SwingScilabWindow window = new SwingScilabWindow();
355
356             window.setTitle(figureTitle);
357             /* TOOLBAR */
358             ToolBar toolBar = ToolBarBuilder.buildToolBar(SwingScilabTab.GRAPHICS_TOOLBAR_DESCRIPTOR, figureId);
359             /* INFOBAR */
360             TextBox infoBar = ScilabTextBox.createTextBox();
361
362             SwingScilabTab tab = new SwingScilabTab(figureTitle, figureId, figure);
363             tab.setId(id);
364
365             tab.setMenuBar(ScilabMenuBar.createMenuBar());
366             tab.setToolBar(toolBar);
367             tab.setInfoBar(ScilabTextBox.createTextBox());
368             window.addMenuBar(tab.getMenuBar());
369             window.addToolBar(tab.getToolBar());
370             window.addInfoBar(tab.getInfoBar());
371
372             tab.setWindowIcon("graphic-window");
373
374             tab.setParentWindowId(window.getId());
375
376             tab.setEventHandler(figure.getEventHandlerString());
377             tab.setEventHandlerEnabled(figure.getEventHandlerEnable());
378
379             DockingManager.dock(tab, window.getDockingPort());
380             ActiveDockableTracker.requestDockableActivation(tab);
381
382             window.setVisible(true);
383             tab.setVisible(true);
384             tab.setName(figureTitle);
385
386             String infoMessage = figure.getInfoMessage();
387             if ((infoMessage == null) || (infoMessage.length() == 0)) {
388                 infoBar.setText("");
389             } else {
390                 infoBar.setText(infoMessage);
391             }
392             tab.update(__GO_SIZE__, (Integer[]) GraphicController.getController().getProperty(id, __GO_SIZE__));
393             tab.update(__GO_POSITION__, (Integer[]) GraphicController.getController().getProperty(id, __GO_POSITION__));
394             // TODO set other default properties
395             return tab;
396         case Frame:
397             SwingScilabFrame frame = new SwingScilabFrame();
398             frame.setId(id);
399             setDefaultProperties(frame, id);
400             return frame;
401         case Image:
402             SwingScilabUiImage image = new SwingScilabUiImage();
403             image.setId(id);
404             setDefaultProperties(image, id);
405             return image;
406         case ListBox:
407             SwingScilabListBox listBox = new SwingScilabListBox();
408             listBox.setId(id);
409             setDefaultProperties(listBox, id);
410             return listBox;
411         case PopupMenu:
412             SwingScilabPopupMenu popupMenu = new SwingScilabPopupMenu();
413             popupMenu.setId(id);
414             setDefaultProperties(popupMenu, id);
415             return popupMenu;
416         case Progressbar:
417             SwingScilabWaitBar progressbar = new SwingScilabWaitBar();
418             progressbar.setIndeterminateMode(true);
419             progressbar.setId(id);
420             return progressbar;
421         case PushButton:
422             SwingScilabPushButton pushButton = new SwingScilabPushButton();
423             pushButton.setId(id);
424             setDefaultProperties(pushButton, id);
425             return pushButton;
426         case RadioButton:
427             SwingScilabRadioButton radioButton = new SwingScilabRadioButton();
428             radioButton.setId(id);
429             setDefaultProperties(radioButton, id);
430             return radioButton;
431         case Slider:
432             SwingScilabSlider slider = new SwingScilabSlider();
433             slider.setId(id);
434             setDefaultProperties(slider, id);
435             return slider;
436         case Table:
437             SwingScilabUiTable table = new SwingScilabUiTable();
438             table.setId(id);
439             setDefaultProperties(table, id);
440             return table;
441         case Text:
442             SwingScilabLabel text = new SwingScilabLabel();
443             text.setId(id);
444             setDefaultProperties(text, id);
445             return text;
446         case Uimenu:
447             throw new UnsupportedOperationException();
448         case UiParentMenu: /* SwingView internal type */
449             SwingScilabMenu parentMenu = new SwingScilabMenu();
450             parentMenu.setId(id);
451             setMenuDefaultProperties(parentMenu, id);
452             return parentMenu;
453         case UiChildMenu: /* SwingView internal type */
454             SwingScilabMenuItem childMenu = new SwingScilabMenuItem();
455             childMenu.setId(id);
456             setMenuDefaultProperties(childMenu, id);
457             return childMenu;
458         case UiCheckedMenu: /* SwingView internal type */
459             SwingScilabCheckBoxMenuItem checkedMenu = new SwingScilabCheckBoxMenuItem(false);
460             checkedMenu.setId(id);
461             setMenuDefaultProperties(checkedMenu, id);
462             return checkedMenu;
463         case UiContextMenu:
464             SwingScilabContextMenu contextMenu = new SwingScilabContextMenu();
465             contextMenu.setId(id);
466             return contextMenu;
467         case Waitbar:
468             SwingScilabWaitBar waitbar = new SwingScilabWaitBar();
469             waitbar.setIndeterminateMode(false);
470             waitbar.setId(id);
471             return waitbar;
472         default:
473             return null;
474         }
475     }
476
477     /**
478      * Initialize all poperties according to model
479      * @param uiMenuObject the uimenu
480      * @param id the uimenu id
481      */
482     private void setMenuDefaultProperties(Widget uiMenuObject, String id) {
483         SwingViewMenu.update(uiMenuObject, __GO_CHILDREN__,
484                 (String[]) GraphicController.getController().getProperty(id, __GO_CHILDREN__));
485         SwingViewMenu.update(uiMenuObject, __GO_CALLBACK__,
486                 (String) GraphicController.getController().getProperty(id, __GO_CALLBACK__));
487         SwingViewMenu.update(uiMenuObject, __GO_CALLBACKTYPE__,
488                 (Integer) GraphicController.getController().getProperty(id, __GO_CALLBACKTYPE__));
489         SwingViewMenu.update(uiMenuObject, __GO_UI_CHECKED__,
490                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_CHECKED__));
491         SwingViewMenu.update(uiMenuObject, __GO_UI_ENABLE__,
492                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_ENABLE__));
493         SwingViewMenu.update(uiMenuObject, __GO_UI_FOREGROUNDCOLOR__,
494                 (Double[]) GraphicController.getController().getProperty(id, __GO_UI_FOREGROUNDCOLOR__));
495         SwingViewMenu.update(uiMenuObject, __GO_UI_LABEL__,
496                 (String) GraphicController.getController().getProperty(id, __GO_UI_LABEL__));
497         SwingViewMenu.update(uiMenuObject, __GO_UI_ICON__,
498                 (String) GraphicController.getController().getProperty(id, __GO_UI_ICON__));
499     }
500
501     /**
502      * Initialize all poperties according to model
503      * @param uiControlObject the uicontrol
504      * @param id the uicontrol id
505      */
506     private void setDefaultProperties(Widget uiControlObject, String id) {
507         /* Visible property is set first to avoid to see the object rendered before all its properties to be set (See bug #10346) */
508         SwingViewWidget.update(uiControlObject, __GO_VISIBLE__,
509                 (Boolean) GraphicController.getController().getProperty(id, __GO_VISIBLE__));
510         SwingViewWidget.update(uiControlObject, __GO_UI_BACKGROUNDCOLOR__,
511                 (Double[]) GraphicController.getController().getProperty(id, __GO_UI_BACKGROUNDCOLOR__));
512         SwingViewWidget.update(uiControlObject, __GO_UI_ENABLE__,
513                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_ENABLE__));
514         SwingViewWidget.update(uiControlObject, __GO_UI_ENABLE__,
515                 (Boolean) GraphicController.getController().getProperty(id, __GO_UI_ENABLE__));
516         SwingViewWidget.update(uiControlObject, __GO_UI_FONTANGLE__,
517                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTANGLE__));
518         SwingViewWidget.update(uiControlObject, __GO_UI_FONTNAME__,
519                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTNAME__));
520         SwingViewWidget.update(uiControlObject, __GO_UI_FONTUNITS__,
521                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTUNITS__));
522         SwingViewWidget.update(uiControlObject, __GO_UI_FONTSIZE__,
523                 (Double) GraphicController.getController().getProperty(id, __GO_UI_FONTSIZE__));
524         SwingViewWidget.update(uiControlObject, __GO_UI_FONTWEIGHT__,
525                 (String) GraphicController.getController().getProperty(id, __GO_UI_FONTWEIGHT__));
526         SwingViewWidget.update(uiControlObject, __GO_UI_FOREGROUNDCOLOR__,
527                 (Double[]) GraphicController.getController().getProperty(id, __GO_UI_FOREGROUNDCOLOR__));
528         SwingViewWidget.update(uiControlObject, __GO_UI_HORIZONTALALIGNMENT__,
529                 (String) GraphicController.getController().getProperty(id, __GO_UI_HORIZONTALALIGNMENT__));
530         SwingViewWidget.update(uiControlObject, __GO_UI_RELIEF__,
531                 (String) GraphicController.getController().getProperty(id, __GO_UI_RELIEF__));
532         SwingViewWidget.update(uiControlObject, __GO_UI_STRING__,
533                 (String[]) GraphicController.getController().getProperty(id, __GO_UI_STRING__));
534         SwingViewWidget.update(uiControlObject, __GO_UI_VERTICALALIGNMENT__,
535                 (String) GraphicController.getController().getProperty(id, __GO_UI_VERTICALALIGNMENT__));
536         SwingViewWidget.update(uiControlObject, __GO_POSITION__,
537                 (Double[]) GraphicController.getController().getProperty(id, __GO_POSITION__));
538     }
539
540     public void deleteObject(String id) {
541         final TypedObject requestedObject = allObjects.get(id);
542         if (requestedObject != null) {
543             switch (requestedObject.getType()) {
544             case Figure:
545                 final SwingScilabTab tab = (SwingScilabTab) requestedObject.getValue();
546                 tab.disablePaint();
547                 DockingManager.close(tab);
548                 DockingManager.unregisterDockable((Dockable) tab);
549                 ClosingOperationsManager.unregisterClosingOperation(tab);
550                 ClosingOperationsManager.removeDependency(tab);
551                 ClosingOperationsManager.checkTabForClosing(tab);
552                 tab.close();
553                 break;
554             case Progressbar:
555             case Waitbar:
556                 SwingScilabWaitBar bar = (SwingScilabWaitBar) requestedObject.getValue();
557                 bar.close();
558                 break;
559             default:
560                 // Nothing to do
561                     // uicontrol case: the object is destroyed when its parent updates its children
562                 break;
563             }
564             allObjects.remove(id);
565         }
566     }
567
568     @Override
569     public void updateObject(final String id, final int property) {
570         final TypedObject registeredObject = allObjects.get(id);
571         if (registeredObject == null && property != __GO_STYLE__) {
572             return;
573         }
574         
575         /* On uicontrol style is set after object creation */
576         if (registeredObject == null && property == __GO_STYLE__) {
577             int style = (Integer) GraphicController.getController().getProperty(id, __GO_STYLE__);
578             allObjects.put(id, CreateObjectFromType(style, id));
579             return;
580         }
581        
582         if (SwingUtilities.isEventDispatchThread()) {
583             updateObjectOnEDT(registeredObject, id, property);
584         } else {
585                 try {
586                     SwingUtilities.invokeAndWait(new Runnable() {
587                         @Override
588                         public void run() {
589                             updateObjectOnEDT(registeredObject, id, property);
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     }
601
602     public void updateObjectOnEDT(TypedObject registeredObject, final String id, final int property) {
603         /* Removes the swing object if its parent is not display */
604         if (registeredObject != null && property == __GO_PARENT__) {
605             String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
606             TypedObject registeredParent = allObjects.get(parentId);
607             if (registeredParent == null) {
608                 allObjects.remove(id);
609             }
610         }
611         
612         int type = (Integer) GraphicController.getController().getProperty(id, __GO_TYPE__);
613         /* Children list update */
614         if (registeredObject != null && property == __GO_CHILDREN__) {
615             final String[] newChildren = (String[]) GraphicController.getController().getProperty(id, __GO_CHILDREN__);
616
617             switch (type) {
618             /*
619              * FIGURE CHILDREN UPDATE
620              */
621             case __GO_FIGURE__ :
622                 updateFigureChildren(registeredObject, newChildren);
623                 break;
624                 /*
625                  * CONSOLE CHILDREN UPDATE
626                  */
627             case __GO_CONSOLE__ :
628                 updateConsoleChildren(registeredObject, newChildren);
629                 break;
630                 /*
631                  * MENU CHILDREN UPDATE
632                  */
633             case __GO_UIMENU__ :
634                 updateMenuChildren(registeredObject, id, newChildren);
635                 break;
636                 /*
637                  * CONTEXTMENU CHILDREN UPDATE
638                  */
639             case __GO_UICONTEXTMENU__ :
640                 updateContextMenuChildren(registeredObject, newChildren);
641                 break;
642                 /*
643                  * UICONTROL "FRAME" CHILDREN UPDATE
644                  */
645             case __GO_UICONTROL__ :
646                 int style = (Integer) GraphicController.getController().getProperty(id, __GO_STYLE__);
647                 if (style == __GO_UI_FRAME__) {
648                     updateFrameChildren(registeredObject, newChildren);
649                 }
650                 break;
651             }
652         }
653
654         /*
655          * When the CHECKED property is updated for a UIMENU,
656          * the object is converted to a SwingScilabCheckBoxMenuItem is not already of this type
657          */
658         if (registeredObject != null && property == __GO_UI_CHECKED__) {
659             if (type == __GO_UIMENU__) {
660                 switch (registeredObject.getType()) {
661                 case UiParentMenu:
662                     SwingScilabMenu meAsAMenu = (SwingScilabMenu) registeredObject.getValue();
663                     Container parent = meAsAMenu.getParent();
664                     parent.remove(meAsAMenu);
665                     registeredObject = CreateObjectFromType(__GO_UICHECKEDMENU__, id);
666                     allObjects.put(id, registeredObject);
667                     SwingScilabCheckBoxMenuItem meAsAMenuItem = (SwingScilabCheckBoxMenuItem) registeredObject.getValue();
668                     parent.add(meAsAMenuItem);
669                     break;
670                 case UiChildMenu:
671                     String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
672                     SwingScilabMenuItem childMenu = (SwingScilabMenuItem) allObjects.get(id).getValue();
673                     SwingScilabMenu parentMenu = (SwingScilabMenu) allObjects.get(parentId).getValue();
674                     
675                     int index = parentMenu.getComponentZOrder(childMenu);
676                     parentMenu.remove(childMenu);
677                     registeredObject = CreateObjectFromType(__GO_UICHECKEDMENU__, id);
678                     allObjects.put(id, registeredObject);
679                     registeredObject = allObjects.get(id);
680                     parentMenu.add((SwingScilabCheckBoxMenuItem) registeredObject.getValue(), index);
681                     return;
682                 default:
683                     break;
684                 }
685             }
686         }
687
688         /*
689          * When the SEPARATOR property is updated for a UIMENU,
690          * When the property is set to TRUE: A separator is added if not already done
691          * When the property is set to FALSE: The previous separator is removed if it exists
692          */
693         if (registeredObject != null && property == __GO_UI_SEPARATOR__) {
694             if (type == __GO_UIMENU__) {
695                 String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
696                 int menuPosition = -1;
697                 Component currentComponent = (Component) registeredObject.getValue();
698                 Component[] allChildren =  ((SwingScilabMenu) allObjects.get(parentId).getValue()).getMenuComponents();
699                 for (int kChild = 0; kChild < allChildren.length; kChild++) {
700                     if (allChildren[kChild] == currentComponent) {
701                         menuPosition = kChild;
702                         break;
703                     }
704                 }
705                 if (menuPosition < 0) {
706                     return;
707                 }
708                 boolean newSeparatorMode = (Boolean) GraphicController.getController().getProperty(id, __GO_UI_SEPARATOR__);
709                 if (newSeparatorMode) { // Add a separator above the menu
710                     ((SwingScilabMenu) allObjects.get(parentId).getValue()).insertSeparator(menuPosition);
711                 } else { // Remove the separator above the menu (if there is one)
712                     if (menuPosition == 0) { // There is no object above the menu
713                         return;
714                     }
715                     if (((SwingScilabMenu) allObjects.get(parentId).getValue()).getComponent(menuPosition - 1) instanceof JSeparator) {
716                         ((SwingScilabMenu) allObjects.get(parentId).getValue()).remove(menuPosition - 1);
717                     }
718                 }
719             }
720         }
721
722         if (registeredObject != null) {
723             final SwingViewObject swingObject = registeredObject.getValue();
724             if (swingObject != null) {
725                 swingObject.update(property, GraphicController.getController().getProperty(id, property));
726             }
727         }
728     }
729
730     /**
731      * Update the figure children (called by generic updateObject method)
732      * @param id the id of the figure
733      * @param newChildren the new children IDs list
734      */
735     private void updateFigureChildren(TypedObject updatedObject, String[] newChildren) {
736         Container updatedComponent = (SwingScilabTab) updatedObject.getValue();
737         boolean needRevalidate = false;
738
739         // Add new children
740         for (String childId : newChildren) {
741             if (!updatedObject.hasChild(childId)) {
742
743                 // Add the child
744                 updatedObject.addChild(childId);
745
746                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
747
748                 /* Add an uicontrol */
749                 if (childType == __GO_UICONTROL__) {
750                     ((SwingScilabTab) updatedComponent).addMember(allObjects.get(childId).getValue());
751                     needRevalidate = true;
752                 }
753
754                 /* Add an uimenu */
755                 if (childType == __GO_UIMENU__) {
756                     TypedObject childAsTypedObject = allObjects.get(childId);
757                     switch (childAsTypedObject.getType()) {
758                     case UiChildMenu:
759                     case UiCheckedMenu:
760                         allObjects.remove(childId);
761                         allObjects.put(childId, CreateObjectFromType(__GO_UIPARENTMENU__, childId));
762                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) allObjects.get(childId).getValue());
763                         break;
764                     default: /* UiParentMenu */
765                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) allObjects.get(childId).getValue());
766                         break;
767                     }
768                     needRevalidate = true;
769                 }
770             }
771         }
772
773         // Remove children which have been deleted
774         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
775         // Clone the children set to avoid concurrent accesses
776         String[] oldChildrenSet = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
777         for (String childId : oldChildrenSet) {
778             if (!newChildrenSet.contains(childId)) {
779
780                 // Remove the child
781                 updatedObject.removeChild(childId);
782
783                 final Object childTypeObject = GraphicController.getController().getProperty(childId, __GO_TYPE__);
784                 if (childTypeObject == null) {
785                     // the child has already been removed from the model
786                     continue;
787                 }
788                 int childType = (Integer) childTypeObject;
789
790                 /* Remove an uicontrol */
791                 if (childType == __GO_UICONTROL__) {
792                     ((SwingScilabTab) updatedComponent).removeMember(allObjects.get(childId).getValue());
793                     needRevalidate = true;
794                 }
795
796                 /* Remove an uimenu */
797                 if (childType == __GO_UIMENU__) {
798                     TypedObject childAsTypedObject = allObjects.get(childId);
799                     switch (childAsTypedObject.getType()) {
800                     case UiCheckedMenu:
801                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
802                         break;
803                     default: /* UiParentMenu */
804                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabMenu) allObjects.get(childId).getValue());
805                         break;
806                     }
807                     needRevalidate = true;
808                 }
809             }
810         }
811         if (needRevalidate && updatedComponent != null) {
812             ((View) updatedComponent).revalidate();
813         }
814     }
815
816     /**
817      * Update the frame children (called by generic updateObject method)
818      * @param id the id of the figure
819      * @param newChildren the new children IDs list
820      */
821     private void updateFrameChildren(TypedObject updatedObject, String[] newChildren) {
822         Container updatedComponent = (SwingScilabFrame) updatedObject.getValue();
823         boolean needRevalidate = false;
824
825         // Add new children
826         for (String childId : newChildren) {
827             if (!updatedObject.hasChild(childId)) {
828
829                 // Add the child
830                 updatedObject.addChild(childId);
831
832                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
833
834                 /* Add an uicontrol */
835                 if (childType == __GO_UICONTROL__) {
836                     ((SwingScilabFrame) updatedComponent).addMember(allObjects.get(childId).getValue());
837                     needRevalidate = true;
838                 }
839             }
840         }
841
842         // Remove children which have been deleted
843         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
844         // Clone the children set to avoid concurrent accesses
845         String[] oldChildrenSet = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
846         for (String childId : oldChildrenSet) {
847             if (!newChildrenSet.contains(childId)) {
848
849                 // Remove the child
850                 updatedObject.removeChild(childId);
851
852                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
853
854                 /* Remove an uicontrol */
855                 if (childType == __GO_UICONTROL__) {
856                     updatedComponent.remove((Component) allObjects.get(childId).getValue());
857                     needRevalidate = true;
858                 }
859             }
860         }
861         if (needRevalidate && updatedComponent != null) {
862             ((JPanel) updatedComponent).revalidate();
863         }
864     }
865
866     /**
867      * Update the Console menus (called by generic updateObject method)
868      * @param id the id of the console object
869      * @param newChildren the new children IDs list
870      */
871     private void updateConsoleChildren(TypedObject updatedObject, String[] newChildren) {
872         Container updatedComponent = (SwingScilabTab) updatedObject.getValue();
873         boolean needRevalidate = false;
874
875         // Add new children
876         for (String childId : newChildren) {
877             if (!updatedObject.hasChild(childId)) {
878
879                 // Add the child
880                 updatedObject.addChild(childId);
881
882                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
883
884                 if (childType == __GO_UIMENU__) {
885                     TypedObject childAsTypedObject = allObjects.get(childId);
886                     switch (childAsTypedObject.getType()) {
887                     case UiChildMenu:
888                     case UiCheckedMenu:
889                         TypedObject newUiParentMenu = CreateObjectFromType(__GO_UIPARENTMENU__, childId);
890                         allObjects.put(childId, newUiParentMenu);
891                         ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) newUiParentMenu.getValue());
892                         break;
893                     default: /* UiParentMenu */
894                         ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) childAsTypedObject.getValue());
895                         break;
896                     }
897                     needRevalidate = true;
898                 }
899             }
900         }
901
902         // Remove children which have been deleted
903         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
904         Object[] updatedObjectChildren = updatedObject.getChildren().toArray();
905         for (int i = 0 ; i < updatedObjectChildren.length ; ++i) {
906             String childId = (String) updatedObjectChildren[i];
907             if (!newChildrenSet.contains(childId)) {
908
909                 // Remove the child
910                 updatedObject.removeChild(childId);
911
912                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
913
914                 if (childType == __GO_UIMENU__) {
915                     ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabMenu) allObjects.get(childId).getValue());
916                     needRevalidate = true;
917                 }
918             }
919         }
920         if (needRevalidate && updatedComponent != null) {
921             updatedComponent.validate();
922         }
923
924     }
925
926     /**
927      * Update the children of a menu menus (called by generic updateObject method)
928      * @param id the id of the menu object
929      * @param newChildren the new children IDs list
930      */
931     private void updateMenuChildren(TypedObject updatedObject, String id, String[] newChildren) {
932         Container updatedComponent = null;
933         boolean needRevalidate = false;
934         int updatedObjectPosition = 0;
935         TypedObject newParent = null;
936
937         // Add new children
938         for (String childId : newChildren) {
939             int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
940             if (childType == __GO_UIMENU__) {
941                 if (!updatedObject.hasChild(childId)) {
942                     // Add the child
943                     updatedObject.addChild(childId);
944
945                     TypedObject childAsTypedObject = allObjects.get(childId);
946                     Object addedChild = allObjects.get(childId).getValue();
947                     JComponent parent = null;
948                     switch (updatedObject.getType()) {
949                     case UiChildMenu:
950                         updatedComponent = (SwingScilabMenuItem) updatedObject.getValue();
951                         parent = (JComponent) updatedComponent.getParent();
952                         switch (childAsTypedObject.getType()) {
953                         case UiChildMenu:
954                             /* Replace the item by a parent menu */
955                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabMenuItem) updatedObject.getValue());
956                             parent.remove((SwingScilabMenuItem) updatedObject.getValue());
957                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
958                             allObjects.put(id, newParent);
959                             newParent.addChild(childId);
960                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
961                             /* Update the created menu */
962                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabMenuItem) addedChild);
963                             break;
964                         case UiCheckedMenu:
965                             /* Replace the item by a parent menu */
966                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
967                             parent.remove((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
968                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
969                             allObjects.put(id, newParent);
970                             newParent.addChild(childId);
971                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
972                             /* Update the created menu */
973                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabCheckBoxMenuItem) addedChild);
974                             break;
975                         default: /* UiParentMenu */
976                             ((SwingScilabMenu) updatedObject.getValue()).add((SwingScilabMenu) addedChild);
977                             break;
978                         }
979                         break;
980                     case UiCheckedMenu:
981                         updatedComponent = (SwingScilabCheckBoxMenuItem) updatedObject.getValue();
982                         parent = (JComponent) updatedComponent.getParent();
983                         switch (childAsTypedObject.getType()) {
984                         case UiChildMenu:
985                             /* Replace the item by a parent menu */
986                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
987                             parent.remove((SwingScilabCheckBoxMenuItem) allObjects.get(id).getValue());
988                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
989                             allObjects.put(id, newParent);
990                             newParent.addChild(childId);
991                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
992                             /* Update the created menu */
993                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabMenuItem) allObjects.get(childId).getValue());
994                             break;
995                         case UiCheckedMenu:
996                             /* Replace the item by a parent menu */
997                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
998                             parent.remove((SwingScilabCheckBoxMenuItem) allObjects.get(id).getValue());
999                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
1000                             allObjects.put(id, newParent);
1001                             newParent.addChild(childId);
1002                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
1003                             /* Update the created menu */
1004                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1005                             break;
1006                         default: /* UiParentMenu */
1007                             System.out.println("childAsTypedObject.getType() = UiParentMenu");
1008                             ((SwingScilabMenu) updatedObject.getValue()).add((SwingScilabMenu) allObjects.get(childId).getValue());
1009                             break;
1010                         }
1011                         break;
1012                     default: /* UiParentMenu */
1013                         SwingScilabMenu updatedMenu = (SwingScilabMenu) updatedObject.getValue();
1014                         updatedComponent = updatedMenu;
1015                         switch (childAsTypedObject.getType()) {
1016                         case UiChildMenu:
1017                             updatedMenu.add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1018                             break;
1019                         case UiCheckedMenu:
1020                             updatedMenu.add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1021                             break;
1022                         default: /* UiParentMenu */
1023                         /* Java can not add a JMenu in a JMenu */
1024                             /* We need to convert the child into a MenuItem */
1025                             TypedObject newMenu = CreateObjectFromType(__GO_UIMENU__, childId);
1026                             allObjects.put(childId, newMenu);
1027                             updatedMenu.add((SwingScilabMenuItem) newMenu.getValue());
1028                             break;
1029                         }
1030                         break;
1031                     }
1032                     needRevalidate = true;
1033                 }
1034             }
1035         }
1036         // Remove children which have been deleted
1037         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
1038         String[] oldChildren = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
1039         for (int childIndex = 0; childIndex < oldChildren.length; childIndex++) {
1040             String childId = oldChildren[childIndex];
1041             if (!newChildrenSet.contains(childId)) {
1042                 // Remove the child
1043                 updatedObject.removeChild(childId);
1044                 updatedComponent = (SwingScilabMenu) updatedObject.getValue();
1045
1046                 TypedObject childAsTypedObject = allObjects.get(childId);
1047                 Object removedMenu = childAsTypedObject.getValue();
1048
1049                 switch (childAsTypedObject.getType()) {
1050                 case UiChildMenu:
1051                     updatedComponent.remove((SwingScilabMenuItem) removedMenu);
1052                     break;
1053                 case UiCheckedMenu:
1054                     updatedComponent.remove((SwingScilabCheckBoxMenuItem) removedMenu);
1055                     break;
1056                 default:
1057                     updatedComponent.remove((SwingScilabMenu) removedMenu);
1058                     break;
1059                 }
1060                 needRevalidate = true;
1061             }
1062         }
1063         if (needRevalidate && updatedComponent != null) {
1064             updatedComponent.validate();
1065         }
1066     }
1067     /**
1068      * Update the children of a contextmenu (called by generic updateObject method)
1069      * @param id the id of the contextmenu object
1070      * @param newChildren the new children IDs list
1071      */
1072     private void updateContextMenuChildren(TypedObject updatedObject, String[] newChildren) {
1073         Container updatedComponent = null;
1074         boolean needRevalidate = false;
1075
1076         // Add new children
1077         for (String childId : newChildren) {
1078             int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
1079             if (childType == __GO_UIMENU__) {
1080                 if (!updatedObject.hasChild(childId)) {
1081
1082                     // Add the child
1083                     updatedObject.addChild(childId);
1084
1085                     TypedObject childAsTypedObject = allObjects.get(childId);
1086                     SwingScilabContextMenu updatedMenu = (SwingScilabContextMenu) updatedObject.getValue();
1087                     updatedComponent = updatedMenu;
1088                     switch (childAsTypedObject.getType()) {
1089                     case UiChildMenu:
1090                         updatedMenu.add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1091                         break;
1092                     case UiCheckedMenu:
1093                         updatedMenu.add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1094                         break;
1095                     default: /* UiParentMenu */
1096                         updatedMenu.add((SwingScilabMenu) allObjects.get(childId).getValue());
1097                         break;
1098                     }
1099                     needRevalidate = true;
1100                 }
1101             }
1102         }
1103         // Remove children which have been deleted
1104         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
1105         for (String childId : updatedObject.getChildren()) {
1106             if (!newChildrenSet.contains(childId)) {
1107                 // Remove the child
1108                 updatedObject.removeChild(childId);
1109                 updatedComponent = (SwingScilabMenu) updatedObject.getValue();
1110
1111                 TypedObject childAsTypedObject = allObjects.get(childId);
1112                 SwingScilabContextMenu updatedMenu = (SwingScilabContextMenu) updatedObject.getValue();
1113                 Object removedMenu = allObjects.get(childId).getValue();
1114
1115                 switch (childAsTypedObject.getType()) {
1116                 case UiChildMenu:
1117                     updatedMenu.remove((SwingScilabMenuItem) removedMenu);
1118                     break;
1119                 case UiCheckedMenu:
1120                     updatedMenu.remove((SwingScilabCheckBoxMenuItem) removedMenu);
1121                     break;
1122                 default:
1123                     updatedMenu.remove((SwingScilabMenu) removedMenu);
1124                     break;
1125                 }
1126                 needRevalidate = true;
1127             }
1128         }
1129         if (needRevalidate && updatedComponent != null) {
1130             updatedComponent.validate();
1131         }
1132     }
1133 }