load: avoid creation of double axes in figure
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_x_mdialog.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Allan CORNET
4  * Copyright (C) 2008 - INRIA - Vincent COUVERT (Java version)
5  *
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  */
16
17 extern "C"
18 {
19 #include "gw_gui.h"
20 #include "api_scilab.h"
21 #include "localization.h"
22 #include "CallMessageBox.h"
23 #include "getPropertyAssignedValue.h"
24 #include "Scierror.h"
25 #include "freeArrayOfString.h"
26 }
27
28 /*--------------------------------------------------------------------------*/
29 int sci_x_mdialog(char *fname, void* pvApiCtx)
30 {
31     SciErr sciErr;
32
33     int* piAddrlabelsAdr = NULL;
34     int* piAddrlineLabelsAdr = NULL;
35     int* piAddrdefaultValuesAdr = NULL;
36     int* piAddrcolumnLabelsAdr = NULL;
37     double* emptyMatrixAdr = NULL;
38
39     int nbRow = 0, nbCol = 0;
40     int nbRowDefaultValues = 0, nbColDefaultValues = 0;
41     int nbRowLineLabels = 0, nbColLineLabels = 0;
42     int nbRowColumnLabels = 0, nbColColumnLabels = 0;
43
44     int messageBoxID = 0;
45
46     char **labelsAdr = NULL;
47     char **lineLabelsAdr = NULL;
48     char **columnLabelsAdr = NULL;
49     char **defaultValuesAdr = NULL;
50
51     int userValueSize = 0;
52     char **userValue = NULL;
53
54     CheckInputArgument(pvApiCtx, 3, 4);
55     CheckOutputArgument(pvApiCtx, 0, 1);
56
57     /* READ THE LABELS */
58     if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
59     {
60         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr);
61         if (sciErr.iErr)
62         {
63             printError(&sciErr, 0);
64             return 1;
65         }
66
67         // Retrieve a matrix of string at position 1.
68         if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
69         {
70             Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
71             return 1;
72         }
73     }
74     else
75     {
76         Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 1);
77         return FALSE;
78     }
79
80     /* Create the Java Object */
81     messageBoxID = createMessageBox();
82
83     /* Title is a default title */
84     setMessageBoxTitle(messageBoxID, _("Scilab Multiple Values Request"));
85     /* Message */
86     setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
87     freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
88
89     /* READ THE LINE LABELS */
90     if (checkInputArgumentType(pvApiCtx, 2, sci_strings))
91     {
92         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlineLabelsAdr);
93         if (sciErr.iErr)
94         {
95             printError(&sciErr, 0);
96             return 1;
97         }
98
99         // Retrieve a matrix of string at position 2.
100         if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr))
101         {
102             Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
103             return 1;
104         }
105
106         if (nbRowLineLabels != 1 && nbColLineLabels != 1)
107         {
108             freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
109             Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 2);
110             return FALSE;
111         }
112         setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels);
113         freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
114     }
115     else
116     {
117         Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
118         return FALSE;
119     }
120
121     /* READ THE COLUMN LABELS or DEFAULT VALUES */
122     if (checkInputArgumentType(pvApiCtx, 3, sci_strings))
123     {
124         if (nbInputArgument(pvApiCtx) == 3)
125         {
126             sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrdefaultValuesAdr);
127             if (sciErr.iErr)
128             {
129                 printError(&sciErr, 0);
130                 return 1;
131             }
132
133             // Retrieve a matrix of string at position 3.
134             if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr))
135             {
136                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
137                 return 1;
138             }
139
140             if ((nbRowDefaultValues != nbRowLineLabels) || (nbColDefaultValues != nbColLineLabels))
141             {
142                 freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr);
143                 Scierror(999, _("%s: Wrong size for input argument #%d: It must have same dimensions as argument #%d.\n"), fname, 3, 2);
144                 return FALSE;
145             }
146
147             setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
148             freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr);
149         }
150         else
151         {
152             sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrcolumnLabelsAdr);
153             if (sciErr.iErr)
154             {
155                 printError(&sciErr, 0);
156                 return 1;
157             }
158
159             // Retrieve a matrix of string at position 3.
160             if (getAllocatedMatrixOfString(pvApiCtx, piAddrcolumnLabelsAdr, &nbRowColumnLabels, &nbColColumnLabels, &columnLabelsAdr))
161             {
162                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
163                 return 1;
164             }
165
166             if (nbRowColumnLabels != 1 && nbColColumnLabels != 1)
167             {
168                 freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr);
169                 Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3);
170                 return FALSE;
171             }
172             setMessageBoxColumnLabels(messageBoxID, columnLabelsAdr, nbColColumnLabels * nbRowColumnLabels);
173             freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr);
174         }
175     }
176     else
177     {
178         Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3);
179         return FALSE;
180     }
181
182     if (nbInputArgument(pvApiCtx) == 4)
183     {
184         /* READ  DEFAULT VALUES */
185         if (checkInputArgumentType(pvApiCtx, 4, sci_strings))
186         {
187             sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrdefaultValuesAdr);
188             if (sciErr.iErr)
189             {
190                 printError(&sciErr, 0);
191                 return 1;
192             }
193
194             // Retrieve a matrix of string at position 4.
195             // DO NOT FORGET TO RELEASE MEMORY via freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr).
196             if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr))
197             {
198                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 4);
199                 return 1;
200             }
201
202             if ((nbRowDefaultValues != nbRowLineLabels * nbColLineLabels) || (nbColDefaultValues != nbRowColumnLabels * nbColColumnLabels))
203             {
204                 Scierror(999, _("%s: Wrong size for input argument #%d: %d x %d matrix of strings expected.\n"), fname, 4, nbRowLineLabels * nbColLineLabels, nbRowColumnLabels * nbColColumnLabels);
205                 freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
206                 return FALSE;
207             }
208             setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
209             freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
210         }
211         else
212         {
213             Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 4);
214             return FALSE;
215         }
216     }
217
218     /* Display it and wait for a user input */
219     messageBoxDisplayAndWait(messageBoxID);
220
221     /* Read the user answer */
222     userValueSize = getMessageBoxValueSize(messageBoxID);
223     if (userValueSize == 0)
224     {
225         nbRow = 0;
226         nbCol = 0;
227         // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int emptyMatrixAdr".
228         sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
229         if (sciErr.iErr)
230         {
231             printError(&sciErr, 0);
232             Scierror(999, _("%s: Memory allocation error.\n"), fname);
233             return 1;
234         }
235
236     }
237     else
238     {
239         userValue = getMessageBoxValue(messageBoxID);
240         nbCol = 1;
241         nbRowDefaultValues = nbColLineLabels * nbRowLineLabels;
242         nbColDefaultValues = 1;
243         if (nbInputArgument(pvApiCtx) == 4)
244         {
245             nbColDefaultValues = nbColColumnLabels * nbRowColumnLabels;
246         }
247
248         createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValue);
249         delete[] userValue;
250     }
251
252     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
253     ReturnArguments(pvApiCtx);
254     return TRUE;
255 }
256 /*--------------------------------------------------------------------------*/