b07002f1b9d33f487205e06640a542b8c0339715
[scilab.git] / scilab / modules / graphic_objects / src / java / org / scilab / modules / graphic_objects / axes / TicksProperty.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 java.util.ArrayList;
17
18 import org.scilab.modules.graphic_objects.graphicObject.GraphicObject.UpdateStatus;
19 import org.scilab.modules.graphic_objects.textObject.Font;
20 import org.scilab.modules.graphic_objects.textObject.FormattedText;
21
22 /**
23  * TicksProperty class
24  * @author Manuel JULIACHS
25  */
26 public class TicksProperty {
27     /** TicksProperty properties names */
28     public enum TicksPropertyProperty { AUTO, LOCATIONS, LABELS,
29                                         FONT_SIZE, FONT_STYLE, FONT_COLOR, SUBTICKS
30                                       };
31
32     /** Default number of ticks */
33     private static final int DEFAULT_NUMBER_OF_TICKS = 11;
34
35     /** Specifies whether ticks are automatically computed or not */
36     private boolean auto;
37
38     /** Number of subticks between two main ticks */
39     private int subticks;
40
41     /** Default font */
42     private Font defaultFont;
43
44     /** TicksArrays class */
45     private class TicksArrays {
46         /** Ticks locations */
47         private double[] locations;
48
49         /** Ticks labels */
50         private ArrayList <FormattedText> labels;
51
52         /** Number of ticks */
53         private int number;
54
55         /**
56          * Constructor
57          */
58         public TicksArrays(int number) {
59             locations = new double[number];
60             labels = new ArrayList<FormattedText>(number);
61
62             for (int i = 0; i < number; i++) {
63                 labels.add(i, new FormattedText());
64             }
65
66             this.number = number;
67         }
68
69         @Override
70         public boolean equals(Object o) {
71             if (o instanceof TicksArrays) {
72                 TicksArrays ta = (TicksArrays) o;
73                 if (ta.number == number) {
74                     for (int i = 0; i < number; i++) {
75                         if (ta.locations[i] != locations[i] || !ta.labels.get(i).equals(labels.get(i))) {
76                             return false;
77                         }
78                     }
79
80                     return true;
81                 }
82             }
83
84             return false;
85         }
86
87         /**
88          * @return the number of ticks
89          */
90         public Integer getNumber() {
91             return number;
92         }
93
94         /**
95          * @return the labels
96          */
97         public ArrayList<FormattedText> getLabels() {
98             return labels;
99         }
100
101         /**
102          * @param labels the labels to set
103          */
104         public UpdateStatus setLabels(ArrayList<FormattedText> labels) {
105             UpdateStatus status = this.labels.equals(labels) ? UpdateStatus.NoChange : UpdateStatus.Success;
106             if (status == UpdateStatus.Success) {
107                 if (!this.labels.isEmpty()) {
108                     this.labels.clear();
109                 }
110
111                 for (int i = 0; i < labels.size(); i++) {
112                     this.labels.add(i, new FormattedText(labels.get(i)));
113                 }
114             }
115
116             return status;
117         }
118
119         /**
120          * @return the labels strings
121          */
122         public String[] getLabelsStrings() {
123             String[] labelsStrings;
124
125             labelsStrings = new String[number];
126
127             for (int i = 0; i < number; i++) {
128                 labelsStrings[i] = new String(labels.get(i).getText()).replaceAll("\u00A0", " ");
129             }
130
131             return labelsStrings;
132         }
133
134         /**
135          * Sets the ticks labels strings
136          * Requires the corresponding ticks locations to have previously been set.
137          * @param labels the labels to set
138          */
139         public UpdateStatus setLabelsStrings(String[] labels) {
140             if (labels.length != number) {
141                 return UpdateStatus.NoChange;
142             }
143
144             if (this.labels == null || this.labels.size() != labels.length) {
145                 this.labels = new ArrayList<FormattedText>(0);
146
147                 Font font = new Font(defaultFont);
148                 for (int i = 0; i < labels.length; i++) {
149                     FormattedText newText = new FormattedText(labels[i], font);
150                     this.labels.add(newText);
151                 }
152
153                 return UpdateStatus.Success;
154             }
155
156             UpdateStatus status = UpdateStatus.NoChange;
157             for (int i = 0; i < number; i++) {
158                 FormattedText ft = this.labels.get(i);
159                 if (!ft.getText().equals(labels[i])) {
160                     this.labels.get(i).setText(labels[i]);
161                     status = UpdateStatus.Success;
162                 }
163             }
164
165             return status;
166         }
167
168         /**
169          * @return the locations
170          */
171         public Double[] getLocations() {
172             Double[] retLocations;
173
174             retLocations = new Double[number];
175
176             for (int i = 0; i < number; i++) {
177                 retLocations[i] = locations[i];
178             }
179
180             return retLocations;
181         }
182
183         /**
184          * Sets the ticks locations
185          * Also sets the current number of ticks to the size of the locations array
186          * if the latter is resized.
187          * @param locations the locations to set
188          */
189         public UpdateStatus setLocations(Double[] locations) {
190             UpdateStatus status = UpdateStatus.Success;
191             if (this.locations == null || number != locations.length) {
192                 this.locations = new double[locations.length];
193                 number = locations.length;
194             } else {
195                 status = UpdateStatus.NoChange;
196             }
197
198             for (int i = 0; i < locations.length; i++) {
199                 if (status == UpdateStatus.NoChange) {
200                     if (this.locations[i] != locations[i]) {
201                         status = UpdateStatus.Success;
202                         this.locations[i] = locations[i];
203                     }
204                 } else {
205                     this.locations[i] = locations[i];
206                 }
207             }
208
209             return status;
210         }
211
212         /**
213          * Supposes all ticks labels have the same font style.
214          * To be corrected.
215          * @return the ticks labels font style
216          */
217         public Integer getFontStyle() {
218             if (!labels.isEmpty()) {
219                 return labels.get(0).getFont().getStyle();
220             }
221             return 0;
222         }
223
224         /**
225          * Supposes all ticks labels have the same font style.
226          * To be corrected.
227          * @param fontStyle the ticks labels font style to set
228          */
229         public UpdateStatus setFontStyle(Integer fontStyle) {
230             UpdateStatus status = UpdateStatus.NoChange;
231             for (int i = 0; i < labels.size(); i++) {
232                 Font f = labels.get(i).getFont();
233                 if (f.getStyle() != fontStyle) {
234                     f.setStyle(fontStyle);
235                     status = UpdateStatus.Success;
236                 }
237             }
238
239             return status;
240         }
241
242         /**
243          * Supposes all ticks labels have the same font size.
244          * To be corrected.
245          * @return the ticks labels font size
246          */
247         public Double getFontSize() {
248             if (!labels.isEmpty()) {
249                 return labels.get(0).getFont().getSize();
250             }
251             return 0.0;
252         }
253
254         /**
255          * Supposes all ticks labels have the same font size.
256          * To be corrected.
257          * @param fontSize the ticks labels font size to set
258          */
259         public UpdateStatus setFontSize(Double fontSize) {
260             UpdateStatus status = UpdateStatus.NoChange;
261             for (int i = 0; i < labels.size(); i++) {
262                 Font f = labels.get(i).getFont();
263                 if (f.getSize() != fontSize) {
264                     f.setSize(fontSize);
265                     status = UpdateStatus.Success;
266                 }
267             }
268
269             return status;
270         }
271
272         /**
273          * Supposes all ticks labels have the same font color.
274          * To be corrected.
275          * @return the ticks labels font color
276          */
277         public Integer getFontColor() {
278             if (!labels.isEmpty()) {
279                 return labels.get(0).getFont().getColor();
280             }
281             return 0;
282         }
283
284         /**
285          * Supposes all ticks labels have the same font color.
286          * To be corrected.
287          * @param fontColor the ticks labels font color to set
288          */
289         public UpdateStatus setFontColor(Integer fontColor) {
290             UpdateStatus status = UpdateStatus.NoChange;
291             for (int i = 0; i < labels.size(); i++) {
292                 Font f = labels.get(i).getFont();
293                 if (!f.getColor().equals(fontColor)) {
294                     f.setColor(fontColor);
295                     status = UpdateStatus.Success;
296                 }
297             }
298
299             return status;
300         }
301
302         /**
303          * Supposes all ticks labels have the same font fractional.
304          * To be corrected.
305          * @return the ticks labels font fractional
306          */
307         public Boolean getFontFractional() {
308             if (!labels.isEmpty()) {
309                 return labels.get(0).getFont().getFractional();
310             }
311             return false;
312         }
313
314         /**
315          * Supposes all ticks labels have the same font fractional.
316          * To be corrected.
317          * @param fontFractional the ticks labels font fractional to set
318          */
319         public UpdateStatus setFontFractional(Boolean fontFractional) {
320             UpdateStatus status = UpdateStatus.NoChange;
321             for (int i = 0; i < labels.size(); i++) {
322                 Font f = labels.get(i).getFont();
323                 if (f.getFractional() != fontFractional) {
324                     f.setFractional(fontFractional);
325                     status = UpdateStatus.Success;
326                 }
327             }
328
329             return status;
330         }
331     }
332
333     /** Automatic ticks */
334     TicksArrays automaticTicks;
335
336     /** User ticks */
337     TicksArrays userTicks;
338
339     /** Constructor */
340     public TicksProperty() {
341         auto = false;
342
343         subticks = 0;
344
345         defaultFont = new Font();
346
347         automaticTicks = new TicksArrays(DEFAULT_NUMBER_OF_TICKS);
348         userTicks = new TicksArrays(0);
349     }
350
351     /**
352      * Copy constructor
353      * @param ticksProperty the TicksProperty to copy
354      */
355     public TicksProperty(TicksProperty ticksProperty) {
356         auto = ticksProperty.auto;
357
358         subticks = ticksProperty.subticks;
359
360         defaultFont = new Font(ticksProperty.defaultFont);
361
362         automaticTicks = new TicksArrays(0);
363         userTicks = new TicksArrays(0);
364
365         automaticTicks.setLocations(ticksProperty.automaticTicks.getLocations());
366         userTicks.setLocations(ticksProperty.userTicks.getLocations());
367
368         automaticTicks.setLabels(ticksProperty.automaticTicks.getLabels());
369         userTicks.setLabels(ticksProperty.userTicks.getLabels());
370     }
371
372     @Override
373     public boolean equals(Object o) {
374         if (o instanceof TicksProperty) {
375             TicksProperty tp = (TicksProperty) o;
376             if (tp.auto == auto && tp.subticks == subticks && tp.defaultFont.equals(defaultFont)) {
377                 if (auto) {
378                     return automaticTicks.equals(tp.automaticTicks);
379                 } else {
380                     return userTicks.equals(tp.userTicks);
381                 }
382             }
383         }
384
385         return false;
386     }
387
388     /**
389      * @return the auto
390      */
391     public Boolean getAuto() {
392         return auto;
393     }
394
395     /**
396      * @param auto the auto to set
397      */
398     public UpdateStatus setAuto(Boolean auto) {
399         if (this.auto != auto) {
400             this.auto = auto;
401             return UpdateStatus.Success;
402         }
403
404         return UpdateStatus.NoChange;
405     }
406
407     /**
408      * @return the labels
409      */
410     public ArrayList<FormattedText> getLabels() {
411         if (auto) {
412             return automaticTicks.getLabels();
413         } else {
414             return userTicks.getLabels();
415         }
416     }
417
418     /**
419      * @param labels the labels to set
420      */
421     public UpdateStatus setLabels(ArrayList<FormattedText> labels) {
422         if (auto) {
423             return automaticTicks.setLabels(labels);
424         } else {
425             return userTicks.setLabels(labels);
426         }
427     }
428
429     /**
430      * @return the labels strings
431      */
432     public String[] getLabelsStrings() {
433         if (auto) {
434             return automaticTicks.getLabelsStrings();
435         } else  {
436             return userTicks.getLabelsStrings();
437         }
438     }
439
440     /**
441      * Sets the ticks labels strings
442      * Requires the corresponding ticks locations to have previously been set.
443      * @param labels the labels to set
444      */
445     public UpdateStatus setLabelsStrings(String[] labels) {
446         if (auto) {
447             return automaticTicks.setLabelsStrings(labels);
448         } else {
449             return userTicks.setLabelsStrings(labels);
450         }
451     }
452
453     /**
454      * @return the number of ticks
455      */
456     public Integer getNumber() {
457         if (auto) {
458             return automaticTicks.getNumber();
459         } else {
460             return userTicks.getNumber();
461         }
462     }
463
464     /**
465      * @return the locations
466      */
467     public Double[] getLocations() {
468         if (auto) {
469             return automaticTicks.getLocations();
470         } else {
471             return userTicks.getLocations();
472         }
473     }
474
475     /**
476      * Sets the ticks locations
477      * Also sets the current number of ticks to the size of the locations array
478      * if the latter is resized.
479      * @param locations the locations to set
480      */
481     public UpdateStatus setLocations(Double[] locations) {
482         if (auto) {
483             return automaticTicks.setLocations(locations);
484         } else {
485             return userTicks.setLocations(locations);
486         }
487     }
488
489     /**
490      * @return the subticks
491      */
492     public Integer getSubticks() {
493         return subticks;
494     }
495
496     /**
497      * @param subticks the subticks to set
498      */
499     public UpdateStatus setSubticks(Integer subticks) {
500         if (this.subticks != subticks) {
501             this.subticks = subticks;
502             return UpdateStatus.Success;
503         }
504
505         return UpdateStatus.NoChange;
506     }
507
508     /**
509      * Supposes that all automatic and user ticks labels have the same font style.
510      * To be corrected (commented out block) when the associated C get function is completed.
511      * @return the ticks labels font style
512      */
513     public Integer getFontStyle() {
514         return automaticTicks.getFontStyle();
515
516         /*
517           if (auto) {
518           return automaticTicks.getFontStyle();
519           } else {
520           return userTicks.getFontStyle();
521           }
522         */
523     }
524
525     /**
526      * Supposes that all automatic and user ticks labels have the same font style.
527      * To be corrected (commented out block) when the associated C set function is completed.
528      * @param fontStyle the ticks labels font style to set
529      */
530     public UpdateStatus setFontStyle(Integer fontStyle) {
531         UpdateStatus status = UpdateStatus.NoChange;
532         if (fontStyle != defaultFont.getStyle()) {
533             defaultFont.setStyle(fontStyle);
534             status = UpdateStatus.Success;
535         }
536
537         UpdateStatus s1 = automaticTicks.setFontStyle(fontStyle);
538         UpdateStatus s2 = userTicks.setFontStyle(fontStyle);
539
540         if (status == UpdateStatus.Success || s1 == UpdateStatus.Success || s2 == UpdateStatus.Success) {
541             return UpdateStatus.Success;
542         }
543
544         return UpdateStatus.NoChange;
545
546         /*
547           if (auto) {
548           automaticTicks.setFontStyle(fontStyle);
549           } else {
550           userTicks.setFontStyle(fontStyle);
551           }
552         */
553     }
554
555     /**
556      * Supposes that all automatic and user ticks labels have the same font size.
557      * To be corrected (commented out block) when the associated C get function is completed.
558      * @return the ticks labels font size
559      */
560     public Double getFontSize() {
561         return automaticTicks.getFontSize();
562
563         /*
564           if (auto) {
565           return automaticTicks.getFontSize();
566           } else {
567           return userTicks.getFontSize();
568           }
569         */
570     }
571
572     /**
573      * Supposes that all automatic and user ticks labels have the same font size.
574      * To be corrected (commented out block) when the associated C set function is completed.
575      * @param fontSize the ticks labels font size to set
576      */
577     public UpdateStatus setFontSize(Double fontSize) {
578         UpdateStatus status = UpdateStatus.NoChange;
579         if (fontSize != defaultFont.getSize()) {
580             defaultFont.setSize(fontSize);
581             status = UpdateStatus.Success;
582         }
583
584         UpdateStatus s1 = automaticTicks.setFontSize(fontSize);
585         UpdateStatus s2 = userTicks.setFontSize(fontSize);
586
587         if (status == UpdateStatus.Success || s1 == UpdateStatus.Success || s2 == UpdateStatus.Success) {
588             return UpdateStatus.Success;
589         }
590
591         return UpdateStatus.NoChange;
592
593         /*
594           if (auto) {
595           automaticTicks.setFontSize(fontSize);
596           } else {
597           userTicks.setFontSize(fontSize);
598           }
599         */
600     }
601
602     /**
603      * Supposes that all automatic and user ticks labels have the same font color.
604      * To be corrected (commented out block) when the associated C get function is completed.
605      * @return the ticks labels font color
606      */
607     public Integer getFontColor() {
608         return automaticTicks.getFontColor();
609
610         /*
611           if (auto) {
612           return automaticTicks.getFontColor();
613           } else {
614           return userTicks.getFontColor();
615           }
616         */
617     }
618
619     /**
620      * Supposes that all automatic and user ticks labels have the same font color.
621      * To be corrected (commented out block) when the associated C set function is completed.
622      * @param fontColor the ticks labels font color to set
623      */
624     public UpdateStatus setFontColor(Integer fontColor) {
625         UpdateStatus status = UpdateStatus.NoChange;
626         if (fontColor != defaultFont.getColor()) {
627             defaultFont.setColor(fontColor);
628             status = UpdateStatus.Success;
629         }
630
631         UpdateStatus s1 = automaticTicks.setFontColor(fontColor);
632         UpdateStatus s2 = userTicks.setFontColor(fontColor);
633
634         if (status == UpdateStatus.Success || s1 == UpdateStatus.Success || s2 == UpdateStatus.Success) {
635             return UpdateStatus.Success;
636         }
637
638         return UpdateStatus.NoChange;
639
640         /*
641           if (auto) {
642           automaticTicks.setFontColor(fontColor);
643           } else {
644           userTicks.setFontColor(fontColor);
645           }
646         */
647     }
648
649     /**
650      * Supposes all automatic and user ticks labels have the same font fractional.
651      * To be corrected (commented out block) when the associated C get function is completed.
652      * @return the ticks labels font fractional
653      */
654     public Boolean getFontFractional() {
655         return automaticTicks.getFontFractional();
656
657         /*
658           if (auto) {
659           return automaticTicks.getFontFractional();
660           } else {
661           return userTicks.getFontFractional();
662           }
663         */
664     }
665
666     /**
667      * Supposes all automatic and user ticks labels have the same font fractional.
668      * To be corrected (commented out block) when the associated C set function is completed.
669      * @param fontFractional the ticks labels font fractional to set
670      */
671     public UpdateStatus setFontFractional(Boolean fontFractional) {
672         UpdateStatus status = UpdateStatus.NoChange;
673         if (fontFractional != defaultFont.getFractional()) {
674             defaultFont.setFractional(fontFractional);
675             status = UpdateStatus.Success;
676         }
677
678         UpdateStatus s1 = automaticTicks.setFontFractional(fontFractional);
679         UpdateStatus s2 = userTicks.setFontFractional(fontFractional);
680
681         if (status == UpdateStatus.Success || s1 == UpdateStatus.Success || s2 == UpdateStatus.Success) {
682             return UpdateStatus.Success;
683         }
684
685         return UpdateStatus.NoChange;
686
687         /*
688           if (auto) {
689           automaticTicks.setFontFractional(fontFractional);
690           } else {
691           userTicks.setFontFractional(fontFractional);
692           }
693         */
694     }
695
696 }