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