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