c53b3655370020c540df7a68ebaafba12f388c35
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_xset.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) 2012 - 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 #include <stdio.h>
20 #include "gw_graphics.h"
21 #include "api_scilab.h"
22 #include "GetProperty.h"
23 #include "SetProperty.h"
24 #include "DrawObjects.h"
25 #include "InitObjects.h"
26 #include "XsetXgetParameters.h"
27 #include "Format.h"
28 #include "msgs.h"
29 #include "localization.h"
30 #include "Scierror.h"
31 #include "HandleManagement.h"
32
33 #include "BuildObjects.h"
34 #include "graphicObjectProperties.h"
35 #include "setGraphicObjectProperty.h"
36 #include "FigureList.h"
37 #include "CurrentFigure.h"
38 #include "CurrentSubwin.h"
39 #include "AxesModel.h"
40 #include "getGraphicObjectProperty.h"
41 #include "deleteGraphicObject.h"
42 #include "warningmode.h"
43 #include "sciprint.h"
44
45 /*--------------------------------------------------------------------------*/
46 int sci_xset(char *fname, unsigned long fname_len)
47 {
48     SciErr sciErr;
49
50     int* piAddrl1 = NULL;
51     char* l1 = NULL;
52     int* piAddrl2 = NULL;
53     char* l2 = NULL;
54     int* piAddrlr = NULL;
55     double* lr = NULL;
56
57     int m1 = 0, m2 = 0, xm[5], xn[5], x[5] = {0, 0, 0, 0, 0}, i = 0, v = 0;
58     double  xx[5] = {0.0, 0.0, 0.0, 0.0, 0.0};
59     char * subwinUID = NULL;
60     BOOL keyFound = FALSE;
61
62     if (nbInputArgument(pvApiCtx) <= 0)
63     {
64         sci_demo(fname, fname_len);
65         return 0;
66     }
67
68     CheckInputArgument(pvApiCtx, 1, 6);
69     CheckOutputArgument(pvApiCtx, 0, 1);
70
71     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
72     if (sciErr.iErr)
73     {
74         printError(&sciErr, 0);
75         return 1;
76     }
77
78     // Retrieve a string at position 1.
79     if (getAllocatedSingleString(pvApiCtx, piAddrl1, &l1))
80     {
81         Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
82         return 1;
83     }
84
85     for (i = 0 ; i < NUMSETFONC ; i++)
86     {
87         if (strcmp(l1, KeyTab_[i]) == 0)
88         {
89             keyFound = TRUE;
90             break;
91         }
92     }
93
94     if (!keyFound)
95     {
96         freeAllocatedSingleString(l1);
97         Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), fname, (l1));
98         return 0;
99     }
100
101     // in case of "fpf" and "auto clear", the second argument must be a string
102     if (nbInputArgument(pvApiCtx) == 2 && (!checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
103     {
104         /* second argument is not a scalar it must be a string */
105         sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
106         if (sciErr.iErr)
107         {
108             freeAllocatedSingleString(l1);
109             printError(&sciErr, 0);
110             return 1;
111         }
112
113         // Retrieve a string at position 2.
114         if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
115         {
116             freeAllocatedSingleString(l1);
117             Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
118             return 1;
119         }
120
121         if (strcmp(l1, "fpf") == 0)
122         {
123             strcpy(getFPF(), l2);
124         }
125         else if (strcmp(l1, "auto clear") == 0)
126         {
127             int bAutoClear = (int) FALSE;
128
129             if (strcmp(l2, "on") == 0)
130             {
131                 bAutoClear = (int) TRUE;
132             }
133
134             setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_AUTO_CLEAR__, &bAutoClear, jni_bool, 1);
135         }
136         else
137         {
138             freeAllocatedSingleString(l1);
139             freeAllocatedSingleString(l2);
140             Scierror(999, _("%s: Unrecognized input argument '%s'.\n"), "xset(arg,<string>)", l1);
141             return -1;
142         }
143
144         AssignOutputVariable(pvApiCtx, 1) = 0;
145         ReturnArguments(pvApiCtx);
146         freeAllocatedSingleString(l1);
147         freeAllocatedSingleString(l2);
148         return 0;
149     }
150
151     // in other case than "fpf" and "auto clear", the secod to fifth argument must be a matrix of double
152     for (i = 2 ; i <= nbInputArgument(pvApiCtx) ; i++)
153     {
154         sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrlr);
155         if (sciErr.iErr)
156         {
157             freeAllocatedSingleString(l1);
158             printError(&sciErr, 0);
159             return 1;
160         }
161
162         // Retrieve a matrix of double at position i.
163         sciErr = getMatrixOfDouble(pvApiCtx, piAddrlr, &xm[i - 2], &xn[i - 2], &lr);
164         if (sciErr.iErr)
165         {
166             freeAllocatedSingleString(l1);
167             printError(&sciErr, 0);
168             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, i);
169             return 1;
170         }
171
172         x[i - 2] = (int)lr[0];
173         xx[i - 2] = lr[0];
174     }
175
176     if (strcmp((l1), "clipping") == 0)
177     {
178         int clipState = 2;
179         if (nbInputArgument(pvApiCtx) != 5 && nbInputArgument(pvApiCtx) != 2)
180         {
181             freeAllocatedSingleString(l1);
182             Scierror(999, _("%s: Wrong number of input arguments: %d or %d expected.\n"), fname, 2, 5);
183             return 1;
184         }
185
186         if (nbInputArgument(pvApiCtx) == 2)
187         {
188             int i = 0;
189             int iRows = 0;
190             int iCols = 0;
191
192             sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlr);
193             if (sciErr.iErr)
194             {
195                 printError(&sciErr, 0);
196                 return 1;
197             }
198
199             // Retrieve a matrix of double at position 2.
200             sciErr = getMatrixOfDouble(pvApiCtx, piAddrlr, &iRows, &iCols, &lr);
201             if (sciErr.iErr)
202             {
203                 freeAllocatedSingleString(l1);
204                 printError(&sciErr, 0);
205                 Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
206                 return 1;
207             }
208
209
210             if (iRows * iCols != 4)
211             {
212                 freeAllocatedSingleString(l1);
213                 Scierror(999, _("%s: Wrong size for input argument #%d: A %d-element vector expected.\n"), fname, 2, 4);
214                 return 1;
215             }
216
217             for (i = 0; i < 4 ; i++)
218             {
219                 xx[i] = lr[i];
220             }
221         }
222         subwinUID = (char*)getOrCreateDefaultSubwin();
223         setGraphicObjectProperty(subwinUID, __GO_CLIP_BOX__, xx, jni_double_vector, 4);
224         setGraphicObjectProperty(subwinUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
225     }
226     else if (strcmp((l1), "colormap") == 0)
227     {
228         char *pFigureUID = NULL;
229         if (nbInputArgument(pvApiCtx) != 2)
230         {
231             freeAllocatedSingleString(l1);
232             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
233             return 1;
234         }
235
236         getOrCreateDefaultSubwin();
237         pFigureUID = (char*)getCurrentFigure();
238         setGraphicObjectProperty(pFigureUID, __GO_COLORMAP__, (lr), jni_double_vector, *xm * (*xn));
239     }
240     else if (strcmp((l1), "mark size") == 0)
241     {
242         int markSize = (int) xx[0];
243         int markSizeUnit = 1; /* force switch to tabulated mode : old syntax / 0 : point, 1 : tabulated */
244         char *subwinUID = (char*)getOrCreateDefaultSubwin();
245
246         if (nbInputArgument(pvApiCtx) != 2)
247         {
248             freeAllocatedSingleString(l1);
249             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
250             return 1;
251         }
252
253         setGraphicObjectProperty(subwinUID, __GO_MARK_SIZE_UNIT__, &markSizeUnit, jni_int, 1);
254         setGraphicObjectProperty(subwinUID, __GO_MARK_SIZE__, &markSize, jni_int, 1);
255     }
256     else if (strcmp((l1), "mark") == 0)
257     {
258         int markStyle = (int) xx[0];
259         int markSize = (int) xx[1];
260         int markSizeUnit = 1; /* force switch to tabulated mode : old syntax / 0 : point, 1 : tabulated */
261         char *subwinUID = NULL;
262         if (nbInputArgument(pvApiCtx) != 3)
263         {
264             freeAllocatedSingleString(l1);
265             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 3);
266             return -1;
267         }
268
269         subwinUID = (char*)getOrCreateDefaultSubwin();
270         setGraphicObjectProperty(subwinUID, __GO_MARK_SIZE_UNIT__, &markSizeUnit, jni_int, 1); /* force switch to tabulated mode : old syntax */
271         setGraphicObjectProperty(subwinUID, __GO_MARK_STYLE__, &markStyle, jni_int, 1);
272         setGraphicObjectProperty(subwinUID, __GO_MARK_SIZE__, &markSize, jni_int, 1);
273     }
274     else if (strcmp((l1), "font size") == 0)
275     {
276         double fontSize = xx[0];
277         if (nbInputArgument(pvApiCtx) != 2)
278         {
279             freeAllocatedSingleString(l1);
280             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
281             return 1;
282         }
283         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_SIZE__, &fontSize, jni_double, 1);
284     }
285     else if (strcmp((l1), "default") == 0)
286     {
287         // default color map
288         unsigned short defcolors[] =
289         {
290             0, 0, 0,                    /* Black: DEFAULTBLACK */
291             0, 0, 255,                  /* Blue */
292             0, 255, 0,                  /* Green */
293             0, 255, 255,                /* Cyan */
294             255, 0, 0,                  /* Red */
295             255, 0, 255,                /* Magenta */
296             255, 255, 0,                /* Yellow */
297             255, 255, 255,              /* White: DEFAULTWHITE */
298             0, 0, 144,                  /* Blue4 */
299             0, 0, 176,                  /* Blue3 */
300             0, 0, 208,                  /* Blue2 */
301             135, 206, 255,              /* LtBlue */
302             0, 144, 0,                  /* Green4 */
303             0, 176, 0,                  /* Green3 */
304             0, 208, 0,                  /* Green2 */
305             0, 144, 144,                /* Cyan4 */
306             0, 176, 176,                /* Cyan3 */
307             0, 208, 208,                /* Cyan2 */
308             144, 0, 0,                  /* Red4 */
309             176, 0, 0,                  /* Red3 */
310             208, 0, 0,                  /* Red2 */
311             144, 0, 144,                /* Magenta4 */
312             176, 0, 176,                /* Magenta3 */
313             208, 0, 208,                /* Magenta2 */
314             128, 48, 0,                 /* Brown4 */
315             160, 64, 0,                 /* Brown3 */
316             192, 96, 0,                 /* Brown2 */
317             255, 128, 128,              /* Pink4 */
318             255, 160, 160,              /* Pink3 */
319             255, 192, 192,              /* Pink2 */
320             255, 224, 224,              /* Pink */
321             255, 215, 0                 /* Gold */
322         };
323
324         int piFigurePosition[2] = {200, 200};
325         int piFigureSize[2]     = {500, 500};
326         int piAxesSize[2]       = {498, 366};
327         int piViewPort[2]       = {0, 0};
328         int piEmptyMatrix[4]    = {1, 0, 0, 0};
329
330         // Create new axes and set it in current figure
331         char* pSubWinUID = NULL;
332
333         // init variables
334         int iZero   = 0;
335         BOOL bTrue  = TRUE;
336         BOOL bFalse = FALSE;
337         int m       = NUMCOLORS_SCI;
338         int i       = 0;
339         int iCopy   = 3;
340
341         int defaultBackground = -2;
342
343         double* pdblColorMap = NULL;
344         char* pFigureUID = NULL;
345
346         if (nbInputArgument(pvApiCtx) != 1)
347         {
348             freeAllocatedSingleString(l1);
349             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 1);
350             return 1;
351         }
352
353
354         getFPF()[0] = '\0';
355
356         pdblColorMap = (double*)malloc(m * 3 * sizeof(double));
357         if (pdblColorMap == NULL)
358         {
359             freeAllocatedSingleString(l1);
360             Scierror(999, _("%s: No more memory.\n"), fname);
361             return 0;
362         }
363
364         // Create figure if it not exist.
365         pFigureUID = (char*)getCurrentFigure();
366         if (pFigureUID == NULL)
367         {
368             pFigureUID = createNewFigureWithAxes();
369             setCurrentFigure(pFigureUID);
370             AssignOutputVariable(pvApiCtx, 1) = 0;
371             ReturnArguments(pvApiCtx);
372             free(pdblColorMap);
373             freeAllocatedSingleString(l1);
374             return 0;
375         }
376
377         pSubWinUID = (char*)getCurrentSubWin();
378         if (pSubWinUID != NULL)
379         {
380             int iChildrenCount  = 0;
381             int* childrencount  = &iChildrenCount;
382             char** childrenUID  = NULL;
383             int iHidden         = 0;
384             int *piHidden       = &iHidden;
385
386             getGraphicObjectProperty(pFigureUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&childrencount);
387             getGraphicObjectProperty(pFigureUID, __GO_CHILDREN__, jni_string_vector, (void **)&childrenUID);
388
389             for (i = 0; i < childrencount[0]; ++i)
390             {
391                 getGraphicObjectProperty(childrenUID[i], __GO_HIDDEN__, jni_bool, (void **)&piHidden);
392                 if (iHidden == 0)
393                 {
394                     deleteGraphicObject(childrenUID[i]);
395                 }
396             }
397         }
398
399         cloneAxesModel(pFigureUID);
400
401         // Set default figure properties
402         setGraphicObjectProperty(pFigureUID, __GO_POSITION__, piFigurePosition, jni_int_vector, 2);
403         setGraphicObjectProperty(pFigureUID, __GO_SIZE__, piFigureSize, jni_int_vector, 2);
404         setGraphicObjectProperty(pFigureUID, __GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2);
405         setGraphicObjectProperty(pFigureUID, __GO_AUTORESIZE__, &bTrue, jni_bool, 1);
406         setGraphicObjectProperty(pFigureUID, __GO_VIEWPORT__, piViewPort, jni_int_vector, 2);
407         setGraphicObjectProperty(pFigureUID, __GO_NAME__, _("Figure n°%d"), jni_string, 1);
408         setGraphicObjectProperty(pFigureUID, __GO_INFO_MESSAGE__, "", jni_string, 1);
409         setGraphicObjectProperty(pFigureUID, __GO_PIXMAP__, &bFalse, jni_bool, 1);
410         setGraphicObjectProperty(pFigureUID, __GO_PIXEL_DRAWING_MODE__, &iCopy, jni_int, 1);
411         setGraphicObjectProperty(pFigureUID, __GO_ANTIALIASING__, &iZero, jni_int, 1);
412         setGraphicObjectProperty(pFigureUID, __GO_IMMEDIATE_DRAWING__, &bTrue, jni_bool, 1);
413         setGraphicObjectProperty(pFigureUID, __GO_BACKGROUND__, &defaultBackground, jni_int, 1);
414         setGraphicObjectProperty(pFigureUID, __GO_VISIBLE__, &bTrue, jni_bool, 1);
415         setGraphicObjectProperty(pFigureUID, __GO_ROTATION_TYPE__, &iZero, jni_int, 1);
416         setGraphicObjectProperty(pFigureUID, __GO_EVENTHANDLER__, "", jni_string, 1);
417         setGraphicObjectProperty(pFigureUID, __GO_EVENTHANDLER_ENABLE__, &bFalse, jni_bool, 1);
418         setGraphicObjectProperty(pFigureUID, __GO_USER_DATA__, piEmptyMatrix, jni_int_vector, 4);
419         setGraphicObjectProperty(pFigureUID, __GO_RESIZEFCN__, "", jni_string, 1);
420         setGraphicObjectProperty(pFigureUID, __GO_TAG__, "", jni_string, 1);
421
422         for (i = 0; i < m; i++)
423         {
424             pdblColorMap[i]         = (double)(defcolors[3 * i] / 255.0);
425             pdblColorMap[i + m]     = (double)(defcolors[3 * i + 1] / 255.0);
426             pdblColorMap[i + 2 * m] = (double)(defcolors[3 * i + 2] / 255.0);
427         }
428
429         setGraphicObjectProperty(pFigureUID, __GO_COLORMAP__, pdblColorMap, jni_double_vector, 3 * m);
430         setGraphicObjectProperty(pFigureUID, __GO_PARENT__, "", jni_string, 1);
431
432     }
433     else if (strcmp((l1), "clipgrf") == 0)
434     {
435         int clipState = 1;
436         /* special treatement for xset("cligrf") */
437         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, &clipState, jni_int, 1);
438     }
439     else if (strcmp((l1), "clipoff") == 0)
440     {
441         int clipState = 0;
442         /* special treatement for xset("clipoff") */
443         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, &clipState, jni_int, 1);
444     }
445     else if (strcmp((l1), "hidden3d") == 0)
446     {
447         /* special treatement for xset("hidden3d") */
448         int hiddenColor = (int) x[0];
449         if (nbInputArgument(pvApiCtx) != 2)
450         {
451             freeAllocatedSingleString(l1);
452             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
453             return 1;
454         }
455         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_HIDDEN_COLOR__, &hiddenColor, jni_int, 1);
456     }
457     else if (strcmp((l1), "font") == 0)
458     {
459         int fontStyle = (int) xx[0];
460         double fontSize = xx[1];
461         if (nbInputArgument(pvApiCtx) != 3)
462         {
463             freeAllocatedSingleString(l1);
464             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 3);
465             return -1;
466         }
467
468         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_SIZE__, &fontSize, jni_double, 1);
469         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_STYLE__, &fontStyle, jni_int, 1);
470     }
471     else if (strcmp((l1), "window") == 0 || strcmp((l1), "figure") == 0)
472     {
473         // Find if window already exists, if not create a new one
474         int iID = x[0];
475         char *pFigureUID = (char*)getFigureFromIndex(iID);
476
477         if (nbInputArgument(pvApiCtx) != 2)
478         {
479             freeAllocatedSingleString(l1);
480             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
481             return 1;
482         }
483
484         if (pFigureUID == NULL)
485         {
486             pFigureUID = createNewFigureWithAxes();
487             setGraphicObjectProperty(pFigureUID, __GO_ID__, &iID, jni_int, 1);
488             setCurrentFigure(pFigureUID);
489         }
490         setCurrentFigure(pFigureUID);
491     }
492     else if ((strcmp((l1), "foreground") == 0) || (strcmp((l1), "color") == 0) || (strcmp((l1), "pattern") == 0))
493     {
494         int iColor = (int) x[0];
495         if (nbInputArgument(pvApiCtx) != 2)
496         {
497             freeAllocatedSingleString(l1);
498             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
499             return 1;
500         }
501         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_COLOR__, &iColor, jni_int, 1);
502     }
503     else if (strcmp((l1), "background") == 0)
504     {
505         int iColor = (int) x[0];
506         if (nbInputArgument(pvApiCtx) != 2)
507         {
508             freeAllocatedSingleString(l1);
509             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
510             return 1;
511         }
512         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_BACKGROUND__, &iColor, jni_int, 1);
513     }
514     else if (strcmp((l1), "thickness") == 0)
515     {
516         if (nbInputArgument(pvApiCtx) != 2)
517         {
518             freeAllocatedSingleString(l1);
519             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
520             return 1;
521         }
522         sciSetLineWidth((char*)getOrCreateDefaultSubwin(), x[0]);
523     }
524     else if (strcmp((l1), "line style") == 0)
525     {
526         int lineStyle = (int) x[0];
527         if (nbInputArgument(pvApiCtx) != 2)
528         {
529             freeAllocatedSingleString(l1);
530             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
531             return 1;
532         }
533         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_STYLE__, &lineStyle, jni_int, 1);
534     }
535     else if (strcmp((l1), "mark") == 0)
536     {
537         int markMode = 1;
538
539         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_MARK_MODE__, &markMode, jni_bool, 1);
540         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_MARK_STYLE__, x, jni_int, 1);
541     }
542     else if (strcmp((l1), "colormap") == 0)
543     {
544         getOrCreateDefaultSubwin();
545         if (nbInputArgument(pvApiCtx) != 2)
546         {
547             freeAllocatedSingleString(l1);
548             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
549             return 1;
550         }
551         setGraphicObjectProperty(getCurrentFigure(), __GO_COLORMAP__, (lr), jni_double_vector, xm[0] * xn[0]);
552     }
553     else if (strcmp((l1), "dashes") == 0)
554     {
555         int lineStyle = (int) x[0];
556         if (nbInputArgument(pvApiCtx) != 2)
557         {
558             freeAllocatedSingleString(l1);
559             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
560             return 1;
561         }
562         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_STYLE__, &lineStyle, jni_int, 1);
563     }
564     else if (strcmp((l1), "wresize") == 0)
565     {
566         int iAutoResizeMode = x[0];
567         if (nbInputArgument(pvApiCtx) != 2)
568         {
569             freeAllocatedSingleString(l1);
570             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
571             return 1;
572         }
573         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_AUTORESIZE__, &iAutoResizeMode, jni_bool, 1);
574     }
575     else if (strcmp((l1), "wpos") == 0)
576     {
577         int figurePosition[2];
578         if (nbInputArgument(pvApiCtx) != 2)
579         {
580             freeAllocatedSingleString(l1);
581             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
582             return -1;
583         }
584         getOrCreateDefaultSubwin();
585
586         figurePosition[0] = x[0];
587         figurePosition[1] = x[1];
588         setGraphicObjectProperty(getCurrentFigure(), __GO_POSITION__, figurePosition, jni_int_vector, 2);
589     }
590     else if (strcmp((l1), "wpdim") == 0 || strcmp((l1), "wdim") == 0)
591     {
592         int figureSize[2];
593         if (nbInputArgument(pvApiCtx) != 2 && nbInputArgument(pvApiCtx) != 3)
594         {
595             freeAllocatedSingleString(l1);
596             Scierror(999, _("%s: Wrong number of input arguments: %d or %d expected.\n"), fname, 2, 3);
597             return -1;
598         }
599
600         /* Xwindows limits dimensions to 2^16 */
601         if ((x[0] > 65535) || (x[1] > 65535))
602         {
603             x[0] = Min(x[0], 65535);
604             x[1] = Min(x[1], 65535);
605             i = 106;
606             v = 0;
607             C2F(msgs)(&i, &v);
608         }
609
610         getOrCreateDefaultSubwin();
611
612         figureSize[0] = x[0];
613         figureSize[1] = x[1];
614         setGraphicObjectProperty(getCurrentFigure(), __GO_SIZE__, figureSize, jni_int_vector, 2);
615     } /*Ajout A.Djalel le 10/11/03 */
616     else if (strcmp((l1), "pixmap") == 0)
617     {
618         int iPixmapMode = x[0];
619         if (nbInputArgument(pvApiCtx) != 2)
620         {
621             freeAllocatedSingleString(l1);
622             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
623             return 1;
624         }
625         getOrCreateDefaultSubwin();
626         setGraphicObjectProperty(getCurrentFigure(), __GO_PIXMAP__, &iPixmapMode, jni_bool, 1);
627     }
628     else if (strcmp((l1), "viewport") == 0)
629     {
630         int viewport[4] = {x[0], x[1], 0, 0};
631         if (nbInputArgument(pvApiCtx) != 3)
632         {
633             freeAllocatedSingleString(l1);
634             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 3);
635             return 1;
636         }
637         getOrCreateDefaultSubwin();
638         setGraphicObjectProperty(getCurrentFigure(), __GO_VIEWPORT__, viewport, jni_int_vector, 2);
639     }
640     else if (strcmp((l1), "line mode") == 0)
641     {
642         char *pstSubwinUID = (char*)getOrCreateDefaultSubwin();
643         int iZero = 0;
644         int iOne = 1;
645         if (nbInputArgument(pvApiCtx) != 2)
646         {
647             freeAllocatedSingleString(l1);
648             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
649             return 1;
650         }
651
652         if (x[0] == 0)
653         {
654             setGraphicObjectProperty(pstSubwinUID, __GO_LINE_MODE__, &iZero, jni_bool, 1);
655         }
656         else
657         {
658             setGraphicObjectProperty(pstSubwinUID, __GO_LINE_MODE__, &iOne, jni_bool, 1);
659         }
660     }
661     else
662     {
663         freeAllocatedSingleString(l1);
664         Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), fname, (l1));
665         return 0;
666     }
667
668     AssignOutputVariable(pvApiCtx, 1) = 0;
669     ReturnArguments(pvApiCtx);
670     freeAllocatedSingleString(l1);
671     return 0;
672 }
673 /*--------------------------------------------------------------------------*/