fix crash on scilab start with splashscreen
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_x_choice.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 implementation)
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 "sci_malloc.h"
21 #include "api_scilab.h"
22 #include "localization.h"
23 #include "CallMessageBox.h"
24 #include "getPropertyAssignedValue.h"
25 #include "Scierror.h"
26 #include "freeArrayOfString.h"
27 }
28
29 /*--------------------------------------------------------------------------*/
30 int sci_x_choice(char *fname, void* pvApiCtx)
31 {
32     SciErr sciErr;
33
34     int* piAddrdefaultValuesAdr = NULL;
35     int* piAddrlabelsAdr = NULL;
36     int* piAddrlineLabelsAdr = 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
43     int messageBoxID = 0;
44
45     char **labelsAdr = NULL;
46     char **lineLabelsAdr = NULL;
47     double *defaultValues = NULL;
48     int *defaultValuesInt = NULL;
49
50     int userValueSize = 0;
51     int *userValue = NULL;
52     double *userValueDouble = NULL;
53
54     int K = 0;
55
56     CheckInputArgument(pvApiCtx, 3, 3);
57     CheckOutputArgument(pvApiCtx, 0, 1);
58
59     /* READ THE DEFAULT VALUES */
60     if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
61     {
62         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrdefaultValuesAdr);
63         if (sciErr.iErr)
64         {
65             printError(&sciErr, 0);
66             return 1;
67         }
68
69         // Retrieve a matrix of double at position 1.
70         sciErr = getMatrixOfDouble(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValues);
71         if (sciErr.iErr)
72         {
73             printError(&sciErr, 0);
74             Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
75             return 1;
76         }
77
78         defaultValuesInt = (int *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(int));
79         for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++)
80         {
81             defaultValuesInt[K] = (int)defaultValues[K];
82         }
83     }
84     else
85     {
86         Scierror(999, _("%s: Wrong type for input argument #%d: Real or complex vector expected.\n"), fname, 1);
87         return FALSE;
88     }
89
90     /* READ THE MESSAGE */
91     if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
92     {
93         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlabelsAdr);
94         if (sciErr.iErr)
95         {
96             printError(&sciErr, 0);
97             FREE(defaultValuesInt);
98             return 1;
99         }
100
101         // Retrieve a matrix of string at position 2.
102         if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
103         {
104             Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 2);
105             FREE(defaultValuesInt);
106             return 1;
107         }
108
109     }
110     else
111     {
112         Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
113         FREE(defaultValuesInt);
114         return FALSE;
115     }
116
117     /* Create the Java Object */
118     messageBoxID = createMessageBox();
119
120     /* Title is a default title */
121     setMessageBoxTitle(messageBoxID, _("Scilab Choices Request"));
122
123     /* Message */
124     setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
125     freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
126
127     /* READ THE LABELS */
128     if (checkInputArgumentType(pvApiCtx, 3, sci_strings))
129     {
130         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlineLabelsAdr);
131         if (sciErr.iErr)
132         {
133             printError(&sciErr, 0);
134             FREE(defaultValuesInt);
135             return 1;
136         }
137
138         // Retrieve a matrix of string at position 3.
139         if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr))
140         {
141             Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
142             FREE(defaultValuesInt);
143             return 1;
144         }
145
146         if (nbRow != 1 && nbCol != 1)
147         {
148             Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3);
149             freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
150             FREE(defaultValuesInt);
151             return FALSE;
152         }
153         setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels);
154         freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
155     }
156     else
157     {
158         Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 3);
159         FREE(defaultValuesInt);
160         return FALSE;
161     }
162
163     /* Default selected buttons */
164     setMessageBoxDefaultSelectedButtons(messageBoxID, defaultValuesInt, nbRowDefaultValues * nbColDefaultValues);
165     FREE(defaultValuesInt);
166
167     /* Display it and wait for a user input */
168     messageBoxDisplayAndWait(messageBoxID);
169
170     /* Read the user answer */
171     userValueSize = getMessageBoxValueSize(messageBoxID);
172     if (userValueSize == 0)
173     {
174         nbRow = 0;
175         nbCol = 0;
176
177         sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
178         if (sciErr.iErr)
179         {
180             printError(&sciErr, 0);
181             Scierror(999, _("%s: Memory allocation error.\n"), fname);
182             return 1;
183         }
184     }
185     else
186     {
187         userValue = (int*)getMessageBoxUserSelectedButtons(messageBoxID);
188
189         userValueDouble = (double *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(double));
190         for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++)
191         {
192             userValueDouble[K] = userValue[K];
193         }
194
195         sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValueDouble);
196         if (sciErr.iErr)
197         {
198             printError(&sciErr, 0);
199             Scierror(999, _("%s: Memory allocation error.\n"), fname);
200             delete[] userValue;
201             return 1;
202         }
203     }
204
205     delete[] userValue;
206     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
207     ReturnArguments(pvApiCtx);
208     return TRUE;
209 }
210 /*--------------------------------------------------------------------------*/