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