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