fix figure with position as string 100|200|300|400
[scilab.git] / scilab / modules / gui / sci_gateway / c / sci_figure.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2014 - Scilab Enterprises - Antoine ELIAS
4  * Copyright (C) 2014 - Scilab Enterprises - Bruno JOFRET
5  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  *
12  */
13
14 #include <stdio.h>
15 #include "gw_gui.h"
16 #include "MALLOC.h"
17 #include "api_scilab.h"
18 #include "localization.h"
19 #include "Scierror.h"
20 #include "createGraphicObject.h"
21 #include "BuildObjects.h"
22 #include "setGraphicObjectProperty.h"
23 #include "getGraphicObjectProperty.h"
24 #include "graphicObjectProperties.h"
25 #include "CurrentFigure.h"
26 #include "CurrentSubwin.h"
27 #include "FigureList.h"
28 #include "FigureModel.h"
29 #include "HandleManagement.h"
30 #include "SetHashTable.h"
31 #include "stricmp.h"
32 #ifdef _MSC_VER
33 #include "strdup_windows.h"
34 #endif
35
36 #include "sciprint.h"
37 #include "addColor.h"
38
39 /*--------------------------------------------------------------------------*/
40 int setDefaultProperties(int _iFig, BOOL bDefaultAxes, BOOL _axesSize);
41 int getStackArgumentAsBoolean(void* _pvCtx, int* _piAddr);
42 /*--------------------------------------------------------------------------*/
43 int sci_figure(char * fname, unsigned long fname_len)
44 {
45     SciErr sciErr;
46     int* piAddr = NULL;
47     int iFig = 0;
48     int iRhs = nbInputArgument(pvApiCtx);
49     int iId = 0;
50     int iPos = 0;
51     int i = 0;
52     int iNewId = -1;
53     int iAxes = 0;
54     int iPropertyOffset = 0;
55     BOOL bDoCreation = TRUE;
56     BOOL bVisible = TRUE; // Create a visible figure by default
57     BOOL bDockable = TRUE; // Create a dockable figure by default
58     BOOL bDefaultAxes = TRUE; // Create an Axes by default
59     double* figureSize = NULL;
60     double* axesSize = NULL;
61     double* position = NULL;
62     double val[4];
63     BOOL bMenuBar = TRUE;
64     BOOL bToolBar = TRUE;
65     BOOL bInfoBar = TRUE;
66     int iMenubarType = 1; // Create a 'figure' menubar by default
67     int iToolbarType = 1; // Create a 'figure' toolbar by default
68     double dblId = 0;
69     BOOL status = FALSE;
70
71     //figure(num) -> scf(num)
72     //figure() -> scf()
73
74     //figure(x, "...", ...)
75
76     // figure()
77     if (iRhs == 0) // Auto ID
78     {
79         iFig = createNewFigureWithAxes();
80         iAxes = setDefaultProperties(iFig, TRUE, TRUE);
81         createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig));
82         AssignOutputVariable(pvApiCtx, 1) = iRhs + 1;
83         ReturnArguments(pvApiCtx);
84         return 0;
85     }
86
87     if (iRhs == 1)
88     {
89         //figure(x);
90         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
91         if (sciErr.iErr)
92         {
93             printError(&sciErr, 0);
94             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
95             return 0;
96         }
97
98         if (isVarMatrixType(pvApiCtx, piAddr) == 0)
99         {
100             Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 1);
101             return 0;
102         }
103
104         if (getScalarDouble(pvApiCtx, piAddr, &dblId))
105         {
106             Scierror(999, _("%s: No more memory.\n"), fname);
107             return 0;
108         }
109
110         iId = (int)(dblId + 0.5); //avoid 1.999 -> 1
111
112         //get current fig from id
113         iFig = getFigureFromIndex(iId);
114         if (iFig == 0) // Figure does not exists, create a new one
115         {
116             iFig = createNewFigureWithAxes();
117             setGraphicObjectProperty(iFig, __GO_ID__, &iId, jni_int,  1);
118             iAxes = setDefaultProperties(iFig, TRUE, TRUE);
119         }
120
121         createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig));
122         AssignOutputVariable(pvApiCtx, 1) = iRhs + 1;
123         ReturnArguments(pvApiCtx);
124         return 0;
125     }
126
127     // Prepare property analysis
128     if (iRhs % 2 == 0)
129     {
130         //get highest value of winsid to create the new windows @ + 1
131         iNewId = getValidDefaultFigureId();
132         iPos = 0;
133     }
134     else
135     {
136         iPos = 1;
137         //figure(x, ...);
138         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
139         if (sciErr.iErr)
140         {
141             printError(&sciErr, 0);
142             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
143             return 0;
144         }
145
146         if (isVarMatrixType(pvApiCtx, piAddr) == 0)
147         {
148             Scierror(999, _("%s: Wrong type for input argument #%d: An integer value expected.\n"), fname, 1);
149             return 0;
150         }
151
152         if (getScalarDouble(pvApiCtx, piAddr, &dblId))
153         {
154             Scierror(999, _("%s: No more memory.\n"), fname);
155             return 0;
156         }
157
158         iNewId = (int)(dblId + 0.5); //avoid 1.999 -> 1
159         //get current fig from id
160         iFig = getFigureFromIndex(iId);
161         if (iFig != 0) // Figure already exists
162         {
163             bDoCreation = FALSE;
164         }
165     }
166
167     if (bDoCreation)
168     {
169         int* piAddrProp = NULL;
170         char* pstProName = NULL;
171         int* piAddrData = NULL;
172         for (i = iPos + 1 ; i <= iRhs ; i += 2)
173         {
174             //get property name
175             sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrProp);
176             if (sciErr.iErr)
177             {
178                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
179                 return 1;
180             }
181
182             if (getAllocatedSingleString(pvApiCtx, piAddrProp, &pstProName))
183             {
184                 Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i);
185                 return 1;
186             }
187
188             if (stricmp(pstProName, "dockable") != 0 &&
189                     stricmp(pstProName, "toolbar") != 0 &&
190                     stricmp(pstProName, "menubar") != 0 &&
191                     stricmp(pstProName, "default_axes") != 0 &&
192                     stricmp(pstProName, "visible") != 0 &&
193                     stricmp(pstProName, "figure_size") != 0 &&
194                     stricmp(pstProName, "axes_size") != 0 &&
195                     stricmp(pstProName, "position") != 0 &&
196                     stricmp(pstProName, "menubar_visible") != 0 &&
197                     stricmp(pstProName, "toolbar_visible") != 0 &&
198                     stricmp(pstProName, "infobar_visible") != 0)
199             {
200                 freeAllocatedSingleString(pstProName);
201                 continue;
202             }
203
204             //get address of value on stack
205             sciErr = getVarAddressFromPosition(pvApiCtx, i + 1, &piAddrData);
206             if (sciErr.iErr)
207             {
208                 Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i + 1);
209                 return 1;
210             }
211
212             //check property value to compatibility
213             if (stricmp(pstProName, "dockable") == 0)
214             {
215                 bDockable = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
216                 if (bDockable == -1)
217                 {
218                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "dockable", "on", "off");
219                     freeAllocatedSingleString(pstProName);
220                     return 1;
221                 }
222             }
223             else if (stricmp(pstProName, "toolbar") == 0)
224             {
225                 char* pstVal = NULL;
226                 if (isStringType(pvApiCtx, piAddrData) == FALSE || isScalar(pvApiCtx, piAddrData) == FALSE)
227                 {
228                     Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i);
229                     freeAllocatedSingleString(pstProName);
230                 }
231
232                 getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal);
233
234                 if (stricmp(pstVal, "none") == 0)
235                 {
236                     iToolbarType = 0;
237                 }
238                 else if (stricmp(pstVal, "figure") == 0)
239                 {
240                     iToolbarType = 1;
241                 }
242                 else
243                 {
244                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "toolbar", "none", "figure");
245                     freeAllocatedSingleString(pstProName);
246                     freeAllocatedSingleString(pstVal);
247                     return 1;
248                 }
249
250                 freeAllocatedSingleString(pstVal);
251             }
252             else if (stricmp(pstProName, "menubar") == 0)
253             {
254                 char* pstVal = NULL;
255                 if (isStringType(pvApiCtx, piAddrData) == FALSE || isScalar(pvApiCtx, piAddrData) == FALSE)
256                 {
257                     Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i + 1);
258                     freeAllocatedSingleString(pstProName);
259                     return 1;
260                 }
261
262                 getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal);
263
264                 if (stricmp(pstVal, "none") == 0)
265                 {
266                     iMenubarType = 0;
267                 }
268                 else if (stricmp(pstVal, "figure") == 0)
269                 {
270                     iMenubarType = 1;
271                 }
272                 else
273                 {
274                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "menubar", "none", "figure");
275                     freeAllocatedSingleString(pstProName);
276                     freeAllocatedSingleString(pstVal);
277                     return 1;
278                 }
279
280                 freeAllocatedSingleString(pstVal);
281             }
282             else if (stricmp(pstProName, "default_axes") == 0)
283             {
284                 bDefaultAxes = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
285                 if (bDefaultAxes == -1)
286                 {
287                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "default_axes", "on", "off");
288                     freeAllocatedSingleString(pstProName);
289                     return 1;
290                 }
291             }
292             else if (stricmp(pstProName, "visible") == 0)
293             {
294                 bVisible = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
295                 if (bVisible == -1)
296                 {
297                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "visible", "on", "off");
298                     freeAllocatedSingleString(pstProName);
299                     return 1;
300                 }
301             }
302             else if (stricmp(pstProName, "figure_size") == 0)
303             {
304                 int iRows = 0;
305                 int iCols = 0;
306                 if (isDoubleType(pvApiCtx, piAddrData) == FALSE)
307                 {
308                     Scierror(999, _("%s: Wrong type for input argument #%d: A double vector expected.\n"), fname, i + 1);
309                     return 1;
310                 }
311
312                 getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &figureSize);
313                 if (iRows * iCols != 2)
314                 {
315                     Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "figure_size", 2);
316                     return 1;
317                 }
318             }
319             else if (stricmp(pstProName, "axes_size") == 0)
320             {
321                 int iRows = 0;
322                 int iCols = 0;
323                 if (isDoubleType(pvApiCtx, piAddrData) == FALSE)
324                 {
325                     Scierror(999, _("%s: Wrong type for input argument #%d: A double vector expected.\n"), fname, i + 1);
326                     return 1;
327                 }
328
329                 getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &axesSize);
330                 if (iRows * iCols != 2)
331                 {
332                     Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "axes_size", 2);
333                     return 1;
334                 }
335             }
336             else if (stricmp(pstProName, "position") == 0)
337             {
338                 int iRows = 0;
339                 int iCols = 0;
340                 double* pdbl = NULL;
341                 if (isDoubleType(pvApiCtx, piAddrData))
342                 {
343                     getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, &pdbl);
344                     if (iRows * iCols != 4)
345                     {
346                         Scierror(999, _("Wrong size for '%s' property: %d elements expected.\n"), "position", 4);
347                         return 1;
348                     }
349
350                     position = pdbl;
351                     axesSize = (pdbl + 2);
352                 }
353                 else if (isStringType(pvApiCtx, piAddrData) && isScalar(pvApiCtx, piAddrData))
354                 {
355                     char* pstVal = NULL;
356                     int iVal = 0;
357
358                     getAllocatedSingleString(pvApiCtx, piAddrData, &pstVal);
359
360                     iVal = sscanf(pstVal, "%lf|%lf|%lf|%lf", &val[0], &val[1], &val[2], &val[3]);
361                     freeAllocatedSingleString(pstVal);
362                     if (iVal != 4)
363                     {
364                         Scierror(999, _("Wrong value for '%s' property: A string or a 1 x %d real row vector expected.\n"), "position", 4);
365                         return 1;
366                     }
367
368                     position = val;
369                     axesSize = (val + 2);
370                 }
371                 else
372                 {
373                     Scierror(999, _("Wrong value for '%s' property: A string or a 1 x %d real row vector expected.\n"), "position", 4);
374                     return 1;
375                 }
376             }
377             else if (stricmp(pstProName, "menubar_visible") == 0)
378             {
379                 bMenuBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
380                 if (bMenuBar == -1)
381                 {
382                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "menubar_visible", "on", "off");
383                     freeAllocatedSingleString(pstProName);
384                     return 1;
385                 }
386             }
387             else if (stricmp(pstProName, "toolbar_visible") == 0)
388             {
389                 bToolBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
390                 if (bToolBar == -1)
391                 {
392                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "toolbar_visible", "on", "off");
393                     freeAllocatedSingleString(pstProName);
394                     return 1;
395                 }
396             }
397             else if (stricmp(pstProName, "infobar_visible") == 0)
398             {
399                 bInfoBar = getStackArgumentAsBoolean(pvApiCtx, piAddrData);
400                 if (bInfoBar == -1)
401                 {
402                     Scierror(999, _("Wrong value for '%s' property: '%s' or '%s' expected."), "infobar_visible", "on", "off");
403                     freeAllocatedSingleString(pstProName);
404                     return 1;
405                 }
406             }
407
408         }
409
410         iFig = createFigure(bDockable, iMenubarType, iToolbarType, bDefaultAxes, bVisible, figureSize, axesSize, position, bMenuBar, bToolBar, bInfoBar);
411         setGraphicObjectProperty(iFig, __GO_ID__, &iNewId, jni_int, 1);
412         iAxes = setDefaultProperties(iFig, bDefaultAxes, figureSize || axesSize ? FALSE : TRUE);
413     }
414
415     //set(iFig, iPos, iPos + 1)
416     for (i = iPos + 1 ; i <= iRhs ; i += 2)
417     {
418         int isMatrixOfString = 0;
419         int* piAddrProp = NULL;
420         char* pstProName = NULL;
421         int* piAddrData = NULL;
422         int iRows = 0;
423         int iCols = 0;
424         void* _pvData = NULL;
425         int iType = 0;
426
427         //get property name
428         sciErr = getVarAddressFromPosition(pvApiCtx, i, &piAddrProp);
429         if (sciErr.iErr)
430         {
431             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i);
432             return 1;
433         }
434
435         if (getAllocatedSingleString(pvApiCtx, piAddrProp, &pstProName))
436         {
437             Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, i);
438             return 1;
439         }
440
441         if (bDoCreation && (
442                     stricmp(pstProName, "dockable") == 0 ||
443                     stricmp(pstProName, "toolbar") == 0 ||
444                     stricmp(pstProName, "menubar") == 0 ||
445                     stricmp(pstProName, "default_axes") == 0 ||
446                     stricmp(pstProName, "visible") == 0 ||
447                     stricmp(pstProName, "figure_size") == 0 ||
448                     stricmp(pstProName, "axes_size") == 0 ||
449                     stricmp(pstProName, "position") == 0 ||
450                     stricmp(pstProName, "menubar_visible") == 0 ||
451                     stricmp(pstProName, "toolbar_visible") == 0 ||
452                     stricmp(pstProName, "infobar_visible") == 0))
453         {
454             // Already set creating new figure
455             // but let the set_ function fail if figure already exists
456             continue;
457         }
458
459         //get address of value on stack
460         sciErr = getVarAddressFromPosition(pvApiCtx, i + 1, &piAddrData);
461         if (sciErr.iErr)
462         {
463             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, i + 1);
464             return 1;
465         }
466
467         getVarType(pvApiCtx, piAddrData, &iType);
468
469         if ((strcmp(pstProName, "user_data") == 0) || (stricmp(pstProName, "userdata") == 0))
470         {
471             /* in this case set_user_data_property
472              * directly uses the  third position in the stack
473              * to get the variable which is to be set in
474              * the user_data property (any data type is allowed) S. Steer */
475             _pvData = (void*)piAddrData;         /*position in the stack */
476             iRows = -1;   /*unused */
477             iCols = -1;   /*unused */
478             iType = -1;
479         }
480         else
481         {
482             switch (iType)
483             {
484                 case sci_matrix :
485                     getMatrixOfDouble(pvApiCtx, piAddrData, &iRows, &iCols, (double**)&_pvData);
486                     break;
487                 case sci_boolean :
488                     getMatrixOfBoolean(pvApiCtx, piAddrData, &iRows, &iCols, (int**)&_pvData);
489                     break;
490                 case sci_handles :
491                     getMatrixOfHandle(pvApiCtx, piAddrData, &iRows, &iCols, (long long**)&_pvData);
492                     break;
493                 case sci_strings :
494                     if (   strcmp(pstProName, "tics_labels") != 0 && strcmp(pstProName, "auto_ticks") != 0 &&
495                             strcmp(pstProName, "axes_visible") != 0 && strcmp(pstProName, "axes_reverse") != 0 &&
496                             strcmp(pstProName, "text") != 0 && stricmp(pstProName, "string") != 0 &&
497                             stricmp(pstProName, "tooltipstring") != 0) /* Added for uicontrols */
498                     {
499                         if (getAllocatedSingleString(pvApiCtx, piAddrData, (char**)&_pvData))
500                         {
501                             Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, 3);
502                             return 1;
503                         }
504                         iRows = (int)strlen((char*)_pvData);
505                         iCols = 1;
506                     }
507                     else
508                     {
509                         isMatrixOfString = 1;
510                         getAllocatedMatrixOfString(pvApiCtx, piAddrData, &iRows, &iCols, (char***)&_pvData);
511                     }
512                     break;
513                 case sci_list :
514                     iCols = 1;
515                     getListItemNumber(pvApiCtx, piAddrData, &iRows);
516                     _pvData = (void*)piAddrData;         /* In this case l3 is the list position in stack */
517                     break;
518                 default :
519                     _pvData = (void*)piAddrData;         /* In this case l3 is the list position in stack */
520                     break;
521             }
522         }
523
524         callSetProperty(pvApiCtx, iFig, _pvData, iType, iRows, iCols, pstProName);
525
526         // If backgroundcolor is set :
527         // * add it to colormap => performed by callSetProperty
528         // * set background to index => performed by callSetProperty
529         // * copy value into axes background property
530         if (stricmp(pstProName, "backgroundcolor") == 0 && iAxes > 0)
531         {
532             int iBackground = 0;
533             int *piBackground = &iBackground;
534
535             getGraphicObjectProperty(iFig, __GO_BACKGROUND__, jni_int, (void **)&piBackground);
536             setGraphicObjectProperty(iAxes, __GO_BACKGROUND__, piBackground, jni_int, 1);
537         }
538
539         if (iType == sci_strings)
540         {
541             //free allacted data
542             if (isMatrixOfString == 1)
543             {
544                 freeAllocatedMatrixOfString(iRows, iCols, (char**)_pvData);
545             }
546             else
547             {
548                 freeAllocatedSingleString((char*)_pvData);
549             }
550         }
551     }
552
553     //return new created fig
554     createScalarHandle(pvApiCtx, iRhs + 1, getHandle(iFig));
555     AssignOutputVariable(pvApiCtx, 1) = iRhs + 1;
556     ReturnArguments(pvApiCtx);
557     return 0;
558 }
559 /*--------------------------------------------------------------------------*/
560 int getStackArgumentAsBoolean(void* _pvCtx, int* _piAddr)
561 {
562     if (isScalar(_pvCtx, _piAddr))
563     {
564         if (isDoubleType(_pvCtx, _piAddr))
565         {
566             double dbl = 0;
567             getScalarDouble(_pvCtx, _piAddr, &dbl);
568             return ((int)dbl == 0 ? FALSE : TRUE);
569         }
570         else if (isBooleanType(_pvCtx, _piAddr))
571         {
572             int i = 0;
573             getScalarBoolean(_pvCtx, _piAddr, &i);
574             return (i == 0 ? FALSE : TRUE);
575         }
576         else if (isStringType(_pvCtx, _piAddr))
577         {
578             int ret = 0;
579             char* pst = NULL;
580             getAllocatedSingleString(_pvCtx, _piAddr, &pst);
581
582             if (stricmp(pst, "on") == 0)
583             {
584                 ret = TRUE;
585             }
586
587             freeAllocatedSingleString(pst);
588
589             return ret;
590         }
591     }
592     return -1;
593 }
594 /*--------------------------------------------------------------------------*/
595 int setDefaultProperties(int _iFig, BOOL _bDefaultAxes, BOOL _axesSize)
596 {
597     //get figure axes
598     int iAxes = -1;
599     int iDrawing = 0;
600     int iColorIndex = 0;
601     int iFilled = 0;
602     int iAxesVisible = 0;
603     int* piAxesSize = NULL;
604     double pdblNewColor[COLOR_COMPONENT] = {0.8, 0.8, 0.8};
605
606     setGraphicObjectProperty(_iFig, __GO_IMMEDIATE_DRAWING__, &iDrawing, jni_bool, 1);
607
608     iColorIndex = addColor(_iFig, pdblNewColor);
609
610     setGraphicObjectProperty(_iFig, __GO_BACKGROUND__, &iColorIndex, jni_int, 1);
611     if (_bDefaultAxes)
612     {
613         iAxes = getOrCreateDefaultSubwin();
614         //set background in figure and axes to new ( or existting ) color
615         setGraphicObjectProperty(iAxes, __GO_BACKGROUND__, &iColorIndex, jni_int, 1);
616
617         //a.filled = "off"
618         setGraphicObjectProperty(iAxes, __GO_FILLED__, &iFilled, jni_bool, 1);
619
620         //a.axes_visible = "off"
621         setGraphicObjectProperty(iAxes, __GO_X_AXIS_VISIBLE__, &iAxesVisible, jni_bool, 1);
622         setGraphicObjectProperty(iAxes, __GO_Y_AXIS_VISIBLE__, &iAxesVisible, jni_bool, 1);
623         setGraphicObjectProperty(iAxes, __GO_Z_AXIS_VISIBLE__, &iAxesVisible, jni_bool, 1);
624     }
625
626     // axes_size
627     if (_axesSize)
628     {
629         getGraphicObjectProperty(getFigureModel(), __GO_AXES_SIZE__, jni_int_vector, (void **)&piAxesSize);
630         setGraphicObjectProperty(_iFig, __GO_AXES_SIZE__, piAxesSize, jni_int_vector, 2);
631     }
632
633     //f.immediate_drawing = "on"
634     iDrawing = 1;
635     setGraphicObjectProperty(_iFig, __GO_IMMEDIATE_DRAWING__, &iDrawing, jni_bool, 1);
636
637     return iAxes;
638 }
639 /*--------------------------------------------------------------------------*/