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