sci_xget : mem leak removed.
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_xget.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Fabrice Leray
4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
5  * Copyright (C) 2011 - Scilab Enterprises - Bruno JOFRET
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15 /*------------------------------------------------------------------------*/
16 /* file: sci_xset.c                                                       */
17 /* desc : interface for xset routine                                      */
18 /*------------------------------------------------------------------------*/
19
20 #include <stdio.h>
21 #include "api_scilab.h"
22 #include "gw_graphics.h"
23 #include "XsetXgetParameters.h"
24 #include "GetProperty.h"
25 #include "Format.h"
26 #include "Scierror.h"
27 #include "localization.h"
28 #include "returnProperty.h"
29 #include "HandleManagement.h"
30 #include "CurrentSubwin.h"
31 #include "getGraphicObjectProperty.h"
32 #include "graphicObjectProperties.h"
33 #include "BuildObjects.h"
34
35 #include "getHandleProperty.h"
36 #include "CurrentFigure.h"
37 /*--------------------------------------------------------------------------*/
38 int xgetg(char * str, char * str1, int * len, int  lx0, int lx1);
39 /*--------------------------------------------------------------------------*/
40 int sci_xget(char *fname, unsigned long fname_len)
41 {
42     SciErr sciErr;
43
44     int* piAddrl1 = NULL;
45     char* l1 = NULL;
46     int* piAddrl2 = NULL;
47     double* l2 = NULL;
48     char* l3 = NULL;
49
50     int m1 = 0, m2 = 0, n2 = 0, i = 0;
51     int one = 1;
52
53     BOOL keyFound = FALSE;
54
55     if (nbInputArgument(pvApiCtx) <= 0)
56     {
57         sci_demo(fname, fname_len);
58         return 0;
59     }
60
61     CheckInputArgument(pvApiCtx, 1, 2);
62     CheckOutputArgument(pvApiCtx, 0, 1);
63
64     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
65     if (sciErr.iErr)
66     {
67         printError(&sciErr, 0);
68         return 1;
69     }
70
71     // Retrieve a matrix of double at position 1.
72     if (getAllocatedSingleString(pvApiCtx, piAddrl1, &l1))
73     {
74         Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
75         return 1;
76     }
77
78     /* check if key is valid */
79     for (i = 0; i < NUMSETFONC ; i++)
80     {
81         if (strcmp((l1), KeyTab_[i]) == 0)
82         {
83             keyFound = TRUE;
84             break;
85         }
86     }
87
88     if (!keyFound)
89     {
90         Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), fname, (l1));
91         freeAllocatedSingleString(l1);
92         return -1;
93     }
94
95     if (nbInputArgument(pvApiCtx) == 2)
96     {
97         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
98         if (sciErr.iErr)
99         {
100             printError(&sciErr, 0);
101             freeAllocatedSingleString(l1);
102             return 1;
103         }
104
105         // Retrieve a matrix of double at position 2.
106         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
107         if (sciErr.iErr)
108         {
109             printError(&sciErr, 0);
110             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
111             freeAllocatedSingleString(l1);
112             return 1;
113         }
114
115         //CheckScalar
116         if (m2 != 1 || n2 != 1)
117         {
118             Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 2);
119             freeAllocatedSingleString(l1);
120             return 1;
121         }
122
123     }
124
125     if (strcmp(l1, "fpf") == 0 || strcmp(l1, "auto clear") == 0)
126     {
127         int bufl;
128         char buf[4096];
129         /*     special case for global variables set */
130         xgetg((l1), buf, &bufl, m1, bsiz);
131         if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, bufl * one, (const char **)&l3))
132         {
133             Scierror(999, _("%s: Memory allocation error.\n"), fname);
134             freeAllocatedSingleString(l1);
135             return 1;
136         }
137
138         strncpy((l3), buf, bufl);
139         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
140         ReturnArguments(pvApiCtx);
141     }
142     else if (strcmp(l1, "colormap") == 0)
143     {
144         char *pobjUID = NULL;
145         // Force figure creation if none exists.
146         getOrCreateDefaultSubwin();
147         pobjUID = (char*)getCurrentFigure();
148
149         get_color_map_property(pvApiCtx, pobjUID);
150
151         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
152         ReturnArguments(pvApiCtx);
153     }
154     else if (strcmp(l1, "mark") == 0)
155     {
156         char *pobjUID = (char*)getOrCreateDefaultSubwin();
157         int iMarkStyle = 0;
158         int* piMarkStyle = &iMarkStyle;
159         int iMarkSize = 0;
160         int* piMarkSize = &iMarkSize;
161         double pdblResult[2];
162
163         getGraphicObjectProperty(pobjUID, __GO_MARK_STYLE__, jni_int, (void**)&piMarkStyle);
164         getGraphicObjectProperty(pobjUID, __GO_MARK_SIZE__, jni_int, (void**)&piMarkSize);
165         pdblResult[0] = iMarkStyle;
166         pdblResult[1] = iMarkSize;
167
168         createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 2, pdblResult);
169         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
170         ReturnArguments(pvApiCtx);
171     }
172     else if (strcmp(l1, "mark size") == 0)
173     {
174         char *pobjUID = (char*)getOrCreateDefaultSubwin();
175         get_mark_size_property(pvApiCtx, pobjUID);
176
177         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
178         ReturnArguments(pvApiCtx);
179     }
180     else if (strcmp(l1, "line style") == 0)
181     {
182         get_line_style_property(pvApiCtx, (char*)getOrCreateDefaultSubwin());
183
184         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
185         ReturnArguments(pvApiCtx);
186     }
187     else if (strcmp(l1, "clipping") == 0)
188     {
189         double *clipBox = NULL;
190         char* pobjUID = (char*)getOrCreateDefaultSubwin();
191
192         getGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, jni_double_vector, (void **)&clipBox);
193
194         createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 4, clipBox);
195         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
196         ReturnArguments(pvApiCtx);
197     }
198     else if (strcmp(l1, "font") == 0)
199     {
200         char *pobjUID = (char*)getOrCreateDefaultSubwin();
201         double dblFontSize = 0;
202         double* pdblFontSize = &dblFontSize;
203         int iFontStyle = 0;
204         int* piFontStyle = &iFontStyle;
205         double pdblResult[2];
206
207         getGraphicObjectProperty(pobjUID, __GO_FONT_SIZE__, jni_double, (void **)&pdblFontSize);
208         getGraphicObjectProperty(pobjUID, __GO_FONT_STYLE__, jni_int, (void**)&piFontStyle);
209
210         pdblResult[0] = iFontStyle;
211         pdblResult[1] = dblFontSize;
212
213
214         createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 2, pdblResult);
215         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
216         ReturnArguments(pvApiCtx);
217     }
218     else if (strcmp(l1, "font size") == 0)
219     {
220         double dblFontSize = 0;
221         double* pdblFontSize = &dblFontSize;
222         getGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_SIZE__, jni_double, (void **)&pdblFontSize);
223
224         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, dblFontSize);
225         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
226         ReturnArguments(pvApiCtx);
227     }
228     else if (strcmp(l1, "dashes") == 0)
229     {
230         int iLineStyle = 0;
231         int* piLineStyle = &iLineStyle;
232
233         getGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_STYLE__, jni_int, (void**)&piLineStyle);
234
235         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iLineStyle);
236         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
237         ReturnArguments(pvApiCtx);
238     }
239     else if (strcmp(l1, "hidden3d") == 0)
240     {
241         get_hidden_color_property(pvApiCtx, (char*)getOrCreateDefaultSubwin());
242
243         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
244         ReturnArguments(pvApiCtx);
245     }
246     else if (strcmp(l1, "window") == 0 || strcmp(l1, "figure") == 0)
247     {
248         int iFigureId = 0;
249         int* piFigureId = &iFigureId;
250
251         getOrCreateDefaultSubwin();
252         getGraphicObjectProperty(getCurrentFigure(), __GO_ID__, jni_int, (void**)&piFigureId);
253         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iFigureId);
254         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
255         ReturnArguments(pvApiCtx);
256     }
257     else if (strcmp(l1, "thickness") == 0)
258     {
259         get_thickness_property(pvApiCtx, (char*)getOrCreateDefaultSubwin());
260
261         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
262         ReturnArguments(pvApiCtx);
263     }
264     else if (strcmp(l1, "wdim") == 0 || strcmp(l1, "wpdim") == 0)
265     {
266         int *piFigureSize = NULL;
267         double pdblFigureSize[2];
268
269         getOrCreateDefaultSubwin();
270         getGraphicObjectProperty(getCurrentFigure(), __GO_SIZE__, jni_int_vector, (void **) &piFigureSize);
271         pdblFigureSize[0] = (double) piFigureSize[0];
272         pdblFigureSize[1] = (double) piFigureSize[1];
273
274         createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 2, pdblFigureSize);
275         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
276         ReturnArguments(pvApiCtx);
277     }
278     else if (strcmp(l1, "wpos") == 0)
279     {
280         int *piFigurePosition = NULL;
281         double pdblFigurePosition[2];
282
283         getOrCreateDefaultSubwin();
284         getGraphicObjectProperty(getCurrentFigure(), __GO_POSITION__, jni_int_vector, (void **) &piFigurePosition);
285         pdblFigurePosition[0] = piFigurePosition[0];
286         pdblFigurePosition[1] = piFigurePosition[1];
287
288         createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 2, pdblFigurePosition);
289         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
290         ReturnArguments(pvApiCtx);
291     }
292     else if (strcmp(l1, "viewport") == 0)
293     {
294         int* viewport = NULL;
295         double pdblViewport[2];
296
297         getOrCreateDefaultSubwin();
298         getGraphicObjectProperty(getCurrentFigure(), __GO_VIEWPORT__, jni_int_vector, (void **)&viewport);
299         pdblViewport[0] = viewport[0];
300         pdblViewport[1] = viewport[1];
301
302         createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 2, pdblViewport);
303         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
304         ReturnArguments(pvApiCtx);
305     }
306     else if (strcmp(l1, "background") == 0)
307     {
308         get_background_property(pvApiCtx, (char*)getOrCreateDefaultSubwin());
309
310         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
311         ReturnArguments(pvApiCtx);
312     }
313     else if (  strcmp(l1, "color") == 0
314                || strcmp(l1, "foreground") == 0
315                || strcmp(l1, "pattern") == 0)
316     {
317         get_foreground_property(pvApiCtx, (char*)getOrCreateDefaultSubwin());
318
319         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
320         ReturnArguments(pvApiCtx);
321     }
322     else if (strcmp(l1, "lastpattern") == 0)
323     {
324         int iNumColors = 0;
325         int* piNumColors = &iNumColors;
326
327         getOrCreateDefaultSubwin();
328         getGraphicObjectProperty(getCurrentFigure(), __GO_COLORMAP_SIZE__, jni_int, (void**)&piNumColors);
329
330         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNumColors);
331
332         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
333         ReturnArguments(pvApiCtx);
334     }
335     else if (strcmp(l1, "line mode") == 0)
336     {
337         int iLineMode = 0;
338         int* lineMode = &iLineMode;
339
340         getGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_MODE__, jni_bool, (void **)&lineMode);
341
342         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iLineMode);
343
344         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
345         ReturnArguments(pvApiCtx);
346     }
347     else if (strcmp(l1, "pixmap") == 0)
348     {
349         int iPixmap = 0;
350         int *piPixmap = &iPixmap;
351
352         getOrCreateDefaultSubwin();
353         getGraphicObjectProperty(getCurrentFigure(), __GO_PIXMAP__, jni_bool, (void **)&piPixmap);
354
355         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iPixmap);
356         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
357         ReturnArguments(pvApiCtx);
358     }
359     else if (strcmp(l1, "white") == 0)
360     {
361         int iNumColors = 0;
362         int* piNumColors = &iNumColors;
363
364         getOrCreateDefaultSubwin();
365         getGraphicObjectProperty(getCurrentFigure(), __GO_COLORMAP_SIZE__, jni_int, (void**)&piNumColors);
366
367         /* White is lqst colormap index + 2 */
368         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iNumColors + 2);
369
370         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
371         ReturnArguments(pvApiCtx);
372     }
373     else if (strcmp(l1, "wresize") == 0)
374     {
375         // autoresize property
376         int iAutoResize = 0;
377         int* piAutoResize =  &iAutoResize;
378
379         getOrCreateDefaultSubwin();
380         getGraphicObjectProperty(getCurrentFigure(), __GO_AUTORESIZE__, jni_bool, (void **)&piAutoResize);
381
382         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iAutoResize);
383
384         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
385         ReturnArguments(pvApiCtx);
386     }
387     else if (strcmp(l1, "clipgrf") == 0)
388     {
389         /* clip_state : 0 = off, 1 = on */
390         int iClipState = 0;
391         int* piClipState = &iClipState;
392
393         getGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, jni_int, (void**)&piClipState);
394
395         createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iClipState);
396         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
397         ReturnArguments(pvApiCtx);
398     }
399     else if (strcmp(l1, "clipoff") == 0)
400     {
401         int iClipState = 0;
402         int* piClipState = &iClipState;
403
404         getGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, jni_int, (void**)&piClipState);
405
406         /* clip_state : 0 = off, 1 = on */
407         if (iClipState == 0)
408         {
409             createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1);
410         }
411         else
412         {
413             createScalarDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 0);
414         }
415         AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
416         ReturnArguments(pvApiCtx);
417     }
418     else
419     {
420         Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), fname, (l1));
421         freeAllocatedSingleString(l1);
422         return -1;
423     }
424
425     freeAllocatedSingleString(l1);
426     return 0;
427 }
428 /*--------------------------------------------------------------------------*/
429 int xgetg(char * str, char * str1, int * len, int  lx0, int lx1)
430 {
431     if (strcmp(str, "fpf") == 0)
432     {
433         strncpy(str1, getFPF(), 32);
434         *len = (int) strlen(str1);
435     }
436     else if (strcmp(str, "auto clear") == 0)
437     {
438         int iAutoClear = 0;
439         int* piAutoClear = &iAutoClear;
440
441         getGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_AUTO_CLEAR__, jni_bool, (void **)&piAutoClear);
442         if (iAutoClear == 1)
443         {
444             strncpy(str1, "on", 2);
445             *len = 2;
446         }
447         else
448         {
449             strncpy(str1, "off", 3);
450             *len = 3;
451         }
452     }
453     return 0;
454 }
455 /*--------------------------------------------------------------------------*/