Set datatips handle as hidden
[scilab.git] / scilab / modules / graphic_objects / src / java / org / scilab / modules / graphic_objects / datatip / Datatip.java
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Pedro Arthur dos S. Souza
4  * Copyright (C) 2012 - Caio Lucas dos S. Souza
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.datatip;
15
16 import static org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties.*;
17 import org.scilab.modules.graphic_objects.graphicObject.GraphicObjectProperties;
18 import org.scilab.modules.graphic_objects.textObject.Text;
19 import org.scilab.modules.graphic_objects.graphicObject.Visitor;
20
21 import java.text.DecimalFormat;
22
23 import org.scilab.modules.action_binding.InterpreterManagement;
24
25 public class Datatip extends Text {
26
27     /** Stores the data that will be shown(tip)*/
28     Double[] tipData;
29     /** false = datatip text box is hidden*/
30     Boolean tipBoxMode;
31     /** false = datatip label is hidden*/
32     Boolean tipLabelMode;
33     /** false = display only (X, Y), true = display (X, Y, Z)*/
34     Boolean use3component;
35     /** false = no interpolation between point segments*/
36     Boolean interpMode;
37     /** Displayed number format*/
38     DecimalFormat tipTextFormat;
39     /** Display function*/
40     String displayFnc;
41     /** For automatic update the datatip orientation*/
42     Boolean autoOrientation;
43
44
45     enum DatatipObjectProperty { TIP_DATA, TIP_BOX_MODE, TIP_LABEL_MODE, TIP_ORIENTATION, TIP_AUTOORIENTATION, TIP_3COMPONENT, TIP_INTERP_MODE, TIP_DISPLAY_FNC };
46     enum TipOrientation { TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT;
47
48                           /**
49                            * Transform a integer to a TipOrientation enum.
50                            */
51     public static TipOrientation intToEnum(Integer i) {
52         switch (i) {
53             case 0:
54                 return TipOrientation.TOP_LEFT;
55             case 1:
56                 return TipOrientation.TOP_RIGHT;
57             case 2:
58                 return TipOrientation.BOTTOM_LEFT;
59             case 3:
60                 return TipOrientation.BOTTOM_RIGHT;
61             default:
62                 return TipOrientation.TOP_RIGHT;
63         }
64     }
65
66                         };
67
68     TipOrientation currentOrientation;
69
70     /**
71      * Initializes the datatip, setup format, orientation and mark.
72      */
73     public Datatip() {
74         super();
75         tipData = new Double[] {0.0, 0.0, 0.0};
76         use3component = false;
77         autoOrientation = true;
78         setOrientationAsEnum(TipOrientation.TOP_RIGHT);
79         tipTextFormat = new DecimalFormat("#.####");
80         tipBoxMode = true;
81         tipLabelMode = true;
82         interpMode = true;
83         displayFnc = "";
84         setVisible(true);
85         setHidden(true); /* To avoid to see the datatips in Scilab when reading 'children' property */
86         setBox(true);
87         setLineMode(true);
88         setFillMode(true);
89         setBackground(-2);
90         setClipState(1);
91
92         setMarkMode(true);
93         setMarkSize(8);
94         setMarkBackground(-1);
95         setMarkForeground(-1);
96         setMarkStyle(11);
97     }
98
99     @Override
100     public void accept(Visitor visitor) {
101         visitor.visit(this);
102     }
103
104     /**
105      * Convert the property name to the DatatipObjectProperty enum.
106      */
107     public Object getPropertyFromName(int propertyName) {
108         switch (propertyName) {
109             case __GO_DATATIP_DATA__:
110                 return DatatipObjectProperty.TIP_DATA;
111             case __GO_DATATIP_BOX_MODE__:
112                 return DatatipObjectProperty.TIP_BOX_MODE;
113             case __GO_DATATIP_LABEL_MODE__:
114                 return DatatipObjectProperty.TIP_LABEL_MODE;
115             case __GO_DATATIP_ORIENTATION__:
116                 return DatatipObjectProperty.TIP_ORIENTATION;
117             case __GO_DATATIP_3COMPONENT__:
118                 return DatatipObjectProperty.TIP_3COMPONENT;
119             case __GO_DATATIP_AUTOORIENTATION__:
120                 return DatatipObjectProperty.TIP_AUTOORIENTATION;
121             case __GO_DATATIP_INTERP_MODE__:
122                 return DatatipObjectProperty.TIP_INTERP_MODE;
123             case __GO_DATATIP_DISPLAY_FNC__:
124                 return DatatipObjectProperty.TIP_DISPLAY_FNC;
125             default:
126                 return super.getPropertyFromName(propertyName);
127         }
128     }
129
130     /**
131      * @return the datatip property
132      */
133     public Object getProperty(Object property) {
134         if (property == DatatipObjectProperty.TIP_DATA) {
135             return getTipData();
136         } else if (property == DatatipObjectProperty.TIP_BOX_MODE) {
137             return getTipBoxMode();
138         } else if (property == DatatipObjectProperty.TIP_LABEL_MODE) {
139             return getTipLabelMode();
140         } else if (property == DatatipObjectProperty.TIP_ORIENTATION) {
141             return getOrientation();
142         } else if (property == DatatipObjectProperty.TIP_3COMPONENT) {
143             return isUsing3Component();
144         } else if (property == DatatipObjectProperty.TIP_AUTOORIENTATION) {
145             return isAutoOrientationEnabled();
146         } else if (property == DatatipObjectProperty.TIP_INTERP_MODE) {
147             return getInterpMode();
148         } else if (property == DatatipObjectProperty.TIP_DISPLAY_FNC) {
149             return getDisplayFunction();
150         } else {
151             return super.getProperty(property);
152         }
153     }
154
155     /**
156      * Set the datatip property
157      * @param property the property
158      * @param value the new property value.
159      */
160     public UpdateStatus setProperty(Object property, Object value) {
161         if (property == DatatipObjectProperty.TIP_DATA) {
162             setTipData((Double[]) value);
163         } else if (property == DatatipObjectProperty.TIP_BOX_MODE) {
164             setTipBoxMode((Boolean) value);
165         } else if (property == DatatipObjectProperty.TIP_LABEL_MODE) {
166             setTipLabelMode((Boolean) value);
167         } else if (property == DatatipObjectProperty.TIP_ORIENTATION) {
168             setOrientation((Integer) value);
169         } else if (property == DatatipObjectProperty.TIP_3COMPONENT) {
170             setUse3Component((Boolean)value);
171         } else if (property == DatatipObjectProperty.TIP_AUTOORIENTATION) {
172             setAutoOrientation((Boolean)value);
173         } else if (property == DatatipObjectProperty.TIP_INTERP_MODE) {
174             setInterpMode((Boolean) value);
175         } else if (property == DatatipObjectProperty.TIP_DISPLAY_FNC) {
176             setDisplayFunction((String) value);
177         } else {
178             return super.setProperty(property, value);
179         }
180
181         return UpdateStatus.Success;
182     }
183
184     /**
185      * Set the data tip that will be shown
186      * @param data A 3 element vector with the data (x, y, z).
187      */
188     public void setTipData(Double[] data) {
189         tipData[0] = data[0];
190         tipData[1] = data[1];
191         tipData[2] = data[2];
192         updateText();
193     }
194
195     /**
196      * Get the current tip data
197      * @return the tip data
198      */
199     public Double[] getTipData() {
200         Double[] ret = new Double[3];
201         ret[0] = tipData[0];
202         ret[1] = tipData[1];
203         ret[2] = tipData[2];
204         return ret;
205     }
206
207     /**
208      * Get the current textbox orientation as an integer
209      * @return current orientation.
210      */
211     public Integer getOrientation() {
212         return getOrientationAsEnum().ordinal();
213     }
214
215     /**
216      * Get the current oriantation as a enum
217      * @return the current orientation
218      */
219     public TipOrientation getOrientationAsEnum() {
220         return currentOrientation;
221     }
222
223     /**
224      * Set the current orientation (updating the text position)
225      * @param orientation the new orientation (integer).
226      */
227     public void setOrientation(Integer orientation) {
228         currentOrientation = TipOrientation.intToEnum(orientation);
229     }
230
231     /**
232      * Set the current orientation (updating the text position)
233      * @param orientation the new orientation (TipOrientation enum).
234      */
235     public void setOrientationAsEnum(TipOrientation orientation) {
236         currentOrientation = orientation;
237     }
238
239     /**
240      * @return true if the datatip is displaying the Z component, false otherwise.
241      */
242     public Boolean isUsing3Component() {
243         return use3component;
244     }
245
246     /**
247      * If true set the Z component to be displayed.
248      * @param useZ True to enable display the Z component, false to disable.
249      */
250     public void setUse3Component(Boolean useZ) {
251         use3component = useZ;
252         updateText();
253     }
254
255
256     public Boolean isAutoOrientationEnabled() {
257         return autoOrientation;
258     }
259
260     public void setAutoOrientation(Boolean status) {
261         autoOrientation = status;
262     }
263
264
265
266     /**
267      * Update the text from the datatip base on current tipData value.
268      */
269     void updateText() {
270         String[] textArray = new String[] {"X:", "Y:", "Z:"};
271         textArray[0] += tipTextFormat.format(tipData[0]);
272         textArray[1] += tipTextFormat.format(tipData[1]);
273         textArray[2] += tipTextFormat.format(tipData[2]);
274
275         Integer[] dim = new Integer[2];
276         dim[0] = use3component ? 3 : 2;
277         dim[1] = 1;
278
279         setTextArrayDimensions(dim);
280         setTextStrings(textArray);
281     }
282
283     /**
284      * Update the text from the datatip for datatipSetDisplay
285      */
286     void updateTextDispFunction(String displayFnc) {
287
288         if (displayFnc.length() != 0) {
289             String updateCommand = "try;" +
290                                    "d = getcallbackobject(\"" + getIdentifier() + "\");" +
291                                    "d.text = " + displayFnc + "(d.tip_data);" +
292                                    "clear(\"d\");" +
293                                    "catch;" +
294                                    "d.tip_disp_function = \"\";" +
295                                    "clear(\"d\");" +
296                                    "error(msprintf(_( \"%s: Wrong name of input argument #%d: Function ''%s'' not defined.\n\"),\"datatipSetDisplay\",2,\"" + displayFnc + "\"));" +
297                                    "end;";
298
299
300             InterpreterManagement.requestScilabExec(updateCommand);
301         } else {
302             updateText();
303         }
304
305     }
306
307     public Boolean getTipBoxMode() {
308         return tipBoxMode;
309     }
310
311     public Boolean getTipLabelMode() {
312         return tipLabelMode;
313     }
314
315     public Boolean getInterpMode() {
316         return interpMode;
317     }
318
319     public String getDisplayFunction() {
320         return displayFnc;
321     }
322
323     public void setTipBoxMode(Boolean mode) {
324         tipBoxMode = mode;
325         setBox(tipBoxMode);
326     }
327
328     public void setTipLabelMode(Boolean mode) {
329         tipLabelMode = mode;
330     }
331
332     public void setInterpMode(Boolean mode) {
333         interpMode = mode;
334     }
335
336     public void setDisplayFunction(String fnc) {
337         displayFnc = fnc;
338         updateTextDispFunction(displayFnc);
339     }
340
341     @Override
342     public Double[] getPosition() {
343         return getTipData();
344     }
345
346     /**
347      * @return Type as String
348      */
349     public Integer getType() {
350         return GraphicObjectProperties.__GO_DATATIP__;
351     }
352
353 }