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