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