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 exist, 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 /*--------------------------------------------------------------------------*/