load: avoid creation of double axes in figure
[scilab.git] / scilab / modules / gui / sci_gateway / cpp / sci_uigetcolor.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 "gw_gui.h"
19 #include "api_scilab.h"
20 #include "localization.h"
21 #include "Scierror.h"
22 #include "CallColorChooser.h"
23 }
24
25 /*--------------------------------------------------------------------------*/
26 int sci_uigetcolor(char *fname, void* pvApiCtx)
27 {
28     SciErr sciErr;
29
30     //WARNING ALL NEW DECALRATIONS ARE HERE IF YOUR HAVE MANY FUNCTIONS
31     //IN THE FILE YOU HAVE PROBABLY TO MOVE DECLARATIONS IN GOOD FUNCTIONS
32     int* piAddrredAdr = NULL;
33     double* redAdr = NULL;
34     int* piAddrtitleAdr = NULL;
35     char* titleAdr = NULL;
36     int* piAddrgreenAdr = NULL;
37     double* greenAdr = NULL;
38     int* piAddrblueAdr = NULL;
39     double* blueAdr = NULL;
40
41     int colorChooserID = 0;
42     int firstColorIndex = 0;
43
44     int nbRow = 0, nbCol = 0;
45
46     double *selectedRGB = NULL;
47
48     CheckInputArgument(pvApiCtx, 0, 4);
49
50     if ((nbOutputArgument(pvApiCtx) != 1) && (nbOutputArgument(pvApiCtx) != 3)) /* Bad use */
51     {
52         Scierror(999, _("%s: Wrong number of output arguments: %d or %d expected.\n"), fname, 1, 3);
53         return FALSE;
54     }
55
56     /* Rhs==1: title or [R, G, B] given */
57     if (nbInputArgument(pvApiCtx) == 1)
58     {
59         if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
60         {
61             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrredAdr);
62             if (sciErr.iErr)
63             {
64                 printError(&sciErr, 0);
65                 return 1;
66             }
67
68             // Retrieve a matrix of double at position 1.
69             sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
70             if (sciErr.iErr)
71             {
72                 printError(&sciErr, 0);
73                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
74                 return 1;
75             }
76
77             if ((nbRow != 1) || (nbCol != 3))
78             {
79                 Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 1, 3);
80                 return FALSE;
81             }
82         }
83         else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
84         {
85             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
86             if (sciErr.iErr)
87             {
88                 printError(&sciErr, 0);
89                 return 1;
90             }
91
92             // Retrieve a matrix of double at position 1.
93             if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
94             {
95                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
96                 return 1;
97             }
98         }
99         else
100         {
101             Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
102             return FALSE;
103         }
104     }
105
106     /* Title and [R, G, B] given */
107     if (nbInputArgument(pvApiCtx) == 2)
108     {
109         /* Title */
110         if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
111         {
112             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
113             if (sciErr.iErr)
114             {
115                 printError(&sciErr, 0);
116                 return 1;
117             }
118
119             // Retrieve a matrix of double at position 1.
120             if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
121             {
122                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
123                 return 1;
124             }
125         }
126         else
127         {
128             Scierror(999, _("%s: Wrong type for input argument #%d: string expected.\n"), fname, 1);
129             return FALSE;
130         }
131
132         /* [R, G, B] */
133         if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
134         {
135             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrredAdr);
136             if (sciErr.iErr)
137             {
138                 printError(&sciErr, 0);
139                 freeAllocatedSingleString(titleAdr);
140                 return 1;
141             }
142
143             // Retrieve a matrix of double at position 2.
144             sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
145             if (sciErr.iErr)
146             {
147                 printError(&sciErr, 0);
148                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
149                 freeAllocatedSingleString(titleAdr);
150                 return 1;
151             }
152
153             if (nbRow * nbCol != 3)
154             {
155                 Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
156                 freeAllocatedSingleString(titleAdr);
157                 return FALSE;
158             }
159         }
160         else
161         {
162             Scierror(999, _("%s: Wrong type for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
163             return FALSE;
164         }
165     }
166
167     /* No title given but colors given with separate values */
168     if (nbInputArgument(pvApiCtx) == 3)
169     {
170         firstColorIndex = 1;
171     }
172
173     /* Title and colors given with separate values */
174     if (nbInputArgument(pvApiCtx) == 4)
175     {
176         firstColorIndex = 2;
177
178         /* Title */
179         if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
180         {
181             sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
182             if (sciErr.iErr)
183             {
184                 printError(&sciErr, 0);
185                 return 1;
186             }
187
188             // Retrieve a matrix of double at position 1.
189             if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
190             {
191                 Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 1);
192                 return 1;
193             }
194         }
195         else
196         {
197             Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
198             return FALSE;
199         }
200     }
201
202     /* R, G, B given */
203     if (nbInputArgument(pvApiCtx) >= 3)
204     {
205         /* Default red value */
206         if ((checkInputArgumentType(pvApiCtx, firstColorIndex, sci_matrix)))
207         {
208             sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex, &piAddrredAdr);
209             if (sciErr.iErr)
210             {
211                 printError(&sciErr, 0);
212                 freeAllocatedSingleString(titleAdr);
213                 return 1;
214             }
215
216             // Retrieve a matrix of double at position firstColorIndex.
217             sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
218             if (sciErr.iErr)
219             {
220                 printError(&sciErr, 0);
221                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex);
222                 freeAllocatedSingleString(titleAdr);
223                 return 1;
224             }
225
226             if (nbRow * nbCol != 1)
227             {
228                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex);
229                 freeAllocatedSingleString(titleAdr);
230                 return FALSE;
231             }
232         }
233         else
234         {
235             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex);
236             freeAllocatedSingleString(titleAdr);
237             return FALSE;
238         }
239
240         /* Default green value */
241         if (checkInputArgumentType(pvApiCtx, firstColorIndex + 1, sci_matrix))
242         {
243             sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 1, &piAddrgreenAdr);
244             if (sciErr.iErr)
245             {
246                 printError(&sciErr, 0);
247                 freeAllocatedSingleString(titleAdr);
248                 return 1;
249             }
250
251             // Retrieve a matrix of double at position firstColorIndex + 1.
252             sciErr = getMatrixOfDouble(pvApiCtx, piAddrgreenAdr, &nbRow, &nbCol, &greenAdr);
253             if (sciErr.iErr)
254             {
255                 printError(&sciErr, 0);
256                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
257                 freeAllocatedSingleString(titleAdr);
258                 return 1;
259             }
260
261             if (nbRow * nbCol != 1)
262             {
263                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
264                 freeAllocatedSingleString(titleAdr);
265                 return FALSE;
266             }
267         }
268         else
269         {
270             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
271             freeAllocatedSingleString(titleAdr);
272             return FALSE;
273         }
274
275         /* Default blue value */
276         if (checkInputArgumentType(pvApiCtx, firstColorIndex + 2, sci_matrix))
277         {
278             sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 2, &piAddrblueAdr);
279             if (sciErr.iErr)
280             {
281                 printError(&sciErr, 0);
282                 freeAllocatedSingleString(titleAdr);
283                 return 1;
284             }
285
286             // Retrieve a matrix of double at position firstColorIndex + 2.
287             sciErr = getMatrixOfDouble(pvApiCtx, piAddrblueAdr, &nbRow, &nbCol, &blueAdr);
288             if (sciErr.iErr)
289             {
290                 printError(&sciErr, 0);
291                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
292                 freeAllocatedSingleString(titleAdr);
293                 return 1;
294             }
295
296             if (nbRow * nbCol != 1)
297             {
298                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
299                 freeAllocatedSingleString(titleAdr);
300                 return FALSE;
301             }
302         }
303         else
304         {
305             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
306             freeAllocatedSingleString(titleAdr);
307             return FALSE;
308         }
309     }
310
311     /* Create the Java Object */
312     colorChooserID = createColorChooser();
313
314     /* Title */
315     if (titleAdr != 0)
316     {
317         setColorChooserTitle(colorChooserID, titleAdr);
318         freeAllocatedSingleString(titleAdr);
319     }
320
321     /* Default red value */
322     if (redAdr != 0)
323     {
324         if (greenAdr != 0 ) /* All values given in first input argument */
325         {
326             setColorChooserDefaultRGBSeparateValues(colorChooserID, (int)redAdr[0], (int)greenAdr[0], (int)blueAdr[0]);
327         }
328         else
329         {
330             setColorChooserDefaultRGB(colorChooserID, redAdr);
331         }
332     }
333
334     /* Display it and wait for a user input */
335     colorChooserDisplayAndWait(colorChooserID);
336
337     /* Return the selected color */
338     /* Read the user answer */
339     selectedRGB = getColorChooserSelectedRGB(colorChooserID);
340
341     if (selectedRGB[0] >= 0) /* The user selected a color */
342     {
343
344         nbRow = 1;
345         if (nbOutputArgument(pvApiCtx) == 1)
346         {
347             nbCol = 3;
348             sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, selectedRGB);
349             if (sciErr.iErr)
350             {
351                 printError(&sciErr, 0);
352                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
353                 delete[] selectedRGB;
354                 return 1;
355             }
356
357             AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
358         }
359
360         if (nbOutputArgument(pvApiCtx) >= 2)
361         {
362             nbCol = 1;
363
364             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
365             if (sciErr.iErr)
366             {
367                 printError(&sciErr, 0);
368                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
369                 delete[] selectedRGB;
370                 return 1;
371             }
372
373             redAdr[0] = selectedRGB[0];
374
375             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr);
376             if (sciErr.iErr)
377             {
378                 printError(&sciErr, 0);
379                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
380                 delete[] selectedRGB;
381                 return 1;
382             }
383
384             greenAdr[0] = selectedRGB[1];
385
386             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr);
387             if (sciErr.iErr)
388             {
389                 printError(&sciErr, 0);
390                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
391                 delete[] selectedRGB;
392                 return 1;
393             }
394
395             blueAdr[0] = selectedRGB[2];
396
397             AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
398             AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
399             AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
400         }
401     }
402     else /* The user canceled */
403     {
404         nbRow = 0;
405         nbCol = 0;
406         if (nbOutputArgument(pvApiCtx) == 1)
407         {
408             /* Return [] */
409             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
410             if (sciErr.iErr)
411             {
412                 printError(&sciErr, 0);
413                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
414                 delete[] selectedRGB;
415                 return 1;
416             }
417
418
419             AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
420         }
421
422         if (nbOutputArgument(pvApiCtx) >= 2)
423         {
424             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
425             if (sciErr.iErr)
426             {
427                 printError(&sciErr, 0);
428                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
429                 delete[] selectedRGB;
430                 return 1;
431             }
432
433             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr);
434             if (sciErr.iErr)
435             {
436                 printError(&sciErr, 0);
437                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
438                 delete[] selectedRGB;
439                 return 1;
440             }
441
442             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr);
443             if (sciErr.iErr)
444             {
445                 printError(&sciErr, 0);
446                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
447                 delete[] selectedRGB;
448                 return 1;
449             }
450
451
452             AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
453             AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
454             AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
455         }
456     }
457
458     delete[] selectedRGB;
459     ReturnArguments(pvApiCtx);
460     return TRUE;
461 }
462 /*--------------------------------------------------------------------------*/