Merge remote-tracking branch 'origin/master' into YaSp
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_set.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Allan Cornet
4  * Copyright (C) 2006 - INRIA - Fabrice Leray
5  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
6  * Copyright (C) 2006 - INRIA - Vincent Couvert
7  * Copyright (C) 2011 - DIGITEO - Allan CORNET
8  *
9  * This file must be used under the terms of the CeCILL.
10  * This source file is licensed as described in the file COPYING, which
11  * you should have received as part of this distribution.  The terms
12  * are also available at
13  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
14  *
15  */
16
17 /*------------------------------------------------------------------------*/
18 /* file: sci_set.h                                                        */
19 /* desc : interface for sci_set routine                                   */
20 /*------------------------------------------------------------------------*/
21 #include <stdio.h>
22 /*------------------------------------------------------------------------*/
23 #include "gw_graphics.h"
24 #include "Scierror.h"
25 #include "HandleManagement.h"
26 #include "GetProperty.h"
27 #include "InitObjects.h"
28 #include "freeArrayOfString.h"
29
30 #include "SetHashTable.h"
31 #include "SetPropertyStatus.h"
32
33 #include "MALLOC.h"             /* MALLOC */
34 #include "localization.h"
35 #include "stricmp.h"
36 #include "api_scilab.h"
37 /*--------------------------------------------------------------------------
38  * sciset(choice-name,x1,x2,x3,x4,x5)
39  * or   xset()
40  *-----------------------------------------------------------*/
41 int sci_set(char *fname, void *pvApiCtx)
42 {
43     SciErr sciErr;
44
45     int* piAddr1 = NULL;
46     int* piAddr2 = NULL;
47     int* piAddr3 = NULL;
48     int lw = 0;
49     int isMatrixOfString = 0;
50
51     char* pstProperty = NULL;
52     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
53     if (sciErr.iErr)
54     {
55         //error
56         return 1;
57     }
58
59     if (isMListType(pvApiCtx, piAddr1) || isTListType(pvApiCtx, piAddr1))
60     {
61         OverLoad(1);
62         return 0;
63     }
64
65     CheckRhs(2, 3);
66     CheckLhs(0, 1);
67
68     if (isDoubleType(pvApiCtx, piAddr1))   /* tclsci handle */
69     {
70         /* call "set" for tcl/tk see tclsci/sci_gateway/c/sci_set.c */
71         OverLoad(1);
72         return 0;
73     }
74     else                        /* others types */
75     {
76         int iRows1 = 0, iCols1 = 0;
77         int iRows2 = 0, iCols2 = 0;
78         int iRows3 = 0, iCols3 = 0;
79         void* _pvData = NULL;
80         unsigned long hdl;
81         char *pobjUID = NULL;
82
83         int iType1 = 0;
84
85         int valueType = 0;      /* type of the rhs */
86
87         int setStatus = 0;
88
89         /* after the call to sciSet get the status : 0 <=> OK,          */
90         /*                                          -1 <=> Error,       */
91         /*                                           1 <=> nothing done */
92
93         /*  set or create a graphic window */
94         sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
95         if (sciErr.iErr)
96         {
97             //error
98             return 1;
99         }
100         switch (iType1)
101         {
102             case sci_handles:
103                 /* first is a scalar argument so it's a gset(hdl,"command",[param]) */
104                 /* F.Leray; INFO: case 9 is considered for a matrix of graphic handles */
105                 CheckRhs(3, 3);
106
107                 if (isScalar(pvApiCtx, piAddr1) == FALSE)
108                 {
109                     OverLoad(1);
110                     return 0;
111                 }
112
113                 getScalarHandle(pvApiCtx, piAddr1, (long long*)&hdl);
114                 pobjUID = (char*)getObjectFromHandle(hdl);
115
116                 getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
117                 getAllocatedSingleString(pvApiCtx, piAddr2, &pstProperty);
118                 valueType = getInputArgumentType(pvApiCtx, 3);
119
120                 getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
121                 if ((strcmp(pstProperty, "user_data") == 0) || (stricmp(pstProperty, "userdata") == 0))
122                 {
123                     /* in this case set_user_data_property
124                      * directly uses the  third position in the stack
125                      * to get the variable which is to be set in
126                      * the user_data property (any data type is allowed) S. Steer */
127                     _pvData = (void*)piAddr3;         /*position in the stack */
128                     iRows3 = -1;   /*unused */
129                     iCols3 = -1;   /*unused */
130                     valueType = -1;
131                 }
132                 else if (valueType == sci_matrix)
133                 {
134                     getMatrixOfDouble(pvApiCtx, piAddr3, &iRows3, &iCols3, (double**)&_pvData);
135                 }
136                 else if (valueType == sci_boolean)
137                 {
138                     getMatrixOfBoolean(pvApiCtx, piAddr3, &iRows3, &iCols3, (int**)&_pvData);
139                 }
140                 else if (valueType == sci_handles)
141                 {
142                     getMatrixOfHandle(pvApiCtx, piAddr3, &iRows3, &iCols3, (long long**)&_pvData);
143                 }
144                 else if (valueType == sci_strings)
145                 {
146                     if (   strcmp(pstProperty, "tics_labels") != 0 && strcmp(pstProperty, "auto_ticks") != 0 &&
147                             strcmp(pstProperty, "axes_visible") != 0 && strcmp(pstProperty, "axes_reverse") != 0 &&
148                             strcmp(pstProperty, "text") != 0 && stricmp(pstProperty, "string") != 0 &&
149                             stricmp(pstProperty, "tooltipstring") != 0) /* Added for uicontrols */
150                     {
151                         getAllocatedSingleString(pvApiCtx, piAddr3, (char**)&_pvData);
152                         iRows3 = (int)strlen((char*)_pvData);
153                         iCols3 = 1;
154                     }
155                     else
156                     {
157                         isMatrixOfString = 1;
158                         getAllocatedMatrixOfString(pvApiCtx, piAddr3, &iRows3, &iCols3, (char***)&_pvData);
159                     }
160                 }
161                 else if (valueType == sci_list) /* Added for callbacks */
162                 {
163                     iCols3 = 1;
164                     getListItemNumber(pvApiCtx, piAddr3, &iRows3);
165                     _pvData = (void*)piAddr3;         /* In this case l3 is the list position in stack */
166                 }
167                 break;
168
169             case sci_strings:      /* first is a string argument so it's a set("command",[param]) */
170                 CheckRhs(2, 2);
171                 getAllocatedSingleString(pvApiCtx, piAddr1, &pstProperty);
172                 hdl = 0;
173                 pobjUID = NULL;
174                 valueType = getInputArgumentType(pvApiCtx, 2);
175                 getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
176
177                 if (valueType == sci_matrix)
178                 {
179                     getMatrixOfDouble(pvApiCtx, piAddr2, &iRows3, &iCols3, (double**)&_pvData);
180                 }
181                 else if (valueType == sci_handles)
182                 {
183                     getMatrixOfHandle(pvApiCtx, piAddr2, &iRows3, &iCols3, (long long**)&_pvData);
184                 }
185                 else if (valueType == sci_strings)
186                 {
187                     if (strcmp(pstProperty, "tics_labels") == 0 || strcmp(pstProperty, "auto_ticks") == 0 ||
188                             strcmp(pstProperty, "axes_visible") == 0 || strcmp(pstProperty, "axes_reverse") == 0 ||
189                             strcmp(pstProperty, "text") == 0)
190                     {
191                         isMatrixOfString = 1;
192                         getAllocatedMatrixOfString(pvApiCtx, piAddr2, &iRows3, &iCols3, (char***)&_pvData);
193                     }
194                     else
195                     {
196                         getAllocatedSingleString(pvApiCtx, piAddr2, (char**)&_pvData);
197                         iRows3 = (int)strlen((char*)_pvData);
198                         iCols3 = 1;
199                     }
200                 }
201                 break;
202
203             default:
204                 Scierror(999, _("%s: Wrong type for input argument #%d: String or handle expected.\n"), fname, 1);
205                 return 0;
206                 break;
207         }
208
209         if (hdl != 0)
210         {
211             pobjUID = (char*)getObjectFromHandle(hdl);
212
213             if (pobjUID == NULL)
214             {
215                 Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
216                 return 0;
217             }
218
219             // Only set the property whitout doing anythig else.
220             //static int sciSet(void* _pvCtx, char *pobjUID, char *marker, void* value, int valueType, int *numrow, int *numcol)
221             setStatus = callSetProperty(pvApiCtx, pobjUID, _pvData, valueType, iRows3, iCols3, pstProperty);
222             if (valueType == sci_strings)
223             {
224                 //free allacted data
225                 if (isMatrixOfString == 1)
226                 {
227                     freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData);
228                 }
229                 else
230                 {
231                     freeAllocatedSingleString((char*)_pvData);
232                 }
233             }
234         }
235         else
236         {
237 #define NB_PROPERTIES_SUPPORTED 7
238             /* No object specified */
239             /* ONLY supported properties are */
240             /* 'current_entity' */
241             /* 'hdl' */
242             /* 'current_figure' */
243             /* 'current_axes' */
244             /* 'default_values' */
245             /* 'figure_style' for compatibility but do nothing */
246             /* others values must return a error */
247             char *propertiesSupported[NB_PROPERTIES_SUPPORTED] = { "current_entity",
248                     "hdl",
249                     "current_figure",
250                     "current_axes",
251                     "figure_style",
252                     "default_values",
253                     "auto_clear"
254                                                                  };
255
256             int i = 0;
257             int iPropertyFound = 0;
258
259             for (i = 0; i < NB_PROPERTIES_SUPPORTED; i++)
260             {
261
262                 if (strcmp(propertiesSupported[i], pstProperty) == 0)
263                 {
264                     iPropertyFound = 1;
265                 }
266             }
267
268             if (iPropertyFound)
269             {
270                 // we do nothing with "figure_style" "new" (to remove in 5.4)
271                 int bDoSet = ((isMatrixOfString) && (strcmp(pstProperty, "figure_style") == 0) && (strcmp(((char**)_pvData)[0], "new") == 0)) != 1;
272
273                 if (bDoSet)
274                 {
275                     setStatus = callSetProperty(pvApiCtx, NULL, _pvData, valueType, iRows3, iCols3, pstProperty);
276                     if (valueType == sci_strings)
277                     {
278                         //free allocated data
279                         if (isMatrixOfString == 1)
280                         {
281                             freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData);
282                         }
283                         else
284                         {
285                             freeAllocatedSingleString((char*)_pvData);
286                         }
287                     }
288                 }
289             }
290             else
291             {
292                 Scierror(999, _("%s: Wrong value for input argument #%d: a valid property expected.\n"), fname, 1);
293                 if (isMatrixOfString)
294                 {
295                     freeArrayOfString((char **)_pvData, iRows3 * iCols3);
296                 }
297                 return 0;
298             }
299         }
300
301         if (isMatrixOfString)
302         {
303             freeArrayOfString((char **)_pvData, iRows3 * iCols3);
304         }
305
306         AssignOutputVariable(pvApiCtx, 1) = 0;
307         ReturnArguments(pvApiCtx);
308     }
309
310     return 0;
311 }
312
313 /*--------------------------------------------------------------------------*/