* Bug #13298 fixed - Static analysis bugs detected by PVS-Studio fixed
[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.1-en.txt
14 *
15 */
16
17 /*--------------------------------------------------------------------------*/
18 #include <string.h>
19 #include "BuildObjects.h"
20 #include "gw_gui.h"
21 #include "localization.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 "os_string.h"
29 #include "CreateUimenu.h"
30 #include "createGraphicObject.h"
31 #include "setGraphicObjectProperty.h"
32 #include "getGraphicObjectProperty.h"
33 #include "graphicObjectProperties.h"
34 #include "CurrentFigure.h"
35 #include "api_scilab.h"
36 #include "HandleManagement.h"
37 /*--------------------------------------------------------------------------*/
38 int sci_uimenu(char *fname, void *pvApiCtx)
39 {
40     SciErr sciErr;
41     int nbRow = 0, nbCol = 0;
42     int setStatus = SET_PROPERTY_SUCCEED;
43     int inputIndex = 0, beginIndex = 0;
44     char *propertyName = NULL;
45     int iParentUID = 0;
46     unsigned long GraphicHandle = 0;
47     int parentDefined = FALSE;
48     int iCurrentFigure = 0;
49     int iParentType = -1;
50     int *piParentType = &iParentType;
51
52     /* Create a new menu */
53     GraphicHandle = getHandle(CreateUimenu());
54
55     /* If no nbInputArgument(pvApiCtx) -> current figure is the parent (Ascendant compatibility) */
56     if (nbInputArgument(pvApiCtx) == 0)
57     {
58         // Set the parent property
59         iCurrentFigure = getCurrentFigure();
60         if (iCurrentFigure == 0)
61         {
62             iCurrentFigure = createNewFigureWithAxes();
63         }
64         setGraphicObjectRelationship(iCurrentFigure, getObjectFromHandle(GraphicHandle));
65     }
66
67     /**
68     * Odd number of input arguments
69     * First input is the parent ID
70     * All event inputs are property names
71     * All odd (except first) inputs are property values
72     */
73     if (nbInputArgument(pvApiCtx) % 2 == 1)
74     {
75         if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
76         {
77             Scierror(999, _("%s: Wrong type for input argument #%d: A graphic handle expected.\n"), fname, 1);
78             return FALSE;
79         }
80         else                    /* Get parent ID */
81         {
82             int *piAddr = NULL;
83             long long hParent = 0;
84             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
85             if (sciErr.iErr)
86             {
87                 printError(&sciErr, 0);
88                 return 1;
89             }
90
91             // Retrieve a matrix of handle at position 1.
92             // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
93             if (getScalarHandle(pvApiCtx, piAddr, &hParent))
94             {
95                 Scierror(202, _("%s: Wrong type for input argument #%d: Handle expected.\n"), fname, 1);
96                 return 1;
97             }
98
99             iParentUID = getObjectFromHandle((long)hParent);
100             if (iParentUID != 0)
101             {
102                 getGraphicObjectProperty(iParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
103                 if (iParentType != __GO_FIGURE__ && iParentType != __GO_UIMENU__)
104                 {
105                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or '%s' handle expected.\n"), fname, 1, "Figure", "Uimenu");
106                     return FALSE;
107                 }
108
109                 // Set the parent property
110                 callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), &hParent, sci_handles, 1, 1, "parent");
111
112                 // Set the flag to avoid setting the parent two times
113                 parentDefined = TRUE;
114             }
115             else
116             {
117                 Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or '%s' handle expected.\n"), fname, 1, "Figure", "Uimenu");
118                 return FALSE;
119             }
120
121             // First input parameter which is a property name
122             beginIndex = 2;
123         }
124     }
125     /**
126     * Even number of input arguments
127     * All odd inputs are property names
128     * All even inputs are property values
129     */
130     else
131     {
132         // First input parameter which is a property name
133         beginIndex = 1;
134     }
135
136     /* Read and set all properties */
137     for (inputIndex = beginIndex; inputIndex < nbInputArgument(pvApiCtx); inputIndex = inputIndex + 2)
138     {
139         int* piAddrValue = NULL;
140         int* piAddrProperty = NULL;
141
142         int isUserDataProperty = 0;
143         int iPropertyValuePositionIndex = inputIndex + 1;
144         size_t posStackOrAdr = 0;
145
146         /* Read property name */
147         if ((!checkInputArgumentType(pvApiCtx, inputIndex, sci_strings)))
148         {
149             Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, inputIndex);
150             return FALSE;
151         }
152         else
153         {
154             sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddrProperty);
155             if (sciErr.iErr)
156             {
157                 printError(&sciErr, 0);
158                 return 1;
159             }
160
161             if (getAllocatedSingleString(pvApiCtx, piAddrProperty, &propertyName))
162             {
163                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, inputIndex);
164                 return 1;
165             }
166
167             if (stricmp(propertyName, "parent") == 0)
168             {
169                 parentDefined = TRUE;
170             }
171
172             isUserDataProperty = (stricmp(propertyName, "user_data") == 0) || (stricmp(propertyName, "userdata") == 0);
173         }
174
175         sciErr = getVarAddressFromPosition(pvApiCtx, iPropertyValuePositionIndex, &piAddrValue);
176         if (sciErr.iErr)
177         {
178             printError(&sciErr, 0);
179             return 1;
180         }
181
182         if (isUserDataProperty)
183         {
184             nbRow = -1;
185             nbCol = -1;
186             setStatus = callSetProperty(pvApiCtx, getObjectFromHandle(GraphicHandle), piAddrValue, 0, 0, 0, propertyName);
187         }
188         else
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, 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: string expected.\n"), fname, iPropertyValuePositionIndex);
213                         return 1;
214                     }
215
216                     nbRow = (int)strlen(pstValue);
217                     nbCol = 1;
218                     setStatus = callSetProperty(pvApiCtx, 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 input argument #%d: Handle matrix expected.\n"), fname, iPropertyValuePositionIndex);
230                         return 1;
231                     }
232                     setStatus = callSetProperty(pvApiCtx, 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, 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
250         if (setStatus == SET_PROPERTY_ERROR)
251         {
252             Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
253             return FALSE;
254         }
255
256         freeAllocatedSingleString(propertyName);
257     }
258
259     /* If the parent is not given, the current figure is set as parent */
260     if (!parentDefined && (nbInputArgument(pvApiCtx) != 0))
261     {
262         // Set the parent property
263         iCurrentFigure = getCurrentFigure();
264         if (iCurrentFigure == 0)
265         {
266             iCurrentFigure = createNewFigureWithAxes();
267         }
268         setGraphicObjectRelationship(iCurrentFigure, getObjectFromHandle(GraphicHandle));
269     }
270
271     /* Create return variable */
272     nbRow = 1;
273     nbCol = 1;
274     // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
275     if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
276     {
277         Scierror(999, _("%s: Memory allocation error.\n"), fname);
278         return 1;
279     }
280
281     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
282     ReturnArguments(pvApiCtx);
283     return TRUE;
284 }
285
286 /*--------------------------------------------------------------------------*/