Bug 12496 fixed: zoom_rect could lead to a crash in log scale
[scilab.git] / scilab / modules / graphic_objects / src / java / org / scilab / modules / graphic_objects / axes / Axes.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Manuel JULIACHS
4  * Copyright (C) 2010 - DIGITEO - Bruno JOFRET
5  * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15 package org.scilab.modules.graphic_objects.axes;
16
17 import org.scilab.modules.graphic_objects.arc.Arc.ArcDrawingMethod;
18 import org.scilab.modules.graphic_objects.arc.Arc.ArcProperty;
19 import org.scilab.modules.graphic_objects.axes.AxisProperty.AxisLocation;
20 import org.scilab.modules.graphic_objects.axes.Box.BoxType;
21 import org.scilab.modules.graphic_objects.axes.Camera.ViewType;
22 import org.scilab.modules.graphic_objects.contouredObject.Line;
23 import org.scilab.modules.graphic_objects.contouredObject.Line.LinePropertyType;
24 import org.scilab.modules.graphic_objects.contouredObject.Line.LineType;
25 import org.scilab.modules.graphic_objects.contouredObject.Mark;
26 import org.scilab.modules.graphic_objects.contouredObject.Mark.MarkPropertyType;
27 import org.scilab.modules.graphic_objects.contouredObject.Mark.MarkSizeUnitType;
28 import org.scilab.modules.graphic_objects.figure.Figure;
29 import org.scilab.modules.graphic_objects.graphicController.GraphicController;
30 import org.scilab.modules.graphic_objects.graphicObject.ClippableProperty;
31 import org.scilab.modules.graphic_objects.graphicObject.ClippableProperty.ClipStateType;
32 import org.scilab.modules.graphic_objects.graphicObject.ClippableProperty.ClippablePropertyType;
33 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject;
34 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
35 import org.scilab.modules.graphic_objects.graphicObject.Visitor;
36 import org.scilab.modules.graphic_objects.textObject.FormattedText;
37 import org.scilab.modules.graphic_objects.lighting.ColorTriplet;
38 import org.scilab.modules.graphic_objects.lighting.Light;
39 import org.scilab.modules.graphic_objects.lighting.Light.LightProperty;
40
41 import java.util.ArrayList;
42
43 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.*;
44
45 /**
46  * Axes class
47  * @author Manuel JULIACHS
48  */
49 public class Axes extends GraphicObject {
50
51     private static final double BOUNDS_PARAMETER = 5;
52
53     /** Axes properties names */
54     private enum AxesProperty {
55         XAXISVISIBLE, XAXISREVERSE, XAXISGRIDCOLOR, XAXISLABEL, XAXISLOCATION, XAXISLOGFLAG,
56         XAXISTICKS, XAXISAUTOTICKS, XAXISNUMBERTICKS, XAXISTICKSLOCATIONS, XAXISTICKSLABELS, XAXISSUBTICKS,
57         YAXISVISIBLE, YAXISREVERSE, YAXISGRIDCOLOR, YAXISLABEL, YAXISLOCATION, YAXISLOGFLAG,
58         YAXISTICKS, YAXISAUTOTICKS, YAXISNUMBERTICKS, YAXISTICKSLOCATIONS, YAXISTICKSLABELS, YAXISSUBTICKS,
59         ZAXISVISIBLE, ZAXISREVERSE, ZAXISGRIDCOLOR, ZAXISLABEL, ZAXISLOCATION, ZAXISLOGFLAG,
60         ZAXISTICKS, ZAXISAUTOTICKS, ZAXISNUMBERTICKS, ZAXISTICKSLOCATIONS, ZAXISTICKSLABELS, ZAXISSUBTICKS,
61         AUTOSUBTICKS,
62         FONT_STYLE, FONT_SIZE, FONT_COLOR, FONT_FRACTIONAL,
63         GRIDPOSITION, TITLE, AUTOCLEAR, FILLED, BACKGROUND,
64         MARGINS, AXESBOUNDS,
65         HIDDENCOLOR
66     };
67
68     /** Specifies the grid position relative to the graphics entities */
69     public static enum GridPosition { BACKGROUND, FOREGROUND;
70
71                                       /**
72                                        * Converts an integer to the corresponding enum
73                                        * @param intValue the integer value
74                                        * @return the grid position enum
75                                        */
76     public static GridPosition intToEnum(Integer intValue) {
77         switch (intValue) {
78             case 0:
79                 return GridPosition.BACKGROUND;
80             case 1:
81                 return GridPosition.FOREGROUND;
82             default:
83                 return null;
84         }
85     }
86                                     };
87
88
89     /** 3-element array (properties of the X, Y and Z axes) */
90     private AxisProperty[] axes;
91
92     /**
93      * Specifies whether subticks are automatically computed or not
94      * Used as an internal state only
95      * Note: shared by the three axes to be compatible with the
96      * former flagNax internal state (autoSubticks is equivalent to !flagNax)
97      * This should eventually become a per-axis property (as the auto ticks flag).
98      */
99     private boolean autoSubticks;
100
101     /** Grid position */
102     private GridPosition gridPosition;
103
104     /** Title label known by its UID. */
105     private Integer title;
106
107     /** Specifies whether the Axes subwindow is cleared when a new plot command is performed */
108     private boolean autoClear;
109
110     /** Specifies whether the Axes background is filled or not  */
111     private boolean filled;
112
113     /** Axes background color and child objects default background color */
114     private int background;
115
116     /** Camera */
117     private Camera camera;
118
119     /** Box: properties related to the data bounds */
120     private Box box;
121
122     /** Margins enclosing the drawing area (left, right, top, bottom) */
123     private double[] margins;
124
125     /**
126      * Axes bounds relative to their parent figure's
127      * drawing area (upper-left corner x and y, width, height)
128      */
129     private double[] axesBounds;
130
131     /** Default hidden surfaces color */
132     private int hiddenColor;
133
134     /** Default Line properties */
135     private Line line;
136
137     /** Default Mark properties */
138     private Mark mark;
139
140     /** Default Arc drawing method */
141     private ArcDrawingMethod arcDrawingMethod;
142
143     /** Default ClippableProperty */
144     private ClippableProperty clipProperty;
145
146
147     /** Constructor */
148     public Axes() {
149         super();
150         axes = new AxisProperty[3];
151         axes[0] = new AxisProperty();
152         axes[1] = new AxisProperty();
153         axes[2] = new AxisProperty();
154         gridPosition = GridPosition.FOREGROUND;
155         title = 0;
156         autoClear = false;
157         filled = false;
158         camera = new Camera();
159         box = new Box();
160         margins = new double[4];
161         axesBounds = new double[4];
162
163         line = new Line();
164         mark = new Mark();
165         arcDrawingMethod = ArcDrawingMethod.LINES;
166         clipProperty = new ClippableProperty();
167     }
168
169     public Axes clone() {
170         Axes copy = (Axes) super.clone();
171
172         AxisProperty [] newAxes = new AxisProperty[3];
173
174         for (int i = 0; i < axes.length; i++) {
175             newAxes[i] = new AxisProperty(axes[i]);
176         }
177
178         copy.axes = newAxes;
179         copy.title = 0;
180         copy.camera = new Camera(this.camera);
181         copy.box = new Box(this.box);
182
183         double [] newMargins = new double[4];
184         for (int i = 0; i < this.margins.length; i++) {
185             newMargins[i] = this.margins[i];
186         }
187
188         copy.margins = newMargins;
189
190         double [] newAxesBounds = new double[4];
191         for (int i = 0; i < this.axesBounds.length; i++) {
192             newAxesBounds[i] = this.axesBounds[i];
193         }
194
195         copy.axesBounds = newAxesBounds;
196         copy.line = new Line(this.line);
197         copy.mark = new Mark(this.mark);
198         copy.clipProperty = new ClippableProperty(this.clipProperty);
199         copy.setValid(true);
200
201         return copy;
202     }
203
204     @Override
205     public void accept(Visitor visitor) {
206         visitor.visit(this);
207     }
208
209     /**
210      * Returns the enum associated to a property name
211      * @param propertyName the property name
212      * @return the property enum
213      */
214     public Object getPropertyFromName(int propertyName) {
215         switch (propertyName) {
216             case __GO_X_AXIS_VISIBLE__ :
217                 return AxesProperty.XAXISVISIBLE;
218             case __GO_X_AXIS_REVERSE__ :
219                 return AxesProperty.XAXISREVERSE;
220             case __GO_X_AXIS_GRID_COLOR__ :
221                 return AxesProperty.XAXISGRIDCOLOR;
222             case __GO_X_AXIS_LABEL__ :
223                 return AxesProperty.XAXISLABEL;
224             case __GO_X_AXIS_LOCATION__ :
225                 return AxesProperty.XAXISLOCATION;
226             case __GO_X_AXIS_LOG_FLAG__ :
227                 return AxesProperty.XAXISLOGFLAG;
228             case __GO_X_AXIS_TICKS__ :
229                 return AxesProperty.XAXISTICKS;
230             case __GO_X_AXIS_AUTO_TICKS__ :
231                 return AxesProperty.XAXISAUTOTICKS;
232             case __GO_X_AXIS_NUMBER_TICKS__ :
233                 return AxesProperty.XAXISNUMBERTICKS;
234             case __GO_X_AXIS_TICKS_LOCATIONS__:
235                 return AxesProperty.XAXISTICKSLOCATIONS;
236             case __GO_X_AXIS_TICKS_LABELS__ :
237                 return AxesProperty.XAXISTICKSLABELS;
238             case __GO_X_AXIS_SUBTICKS__ :
239                 return AxesProperty.XAXISSUBTICKS;
240             case __GO_Y_AXIS_VISIBLE__ :
241                 return AxesProperty.YAXISVISIBLE;
242             case __GO_Y_AXIS_REVERSE__ :
243                 return AxesProperty.YAXISREVERSE;
244             case __GO_Y_AXIS_GRID_COLOR__ :
245                 return AxesProperty.YAXISGRIDCOLOR;
246             case __GO_Y_AXIS_LABEL__ :
247                 return AxesProperty.YAXISLABEL;
248             case __GO_Y_AXIS_LOCATION__ :
249                 return AxesProperty.YAXISLOCATION;
250             case __GO_Y_AXIS_LOG_FLAG__ :
251                 return AxesProperty.YAXISLOGFLAG;
252             case __GO_Y_AXIS_TICKS__ :
253                 return AxesProperty.YAXISTICKS;
254             case __GO_Y_AXIS_AUTO_TICKS__ :
255                 return AxesProperty.YAXISAUTOTICKS;
256             case __GO_Y_AXIS_NUMBER_TICKS__ :
257                 return AxesProperty.YAXISNUMBERTICKS;
258             case __GO_Y_AXIS_TICKS_LOCATIONS__ :
259                 return AxesProperty.YAXISTICKSLOCATIONS;
260             case __GO_Y_AXIS_TICKS_LABELS__ :
261                 return AxesProperty.YAXISTICKSLABELS;
262             case __GO_Y_AXIS_SUBTICKS__ :
263                 return AxesProperty.YAXISSUBTICKS;
264             case __GO_Z_AXIS_VISIBLE__ :
265                 return AxesProperty.ZAXISVISIBLE;
266             case __GO_Z_AXIS_REVERSE__ :
267                 return AxesProperty.ZAXISREVERSE;
268             case __GO_Z_AXIS_GRID_COLOR__ :
269                 return AxesProperty.ZAXISGRIDCOLOR;
270             case __GO_Z_AXIS_LABEL__ :
271                 return AxesProperty.ZAXISLABEL;
272             case __GO_Z_AXIS_LOCATION__ :
273                 return AxesProperty.ZAXISLOCATION;
274             case __GO_Z_AXIS_LOG_FLAG__ :
275                 return AxesProperty.ZAXISLOGFLAG;
276             case __GO_Z_AXIS_TICKS__ :
277                 return AxesProperty.ZAXISTICKS;
278             case __GO_Z_AXIS_AUTO_TICKS__ :
279                 return AxesProperty.ZAXISAUTOTICKS;
280             case __GO_Z_AXIS_NUMBER_TICKS__ :
281                 return AxesProperty.ZAXISNUMBERTICKS;
282             case __GO_Z_AXIS_TICKS_LOCATIONS__ :
283                 return AxesProperty.ZAXISTICKSLOCATIONS;
284             case __GO_Z_AXIS_TICKS_LABELS__ :
285                 return AxesProperty.ZAXISTICKSLABELS;
286             case __GO_Z_AXIS_SUBTICKS__ :
287                 return AxesProperty.ZAXISSUBTICKS;
288             case __GO_AUTO_SUBTICKS__ :
289                 return AxesProperty.AUTOSUBTICKS;
290             case __GO_FONT_STYLE__ :
291                 return AxesProperty.FONT_STYLE;
292             case __GO_FONT_SIZE__ :
293                 return AxesProperty.FONT_SIZE;
294             case __GO_FONT_COLOR__ :
295                 return AxesProperty.FONT_COLOR;
296             case __GO_FONT_FRACTIONAL__ :
297                 return AxesProperty.FONT_FRACTIONAL;
298             case __GO_GRID_POSITION__ :
299                 return AxesProperty.GRIDPOSITION;
300             case __GO_TITLE__ :
301                 return AxesProperty.TITLE;
302             case __GO_AUTO_CLEAR__ :
303                 return AxesProperty.AUTOCLEAR;
304             case __GO_FILLED__ :
305                 return AxesProperty.FILLED;
306             case __GO_BACKGROUND__ :
307                 return AxesProperty.BACKGROUND;
308             case __GO_VIEW__ :
309                 return Camera.CameraProperty.VIEW;
310             case __GO_ISOVIEW__ :
311                 return Camera.CameraProperty.ISOVIEW;
312             case __GO_CUBE_SCALING__ :
313                 return Camera.CameraProperty.CUBESCALING;
314             case __GO_ROTATION_ANGLES__ :
315                 return Camera.CameraProperty.ROTATIONANGLES;
316             case __GO_ROTATION_ANGLES_3D__ :
317                 return Camera.CameraProperty.ROTATIONANGLES3D;
318             case __GO_BOX_TYPE__ :
319                 return Box.BoxProperty.BOX;
320             case __GO_HIDDEN_AXIS_COLOR__ :
321                 return Box.BoxProperty.HIDDENAXISCOLOR;
322             case __GO_TIGHT_LIMITS__ :
323                 return Box.BoxProperty.TIGHTLIMITS;
324             case __GO_DATA_BOUNDS__ :
325                 return Box.BoxProperty.DATABOUNDS;
326             case __GO_REAL_DATA_BOUNDS__ :
327                 return Box.BoxProperty.REALDATABOUNDS;
328             case __GO_ZOOM_ENABLED__ :
329                 return Box.BoxProperty.ZOOMENABLED;
330             case __GO_ZOOM_BOX__ :
331                 return Box.BoxProperty.ZOOMBOX;
332             case __GO_AUTO_SCALE__ :
333                 return Box.BoxProperty.AUTOSCALE;
334             case __GO_FIRST_PLOT__ :
335                 return Box.BoxProperty.FIRSTPLOT;
336             case __GO_MARGINS__ :
337                 return AxesProperty.MARGINS;
338             case __GO_AXES_BOUNDS__ :
339                 return AxesProperty.AXESBOUNDS;
340             case __GO_HIDDEN_COLOR__ :
341                 return AxesProperty.HIDDENCOLOR;
342             case __GO_LINE_MODE__ :
343                 return LinePropertyType.MODE;
344             case __GO_LINE_STYLE__ :
345                 return LinePropertyType.LINESTYLE;
346             case __GO_LINE_THICKNESS__ :
347                 return LinePropertyType.THICKNESS;
348             case __GO_LINE_COLOR__ :
349                 return LinePropertyType.COLOR;
350             case __GO_MARK_MODE__ :
351                 return MarkPropertyType.MODE;
352             case __GO_MARK_STYLE__ :
353                 return MarkPropertyType.STYLE;
354             case __GO_MARK_SIZE_UNIT__ :
355                 return MarkPropertyType.SIZEUNIT;
356             case __GO_MARK_SIZE__ :
357                 return MarkPropertyType.SIZE;
358             case __GO_MARK_FOREGROUND__ :
359                 return MarkPropertyType.FOREGROUND;
360             case __GO_MARK_BACKGROUND__ :
361                 return MarkPropertyType.BACKGROUND;
362             case __GO_CLIP_STATE__ :
363                 return ClippablePropertyType.CLIPSTATE;
364             case __GO_CLIP_BOX__ :
365                 return ClippablePropertyType.CLIPBOX;
366             case __GO_CLIP_BOX_SET__ :
367                 return ClippablePropertyType.CLIPBOXSET;
368             case __GO_ARC_DRAWING_METHOD__ :
369                 return ArcProperty.ARCDRAWINGMETHOD;
370             default :
371                 return super.getPropertyFromName(propertyName);
372         }
373     }
374
375     /**
376      * Fast property get method
377      * @param property the property to get
378      * @return the property value
379      */
380     public Object getProperty(Object property) {
381         if (property instanceof AxesProperty) {
382             AxesProperty ap = (AxesProperty) property;
383             switch (ap) {
384                 case XAXISVISIBLE:
385                     return getXAxisVisible();
386                 case XAXISREVERSE:
387                     return getXAxisReverse();
388                 case XAXISGRIDCOLOR:
389                     return getXAxisGridColor();
390                 case XAXISLABEL:
391                     return getXAxisLabel();
392                 case XAXISLOCATION:
393                     return getXAxisLocation();
394                 case XAXISLOGFLAG:
395                     return getXAxisLogFlag();
396                 case XAXISTICKS:
397                     return getXAxisTicks();
398                 case XAXISAUTOTICKS:
399                     return getXAxisAutoTicks();
400                 case XAXISNUMBERTICKS:
401                     return getXAxisNumberTicks();
402                 case XAXISTICKSLOCATIONS:
403                     return getXAxisTicksLocations();
404                 case XAXISTICKSLABELS:
405                     return getXAxisTicksLabels();
406                 case XAXISSUBTICKS:
407                     return getXAxisSubticks();
408                 case YAXISVISIBLE:
409                     return getYAxisVisible();
410                 case YAXISREVERSE:
411                     return getYAxisReverse();
412                 case YAXISGRIDCOLOR:
413                     return getYAxisGridColor();
414                 case YAXISLABEL:
415                     return getYAxisLabel();
416                 case YAXISLOCATION:
417                     return getYAxisLocation();
418                 case YAXISLOGFLAG:
419                     return getYAxisLogFlag();
420                 case YAXISTICKS:
421                     return getYAxisTicks();
422                 case YAXISAUTOTICKS:
423                     return getYAxisAutoTicks();
424                 case YAXISNUMBERTICKS:
425                     return getYAxisNumberTicks();
426                 case YAXISTICKSLOCATIONS:
427                     return getYAxisTicksLocations();
428                 case YAXISTICKSLABELS:
429                     return getYAxisTicksLabels();
430                 case YAXISSUBTICKS:
431                     return getYAxisSubticks();
432                 case ZAXISVISIBLE:
433                     return getZAxisVisible();
434                 case ZAXISREVERSE:
435                     return getZAxisReverse();
436                 case ZAXISGRIDCOLOR:
437                     return getZAxisGridColor();
438                 case ZAXISLABEL:
439                     return getZAxisLabel();
440                 case ZAXISLOCATION:
441                     return getZAxisLocation();
442                 case ZAXISLOGFLAG:
443                     return getZAxisLogFlag();
444                 case ZAXISTICKS:
445                     return getZAxisTicks();
446                 case ZAXISAUTOTICKS:
447                     return getZAxisAutoTicks();
448                 case ZAXISNUMBERTICKS:
449                     return getZAxisNumberTicks();
450                 case ZAXISTICKSLOCATIONS:
451                     return getZAxisTicksLocations();
452                 case ZAXISTICKSLABELS:
453                     return getZAxisTicksLabels();
454                 case ZAXISSUBTICKS:
455                     return getZAxisSubticks();
456                 case AUTOSUBTICKS:
457                     return getAutoSubticks();
458                 case FONT_STYLE:
459                     return getFontStyle();
460                 case FONT_SIZE:
461                     return getFontSize();
462                 case FONT_COLOR:
463                     return getFontColor();
464                 case FONT_FRACTIONAL:
465                     return getFontFractional();
466                 case GRIDPOSITION:
467                     return getGridPosition();
468                 case TITLE:
469                     return getTitle();
470                 case AUTOCLEAR:
471                     return getAutoClear();
472                 case FILLED:
473                     return getFilled();
474                 case BACKGROUND:
475                     return getBackground();
476                 case MARGINS:
477                     return getMargins();
478                 case AXESBOUNDS:
479                     return getAxesBounds();
480                 case HIDDENCOLOR:
481                     return getHiddenColor();
482             }
483         } else if (property instanceof Camera.CameraProperty) {
484             Camera.CameraProperty cp = (Camera.CameraProperty) property;
485             switch (cp) {
486                 case VIEW:
487                     return getView();
488                 case ISOVIEW:
489                     return getIsoview();
490                 case CUBESCALING:
491                     return getCubeScaling();
492                 case ROTATIONANGLES:
493                     return getRotationAngles();
494                 case ROTATIONANGLES3D:
495                     return getRotationAngles3d();
496             }
497         } else if (property instanceof Box.BoxProperty) {
498             Box.BoxProperty bp = (Box.BoxProperty) property;
499             switch (bp) {
500                 case BOX:
501                     return getBoxType();
502                 case HIDDENAXISCOLOR:
503                     return getHiddenAxisColor();
504                 case TIGHTLIMITS:
505                     return getTightLimits();
506                 case DATABOUNDS:
507                     return getDataBounds();
508                 case REALDATABOUNDS:
509                     return getRealDataBounds();
510                 case ZOOMENABLED:
511                     return getZoomEnabled();
512                 case ZOOMBOX:
513                     return getZoomBox();
514                 case AUTOSCALE:
515                     return getAutoScale();
516                 case FIRSTPLOT:
517                     return getFirstPlot();
518             }
519         } else if (property instanceof LinePropertyType) {
520             LinePropertyType lp = (LinePropertyType) property;
521             switch (lp) {
522                 case MODE:
523                     return getLineMode();
524                 case LINESTYLE:
525                     return getLineStyle();
526                 case THICKNESS:
527                     return getLineThickness();
528                 case COLOR:
529                     return getLineColor();
530             }
531         } else if (property instanceof MarkPropertyType) {
532             MarkPropertyType mp = (MarkPropertyType) property;
533             switch (mp) {
534                 case MODE:
535                     return getMarkMode();
536                 case STYLE:
537                     return getMarkStyle();
538                 case SIZE:
539                     return getMarkSize();
540                 case SIZEUNIT:
541                     return getMarkSizeUnit();
542                 case FOREGROUND:
543                     return getMarkForeground();
544                 case BACKGROUND:
545                     return getMarkBackground();
546             }
547         } else if (property instanceof ClippablePropertyType) {
548             ClippablePropertyType cp = (ClippablePropertyType) property;
549             switch (cp) {
550                 case CLIPSTATE:
551                     return getClipState();
552                 case CLIPBOX:
553                     return getClipBox();
554                 case CLIPBOXSET:
555                     return getClipBoxSet();
556             }
557         } else if (property == ArcProperty.ARCDRAWINGMETHOD) {
558             return getArcDrawingMethod();
559         }
560
561         return super.getProperty(property);
562     }
563
564     /**
565      * Fast property set method
566      * @param property the property to set
567      * @param value the property value
568      * @return true if the property has been set, false otherwise
569      */
570     public UpdateStatus setProperty(Object property, Object value) {
571         if (property instanceof AxesProperty) {
572             AxesProperty ap = (AxesProperty) property;
573             switch (ap) {
574                 case XAXISVISIBLE:
575                     return setXAxisVisible((Boolean) value);
576                 case XAXISREVERSE:
577                     return setXAxisReverse((Boolean) value);
578                 case XAXISGRIDCOLOR:
579                     return setXAxisGridColor((Integer) value);
580                 case XAXISLABEL:
581                     return setXAxisLabel((Integer) value);
582                 case XAXISLOCATION:
583                     return setXAxisLocation((Integer) value);
584                 case XAXISLOGFLAG:
585                     return setXAxisLogFlag((Boolean) value);
586                 case XAXISTICKS:
587                     return setXAxisTicks((TicksProperty) value);
588                 case XAXISAUTOTICKS:
589                     return setXAxisAutoTicks((Boolean) value);
590                 case XAXISTICKSLOCATIONS:
591                     return setXAxisTicksLocations((Double[]) value);
592                 case XAXISTICKSLABELS:
593                     return setXAxisTicksLabels((String[]) value);
594                 case XAXISSUBTICKS:
595                     return setXAxisSubticks((Integer) value);
596                 case YAXISVISIBLE:
597                     return setYAxisVisible((Boolean) value);
598                 case YAXISREVERSE:
599                     return setYAxisReverse((Boolean) value);
600                 case YAXISGRIDCOLOR:
601                     return setYAxisGridColor((Integer) value);
602                 case YAXISLABEL:
603                     return setYAxisLabel((Integer) value);
604                 case YAXISLOCATION:
605                     return setYAxisLocation((Integer) value);
606                 case YAXISLOGFLAG:
607                     return setYAxisLogFlag((Boolean) value);
608                 case YAXISTICKS:
609                     return setYAxisTicks((TicksProperty) value);
610                 case YAXISAUTOTICKS:
611                     return setYAxisAutoTicks((Boolean) value);
612                 case YAXISTICKSLOCATIONS:
613                     return setYAxisTicksLocations((Double[]) value);
614                 case YAXISTICKSLABELS:
615                     return setYAxisTicksLabels((String[]) value);
616                 case YAXISSUBTICKS:
617                     return setYAxisSubticks((Integer) value);
618                 case ZAXISVISIBLE:
619                     return setZAxisVisible((Boolean) value);
620                 case ZAXISREVERSE:
621                     return setZAxisReverse((Boolean) value);
622                 case ZAXISGRIDCOLOR:
623                     return setZAxisGridColor((Integer) value);
624                 case ZAXISLABEL:
625                     return setZAxisLabel((Integer) value);
626                 case ZAXISLOCATION:
627                     return setZAxisLocation((Integer) value);
628                 case ZAXISLOGFLAG:
629                     return setZAxisLogFlag((Boolean) value);
630                 case ZAXISTICKS:
631                     return setZAxisTicks((TicksProperty) value);
632                 case ZAXISAUTOTICKS:
633                     return setZAxisAutoTicks((Boolean) value);
634                 case ZAXISTICKSLOCATIONS:
635                     return setZAxisTicksLocations((Double[]) value);
636                 case ZAXISTICKSLABELS:
637                     return setZAxisTicksLabels((String[]) value);
638                 case ZAXISSUBTICKS:
639                     return setZAxisSubticks((Integer) value);
640                 case AUTOSUBTICKS:
641                     return setAutoSubticks((Boolean) value);
642                 case FONT_STYLE:
643                     return setFontStyle((Integer) value);
644                 case FONT_SIZE:
645                     return setFontSize((Double) value);
646                 case FONT_COLOR:
647                     return setFontColor((Integer) value);
648                 case FONT_FRACTIONAL:
649                     return setFontFractional((Boolean) value);
650                 case GRIDPOSITION:
651                     return setGridPosition((Integer) value);
652                 case TITLE:
653                     return setTitle((Integer) value);
654                 case AUTOCLEAR:
655                     return setAutoClear((Boolean) value);
656                 case FILLED:
657                     return setFilled((Boolean) value);
658                 case BACKGROUND:
659                     return setBackground((Integer) value);
660                 case MARGINS:
661                     return setMargins((Double[]) value);
662                 case AXESBOUNDS:
663                     return setAxesBounds((Double[]) value);
664                 case HIDDENCOLOR:
665                     return setHiddenColor((Integer) value);
666             }
667         } else if (property instanceof Camera.CameraProperty) {
668             Camera.CameraProperty cp = (Camera.CameraProperty) property;
669             switch (cp) {
670                 case VIEW:
671                     return setView((Integer) value);
672                 case ISOVIEW:
673                     return setIsoview((Boolean) value);
674                 case CUBESCALING:
675                     return setCubeScaling((Boolean) value);
676                 case ROTATIONANGLES:
677                     return setRotationAngles((Double[]) value);
678                 case ROTATIONANGLES3D:
679                     return setRotationAngles3d((Double[]) value);
680             }
681         } else if (property instanceof Box.BoxProperty) {
682             Box.BoxProperty bp = (Box.BoxProperty) property;
683             switch (bp) {
684                 case BOX:
685                     return setBoxType((Integer) value);
686                 case HIDDENAXISCOLOR:
687                     return setHiddenAxisColor((Integer) value);
688                 case TIGHTLIMITS:
689                     return setTightLimits((Boolean) value);
690                 case DATABOUNDS:
691                     return setDataBounds((Double[]) value);
692                 case REALDATABOUNDS:
693                     return setRealDataBounds((Double[]) value);
694                 case ZOOMENABLED:
695                     return setZoomEnabled((Boolean) value);
696                 case ZOOMBOX:
697                     return setZoomBox((Double[]) value);
698                 case AUTOSCALE:
699                     return setAutoScale((Boolean) value);
700                 case FIRSTPLOT:
701                     return setFirstPlot((Boolean) value);
702             }
703         } else if (property instanceof LinePropertyType) {
704             LinePropertyType lp = (LinePropertyType) property;
705             switch (lp) {
706                 case MODE:
707                     return setLineMode((Boolean) value);
708                 case LINESTYLE:
709                     return setLineStyle((Integer) value);
710                 case THICKNESS:
711                     return setLineThickness((Double) value);
712                 case COLOR:
713                     return setLineColor((Integer) value);
714             }
715         } else if (property instanceof MarkPropertyType) {
716             MarkPropertyType mp = (MarkPropertyType) property;
717             switch (mp) {
718                 case MODE:
719                     return setMarkMode((Boolean) value);
720                 case STYLE:
721                     return setMarkStyle((Integer) value);
722                 case SIZE:
723                     return setMarkSize((Integer) value);
724                 case SIZEUNIT:
725                     return setMarkSizeUnit((Integer) value);
726                 case FOREGROUND:
727                     return setMarkForeground((Integer) value);
728                 case BACKGROUND:
729                     return setMarkBackground((Integer) value);
730             }
731         } else if (property instanceof ClippablePropertyType) {
732             ClippablePropertyType cp = (ClippablePropertyType) property;
733             switch (cp) {
734                 case CLIPSTATE:
735                     return setClipState((Integer) value);
736                 case CLIPBOX:
737                     return setClipBox((Double[]) value);
738                 case CLIPBOXSET:
739                     return setClipBoxSet((Boolean) value);
740             }
741         } else if (property == ArcProperty.ARCDRAWINGMETHOD) {
742             return setArcDrawingMethod((Integer) value);
743         }
744
745         return super.setProperty(property, value);
746     }
747
748     /**
749      * @return the autoClear
750      */
751     public Boolean getAutoClear() {
752         return autoClear;
753     }
754
755     /**
756      * @param autoClear the autoClear to set
757      */
758     public UpdateStatus setAutoClear(Boolean autoClear) {
759         if (autoClear != this.autoClear) {
760             this.autoClear = autoClear;
761             return UpdateStatus.Success;
762         }
763
764         return UpdateStatus.NoChange;
765     }
766
767     /**
768      * @return the axes
769      */
770     public AxisProperty[] getAxes() {
771         return axes;
772     }
773
774     /**
775      * @param axes the axes to set
776      */
777     public UpdateStatus setAxes(AxisProperty[] axes) {
778         this.axes = axes;
779
780         return UpdateStatus.Success;
781     }
782
783     /**
784      * @return the x axis
785      */
786     public AxisProperty getXAxis() {
787         return axes[0];
788     }
789
790     /**
791      * @param xAxis the x axis to set
792      */
793     public UpdateStatus setXAxis(AxisProperty xAxis) {
794         axes[0] = xAxis;
795
796         return UpdateStatus.Success;
797     }
798
799     /**
800      * @return the x axis visible
801      */
802     public Boolean getXAxisVisible() {
803         return axes[0].getVisible();
804     }
805
806     /**
807      * @param visible the x axis visible to set
808      */
809     public UpdateStatus setXAxisVisible(Boolean visible) {
810         return axes[0].setVisible(visible);
811     }
812
813     /**
814      * @return the x axis reverse
815      */
816     public Boolean getXAxisReverse() {
817         return axes[0].getReverse();
818     }
819
820     /**
821      * @param reverse the x axis reverse to set
822      */
823     public UpdateStatus setXAxisReverse(Boolean reverse) {
824         return axes[0].setReverse(reverse);
825     }
826
827     /**
828      * @return the x axis grid color
829      */
830     public Integer getXAxisGridColor() {
831         return axes[0].getGridColor();
832     }
833
834     /**
835      * @param gridColor the x axis grid color to set
836      */
837     public UpdateStatus setXAxisGridColor(Integer gridColor) {
838         return axes[0].setGridColor(gridColor);
839     }
840
841     /**
842      * @return the x axis label UID
843      */
844     public Integer getXAxisLabel() {
845         return axes[0].getLabel();
846     }
847
848     /**
849      * @param label the x axis label to set
850      */
851     public UpdateStatus setXAxisLabel(Integer label) {
852         return axes[0].setLabel(label);
853     }
854
855     /**
856      * @return the x axis location
857      */
858     public Integer getXAxisLocation() {
859         return getXAxisLocationAsEnum().ordinal();
860     }
861
862     /**
863      * @return the x axis location
864      */
865     public AxisLocation getXAxisLocationAsEnum() {
866         return axes[0].getAxisLocation();
867     }
868
869     /**
870      * @param axisLocation the x axis location to set
871      */
872     public UpdateStatus setXAxisLocation(Integer axisLocation) {
873         return setXAxisLocationAsEnum(AxisLocation.intToEnum(axisLocation));
874     }
875
876     /**
877      * @param axisLocation the x axis location to set
878      */
879     public UpdateStatus setXAxisLocationAsEnum(AxisLocation axisLocation) {
880         return axes[0].setAxisLocation(axisLocation);
881     }
882
883     /**
884      * @return the x axis log flag
885      */
886     public Boolean getXAxisLogFlag() {
887         return axes[0].getLogFlag();
888     }
889
890     /**
891      * @param logFlag the x axis log flag to set
892      */
893     public UpdateStatus setXAxisLogFlag(Boolean logFlag) {
894         return axes[0].setLogFlag(logFlag);
895     }
896
897     /**
898      * @return the x axis ticks
899      */
900     public TicksProperty getXAxisTicks() {
901         return axes[0].getTicks();
902     }
903
904     /**
905      * @param ticks the x axis ticks to set
906      */
907     public UpdateStatus setXAxisTicks(TicksProperty ticks) {
908         return axes[0].setTicks(ticks);
909     }
910
911     /**
912      * @return the x axis autoticks
913      */
914     public Boolean getXAxisAutoTicks() {
915         return axes[0].getAutoTicks();
916     }
917
918     /**
919      * @param autoTicks the x axis autoticks to set
920      */
921     public UpdateStatus setXAxisAutoTicks(Boolean autoTicks) {
922         return axes[0].setAutoTicks(autoTicks);
923     }
924
925     /**
926      * @return the x axis number of ticks
927      */
928     public Integer getXAxisNumberTicks() {
929         return axes[0].getNumberOfTicks();
930     }
931
932     /**
933      * @return the x axis ticks locations
934      */
935     public Double[] getXAxisTicksLocations() {
936         return axes[0].getTicksLocations();
937     }
938
939     /**
940      * @param ticksLocations the x axis ticks locations to set
941      */
942     public UpdateStatus setXAxisTicksLocations(Double[] ticksLocations) {
943         return axes[0].setTicksLocations(ticksLocations);
944     }
945
946     /**
947      * @return the x axis ticks labels
948      */
949     public String[] getXAxisTicksLabels() {
950         return axes[0].getTicksLabelsStrings();
951     }
952
953     /**
954      * @return the x axis ticks labels
955      */
956     public ArrayList<FormattedText> getXAxisTicksLabelsAsArrayList() {
957         return axes[0].getTicksLabels();
958     }
959
960     /**
961      * @param labels the x axis ticks labels to set
962      */
963     public UpdateStatus setXAxisTicksLabels(String[] labels) {
964         return axes[0].setTicksLabelsStrings(labels);
965     }
966
967     /**
968      * @param labels the x axis ticks labels to set
969      */
970     public UpdateStatus setXAxisTicksLabelsAsArrayList(ArrayList<FormattedText> labels) {
971         return axes[0].setTicksLabels(labels);
972     }
973
974     /**
975      * @return the x axis number of subticks
976      */
977     public Integer getXAxisSubticks() {
978         return axes[0].getSubticks();
979     }
980
981     /**
982      * @param subticks the x axis number of subticks to set
983      */
984     public UpdateStatus setXAxisSubticks(Integer subticks) {
985         return axes[0].setSubticks(subticks);
986     }
987
988     /**
989      * @return the y axis
990      */
991     public AxisProperty getYAxis() {
992         return axes[1];
993     }
994
995     /**
996      * @param yAxis the y axis to set
997      */
998     public UpdateStatus setYAxis(AxisProperty yAxis) {
999         axes[1] = yAxis;
1000
1001         return UpdateStatus.Success;
1002     }
1003
1004     /**
1005      * @return the y axis visible
1006      */
1007     public Boolean getYAxisVisible() {
1008         return axes[1].getVisible();
1009     }
1010
1011     /**
1012      * @param visible the y axis visible to set
1013      */
1014     public UpdateStatus setYAxisVisible(Boolean visible) {
1015         return axes[1].setVisible(visible);
1016     }
1017
1018     /**
1019      * @return the y axis reverse
1020      */
1021     public Boolean getYAxisReverse() {
1022         return axes[1].getReverse();
1023     }
1024
1025     /**
1026      * @param reverse the y axis reverse to set
1027      */
1028     public UpdateStatus setYAxisReverse(Boolean reverse) {
1029         return axes[1].setReverse(reverse);
1030     }
1031
1032     /**
1033      * @return the y axis grid color
1034      */
1035     public Integer getYAxisGridColor() {
1036         return axes[1].getGridColor();
1037     }
1038
1039     /**
1040      * @param gridColor the y axis grid color to set
1041      */
1042     public UpdateStatus setYAxisGridColor(Integer gridColor) {
1043         return axes[1].setGridColor(gridColor);
1044     }
1045
1046     /**
1047      * @return the y axis label UID
1048      */
1049     public Integer getYAxisLabel() {
1050         return axes[1].getLabel();
1051     }
1052
1053     /**
1054      * @param label the y axis label to set
1055      */
1056     public UpdateStatus setYAxisLabel(Integer label) {
1057         return axes[1].setLabel(label);
1058     }
1059
1060     /**
1061      * @return the y axis location
1062      */
1063     public Integer getYAxisLocation() {
1064         return getYAxisLocationAsEnum().ordinal();
1065     }
1066
1067     /**
1068      * @return the y axis location
1069      */
1070     public AxisLocation getYAxisLocationAsEnum() {
1071         return axes[1].getAxisLocation();
1072     }
1073
1074     /**
1075      * @param axisLocation the y axis location to set
1076      */
1077     public UpdateStatus setYAxisLocation(Integer axisLocation) {
1078         return setYAxisLocationAsEnum(AxisLocation.intToEnum(axisLocation));
1079     }
1080
1081     /**
1082      * @param axisLocation the y axis location to set
1083      */
1084     public UpdateStatus setYAxisLocationAsEnum(AxisLocation axisLocation) {
1085         return axes[1].setAxisLocation(axisLocation);
1086     }
1087
1088     /**
1089      * @return the y axis log flag
1090      */
1091     public Boolean getYAxisLogFlag() {
1092         return axes[1].getLogFlag();
1093     }
1094
1095     /**
1096      * @param logFlag the y axis log flag to set
1097      */
1098     public UpdateStatus setYAxisLogFlag(Boolean logFlag) {
1099         return axes[1].setLogFlag(logFlag);
1100     }
1101
1102     /**
1103      * @return the y axis ticks
1104      */
1105     public TicksProperty getYAxisTicks() {
1106         return axes[1].getTicks();
1107     }
1108
1109     /**
1110      * @param ticks the y axis ticks to set
1111      */
1112     public UpdateStatus setYAxisTicks(TicksProperty ticks) {
1113         return axes[1].setTicks(ticks);
1114     }
1115
1116     /**
1117      * @return the y axis autoticks
1118      */
1119     public Boolean getYAxisAutoTicks() {
1120         return axes[1].getAutoTicks();
1121     }
1122
1123     /**
1124      * @param autoTicks the y axis autoticks to set
1125      */
1126     public UpdateStatus setYAxisAutoTicks(Boolean autoTicks) {
1127         return axes[1].setAutoTicks(autoTicks);
1128     }
1129
1130     /**
1131      * @return the y axis number of ticks
1132      */
1133     public Integer getYAxisNumberTicks() {
1134         return axes[1].getNumberOfTicks();
1135     }
1136
1137     /**
1138      * @return the y axis ticks locations
1139      */
1140     public Double[] getYAxisTicksLocations() {
1141         return axes[1].getTicksLocations();
1142     }
1143
1144     /**
1145      * @param ticksLocations the y axis ticks locations to set
1146      */
1147     public UpdateStatus setYAxisTicksLocations(Double[] ticksLocations) {
1148         return axes[1].setTicksLocations(ticksLocations);
1149     }
1150
1151     /**
1152      * @return the y axis ticks labels
1153      */
1154     public String[] getYAxisTicksLabels() {
1155         return axes[1].getTicksLabelsStrings();
1156     }
1157
1158     /**
1159      * @return the y axis ticks labels
1160      */
1161     public ArrayList<FormattedText> getYAxisTicksLabelsAsArrayList() {
1162         return axes[1].getTicksLabels();
1163     }
1164
1165     /**
1166      * @param labels the y axis ticks labels to set
1167      */
1168     public UpdateStatus setYAxisTicksLabels(String[] labels) {
1169         return axes[1].setTicksLabelsStrings(labels);
1170     }
1171
1172     /**
1173      * @param labels the y axis ticks labels to set
1174      */
1175     public UpdateStatus setYAxisTicksLabelsAsArrayList(ArrayList<FormattedText> labels) {
1176         return axes[1].setTicksLabels(labels);
1177     }
1178
1179     /**
1180      * @return the y axis number of subticks
1181      */
1182     public Integer getYAxisSubticks() {
1183         return axes[1].getSubticks();
1184     }
1185
1186     /**
1187      * @param subticks the y axis number of subticks to set
1188      */
1189     public UpdateStatus setYAxisSubticks(Integer subticks) {
1190         return axes[1].setSubticks(subticks);
1191     }
1192
1193     /**
1194      * @return the z axis
1195      */
1196     public AxisProperty getZAxis() {
1197         return axes[2];
1198     }
1199
1200     /**
1201      * @param zAxis the z axis to set
1202      */
1203     public UpdateStatus setZAxis(AxisProperty zAxis) {
1204         axes[2] = zAxis;
1205
1206         return UpdateStatus.Success;
1207     }
1208
1209     /**
1210      * @return the z axis visible
1211      */
1212     public Boolean getZAxisVisible() {
1213         return axes[2].getVisible();
1214     }
1215
1216     /**
1217      * @param visible the z axis visible to set
1218      */
1219     public UpdateStatus setZAxisVisible(Boolean visible) {
1220         return axes[2].setVisible(visible);
1221     }
1222
1223     /**
1224      * @return the z axis reverse
1225      */
1226     public Boolean getZAxisReverse() {
1227         return axes[2].getReverse();
1228     }
1229
1230     /**
1231      * @param reverse the z axis reverse to set
1232      */
1233     public UpdateStatus setZAxisReverse(Boolean reverse) {
1234         return axes[2].setReverse(reverse);
1235     }
1236
1237     /**
1238      * @return the z axis grid color
1239      */
1240     public Integer getZAxisGridColor() {
1241         return axes[2].getGridColor();
1242     }
1243
1244     /**
1245      * @param gridColor the z axis grid color to set
1246      */
1247     public UpdateStatus setZAxisGridColor(Integer gridColor) {
1248         return axes[2].setGridColor(gridColor);
1249     }
1250
1251     /**
1252      * @return the z axis label UID
1253      */
1254     public Integer getZAxisLabel() {
1255         return axes[2].getLabel();
1256     }
1257
1258     /**
1259      * @param label the z axis label to set
1260      */
1261     public UpdateStatus setZAxisLabel(Integer label) {
1262         return axes[2].setLabel(label);
1263     }
1264
1265     /**
1266      * @return the z axis location
1267      */
1268     public Integer getZAxisLocation() {
1269         return getZAxisLocationAsEnum().ordinal();
1270     }
1271
1272     /**
1273      * @return the z axis location
1274      */
1275     public AxisLocation getZAxisLocationAsEnum() {
1276         return axes[2].getAxisLocation();
1277     }
1278
1279     /**
1280      * @param axisLocation the z axis location to set
1281      */
1282     public UpdateStatus setZAxisLocation(Integer axisLocation) {
1283         return setZAxisLocationAsEnum(AxisLocation.intToEnum(axisLocation));
1284     }
1285
1286     /**
1287      * @param axisLocation the z axis location to set
1288      */
1289     public UpdateStatus setZAxisLocationAsEnum(AxisLocation axisLocation) {
1290         return axes[2].setAxisLocation(axisLocation);
1291     }
1292
1293     /**
1294      * @return the z axis log flag
1295      */
1296     public Boolean getZAxisLogFlag() {
1297         return axes[2].getLogFlag();
1298     }
1299
1300     /**
1301      * @param logFlag the z axis log flag to set
1302      */
1303     public UpdateStatus setZAxisLogFlag(Boolean logFlag) {
1304         return axes[2].setLogFlag(logFlag);
1305     }
1306
1307     /**
1308      * @return the z axis ticks
1309      */
1310     public TicksProperty getZAxisTicks() {
1311         return axes[2].getTicks();
1312     }
1313
1314     /**
1315      * @param ticks the z axis ticks to set
1316      */
1317     public UpdateStatus setZAxisTicks(TicksProperty ticks) {
1318         return axes[2].setTicks(ticks);
1319     }
1320
1321     /**
1322      * @return the z axis autoticks
1323      */
1324     public Boolean getZAxisAutoTicks() {
1325         return axes[2].getAutoTicks();
1326     }
1327
1328     /**
1329      * @param autoTicks the z axis autoticks to set
1330      */
1331     public UpdateStatus setZAxisAutoTicks(Boolean autoTicks) {
1332         return axes[2].setAutoTicks(autoTicks);
1333     }
1334
1335     /**
1336      * @return the z axis number of ticks
1337      */
1338     public Integer getZAxisNumberTicks() {
1339         return axes[2].getNumberOfTicks();
1340     }
1341
1342     /**
1343      * @return the z axis ticks locations
1344      */
1345     public Double[] getZAxisTicksLocations() {
1346         return axes[2].getTicksLocations();
1347     }
1348
1349     /**
1350      * @param ticksLocations the z axis ticks locations to set
1351      */
1352     public UpdateStatus setZAxisTicksLocations(Double[] ticksLocations) {
1353         return axes[2].setTicksLocations(ticksLocations);
1354     }
1355
1356     /**
1357      * @return the z axis ticks labels
1358      */
1359     public String[] getZAxisTicksLabels() {
1360         return axes[2].getTicksLabelsStrings();
1361     }
1362
1363     /**
1364      * @return the z axis ticks labels
1365      */
1366     public ArrayList<FormattedText> getZAxisTicksLabelsAsArrayList() {
1367         return axes[2].getTicksLabels();
1368     }
1369
1370     /**
1371      * @param labels the z axis ticks labels to set
1372      */
1373     public UpdateStatus setZAxisTicksLabels(String[] labels) {
1374         return axes[2].setTicksLabelsStrings(labels);
1375     }
1376
1377     /**
1378      * @param labels the z axis ticks labels to set
1379      */
1380     public UpdateStatus setZAxisTicksLabelsAsArrayList(ArrayList<FormattedText> labels) {
1381         return axes[2].setTicksLabels(labels);
1382     }
1383
1384     /**
1385      * @return the z axis number of subticks
1386      */
1387     public Integer getZAxisSubticks() {
1388         return axes[2].getSubticks();
1389     }
1390
1391     /**
1392      * @param subticks the z axis number of subticks to set
1393      */
1394     public UpdateStatus setZAxisSubticks(Integer subticks) {
1395         return axes[2].setSubticks(subticks);
1396     }
1397
1398     /**
1399      * @return the autosubticks
1400      */
1401     public Boolean getAutoSubticks() {
1402         return autoSubticks;
1403     }
1404
1405     /**
1406      * @param autoSubticks the autosubticks to set
1407      */
1408     public UpdateStatus setAutoSubticks(Boolean autoSubticks) {
1409         if (this.autoSubticks != autoSubticks) {
1410             this.autoSubticks = autoSubticks;
1411             return UpdateStatus.Success;
1412         }
1413
1414         return UpdateStatus.NoChange;
1415     }
1416
1417     /**
1418      * Gets the ticks labels font style.
1419      * It supposes all ticks labels within a single axis have the same font style value
1420      * and that this value is the same for the 3 axes.
1421      * To be corrected.
1422      * @return the ticks labels font style
1423      */
1424     public Integer getFontStyle() {
1425         return axes[0].getFontStyle();
1426     }
1427
1428     /**
1429      * Sets the ticks labels font style.
1430      * It supposes all ticks labels within a single axis have the same font style value
1431      * and that this value is the same for the 3 axes.
1432      * To be corrected.
1433      * @param fontStyle the ticks labels font style to set
1434      */
1435     public UpdateStatus setFontStyle(Integer fontStyle) {
1436         UpdateStatus status = UpdateStatus.NoChange;
1437         for (int i = 0; i < axes.length; i++) {
1438             UpdateStatus s = axes[i].setFontStyle(fontStyle);
1439             if (s == UpdateStatus.Success) {
1440                 status = UpdateStatus.Success;
1441             }
1442         }
1443
1444         return status;
1445     }
1446
1447     /**
1448      * Gets the ticks labels font size.
1449      * It supposes all ticks labels within a single axis have the same font size value
1450      * and that this value is the same for the 3 axes.
1451      * To be corrected.
1452      * @return the ticks labels font size
1453      */
1454     public Double getFontSize() {
1455         return axes[0].getFontSize();
1456     }
1457
1458     /**
1459      * Sets the ticks labels font size.
1460      * It supposes all ticks labels within a single axis have the same font size value
1461      * and that this value is the same for the 3 axes.
1462      * To be corrected.
1463      * @param fontSize the ticks labels font size to set
1464      */
1465     public UpdateStatus setFontSize(Double fontSize) {
1466         UpdateStatus status = UpdateStatus.NoChange;
1467         for (int i = 0; i < axes.length; i++) {
1468             UpdateStatus s = axes[i].setFontSize(fontSize);
1469             if (s == UpdateStatus.Success) {
1470                 status = UpdateStatus.Success;
1471             }
1472         }
1473
1474         return status;
1475     }
1476
1477     /**
1478      * Gets the ticks labels font color.
1479      * It supposes all ticks labels within a single axis have the same font color value
1480      * and that this value is the same for the 3 axes.
1481      * To be corrected.
1482      * @return the ticks labels font color
1483      */
1484     public Integer getFontColor() {
1485         return axes[0].getFontColor();
1486     }
1487
1488     /**
1489      * Sets the ticks labels font color.
1490      * It supposes all ticks labels within a single axis have the same font color value
1491      * and that this value is the same for the 3 axes.
1492      * To be corrected.
1493      * @param fontColor the ticks labels font color to set
1494      */
1495     public UpdateStatus setFontColor(Integer fontColor) {
1496         UpdateStatus status = UpdateStatus.NoChange;
1497         for (int i = 0; i < axes.length; i++) {
1498             UpdateStatus s = axes[i].setFontColor(fontColor);
1499             if (s == UpdateStatus.Success) {
1500                 status = UpdateStatus.Success;
1501             }
1502         }
1503
1504         return status;
1505     }
1506
1507     /**
1508      * Gets the ticks labels font fractional.
1509      * It supposes all ticks labels within a single axis have the same font fractional value
1510      * and that this value is the same for the 3 axes.
1511      * To be corrected.
1512      * @return the ticks labels font fractional
1513      */
1514     public Boolean getFontFractional() {
1515         return axes[0].getFontFractional();
1516     }
1517
1518     /**
1519      * Sets the ticks labels font fractional.
1520      * It supposes all ticks labels within a single axis have the same font fractional value
1521      * and that this value is the same for the 3 axes.
1522      * To be corrected.
1523      * @param fontFractional the ticks labels font fractional to set
1524      */
1525     public UpdateStatus setFontFractional(Boolean fontFractional) {
1526         UpdateStatus status = UpdateStatus.NoChange;
1527         for (int i = 0; i < axes.length; i++) {
1528             UpdateStatus s = axes[i].setFontFractional(fontFractional);
1529             if (s == UpdateStatus.Success) {
1530                 status = UpdateStatus.Success;
1531             }
1532         }
1533
1534         return status;
1535     }
1536
1537     /**
1538      * @return the axesBounds
1539      */
1540     public Double[] getAxesBounds() {
1541         Double[] retAxesBounds = new Double[4];
1542
1543         retAxesBounds[0] = axesBounds[0];
1544         retAxesBounds[1] = axesBounds[1];
1545         retAxesBounds[2] = axesBounds[2];
1546         retAxesBounds[3] = axesBounds[3];
1547
1548         return retAxesBounds;
1549     }
1550
1551     /**
1552      * @param axesBounds the axesBounds to set
1553      */
1554     public UpdateStatus setAxesBounds(Double[] axesBounds) {
1555         if (this.axesBounds[0] != axesBounds[0] || this.axesBounds[1] != axesBounds[1]
1556                 || this.axesBounds[2] != axesBounds[2] || this.axesBounds[3] != axesBounds[3]) {
1557             this.axesBounds[0] = axesBounds[0];
1558             this.axesBounds[1] = axesBounds[1];
1559             this.axesBounds[2] = axesBounds[2];
1560             this.axesBounds[3] = axesBounds[3];
1561
1562             return UpdateStatus.Success;
1563         }
1564
1565         return UpdateStatus.NoChange;
1566     }
1567
1568     /**
1569      * @return the hiddenColor
1570      */
1571     public Integer getHiddenColor() {
1572         return hiddenColor;
1573     }
1574
1575     /**
1576      * @param hiddenColor the hiddenColor to set
1577      */
1578     public UpdateStatus setHiddenColor(Integer hiddenColor) {
1579         if (this.hiddenColor != hiddenColor) {
1580             this.hiddenColor = hiddenColor;
1581             return UpdateStatus.Success;
1582         }
1583
1584         return UpdateStatus.NoChange;
1585     }
1586
1587     /**
1588      * Returns the line property
1589      * @return the line property
1590      */
1591     public Line getLine() {
1592         return line;
1593     }
1594
1595     /**
1596      * @return the line mode
1597      */
1598     public Boolean getLineMode() {
1599         return line.getMode();
1600     }
1601
1602     /**
1603      * @param lineMode the line mode to set
1604      */
1605     public UpdateStatus setLineMode(Boolean lineMode) {
1606         return line.setMode(lineMode);
1607     }
1608
1609     /**
1610      * @return the line style
1611      */
1612     public Integer getLineStyle() {
1613         return line.getLineStyle().asScilabIndex();
1614     }
1615
1616     /**
1617      * @param lineStyle the line style to set
1618      */
1619     public UpdateStatus setLineStyle(Integer lineStyle) {
1620         return line.setLineStyle(LineType.fromScilabIndex(lineStyle));
1621     }
1622
1623     /**
1624      * @return the line thickness
1625      */
1626     public Double getLineThickness() {
1627         return line.getThickness();
1628     }
1629
1630     /**
1631      * @param lineThickness the line thickness to set
1632      */
1633     public UpdateStatus setLineThickness(Double lineThickness) {
1634         return line.setThickness(lineThickness);
1635     }
1636
1637     /**
1638      * @return the line color
1639      */
1640     public Integer getLineColor() {
1641         return line.getColor();
1642     }
1643
1644     /**
1645      * @param lineColor the lineColor to set
1646      */
1647     public UpdateStatus setLineColor(Integer lineColor) {
1648         return line.setColor(lineColor);
1649     }
1650
1651     /**
1652      * @return the mark mode
1653      */
1654     public Boolean getMarkMode() {
1655         return mark.getMode();
1656     }
1657
1658     /**
1659      * @param markMode the mark mode to set
1660      */
1661     public UpdateStatus setMarkMode(Boolean markMode) {
1662         return mark.setMode(markMode);
1663     }
1664
1665     /**
1666      * @return the mark style
1667      */
1668     public Integer getMarkStyle() {
1669         return mark.getStyle();
1670     }
1671
1672     /**
1673      * @param markStyle the mark style to set
1674      */
1675     public UpdateStatus setMarkStyle(Integer markStyle) {
1676         return mark.setStyle(markStyle);
1677     }
1678
1679     /**
1680      * @return the mark size
1681      */
1682     public Integer getMarkSize() {
1683         return mark.getSize();
1684     }
1685
1686     /**
1687      * @param markSize the mark size to set
1688      */
1689     public UpdateStatus setMarkSize(Integer markSize) {
1690         return mark.setSize(markSize);
1691     }
1692
1693     /**
1694      * @return the mark size unit
1695      */
1696     public Integer getMarkSizeUnit() {
1697         return mark.getMarkSizeUnit().ordinal();
1698     }
1699
1700     /**
1701      * @param markSizeUnit the mark size unit to set
1702      */
1703     public UpdateStatus setMarkSizeUnit(Integer markSizeUnit) {
1704         return mark.setMarkSizeUnit(MarkSizeUnitType.intToEnum(markSizeUnit));
1705     }
1706
1707     /**
1708      * @return the mark foreground
1709      */
1710     public Integer getMarkForeground() {
1711         return mark.getForeground();
1712     }
1713
1714     /**
1715      * @param markForeground the mark foreground to set
1716      */
1717     public UpdateStatus setMarkForeground(Integer markForeground) {
1718         return mark.setForeground(markForeground);
1719     }
1720
1721     /**
1722      * @return the mark background
1723      */
1724     public Integer getMarkBackground() {
1725         return mark.getBackground();
1726     }
1727
1728     /**
1729      * @param markBackground the mark background to set
1730      */
1731     public UpdateStatus setMarkBackground(Integer markBackground) {
1732         return mark.setBackground(markBackground);
1733     }
1734
1735     /**
1736      * @return the clip state
1737      */
1738     public Integer getClipState() {
1739         return clipProperty.getClipState().ordinal();
1740     }
1741
1742     /**
1743      * @param clipState the clip state to set
1744      */
1745     public UpdateStatus setClipState(Integer clipState) {
1746         return clipProperty.setClipState(ClipStateType.intToEnum(clipState));
1747     }
1748
1749     /**
1750      * @return the clip box
1751      */
1752     public Double[] getClipBox() {
1753         return clipProperty.getClipBox();
1754     }
1755
1756     /**
1757      * @param clipBox the clip box to set
1758      */
1759     public UpdateStatus setClipBox(Double[] clipBox) {
1760         return clipProperty.setClipBox(clipBox);
1761     }
1762
1763     /**
1764      * @return the clip box set
1765      */
1766     public Boolean getClipBoxSet() {
1767         return clipProperty.getClipBoxSet();
1768     }
1769
1770     /**
1771      * @param clipBoxSet the clip box set to set
1772      */
1773     public UpdateStatus setClipBoxSet(Boolean clipBoxSet) {
1774         return clipProperty.setClipBoxSet(clipBoxSet);
1775     }
1776
1777     /**
1778      * @return the arcDrawingMethod
1779      */
1780     public Integer getArcDrawingMethod() {
1781         return arcDrawingMethod.ordinal();
1782     }
1783
1784     /**
1785      * @param arcDrawingMethod the arcDrawingMethod to set
1786      */
1787     public UpdateStatus setArcDrawingMethod(Integer arcDrawingMethod) {
1788         ArcDrawingMethod mode = ArcDrawingMethod.intToEnum(arcDrawingMethod);
1789         if (this.arcDrawingMethod != mode) {
1790             this.arcDrawingMethod = mode;
1791             return UpdateStatus.Success;
1792         }
1793
1794         return UpdateStatus.NoChange;
1795     }
1796
1797     /**
1798      * @return the box
1799      */
1800     public Box getBox() {
1801         return box;
1802     }
1803
1804     /**
1805      * @param box the box to set
1806      */
1807     public UpdateStatus setBox(Box box) {
1808         this.box = box;
1809
1810         return UpdateStatus.Success;
1811     }
1812
1813     /**
1814      * @return the box type
1815      */
1816     public Integer getBoxType() {
1817         return getBoxTypeAsEnum().ordinal();
1818     }
1819
1820     /**
1821      * @return the box type
1822      */
1823     public BoxType getBoxTypeAsEnum() {
1824         return box.getBox();
1825     }
1826
1827     /**
1828      * @param box the BoxType to set
1829      */
1830     public UpdateStatus setBoxType(Integer box) {
1831         return setBoxTypeAsEnum(BoxType.intToEnum(box));
1832     }
1833
1834     /**
1835      * @param box the BoxType to set
1836      */
1837     public UpdateStatus setBoxTypeAsEnum(BoxType box) {
1838         return this.box.setBox(box);
1839     }
1840
1841     /**
1842      * @return the hidden axis color
1843      */
1844     public Integer getHiddenAxisColor() {
1845         return box.getHiddenAxisColor();
1846     }
1847
1848     /**
1849      * @param color the hidden axis color to set
1850      */
1851     public UpdateStatus setHiddenAxisColor(Integer color) {
1852         return box.setHiddenAxisColor(color);
1853     }
1854
1855     /**
1856      * @return the tight limits
1857      */
1858     public Boolean getTightLimits() {
1859         return box.getTightLimits();
1860     }
1861
1862     /**
1863      * @param tightLimits the tightLimits to set
1864      */
1865     public UpdateStatus setTightLimits(Boolean tightLimits) {
1866         return box.setTightLimits(tightLimits);
1867     }
1868
1869     /**
1870      * @return the data bounds
1871      */
1872     public Double[] getDataBounds() {
1873         return box.getDataBounds();
1874     }
1875
1876     /**
1877      * @param dataBounds the data bounds to set
1878      */
1879     public UpdateStatus setDataBounds(Double[] dataBounds) {
1880         return box.setDataBounds(dataBounds);
1881     }
1882
1883     /**
1884      * @return the real data bounds
1885      */
1886     public Double[] getRealDataBounds() {
1887         return box.getRealDataBounds();
1888     }
1889
1890     /**
1891      * @param realDataBounds the real data bounds to set
1892      */
1893     public UpdateStatus setRealDataBounds(Double[] realDataBounds) {
1894         return box.setRealDataBounds(realDataBounds);
1895     }
1896
1897     /**
1898      * Get the scale and translate factors corresponding to the displayed bounds
1899      * @return the factors as a multidimensional array 2x3
1900      */
1901     public double[][] getScaleTranslateFactors() {
1902         // For an axe scale and translate factors are
1903         // such that scale*min+translate=-1 and scale*max+translate=+1
1904         // With these factors, double data will be in interval [-1;1]
1905
1906         Double[] bounds = getMaximalDisplayedBounds();
1907         double[][] f = new double[2][];
1908
1909         // scale factors
1910         f[0] = new double[] {2 / (bounds[1] - bounds[0]),
1911                              2 / (bounds[3] - bounds[2]),
1912                              2 / (bounds[5] - bounds[4])
1913                             };
1914
1915         // translate factors
1916         f[1] = new double[] { -(bounds[1] + bounds[0]) / (bounds[1] - bounds[0]), -(bounds[3] + bounds[2]) / (bounds[3] - bounds[2]), -(bounds[5] + bounds[4]) / (bounds[5] - bounds[4])};
1917
1918         return f;
1919     }
1920
1921     public Double[] getCorrectedBounds() {
1922         if (getZoomEnabled()) {
1923             Double[] b = getCorrectZoomBox();
1924             double[][] factors = getScaleTranslateFactors();
1925
1926             b[0] = b[0] * factors[0][0] + factors[1][0];
1927             b[1] = b[1] * factors[0][0] + factors[1][0];
1928             b[2] = b[2] * factors[0][1] + factors[1][1];
1929             b[3] = b[3] * factors[0][1] + factors[1][1];
1930             b[4] = b[4] * factors[0][2] + factors[1][2];
1931             b[5] = b[5] * factors[0][2] + factors[1][2];
1932
1933             return b;
1934         } else {
1935             return new Double[] { -1., 1., -1., 1., -1., 1.};
1936         }
1937     }
1938
1939     /**
1940      * Current displayed bounds getter.
1941      * @return the current visible bounds of this axes.
1942      */
1943     public Double[] getDisplayedBounds() {
1944         if (getZoomEnabled()) {
1945             return getCorrectZoomBox();
1946         } else {
1947             return getMaximalDisplayedBounds();
1948         }
1949     }
1950
1951     /**
1952      * Maximal possible displayed bounds getter.
1953      * @return the maximal possible displayed bounds.
1954      */
1955     public Double[] getMaximalDisplayedBounds() {
1956         Double[] bounds = getDataBounds();
1957         boolean eq = bounds[0].doubleValue() == bounds[1].doubleValue();
1958         if (getXAxisLogFlag()) {
1959             if (eq) {
1960                 bounds[0] = Math.log10(bounds[0]) - 1;
1961                 bounds[1] = bounds[0] + 2;
1962             } else {
1963                 bounds[0] = Math.log10(bounds[0]);
1964                 bounds[1] = Math.log10(bounds[1]);
1965             }
1966         } else if (eq) {
1967             // Avoid to have same bounds.
1968             double inc = getIncrement(bounds[0]);
1969             bounds[0] -= inc;
1970             bounds[1] += inc;
1971         }
1972
1973         if (getXAxisLocationAsEnum() == AxisProperty.AxisLocation.ORIGIN) {
1974             if (0 < bounds[0]) {
1975                 bounds[0] = 0.;
1976             } else if (bounds[1] < 0) {
1977                 bounds[1] = 0.;
1978             }
1979         }
1980
1981         eq = bounds[2].doubleValue() == bounds[3].doubleValue();
1982         if (getYAxisLogFlag()) {
1983             if (eq) {
1984                 bounds[2] = Math.log10(bounds[2]) - 1;
1985                 bounds[3] = bounds[2] + 2;
1986             } else {
1987                 bounds[2] = Math.log10(bounds[2]);
1988                 bounds[3] = Math.log10(bounds[3]);
1989             }
1990         } else if (eq) {
1991             double inc = getIncrement(bounds[2]);
1992             bounds[2] -= inc;
1993             bounds[3] += inc;
1994         }
1995
1996         if (getYAxisLocationAsEnum() == AxisProperty.AxisLocation.ORIGIN) {
1997             if (0 < bounds[2]) {
1998                 bounds[2] = 0.;
1999             } else if (bounds[3] < 0) {
2000                 bounds[3] = 0.;
2001             }
2002         }
2003
2004         eq = bounds[4].doubleValue() == bounds[5].doubleValue();
2005         if (getZAxisLogFlag()) {
2006             if (eq) {
2007                 bounds[4] = Math.log10(bounds[4]) - 1;
2008                 bounds[5] = bounds[4] + 2;
2009             } else {
2010                 bounds[4] = Math.log10(bounds[4]);
2011                 bounds[5] = Math.log10(bounds[5]);
2012             }
2013         } else if (eq) {
2014             double inc = getIncrement(bounds[4]);
2015             bounds[4] -= inc;
2016             bounds[5] += inc;
2017         }
2018
2019         if (getZAxisLocationAsEnum() == AxisProperty.AxisLocation.ORIGIN) {
2020             if (0 < bounds[4]) {
2021                 bounds[4] = 0.;
2022             } else if (bounds[5] < 0) {
2023                 bounds[5] = 0.;
2024             }
2025         }
2026
2027         if (!getTightLimits()) {
2028             for (int i = 0 ; i < 6 ; i += 2) {
2029                 round(bounds, i);
2030             }
2031         }
2032
2033         return bounds;
2034     }
2035
2036     private final double getIncrement(final double x) {
2037         final int exponent = (int) (((Double.doubleToLongBits(x) & 0x7FF0000000000000L) >> 52) - 1023);
2038
2039         return Math.pow(2, Math.max(0, exponent - 52));
2040     }
2041
2042     /**
2043      * Round the bounds in the bounds array at the given index.
2044      * bounds[i] and bounds[i + 1 ] are rounded to be in the value written
2045      * k * b * 10^n
2046      * where b is in {1, 2, 5}
2047      * and b * 10 ^n the maximal value less than (bounds[i + 1] - bounds[i]) / BOUNDS_PARAMETER.
2048      * @param bounds the bounds array.
2049      * @param i the start index.
2050      */
2051     private void round(Double[] bounds, int i) {
2052         double delta = (bounds[i + 1] - bounds[i]) / BOUNDS_PARAMETER;
2053         double powerOfTen = Math.pow(10, Math.floor(Math.log10(delta)));
2054         double base = delta / powerOfTen;
2055
2056         if (base < 2) {
2057             base = 1;
2058         } else if (base < 5) {
2059             base = 2;
2060         } else {
2061             base = 5;
2062         }
2063
2064         double step = base * powerOfTen;
2065         bounds[i] = step * Math.floor(bounds[i] / step);
2066         bounds[i + 1] = step * Math.ceil(bounds[i + 1] / step);
2067     }
2068
2069     /**
2070      * @return the zoomEnabled
2071      */
2072     public Boolean getZoomEnabled() {
2073         return box.getZoomEnabled();
2074     }
2075
2076     /**
2077      * @param zoomEnabled the zoomEnabled to set
2078      */
2079     public UpdateStatus setZoomEnabled(Boolean zoomEnabled) {
2080         return box.setZoomEnabled(zoomEnabled);
2081     }
2082
2083     /**
2084      * @return the zoom box
2085      */
2086     public Double[] getZoomBox() {
2087         return box.getZoomBox();
2088     }
2089
2090     public Double[] getCorrectZoomBox() {
2091         Double[] b = getZoomBox();
2092         if (getXAxisLogFlag()) {
2093             b[0] = Math.log10(b[0]);
2094             b[1] = Math.log10(b[1]);
2095         }
2096
2097         if (getYAxisLogFlag()) {
2098             b[2] = Math.log10(b[2]);
2099             b[3] = Math.log10(b[3]);
2100         }
2101
2102         if (getZAxisLogFlag()) {
2103             b[4] = Math.log10(b[4]);
2104             b[5] = Math.log10(b[5]);
2105         }
2106
2107         return b;
2108     }
2109
2110     /**
2111      * @param zoomBox the zoom box to set
2112      */
2113     public UpdateStatus setZoomBox(Double[] zoomBox) {
2114         return box.setZoomBox(zoomBox);
2115     }
2116
2117     /**
2118      * @return the autoscale
2119      */
2120     public Boolean getAutoScale() {
2121         return box.getAutoScale();
2122     }
2123
2124     /**
2125      * @param autoScale the autoscale to set
2126      */
2127     public UpdateStatus setAutoScale(Boolean autoScale) {
2128         return box.setAutoScale(autoScale);
2129     }
2130
2131     /**
2132      * @return the firstplot
2133      */
2134     public Boolean getFirstPlot() {
2135         return box.getFirstPlot();
2136     }
2137
2138     /**
2139      * @param firstPlot the firstplot to set
2140      */
2141     public UpdateStatus setFirstPlot(Boolean firstPlot) {
2142         return box.setFirstPlot(firstPlot);
2143     }
2144
2145     /**
2146      * @return the camera
2147      */
2148     public Camera getCamera() {
2149         return camera;
2150     }
2151
2152     /**
2153      * @param camera the camera to set
2154      */
2155     public UpdateStatus setCamera(Camera camera) {
2156         if (this.camera.equals(camera)) {
2157             this.camera = camera;
2158             return UpdateStatus.Success;
2159         }
2160
2161         return UpdateStatus.NoChange;
2162     }
2163
2164     /**
2165      * @return the view type
2166      */
2167     public Integer getView() {
2168         return getViewAsEnum().ordinal();
2169     }
2170
2171     /**
2172      * @return the view type
2173      */
2174     public ViewType getViewAsEnum() {
2175         return camera.getView();
2176     }
2177
2178     /**
2179      * @param view the view type to set
2180      */
2181     public UpdateStatus setView(Integer view) {
2182         return setViewAsEnum(ViewType.intToEnum(view));
2183     }
2184
2185     /**
2186      * @param view the view type to set
2187      */
2188     public UpdateStatus setViewAsEnum(ViewType view) {
2189         return camera.setView(view);
2190     }
2191
2192     /**
2193      * @return the isoview
2194      */
2195     public Boolean getIsoview() {
2196         return camera.getIsoview();
2197     }
2198
2199     /**
2200      * @param isoview the isoview to set
2201      */
2202     public UpdateStatus setIsoview(Boolean isoview) {
2203         return camera.setIsoview(isoview);
2204     }
2205
2206     /**
2207      * @return the cubescaling
2208      */
2209     public Boolean getCubeScaling() {
2210         return camera.getCubeScaling();
2211     }
2212
2213     /**
2214      * @param cubeScaling the cubescaling to set
2215      */
2216     public UpdateStatus setCubeScaling(Boolean cubeScaling) {
2217         return camera.setCubeScaling(cubeScaling);
2218     }
2219
2220     /**
2221      * @return the rotation angles
2222      */
2223     public Double[] getRotationAngles() {
2224         return camera.getRotationAngles();
2225     }
2226
2227     /**
2228      * @param rotationAngles the rotation angles to set
2229      * @return the update status.
2230      */
2231     public UpdateStatus setRotationAngles(Double[] rotationAngles) {
2232         if (camera.setRotationAngles(rotationAngles)) {
2233             try {
2234                 GraphicController controller = GraphicController.getController();
2235                 Figure figure = (Figure) controller.getObjectFromId(getParentFigure());
2236                 if (figure.getRotationAsEnum().equals(Figure.RotationType.MULTIPLE)) {
2237                     for (Integer child : figure.getChildren()) {
2238                         if (child != null) {
2239                             if (GraphicObjectProperties.__GO_AXES__ == ((Integer) controller.getProperty(child, GraphicObjectProperties.__GO_TYPE__))) {
2240                                 controller.setProperty(
2241                                     child,
2242                                     GraphicObjectProperties.__GO_ROTATION_ANGLES__,
2243                                     rotationAngles);
2244                             }
2245                         }
2246                     }
2247                 }
2248             } catch (ClassCastException ignored) {
2249             }
2250             return UpdateStatus.Success;
2251         } else {
2252             return UpdateStatus.NoChange;
2253         }
2254     }
2255
2256     /**
2257      * @return the 3d rotation angles
2258      */
2259     public Double[] getRotationAngles3d() {
2260         return camera.getRotationAngles3d();
2261     }
2262
2263     /**
2264      * @param rotationAngles3d the 3d rotation angles to set
2265      */
2266     public UpdateStatus setRotationAngles3d(Double[] rotationAngles3d) {
2267         return camera.setRotationAngles3d(rotationAngles3d);
2268     }
2269
2270     /**
2271      * @return the filled
2272      */
2273     public Boolean getFilled() {
2274         return filled;
2275     }
2276
2277     /**
2278      * @param filled the filled to set
2279      */
2280     public UpdateStatus setFilled(Boolean filled) {
2281         if (this.filled != filled) {
2282             this.filled = filled;
2283             return UpdateStatus.Success;
2284         }
2285
2286         return UpdateStatus.NoChange;
2287     }
2288
2289     /**
2290      * @return the background
2291      */
2292     public Integer getBackground() {
2293         return background;
2294     }
2295
2296     /**
2297      * @param background the background to set
2298      */
2299     public UpdateStatus setBackground(Integer background) {
2300         if (this.background != background) {
2301             this.background = background;
2302             return UpdateStatus.Success;
2303         }
2304
2305         return UpdateStatus.NoChange;
2306     }
2307
2308     /**
2309      * @return the gridPosition
2310      */
2311     public Integer getGridPosition() {
2312         return getGridPositionAsEnum().ordinal();
2313     }
2314
2315     /**
2316      * @return the gridPosition
2317      */
2318     public GridPosition getGridPositionAsEnum() {
2319         return gridPosition;
2320     }
2321
2322     /**
2323      * @param gridPosition the gridPosition to set
2324      */
2325     public UpdateStatus setGridPosition(Integer gridPosition) {
2326         return setGridPositionAsEnum(GridPosition.intToEnum(gridPosition));
2327     }
2328
2329     /**
2330      * @param gridPosition the gridPosition to set
2331      */
2332     public UpdateStatus setGridPositionAsEnum(GridPosition gridPosition) {
2333         if (this.gridPosition != gridPosition) {
2334             this.gridPosition = gridPosition;
2335             return UpdateStatus.Success;
2336         }
2337
2338         return UpdateStatus.NoChange;
2339     }
2340
2341     /**
2342      * @return the margins
2343      */
2344     public Double[] getMargins() {
2345         Double[] retMargins = new Double[4];
2346
2347         retMargins[0] = margins[0];
2348         retMargins[1] = margins[1];
2349         retMargins[2] = margins[2];
2350         retMargins[3] = margins[3];
2351
2352         return retMargins;
2353     }
2354
2355     /**
2356      * @param margins the margins to set
2357      */
2358     public UpdateStatus setMargins(Double[] margins) {
2359         if (this.margins[0] != margins[0] || this.margins[1] != margins[1] || this.margins[2] != margins[2] || this.margins[3] != margins[3]) {
2360             this.margins[0] = margins[0];
2361             this.margins[1] = margins[1];
2362             this.margins[2] = margins[2];
2363             this.margins[3] = margins[3];
2364
2365             return UpdateStatus.Success;
2366         }
2367
2368         return UpdateStatus.NoChange;
2369     }
2370
2371     /**
2372      * @return the title UID
2373      */
2374     public Integer getTitle() {
2375         return title;
2376     }
2377
2378     /**
2379      * @param title the title to set
2380      */
2381     public UpdateStatus setTitle(Integer title) {
2382         if (this.title != title) {
2383             this.title = title;
2384             return UpdateStatus.Success;
2385         }
2386
2387         return UpdateStatus.NoChange;
2388     }
2389
2390     public Integer getType() {
2391         return GraphicObjectProperties.__GO_AXES__;
2392     }
2393 }