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