* Bug #13690 fixed - tight_limits property can now manage X, Y and Z axis separately.
[scilab.git] / scilab / modules / graphic_objects / src / java / org / scilab / modules / graphic_objects / axes / Box.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2010 - DIGITEO - Manuel JULIACHS
4  * Copyright (C) 2013 - Scilab Enterprises - Calixte DENIZET
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.1-en.txt
11  *
12  */
13
14 package org.scilab.modules.graphic_objects.axes;
15
16 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject.UpdateStatus;
17
18 /**
19  * Box class
20  * @author Manuel JULIACHS
21  */
22 public class Box {
23     /** Box properties names */
24     public enum BoxProperty { BOX, HIDDENAXISCOLOR, XTIGHTLIMITS, YTIGHTLIMITS, ZTIGHTLIMITS, DATABOUNDS, REALDATABOUNDS, ZOOMENABLED, ZOOMBOX, AUTOSCALE, FIRSTPLOT };
25
26     /** Box type */
27     public static enum BoxType { OFF, ON, HIDDEN_AXES, BACK_HALF;
28
29                                  /**
30                                   * Converts an integer to the corresponding enum
31                                   * @param intValue the integer value
32                                   * @return the box type enum
33                                   */
34     public static BoxType intToEnum(Integer intValue) {
35         switch (intValue) {
36             case 0:
37                 return BoxType.OFF;
38             case 1:
39                 return BoxType.ON;
40             case 2:
41                 return BoxType.HIDDEN_AXES;
42             case 3:
43                 return BoxType.BACK_HALF;
44             default:
45                 return null;
46         }
47     }
48                                }
49
50     /** Box type */
51     private BoxType box;
52
53     /** Hidden axis color */
54     private int hiddenAxisColor;
55
56     /** Specifies whether tight limits are enforced or not */
57     private boolean[] tightLimits;
58
59     /** Data bounding box (6-element array) */
60     private double[] dataBounds;
61
62     /** Data bounding box, as modified by automatic ticks computation (6-element array) */
63     private double[] realDataBounds;
64
65     /** Speficies whether zooming is enabled or not */
66     private boolean zoomEnabled;
67
68     /** Magnified 3D sub-region (6-element array) */
69     private double[] zoomBox;
70
71     /** Indicates whether data bounds are updated when a new plot command is executed */
72     private boolean autoScale;
73
74     /**
75      * Indicates whether no high-level drawing function has yet been called (true) or
76      * has been called at least once (false)
77      */
78     private boolean firstPlot;
79
80     /** Constructor */
81     public Box() {
82         box = BoxType.OFF;
83         hiddenAxisColor = 0;
84         tightLimits = new boolean[] {false, false, false};
85         dataBounds = new double[] {0, 1, 0, 1, -1, 1};
86         realDataBounds = new double[6];
87         zoomEnabled = false;
88         zoomBox = new double[6];
89         autoScale = false;
90         firstPlot = true;
91     }
92
93     /**
94      * Copy constructor
95      * @param box the Box to copy
96      */
97     public Box(Box box) {
98         this.box = box.box;
99         hiddenAxisColor = box.hiddenAxisColor;
100
101         tightLimits = new boolean[3];
102         for (int i = 0; i < tightLimits.length; i++) {
103             tightLimits[i] = box.tightLimits[i];
104         }
105
106         dataBounds = new double[6];
107
108         for (int i = 0; i < dataBounds.length; i++) {
109             dataBounds[i] = box.dataBounds[i];
110         }
111
112         realDataBounds = new double[6];
113
114         for (int i = 0; i < realDataBounds.length; i++) {
115             realDataBounds[i] = box.realDataBounds[i];
116         }
117
118         zoomEnabled = box.zoomEnabled;
119
120         zoomBox = new double[6];
121
122         for (int i = 0; i < zoomBox.length; i++) {
123             zoomBox[i] = box.zoomBox[i];
124         }
125
126         autoScale = box.autoScale;
127         firstPlot = box.firstPlot;
128     }
129
130     /**
131      * @return the autoScale
132      */
133     public Boolean getAutoScale() {
134         return autoScale;
135     }
136
137     /**
138      * @param autoScale the autoScale to set
139      */
140     public UpdateStatus setAutoScale(Boolean autoScale) {
141         if (this.autoScale != autoScale) {
142             this.autoScale = autoScale;
143             return UpdateStatus.Success;
144         }
145
146         return UpdateStatus.NoChange;
147     }
148
149     /**
150      * @return the box
151      */
152     public BoxType getBox() {
153         return box;
154     }
155
156     /**
157      * @param box the box to set
158      */
159     public UpdateStatus setBox(BoxType box) {
160         if (this.box != box) {
161             this.box = box;
162             return UpdateStatus.Success;
163         }
164
165         return UpdateStatus.NoChange;
166     }
167
168     /**
169      * Return the data bounds.
170      * The array contain : {xMin, xMax, yMin, yMax, zMin, zMax}
171      * @return the dataBounds
172      */
173     public Double[] getDataBounds() {
174         Double[] retDataBounds = new Double[6];
175
176         for (int i = 0; i < retDataBounds.length; i++) {
177             retDataBounds[i] = dataBounds[i];
178         }
179
180         return retDataBounds;
181     }
182
183     /**
184      * @param dataBounds the dataBounds to set
185      */
186     public UpdateStatus setDataBounds(Double[] dataBounds) {
187         UpdateStatus status = UpdateStatus.NoChange;
188         final int len = Math.min(this.dataBounds.length, dataBounds.length);
189         for (int i = 0; i < len; i++) {
190             if (this.dataBounds[i] != dataBounds[i]) {
191                 this.dataBounds[i] = dataBounds[i];
192                 status = UpdateStatus.Success;
193             }
194         }
195
196         return status;
197     }
198
199     /**
200      * @return the hiddenAxisColor
201      */
202     public Integer getHiddenAxisColor() {
203         return hiddenAxisColor;
204     }
205
206     /**
207      * @param hiddenAxisColor the hiddenAxisColor to set
208      */
209     public UpdateStatus setHiddenAxisColor(Integer hiddenAxisColor) {
210         if (this.hiddenAxisColor != hiddenAxisColor) {
211             this.hiddenAxisColor = hiddenAxisColor;
212             return UpdateStatus.Success;
213         }
214
215         return UpdateStatus.NoChange;
216     }
217
218     /**
219      * @return the realDataBounds
220      */
221     public Double[] getRealDataBounds() {
222         Double[] retRealDataBounds = new Double[6];
223
224         for (int i = 0; i < retRealDataBounds.length; i++) {
225             retRealDataBounds[i] = realDataBounds[i];
226         }
227
228         return retRealDataBounds;
229     }
230
231     /**
232      * @param realDataBounds the realDataBounds to set
233      */
234     public UpdateStatus setRealDataBounds(Double[] realDataBounds) {
235         UpdateStatus status = UpdateStatus.NoChange;
236         final int len = Math.min(this.realDataBounds.length, realDataBounds.length);
237         for (int i = 0; i < len; i++) {
238             if (this.realDataBounds[i] != realDataBounds[i]) {
239                 this.realDataBounds[i] = realDataBounds[i];
240                 status = UpdateStatus.Success;
241             }
242         }
243
244         return status;
245     }
246
247     /**
248      * @return the tightLimits for X axis
249      */
250     public Boolean getXTightLimits() {
251         return tightLimits[0];
252     }
253
254     /**
255      * @return the tightLimits for Y axis
256      */
257     public Boolean getYTightLimits() {
258         return tightLimits[1];
259     }
260
261     /**
262      * @return the tightLimits for X axis
263      */
264     public Boolean getZTightLimits() {
265         return tightLimits[2];
266     }
267
268     /**
269      * @param tightLimits the tightLimits to set for X axis
270      */
271     public UpdateStatus setXTightLimits(Boolean tightLimits) {
272         if (this.tightLimits[0] != tightLimits) {
273             this.tightLimits[0] = tightLimits;
274             return UpdateStatus.Success;
275         }
276
277         return UpdateStatus.NoChange;
278     }
279
280     /**
281      * @param tightLimits the tightLimits to set for Y axis
282      */
283     public UpdateStatus setYTightLimits(Boolean tightLimits) {
284         if (this.tightLimits[1] != tightLimits) {
285             this.tightLimits[1] = tightLimits;
286             return UpdateStatus.Success;
287         }
288
289         return UpdateStatus.NoChange;
290     }
291
292     /**
293      * @param tightLimits the tightLimits to set for Z axis
294      */
295     public UpdateStatus setZTightLimits(Boolean tightLimits) {
296         if (this.tightLimits[2] != tightLimits) {
297             this.tightLimits[2] = tightLimits;
298             return UpdateStatus.Success;
299         }
300
301         return UpdateStatus.NoChange;
302     }
303
304     /**
305      * @return the zoomEnabled
306      */
307     public Boolean getZoomEnabled() {
308         return zoomEnabled;
309     }
310
311     /**
312      * @param zoomEnabled the zoomEnabled to set
313      */
314     public UpdateStatus setZoomEnabled(Boolean zoomEnabled) {
315         if (this.zoomEnabled != zoomEnabled) {
316             this.zoomEnabled = zoomEnabled;
317             return UpdateStatus.Success;
318         }
319
320         return UpdateStatus.NoChange;
321     }
322
323     /**
324      * @return the zoomBox
325      */
326     public Double[] getZoomBox() {
327         Double[] retZoomBox = new Double[6];
328
329         for (int i = 0; i < retZoomBox.length; i++) {
330             retZoomBox[i] = zoomBox[i];
331         }
332
333         return retZoomBox;
334     }
335
336     /**
337      * @param zoomBox the zoomBox to set
338      */
339     public UpdateStatus setZoomBox(Double[] zoomBox) {
340         UpdateStatus status = UpdateStatus.NoChange;
341         final int len = Math.min(this.zoomBox.length, zoomBox.length);
342         for (int i = 0; i < len; i++) {
343             if (this.zoomBox[i] != zoomBox[i]) {
344                 this.zoomBox[i] = zoomBox[i];
345                 status = UpdateStatus.Success;
346             }
347         }
348
349         return status;
350     }
351
352     /**
353      * @return the firstPlot
354      */
355     public Boolean getFirstPlot() {
356         return firstPlot;
357     }
358
359     /**
360      * @param firstPlot the firstPlot to set
361      */
362     public UpdateStatus setFirstPlot(Boolean firstPlot) {
363         if (this.firstPlot != firstPlot) {
364             this.firstPlot = firstPlot;
365             return UpdateStatus.Success;
366         }
367
368         return UpdateStatus.NoChange;
369     }
370 }