GUI module ported to api_scilab. test_run("gui")
[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 "stack-c.h"
25 #include "Scierror.h"
26 #include "HandleManagement.h"
27 #include "GetProperty.h"
28 #include "InitObjects.h"
29 #include "freeArrayOfString.h"
30
31 #include "SetHashTable.h"
32 #include "SetPropertyStatus.h"
33
34 #include "MALLOC.h"             /* MALLOC */
35 #include "localization.h"
36 #include "stricmp.h"
37 #include "api_scilab.h"
38 /*--------------------------------------------------------------------------
39  * sciset(choice-name,x1,x2,x3,x4,x5)
40  * or   xset()
41  *-----------------------------------------------------------*/
42 int sci_set(char *fname, unsigned long fname_len)
43 {
44     SciErr sciErr;
45
46     int* piAddr1 = NULL;
47     int* piAddr2 = NULL;
48     int* piAddr3 = NULL;
49     int lw = 0;
50     int isMatrixOfString = 0;
51
52     char* pstProperty = NULL;
53     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
54     if (sciErr.iErr)
55     {
56         //error
57         return 1;
58     }
59
60     if (isMListType(pvApiCtx, piAddr1) || isTListType(pvApiCtx, piAddr1))
61     {
62         OverLoad(1);
63         return 0;
64     }
65
66     CheckRhs(2, 3);
67     CheckLhs(0, 1);
68
69     if (isDoubleType(pvApiCtx, piAddr1))   /* tclsci handle */
70     {
71         /* call "set" for tcl/tk see tclsci/sci_gateway/c/sci_set.c */
72         OverLoad(1);
73         return 0;
74     }
75     else                        /* others types */
76     {
77         int iRows1 = 0, iCols1 = 0;
78         int iRows2 = 0, iCols2 = 0;
79         int iRows3 = 0, iCols3 = 0;
80         void* _pvData = NULL;
81         unsigned long hdl;
82         char *pobjUID = NULL;
83
84         int iType1 = 0;
85
86         int valueType = 0;      /* type of the rhs */
87
88         int setStatus = 0;
89
90         /* after the call to sciSet get the status : 0 <=> OK,          */
91         /*                                          -1 <=> Error,       */
92         /*                                           1 <=> nothing done */
93
94         /*  set or create a graphic window */
95         sciErr = getVarType(pvApiCtx, piAddr1, &iType1);
96         if (sciErr.iErr)
97         {
98             //error
99             return 1;
100         }
101         switch (iType1)
102         {
103             case sci_handles:
104                 /* first is a scalar argument so it's a gset(hdl,"command",[param]) */
105                 /* F.Leray; INFO: case 9 is considered for a matrix of graphic handles */
106                 CheckRhs(3, 3);
107
108                 if (isScalar(pvApiCtx, piAddr1) == FALSE)
109                 {
110                     OverLoad(1);
111                     return 0;
112                 }
113
114                 getScalarHandle(pvApiCtx, piAddr1, (long long*)&hdl);
115                 pobjUID = (char*)getObjectFromHandle(hdl);
116
117                 getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
118                 getAllocatedSingleString(pvApiCtx, piAddr2, &pstProperty);
119                 valueType = getInputArgumentType(pvApiCtx, 3);
120
121                 getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
122                 if ((strcmp(pstProperty, "user_data") == 0) || (stricmp(pstProperty, "userdata") == 0))
123                 {
124                     /* in this case set_user_data_property
125                      * directly uses the  third position in the stack
126                      * to get the variable which is to be set in
127                      * the user_data property (any data type is allowed) S. Steer */
128                     _pvData = (void*)piAddr3;         /*position in the stack */
129                     iRows3 = -1;   /*unused */
130                     iCols3 = -1;   /*unused */
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 iPropertyFounded = 0;
258
259             for (i = 0; i < NB_PROPERTIES_SUPPORTED; i++)
260             {
261
262                 if (strcmp(propertiesSupported[i], pstProperty) == 0)
263                 {
264                     iPropertyFounded = 1;
265                 }
266             }
267
268             if (iPropertyFounded)
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 allacted 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         AssignOutputVariable(pvApiCtx, 1) = 0;
302         ReturnArguments(pvApiCtx);
303     }
304
305     return 0;
306 }
307
308 /*--------------------------------------------------------------------------*/