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