GUI module ported to api_scilab. test_run("gui")
[scilab.git] / scilab / modules / gui / sci_gateway / c / sci_unsetmenu.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Allan CORNET
4  * Copyright (C) 2007 - INRIA - Vincent COUVERT
5  * Copyright (C) 2011 - DIGITEO - Vincent COUVERT
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
12  *
13  */
14
15 #include "gw_gui.h"
16 #include "api_scilab.h"
17 #include "localization.h"
18 #include "Scierror.h"
19 #include "InitUIMenu.h"
20 #include "scilabmode.h"
21 #include "FigureList.h"
22 #include "getConsoleIdentifier.h"
23 /*--------------------------------------------------------------------------*/
24 int sci_unsetmenu(char *fname, unsigned long fname_len)
25 {
26     SciErr sciErr;
27
28     int* piAddrmenuNameAdr      = NULL;
29     char* menuNameAdr           = NULL;
30     int* piAddrfigureNumberAdr  = NULL;
31     double* figureNumberAdr     = NULL;
32     int* piAddrsubMenuIndexAdr  = NULL;
33     double* subMenuIndexAdr     = NULL;
34
35     int nbRow = 0;
36     int nbCol = 0;
37
38     // Check parameter number
39     CheckInputArgument(pvApiCtx, 1, 3);
40     CheckOutputArgument(pvApiCtx, 1, 1);
41
42     if (nbInputArgument(pvApiCtx) == 1)
43     {
44         // Error message in not in standard mode (we need figure number)
45         if (getScilabMode() != SCILAB_STD)
46         {
47             Scierror(999, _("%s: Figure number must be given when not in '%s' mode.\n"), fname, "STD");
48             return FALSE;
49         }
50
51         // Unset a Menu of Scilab Main Window
52         if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)))
53         {
54             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
55             return FALSE;
56         }
57
58         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr);
59         if (sciErr.iErr)
60         {
61             printError(&sciErr, 0);
62             return 1;
63         }
64
65         // Retrieve a matrix of double at position 1.
66         if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
67         {
68             Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
69             return 1;
70         }
71
72         if (nbCol != 1)
73         {
74             Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
75             return FALSE;
76         }
77
78         EnableMenu(getConsoleIdentifier(), menuNameAdr, FALSE);
79         freeAllocatedSingleString(menuNameAdr);
80     }
81     else if (nbInputArgument(pvApiCtx) == 2)
82     {
83         // Unset a Menu a Scilab Graphic Window
84         if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (checkInputArgumentType(pvApiCtx, 2, sci_strings)))
85         {
86             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr);
87             if (sciErr.iErr)
88             {
89                 printError(&sciErr, 0);
90                 return 1;
91             }
92
93             // Retrieve a matrix of double at position 1.
94             sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr);
95             if (sciErr.iErr)
96             {
97                 printError(&sciErr, 0);
98                 Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
99                 return 1;
100             }
101
102
103             if (nbRow * nbCol != 1)
104             {
105                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
106                 return FALSE;
107             }
108
109             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr);
110             if (sciErr.iErr)
111             {
112                 printError(&sciErr, 0);
113                 return 1;
114             }
115
116             // Retrieve a matrix of double at position 2.
117             if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
118             {
119                 Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
120                 return 1;
121             }
122
123             EnableMenu((char*)getFigureFromIndex((int)*figureNumberAdr), menuNameAdr, FALSE);
124             freeAllocatedSingleString(menuNameAdr);
125         }
126         else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)) && (checkInputArgumentType(pvApiCtx, 2, sci_matrix))) // Unset a submenu in main window
127         {
128             // Error message in not in standard mode (we need figure number)
129             if (getScilabMode() != SCILAB_STD)
130             {
131                 Scierror(999, _("%s: Figure number must be given when not in '%s' mode.\n"), fname, "STD");
132                 return FALSE;
133             }
134
135             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr);
136             if (sciErr.iErr)
137             {
138                 printError(&sciErr, 0);
139                 return 1;
140             }
141
142             // Retrieve a matrix of double at position 1.
143             if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
144             {
145                 Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
146                 return 1;
147             }
148
149             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrsubMenuIndexAdr);
150             if (sciErr.iErr)
151             {
152                 printError(&sciErr, 0);
153                 return 1;
154             }
155
156             // Retrieve a matrix of double at position 2.
157             sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr);
158             if (sciErr.iErr)
159             {
160                 printError(&sciErr, 0);
161                 Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
162                 return 1;
163             }
164
165
166             if (nbRow * nbCol != 1)
167             {
168                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 2);
169                 return FALSE;
170             }
171
172             EnableSubMenu(getConsoleIdentifier(), menuNameAdr, (int)*subMenuIndexAdr, FALSE);
173             freeAllocatedSingleString(menuNameAdr);
174         }
175         else
176         {
177             Scierror(999, _("%s: Wrong input arguments: '%s' or '%s' expected.\n"), fname, "(button, nsub)", "(gwin, button)");
178             return FALSE;
179         }
180     }
181     else                        // Unset a submenu in graphics window
182     {
183         if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
184         {
185             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr);
186             if (sciErr.iErr)
187             {
188                 printError(&sciErr, 0);
189                 return 1;
190             }
191
192             // Retrieve a matrix of double at position 1.
193             sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr);
194             if (sciErr.iErr)
195             {
196                 printError(&sciErr, 0);
197                 Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
198                 return 1;
199             }
200
201
202             if (nbRow * nbCol != 1)
203             {
204                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
205                 return FALSE;
206             }
207         }
208         else
209         {
210             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 1);
211             return FALSE;
212         }
213
214         if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
215         {
216             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr);
217             if (sciErr.iErr)
218             {
219                 printError(&sciErr, 0);
220                 return 1;
221             }
222
223             // Retrieve a matrix of double at position 2.
224             if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
225             {
226                 Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
227                 return 1;
228             }
229         }
230         else
231         {
232             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
233             return FALSE;
234         }
235
236         if ((checkInputArgumentType(pvApiCtx, 3, sci_matrix)))
237         {
238             sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrsubMenuIndexAdr);
239             if (sciErr.iErr)
240             {
241                 printError(&sciErr, 0);
242                 return 1;
243             }
244
245             // Retrieve a matrix of double at position 3.
246             sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr);
247             if (sciErr.iErr)
248             {
249                 printError(&sciErr, 0);
250                 Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
251                 return 1;
252             }
253
254             if (nbRow * nbCol != 1)
255             {
256                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 3);
257                 return FALSE;
258             }
259         }
260         else
261         {
262             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 3);
263             return FALSE;
264         }
265
266         EnableSubMenu((char*)getFigureFromIndex((int)*figureNumberAdr), menuNameAdr, (int)*subMenuIndexAdr, FALSE);
267         freeAllocatedSingleString(menuNameAdr);
268     }
269
270     AssignOutputVariable(pvApiCtx, 1) = 0;
271     ReturnArguments(pvApiCtx);
272     return 0;
273 }
274 /*--------------------------------------------------------------------------*/