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