fix NullPointerException in builder.createFigure
[scilab.git] / scilab / modules / graphic_objects / src / java / org / scilab / modules / graphic_objects / builder / Builder.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
4  * Copyright (C) 2013 - Scilab Enterprises - Antoine ELIAS
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  *
12  */
13
14 package org.scilab.modules.graphic_objects.builder;
15
16 import java.util.ArrayList;
17 import java.util.StringTokenizer;
18
19 import org.scilab.modules.graphic_objects.ScilabNativeView;
20 import org.scilab.modules.graphic_objects.arc.Arc;
21 import org.scilab.modules.graphic_objects.axes.Axes;
22 import org.scilab.modules.graphic_objects.axis.Axis;
23 import org.scilab.modules.graphic_objects.fec.Fec;
24 import org.scilab.modules.graphic_objects.figure.Figure;
25 import org.scilab.modules.graphic_objects.figure.Figure.BarType;
26 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
27 import org.scilab.modules.graphic_objects.graphicModel.GraphicModel;
28 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject;
29 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject.Type;
30 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
31 import org.scilab.modules.graphic_objects.imageplot.Imageplot;
32 import org.scilab.modules.graphic_objects.label.Label;
33 import org.scilab.modules.graphic_objects.legend.Legend;
34 import org.scilab.modules.graphic_objects.lighting.Light;
35 import org.scilab.modules.graphic_objects.lighting.Light.LightType;
36 import org.scilab.modules.graphic_objects.polyline.Polyline;
37 import org.scilab.modules.graphic_objects.rectangle.Rectangle;
38 import org.scilab.modules.graphic_objects.surface.Surface;
39 import org.scilab.modules.graphic_objects.textObject.Font;
40 import org.scilab.modules.graphic_objects.textObject.Text;
41 import org.scilab.modules.graphic_objects.vectfield.Champ;
42 import org.scilab.modules.graphic_objects.vectfield.Segs;
43
44 public final class Builder {
45     public final static int createRect(int parentSubwin, double x, double y, double height, double width, int foreground, int background, int isfilled, int isline) {
46         GraphicController controller = GraphicController.getController();
47         Axes axes = (Axes) controller.getObjectFromId(parentSubwin);
48
49         if (height < 0 || width < 0) {
50             return 0;
51         }
52
53         Integer iRect = controller.askObject(Type.RECTANGLE, false);
54
55         /*
56          * Sets the rectangle's parent in order to initialize the former's
57          * Contoured properties with the latter's values (cloneGraphicContext
58          * call below)
59          */
60
61         Rectangle rect = (Rectangle) controller.getObjectFromId(iRect);
62         rect.setUpperLeftPoint(new Double[] { x, y, 0.0 });
63         rect.setHeight(height);
64         rect.setWidth(width);
65
66         rect.setVisible(axes.getVisible());
67
68         /* Clip state and region */
69         /* To be checked for consistency */
70
71         rect.setClipBox(axes.getClipBox());
72         rect.setClipBoxSet(axes.getClipBoxSet());
73         rect.setClipState(axes.getClipState());
74         rect.setMarkMode(axes.getMarkMode());
75
76         /*
77          * Initializes the contour properties (background, foreground, etc) to
78          * the default values (those of the parent Axes).
79          */
80         cloneGraphicContext(parentSubwin, iRect);
81
82         /* Contour settings */
83         rect.setLineMode(isline == 1);
84         rect.setFillMode(isfilled == 1);
85
86         if (foreground != -1) {
87             rect.setLineColor(foreground);
88         }
89
90         if (background != -1) {
91             rect.setBackground(background);
92         }
93
94         controller.objectCreated(iRect);
95
96         /*
97          * Sets the Axes as the rectangle's parent and adds the rectangle to its
98          * parent's list of children.
99          */
100         //setGraphicObjectRelationship(pparentsubwinUID, pobjUID);
101
102         return iRect;
103     }
104
105     public static int cloneGraphicContext(int sourceIdentifier, int destIdentifier) {
106         GraphicController controller = GraphicController.getController();
107         Boolean lineMode = false;
108         Integer foreground = 0;
109         Integer lineStyle = 0;
110         Integer background = 0;
111         Integer markForeground = 0;
112         Integer markBackground = 0;
113         Integer markStyle = 0;
114         Integer markSize = 0;
115         Integer markSizeUnit = 0;
116         Double lineThickness = 0.;
117
118         /*
119          * All these properties are passed by value thus do not care to release
120          * them and do not call releaseGraphicObjectProperty on purpose.
121          */
122
123         lineMode = (Boolean) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_MODE__);
124         foreground = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_COLOR__);
125         lineThickness = (Double) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_THICKNESS__);
126         lineStyle = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_LINE_STYLE__);
127
128         background = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_BACKGROUND__);
129
130         markForeground = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_FOREGROUND__);
131
132         markBackground = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_BACKGROUND__);
133
134         markStyle = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_STYLE__);
135
136         markSize = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_SIZE__);
137
138         markSizeUnit = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_MARK_SIZE_UNIT__);
139
140         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_MODE__, lineMode);
141         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_COLOR__, foreground);
142         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_THICKNESS__, lineThickness);
143         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_LINE_STYLE__, lineStyle);
144
145         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_BACKGROUND__, background);
146
147         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_FOREGROUND__, markForeground);
148         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_BACKGROUND__, markBackground);
149         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_STYLE__, markStyle);
150         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_SIZE__, markSize);
151         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_MARK_SIZE_UNIT__, markSizeUnit);
152
153         return 0;
154     }
155
156     public static int cloneFontContext(int sourceIdentifier, int destIdentifier) {
157         GraphicController controller = GraphicController.getController();
158
159         Integer fontColor = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_COLOR__);
160         Integer fontStyle = (Integer) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_STYLE__);
161         Double fontSize = (Double) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_SIZE__);
162         Boolean fontFractional = (Boolean) controller.getProperty(sourceIdentifier, GraphicObjectProperties.__GO_FONT_FRACTIONAL__);
163
164         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_COLOR__, fontColor);
165         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_STYLE__, fontStyle);
166         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_SIZE__, fontSize);
167         controller.setProperty(destIdentifier, GraphicObjectProperties.__GO_FONT_FRACTIONAL__, fontFractional);
168
169         return 0;
170     }
171
172     public static int createHiddenLabel(int parent) {
173
174         GraphicController controller = GraphicController.getController();
175
176         Integer iLabel = controller.askObject(Type.LABEL, false);
177         Label label = (Label) controller.getObjectFromId(iLabel);
178
179         //Hide Label as they are non explicit children
180         label.setHidden(true);
181         label.setAutoPosition(true);
182         label.setAutoRotation(true);
183
184         cloneGraphicContext(parent, iLabel);
185         cloneFontContext(parent, iLabel);
186         controller.objectCreated(iLabel);
187
188         // Sets the label's parent
189         controller.setGraphicObjectRelationship(parent, iLabel);
190
191         return iLabel;
192     }
193
194     public static void initSubWinBounds(int subWin) {
195         GraphicController controller = GraphicController.getController();
196
197         controller.setProperty(subWin, GraphicObjectProperties.__GO_X_AXIS_LOG_FLAG__, false);
198         controller.setProperty(subWin, GraphicObjectProperties.__GO_Y_AXIS_LOG_FLAG__, false);
199         controller.setProperty(subWin, GraphicObjectProperties.__GO_Z_AXIS_LOG_FLAG__, false);
200     }
201
202     public static void reinitSubWin(int subWin) {
203         GraphicController controller = GraphicController.getController();
204         Integer label = 0;
205
206         for (Integer childId : (Integer[]) controller.getProperty(subWin, GraphicObjectProperties.__GO_CHILDREN__)) {
207             GraphicModel.getModel().deleteObject(childId);
208         }
209
210         label = createHiddenLabel(subWin);
211         controller.setProperty(subWin, GraphicObjectProperties.__GO_TITLE__, label);
212
213         label = createHiddenLabel(subWin);
214         controller.setProperty(subWin, GraphicObjectProperties.__GO_X_AXIS_LABEL__, label);
215
216         label = createHiddenLabel(subWin);
217         controller.setProperty(subWin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__, label);
218
219         label = createHiddenLabel(subWin);
220         controller.setProperty(subWin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__, label);
221
222         controller.setProperty(subWin, GraphicObjectProperties.__GO_X_AXIS_LOCATION__, 0);
223         controller.setProperty(subWin, GraphicObjectProperties.__GO_Y_AXIS_LOCATION__, 4);
224         controller.setProperty(subWin, GraphicObjectProperties.__GO_VISIBLE__, true);
225         controller.setProperty(subWin, GraphicObjectProperties.__GO_FIRST_PLOT__, true);
226
227         Integer axesModel = GraphicModel.getAxesModel().getIdentifier();
228         Axes axes = (Axes) controller.getObjectFromId(axesModel);
229
230         controller.setProperty(subWin, GraphicObjectProperties.__GO_VIEW__, axes.getView());
231         controller.setProperty(subWin, GraphicObjectProperties.__GO_ROTATION_ANGLES__, axes.getRotationAngles());
232         controller.setProperty(subWin, GraphicObjectProperties.__GO_ROTATION_ANGLES_3D__, axes.getRotationAngles3d());
233     }
234
235     public static boolean isAxesRedrawing(int subWin) {
236         GraphicController controller = GraphicController.getController();
237         Axes axes = (Axes) controller.getObjectFromId(subWin);
238
239         if (axes.getAutoClear()) {
240             reinitSubWin(subWin);
241             return true;
242         }
243         return false;
244     }
245
246     public static int createLabel(int parent, int type) {
247         GraphicController controller = GraphicController.getController();
248         Double[] position = new Double[3];
249         position[0] = 1.0;
250         position[1] = 1.0;
251         position[2] = 1.0;
252
253         //check parent type
254         Integer parentType = (Integer) controller.getProperty(parent, GraphicObjectProperties.__GO_TYPE__);
255         if (parentType != GraphicObjectProperties.__GO_AXES__) {
256             return 1;
257         }
258
259         //get axes model
260         Integer axesModel = GraphicModel.getAxesModel().getIdentifier();
261
262         //get type label from axes model
263         Integer labelSource = (Integer) controller.getProperty(axesModel, type);
264
265         //clone label
266         Integer newLabel = controller.cloneObject(labelSource);
267         controller.setProperty(newLabel, GraphicObjectProperties.__GO_POSITION__, position);
268         // Auto position must be reset as setting the position has set it to false
269         Boolean autoPosition = (Boolean) controller.getProperty(labelSource, GraphicObjectProperties.__GO_AUTO_POSITION__);
270         controller.setProperty(newLabel, GraphicObjectProperties.__GO_AUTO_POSITION__, autoPosition);
271
272         // Set relation between newLabel and parent
273         controller.setProperty(parent, type, newLabel);
274         controller.setGraphicObjectRelationship(parent, newLabel);
275         return 0;
276     }
277
278     public final static int createFigureFromModel() {
279         GraphicController controller = GraphicController.getController();
280         return controller.cloneObject(GraphicModel.getFigureModel().getIdentifier());
281     }
282
283     public final static int cloneAxesModel(int parent) {
284         GraphicController controller = GraphicController.getController();
285
286         Integer newAxes = controller.cloneObject(GraphicModel.getAxesModel().getIdentifier());
287         createLabel(newAxes, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
288         createLabel(newAxes, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
289         createLabel(newAxes, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
290         createLabel(newAxes, GraphicObjectProperties.__GO_TITLE__);
291
292         controller.setGraphicObjectRelationship(parent, newAxes);
293         controller.setProperty(parent, GraphicObjectProperties.__GO_SELECTED_CHILD__, newAxes);
294
295         ScilabNativeView.ScilabNativeView__setCurrentSubWin(newAxes);
296         ScilabNativeView.ScilabNativeView__setCurrentObject(newAxes);
297         return newAxes;
298     }
299
300     public final static void cloneMenus(int iModel, int iParent) {
301         GraphicController controller = GraphicController.getController();
302         GraphicObject model = controller.getObjectFromId(iModel);
303
304         Integer[] children = model.getChildren();
305
306         for (int i = children.length - 1; i >= 0; i--) {
307             GraphicObject child = controller.getObjectFromId(children[i]);
308             if (child.getType() == GraphicObjectProperties.__GO_UIMENU__) {
309                 Integer newMenu = controller.cloneObject(children[i]);
310                 controller.setGraphicObjectRelationship(iParent, newMenu);
311
312                 cloneMenus(children[i], newMenu);
313             }
314         }
315     }
316
317     public final static int createFigure(boolean dockable, int menubarType, int toolbarType, boolean defaultAxes, boolean visible, double[] figureSize, double[] axesSize, double[] position,
318                                          boolean menubar, boolean toolbar, boolean infobar) {
319         GraphicController controller = GraphicController.getController();
320         Integer figModel = GraphicModel.getFigureModel().getIdentifier();
321         Integer figId = controller.cloneObject(figModel, false);
322         Figure figure = (Figure) controller.getObjectFromId(figId);
323         figure.setDockable(dockable);
324         figure.setMenubar(menubarType);
325         figure.setToolbar(toolbarType);
326         figure.setVisible(visible);
327         figure.setDefaultAxes(defaultAxes);
328
329         //set figure size only if axes size is not set too
330         if (figureSize != null && figureSize.length == 2 && (axesSize == null || axesSize.length == 0)) {
331             figure.setSize(new Integer[] { (int) figureSize[0], (int) figureSize[1] });
332         }
333
334         if (position != null && position.length == 2) {
335             figure.setPosition(new Integer[] { (int) position[0], (int) position[1] });
336         }
337
338         figure.setMenubarVisible(menubar);
339         figure.setToolbarVisible(toolbar);
340         figure.setInfobarVisible(infobar);
341
342         controller.objectCreated(figId);
343
344         ScilabNativeView.ScilabNativeView__setCurrentFigure(figId);
345
346         if (menubarType == BarType.FIGURE.ordinal()) {
347             cloneMenus(figModel, figId);
348         }
349
350         if (defaultAxes) {
351             //clone default axes
352             cloneAxesModel(figId);
353         }
354
355         if (axesSize != null && axesSize.length == 2) {
356             controller.setProperty(figId, GraphicObjectProperties.__GO_AXES_SIZE__, new Integer[] { (int) axesSize[0], (int) axesSize[1] });
357         }
358
359         return figId;
360     }
361
362     public final static int createNewFigureWithAxes() {
363         GraphicController controller = GraphicController.getController();
364         Integer figModel = GraphicModel.getFigureModel().getIdentifier();
365
366         //clone default figure
367         Integer newFigure = createFigureFromModel();
368
369         //Clone the default menus
370         cloneMenus(figModel, newFigure);
371
372         //set ID to 0
373         controller.setProperty(newFigure, GraphicObjectProperties.__GO_ID__, 0);
374
375         //clone default axes
376         cloneAxesModel(newFigure);
377         ScilabNativeView.ScilabNativeView__setCurrentFigure(newFigure);
378
379         //Force axes size after window creation
380         Integer[] axesSize = (Integer[]) controller.getProperty(figModel, GraphicObjectProperties.__GO_AXES_SIZE__);
381         controller.setProperty(newFigure, GraphicObjectProperties.__GO_AXES_SIZE__, axesSize);
382
383         controller.setProperty(newFigure, GraphicObjectProperties.__GO_VALID__, true);
384
385         return newFigure;
386     }
387
388     public final static int createSubWin(int parentFigure) {
389         //GraphicController controller = GraphicController.getController();
390         //GraphicObject parent = controller.getObjectFromId(parentFigure);
391         //if (parent.getType() != GraphicObjectProperties.__GO_FIGURE__) {
392         //    return 0;
393         //}
394
395         return cloneAxesModel(parentFigure);
396     }
397
398     public final static int createText(int iParentsubwinUID, String[] str, int nbRow, int nbCol, double x, double y, boolean autoSize, double[] userSize, int centerPos, int foreground,
399                                        boolean isForeground, int background, boolean isBackground, boolean isBoxed, boolean isLine, boolean isFilled, int align) {
400
401         GraphicController controller = GraphicController.getController();
402         int iText = controller.askObject(Type.TEXT, false);
403
404         Axes axes = (Axes) controller.getObjectFromId(iParentsubwinUID);
405         Text text = (Text) controller.getObjectFromId(iText);
406
407         //clip
408         text.setClipBox(axes.getClipBox());
409         text.setClipBoxSet(axes.getClipBoxSet());
410         text.setClipState(axes.getClipState());
411
412         //text
413         Integer[] dimensions = new Integer[2];
414         dimensions[0] = nbRow;
415         dimensions[1] = nbCol;
416         text.setTextArrayDimensions(dimensions);
417         text.setTextStrings(str);
418
419         //position
420         Double[] position = new Double[3];
421         position[0] = x;
422         position[1] = y;
423         position[2] = 0.0;
424         text.setPosition(position);
425
426         //test box
427         Double[] setUserSize = new Double[2];
428         text.setTextBoxMode(centerPos);
429         text.setAutoDimensioning(autoSize);
430
431         if (autoSize == false || centerPos != 0) {
432             setUserSize[0] = userSize[0];
433             setUserSize[1] = userSize[1];
434         } else {
435             setUserSize[0] = 0.0;
436             setUserSize[1] = 0.0;
437         }
438         text.setTextBox(setUserSize);
439
440         int alignment = align - 1;
441         if (alignment < 0 || alignment > 2) {
442             alignment = 0;
443         }
444
445         text.setAlignment(alignment);
446
447         cloneGraphicContext(iParentsubwinUID, iText);
448         cloneFontContext(iParentsubwinUID, iText);
449
450         text.setBox(isBoxed);
451         text.setLineMode(isLine);
452         text.setFillMode(isFilled);
453
454         if (isForeground) {
455             text.setLineColor(foreground);
456         }
457
458         if (isBackground) {
459             text.setBackground(background);
460         }
461
462         text.setVisible(axes.getVisible());
463         controller.objectCreated(iText);
464         return iText;
465     }
466
467     public final static int createArc(int parent, double x, double y, double h, double w, double startAngle, double endAngle, int foreground, boolean isForeground, int background,
468                                       boolean isBackground, boolean filled, boolean line) {
469
470         GraphicController controller = GraphicController.getController();
471         int iArc = controller.askObject(Type.ARC, false);
472
473         Axes axes = (Axes) controller.getObjectFromId(parent);
474         Arc arc = (Arc) controller.getObjectFromId(iArc);
475
476         //set visible false during construction
477         arc.setVisible(false);
478
479         Double[] upperLeftPoint = new Double[3];
480         upperLeftPoint[0] = x;
481         upperLeftPoint[1] = y;
482         upperLeftPoint[2] = 0.0;
483
484         arc.setUpperLeftPoint(upperLeftPoint);
485         arc.setHeight(h);
486         arc.setWidth(w);
487         arc.setStartAngle(startAngle);
488         arc.setEndAngle(endAngle);
489         arc.setArcDrawingMethod(axes.getArcDrawingMethod());
490
491         //clip
492         arc.setClipBox(axes.getClipBox());
493         arc.setClipBoxSet(axes.getClipBoxSet());
494         arc.setClipState(axes.getClipState());
495
496         cloneGraphicContext(parent, iArc);
497
498         arc.setLineMode(line);
499         arc.setFillMode(filled);
500
501         if (isForeground) {
502             arc.setLineColor(foreground);
503         }
504
505         if (isBackground) {
506             arc.setBackground(background);
507         }
508
509         arc.setVisible(axes.getVisible());
510         controller.objectCreated(iArc);
511         controller.setGraphicObjectRelationship(parent, iArc);
512         return iArc;
513     }
514
515     public final static int createAxis(int parent, int dir, int tics, double[] vx, double[] vy, int subint, String format, int fontSize, int textColor, int ticsColor, boolean seg) {
516
517         GraphicController controller = GraphicController.getController();
518         int iAxis = controller.askObject(Type.AXIS, false);
519
520         Axes axes = (Axes) controller.getObjectFromId(parent);
521         Axis axis = (Axis) controller.getObjectFromId(iAxis);
522
523         //clip box
524         axis.setClipBox(axes.getClipBox());
525         axis.setClipBoxSet(false);
526
527         axis.setTicksDirection(dir);
528         axis.setTicksStyle(tics);
529
530         axis.setXTicksCoords(toDouble(vx));
531         axis.setYTicksCoords(toDouble(vy));
532
533         if (format != null && format.equals("") == false) {
534             axis.setFormatn(format);
535         }
536
537         axis.setSubticks(subint);
538         axis.setTicksSegment(seg);
539         cloneGraphicContext(parent, iAxis);
540         cloneFontContext(parent, iAxis);
541
542         Font font = axis.getFont();
543         font.setSize(new Double(fontSize));
544         font.setColor(textColor);
545         axis.setTicksColor(ticsColor);
546
547         controller.objectCreated(iAxis);
548         controller.setGraphicObjectRelationship(parent, iAxis);
549         return iAxis;
550     }
551
552     public static int createCompound(int parent, int[] children) {
553         GraphicController controller = GraphicController.getController();
554         int iCompound = controller.askObject(Type.COMPOUND);
555
556         GraphicObject obj = controller.getObjectFromId(parent);
557         for (int i = 0; i < children.length; i++) {
558             controller.setGraphicObjectRelationship(iCompound, children[i]);
559         }
560
561         controller.setGraphicObjectRelationship(parent, iCompound);
562         controller.setProperty(iCompound, GraphicObjectProperties.__GO_VISIBLE__, obj.getVisible());
563         return iCompound;
564     }
565
566     public static int createCompoundSeq(int parent, int childrenCount) {
567         GraphicController controller = GraphicController.getController();
568         int iCompound = controller.askObject(Type.COMPOUND);
569         GraphicObject axes = controller.getObjectFromId(parent);
570
571         Integer[] children = axes.getChildren();
572
573         /*
574          * Remove the last "number" created objects (located at the children
575          * list's head) and add them to the compound in the same order
576          */
577         for (int i = 0; i < childrenCount; i++) {
578             /*
579              * Set the parent-child relationship between the Compound and each
580              * aggregated object. Children are added to the Compound from the
581              * least recent to the most recent, to preserve their former
582              * ordering.
583              */
584             controller.setGraphicObjectRelationship(iCompound, children[childrenCount - i - 1]);
585         }
586
587         controller.setGraphicObjectRelationship(parent, iCompound);
588
589         /*
590          * visibility is obtained from the parent Figure, whereas it is
591          * retrieved from the parent Axes in ConstructCompound. To be made
592          * consistent.
593          */
594         Figure fig = (Figure) controller.getObjectFromId(axes.getParentFigure());
595         controller.setProperty(iCompound, GraphicObjectProperties.__GO_VISIBLE__, fig.getVisible());
596         return iCompound;
597     }
598
599     public static int createFec(int parent, double[] zminmax, int[] colminmax, int[] colout, boolean with_mesh) {
600
601         GraphicController controller = GraphicController.getController();
602         int iFec = controller.askObject(Type.FEC, false);
603         Axes axes = (Axes) controller.getObjectFromId(parent);
604         Fec fec = (Fec) controller.getObjectFromId(iFec);
605
606         fec.setZBounds(toDouble(zminmax));
607         fec.setColorRange(toInteger(colminmax));
608         fec.setOutsideColor(toInteger(colout));
609
610         fec.setVisible(axes.getVisible());
611
612         //clip box
613         fec.setClipBox(axes.getClipBox());
614         fec.setClipBoxSet(axes.getClipBoxSet());
615         fec.setClipState(axes.getClipState());
616
617         cloneGraphicContext(parent, iFec);
618
619         fec.setLineMode(with_mesh);
620
621         controller.objectCreated(iFec);
622         return iFec;
623     }
624
625     public static int createGrayplot(int parent, int type, double[] pvecx, int n1, int n2) {
626
627         int[] objectTypes = new int[] { GraphicObjectProperties.__GO_GRAYPLOT__, GraphicObjectProperties.__GO_MATPLOT__, GraphicObjectProperties.__GO_MATPLOT__ };
628
629         GraphicController controller = GraphicController.getController();
630         int iPlot = controller.askObject(GraphicObject.getTypeFromName(objectTypes[type]), false);
631         Axes axes = (Axes) controller.getObjectFromId(parent);
632         Imageplot plot = (Imageplot) controller.getObjectFromId(iPlot);
633
634         if (type == 2) { //Matplot1
635             Double[] data = new Double[pvecx.length];
636             for (int i = 0; i < pvecx.length; i++) {
637                 data[i] = pvecx[i];
638             }
639             plot.setTranslate(data);
640
641             Double[] scale = new Double[2];
642             scale[0] = (pvecx[2] - pvecx[0]) / (n2 - 1.0);
643             scale[1] = (pvecx[3] - pvecx[1]) / (n1 - 1.0);
644             plot.setScale(scale);
645         }
646
647         plot.setVisible(axes.getVisible());
648
649         //clip box
650         plot.setClipBox(axes.getClipBox());
651         plot.setClipBoxSet(axes.getClipBoxSet());
652         plot.setClipState(axes.getClipState());
653
654         cloneGraphicContext(parent, iPlot);
655         controller.objectCreated(iPlot);
656         return iPlot;
657     }
658
659     public static int createPolyline(int parent, boolean closed, int plot, int foreground, boolean isForeground, int[] background, int mark_style, boolean isMarkStyle, int mark_foreground,
660                                      boolean isMarkForeground, int mark_background, boolean isMarkBackground, boolean isline, boolean isfilled, boolean ismark, boolean isinterp) {
661
662         GraphicController controller = GraphicController.getController();
663         int iPoly = controller.askObject(Type.POLYLINE, false);
664         Axes axes = (Axes) controller.getObjectFromId(parent);
665         Polyline poly = (Polyline) controller.getObjectFromId(iPoly);
666
667         poly.setVisible(false);
668
669         //clip box
670         poly.setClipBox(axes.getClipBox());
671         poly.setClipBoxSet(axes.getClipBoxSet());
672         poly.setClipState(axes.getClipState());
673
674         poly.setClosed(closed);
675         poly.setPolylineStyle(plot);
676
677         cloneGraphicContext(parent, iPoly);
678
679         poly.setMarkMode(ismark);
680         poly.setLineMode(isline);
681         poly.setFillMode(isfilled);
682         poly.setInterpColorMode(isinterp);
683
684         if (isForeground) {
685             poly.setLineColor(foreground);
686         }
687
688         if (background.length != 0) {
689             if (isinterp) {
690                 /* 3 or 4 values to store */
691                 Integer[] color = new Integer[background.length];
692                 for (int i = 0; i < background.length; i++) {
693                     color[i] = background[i];
694                 }
695
696                 poly.setInterpColorVector(color);
697             } else {
698                 poly.setBackground(background[0]);
699             }
700         }
701
702         if (isMarkStyle) {
703             poly.setMarkStyle(mark_style);
704         }
705
706         if (isMarkForeground) {
707             poly.setMarkForeground(mark_foreground);
708         }
709
710         if (isMarkBackground) {
711             poly.setMarkBackground(mark_background);
712         }
713
714         poly.setVisible(true);
715         controller.objectCreated(iPoly);
716         return iPoly;
717     }
718
719     public static int createLegend(int parent, String[] text, int[] handles) {
720         GraphicController controller = GraphicController.getController();
721         Axes axes = (Axes) controller.getObjectFromId(parent);
722
723         if (axes.getHasLegendChild()) {
724             controller.removeRelationShipAndDelete(axes.getLegendChild());
725         }
726
727         int iLeg = controller.askObject(Type.LEGEND, false);
728         Legend leg = (Legend) controller.getObjectFromId(iLeg);
729
730         leg.setParent(parent);
731         leg.setVisible(axes.getVisible());
732
733         int count = handles.length;
734         Integer[] textDims = new Integer[2];
735         textDims[0] = count;
736         textDims[1] = 1;
737
738         leg.setTextArrayDimensions(textDims);
739         leg.setTextStrings(text);
740
741         /*
742          * Links are ordered from most recent to least recent, as their
743          * referred-to Polylines in the latter's parent Compound object.
744          */
745
746         ArrayList<Integer> links = new ArrayList<Integer>();
747         for (int i = count - 1; i >= 0; i--) {
748             links.add(count - i - 1, handles[i]);
749         }
750
751         leg.setLinks(links);
752
753         leg.setClipBoxSet(false);
754         leg.setClipState(0); //OFF
755         leg.setClipBox(axes.getClipBox());
756
757         cloneGraphicContext(parent, iLeg);
758         cloneFontContext(parent, iLeg);
759
760         leg.setFillMode(true);
761
762         controller.objectCreated(iLeg);
763         leg.setParent(0);
764         controller.setGraphicObjectRelationship(parent, iLeg);
765         return iLeg;
766     }
767
768     public static int createSegs(int parent, double[] vx, double[] vy, double[] vz, boolean isVZ, int[] style, double arsize) {
769         GraphicController controller = GraphicController.getController();
770         Axes axes = (Axes) controller.getObjectFromId(parent);
771         int iSegs = controller.askObject(Type.SEGS, false);
772         Segs segs = (Segs) controller.getObjectFromId(iSegs);
773
774         segs.setVisible(axes.getVisible());
775
776         //clip box
777         segs.setClipBox(axes.getClipBox());
778         segs.setClipBoxSet(axes.getClipBoxSet());
779         segs.setClipState(axes.getClipState());
780
781         /* Segs: Nbr1/2 arrows, Nbr1 is the number of endpoints */
782         int numberArrows = vx.length / 2;
783
784         segs.setNumberArrows(numberArrows);
785         segs.setArrowSize(arsize);
786
787         Double[] arrowCoords = new Double[3 * numberArrows];
788         for (int i = 0; i < numberArrows; i++) {
789             arrowCoords[3 * i] = vx[2 * i];
790             arrowCoords[3 * i + 1] = vy[2 * i];
791             if (isVZ) {
792                 arrowCoords[3 * i + 2] = vz[2 * i];
793             } else {
794                 arrowCoords[3 * i + 2] = 0.0;
795             }
796         }
797
798         segs.setBase(arrowCoords);
799
800         for (int i = 0; i < numberArrows; i++) {
801             arrowCoords[3 * i] = vx[2 * i + 1];
802             arrowCoords[3 * i + 1] = vy[2 * i + 1];
803             if (isVZ) {
804                 arrowCoords[3 * i + 2] = vz[2 * i + 1];
805             } else {
806                 arrowCoords[3 * i + 2] = 0.0;
807             }
808         }
809
810         segs.setDirection(arrowCoords);
811         segs.setColors(toInteger(style));
812
813         cloneGraphicContext(parent, iSegs);
814         controller.objectCreated(iSegs);
815         controller.setGraphicObjectRelationship(parent, iSegs);
816         return iSegs;
817     }
818
819     public static int createChamp(int parent, double[] vx, double[] vy, double[] vfx, double[] vfy, double arsize, boolean typeofchamp) {
820
821         GraphicController controller = GraphicController.getController();
822         Axes axes = (Axes) controller.getObjectFromId(parent);
823
824         int iChamp = controller.askObject(Type.CHAMP, false);
825         Champ champ = (Champ) controller.getObjectFromId(iChamp);
826
827         champ.setVisible(axes.getVisible());
828
829         //clip box
830         champ.setClipBox(axes.getClipBox());
831         champ.setClipBoxSet(axes.getClipBoxSet());
832         champ.setClipState(axes.getClipState());
833
834         int numberArrows = vx.length * vy.length;
835         champ.setNumberArrows(numberArrows);
836
837         Integer[] dimensions = new Integer[] { vx.length, vy.length };
838         champ.setDimensions(dimensions);
839
840         champ.setArrowSize(arsize);
841
842         Double[] arrowCoords = new Double[3 * numberArrows];
843
844         //convert vx Double
845         Double[] temp = new Double[vx.length];
846         for (int i = 0; i < vx.length; i++) {
847             temp[i] = vx[i];
848         }
849         champ.setBaseX(temp);
850
851         //convert vy Double
852         temp = new Double[vy.length];
853         for (int i = 0; i < vy.length; i++) {
854             temp[i] = vy[i];
855         }
856         champ.setBaseY(temp);
857
858         for (int i = 0; i < numberArrows; i++) {
859             arrowCoords[3 * i] = vfx[i];
860             arrowCoords[3 * i + 1] = vfy[i];
861             arrowCoords[3 * i + 2] = 0.0;
862         }
863
864         champ.setDirection(arrowCoords);
865         champ.setColored(typeofchamp);
866
867         cloneGraphicContext(parent, iChamp);
868
869         controller.objectCreated(iChamp);
870         controller.setGraphicObjectRelationship(parent, iChamp);
871
872         return iChamp;
873     }
874
875     public static int createSurface(int parent, int typeof3d, int colorFlag, int colorMode) {
876         GraphicController controller = GraphicController.getController();
877         Axes axes = (Axes) controller.getObjectFromId(parent);
878
879         int iSurf = controller.askObject(GraphicObject.getTypeFromName(typeof3d), false);
880         Surface surf = (Surface) controller.getObjectFromId(iSurf);
881
882         surf.setVisible(axes.getVisible());
883
884         //clip box
885         surf.setClipBox(axes.getClipBox());
886         surf.setClipBoxSet(axes.getClipBoxSet());
887         surf.setClipState(axes.getClipState());
888
889         surf.setColorFlag(colorFlag);
890         surf.setColorMode(colorMode);
891
892         surf.setHiddenColor(axes.getHiddenColor());
893
894         surf.setSurfaceMode(true);
895         cloneGraphicContext(parent, iSurf);
896         controller.objectCreated(iSurf);
897         controller.setGraphicObjectRelationship(parent, iSurf);
898
899         return iSurf;
900     }
901
902     public static void initSubWinTo3d(int iSubwin, String legend, boolean isLegend, int[] flag, double alpha, double theta, double[] ebox, double[] x, double[] y, double[] z) {
903         GraphicController controller = GraphicController.getController();
904
905         // Force 3d view
906         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_VIEW__, 1);
907
908         if (isLegend) {
909             StringTokenizer strTok = new StringTokenizer(legend, "@");
910             int iToken = strTok.countTokens();
911             if (iToken > 0) {
912                 //X
913                 String str[] = new String[] { strTok.nextToken() };
914                 Integer label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
915                 Integer[] dims = new Integer[] { 1, 1 };
916                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_ARRAY_DIMENSIONS__, dims);
917                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_STRINGS__, str);
918             }
919
920             if (iToken > 1) {
921                 //Y
922                 String str[] = new String[] { strTok.nextToken() };
923                 Integer label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
924                 Integer[] dims = new Integer[] { 1, 1 };
925                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_ARRAY_DIMENSIONS__, dims);
926                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_STRINGS__, str);
927             }
928
929             if (iToken > 2) {
930                 //Z
931                 String str[] = new String[] { strTok.nextToken() };
932                 Integer label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
933                 Integer[] dims = new Integer[] { 1, 1 };
934                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_ARRAY_DIMENSIONS__, dims);
935                 controller.setProperty(label, GraphicObjectProperties.__GO_TEXT_STRINGS__, str);
936             }
937         }
938
939         // Force psubwin->logflags to linear
940         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LOG_FLAG__, false);
941         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LOG_FLAG__, false);
942         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LOG_FLAG__, false);
943
944         Boolean firstPlot = (Boolean) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_FIRST_PLOT__);
945
946         if (firstPlot && (flag[2] == 0 || flag[2] == 1)) {
947             /* Nothing to do */
948         } else {
949             if (flag[2] == 0 || flag[2] == 1) {
950                 if (firstPlot) {
951                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, false);
952                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, false);
953                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, false);
954
955                     // 0: OFF
956                     controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 0);
957
958                     Integer label = 0;
959                     label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
960                     controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
961                     label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
962                     controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
963                     label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
964                     controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
965                 }
966             } else if (flag[2] == 2) {
967                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, false);
968                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, false);
969                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, false);
970
971                 //2: HIDDEN_AXES
972                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 2);
973
974                 Integer label = 0;
975                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
976                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
977                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
978                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
979                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
980                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, false);
981
982             } else if (flag[2] == 3) {
983                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, false);
984                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, false);
985                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, false);
986
987                 //1: ON
988                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 1);
989
990                 Integer label = 0;
991                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
992                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
993                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
994                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
995                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
996                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
997
998             } else if (flag[2] == 4) {
999                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_VISIBLE__, true);
1000                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_VISIBLE__, true);
1001                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_VISIBLE__, true);
1002
1003                 //1: ON
1004                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_BOX_TYPE__, 1);
1005
1006                 Integer label = 0;
1007                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_X_AXIS_LABEL__);
1008                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
1009                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Y_AXIS_LABEL__);
1010                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
1011                 label = (Integer) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_Z_AXIS_LABEL__);
1012                 controller.setProperty(label, GraphicObjectProperties.__GO_VISIBLE__, true);
1013             }
1014         }
1015
1016         Double[] rotationAngles = new Double[] { alpha, theta };
1017         controller.setProperty(iSubwin, GraphicObjectProperties.__GO_ROTATION_ANGLES__, rotationAngles);
1018
1019         Double[] dataBounds = (Double[]) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_DATA_BOUNDS__);
1020         Boolean autoScale = (Boolean) controller.getProperty(iSubwin, GraphicObjectProperties.__GO_AUTO_SCALE__);
1021
1022         Double rect[] = new Double[] { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
1023         if (autoScale) {
1024             // compute and merge new specified bounds with data bounds
1025             switch (flag[1]) {
1026                 case 0:
1027                     break;
1028                 case 1:
1029                 case 3:
1030                 case 5:
1031                 case 7:
1032                     rect[0] = ebox[0]; // xmin
1033                     rect[1] = ebox[1]; // xmax
1034                     rect[2] = ebox[2]; // ymin
1035                     rect[3] = ebox[3]; // ymax
1036                     rect[4] = ebox[4]; // zmin
1037                     rect[5] = ebox[5]; // zmax
1038                     break;
1039                 case 2:
1040                 case 4:
1041                 case 6:
1042                 case 8:
1043                     double[] res = getDrect(x, rect[0], rect[1], dataBounds[0], dataBounds[1]);
1044                     rect[0] = res[0];
1045                     rect[1] = res[1];
1046
1047                     res = getDrect(y, rect[2], rect[3], dataBounds[2], dataBounds[3]);
1048                     rect[2] = res[0];
1049                     rect[3] = res[1];
1050
1051                     res = getDrect(z, rect[4], rect[5], dataBounds[4], dataBounds[5]);
1052                     rect[4] = res[0];
1053                     rect[5] = res[1];
1054                     break;
1055             }
1056
1057             if (firstPlot == false) {
1058                 rect[0] = Math.min(dataBounds[0], rect[0]); // xmin
1059                 rect[1] = Math.max(dataBounds[1], rect[1]); // xmax
1060                 rect[2] = Math.min(dataBounds[2], rect[2]); // ymin
1061                 rect[3] = Math.max(dataBounds[3], rect[3]); // ymax
1062                 rect[4] = Math.min(dataBounds[4], rect[4]); // zmin
1063                 rect[5] = Math.max(dataBounds[5], rect[5]); // zmax
1064             }
1065
1066             if (flag[1] != 0) {
1067                 controller.setProperty(iSubwin, GraphicObjectProperties.__GO_DATA_BOUNDS__, rect);
1068             }
1069         }
1070
1071         if (flag[1] != 0) {
1072             boolean isoview = (flag[1] == 3 || flag[1] == 4 || flag[1] == 5 || flag[1] == 6);
1073             controller.setProperty(iSubwin, GraphicObjectProperties.__GO_ISOVIEW__, isoview);
1074         }
1075     }
1076
1077     private static double[] getDrect(double[] x, double min, double max, double defaultMin, double defaultMax) {
1078         double refMax = Double.NEGATIVE_INFINITY;
1079         double refMin = Double.POSITIVE_INFINITY;
1080         boolean isInfinite = true;
1081
1082         for (int i = 0; i < x.length; i++) {
1083             Double tmp = x[i];
1084             if (tmp.isInfinite() == false && tmp.isNaN() == false) {
1085                 refMin = Math.min(refMin, tmp);
1086                 refMax = Math.max(refMax, tmp);
1087                 isInfinite = false;
1088             }
1089         }
1090
1091         if (isInfinite) {
1092             refMin = defaultMin;
1093             refMax = defaultMax;
1094         }
1095
1096         return new double[] { refMin, refMax };
1097     }
1098
1099     private static boolean isValidType(int type) {
1100         return type >= 0 && type <= 1;
1101     }
1102
1103     private static boolean isValidColor(double[] color) {
1104         return (color[0] >= 0.0 && color[0] <= 1.0) && (color[1] >= 0.0 && color[1] <= 1.0) && (color[2] >= 0.0 && color[2] <= 1.0);
1105     }
1106
1107     public static int createLight(int parent, int type, boolean visible, double[] pos, double[] dir, double[] ambient, double[] diffuse, double[] specular) {
1108         GraphicController controller = GraphicController.getController();
1109
1110         int iLight = controller.askObject(Type.LIGHT, false);
1111         Light light = (Light) controller.getObjectFromId(iLight);
1112
1113         light.setVisible(visible);
1114         if (isValidType(type)) {
1115             light.setLightType(LightType.intToEnum(type));
1116         }
1117
1118         if (pos.length == 3) {
1119             light.setPosition(toDouble(pos));
1120         }
1121
1122         if (dir.length == 3) {
1123             light.setDirection(toDouble(dir));
1124         }
1125         if (ambient.length == 3) {
1126             if (isValidColor(ambient)) {
1127                 light.setAmbientColor(toDouble(ambient));
1128             }
1129         }
1130         if (diffuse.length == 3) {
1131             if (isValidColor(diffuse)) {
1132                 light.setDiffuseColor(toDouble(diffuse));
1133             }
1134         }
1135         if (specular.length == 3) {
1136             if (isValidColor(specular)) {
1137                 light.setSpecularColor(toDouble(specular));
1138             }
1139         }
1140
1141         controller.objectCreated(iLight);
1142         // Set light's parent
1143         controller.setGraphicObjectRelationship(parent, iLight);
1144         return iLight;
1145     }
1146
1147     private static Double[] toDouble(double[] var) {
1148         Double[] ret = new Double[var.length];
1149         for (int i = 0; i < var.length; i++) {
1150             ret[i] = var[i];
1151         }
1152
1153         return ret;
1154     }
1155
1156     private static Integer[] toInteger(int[] var) {
1157         Integer[] ret = new Integer[var.length];
1158         for (int i = 0; i < var.length; i++) {
1159             ret[i] = var[i];
1160         }
1161
1162         return ret;
1163     }
1164 }