GUI module ported to api_scilab. test_run("gui")
[scilab.git] / scilab / modules / gui / sci_gateway / c / sci_uimenu.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 - Jean-Baptiste Silvy
5  * Copyright (C) 2006 - INRIA - Fabrice Leray
6  * Copyright (C) 2011 - DIGITEO - Allan CORNET
7  * desc : interface for sci_uimenu routine
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 #include "BuildObjects.h"
19 #include "gw_gui.h"
20 #include "localization.h"
21 #include "stack-c.h"
22 #include "GetProperty.h"
23 #include "sciprint.h"
24 #include "SetPropertyStatus.h"
25 #include "SetHashTable.h"
26 #include "localization.h"
27 #include "Scierror.h"
28 #include "stricmp.h"
29 #include "CreateUimenu.h"
30 #include "setGraphicObjectProperty.h"
31 #include "getGraphicObjectProperty.h"
32 #include "graphicObjectProperties.h"
33 #include "CurrentFigure.h"
34 #include "api_scilab.h"
35 #include "HandleManagement.h"
36 /*--------------------------------------------------------------------------*/
37 // callSetProperty get a stack pointer in input argument.
38 /*--------------------------------------------------------------------------*/
39 int sci_uimenu(char *fname, unsigned long fname_len)
40 {
41     SciErr sciErr;
42     int nbRow = 0, nbCol = 0;
43     int setStatus = SET_PROPERTY_SUCCEED;
44     int inputIndex = 0, beginIndex = 0;
45     char *propertyName = NULL;
46     char *pParentUID = NULL;
47     unsigned long GraphicHandle = 0;
48     int parentDefined = FALSE;
49     char *pstCurrentFigure = NULL;
50     int iParentType = -1;
51     int *piParentType = &iParentType;
52
53     /* Create a new menu */
54     GraphicHandle = getHandle(CreateUimenu());
55
56     /* If no nbInputArgument(pvApiCtx) -> current figure is the parent (Ascendant compatibility) */
57     if (nbInputArgument(pvApiCtx) == 0)
58     {
59         // Set the parent property
60         pstCurrentFigure = (char*)getCurrentFigure();
61         if (pstCurrentFigure == NULL)
62         {
63             pstCurrentFigure = createNewFigureWithAxes();
64         }
65         setGraphicObjectRelationship(pstCurrentFigure, getObjectFromHandle(GraphicHandle));
66     }
67
68     /**
69      * Odd number of input arguments
70      * First input is the parent ID
71      * All event inputs are property names
72      * All odd (except first) inputs are property values
73      */
74     if (nbInputArgument(pvApiCtx) % 2 == 1)
75     {
76         if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
77         {
78             Scierror(999, _("%s: Wrong type for input argument #%d: A graphic handle expected.\n"), fname, 1);
79             return FALSE;
80         }
81         else                    /* Get parent ID */
82         {
83             int *piAddr = NULL;
84             long long hParent = 0;
85             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
86             if (sciErr.iErr)
87             {
88                 printError(&sciErr, 0);
89                 return 1;
90             }
91
92             // Retrieve a matrix of handle at position 1.
93             // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
94             if (getScalarHandle(pvApiCtx, piAddr, &hParent))
95             {
96                 Scierror(202, _("%s: Wrong type for argument %d: Handle expected.\n"), fname, 1);
97                 return 1;
98             }
99
100             pParentUID = (char*)getObjectFromHandle((long)hParent);
101             if (pParentUID != NULL)
102             {
103                 getGraphicObjectProperty(pParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
104                 if (iParentType == __GO_FIGURE__ && iParentType == __GO_UIMENU__)
105                 {
106                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or '%s' handle expected.\n"), fname, 1, "Figure", "Uimenu");
107                     return FALSE;
108                 }
109
110                 // Set the parent property
111                 callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), &hParent, sci_handles, 1, 1, "parent");
112
113                 // Set the flag to avoid setting the parent two times
114                 parentDefined = TRUE;
115             }
116             else
117             {
118                 Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or '%s' handle expected.\n"), fname, 1, "Figure", "Uimenu");
119                 return FALSE;
120             }
121
122             // First input parameter which is a property name
123             beginIndex = 2;
124         }
125     }
126     /**
127      * Even number of input arguments
128      * All odd inputs are property names
129      * All even inputs are property values
130      */
131     else
132     {
133         // First input parameter which is a property name
134         beginIndex = 1;
135     }
136
137     /* Read and set all properties */
138     for (inputIndex = beginIndex; inputIndex < nbInputArgument(pvApiCtx); inputIndex = inputIndex + 2)
139     {
140         int* piAddrValue = NULL;
141         int* piAddrProperty = NULL;
142
143         int isUserDataProperty = 0;
144         int iPropertyValuePositionIndex = inputIndex + 1;
145         size_t posStackOrAdr = 0;
146
147         /* Read property name */
148         if ((!checkInputArgumentType(pvApiCtx, inputIndex, sci_strings)))
149         {
150             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, inputIndex);
151             return FALSE;
152         }
153         else
154         {
155             sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddrProperty);
156             if (sciErr.iErr)
157             {
158                 printError(&sciErr, 0);
159                 return 1;
160             }
161
162             if (getAllocatedSingleString(pvApiCtx, piAddrProperty, &propertyName))
163             {
164                 Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, inputIndex);
165                 return 1;
166             }
167
168             if (stricmp(propertyName, "parent") == 0)
169             {
170                 parentDefined = TRUE;
171             }
172
173             isUserDataProperty = (stricmp(propertyName, "user_data") == 0) || (stricmp(propertyName, "userdata") == 0);
174         }
175
176         sciErr = getVarAddressFromPosition(pvApiCtx, iPropertyValuePositionIndex, &piAddrValue);
177         if (sciErr.iErr)
178         {
179             printError(&sciErr, 0);
180             return 1;
181         }
182
183         if (isUserDataProperty)
184         {
185             nbRow = -1;
186             nbCol = -1;
187             setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), piAddrValue, 0, 0, 0, propertyName);
188         }
189
190         /* Read property value */
191         switch (getInputArgumentType(pvApiCtx, iPropertyValuePositionIndex))
192         {
193             case sci_matrix:
194             {
195                 double* pdblValue = NULL;
196                 sciErr = getMatrixOfDouble(pvApiCtx, piAddrValue, &nbRow, &nbCol, &pdblValue);
197                 if (sciErr.iErr)
198                 {
199                     printError(&sciErr, 0);
200                     Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, iPropertyValuePositionIndex);
201                     return 1;
202                 }
203
204                 setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pdblValue, sci_matrix, nbRow, nbCol, propertyName);
205                 break;
206             }
207             case sci_strings:
208             {
209                 char* pstValue = NULL;
210                 if (getAllocatedSingleString(pvApiCtx, piAddrValue, &pstValue))
211                 {
212                     Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, iPropertyValuePositionIndex);
213                     return 1;
214                 }
215
216                 nbRow = (int)strlen(pstValue);
217                 nbCol = 1;
218                 setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pstValue, sci_strings, nbRow, nbCol, propertyName);
219                 freeAllocatedSingleString(pstValue);
220                 break;
221             }
222             case sci_handles:
223             {
224                 long long* phValues = NULL;
225                 sciErr = getMatrixOfHandle(pvApiCtx, piAddrValue, &nbRow, &nbCol, &phValues);
226                 if (sciErr.iErr)
227                 {
228                     printError(&sciErr, 0);
229                     Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, iPropertyValuePositionIndex);
230                     return 1;
231                 }
232                 setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), phValues, sci_handles, nbRow, nbCol, propertyName);
233                 break;
234             }
235             case sci_list:
236             {
237                 getListItemNumber(pvApiCtx, piAddrValue, &nbRow);
238                 nbCol = 1;
239                 setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), piAddrValue, sci_list, nbRow, nbCol, propertyName);
240                 break;
241             }
242             default:
243             {
244                 setStatus = SET_PROPERTY_ERROR;
245                 break;
246             }
247         }
248
249         if (setStatus == SET_PROPERTY_ERROR)
250         {
251             Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
252             return FALSE;
253         }
254
255         freeAllocatedSingleString(propertyName);
256     }
257
258     /* If the parent is not given, the current figure is set as parent */
259     if (!parentDefined && (nbInputArgument(pvApiCtx) != 0))
260     {
261         // Set the parent property
262         pstCurrentFigure = (char*)getCurrentFigure();
263         if (pstCurrentFigure == NULL)
264         {
265             pstCurrentFigure = createNewFigureWithAxes();
266         }
267         setGraphicObjectRelationship(pstCurrentFigure, getObjectFromHandle(GraphicHandle));
268     }
269
270     /* Create return variable */
271     nbRow = 1;
272     nbCol = 1;
273     // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
274     if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
275     {
276         Scierror(999, _("%s: Memory allocation error.\n"), fname);
277         return 1;
278     }
279
280     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
281     ReturnArguments(pvApiCtx);
282     return TRUE;
283 }
284
285 /*--------------------------------------------------------------------------*/