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