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                 final SwingScilabTab tab = (SwingScilabTab) requestedObject.getValue();
 567                 tab.disablePaint();
 568                 DockingManager.close(tab);
 569                 DockingManager.unregisterDockable((Dockable) tab);
 570                 ClosingOperationsManager.unregisterClosingOperation(tab);
 571                 ClosingOperationsManager.removeDependency(tab);
 572                 ClosingOperationsManager.checkTabForClosing(tab);
 573                 tab.close();
 574                 break;
 575             case Progressbar:
 576             case Waitbar:
 577                 SwingScilabWaitBar bar = (SwingScilabWaitBar) requestedObject.getValue();
 578                 bar.close();
 579                 break;
 580             default:
 581                 // Nothing to do
 582                     // uicontrol case: the object is destroyed when its parent updates its children
 583                 break;
 584             }
 585             allObjects.remove(id);
 586         }
 587     }
 588
 589     @Override
 590     public void updateObject(final String id, final int property) {
 591         final TypedObject registeredObject = allObjects.get(id);
 592         if (registeredObject == null && property != __GO_STYLE__) {
 593             return;
 594         }
 595
 596         /* On uicontrol style is set after object creation */
 597         if (registeredObject == null && property == __GO_STYLE__) {
 598             int style = (Integer) GraphicController.getController().getProperty(id, __GO_STYLE__);
 599             allObjects.put(id, CreateObjectFromType(style, id));
 600             return;
 601         }
 602
 603         if (SwingUtilities.isEventDispatchThread()) {
 604             updateObjectOnEDT(registeredObject, id, property);
 605         } else {
 606                 try {
 607                     SwingUtilities.invokeAndWait(new Runnable() {
 608                         @Override
 609                         public void run() {
 610                             updateObjectOnEDT(registeredObject, id, property);
 611                         }
 612                     });
 613                 } catch (InterruptedException e) {
 614                     // TODO Auto-generated catch block
 615                     e.printStackTrace();
 616                 } catch (InvocationTargetException e) {
 617                     // TODO Auto-generated catch block
 618                     e.printStackTrace();
 619                 }
 620         }
 621     }
 622
 623     public void updateObjectOnEDT(TypedObject registeredObject, final String id, final int property) {
 624         /* Removes the swing object if its parent is not display */
 625         if (registeredObject != null && property == __GO_PARENT__) {
 626             String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
 627             TypedObject registeredParent = allObjects.get(parentId);
 628             if (registeredParent == null) {
 629                 allObjects.remove(id);
 630             }
 631         }
 632
 633         int type = (Integer) GraphicController.getController().getProperty(id, __GO_TYPE__);
 634         /* Children list update */
 635         if (registeredObject != null && property == __GO_CHILDREN__) {
 636             final String[] newChildren = (String[]) GraphicController.getController().getProperty(id, __GO_CHILDREN__);
 637
 638             switch (type) {
 639             /*
 640              * FIGURE CHILDREN UPDATE
 641              */
 642             case __GO_FIGURE__ :
 643                 updateFigureChildren(registeredObject, newChildren);
 644                 break;
 645                 /*
 646                  * CONSOLE CHILDREN UPDATE
 647                  */
 648             case __GO_CONSOLE__ :
 649                 updateConsoleChildren(registeredObject, newChildren);
 650                 break;
 651                 /*
 652                  * MENU CHILDREN UPDATE
 653                  */
 654             case __GO_UIMENU__ :
 655                 updateMenuChildren(registeredObject, id, newChildren);
 656                 break;
 657                 /*
 658                  * CONTEXTMENU CHILDREN UPDATE
 659                  */
 660             case __GO_UICONTEXTMENU__ :
 661                 updateContextMenuChildren(registeredObject, newChildren);
 662                 break;
 663                 /*
 664                  * UICONTROL "FRAME" CHILDREN UPDATE
 665                  */
 666             case __GO_UICONTROL__ :
 667                 int style = (Integer) GraphicController.getController().getProperty(id, __GO_STYLE__);
 668                 if (style == __GO_UI_FRAME__) {
 669                     updateFrameChildren(registeredObject, newChildren);
 670                 }
 671                 break;
 672             }
 673         }
 674
 675         /*
 676          * When the CHECKED property is updated for a UIMENU,
 677          * the object is converted to a SwingScilabCheckBoxMenuItem is not already of this type
 678          */
 679         if (registeredObject != null && property == __GO_UI_CHECKED__) {
 680             if (type == __GO_UIMENU__) {
 681                 switch (registeredObject.getType()) {
 682                 case UiParentMenu:
 683                     SwingScilabMenu meAsAMenu = (SwingScilabMenu) registeredObject.getValue();
 684                     Container parent = meAsAMenu.getParent();
 685                     parent.remove(meAsAMenu);
 686                     registeredObject = CreateObjectFromType(__GO_UICHECKEDMENU__, id);
 687                     allObjects.put(id, registeredObject);
 688                     SwingScilabCheckBoxMenuItem meAsAMenuItem = (SwingScilabCheckBoxMenuItem) registeredObject.getValue();
 689                     parent.add(meAsAMenuItem);
 690                     break;
 691                 case UiChildMenu:
 692                     String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
 693                     SwingScilabMenuItem childMenu = (SwingScilabMenuItem) allObjects.get(id).getValue();
 694                     SwingScilabMenu parentMenu = (SwingScilabMenu) allObjects.get(parentId).getValue();
 695
 696                     int index = parentMenu.getComponentZOrder(childMenu);
 697                     parentMenu.remove(childMenu);
 698                     registeredObject = CreateObjectFromType(__GO_UICHECKEDMENU__, id);
 699                     allObjects.put(id, registeredObject);
 700                     registeredObject = allObjects.get(id);
 701                     parentMenu.add((SwingScilabCheckBoxMenuItem) registeredObject.getValue(), index);
 702                     return;
 703                 default:
 704                     break;
 705                 }
 706             }
 707         }
 708
 709         /*
 710          * When the SEPARATOR property is updated for a UIMENU,
 711          * When the property is set to TRUE: A separator is added if not already done
 712          * When the property is set to FALSE: The previous separator is removed if it exists
 713          */
 714         if (registeredObject != null && property == __GO_UI_SEPARATOR__) {
 715             if (type == __GO_UIMENU__) {
 716                 String parentId = (String) GraphicController.getController().getProperty(id, __GO_PARENT__);
 717                 int menuPosition = -1;
 718                 Component currentComponent = (Component) registeredObject.getValue();
 719                 Component[] allChildren =  ((SwingScilabMenu) allObjects.get(parentId).getValue()).getMenuComponents();
 720                 for (int kChild = 0; kChild < allChildren.length; kChild++) {
 721                     if (allChildren[kChild] == currentComponent) {
 722                         menuPosition = kChild;
 723                         break;
 724                     }
 725                 }
 726                 if (menuPosition < 0) {
 727                     return;
 728                 }
 729                 boolean newSeparatorMode = (Boolean) GraphicController.getController().getProperty(id, __GO_UI_SEPARATOR__);
 730                 if (newSeparatorMode) { // Add a separator above the menu
 731                     ((SwingScilabMenu) allObjects.get(parentId).getValue()).insertSeparator(menuPosition);
 732                 } else { // Remove the separator above the menu (if there is one)
 733                     if (menuPosition == 0) { // There is no object above the menu
 734                         return;
 735                     }
 736                     if (((SwingScilabMenu) allObjects.get(parentId).getValue()).getComponent(menuPosition - 1) instanceof JSeparator) {
 737                         ((SwingScilabMenu) allObjects.get(parentId).getValue()).remove(menuPosition - 1);
 738                     }
 739                 }
 740             }
 741         }
 742
 743         if (registeredObject != null) {
 744             final SwingViewObject swingObject = registeredObject.getValue();
 745             if (swingObject != null) {
 746                 swingObject.update(property, GraphicController.getController().getProperty(id, property));
 747             }
 748         }
 749     }
 750
 751     /**
 752      * Update the figure children (called by generic updateObject method)
 753      * @param id the id of the figure
 754      * @param newChildren the new children IDs list
 755      */
 756     private void updateFigureChildren(TypedObject updatedObject, String[] newChildren) {
 757         Container updatedComponent = (SwingScilabTab) updatedObject.getValue();
 758         boolean needRevalidate = false;
 759
 760         // Add new children
 761         for (String childId : newChildren) {
 762             if (!updatedObject.hasChild(childId)) {
 763
 764                 // Add the child
 765                 updatedObject.addChild(childId);
 766
 767                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
 768
 769                 /* Add an uicontrol */
 770                 if (childType == __GO_UICONTROL__) {
 771                     ((SwingScilabTab) updatedComponent).addMember(allObjects.get(childId).getValue());
 772                     needRevalidate = true;
 773                 }
 774
 775                 /* Add an uimenu */
 776                 if (childType == __GO_UIMENU__) {
 777                     TypedObject childAsTypedObject = allObjects.get(childId);
 778                     switch (childAsTypedObject.getType()) {
 779                     case UiChildMenu:
 780                     case UiCheckedMenu:
 781                         allObjects.remove(childId);
 782                         allObjects.put(childId, CreateObjectFromType(__GO_UIPARENTMENU__, childId));
 783                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) allObjects.get(childId).getValue());
 784                         break;
 785                     default: /* UiParentMenu */
 786                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) allObjects.get(childId).getValue());
 787                         break;
 788                     }
 789                     needRevalidate = true;
 790                 }
 791             }
 792         }
 793
 794         // Remove children which have been deleted
 795         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
 796         // Clone the children set to avoid concurrent accesses
 797         String[] oldChildrenSet = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
 798         for (String childId : oldChildrenSet) {
 799             if (!newChildrenSet.contains(childId)) {
 800
 801                 // Remove the child
 802                 updatedObject.removeChild(childId);
 803
 804                 final Object childTypeObject = GraphicController.getController().getProperty(childId, __GO_TYPE__);
 805                 if (childTypeObject == null) {
 806                     // the child has already been removed from the model
 807                     continue;
 808                 }
 809                 int childType = (Integer) childTypeObject;
 810
 811                 /* Remove an uicontrol */
 812                 if (childType == __GO_UICONTROL__) {
 813                     ((SwingScilabTab) updatedComponent).removeMember(allObjects.get(childId).getValue());
 814                     needRevalidate = true;
 815                 }
 816
 817                 /* Remove an uimenu */
 818                 if (childType == __GO_UIMENU__) {
 819                     TypedObject childAsTypedObject = allObjects.get(childId);
 820                     switch (childAsTypedObject.getType()) {
 821                     case UiCheckedMenu:
 822                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
 823                         break;
 824                     default: /* UiParentMenu */
 825                         ((Container) ((SwingScilabTab) updatedComponent).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabMenu) allObjects.get(childId).getValue());
 826                         break;
 827                     }
 828                     needRevalidate = true;
 829                 }
 830             }
 831         }
 832         if (needRevalidate && updatedComponent != null) {
 833             ((View) updatedComponent).revalidate();
 834         }
 835     }
 836
 837     /**
 838      * Update the frame children (called by generic updateObject method)
 839      * @param id the id of the figure
 840      * @param newChildren the new children IDs list
 841      */
 842     private void updateFrameChildren(TypedObject updatedObject, String[] newChildren) {
 843         Container updatedComponent = (SwingScilabFrame) updatedObject.getValue();
 844         boolean needRevalidate = false;
 845
 846         // Add new children
 847         for (String childId : newChildren) {
 848             if (!updatedObject.hasChild(childId)) {
 849
 850                 // Add the child
 851                 updatedObject.addChild(childId);
 852
 853                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
 854
 855                 /* Add an uicontrol */
 856                 if (childType == __GO_UICONTROL__) {
 857                     ((SwingScilabFrame) updatedComponent).addMember(allObjects.get(childId).getValue());
 858                     needRevalidate = true;
 859                 }
 860             }
 861         }
 862
 863         // Remove children which have been deleted
 864         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
 865         // Clone the children set to avoid concurrent accesses
 866         String[] oldChildrenSet = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
 867         for (String childId : oldChildrenSet) {
 868             if (!newChildrenSet.contains(childId)) {
 869
 870                 // Remove the child
 871                 updatedObject.removeChild(childId);
 872
 873                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
 874
 875                 /* Remove an uicontrol */
 876                 if (childType == __GO_UICONTROL__) {
 877                     updatedComponent.remove((Component) allObjects.get(childId).getValue());
 878                     needRevalidate = true;
 879                 }
 880             }
 881         }
 882         if (needRevalidate && updatedComponent != null) {
 883             ((JPanel) updatedComponent).revalidate();
 884         }
 885     }
 886
 887     /**
 888      * Update the Console menus (called by generic updateObject method)
 889      * @param id the id of the console object
 890      * @param newChildren the new children IDs list
 891      */
 892     private void updateConsoleChildren(TypedObject updatedObject, String[] newChildren) {
 893         Container updatedComponent = (SwingScilabTab) updatedObject.getValue();
 894         boolean needRevalidate = false;
 895
 896         // Add new children
 897         for (String childId : newChildren) {
 898             if (!updatedObject.hasChild(childId)) {
 899
 900                 // Add the child
 901                 updatedObject.addChild(childId);
 902
 903                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
 904
 905                 if (childType == __GO_UIMENU__) {
 906                     TypedObject childAsTypedObject = allObjects.get(childId);
 907                     switch (childAsTypedObject.getType()) {
 908                     case UiChildMenu:
 909                     case UiCheckedMenu:
 910                         TypedObject newUiParentMenu = CreateObjectFromType(__GO_UIPARENTMENU__, childId);
 911                         allObjects.put(childId, newUiParentMenu);
 912                         ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) newUiParentMenu.getValue());
 913                         break;
 914                     default: /* UiParentMenu */
 915                         ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).add((SwingScilabMenu) childAsTypedObject.getValue());
 916                         break;
 917                     }
 918                     needRevalidate = true;
 919                 }
 920             }
 921         }
 922
 923         // Remove children which have been deleted
 924         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
 925         Object[] updatedObjectChildren = updatedObject.getChildren().toArray();
 926         for (int i = 0 ; i < updatedObjectChildren.length ; ++i) {
 927             String childId = (String) updatedObjectChildren[i];
 928             if (!newChildrenSet.contains(childId)) {
 929
 930                 // Remove the child
 931                 updatedObject.removeChild(childId);
 932
 933                 int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
 934
 935                 if (childType == __GO_UIMENU__) {
 936                     ((Container) ((SwingScilabTab) updatedObject.getValue()).getMenuBar().getAsSimpleMenuBar()).remove((SwingScilabMenu) allObjects.get(childId).getValue());
 937                     needRevalidate = true;
 938                 }
 939             }
 940         }
 941         if (needRevalidate && updatedComponent != null) {
 942             updatedComponent.validate();
 943         }
 944
 945     }
 946
 947     /**
 948      * Update the children of a menu menus (called by generic updateObject method)
 949      * @param id the id of the menu object
 950      * @param newChildren the new children IDs list
 951      */
 952     private void updateMenuChildren(TypedObject updatedObject, String id, String[] newChildren) {
 953         Container updatedComponent = null;
 954         boolean needRevalidate = false;
 955         int updatedObjectPosition = 0;
 956         TypedObject newParent = null;
 957
 958         // Add new children
 959         for (String childId : newChildren) {
 960             int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
 961             if (childType == __GO_UIMENU__) {
 962                 if (!updatedObject.hasChild(childId)) {
 963                     // Add the child
 964                     updatedObject.addChild(childId);
 965
 966                     TypedObject childAsTypedObject = allObjects.get(childId);
 967                     Object addedChild = allObjects.get(childId).getValue();
 968                     JComponent parent = null;
 969                     switch (updatedObject.getType()) {
 970                     case UiChildMenu:
 971                         updatedComponent = (SwingScilabMenuItem) updatedObject.getValue();
 972                         parent = (JComponent) updatedComponent.getParent();
 973                         switch (childAsTypedObject.getType()) {
 974                         case UiChildMenu:
 975                             /* Replace the item by a parent menu */
 976                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabMenuItem) updatedObject.getValue());
 977                             parent.remove((SwingScilabMenuItem) updatedObject.getValue());
 978                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
 979                             allObjects.put(id, newParent);
 980                             newParent.addChild(childId);
 981                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
 982                             /* Update the created menu */
 983                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabMenuItem) addedChild);
 984                             break;
 985                         case UiCheckedMenu:
 986                             /* Replace the item by a parent menu */
 987                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
 988                             parent.remove((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
 989                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
 990                             allObjects.put(id, newParent);
 991                             newParent.addChild(childId);
 992                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
 993                             /* Update the created menu */
 994                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabCheckBoxMenuItem) addedChild);
 995                             break;
 996                         default: /* UiParentMenu */
 997                             ((SwingScilabMenu) updatedObject.getValue()).add((SwingScilabMenu) addedChild);
 998                             break;
 999                         }
1000                         break;
1001                     case UiCheckedMenu:
1002                         updatedComponent = (SwingScilabCheckBoxMenuItem) updatedObject.getValue();
1003                         parent = (JComponent) updatedComponent.getParent();
1004                         switch (childAsTypedObject.getType()) {
1005                         case UiChildMenu:
1006                             /* Replace the item by a parent menu */
1007                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
1008                             parent.remove((SwingScilabCheckBoxMenuItem) allObjects.get(id).getValue());
1009                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
1010                             allObjects.put(id, newParent);
1011                             newParent.addChild(childId);
1012                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
1013                             /* Update the created menu */
1014                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1015                             break;
1016                         case UiCheckedMenu:
1017                             /* Replace the item by a parent menu */
1018                             updatedObjectPosition = parent.getComponentZOrder((SwingScilabCheckBoxMenuItem) updatedObject.getValue());
1019                             parent.remove((SwingScilabCheckBoxMenuItem) allObjects.get(id).getValue());
1020                             newParent = CreateObjectFromType(__GO_UIPARENTMENU__, id);
1021                             allObjects.put(id, newParent);
1022                             newParent.addChild(childId);
1023                             parent.add((SwingScilabMenu) newParent.getValue(), updatedObjectPosition);
1024                             /* Update the created menu */
1025                             ((SwingScilabMenu) newParent.getValue()).add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1026                             break;
1027                         default: /* UiParentMenu */
1028                             System.out.println("childAsTypedObject.getType() = UiParentMenu");
1029                             ((SwingScilabMenu) updatedObject.getValue()).add((SwingScilabMenu) allObjects.get(childId).getValue());
1030                             break;
1031                         }
1032                         break;
1033                     default: /* UiParentMenu */
1034                         SwingScilabMenu updatedMenu = (SwingScilabMenu) updatedObject.getValue();
1035                         updatedComponent = updatedMenu;
1036                         switch (childAsTypedObject.getType()) {
1037                         case UiChildMenu:
1038                             updatedMenu.add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1039                             break;
1040                         case UiCheckedMenu:
1041                             updatedMenu.add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1042                             break;
1043                         default: /* UiParentMenu */
1044                         /* Java can not add a JMenu in a JMenu */
1045                             /* We need to convert the child into a MenuItem */
1046                             TypedObject newMenu = CreateObjectFromType(__GO_UIMENU__, childId);
1047                             allObjects.put(childId, newMenu);
1048                             updatedMenu.add((SwingScilabMenuItem) newMenu.getValue());
1049                             break;
1050                         }
1051                         break;
1052                     }
1053                     needRevalidate = true;
1054                 }
1055             }
1056         }
1057         // Remove children which have been deleted
1058         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
1059         String[] oldChildren = updatedObject.getChildren().toArray(new String[updatedObject.getChildren().size()]);
1060         for (int childIndex = 0; childIndex < oldChildren.length; childIndex++) {
1061             String childId = oldChildren[childIndex];
1062             if (!newChildrenSet.contains(childId)) {
1063                 // Remove the child
1064                 updatedObject.removeChild(childId);
1065                 updatedComponent = (SwingScilabMenu) updatedObject.getValue();
1066
1067                 TypedObject childAsTypedObject = allObjects.get(childId);
1068                 Object removedMenu = childAsTypedObject.getValue();
1069
1070                 switch (childAsTypedObject.getType()) {
1071                 case UiChildMenu:
1072                     updatedComponent.remove((SwingScilabMenuItem) removedMenu);
1073                     break;
1074                 case UiCheckedMenu:
1075                     updatedComponent.remove((SwingScilabCheckBoxMenuItem) removedMenu);
1076                     break;
1077                 default:
1078                     updatedComponent.remove((SwingScilabMenu) removedMenu);
1079                     break;
1080                 }
1081                 needRevalidate = true;
1082             }
1083         }
1084         if (needRevalidate && updatedComponent != null) {
1085             updatedComponent.validate();
1086         }
1087     }
1088     /**
1089      * Update the children of a contextmenu (called by generic updateObject method)
1090      * @param id the id of the contextmenu object
1091      * @param newChildren the new children IDs list
1092      */
1093     private void updateContextMenuChildren(TypedObject updatedObject, String[] newChildren) {
1094         Container updatedComponent = null;
1095         boolean needRevalidate = false;
1096
1097         // Add new children
1098         for (String childId : newChildren) {
1099             int childType = (Integer) GraphicController.getController().getProperty(childId, __GO_TYPE__);
1100             if (childType == __GO_UIMENU__) {
1101                 if (!updatedObject.hasChild(childId)) {
1102
1103                     // Add the child
1104                     updatedObject.addChild(childId);
1105
1106                     TypedObject childAsTypedObject = allObjects.get(childId);
1107                     SwingScilabContextMenu updatedMenu = (SwingScilabContextMenu) updatedObject.getValue();
1108                     updatedComponent = updatedMenu;
1109                     switch (childAsTypedObject.getType()) {
1110                     case UiChildMenu:
1111                         updatedMenu.add((SwingScilabMenuItem) allObjects.get(childId).getValue());
1112                         break;
1113                     case UiCheckedMenu:
1114                         updatedMenu.add((SwingScilabCheckBoxMenuItem) allObjects.get(childId).getValue());
1115                         break;
1116                     default: /* UiParentMenu */
1117                         updatedMenu.add((SwingScilabMenu) allObjects.get(childId).getValue());
1118                         break;
1119                     }
1120                     needRevalidate = true;
1121                 }
1122             }
1123         }
1124         // Remove children which have been deleted
1125         Set<String> newChildrenSet = new HashSet<String>(Arrays.asList(newChildren));
1126         for (String childId : updatedObject.getChildren()) {
1127             if (!newChildrenSet.contains(childId)) {
1128                 // Remove the child
1129                 updatedObject.removeChild(childId);
1130                 updatedComponent = (SwingScilabMenu) updatedObject.getValue();
1131
1132                 TypedObject childAsTypedObject = allObjects.get(childId);
1133                 SwingScilabContextMenu updatedMenu = (SwingScilabContextMenu) updatedObject.getValue();
1134                 Object removedMenu = allObjects.get(childId).getValue();
1135
1136                 switch (childAsTypedObject.getType()) {
1137                 case UiChildMenu:
1138                     updatedMenu.remove((SwingScilabMenuItem) removedMenu);
1139                     break;
1140                 case UiCheckedMenu:
1141                     updatedMenu.remove((SwingScilabCheckBoxMenuItem) removedMenu);
1142                     break;
1143                 default:
1144                     updatedMenu.remove((SwingScilabMenu) removedMenu);
1145                     break;
1146                 }
1147                 needRevalidate = true;
1148             }
1149         }
1150         if (needRevalidate && updatedComponent != null) {
1151             updatedComponent.validate();
1152         }
1153     }
1154 }