CID #1098686, #1098693 Fixed
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_uigetfont.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2008 - INRIA - Vincent COUVERT (java version)
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15
16 extern "C"
17 {
18 #include <string.h>
19 #include "gw_gui.h"
20 #include "api_scilab.h"
21 #include "localization.h"
22 #include "Scierror.h"
23 #include "CallFontChooser.h"
24 #include "getPropertyAssignedValue.h"
25 #include "freeArrayOfString.h"
26 }
27
28 /*--------------------------------------------------------------------------*/
29 int sci_uigetfont(char *fname, void* pvApiCtx)
30 {
31     SciErr sciErr;
32
33     int* piAddrfontNameAdr  = NULL;
34     int* piAddrfontSizeAdr  = NULL;
35     int* piAddrboldAdr      = NULL;
36     int* boldAdr            = NULL;
37     int* piAddritalicAdr    = NULL;
38     int* italicAdr          = NULL;
39     double* fontSizeAdr     = NULL;
40
41     int fontChooserID = 0;
42     int nbRow = 0;
43     int nbCol = 0;
44
45     char **fontNameAdr = NULL;
46     int fontNameSize   = 0;
47
48     char *selectedFontName  = NULL;
49     int selectedFontSize    = 0;
50     BOOL selectedBold       = FALSE;
51     BOOL selectedItalic     = FALSE;
52
53     CheckInputArgument(pvApiCtx, 0, 4);
54     CheckOutputArgument(pvApiCtx, 1, 4);
55
56     /* Default font name */
57     if (nbInputArgument(pvApiCtx) >= 1)
58     {
59         if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
60         {
61             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfontNameAdr);
62             if (sciErr.iErr)
63             {
64                 printError(&sciErr, 0);
65                 return 1;
66             }
67
68             // Retrieve a matrix of string at position 1.
69             if (getAllocatedMatrixOfString(pvApiCtx, piAddrfontNameAdr, &nbRow, &nbCol, &fontNameAdr))
70             {
71                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
72                 return 1;
73             }
74
75             fontNameSize = nbRow * nbCol;
76             if (fontNameSize != 1)
77             {
78                 freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
79                 Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1);
80                 return FALSE;
81             }
82         }
83         else
84         {
85             Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
86             return FALSE;
87         }
88     }
89
90     /* Default font size */
91     if (nbInputArgument(pvApiCtx) >= 2)
92     {
93         if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
94         {
95             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrfontSizeAdr);
96             if (sciErr.iErr)
97             {
98                 printError(&sciErr, 0);
99                 return 1;
100             }
101
102             // Retrieve a matrix of double at position 2.
103             sciErr = getMatrixOfDouble(pvApiCtx, piAddrfontSizeAdr, &nbRow, &nbCol, &fontSizeAdr);
104             if (sciErr.iErr)
105             {
106                 printError(&sciErr, 0);
107                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
108                 return 1;
109             }
110
111             if (nbRow * nbCol != 1)
112             {
113                 freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
114                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 2);
115                 return FALSE;
116             }
117         }
118         else
119         {
120             freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
121             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 2);
122             return FALSE;
123         }
124     }
125
126     /* Is the default font bold ? */
127     if (nbInputArgument(pvApiCtx) >= 3)
128     {
129         if ((checkInputArgumentType(pvApiCtx, 3, sci_boolean)))
130         {
131             sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrboldAdr);
132             if (sciErr.iErr)
133             {
134                 printError(&sciErr, 0);
135                 return 1;
136             }
137
138             // Retrieve a matrix of boolean at position 3.
139             sciErr = getMatrixOfBoolean(pvApiCtx, piAddrboldAdr, &nbRow, &nbCol, &boldAdr);
140             if (sciErr.iErr)
141             {
142                 printError(&sciErr, 0);
143                 Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 3);
144                 return 1;
145             }
146
147             if (nbRow * nbCol != 1)
148             {
149                 freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
150                 Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
151                 return FALSE;
152             }
153
154         }
155         else
156         {
157             freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
158             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
159             return FALSE;
160         }
161     }
162
163     /* Is the default font italic ? */
164     if (nbInputArgument(pvApiCtx) >= 4)
165     {
166         if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
167         {
168             sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddritalicAdr);
169             if (sciErr.iErr)
170             {
171                 printError(&sciErr, 0);
172                 return 1;
173             }
174
175             // Retrieve a matrix of boolean at position 4.
176             sciErr = getMatrixOfBoolean(pvApiCtx, piAddritalicAdr, &nbRow, &nbCol, &italicAdr);
177             if (sciErr.iErr)
178             {
179                 printError(&sciErr, 0);
180                 Scierror(202, _("%s: Wrong type for argument #%d: Boolean matrix expected.\n"), fname, 4);
181                 return 1;
182             }
183
184             if (nbRow * nbCol != 1)
185             {
186                 freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
187                 Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
188                 return FALSE;
189             }
190
191         }
192         else
193         {
194             freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
195             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
196             return FALSE;
197         }
198     }
199
200     /* Create the Java Object */
201     fontChooserID = createFontChooser();
202
203     /* Default font */
204     if (fontNameAdr != NULL)
205     {
206         setFontChooserFontName(fontChooserID, fontNameAdr[0]);
207     }
208
209     /* Default size */
210     if (fontSizeAdr != 0)
211     {
212         setFontChooserFontSize(fontChooserID, (int)fontSizeAdr[0]);
213     }
214
215     /* Default bold */
216     if (boldAdr != 0)
217     {
218         setFontChooserBold(fontChooserID, booltoBOOL(boldAdr[0]));
219     }
220
221     /* Default italic */
222     if (italicAdr != 0)
223     {
224         setFontChooserItalic(fontChooserID, booltoBOOL(italicAdr[0]));
225     }
226
227     /* Display it and wait for a user input */
228     fontChooserDisplayAndWait(fontChooserID);
229
230     /* Return the selected font */
231
232     /* Read the user answer */
233     selectedFontName = getFontChooserFontName(fontChooserID);
234
235
236     if (strcmp(selectedFontName, "")) /* The user selected a font */
237     {
238         selectedFontSize = getFontChooserFontSize(fontChooserID);
239         selectedBold = getFontChooserBold(fontChooserID);
240         selectedItalic = getFontChooserItalic(fontChooserID);
241
242         nbRow = 1;
243         nbCol = 1;
244         if (nbOutputArgument(pvApiCtx) >= 1)
245         {
246             sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, (const char * const*) &selectedFontName);
247             if (sciErr.iErr)
248             {
249                 printError(&sciErr, 0);
250                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
251                 delete[] selectedFontName;
252                 return 1;
253             }
254         }
255
256         delete[] selectedFontName;
257
258         if (nbOutputArgument(pvApiCtx) >= 2)
259         {
260             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
261             if (sciErr.iErr)
262             {
263                 printError(&sciErr, 0);
264                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
265                 return 1;
266             }
267
268             *fontSizeAdr = selectedFontSize;
269         }
270
271         if (nbOutputArgument(pvApiCtx) >= 3)
272         {
273             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
274             if (sciErr.iErr)
275             {
276                 printError(&sciErr, 0);
277                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
278                 return 1;
279             }
280
281             *boldAdr = selectedBold;
282         }
283
284         if (nbOutputArgument(pvApiCtx) >= 4)
285         {
286             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
287             if (sciErr.iErr)
288             {
289                 printError(&sciErr, 0);
290                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
291                 return 1;
292             }
293
294             *italicAdr = selectedItalic;
295         }
296     }
297     else /* The user canceled */
298     {
299         delete[] selectedFontName;
300         nbRow = 0;
301         nbCol = 0;
302         if (nbOutputArgument(pvApiCtx) >= 1)
303         {
304             /* Return "" as font name */
305             char* fontNameEmpty = NULL;
306             if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow * nbCol, (const char**) &fontNameEmpty))
307             {
308                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
309                 return 1;
310             }
311         }
312
313         if (nbOutputArgument(pvApiCtx) >= 2)
314         {
315             /* Return [] as font size */
316             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
317             if (sciErr.iErr)
318             {
319                 printError(&sciErr, 0);
320                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
321                 return 1;
322             }
323         }
324
325         if (nbOutputArgument(pvApiCtx) >= 3)
326         {
327             /* Return [] as bold value */
328             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
329             if (sciErr.iErr)
330             {
331                 printError(&sciErr, 0);
332                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
333                 return 1;
334             }
335         }
336
337         if (nbOutputArgument(pvApiCtx) >= 4)
338         {
339             /* Return [] as italic value */
340             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
341             if (sciErr.iErr)
342             {
343                 printError(&sciErr, 0);
344                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
345                 return 1;
346             }
347         }
348     }
349
350     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
351     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
352     AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
353     AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
354
355     if (fontNameSize)
356     {
357         freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
358     }
359     ReturnArguments(pvApiCtx);
360     return TRUE;
361 }
362 /*--------------------------------------------------------------------------*/