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