1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2013 - Pedro Arthur dos S. Souza
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15 
16 #include "DatatipManager.hxx"
17 
18 extern "C"
19 {
20 #include "api_scilab.h"
21 #include "getScilabJavaVM.h"
22 #include "localization.h"
23 #include "Scierror.h"
24 #include "gw_gui.h"
25 #include "HandleManagement.h"
26 #include "CurrentFigure.h"
27 }
28 
29 using namespace org_scilab_modules_gui_datatip;
30 
sci_datatip_manager_mode(char * fname,void * pvApiCtx)31 int sci_datatip_manager_mode(char *fname, void* pvApiCtx)
32 {
33     int iFigureUID      = NULL;
34 
35     int* piAddr         = NULL;
36     int* pbValue        = NULL;
37     char* pstData       = NULL;
38     int iRows           = 0;
39     int iCols           = 0;
40     int stkAdr          = 0;
41     int iType           = 0;
42     int iLen            = 0;
43     int iErr            = 0;
44     bool enabled        = false;
45     long long llHandle  = 0;
46 
47     SciErr sciErr;
48     CheckInputArgument(pvApiCtx, 0, 2);
49     CheckOutputArgument(pvApiCtx, 0, 1);
50 
51     if (nbInputArgument(pvApiCtx) == 0)
52     {
53         iFigureUID = getCurrentFigure();
54         if (iFigureUID)
55         {
56             enabled = DatatipManager::isEnabled(getScilabJavaVM(), iFigureUID);
57             DatatipManager::setEnabled(getScilabJavaVM(), iFigureUID, (!enabled));
58         }
59     }
60     else if (nbInputArgument(pvApiCtx) == 1)
61     {
62         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
63         if (sciErr.iErr)
64         {
65             printError(&sciErr, 0);
66             return 1;
67         }
68 
69         sciErr = getVarType(pvApiCtx, piAddr, &iType);
70         if (sciErr.iErr)
71         {
72             printError(&sciErr, 0);
73             return 1;
74         }
75 
76         switch (iType)
77         {
78             case sci_boolean :
79                 sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &pbValue);
80                 if (sciErr.iErr)
81                 {
82                     printError(&sciErr, 0);
83                     return 1;
84                 }
85                 if (iRows * iCols != 1)
86                 {
87                     Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 1);
88                     return 1;
89                 }
90                 iFigureUID = getCurrentFigure();
91                 enabled = pbValue[0] == 0 ? false : true;
92                 break;
93             case sci_strings :
94                 sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
95                 if (sciErr.iErr)
96                 {
97                     printError(&sciErr, 0);
98                     return 1;
99                 }
100                 if (iRows * iCols != 1)
101                 {
102                     Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 1);
103                     return 1;
104                 }
105                 sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &iLen, NULL);
106                 if (sciErr.iErr)
107                 {
108                     printError(&sciErr, 0);
109                     return 1;
110                 }
111                 pstData = (char*) malloc(sizeof(char) * (iLen + 1));
112                 sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &iLen, &pstData);
113                 if (sciErr.iErr)
114                 {
115                     printError(&sciErr, 0);
116                     free(pstData);
117                     return 1;
118                 }
119                 if (strcmp("on", pstData) == 0 || strcmp("T", pstData) == 0 || strcmp("1", pstData) == 0)
120                 {
121                     iFigureUID = getCurrentFigure();
122                     enabled = true;
123                 }
124                 else if (strcmp("off", pstData) == 0 || strcmp("F", pstData) == 0 || strcmp("0", pstData) == 0)
125                 {
126                     iFigureUID = getCurrentFigure();
127                     enabled = false;
128                 }
129                 else
130                 {
131                     free(pstData);
132                     Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "on", "off");
133                     return 1;
134                 }
135                 free(pstData);
136                 break;
137             case sci_handles :
138                 iErr = getScalarHandle(pvApiCtx, piAddr, &llHandle);
139                 if (iErr)
140                 {
141                     Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
142                     return 1;
143                 }
144                 iFigureUID = getObjectFromHandle((unsigned long) llHandle);
145                 if (iFigureUID)
146                 {
147                     enabled = !(DatatipManager::isEnabled(getScilabJavaVM(), iFigureUID));
148                 }
149                 break;
150             default :
151                 Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 1);
152                 return 1;
153         }
154     }
155     else if (nbInputArgument(pvApiCtx) == 2)
156     {
157         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
158         if (sciErr.iErr)
159         {
160             printError(&sciErr, 0);
161             return 1;
162         }
163 
164         iErr = getScalarHandle(pvApiCtx, piAddr, &llHandle);
165         if (iErr)
166         {
167             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
168             return 1;
169         }
170 
171         iFigureUID = getObjectFromHandle((unsigned long) llHandle);
172 
173         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr);
174         if (sciErr.iErr)
175         {
176             printError(&sciErr, 0);
177             return 1;
178         }
179 
180         sciErr = getVarType(pvApiCtx, piAddr, &iType);
181         if (sciErr.iErr)
182         {
183             printError(&sciErr, 0);
184             return 1;
185         }
186 
187         switch (iType)
188         {
189             case sci_boolean :
190                 sciErr = getMatrixOfBoolean(pvApiCtx, piAddr, &iRows, &iCols, &pbValue);
191                 if (sciErr.iErr)
192                 {
193                     printError(&sciErr, 0);
194                     return 1;
195                 }
196                 if (iRows * iCols != 1)
197                 {
198                     Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 1);
199                     return 1;
200                 }
201                 iFigureUID = getCurrentFigure();
202                 enabled = pbValue[0] == 0 ? false : true;
203                 break;
204             case sci_strings :
205                 sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, NULL, NULL);
206                 if (sciErr.iErr)
207                 {
208                     printError(&sciErr, 0);
209                     return 1;
210                 }
211                 if (iRows * iCols != 1)
212                 {
213                     Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 1);
214                     return 1;
215                 }
216                 sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &iLen, NULL);
217                 if (sciErr.iErr)
218                 {
219                     printError(&sciErr, 0);
220                     return 1;
221                 }
222                 pstData = (char*) malloc(sizeof(char) * (iLen + 1));
223                 sciErr = getMatrixOfString(pvApiCtx, piAddr, &iRows, &iCols, &iLen, &pstData);
224                 if (sciErr.iErr)
225                 {
226                     printError(&sciErr, 0);
227                     free(pstData);
228                     return 1;
229                 }
230                 if (strcmp("on", pstData) == 0 || strcmp("T", pstData) == 0 || strcmp("1", pstData) == 0)
231                 {
232                     iFigureUID = getCurrentFigure();
233                     enabled = true;
234                 }
235                 else if (strcmp("off", pstData) == 0 || strcmp("F", pstData) == 0 || strcmp("0", pstData) == 0)
236                 {
237                     iFigureUID = getCurrentFigure();
238                     enabled = false;
239                 }
240                 else
241                 {
242                     free(pstData);
243                     Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "on", "off");
244                     return 1;
245                 }
246                 free(pstData);
247                 break;
248             default :
249                 Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 2);
250                 return 1;
251         }
252     }
253     else
254     {
255         Scierror(999, _("%s: Wrong number for input argument: %d expected.\n"), fname, 2);
256         return 1;
257     }
258 
259     if (iFigureUID)
260     {
261         DatatipManager::setEnabled(getScilabJavaVM(), iFigureUID, enabled);
262     }
263 
264     AssignOutputVariable(pvApiCtx, 1) = 0;
265     ReturnArguments(pvApiCtx);
266     return 0;
267 }
268 
269