Add loadGui and saveGui help pages.
[scilab.git] / 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 }