scilab/modules/graphic_objects/src/java/org/scilab/modules/graphic_objects/xmlloader/XMLDomLoader.java

   1 package org.scilab.modules.graphic_objects.xmlloader;
   2
   3 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.*;
   4
   5 import java.awt.Color;
   6 import java.io.File;
   7 import java.util.HashMap;
   8 import java.util.StringTokenizer;
   9
  10 import javax.xml.parsers.DocumentBuilder;
  11 import javax.xml.parsers.DocumentBuilderFactory;
  12
  13 import org.scilab.modules.commons.CommonFileUtils;
  14 import org.scilab.modules.commons.gui.FindIconHelper;
  15 import org.scilab.modules.graphic_objects.ScilabNativeView;
  16 import org.scilab.modules.graphic_objects.builder.Builder;
  17 import org.scilab.modules.graphic_objects.console.Console;
  18 import org.scilab.modules.graphic_objects.figure.Figure;
  19 import org.scilab.modules.graphic_objects.figure.Figure.BarType;
  20 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
  21 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject;
  22 import org.scilab.modules.graphic_objects.uicontrol.Uicontrol;
  23 import org.scilab.modules.graphic_objects.uicontrol.frame.border.FrameBorderType;
  24 import org.scilab.modules.graphic_objects.utils.LayoutType;
  25 import org.w3c.dom.Document;
  26 import org.w3c.dom.NamedNodeMap;
  27 import org.w3c.dom.Node;
  28 import org.w3c.dom.NodeList;
  29
  30 public class XMLDomLoader {
  31
  32     private enum ModelType {
  33         BOOLEAN, BOOLEAN_ARRAY, DOUBLE, DOUBLE_ARRAY, STRING, STRING_ARRAY, INTEGER, INTEGER_ARRAY,
  34         ROTATIONTYPE, BARTYPE, LAYOUTTYPE, FILLTYPE, ANCHORTYPE, POSITIONTYPE;
  35     };
  36
  37     private static final int __NODE_SCILABGUI__     = -10;
  38     private static final int __NODE_OUT__           = -20;
  39     private static final int __NODE_IN__            = -30;
  40     private static final int __NODE_TITLE__         = -40;
  41     private static final int __NODE_STRING__        = -50;
  42     private static final int __NODE_STRINGITEM__    = -50;
  43     private static final int __NODE_COLORMAP__      = -60;
  44     private static final int __NODE_COLORMAPITEM__  = -70;
  45
  46     private static HashMap<String, Integer> nameToGO = new HashMap<String, Integer>();
  47
  48     private static HashMap<String, Pair<Integer, ModelType>> figPropToGO = new HashMap<String, Pair<Integer, ModelType>>();
  49     private static HashMap<String, Pair<Integer, ModelType>> UiPropToGO = new HashMap<String, Pair<Integer, ModelType>>();
  50     private static HashMap<String, Pair<Integer, ModelType>> MenuPropToGO = new HashMap<String, Pair<Integer, ModelType>>();
  51     private static HashMap<String, Pair<Integer, ModelType>> BorderPropToGO = new HashMap<String, Pair<Integer, ModelType>>();
  52
  53
  54     static {
  55         // init map to convert control name to id
  56         nameToGO.put("figure", __GO_FIGURE__);
  57         nameToGO.put("frame", __GO_UI_FRAME__);
  58         nameToGO.put("layer", __GO_UI_LAYER__);
  59         nameToGO.put("pushbutton", __GO_UI_PUSHBUTTON__);
  60         nameToGO.put("text", __GO_UI_TEXT__);
  61         nameToGO.put("checkbox", __GO_UI_CHECKBOX__);
  62         nameToGO.put("textfield", __GO_UI_EDIT__);
  63         nameToGO.put("spinner", __GO_UI_SPINNER__);
  64         nameToGO.put("edit", __GO_UI_EDIT__);
  65         nameToGO.put("image", __GO_UI_IMAGE__);
  66         nameToGO.put("picture", __GO_UI_IMAGE__);
  67         nameToGO.put("listbox", __GO_UI_LISTBOX__);
  68         nameToGO.put("popupmenu", __GO_UI_POPUPMENU__);
  69         nameToGO.put("radiobutton", __GO_UI_RADIOBUTTON__);
  70         nameToGO.put("slider", __GO_UI_SLIDER__);
  71         nameToGO.put("table", __GO_UI_TABLE__);
  72         nameToGO.put("tab", __GO_UI_TAB__);
  73
  74         nameToGO.put("menu", __GO_UIMENU__);
  75         nameToGO.put("contextmenu", __GO_UICONTEXTMENU__);
  76
  77         nameToGO.put("axes", __GO_AXES__);
  78
  79         nameToGO.put("border", __GO_UI_FRAME_BORDER__);
  80
  81         /* internal */
  82         nameToGO.put("out", __NODE_OUT__);
  83         nameToGO.put("in", __NODE_IN__);
  84         nameToGO.put("title", __NODE_TITLE__);
  85         nameToGO.put("string", __NODE_STRING__);
  86         nameToGO.put("stringitem", __NODE_STRINGITEM__);
  87         nameToGO.put("colormap", __NODE_COLORMAP__);
  88         nameToGO.put("colormapitem", __NODE_COLORMAPITEM__);
  89
  90         /* system */
  91         nameToGO.put("scilabgui", __NODE_SCILABGUI__);
  92
  93         //fill map of property -> {GO, ModelType}
  94
  95         //figure property list
  96         figPropToGO.put("figure_position", new Pair<Integer, ModelType>(__GO_POSITION__, ModelType.INTEGER_ARRAY));
  97         figPropToGO.put("figure_size", new Pair<Integer, ModelType>(__GO_SIZE__, ModelType.INTEGER_ARRAY));
  98         figPropToGO.put("axes_size", new Pair<Integer, ModelType>(__GO_AXES_SIZE__, ModelType.INTEGER_ARRAY));
  99         figPropToGO.put("auto_resize", new Pair<Integer, ModelType>(__GO_AUTORESIZE__, ModelType.BOOLEAN));
 100         figPropToGO.put("view_port", new Pair<Integer, ModelType>(__GO_VIEWPORT__, ModelType.INTEGER_ARRAY));
 101         figPropToGO.put("figure_name", new Pair<Integer, ModelType>(__GO_NAME__, ModelType.STRING));
 102         figPropToGO.put("figure_id", new Pair<Integer, ModelType>(__GO_ID__, ModelType.INTEGER));
 103         figPropToGO.put("info_message", new Pair<Integer, ModelType>(__GO_INFO_MESSAGE__, ModelType.STRING));
 104         figPropToGO.put("pixel_drawing_mode", new Pair<Integer, ModelType>(__GO_PIXEL_DRAWING_MODE__, ModelType.STRING));
 105         figPropToGO.put("anti_aliasing", new Pair<Integer, ModelType>(__GO_ANTIALIASING__, ModelType.BOOLEAN));
 106         figPropToGO.put("immediate_drawing", new Pair<Integer, ModelType>(__GO_IMMEDIATE_DRAWING__, ModelType.BOOLEAN));
 107         figPropToGO.put("background", new Pair<Integer, ModelType>(__GO_BACKGROUND__, ModelType.INTEGER));
 108         figPropToGO.put("visible", new Pair<Integer, ModelType>(__GO_VISIBLE__, ModelType.BOOLEAN));
 109         figPropToGO.put("rotation_style", new Pair<Integer, ModelType>(__GO_ROTATION_TYPE__, ModelType.ROTATIONTYPE));
 110         figPropToGO.put("event_handler", new Pair<Integer, ModelType>(__GO_EVENTHANDLER_NAME__, ModelType.STRING));
 111         figPropToGO.put("event_handler_enable", new Pair<Integer, ModelType>(__GO_EVENTHANDLER_ENABLE__, ModelType.BOOLEAN));
 112         figPropToGO.put("resizefcn", new Pair<Integer, ModelType>(__GO_RESIZEFCN__, ModelType.STRING));
 113         figPropToGO.put("closerequestfcn", new Pair<Integer, ModelType>(__GO_CLOSEREQUESTFCN__, ModelType.STRING));
 114         figPropToGO.put("resize", new Pair<Integer, ModelType>(__GO_RESIZE__, ModelType.BOOLEAN));
 115         figPropToGO.put("toolbar", new Pair<Integer, ModelType>(__GO_TOOLBAR__, ModelType.BARTYPE));
 116         figPropToGO.put("toolbar_visible", new Pair<Integer, ModelType>(__GO_TOOLBAR_VISIBLE__, ModelType.BOOLEAN));
 117         figPropToGO.put("menubar", new Pair<Integer, ModelType>(__GO_MENUBAR__, ModelType.BARTYPE));
 118         figPropToGO.put("menubar_visible", new Pair<Integer, ModelType>(__GO_MENUBAR_VISIBLE__, ModelType.BOOLEAN));
 119         figPropToGO.put("infobar_visible", new Pair<Integer, ModelType>(__GO_INFOBAR_VISIBLE__, ModelType.BOOLEAN));
 120         figPropToGO.put("dockable", new Pair<Integer, ModelType>(__GO_DOCKABLE__, ModelType.BOOLEAN));
 121         figPropToGO.put("layout", new Pair<Integer, ModelType>(__GO_LAYOUT__, ModelType.LAYOUTTYPE));
 122         figPropToGO.put("default_axes", new Pair<Integer, ModelType>(__GO_DEFAULT_AXES__, ModelType.BOOLEAN));
 123         figPropToGO.put("icon", new Pair<Integer, ModelType>(__GO_UI_ICON__, ModelType.STRING));
 124         figPropToGO.put("tag", new Pair<Integer, ModelType>(__GO_TAG__, ModelType.STRING));
 125         figPropToGO.put("grid_opt_grid", new Pair<Integer, ModelType>(__GO_GRID_OPT_GRID__, ModelType.INTEGER_ARRAY));
 126         figPropToGO.put("grid_opt_padding", new Pair<Integer, ModelType>(__GO_GRID_OPT_PADDING__, ModelType.INTEGER_ARRAY));
 127         figPropToGO.put("border_opt_padding", new Pair<Integer, ModelType>(__GO_BORDER_OPT_PADDING__, ModelType.INTEGER_ARRAY));
 128
 129         //uicontrol property list
 130         UiPropToGO.put("position", new Pair<Integer, ModelType>(__GO_POSITION__, ModelType.INTEGER));
 131         UiPropToGO.put("backgroundcolor", new Pair<Integer, ModelType>(__GO_UI_BACKGROUNDCOLOR__, ModelType.DOUBLE_ARRAY));
 132         UiPropToGO.put("enable", new Pair<Integer, ModelType>(__GO_UI_ENABLE__, ModelType.BOOLEAN));
 133         UiPropToGO.put("fontangle", new Pair<Integer, ModelType>(__GO_UI_FONTANGLE__, ModelType.STRING));
 134         UiPropToGO.put("fontname", new Pair<Integer, ModelType>(__GO_UI_FONTNAME__, ModelType.STRING));
 135         UiPropToGO.put("fontsize", new Pair<Integer, ModelType>(__GO_UI_FONTSIZE__, ModelType.DOUBLE));
 136         UiPropToGO.put("fontunits", new Pair<Integer, ModelType>(__GO_UI_FONTUNITS__, ModelType.STRING));
 137         UiPropToGO.put("fontweight", new Pair<Integer, ModelType>(__GO_UI_FONTWEIGHT__, ModelType.STRING));
 138         UiPropToGO.put("foregroundcolor", new Pair<Integer, ModelType>(__GO_UI_FOREGROUNDCOLOR__, ModelType.DOUBLE_ARRAY));
 139         UiPropToGO.put("horizontalalignment", new Pair<Integer, ModelType>(__GO_UI_HORIZONTALALIGNMENT__, ModelType.STRING));
 140         UiPropToGO.put("listboxtop", new Pair<Integer, ModelType>(__GO_UI_LISTBOXTOP__, ModelType.INTEGER_ARRAY));
 141         UiPropToGO.put("max", new Pair<Integer, ModelType>(__GO_UI_MAX__, ModelType.DOUBLE));
 142         UiPropToGO.put("min", new Pair<Integer, ModelType>(__GO_UI_MIN__, ModelType.DOUBLE));
 143         UiPropToGO.put("position", new Pair<Integer, ModelType>(__GO_POSITION__, ModelType.DOUBLE_ARRAY));
 144         UiPropToGO.put("relief", new Pair<Integer, ModelType>(__GO_UI_RELIEF__, ModelType.STRING));
 145         UiPropToGO.put("sliderstep", new Pair<Integer, ModelType>(__GO_UI_SLIDERSTEP__, ModelType.DOUBLE_ARRAY));
 146         UiPropToGO.put("units", new Pair<Integer, ModelType>(__GO_UI_UNITS__, ModelType.STRING));
 147         UiPropToGO.put("value", new Pair<Integer, ModelType>(__GO_UI_VALUE__, ModelType.DOUBLE_ARRAY));
 148         UiPropToGO.put("verticalalignment", new Pair<Integer, ModelType>(__GO_UI_VERTICALALIGNMENT__, ModelType.STRING));
 149         UiPropToGO.put("string", new Pair<Integer, ModelType>(__GO_UI_STRING__, ModelType.STRING_ARRAY));
 150         UiPropToGO.put("tooltipstring", new Pair<Integer, ModelType>(__GO_UI_TOOLTIPSTRING__, ModelType.STRING_ARRAY));
 151         UiPropToGO.put("visible", new Pair<Integer, ModelType>(__GO_VISIBLE__, ModelType.BOOLEAN));
 152         UiPropToGO.put("layout", new Pair<Integer, ModelType>(__GO_LAYOUT__, ModelType.LAYOUTTYPE));
 153         UiPropToGO.put("callback", new Pair<Integer, ModelType>(__GO_CALLBACK__, ModelType.STRING));
 154         UiPropToGO.put("callback_type", new Pair<Integer, ModelType>(__GO_CALLBACKTYPE__, ModelType.INTEGER));
 155         UiPropToGO.put("gridbaggrid", new Pair<Integer, ModelType>(__GO_UI_GRIDBAG_GRID__, ModelType.INTEGER_ARRAY));
 156         UiPropToGO.put("gridbagweight", new Pair<Integer, ModelType>(__GO_UI_GRIDBAG_WEIGHT__, ModelType.DOUBLE_ARRAY));
 157         UiPropToGO.put("gridbagfill", new Pair<Integer, ModelType>(__GO_UI_GRIDBAG_FILL__, ModelType.FILLTYPE));
 158         UiPropToGO.put("gridbaganchor", new Pair<Integer, ModelType>(__GO_UI_GRIDBAG_ANCHOR__, ModelType.ANCHORTYPE));
 159         UiPropToGO.put("gridbagpadding", new Pair<Integer, ModelType>(__GO_UI_GRIDBAG_PADDING__, ModelType.INTEGER_ARRAY));
 160         UiPropToGO.put("gridbagpreferredsize", new Pair<Integer, ModelType>(__GO_UI_GRIDBAG_PREFERREDSIZE__, ModelType.INTEGER_ARRAY));
 161         UiPropToGO.put("borderposition", new Pair<Integer, ModelType>(__GO_UI_BORDER_POSITION__, ModelType.POSITIONTYPE));
 162         UiPropToGO.put("borderpreferredsize", new Pair<Integer, ModelType>(__GO_UI_BORDER_PREFERREDSIZE__, ModelType.INTEGER_ARRAY));
 163         UiPropToGO.put("margins", new Pair<Integer, ModelType>(__GO_MARGINS__, ModelType.DOUBLE_ARRAY));
 164         UiPropToGO.put("groupname", new Pair<Integer, ModelType>(__GO_UI_GROUP_NAME__, ModelType.STRING));
 165         UiPropToGO.put("icon", new Pair<Integer, ModelType>(__GO_UI_ICON__, ModelType.STRING));
 166         UiPropToGO.put("scrollable", new Pair<Integer, ModelType>(__GO_UI_SCROLLABLE__, ModelType.BOOLEAN));
 167         UiPropToGO.put("gridoptgrid", new Pair<Integer, ModelType>(__GO_GRID_OPT_GRID__, ModelType.INTEGER_ARRAY));
 168         UiPropToGO.put("gridoptpadding", new Pair<Integer, ModelType>(__GO_GRID_OPT_PADDING__, ModelType.INTEGER_ARRAY));
 169         UiPropToGO.put("borderoptpadding", new Pair<Integer, ModelType>(__GO_BORDER_OPT_PADDING__, ModelType.INTEGER_ARRAY));
 170         UiPropToGO.put("tag", new Pair<Integer, ModelType>(__GO_TAG__, ModelType.STRING));
 171
 172         //border property list
 173         BorderPropToGO.put("style", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_STYLE__, ModelType.INTEGER));
 174         BorderPropToGO.put("type", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_TYPE__, ModelType.INTEGER));
 175         BorderPropToGO.put("position", new Pair<Integer, ModelType>(__GO_POSITION__, ModelType.DOUBLE_ARRAY));
 176         BorderPropToGO.put("hlout", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, ModelType.STRING));
 177         BorderPropToGO.put("hlin", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_HIGHLIGHT_IN__, ModelType.STRING));
 178         BorderPropToGO.put("shadowout", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_SHADOW_OUT__, ModelType.STRING));
 179         BorderPropToGO.put("shadowin", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_SHADOW_IN__, ModelType.STRING));
 180         BorderPropToGO.put("titleposition", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_POSITION__, ModelType.DOUBLE_ARRAY));
 181         BorderPropToGO.put("hl", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, ModelType.STRING));
 182         BorderPropToGO.put("shadow", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_SHADOW_OUT__, ModelType.STRING));
 183         BorderPropToGO.put("color", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_COLOR__, ModelType.STRING));
 184         BorderPropToGO.put("thickness", new Pair<Integer, ModelType>(__GO_LINE_THICKNESS__, ModelType.INTEGER));
 185         BorderPropToGO.put("rounded", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_ROUNDED__, ModelType.BOOLEAN));
 186         BorderPropToGO.put("title", new Pair<Integer, ModelType>(__GO_TITLE__, ModelType.STRING));
 187         BorderPropToGO.put("justification", new Pair<Integer, ModelType>(__GO_UI_FRAME_BORDER_JUSTIFICATION__, ModelType.INTEGER));
 188         BorderPropToGO.put("fontangle", new Pair<Integer, ModelType>(__GO_UI_FONTANGLE__, ModelType.STRING));
 189         BorderPropToGO.put("fontname", new Pair<Integer, ModelType>(__GO_UI_FONTNAME__, ModelType.STRING));
 190         BorderPropToGO.put("fontsize", new Pair<Integer, ModelType>(__GO_UI_FONTSIZE__, ModelType.INTEGER));
 191         BorderPropToGO.put("fontweight", new Pair<Integer, ModelType>(__GO_UI_FONTWEIGHT__, ModelType.STRING));
 192
 193         MenuPropToGO.put("enable", new Pair<Integer, ModelType>(__GO_UI_ENABLE__, ModelType.BOOLEAN));
 194         MenuPropToGO.put("foreground", new Pair<Integer, ModelType>(__GO_UI_FOREGROUNDCOLOR__, ModelType.DOUBLE_ARRAY));
 195         MenuPropToGO.put("label", new Pair<Integer, ModelType>(__GO_UI_LABEL__, ModelType.STRING));
 196         MenuPropToGO.put("hidden", new Pair<Integer, ModelType>(__GO_HIDDEN__, ModelType.BOOLEAN));
 197         MenuPropToGO.put("visible", new Pair<Integer, ModelType>(__GO_VISIBLE__, ModelType.BOOLEAN));
 198         MenuPropToGO.put("callback", new Pair<Integer, ModelType>(__GO_CALLBACK__, ModelType.STRING));
 199         MenuPropToGO.put("callback_type", new Pair<Integer, ModelType>(__GO_CALLBACKTYPE__, ModelType.INTEGER));
 200         MenuPropToGO.put("checked", new Pair<Integer, ModelType>(__GO_UI_CHECKED__, ModelType.BOOLEAN));
 201         MenuPropToGO.put("icon", new Pair<Integer, ModelType>(__GO_UI_ICON__, ModelType.STRING));
 202         MenuPropToGO.put("tag", new Pair<Integer, ModelType>(__GO_TAG__, ModelType.STRING));
 203     }
 204
 205     private String filename = "";
 206     private Integer figure = 0;
 207     private Boolean figVisible = true;
 208
 209     public XMLDomLoader(String filename) {
 210         this.filename = filename;
 211     }
 212
 213     public int parse() {
 214         return parse(filename);
 215     }
 216
 217     public int parse(String filename) {
 218         try {
 219             this.filename = filename;
 220             File f = new File(filename);
 221             String currentPath = "";
 222
 223             if (f.exists()) {
 224                 //add filename filepath in ScilabSwingUtilities paths
 225                 if (f.isAbsolute()) {
 226                     String filePath = f.getAbsolutePath();
 227                     currentPath = filePath.substring(0, filePath.lastIndexOf(File.separator));
 228                     FindIconHelper.addThemePath(currentPath);
 229                 } else {
 230                     String initialDirectoryPath = CommonFileUtils.getCWD();
 231                     String filePath = "";
 232                     Integer index = filename.lastIndexOf(File.separator);
 233                     if (index != -1) {
 234                         filePath = filename.substring(0, index);
 235                     }
 236
 237                     currentPath = initialDirectoryPath + File.separator + filePath;
 238                     FindIconHelper.addThemePath(currentPath);
 239
 240                     f = new File(currentPath + File.separator + filename);
 241                 }
 242             } else {
 243                 //try to find file in currentPath
 244                 if (f.isAbsolute()) {
 245                     //failed
 246                     return 1;
 247                 } else {
 248                     String initialDirectoryPath = CommonFileUtils.getCWD();
 249                     String filePath = "";
 250                     Integer index = filename.lastIndexOf(File.separator);
 251                     if (index != -1) {
 252                         filePath = filename.substring(0, index);
 253                     }
 254
 255                     currentPath = initialDirectoryPath + File.separator + filePath;
 256                 }
 257
 258                 f = new File(currentPath + File.separator + filename);
 259                 if (f.exists() == false) {
 260                     return 1;
 261                 }
 262             }
 263
 264             DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
 265             Document doc = dBuilder.parse(f);
 266             doc.getDocumentElement().normalize();
 267
 268             if (doc.hasChildNodes()) {
 269                 parseNode(0, doc.getChildNodes());
 270             }
 271         } catch (Exception e) {
 272             e.printStackTrace();
 273         }
 274
 275         //update visible property of main window
 276         GraphicController.getController().setProperty(figure, __GO_VISIBLE__, figVisible);
 277         return figure;
 278     }
 279
 280     private void parseNode(Integer parent, NodeList nodes) {
 281         for (int i = nodes.getLength() - 1 ; i >= 0;  i--) {
 282             Node childNode = nodes.item(i);
 283             Integer child = 0;
 284
 285             // make sure it's element node.
 286             if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 287                 // get node name and value
 288                 int nodeType = nameToGO.get(childNode.getNodeName());
 289                 switch (nodeType) {
 290                     case __GO_FIGURE__: {
 291                         child = createFigure(childNode);
 292                         figure = child;
 293                         break;
 294                     }
 295
 296                     case __GO_UI_CHECKBOX__:
 297                     case __GO_UI_EDIT__:
 298                     case __GO_UI_FRAME__:
 299                     case __GO_UI_IMAGE__:
 300                     case __GO_UI_LAYER__:
 301                     case __GO_UI_LISTBOX__:
 302                     case __GO_UI_POPUPMENU__:
 303                     case __GO_UI_PUSHBUTTON__:
 304                     case __GO_UI_RADIOBUTTON__:
 305                     case __GO_UI_SLIDER__:
 306                     case __GO_UI_TABLE__:
 307                     case __GO_UI_TAB__:
 308                     case __GO_UI_SPINNER__:
 309                     case __GO_UI_TEXT__: {
 310                         child = createUiControl(nodeType, parent, childNode);
 311                         break;
 312                     }
 313
 314                     case __GO_AXES__ : {
 315                         child = createAxes(parent, childNode);
 316                         break;
 317                     }
 318
 319                     case __GO_UI_FRAME_BORDER__: {
 320                         child = createBorder(childNode);
 321                         GraphicController.getController().setProperty(parent, __GO_UI_FRAME_BORDER__, child);
 322                         break;
 323                     }
 324
 325                     case __NODE_STRING__ : {
 326                         //avoid relationship
 327                         child = 0;
 328                         createString(parent, childNode);
 329                         break;
 330                     }
 331
 332                     case __NODE_COLORMAP__: {
 333                         //avoid relationship
 334                         child = 0;
 335                         createColorMap(parent, childNode);
 336                         break;
 337                     }
 338
 339                     case __NODE_SCILABGUI__ : {
 340                         //check version
 341                         Node nodeVersion = childNode.getAttributes().getNamedItem("version");
 342                         double version = Double.parseDouble(nodeVersion.getNodeValue());
 343                         if (version > 1.0) {
 344                             //call version manager ^^
 345                         }
 346
 347                         Integer console = Console.getConsole().getIdentifier();
 348                         //set usedeprecatedskin flag
 349                         setBooleanAttribute(console, __GO_USEDEPRECATEDLF__, childNode.getAttributes(), "usedeprecatedskin");
 350                         break;
 351                     }
 352
 353                     case __GO_UICONTEXTMENU__: {
 354                         break;
 355                     }
 356                     case __GO_UIMENU__: {
 357                         child = createUiMenu(parent, childNode);
 358                         break;
 359                     }
 360
 361
 362                     default: {
 363                         //ignore TITLED, IN, OUT, STRING_AARAY, COLORMAPITEM node
 364                         break;
 365                     }
 366                 }
 367
 368                 if (parent != 0 && child != 0) {
 369                     GraphicController.getController().setGraphicObjectRelationship(parent, child);
 370                 }
 371
 372                 if (childNode.hasChildNodes()) {
 373                     parseNode(child, childNode.getChildNodes());
 374                 }
 375
 376             }
 377         }
 378     }
 379
 380     private void createColorMap(Integer parent, Node node) {
 381         NamedNodeMap attr = node.getAttributes();
 382
 383         Node rowNode = attr.getNamedItem("size");
 384         if (rowNode == null) {
 385             return;
 386         }
 387
 388         Integer rows = Integer.parseInt(rowNode.getNodeValue());
 389
 390         if (node.hasChildNodes()) {
 391             Double[] colorMap = new Double[rows * 3];
 392             NodeList list = node.getChildNodes();
 393             int index = 0;
 394             for (int i = 0 ; i < list.getLength() ; i++) {
 395                 Node childNode = list.item(i);
 396                 if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 397                     attr = childNode.getAttributes();
 398                     Node valueNode = attr.getNamedItem("color");
 399                     if (valueNode == null) {
 400                         colorMap[index] = 0.0;
 401                         colorMap[index + rows] = 0.0;
 402                         colorMap[index + 2 * rows] = 0.0;
 403                     } else {
 404                         try {
 405                             Color c = Color.decode(valueNode.getNodeValue());
 406                             colorMap[index] = c.getRed() / 255.0;
 407                             colorMap[index + rows] = c.getGreen() / 255.0;
 408                             colorMap[index + 2 * rows] = c.getBlue() / 255.0;
 409                         } catch (NumberFormatException e) {
 410                             colorMap[index] = 0.0;
 411                             colorMap[index + rows] = 0.0;
 412                             colorMap[index + 2 * rows] = 0.0;
 413                         }
 414                     }
 415                     index++;
 416                 }
 417             }
 418
 419             GraphicController.getController().setProperty(parent, __GO_COLORMAP__, colorMap);
 420         }
 421     }
 422
 423     private void createString(Integer parent, Node node) {
 424         NamedNodeMap attr = node.getAttributes();
 425
 426         Node propertyNode = attr.getNamedItem("property");
 427         if (propertyNode == null) {
 428             return;
 429         }
 430
 431         String property = propertyNode.getNodeValue();
 432
 433         Node rowNode = attr.getNamedItem("rows");
 434         if (rowNode == null) {
 435             return;
 436         }
 437
 438         Integer rows = Integer.parseInt(rowNode.getNodeValue());
 439
 440         Node colNode = attr.getNamedItem("cols");
 441         if (colNode == null) {
 442             return;
 443         }
 444
 445         Integer cols = Integer.parseInt(colNode.getNodeValue());
 446
 447
 448         if (node.hasChildNodes()) {
 449             String[] str = new String[rows * cols];
 450             NodeList list = node.getChildNodes();
 451             int index = 0;
 452             for (int i = 0 ; i < list.getLength() ; i++) {
 453                 Node childNode = list.item(i);
 454                 if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 455                     attr = childNode.getAttributes();
 456                     Node valueNode = attr.getNamedItem("value");
 457                     if (valueNode == null) {
 458                         str[index++] = "";
 459                     } else {
 460                         str[index++] = valueNode.getNodeValue();
 461                     }
 462                 }
 463             }
 464
 465             Integer propId = UiPropToGO.get(property).getFirst();
 466
 467             if (propId == __GO_UI_STRING__ && cols > 1) {
 468                 GraphicController.getController().setProperty(parent, __GO_UI_STRING_COLNB__, cols);
 469             }
 470             GraphicController.getController().setProperty(parent, propId, str);
 471         }
 472     }
 473
 474     private Integer createAxes(Integer parent, Node node) {
 475         GraphicController controller = GraphicController.getController();
 476         Integer axes = Builder.createSubWin(parent);
 477
 478         NamedNodeMap attr = node.getAttributes();
 479         Node tagNode = attr.getNamedItem("tag");
 480         if (tagNode != null) {
 481             controller.setProperty(axes, __GO_TAG__, tagNode.getNodeValue());
 482             attr.removeNamedItem("tag");
 483         }
 484
 485         return axes;
 486     }
 487
 488     private Integer createBorder(Node node) {
 489         GraphicController controller = GraphicController.getController();
 490         Integer uib = controller.askObject(GraphicObject.getTypeFromName(__GO_UI_FRAME_BORDER__));
 491
 492         NamedNodeMap attr = node.getAttributes();
 493
 494         Node styleNode = attr.getNamedItem("style");
 495         if (styleNode != null) {
 496             Integer style = FrameBorderType.stringToEnum(styleNode.getNodeValue()).ordinal();
 497             controller.setProperty(uib, __GO_UI_FRAME_BORDER_STYLE__, style);
 498             attr.removeNamedItem("style");
 499         }
 500
 501         //frame borders are always hidden
 502         controller.setProperty(uib,  __GO_HIDDEN__, true);
 503
 504         for (int i = 0 ; i < attr.getLength() ; i++) {
 505             Node prop = attr.item(i);
 506             Pair<Integer, ModelType> pair = BorderPropToGO.get(prop.getNodeName());
 507
 508             ModelType modelType = pair.getSecond();
 509             switch (modelType) {
 510                 case BOOLEAN:
 511                     controller.setProperty(uib, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 512                     break;
 513                 case BOOLEAN_ARRAY :
 514                     controller.setProperty(uib, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 515                     break;
 516                 case DOUBLE:
 517                     controller.setProperty(uib, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 518                     break;
 519                 case DOUBLE_ARRAY:
 520                     controller.setProperty(uib, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 521                     break;
 522                 case INTEGER:
 523                     controller.setProperty(uib, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 524                     break;
 525                 case INTEGER_ARRAY:
 526                     controller.setProperty(uib, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 527                     break;
 528                 case STRING:
 529                     controller.setProperty(uib, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 530                     break;
 531                 case STRING_ARRAY:
 532                     controller.setProperty(uib, pair.getFirst(), getAttributeAsStringArray(prop.getNodeValue()));
 533                     break;
 534                 default:
 535                     System.out.println("missing type");
 536                     break;
 537             }
 538         }
 539
 540         //manage children here to avoid trouble on draw without children in SwingView
 541         if (node.hasChildNodes()) {
 542             NodeList list = node.getChildNodes();
 543             for (int i = 0 ; i < list.getLength() ; i++) {
 544                 Node childNode = list.item(i);
 545                 if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 546                     Integer child = createBorder(childNode);
 547                     String nodeName = childNode.getNodeName();
 548                     if (nodeName.equals("title")) {
 549                         GraphicController.getController().setProperty(uib, __GO_UI_FRAME_BORDER_TITLE__, child);
 550                         GraphicController.getController().setGraphicObjectRelationship(uib, child);
 551                     } else if (nodeName.equals("out")) {
 552                         GraphicController.getController().setProperty(uib, __GO_UI_FRAME_BORDER_OUT_BORDER__, child);
 553                         GraphicController.getController().setGraphicObjectRelationship(uib, child);
 554                     } else if (nodeName.equals("in")) {
 555                         GraphicController.getController().setProperty(uib, __GO_UI_FRAME_BORDER_IN_BORDER__, child);
 556                         GraphicController.getController().setGraphicObjectRelationship(uib, child);
 557                     }
 558                 }
 559             }
 560         }
 561         return uib;
 562     }
 563
 564     private Integer createFigure(Node node) {
 565         GraphicController controller = GraphicController.getController();
 566         Boolean dockable = true;
 567         Integer menubar = 1;
 568         Integer toolbar = 1;
 569         Boolean default_axes = true;
 570         double[] figureSize = null;
 571         double[] axesSize = null;
 572         boolean menubarVisisble = true;
 573         boolean toolbarVisisble = true;
 574         boolean infobarVisisble = true;
 575
 576         NamedNodeMap attr = node.getAttributes();
 577         //dockable
 578         Node tempnode = attr.getNamedItem("dockable");
 579         if (tempnode != null) {
 580             dockable = getAttributeAsBoolean(tempnode.getNodeValue());
 581             attr.removeNamedItem("dockable");
 582         }
 583         //menubar
 584         tempnode = attr.getNamedItem("menubar");
 585         if (tempnode != null) {
 586             menubar = Figure.BarType.stringToEnum(getAttributeAsString(tempnode.getNodeValue())).ordinal();
 587             attr.removeNamedItem("menubar");
 588         }
 589         //toolbar
 590         tempnode = attr.getNamedItem("toolbar");
 591         if (tempnode != null) {
 592             toolbar = Figure.BarType.stringToEnum(getAttributeAsString(tempnode.getNodeValue())).ordinal();
 593             attr.removeNamedItem("toolbar");
 594         }
 595         //default_axes
 596         tempnode = attr.getNamedItem("default_axes");
 597         if (tempnode != null) {
 598             default_axes = getAttributeAsBoolean(tempnode.getNodeValue());
 599             attr.removeNamedItem("default_axes");
 600         }
 601         //visible
 602         tempnode = attr.getNamedItem("visible");
 603         if (tempnode != null) {
 604             figVisible = getAttributeAsBoolean(tempnode.getNodeValue());
 605             attr.removeNamedItem("visible");
 606         }
 607
 608         //axesSize
 609         tempnode = attr.getNamedItem("axes_size");
 610         if (tempnode != null) {
 611             Double[] size = getAttributeAsDoubleArray(tempnode.getNodeValue());
 612             axesSize = new double[] {size[0], size[1]};
 613             attr.removeNamedItem("axes_size");
 614         }
 615
 616         //figureSize
 617         tempnode = attr.getNamedItem("figure_size");
 618         if (axesSize == null && tempnode != null) {
 619             Double[] size = getAttributeAsDoubleArray(tempnode.getNodeValue());
 620             figureSize = new double[] {size[0], size[1]};
 621             attr.removeNamedItem("figure_size");
 622         }
 623
 624         //menubar
 625         tempnode = attr.getNamedItem("menubar_visible");
 626         if (tempnode != null) {
 627             menubarVisisble = getAttributeAsBoolean(tempnode.getNodeValue());
 628             attr.removeNamedItem("menubar_visible");
 629         }
 630         //toolbar
 631         tempnode = attr.getNamedItem("toolbar_visible");
 632         if (tempnode != null) {
 633             toolbarVisisble = getAttributeAsBoolean(tempnode.getNodeValue());
 634             attr.removeNamedItem("toolbar_visible");
 635         }
 636         //infobar
 637         tempnode = attr.getNamedItem("infobar_visible");
 638         if (tempnode != null) {
 639             infobarVisisble = getAttributeAsBoolean(tempnode.getNodeValue());
 640             attr.removeNamedItem("infobar_visible");
 641         }
 642
 643         Integer fig = Builder.createFigure(dockable, menubar, toolbar, default_axes, false, figureSize, axesSize, null, menubarVisisble, toolbarVisisble, infobarVisisble);
 644         //set new id
 645         int newId = ScilabNativeView.ScilabNativeView__getValidDefaultFigureId();
 646
 647         controller.setProperty(fig,  __GO_ID__, newId);
 648         for (int i = 0 ; i < attr.getLength() ; i++) {
 649             Node prop = attr.item(i);
 650             Pair<Integer, ModelType> pair = figPropToGO.get(prop.getNodeName());
 651
 652             ModelType type = pair.getSecond();
 653             switch (type) {
 654                 case BOOLEAN:
 655                     controller.setProperty(fig, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 656                     break;
 657                 case BOOLEAN_ARRAY:
 658                     controller.setProperty(fig, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 659                     break;
 660                 case DOUBLE:
 661                     controller.setProperty(fig, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 662                     break;
 663                 case DOUBLE_ARRAY:
 664                     controller.setProperty(fig, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 665                     break;
 666                 case INTEGER:
 667                     controller.setProperty(fig, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 668                     break;
 669                 case INTEGER_ARRAY:
 670                     controller.setProperty(fig, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 671                     break;
 672                 case STRING:
 673                     controller.setProperty(fig, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 674                     break;
 675                 case STRING_ARRAY:
 676                     controller.setProperty(fig, pair.getFirst(), getAttributeAsStringArray(prop.getNodeValue()));
 677                     break;
 678                 case ROTATIONTYPE :
 679                     controller.setProperty(fig, pair.getFirst(), Figure.RotationType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 680                     break;
 681                 case BARTYPE :
 682                     controller.setProperty(fig, pair.getFirst(), Figure.BarType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 683                     break;
 684                 case LAYOUTTYPE :
 685                     controller.setProperty(fig, pair.getFirst(), LayoutType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 686                     break;
 687                 default:
 688                     System.out.println("missing type");
 689                     break;
 690             }
 691         }
 692
 693         return fig;
 694     }
 695
 696     private Integer createUiControl(Integer type, Integer parent, Node node) {
 697         GraphicController controller = GraphicController.getController();
 698         NamedNodeMap attr = node.getAttributes();
 699
 700         /*for frame we have to take care of scrollable property*/
 701         if (type == __GO_UI_FRAME__) {
 702             Node item = attr.getNamedItem("scrollable");
 703             if (item != null && item.getNodeValue().equals("on")) {
 704                 type = __GO_UI_FRAME_SCROLLABLE__;
 705             }
 706         }
 707
 708         Integer uic = GraphicController.getController().askObject(GraphicObject.getTypeFromName(type));
 709         controller.setProperty(uic, __GO_VISIBLE__, true);
 710
 711         for (int i = 0 ; i < attr.getLength() ; i++) {
 712             Node prop = attr.item(i);
 713             Pair<Integer, ModelType> pair = UiPropToGO.get(prop.getNodeName());
 714
 715             ModelType modelType = pair.getSecond();
 716             switch (modelType) {
 717                 case BOOLEAN:
 718                     controller.setProperty(uic, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 719                     break;
 720                 case BOOLEAN_ARRAY :
 721                     controller.setProperty(uic, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 722                     break;
 723                 case DOUBLE:
 724                     controller.setProperty(uic, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 725                     break;
 726                 case DOUBLE_ARRAY:
 727                     controller.setProperty(uic, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 728                     break;
 729                 case INTEGER:
 730                     controller.setProperty(uic, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 731                     break;
 732                 case INTEGER_ARRAY:
 733                     controller.setProperty(uic, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 734                     break;
 735                 case STRING:
 736                     controller.setProperty(uic, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 737                     break;
 738                 case STRING_ARRAY:
 739                     //nothing to do, manage as node instead of attributes
 740                     break;
 741                 case LAYOUTTYPE :
 742                     controller.setProperty(uic, pair.getFirst(), LayoutType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 743                     break;
 744                 case FILLTYPE :
 745                     controller.setProperty(uic, pair.getFirst(), Uicontrol.FillType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 746                     break;
 747                 case ANCHORTYPE :
 748                     controller.setProperty(uic, pair.getFirst(), Uicontrol.AnchorType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 749                     break;
 750                 case POSITIONTYPE :
 751                     controller.setProperty(uic, pair.getFirst(), Uicontrol.BorderLayoutType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 752                     break;
 753                 default:
 754                     System.out.println("missing type");
 755                     break;
 756             }
 757         }
 758
 759         return uic;
 760     }
 761
 762     private Integer createUiMenu(Integer parent, Node node) {
 763         GraphicController controller = GraphicController.getController();
 764         NamedNodeMap attr = node.getAttributes();
 765
 766         Integer uim = GraphicController.getController().askObject(GraphicObject.getTypeFromName(__GO_UIMENU__));
 767         controller.setProperty(uim, __GO_VISIBLE__, true);
 768
 769         for (int i = 0 ; i < attr.getLength() ; i++) {
 770             Node prop = attr.item(i);
 771             Pair<Integer, ModelType> pair = MenuPropToGO.get(prop.getNodeName());
 772             ModelType modelType = pair.getSecond();
 773             switch (modelType) {
 774                 case BOOLEAN:
 775                     controller.setProperty(uim, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 776                     break;
 777                 case BOOLEAN_ARRAY :
 778                     controller.setProperty(uim, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 779                     break;
 780                 case DOUBLE:
 781                     controller.setProperty(uim, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 782                     break;
 783                 case DOUBLE_ARRAY:
 784                     controller.setProperty(uim, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 785                     break;
 786                 case INTEGER:
 787                     controller.setProperty(uim, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 788                     break;
 789                 case INTEGER_ARRAY:
 790                     controller.setProperty(uim, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 791                     break;
 792                 case STRING:
 793                     controller.setProperty(uim, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 794                     break;
 795                 case STRING_ARRAY:
 796                     controller.setProperty(uim, pair.getFirst(), getAttributeAsStringArray(prop.getNodeValue()));
 797                     break;
 798                 default:
 799                     System.out.println("missing type");
 800                     break;
 801             }
 802         }
 803
 804         return uim;
 805     }
 806
 807     private Boolean getAttributeAsBoolean(String val) {
 808         if (val == null) {
 809             return null;
 810         }
 811
 812         if (val.equals("on")) {
 813             return true;
 814         }
 815
 816         if (val.equals("off")) {
 817             return false;
 818         }
 819
 820         return false;
 821     }
 822
 823     private void setBooleanAttribute(Integer id, int property, NamedNodeMap attributes, String attr) {
 824         Node node = attributes.getNamedItem(attr);
 825         if (node != null) {
 826             Boolean b = getAttributeAsBoolean(node.getNodeValue());
 827             if (b != null) {
 828                 GraphicController.getController().setProperty(id, property, b);
 829             }
 830         }
 831     }
 832
 833     private Double getAttributeAsDouble(String val) {
 834         if (val == null) {
 835             return null;
 836         }
 837
 838         return Double.parseDouble(val);
 839     }
 840
 841     private Integer getAttributeAsInteger(String val) {
 842         if (val == null) {
 843             return null;
 844         }
 845
 846         return Integer.parseInt(val);
 847     }
 848
 849     private String getAttributeAsString(String val) {
 850         return val;
 851     }
 852
 853     private Boolean[] getAttributeAsBooleanArray(String val) {
 854
 855         if (val == null) {
 856             return new Boolean[] {};
 857         }
 858
 859         StringTokenizer token = new StringTokenizer(val, ",");
 860
 861         Boolean[] b = new Boolean[token.countTokens()];
 862         int i = 0;
 863         while (token.hasMoreElements()) {
 864             String s = token.nextToken();
 865             if (s.equals("on")) {
 866                 b[i++] = true;
 867             } else {
 868                 b[i++] = false;
 869             }
 870         }
 871
 872         return b;
 873     }
 874
 875     private Double[] getAttributeAsDoubleArray(String val) {
 876
 877         if (val == null) {
 878             return new Double[] {};
 879         }
 880
 881         StringTokenizer token = new StringTokenizer(val, ",");
 882
 883         Double[] d = new Double[token.countTokens()];
 884         int i = 0;
 885         while (token.hasMoreElements()) {
 886             String s = token.nextToken();
 887             d[i++] = Double.parseDouble(s);
 888         }
 889
 890         return d;
 891     }
 892
 893     private Integer[] getAttributeAsIntegerArray(String val) {
 894
 895         if (val == null) {
 896             return new Integer[] {};
 897         }
 898
 899         StringTokenizer token = new StringTokenizer(val, ",");
 900
 901         Integer[] integer = new Integer[token.countTokens()];
 902         int i = 0;
 903         while (token.hasMoreElements()) {
 904             String s = token.nextToken();
 905             integer[i++] = Integer.parseInt(s);
 906         }
 907
 908         return integer;
 909     }
 910
 911     private String[] getAttributeAsStringArray(String val) {
 912
 913         if (val == null) {
 914             return null;
 915         }
 916
 917         StringTokenizer token = new StringTokenizer(val, ",");
 918
 919         String[] s = new String[token.countTokens()];
 920         int i = 0;
 921         while (token.hasMoreElements()) {
 922             s[i++] = token.nextToken();
 923         }
 924
 925         return s;
 926     }
 927 }