scilab/modules/gui/sci_gateway/c/sci_figure.c

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