xset : duplicate case removed.
[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         int markMode = 1;
262         char *subwinUID = NULL;
263         if (nbInputArgument(pvApiCtx) != 3)
264         {
265             freeAllocatedSingleString(l1);
266             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 3);
267             return -1;
268         }
269
270         subwinUID = (char*)getOrCreateDefaultSubwin();
271         setGraphicObjectProperty(subwinUID, __GO_MARK_MODE__, &markMode, jni_bool, 1);
272         setGraphicObjectProperty(subwinUID, __GO_MARK_SIZE_UNIT__, &markSizeUnit, jni_int, 1); /* force switch to tabulated mode : old syntax */
273         setGraphicObjectProperty(subwinUID, __GO_MARK_STYLE__, &markStyle, jni_int, 1);
274         setGraphicObjectProperty(subwinUID, __GO_MARK_SIZE__, &markSize, jni_int, 1);
275     }
276     else if (strcmp((l1), "font size") == 0)
277     {
278         double fontSize = xx[0];
279         if (nbInputArgument(pvApiCtx) != 2)
280         {
281             freeAllocatedSingleString(l1);
282             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
283             return 1;
284         }
285         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_SIZE__, &fontSize, jni_double, 1);
286     }
287     else if (strcmp((l1), "default") == 0)
288     {
289         // default color map
290         unsigned short defcolors[] =
291         {
292             0, 0, 0,                    /* Black: DEFAULTBLACK */
293             0, 0, 255,                  /* Blue */
294             0, 255, 0,                  /* Green */
295             0, 255, 255,                /* Cyan */
296             255, 0, 0,                  /* Red */
297             255, 0, 255,                /* Magenta */
298             255, 255, 0,                /* Yellow */
299             255, 255, 255,              /* White: DEFAULTWHITE */
300             0, 0, 144,                  /* Blue4 */
301             0, 0, 176,                  /* Blue3 */
302             0, 0, 208,                  /* Blue2 */
303             135, 206, 255,              /* LtBlue */
304             0, 144, 0,                  /* Green4 */
305             0, 176, 0,                  /* Green3 */
306             0, 208, 0,                  /* Green2 */
307             0, 144, 144,                /* Cyan4 */
308             0, 176, 176,                /* Cyan3 */
309             0, 208, 208,                /* Cyan2 */
310             144, 0, 0,                  /* Red4 */
311             176, 0, 0,                  /* Red3 */
312             208, 0, 0,                  /* Red2 */
313             144, 0, 144,                /* Magenta4 */
314             176, 0, 176,                /* Magenta3 */
315             208, 0, 208,                /* Magenta2 */
316             128, 48, 0,                 /* Brown4 */
317             160, 64, 0,                 /* Brown3 */
318             192, 96, 0,                 /* Brown2 */
319             255, 128, 128,              /* Pink4 */
320             255, 160, 160,              /* Pink3 */
321             255, 192, 192,              /* Pink2 */
322             255, 224, 224,              /* Pink */
323             255, 215, 0                 /* Gold */
324         };
325
326         int piFigurePosition[2] = {200, 200};
327         int piFigureSize[2]     = {500, 500};
328         int piAxesSize[2]       = {498, 366};
329         int piViewPort[2]       = {0, 0};
330         int piEmptyMatrix[4]    = {1, 0, 0, 0};
331
332         // Create new axes and set it in current figure
333         char* pSubWinUID = NULL;
334
335         // init variables
336         int iZero   = 0;
337         BOOL bTrue  = TRUE;
338         BOOL bFalse = FALSE;
339         int m       = NUMCOLORS_SCI;
340         int i       = 0;
341         int iCopy   = 3;
342
343         int defaultBackground = -2;
344
345         double* pdblColorMap = NULL;
346         char* pFigureUID = NULL;
347
348         if (nbInputArgument(pvApiCtx) != 1)
349         {
350             freeAllocatedSingleString(l1);
351             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 1);
352             return 1;
353         }
354
355
356         getFPF()[0] = '\0';
357
358         pdblColorMap = (double*)malloc(m * 3 * sizeof(double));
359         if (pdblColorMap == NULL)
360         {
361             freeAllocatedSingleString(l1);
362             Scierror(999, _("%s: No more memory.\n"), fname);
363             return 0;
364         }
365
366         // Create figure if it not exist.
367         pFigureUID = (char*)getCurrentFigure();
368         if (pFigureUID == NULL)
369         {
370             pFigureUID = createNewFigureWithAxes();
371             setCurrentFigure(pFigureUID);
372             AssignOutputVariable(pvApiCtx, 1) = 0;
373             ReturnArguments(pvApiCtx);
374             free(pdblColorMap);
375             freeAllocatedSingleString(l1);
376             return 0;
377         }
378
379         pSubWinUID = (char*)getCurrentSubWin();
380         if (pSubWinUID != NULL)
381         {
382             int iChildrenCount  = 0;
383             int* childrencount  = &iChildrenCount;
384             char** childrenUID  = NULL;
385             int iHidden         = 0;
386             int *piHidden       = &iHidden;
387
388             getGraphicObjectProperty(pFigureUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&childrencount);
389             getGraphicObjectProperty(pFigureUID, __GO_CHILDREN__, jni_string_vector, (void **)&childrenUID);
390
391             for (i = 0; i < childrencount[0]; ++i)
392             {
393                 getGraphicObjectProperty(childrenUID[i], __GO_HIDDEN__, jni_bool, (void **)&piHidden);
394                 if (iHidden == 0)
395                 {
396                     deleteGraphicObject(childrenUID[i]);
397                 }
398             }
399         }
400
401         cloneAxesModel(pFigureUID);
402
403         // Set default figure properties
404         setGraphicObjectProperty(pFigureUID, __GO_POSITION__, piFigurePosition, jni_int_vector, 2);
405         setGraphicObjectProperty(pFigureUID, __GO_SIZE__, piFigureSize, jni_int_vector, 2);
406         setGraphicObjectProperty(pFigureUID, __GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2);
407         setGraphicObjectProperty(pFigureUID, __GO_AUTORESIZE__, &bTrue, jni_bool, 1);
408         setGraphicObjectProperty(pFigureUID, __GO_VIEWPORT__, piViewPort, jni_int_vector, 2);
409         setGraphicObjectProperty(pFigureUID, __GO_NAME__, _("Figure n°%d"), jni_string, 1);
410         setGraphicObjectProperty(pFigureUID, __GO_INFO_MESSAGE__, "", jni_string, 1);
411         setGraphicObjectProperty(pFigureUID, __GO_PIXMAP__, &bFalse, jni_bool, 1);
412         setGraphicObjectProperty(pFigureUID, __GO_PIXEL_DRAWING_MODE__, &iCopy, jni_int, 1);
413         setGraphicObjectProperty(pFigureUID, __GO_ANTIALIASING__, &iZero, jni_int, 1);
414         setGraphicObjectProperty(pFigureUID, __GO_IMMEDIATE_DRAWING__, &bTrue, jni_bool, 1);
415         setGraphicObjectProperty(pFigureUID, __GO_BACKGROUND__, &defaultBackground, jni_int, 1);
416         setGraphicObjectProperty(pFigureUID, __GO_VISIBLE__, &bTrue, jni_bool, 1);
417         setGraphicObjectProperty(pFigureUID, __GO_ROTATION_TYPE__, &iZero, jni_int, 1);
418         setGraphicObjectProperty(pFigureUID, __GO_EVENTHANDLER__, "", jni_string, 1);
419         setGraphicObjectProperty(pFigureUID, __GO_EVENTHANDLER_ENABLE__, &bFalse, jni_bool, 1);
420         setGraphicObjectProperty(pFigureUID, __GO_USER_DATA__, piEmptyMatrix, jni_int_vector, 4);
421         setGraphicObjectProperty(pFigureUID, __GO_RESIZEFCN__, "", jni_string, 1);
422         setGraphicObjectProperty(pFigureUID, __GO_TAG__, "", jni_string, 1);
423
424         for (i = 0; i < m; i++)
425         {
426             pdblColorMap[i]         = (double)(defcolors[3 * i] / 255.0);
427             pdblColorMap[i + m]     = (double)(defcolors[3 * i + 1] / 255.0);
428             pdblColorMap[i + 2 * m] = (double)(defcolors[3 * i + 2] / 255.0);
429         }
430
431         setGraphicObjectProperty(pFigureUID, __GO_COLORMAP__, pdblColorMap, jni_double_vector, 3 * m);
432         setGraphicObjectProperty(pFigureUID, __GO_PARENT__, "", jni_string, 1);
433
434     }
435     else if (strcmp((l1), "clipgrf") == 0)
436     {
437         int clipState = 1;
438         /* special treatement for xset("cligrf") */
439         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, &clipState, jni_int, 1);
440     }
441     else if (strcmp((l1), "clipoff") == 0)
442     {
443         int clipState = 0;
444         /* special treatement for xset("clipoff") */
445         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_CLIP_STATE__, &clipState, jni_int, 1);
446     }
447     else if (strcmp((l1), "hidden3d") == 0)
448     {
449         /* special treatement for xset("hidden3d") */
450         int hiddenColor = (int) x[0];
451         if (nbInputArgument(pvApiCtx) != 2)
452         {
453             freeAllocatedSingleString(l1);
454             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
455             return 1;
456         }
457         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_HIDDEN_COLOR__, &hiddenColor, jni_int, 1);
458     }
459     else if (strcmp((l1), "font") == 0)
460     {
461         int fontStyle = (int) xx[0];
462         double fontSize = xx[1];
463         if (nbInputArgument(pvApiCtx) != 3)
464         {
465             freeAllocatedSingleString(l1);
466             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 3);
467             return -1;
468         }
469
470         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_SIZE__, &fontSize, jni_double, 1);
471         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_FONT_STYLE__, &fontStyle, jni_int, 1);
472     }
473     else if (strcmp((l1), "window") == 0 || strcmp((l1), "figure") == 0)
474     {
475         // Find if window already exists, if not create a new one
476         int iID = x[0];
477         char *pFigureUID = (char*)getFigureFromIndex(iID);
478
479         if (nbInputArgument(pvApiCtx) != 2)
480         {
481             freeAllocatedSingleString(l1);
482             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
483             return 1;
484         }
485
486         if (pFigureUID == NULL)
487         {
488             pFigureUID = createNewFigureWithAxes();
489             setGraphicObjectProperty(pFigureUID, __GO_ID__, &iID, jni_int, 1);
490             setCurrentFigure(pFigureUID);
491         }
492         setCurrentFigure(pFigureUID);
493     }
494     else if ((strcmp((l1), "foreground") == 0) || (strcmp((l1), "color") == 0) || (strcmp((l1), "pattern") == 0))
495     {
496         int iColor = (int) x[0];
497         if (nbInputArgument(pvApiCtx) != 2)
498         {
499             freeAllocatedSingleString(l1);
500             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
501             return 1;
502         }
503         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_COLOR__, &iColor, jni_int, 1);
504     }
505     else if (strcmp((l1), "background") == 0)
506     {
507         int iColor = (int) x[0];
508         if (nbInputArgument(pvApiCtx) != 2)
509         {
510             freeAllocatedSingleString(l1);
511             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
512             return 1;
513         }
514         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_BACKGROUND__, &iColor, jni_int, 1);
515     }
516     else if (strcmp((l1), "thickness") == 0)
517     {
518         if (nbInputArgument(pvApiCtx) != 2)
519         {
520             freeAllocatedSingleString(l1);
521             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
522             return 1;
523         }
524         sciSetLineWidth((char*)getOrCreateDefaultSubwin(), x[0]);
525     }
526     else if (strcmp((l1), "line style") == 0)
527     {
528         int lineStyle = (int) x[0];
529         if (nbInputArgument(pvApiCtx) != 2)
530         {
531             freeAllocatedSingleString(l1);
532             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
533             return 1;
534         }
535         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_STYLE__, &lineStyle, jni_int, 1);
536     }
537     else if (strcmp((l1), "dashes") == 0)
538     {
539         int lineStyle = (int) x[0];
540         if (nbInputArgument(pvApiCtx) != 2)
541         {
542             freeAllocatedSingleString(l1);
543             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
544             return 1;
545         }
546         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_LINE_STYLE__, &lineStyle, jni_int, 1);
547     }
548     else if (strcmp((l1), "wresize") == 0)
549     {
550         int iAutoResizeMode = x[0];
551         if (nbInputArgument(pvApiCtx) != 2)
552         {
553             freeAllocatedSingleString(l1);
554             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
555             return 1;
556         }
557         setGraphicObjectProperty(getOrCreateDefaultSubwin(), __GO_AUTORESIZE__, &iAutoResizeMode, jni_bool, 1);
558     }
559     else if (strcmp((l1), "wpos") == 0)
560     {
561         int figurePosition[2];
562         if (nbInputArgument(pvApiCtx) != 2)
563         {
564             freeAllocatedSingleString(l1);
565             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
566             return -1;
567         }
568         getOrCreateDefaultSubwin();
569
570         figurePosition[0] = x[0];
571         figurePosition[1] = x[1];
572         setGraphicObjectProperty(getCurrentFigure(), __GO_POSITION__, figurePosition, jni_int_vector, 2);
573     }
574     else if (strcmp((l1), "wpdim") == 0 || strcmp((l1), "wdim") == 0)
575     {
576         int figureSize[2];
577         if (nbInputArgument(pvApiCtx) != 2 && nbInputArgument(pvApiCtx) != 3)
578         {
579             freeAllocatedSingleString(l1);
580             Scierror(999, _("%s: Wrong number of input arguments: %d or %d expected.\n"), fname, 2, 3);
581             return -1;
582         }
583
584         /* Xwindows limits dimensions to 2^16 */
585         if ((x[0] > 65535) || (x[1] > 65535))
586         {
587             x[0] = Min(x[0], 65535);
588             x[1] = Min(x[1], 65535);
589             i = 106;
590             v = 0;
591             C2F(msgs)(&i, &v);
592         }
593
594         getOrCreateDefaultSubwin();
595
596         figureSize[0] = x[0];
597         figureSize[1] = x[1];
598         setGraphicObjectProperty(getCurrentFigure(), __GO_SIZE__, figureSize, jni_int_vector, 2);
599     } /*Ajout A.Djalel le 10/11/03 */
600     else if (strcmp((l1), "pixmap") == 0)
601     {
602         int iPixmapMode = x[0];
603         if (nbInputArgument(pvApiCtx) != 2)
604         {
605             freeAllocatedSingleString(l1);
606             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
607             return 1;
608         }
609         getOrCreateDefaultSubwin();
610         setGraphicObjectProperty(getCurrentFigure(), __GO_PIXMAP__, &iPixmapMode, jni_bool, 1);
611     }
612     else if (strcmp((l1), "viewport") == 0)
613     {
614         int viewport[4] = {x[0], x[1], 0, 0};
615         if (nbInputArgument(pvApiCtx) != 3)
616         {
617             freeAllocatedSingleString(l1);
618             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 3);
619             return 1;
620         }
621         getOrCreateDefaultSubwin();
622         setGraphicObjectProperty(getCurrentFigure(), __GO_VIEWPORT__, viewport, jni_int_vector, 2);
623     }
624     else if (strcmp((l1), "line mode") == 0)
625     {
626         char *pstSubwinUID = (char*)getOrCreateDefaultSubwin();
627         int iZero = 0;
628         int iOne = 1;
629         if (nbInputArgument(pvApiCtx) != 2)
630         {
631             freeAllocatedSingleString(l1);
632             Scierror(999, _("%s: Wrong number of input arguments: %d expected.\n"), fname, 2);
633             return 1;
634         }
635
636         if (x[0] == 0)
637         {
638             setGraphicObjectProperty(pstSubwinUID, __GO_LINE_MODE__, &iZero, jni_bool, 1);
639         }
640         else
641         {
642             setGraphicObjectProperty(pstSubwinUID, __GO_LINE_MODE__, &iOne, jni_bool, 1);
643         }
644     }
645     else
646     {
647         freeAllocatedSingleString(l1);
648         Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), fname, (l1));
649         return 0;
650     }
651
652     AssignOutputVariable(pvApiCtx, 1) = 0;
653     ReturnArguments(pvApiCtx);
654     freeAllocatedSingleString(l1);
655     return 0;
656 }
657 /*--------------------------------------------------------------------------*/