46cfed9187d933dbc074753bda348b4bc5bc5c3f
[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                 return 1;
252             }
253         }
254
255         delete[] selectedFontName;
256
257         if (nbOutputArgument(pvApiCtx) >= 2)
258         {
259             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
260             if (sciErr.iErr)
261             {
262                 printError(&sciErr, 0);
263                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
264                 return 1;
265             }
266
267             *fontSizeAdr = selectedFontSize;
268         }
269
270         if (nbOutputArgument(pvApiCtx) >= 3)
271         {
272             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
273             if (sciErr.iErr)
274             {
275                 printError(&sciErr, 0);
276                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
277                 return 1;
278             }
279
280             *boldAdr = selectedBold;
281         }
282
283         if (nbOutputArgument(pvApiCtx) >= 4)
284         {
285             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
286             if (sciErr.iErr)
287             {
288                 printError(&sciErr, 0);
289                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
290                 return 1;
291             }
292
293             *italicAdr = selectedItalic;
294         }
295     }
296     else /* The user canceled */
297     {
298         delete[] selectedFontName;
299         nbRow = 0;
300         nbCol = 0;
301         if (nbOutputArgument(pvApiCtx) >= 1)
302         {
303             /* Return "" as font name */
304             char* fontNameEmpty = NULL;
305             if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow * nbCol, (const char**) &fontNameEmpty))
306             {
307                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
308                 return 1;
309             }
310         }
311
312         if (nbOutputArgument(pvApiCtx) >= 2)
313         {
314             /* Return [] as font size */
315             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
316             if (sciErr.iErr)
317             {
318                 printError(&sciErr, 0);
319                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
320                 return 1;
321             }
322         }
323
324         if (nbOutputArgument(pvApiCtx) >= 3)
325         {
326             /* Return [] as bold value */
327             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
328             if (sciErr.iErr)
329             {
330                 printError(&sciErr, 0);
331                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
332                 return 1;
333             }
334         }
335
336         if (nbOutputArgument(pvApiCtx) >= 4)
337         {
338             /* Return [] as italic value */
339             sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
340             if (sciErr.iErr)
341             {
342                 printError(&sciErr, 0);
343                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
344                 return 1;
345             }
346         }
347     }
348
349     AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
350     AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
351     AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
352     AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
353
354     if (fontNameSize)
355     {
356         freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
357     }
358     ReturnArguments(pvApiCtx);
359     return TRUE;
360 }
361 /*--------------------------------------------------------------------------*/