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                     FindIconHelper.addThemePath(initialDirectoryPath);
 240
 241                     f = new File(initialDirectoryPath, filename);
 242                 }
 243             } else {
 244                 //try to find file in currentPath
 245                 if (f.isAbsolute()) {
 246                     //failed
 247                     return 1;
 248                 } else {
 249                     String initialDirectoryPath = CommonFileUtils.getCWD();
 250                     String filePath = "";
 251                     Integer index = filename.lastIndexOf(File.separator);
 252                     if (index != -1) {
 253                         filePath = filename.substring(0, index);
 254                     }
 255
 256                     currentPath = initialDirectoryPath + File.separator + filePath;
 257                 }
 258
 259                 f = new File(currentPath + File.separator + filename);
 260                 if (f.exists() == false) {
 261                     return 1;
 262                 }
 263             }
 264
 265             DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
 266             Document doc = dBuilder.parse(f);
 267             doc.getDocumentElement().normalize();
 268
 269             if (doc.hasChildNodes()) {
 270                 parseNode(0, doc.getChildNodes());
 271             }
 272         } catch (Exception e) {
 273             e.printStackTrace();
 274         }
 275
 276         //update visible property of main window
 277         GraphicController.getController().setProperty(figure, __GO_VISIBLE__, figVisible);
 278         return figure;
 279     }
 280
 281     private void parseNode(Integer parent, NodeList nodes) {
 282         for (int i = nodes.getLength() - 1 ; i >= 0;  i--) {
 283             Node childNode = nodes.item(i);
 284             Integer child = 0;
 285
 286             // make sure it's element node.
 287             if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 288                 // get node name and value
 289                 int nodeType = nameToGO.get(childNode.getNodeName());
 290                 switch (nodeType) {
 291                     case __GO_FIGURE__: {
 292                         child = createFigure(childNode);
 293                         figure = child;
 294                         break;
 295                     }
 296
 297                     case __GO_UI_CHECKBOX__:
 298                     case __GO_UI_EDIT__:
 299                     case __GO_UI_FRAME__:
 300                     case __GO_UI_IMAGE__:
 301                     case __GO_UI_LAYER__:
 302                     case __GO_UI_LISTBOX__:
 303                     case __GO_UI_POPUPMENU__:
 304                     case __GO_UI_PUSHBUTTON__:
 305                     case __GO_UI_RADIOBUTTON__:
 306                     case __GO_UI_SLIDER__:
 307                     case __GO_UI_TABLE__:
 308                     case __GO_UI_TAB__:
 309                     case __GO_UI_SPINNER__:
 310                     case __GO_UI_TEXT__: {
 311                         child = createUiControl(nodeType, parent, childNode);
 312                         break;
 313                     }
 314
 315                     case __GO_AXES__ : {
 316                         child = createAxes(parent, childNode);
 317                         break;
 318                     }
 319
 320                     case __GO_UI_FRAME_BORDER__: {
 321                         child = createBorder(childNode);
 322                         GraphicController.getController().setProperty(parent, __GO_UI_FRAME_BORDER__, child);
 323                         break;
 324                     }
 325
 326                     case __NODE_STRING__ : {
 327                         //avoid relationship
 328                         child = 0;
 329                         createString(parent, childNode);
 330                         break;
 331                     }
 332
 333                     case __NODE_COLORMAP__: {
 334                         //avoid relationship
 335                         child = 0;
 336                         createColorMap(parent, childNode);
 337                         break;
 338                     }
 339
 340                     case __NODE_SCILABGUI__ : {
 341                         //check version
 342                         Node nodeVersion = childNode.getAttributes().getNamedItem("version");
 343                         double version = Double.parseDouble(nodeVersion.getNodeValue());
 344                         if (version > 1.0) {
 345                             //call version manager ^^
 346                         }
 347
 348                         Integer console = Console.getConsole().getIdentifier();
 349                         //set usedeprecatedskin flag
 350                         setBooleanAttribute(console, __GO_USEDEPRECATEDLF__, childNode.getAttributes(), "usedeprecatedskin");
 351                         break;
 352                     }
 353
 354                     case __GO_UICONTEXTMENU__: {
 355                         break;
 356                     }
 357                     case __GO_UIMENU__: {
 358                         child = createUiMenu(parent, childNode);
 359                         break;
 360                     }
 361
 362
 363                     default: {
 364                         //ignore TITLED, IN, OUT, STRING_AARAY, COLORMAPITEM node
 365                         break;
 366                     }
 367                 }
 368
 369                 if (parent != 0 && child != 0) {
 370                     GraphicController.getController().setGraphicObjectRelationship(parent, child);
 371                 }
 372
 373                 if (childNode.hasChildNodes()) {
 374                     parseNode(child, childNode.getChildNodes());
 375                 }
 376
 377             }
 378         }
 379     }
 380
 381     private void createColorMap(Integer parent, Node node) {
 382         NamedNodeMap attr = node.getAttributes();
 383
 384         Node rowNode = attr.getNamedItem("size");
 385         if (rowNode == null) {
 386             return;
 387         }
 388
 389         Integer rows = Integer.parseInt(rowNode.getNodeValue());
 390
 391         if (node.hasChildNodes()) {
 392             Double[] colorMap = new Double[rows * 3];
 393             NodeList list = node.getChildNodes();
 394             int index = 0;
 395             for (int i = 0 ; i < list.getLength() ; i++) {
 396                 Node childNode = list.item(i);
 397                 if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 398                     attr = childNode.getAttributes();
 399                     Node valueNode = attr.getNamedItem("color");
 400                     if (valueNode == null) {
 401                         colorMap[index] = 0.0;
 402                         colorMap[index + rows] = 0.0;
 403                         colorMap[index + 2 * rows] = 0.0;
 404                     } else {
 405                         try {
 406                             Color c = Color.decode(valueNode.getNodeValue());
 407                             colorMap[index] = c.getRed() / 255.0;
 408                             colorMap[index + rows] = c.getGreen() / 255.0;
 409                             colorMap[index + 2 * rows] = c.getBlue() / 255.0;
 410                         } catch (NumberFormatException e) {
 411                             colorMap[index] = 0.0;
 412                             colorMap[index + rows] = 0.0;
 413                             colorMap[index + 2 * rows] = 0.0;
 414                         }
 415                     }
 416                     index++;
 417                 }
 418             }
 419
 420             GraphicController.getController().setProperty(parent, __GO_COLORMAP__, colorMap);
 421         }
 422     }
 423
 424     private void createString(Integer parent, Node node) {
 425         NamedNodeMap attr = node.getAttributes();
 426
 427         Node propertyNode = attr.getNamedItem("property");
 428         if (propertyNode == null) {
 429             return;
 430         }
 431
 432         String property = propertyNode.getNodeValue();
 433
 434         Node rowNode = attr.getNamedItem("rows");
 435         if (rowNode == null) {
 436             return;
 437         }
 438
 439         Integer rows = Integer.parseInt(rowNode.getNodeValue());
 440
 441         Node colNode = attr.getNamedItem("cols");
 442         if (colNode == null) {
 443             return;
 444         }
 445
 446         Integer cols = Integer.parseInt(colNode.getNodeValue());
 447
 448
 449         if (node.hasChildNodes()) {
 450             String[] str = new String[rows * cols];
 451             NodeList list = node.getChildNodes();
 452             int index = 0;
 453             for (int i = 0 ; i < list.getLength() ; i++) {
 454                 Node childNode = list.item(i);
 455                 if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 456                     attr = childNode.getAttributes();
 457                     Node valueNode = attr.getNamedItem("value");
 458                     if (valueNode == null) {
 459                         str[index++] = "";
 460                     } else {
 461                         str[index++] = valueNode.getNodeValue();
 462                     }
 463                 }
 464             }
 465
 466             Integer propId = UiPropToGO.get(property).getFirst();
 467
 468             if (propId == __GO_UI_STRING__ && cols > 1) {
 469                 GraphicController.getController().setProperty(parent, __GO_UI_STRING_COLNB__, cols);
 470             }
 471             GraphicController.getController().setProperty(parent, propId, str);
 472         }
 473     }
 474
 475     private Integer createAxes(Integer parent, Node node) {
 476         GraphicController controller = GraphicController.getController();
 477         Integer axes = Builder.createSubWin(parent);
 478
 479         NamedNodeMap attr = node.getAttributes();
 480         Node tagNode = attr.getNamedItem("tag");
 481         if (tagNode != null) {
 482             controller.setProperty(axes, __GO_TAG__, tagNode.getNodeValue());
 483             attr.removeNamedItem("tag");
 484         }
 485
 486         return axes;
 487     }
 488
 489     private Integer createBorder(Node node) {
 490         GraphicController controller = GraphicController.getController();
 491         Integer uib = controller.askObject(GraphicObject.getTypeFromName(__GO_UI_FRAME_BORDER__));
 492
 493         NamedNodeMap attr = node.getAttributes();
 494
 495         Node styleNode = attr.getNamedItem("style");
 496         if (styleNode != null) {
 497             Integer style = FrameBorderType.stringToEnum(styleNode.getNodeValue()).ordinal();
 498             controller.setProperty(uib, __GO_UI_FRAME_BORDER_STYLE__, style);
 499             attr.removeNamedItem("style");
 500         }
 501
 502         //frame borders are always hidden
 503         controller.setProperty(uib,  __GO_HIDDEN__, true);
 504
 505         for (int i = 0 ; i < attr.getLength() ; i++) {
 506             Node prop = attr.item(i);
 507             Pair<Integer, ModelType> pair = BorderPropToGO.get(prop.getNodeName());
 508
 509             ModelType modelType = pair.getSecond();
 510             switch (modelType) {
 511                 case BOOLEAN:
 512                     controller.setProperty(uib, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 513                     break;
 514                 case BOOLEAN_ARRAY :
 515                     controller.setProperty(uib, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 516                     break;
 517                 case DOUBLE:
 518                     controller.setProperty(uib, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 519                     break;
 520                 case DOUBLE_ARRAY:
 521                     controller.setProperty(uib, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 522                     break;
 523                 case INTEGER:
 524                     controller.setProperty(uib, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 525                     break;
 526                 case INTEGER_ARRAY:
 527                     controller.setProperty(uib, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 528                     break;
 529                 case STRING:
 530                     controller.setProperty(uib, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 531                     break;
 532                 case STRING_ARRAY:
 533                     controller.setProperty(uib, pair.getFirst(), getAttributeAsStringArray(prop.getNodeValue()));
 534                     break;
 535                 default:
 536                     System.out.println("missing type");
 537                     break;
 538             }
 539         }
 540
 541         //manage children here to avoid trouble on draw without children in SwingView
 542         if (node.hasChildNodes()) {
 543             NodeList list = node.getChildNodes();
 544             for (int i = 0 ; i < list.getLength() ; i++) {
 545                 Node childNode = list.item(i);
 546                 if (childNode.getNodeType() == Node.ELEMENT_NODE) {
 547                     Integer child = createBorder(childNode);
 548                     String nodeName = childNode.getNodeName();
 549                     if (nodeName.equals("title")) {
 550                         GraphicController.getController().setProperty(uib, __GO_UI_FRAME_BORDER_TITLE__, child);
 551                         GraphicController.getController().setGraphicObjectRelationship(uib, child);
 552                     } else if (nodeName.equals("out")) {
 553                         GraphicController.getController().setProperty(uib, __GO_UI_FRAME_BORDER_OUT_BORDER__, child);
 554                         GraphicController.getController().setGraphicObjectRelationship(uib, child);
 555                     } else if (nodeName.equals("in")) {
 556                         GraphicController.getController().setProperty(uib, __GO_UI_FRAME_BORDER_IN_BORDER__, child);
 557                         GraphicController.getController().setGraphicObjectRelationship(uib, child);
 558                     }
 559                 }
 560             }
 561         }
 562         return uib;
 563     }
 564
 565     private Integer createFigure(Node node) {
 566         GraphicController controller = GraphicController.getController();
 567         Boolean dockable = true;
 568         Integer menubar = 1;
 569         Integer toolbar = 1;
 570         Boolean default_axes = true;
 571         double[] figureSize = null;
 572         double[] axesSize = null;
 573         boolean menubarVisisble = true;
 574         boolean toolbarVisisble = true;
 575         boolean infobarVisisble = true;
 576
 577         NamedNodeMap attr = node.getAttributes();
 578         //dockable
 579         Node tempnode = attr.getNamedItem("dockable");
 580         if (tempnode != null) {
 581             dockable = getAttributeAsBoolean(tempnode.getNodeValue());
 582             attr.removeNamedItem("dockable");
 583         }
 584         //menubar
 585         tempnode = attr.getNamedItem("menubar");
 586         if (tempnode != null) {
 587             menubar = Figure.BarType.stringToEnum(getAttributeAsString(tempnode.getNodeValue())).ordinal();
 588             attr.removeNamedItem("menubar");
 589         }
 590         //toolbar
 591         tempnode = attr.getNamedItem("toolbar");
 592         if (tempnode != null) {
 593             toolbar = Figure.BarType.stringToEnum(getAttributeAsString(tempnode.getNodeValue())).ordinal();
 594             attr.removeNamedItem("toolbar");
 595         }
 596         //default_axes
 597         tempnode = attr.getNamedItem("default_axes");
 598         if (tempnode != null) {
 599             default_axes = getAttributeAsBoolean(tempnode.getNodeValue());
 600             attr.removeNamedItem("default_axes");
 601         }
 602         //visible
 603         tempnode = attr.getNamedItem("visible");
 604         if (tempnode != null) {
 605             figVisible = getAttributeAsBoolean(tempnode.getNodeValue());
 606             attr.removeNamedItem("visible");
 607         }
 608
 609         //axesSize
 610         tempnode = attr.getNamedItem("axes_size");
 611         if (tempnode != null) {
 612             Double[] size = getAttributeAsDoubleArray(tempnode.getNodeValue());
 613             axesSize = new double[] {size[0], size[1]};
 614             attr.removeNamedItem("axes_size");
 615         }
 616
 617         //figureSize
 618         tempnode = attr.getNamedItem("figure_size");
 619         if (axesSize == null && tempnode != null) {
 620             Double[] size = getAttributeAsDoubleArray(tempnode.getNodeValue());
 621             figureSize = new double[] {size[0], size[1]};
 622             attr.removeNamedItem("figure_size");
 623         }
 624
 625         //menubar
 626         tempnode = attr.getNamedItem("menubar_visible");
 627         if (tempnode != null) {
 628             menubarVisisble = getAttributeAsBoolean(tempnode.getNodeValue());
 629             attr.removeNamedItem("menubar_visible");
 630         }
 631         //toolbar
 632         tempnode = attr.getNamedItem("toolbar_visible");
 633         if (tempnode != null) {
 634             toolbarVisisble = getAttributeAsBoolean(tempnode.getNodeValue());
 635             attr.removeNamedItem("toolbar_visible");
 636         }
 637         //infobar
 638         tempnode = attr.getNamedItem("infobar_visible");
 639         if (tempnode != null) {
 640             infobarVisisble = getAttributeAsBoolean(tempnode.getNodeValue());
 641             attr.removeNamedItem("infobar_visible");
 642         }
 643
 644         Integer fig = Builder.createFigure(dockable, menubar, toolbar, default_axes, false, figureSize, axesSize, null, menubarVisisble, toolbarVisisble, infobarVisisble);
 645         //set new id
 646         int newId = ScilabNativeView.ScilabNativeView__getValidDefaultFigureId();
 647
 648         controller.setProperty(fig,  __GO_ID__, newId);
 649         for (int i = 0 ; i < attr.getLength() ; i++) {
 650             Node prop = attr.item(i);
 651             Pair<Integer, ModelType> pair = figPropToGO.get(prop.getNodeName());
 652
 653             ModelType type = pair.getSecond();
 654             switch (type) {
 655                 case BOOLEAN:
 656                     controller.setProperty(fig, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 657                     break;
 658                 case BOOLEAN_ARRAY:
 659                     controller.setProperty(fig, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 660                     break;
 661                 case DOUBLE:
 662                     controller.setProperty(fig, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 663                     break;
 664                 case DOUBLE_ARRAY:
 665                     controller.setProperty(fig, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 666                     break;
 667                 case INTEGER:
 668                     controller.setProperty(fig, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 669                     break;
 670                 case INTEGER_ARRAY:
 671                     controller.setProperty(fig, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 672                     break;
 673                 case STRING:
 674                     controller.setProperty(fig, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 675                     break;
 676                 case STRING_ARRAY:
 677                     controller.setProperty(fig, pair.getFirst(), getAttributeAsStringArray(prop.getNodeValue()));
 678                     break;
 679                 case ROTATIONTYPE :
 680                     controller.setProperty(fig, pair.getFirst(), Figure.RotationType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 681                     break;
 682                 case BARTYPE :
 683                     controller.setProperty(fig, pair.getFirst(), Figure.BarType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 684                     break;
 685                 case LAYOUTTYPE :
 686                     controller.setProperty(fig, pair.getFirst(), LayoutType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 687                     break;
 688                 default:
 689                     System.out.println("missing type");
 690                     break;
 691             }
 692         }
 693
 694         return fig;
 695     }
 696
 697     private Integer createUiControl(Integer type, Integer parent, Node node) {
 698         GraphicController controller = GraphicController.getController();
 699         NamedNodeMap attr = node.getAttributes();
 700
 701         /*for frame we have to take care of scrollable property*/
 702         if (type == __GO_UI_FRAME__) {
 703             Node item = attr.getNamedItem("scrollable");
 704             if (item != null && item.getNodeValue().equals("on")) {
 705                 type = __GO_UI_FRAME_SCROLLABLE__;
 706             }
 707         }
 708
 709         Integer uic = GraphicController.getController().askObject(GraphicObject.getTypeFromName(type));
 710         controller.setProperty(uic, __GO_VISIBLE__, true);
 711
 712         for (int i = 0 ; i < attr.getLength() ; i++) {
 713             Node prop = attr.item(i);
 714             Pair<Integer, ModelType> pair = UiPropToGO.get(prop.getNodeName());
 715
 716             ModelType modelType = pair.getSecond();
 717             switch (modelType) {
 718                 case BOOLEAN:
 719                     controller.setProperty(uic, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 720                     break;
 721                 case BOOLEAN_ARRAY :
 722                     controller.setProperty(uic, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 723                     break;
 724                 case DOUBLE:
 725                     controller.setProperty(uic, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 726                     break;
 727                 case DOUBLE_ARRAY:
 728                     controller.setProperty(uic, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 729                     break;
 730                 case INTEGER:
 731                     controller.setProperty(uic, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 732                     break;
 733                 case INTEGER_ARRAY:
 734                     controller.setProperty(uic, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 735                     break;
 736                 case STRING:
 737                     controller.setProperty(uic, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 738                     break;
 739                 case STRING_ARRAY:
 740                     //nothing to do, manage as node instead of attributes
 741                     break;
 742                 case LAYOUTTYPE :
 743                     controller.setProperty(uic, pair.getFirst(), LayoutType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 744                     break;
 745                 case FILLTYPE :
 746                     controller.setProperty(uic, pair.getFirst(), Uicontrol.FillType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 747                     break;
 748                 case ANCHORTYPE :
 749                     controller.setProperty(uic, pair.getFirst(), Uicontrol.AnchorType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 750                     break;
 751                 case POSITIONTYPE :
 752                     controller.setProperty(uic, pair.getFirst(), Uicontrol.BorderLayoutType.stringToEnum(getAttributeAsString(prop.getNodeValue())).ordinal());
 753                     break;
 754                 default:
 755                     System.out.println("missing type");
 756                     break;
 757             }
 758         }
 759
 760         return uic;
 761     }
 762
 763     private Integer createUiMenu(Integer parent, Node node) {
 764         GraphicController controller = GraphicController.getController();
 765         NamedNodeMap attr = node.getAttributes();
 766
 767         Integer uim = GraphicController.getController().askObject(GraphicObject.getTypeFromName(__GO_UIMENU__));
 768         controller.setProperty(uim, __GO_VISIBLE__, true);
 769
 770         for (int i = 0 ; i < attr.getLength() ; i++) {
 771             Node prop = attr.item(i);
 772             Pair<Integer, ModelType> pair = MenuPropToGO.get(prop.getNodeName());
 773             ModelType modelType = pair.getSecond();
 774             switch (modelType) {
 775                 case BOOLEAN:
 776                     controller.setProperty(uim, pair.getFirst(), getAttributeAsBoolean(prop.getNodeValue()));
 777                     break;
 778                 case BOOLEAN_ARRAY :
 779                     controller.setProperty(uim, pair.getFirst(), getAttributeAsBooleanArray(prop.getNodeValue()));
 780                     break;
 781                 case DOUBLE:
 782                     controller.setProperty(uim, pair.getFirst(), getAttributeAsDouble(prop.getNodeValue()));
 783                     break;
 784                 case DOUBLE_ARRAY:
 785                     controller.setProperty(uim, pair.getFirst(), getAttributeAsDoubleArray(prop.getNodeValue()));
 786                     break;
 787                 case INTEGER:
 788                     controller.setProperty(uim, pair.getFirst(), getAttributeAsInteger(prop.getNodeValue()));
 789                     break;
 790                 case INTEGER_ARRAY:
 791                     controller.setProperty(uim, pair.getFirst(), getAttributeAsIntegerArray(prop.getNodeValue()));
 792                     break;
 793                 case STRING:
 794                     controller.setProperty(uim, pair.getFirst(), getAttributeAsString(prop.getNodeValue()));
 795                     break;
 796                 case STRING_ARRAY:
 797                     controller.setProperty(uim, pair.getFirst(), getAttributeAsStringArray(prop.getNodeValue()));
 798                     break;
 799                 default:
 800                     System.out.println("missing type");
 801                     break;
 802             }
 803         }
 804
 805         return uim;
 806     }
 807
 808     private Boolean getAttributeAsBoolean(String val) {
 809         if (val == null) {
 810             return null;
 811         }
 812
 813         if (val.equals("on")) {
 814             return true;
 815         }
 816
 817         if (val.equals("off")) {
 818             return false;
 819         }
 820
 821         return false;
 822     }
 823
 824     private void setBooleanAttribute(Integer id, int property, NamedNodeMap attributes, String attr) {
 825         Node node = attributes.getNamedItem(attr);
 826         if (node != null) {
 827             Boolean b = getAttributeAsBoolean(node.getNodeValue());
 828             if (b != null) {
 829                 GraphicController.getController().setProperty(id, property, b);
 830             }
 831         }
 832     }
 833
 834     private Double getAttributeAsDouble(String val) {
 835         if (val == null) {
 836             return null;
 837         }
 838
 839         return Double.parseDouble(val);
 840     }
 841
 842     private Integer getAttributeAsInteger(String val) {
 843         if (val == null) {
 844             return null;
 845         }
 846
 847         return Integer.parseInt(val);
 848     }
 849
 850     private String getAttributeAsString(String val) {
 851         return val;
 852     }
 853
 854     private Boolean[] getAttributeAsBooleanArray(String val) {
 855
 856         if (val == null) {
 857             return new Boolean[] {};
 858         }
 859
 860         StringTokenizer token = new StringTokenizer(val, ",");
 861
 862         Boolean[] b = new Boolean[token.countTokens()];
 863         int i = 0;
 864         while (token.hasMoreElements()) {
 865             String s = token.nextToken();
 866             if (s.equals("on")) {
 867                 b[i++] = true;
 868             } else {
 869                 b[i++] = false;
 870             }
 871         }
 872
 873         return b;
 874     }
 875
 876     private Double[] getAttributeAsDoubleArray(String val) {
 877
 878         if (val == null) {
 879             return new Double[] {};
 880         }
 881
 882         StringTokenizer token = new StringTokenizer(val, ",");
 883
 884         Double[] d = new Double[token.countTokens()];
 885         int i = 0;
 886         while (token.hasMoreElements()) {
 887             String s = token.nextToken();
 888             d[i++] = Double.parseDouble(s);
 889         }
 890
 891         return d;
 892     }
 893
 894     private Integer[] getAttributeAsIntegerArray(String val) {
 895
 896         if (val == null) {
 897             return new Integer[] {};
 898         }
 899
 900         StringTokenizer token = new StringTokenizer(val, ",");
 901
 902         Integer[] integer = new Integer[token.countTokens()];
 903         int i = 0;
 904         while (token.hasMoreElements()) {
 905             String s = token.nextToken();
 906             integer[i++] = Integer.parseInt(s);
 907         }
 908
 909         return integer;
 910     }
 911
 912     private String[] getAttributeAsStringArray(String val) {
 913
 914         if (val == null) {
 915             return null;
 916         }
 917
 918         StringTokenizer token = new StringTokenizer(val, ",");
 919
 920         String[] s = new String[token.countTokens()];
 921         int i = 0;
 922         while (token.hasMoreElements()) {
 923             s[i++] = token.nextToken();
 924         }
 925
 926         return s;
 927     }
 928 }