scilab/modules/scicos_blocks/src/c/cfscope.c

   1 /*
   2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  *  Copyright (C) 2011 - Scilab Enterprises - Clement DAVID
   4  *
   5  *  This file must be used under the terms of the CeCILL.
   6  *  This source file is licensed as described in the file COPYING, which
   7  *  you should have received as part of this distribution.  The terms
   8  *  are also available at
   9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12
  13 #include <string.h>
  14
  15 #include "dynlib_scicos_blocks.h"
  16 #include "scoUtils.h"
  17
  18 #include "MALLOC.h"
  19 #include "elementary_functions.h"
  20
  21 #include "getGraphicObjectProperty.h"
  22 #include "setGraphicObjectProperty.h"
  23 #include "graphicObjectProperties.h"
  24 #include "createGraphicObject.h"
  25
  26 #include "CurrentFigure.h"
  27 #include "CurrentObject.h"
  28
  29 #include "scicos_block4.h"
  30 #include "scicos.h"
  31
  32 #include "localization.h"
  33 #ifdef _MSC_VER
  34 #include "strdup_windows.h"
  35 #endif
  36
  37 #include "FigureList.h"
  38 #include "BuildObjects.h"
  39 #include "AxesModel.h"
  40
  41 /*****************************************************************************
  42  * Internal container structure
  43  ****************************************************************************/
  44
  45 /**
  46  * Container structure
  47  */
  48 typedef struct
  49 {
  50     struct
  51     {
  52         int numberOfPoints;
  53         int maxNumberOfPoints;
  54         double *time;
  55         double ***data;
  56     } internal;
  57
  58     struct
  59     {
  60         int periodCounter;
  61
  62         char const* cachedFigureUID;
  63         char *cachedAxeUID;
  64         char **cachedPolylinesUIDs;
  65     } scope;
  66 } sco_data;
  67
  68 /**
  69  * Get (and allocate on demand) the internal data used on this scope
  70  * \param block the block
  71  * \return the scope data
  72  */
  73 static sco_data *getScoData(scicos_block * block);
  74
  75 /**
  76  * Release any internal data
  77  *
  78  * \param block the block
  79  */
  80 static void freeScoData(scicos_block * block);
  81
  82 /**
  83  * Append the data to the current data
  84  *
  85  * \param block the block
  86  * \param input the input (0-indexed)
  87  * \param t the current time
  88  * \param data the data to append
  89  */
  90 static void appendData(scicos_block * block, int input, double t, double *data);
  91
  92 /**
  93  * Push the block data to the polyline
  94  *
  95  * \param block the block
  96  * \param input the selected input
  97  * \param row the selected row
  98  * \param pPolylineUID the polyline uid
  99  *
 100  */
 101 static BOOL pushData(scicos_block * block, int input, int row);
 102
 103 /*****************************************************************************
 104  * Graphics utils
 105  ****************************************************************************/
 106
 107 /**
 108  * Get (and allocate on demand) the figure associated with the block
 109  * \param block the block
 110  * \return a valid figure UID or NULL on error
 111  */
 112 static char const* getFigure(scicos_block * block);
 113
 114 /**
 115  * Get (and allocate on demand) the axe associated with the input
 116  *
 117  * \param pFigureUID the parent figure UID
 118  * \param block the block
 119  * \param input the current input index (0-indexed)
 120  * \return a valid axe UID or NULL on error
 121  */
 122 static char *getAxe(char const* pFigureUID, scicos_block * block, int input);
 123
 124 /**
 125  * Get (and allocate on demand) the polyline associated with the row
 126  *
 127  * \param pAxeUID the parent axe UID
 128  * \param block the block
 129  * \param row the current row index (0-indexed)
 130  * \return a valid polyline UID or NULL on error
 131  */
 132 static char *getPolyline(char *pAxeUID, scicos_block * block, int row);
 133
 134 /**
 135  * Set the polylines buffer size
 136  *
 137  * \param block the block
 138  * \param input the input port index
 139  * \param maxNumberOfPoints the size of the buffer
 140  */
 141 static BOOL setPolylinesBuffers(scicos_block * block, int input, int maxNumberOfPoints);
 142
 143 /**
 144  * Set the polylines bounds
 145  *
 146  * \param block the block
 147  * \param input the input port index
 148  * \param periodCounter number of past periods since startup
 149  */
 150 static BOOL setPolylinesBounds(scicos_block * block, int input, int periodCounter);
 151
 152 /*****************************************************************************
 153  * Simulation function
 154  ****************************************************************************/
 155
 156 /** \fn void cfscope(scicos_block * block,int flag)
 157     \brief the computational function
 158     \param block A pointer to a scicos_block
 159     \param flag An int which indicates the state of the block (init, update, ending)
 160 */
 161 SCICOS_BLOCKS_IMPEXP void cfscope(scicos_block * block, scicos_flag flag)
 162 {
 163     char const* pFigureUID;
 164
 165     double t;
 166     int links_count;
 167     int *links_indexes;
 168     double *u;
 169     sco_data *sco;
 170
 171     int i;
 172     BOOL result;
 173
 174     switch (flag)
 175     {
 176
 177         case Initialization:
 178             sco = getScoData(block);
 179             if (sco == NULL)
 180             {
 181                 set_block_error(-5);
 182                 break;
 183             }
 184             pFigureUID = getFigure(block);
 185             if (pFigureUID == NULL)
 186             {
 187                 // allocation error
 188                 set_block_error(-5);
 189                 break;
 190             }
 191             break;
 192
 193         case StateUpdate:
 194             pFigureUID = getFigure(block);
 195             if (pFigureUID == NULL)
 196             {
 197                 // allocation error
 198                 set_block_error(-5);
 199                 return;
 200             }
 201
 202             t = get_scicos_time();
 203
 204             /*
 205              * Get the data through the scicos_import structure
 206              */
 207             links_count = block->ipar[15];
 208             links_indexes = &(block->ipar[16]);
 209
 210             u = (double *) CALLOC(links_count, sizeof(double));
 211             if (u == NULL)
 212             {
 213                 Coserror("%s: unable to allocate some data.", "cfscope");
 214                 return;
 215             }
 216             C2F(getouttb) (&links_count, links_indexes, u);
 217
 218             /*
 219              * Append the data (copy) then free
 220              */
 221             appendData(block, 0, t, u);
 222             FREE(u);
 223
 224             for (i = 0; i < links_count; i++)
 225             {
 226                 result = pushData(block, 0, i);
 227                 if (result == FALSE)
 228                 {
 229                     Coserror("%s: unable to push some data.", "cfscope");
 230                     break;
 231                 }
 232             }
 233             break;
 234
 235         case Ending:
 236             freeScoData(block);
 237             break;
 238
 239         default:
 240             break;
 241     }
 242 }
 243
 244 /*-------------------------------------------------------------------------*/
 245
 246 /*****************************************************************************
 247  *
 248  * Container management
 249  *
 250  ****************************************************************************/
 251
 252 static sco_data *getScoData(scicos_block * block)
 253 {
 254     sco_data *sco = (sco_data *) * (block->work);
 255     int links_count = block->ipar[15];
 256     int i, j, k, l;
 257
 258     if (sco == NULL)
 259     {
 260         /*
 261          * Data allocation
 262          */
 263
 264         sco = (sco_data *) MALLOC(sizeof(sco_data));
 265         if (sco == NULL)
 266             goto error_handler_sco;
 267
 268         sco->internal.numberOfPoints = 0;
 269         sco->internal.maxNumberOfPoints = block->ipar[2];
 270
 271         sco->internal.data = (double ***)CALLOC(1, sizeof(double **));
 272         if (sco->internal.data == NULL)
 273             goto error_handler_data;
 274
 275         for (i = 0; i < 1; i++)
 276         {
 277             sco->internal.data[i] = (double **)CALLOC(links_count, sizeof(double *));
 278             if (sco->internal.data[i] == NULL)
 279                 goto error_handler_data_i;
 280         }
 281         for (i = 0; i < 1; i++)
 282         {
 283             for (j = 0; j < links_count; j++)
 284             {
 285                 sco->internal.data[i][j] = (double *)CALLOC(block->ipar[2], sizeof(double));
 286
 287                 if (sco->internal.data[i][j] == NULL)
 288                     goto error_handler_data_ij;
 289             }
 290         }
 291
 292         sco->internal.time = (double *)CALLOC(block->ipar[2], sizeof(double));
 293         if (sco->internal.time == NULL)
 294         {
 295             goto error_handler_time;
 296         }
 297
 298         sco->scope.periodCounter = 0;
 299         sco->scope.cachedFigureUID = NULL;
 300         sco->scope.cachedAxeUID = NULL;
 301         sco->scope.cachedPolylinesUIDs = (char **)CALLOC(links_count, sizeof(char *));
 302
 303         *(block->work) = sco;
 304     }
 305
 306     return sco;
 307
 308     /*
 309      * Error management (out of normal flow)
 310      */
 311
 312 error_handler_time:
 313 error_handler_data_ij:
 314     for (k = 0; k < i; k++)
 315     {
 316         for (l = 0; l < j; l++)
 317         {
 318             FREE(sco->internal.data[k][l]);
 319         }
 320     }
 321     i = 1;
 322 error_handler_data_i:
 323     for (j = 0; j < i; j++)
 324     {
 325         FREE(sco->internal.data[i]);
 326     }
 327     FREE(sco->internal.data);
 328 error_handler_data:
 329     FREE(sco);
 330 error_handler_sco:
 331     // allocation error
 332     set_block_error(-5);
 333     return NULL;
 334 }
 335
 336 static void freeScoData(scicos_block * block)
 337 {
 338     sco_data *sco = (sco_data *) * (block->work);
 339     int links_count = block->ipar[15];
 340     int i, j;
 341
 342     if (sco != NULL)
 343     {
 344         for (i = 0; i < 1; i++)
 345         {
 346             for (j = 0; j < links_count; j++)
 347             {
 348                 FREE(sco->internal.data[i][j]);
 349             }
 350             FREE(sco->internal.data[i]);
 351         }
 352
 353         FREE(sco->internal.data);
 354         FREE(sco->internal.time);
 355
 356         for (i = 0; i < links_count; i++)
 357         {
 358             FREE(sco->scope.cachedPolylinesUIDs[i]);
 359         }
 360         FREE(sco->scope.cachedAxeUID);
 361
 362         FREE(sco);
 363         *(block->work) = NULL;
 364     }
 365 }
 366
 367 static sco_data *reallocScoData(scicos_block * block, int numberOfPoints)
 368 {
 369     sco_data *sco = (sco_data *) * (block->work);
 370     int i, j;
 371
 372     double *ptr;
 373     int setLen;
 374     int links_count = block->ipar[15];
 375     int previousNumberOfPoints = sco->internal.maxNumberOfPoints;
 376
 377     for (i = 0; i < 1; i++)
 378     {
 379         for (j = 0; j < links_count; j++)
 380         {
 381             ptr = (double *)REALLOC(sco->internal.data[i][j], numberOfPoints * sizeof(double));
 382             if (ptr == NULL)
 383                 goto error_handler;
 384
 385             for (setLen = numberOfPoints - previousNumberOfPoints - 1; setLen >= 0; setLen--)
 386                 ptr[previousNumberOfPoints + setLen] = ptr[previousNumberOfPoints - 1];
 387             sco->internal.data[i][j] = ptr;
 388         }
 389     }
 390
 391     ptr = (double *)REALLOC(sco->internal.time, numberOfPoints * sizeof(double));
 392     if (ptr == NULL)
 393         goto error_handler;
 394
 395     for (setLen = numberOfPoints - previousNumberOfPoints - 1; setLen >= 0; setLen--)
 396         ptr[previousNumberOfPoints + setLen] = ptr[previousNumberOfPoints - 1];
 397     sco->internal.time = ptr;
 398
 399     sco->internal.maxNumberOfPoints = numberOfPoints;
 400     return sco;
 401
 402 error_handler:
 403     freeScoData(block);
 404     // allocation error
 405     set_block_error(-5);
 406     return NULL;
 407 }
 408
 409 static void appendData(scicos_block * block, int input, double t, double *data)
 410 {
 411     int i;
 412
 413     sco_data *sco = (sco_data *) * (block->work);
 414     int maxNumberOfPoints = sco->internal.maxNumberOfPoints;
 415     int numberOfPoints = sco->internal.numberOfPoints;
 416     int links_count = block->ipar[15];
 417
 418     /*
 419      * Handle the case where the t is greater than the data_bounds
 420      */
 421     if (t > ((sco->scope.periodCounter + 1) * block->rpar[3]))
 422     {
 423         sco->scope.periodCounter++;
 424
 425         numberOfPoints = 0;
 426         sco->internal.numberOfPoints = 0;
 427         if (setPolylinesBounds(block, input, sco->scope.periodCounter) == FALSE)
 428         {
 429             set_block_error(-5);
 430             freeScoData(block);
 431             sco = NULL;
 432         }
 433     }
 434
 435     /*
 436      * Handle the case where the scope has more points than maxNumberOfPoints
 437      */
 438     if (sco != NULL && numberOfPoints >= maxNumberOfPoints)
 439     {
 440         // on a full scope, re-alloc
 441         maxNumberOfPoints = maxNumberOfPoints + block->ipar[2];
 442         sco = reallocScoData(block, maxNumberOfPoints);
 443
 444         // reconfigure related graphic objects
 445         if (setPolylinesBuffers(block, input, maxNumberOfPoints) == FALSE)
 446         {
 447             set_block_error(-5);
 448             freeScoData(block);
 449             sco = NULL;
 450         }
 451     }
 452
 453     /*
 454      * Update data
 455      */
 456     if (sco != NULL)
 457     {
 458         int setLen;
 459
 460         for (i = 0; i < links_count; i++)
 461         {
 462             for (setLen = maxNumberOfPoints - numberOfPoints - 1; setLen >= 0; setLen--)
 463                 sco->internal.data[input][i][numberOfPoints + setLen] = data[i];
 464         }
 465
 466         for (setLen = maxNumberOfPoints - numberOfPoints - 1; setLen >= 0; setLen--)
 467             sco->internal.time[numberOfPoints + setLen] = t;
 468
 469         sco->internal.numberOfPoints++;
 470     }
 471 }
 472
 473 static BOOL pushData(scicos_block * block, int input, int row)
 474 {
 475     char const* pFigureUID;
 476     char *pAxeUID;
 477     char *pPolylineUID;
 478
 479     double *data;
 480     sco_data *sco;
 481
 482     BOOL result = TRUE;
 483
 484     pFigureUID = getFigure(block);
 485     pAxeUID = getAxe(pFigureUID, block, input);
 486     pPolylineUID = getPolyline(pAxeUID, block, row);
 487
 488     sco = getScoData(block);
 489     if (sco == NULL)
 490         return FALSE;
 491
 492     // select the right input and row
 493     data = sco->internal.data[input][row];
 494
 495     result &= setGraphicObjectProperty(pPolylineUID, __GO_DATA_MODEL_X__, sco->internal.time, jni_double_vector, sco->internal.maxNumberOfPoints);
 496     result &= setGraphicObjectProperty(pPolylineUID, __GO_DATA_MODEL_Y__, data, jni_double_vector, sco->internal.maxNumberOfPoints);
 497
 498     return result;
 499 }
 500
 501 /*****************************************************************************
 502  *
 503  * Graphic utils
 504  *
 505  ****************************************************************************/
 506
 507 /**
 508  * Set properties on the figure.
 509  *
 510  * \param pFigureUID the figure uid
 511  * \param block the current block
 512  */
 513 static void setFigureSettings(char const* pFigureUID, scicos_block * block)
 514 {
 515     int *ipar = GetIparPtrs(block);
 516
 517     int win_pos[2];
 518     int win_dim[2];
 519
 520     win_pos[0] = ipar[11];
 521     win_pos[1] = ipar[12];
 522     win_dim[0] = ipar[13];
 523     win_dim[1] = ipar[14];
 524
 525     if (win_pos[0] > 0 && win_pos[1] > 0)
 526     {
 527         setGraphicObjectProperty(pFigureUID, __GO_POSITION__, &win_pos, jni_int_vector, 2);
 528     }
 529
 530     if (win_dim[0] > 0 && win_dim[1] > 0)
 531     {
 532         setGraphicObjectProperty(pFigureUID, __GO_SIZE__, &win_dim, jni_int_vector, 2);
 533     }
 534 };
 535
 536 /*****************************************************************************
 537  *
 538  * Graphic
 539  *
 540  ****************************************************************************/
 541
 542 static char const* getFigure(scicos_block * block)
 543 {
 544     signed int figNum;
 545     char const* pFigureUID = NULL;
 546     char *pAxe = NULL;
 547     int i__1 = 1;
 548     sco_data *sco = (sco_data *) * (block->work);
 549
 550     int i;
 551
 552     // assert the sco is not NULL
 553     if (sco == NULL)
 554     {
 555         return NULL;
 556     }
 557
 558     // fast path for an existing object
 559     if (sco->scope.cachedFigureUID != NULL)
 560     {
 561         return sco->scope.cachedFigureUID;
 562     }
 563
 564     figNum = block->ipar[0];
 565
 566     // with a negative id, use the block number indexed from a constant.
 567     if (figNum < 0)
 568     {
 569         figNum = 20000 + get_block_number();
 570     }
 571
 572     pFigureUID = getFigureFromIndex(figNum);
 573     // create on demand
 574     if (pFigureUID == NULL)
 575     {
 576         pFigureUID = createNewFigureWithAxes();
 577         setGraphicObjectProperty(pFigureUID, __GO_ID__, &figNum, jni_int, 1);
 578
 579         // the stored uid is a reference to the figure map, not to the current figure
 580         pFigureUID = getFigureFromIndex(figNum);
 581         sco->scope.cachedFigureUID = pFigureUID;
 582
 583         // set configured parameters
 584         setFigureSettings(pFigureUID, block);
 585
 586         // allocate the axes through the getter
 587         for (i = 0; i < 1; i++)
 588         {
 589             pAxe = getAxe(pFigureUID, block, i);
 590
 591             /*
 592              * Setup according to block settings
 593              */
 594             setLabel(pAxe, __GO_X_AXIS_LABEL__, "t");
 595             setLabel(pAxe, __GO_Y_AXIS_LABEL__, "y");
 596
 597             setGraphicObjectProperty(pAxe, __GO_X_AXIS_VISIBLE__, &i__1, jni_bool, 1);
 598             setGraphicObjectProperty(pAxe, __GO_Y_AXIS_VISIBLE__, &i__1, jni_bool, 1);
 599
 600             setPolylinesBounds(block, i, 0);
 601         }
 602     }
 603
 604     if (sco->scope.cachedFigureUID == NULL)
 605     {
 606         sco->scope.cachedFigureUID = pFigureUID;
 607     }
 608     return pFigureUID;
 609 }
 610
 611 static char *getAxe(char const* pFigureUID, scicos_block * block, int input)
 612 {
 613     char *pAxe;
 614     int i;
 615     sco_data *sco = (sco_data *) * (block->work);
 616     int links_count = block->ipar[15];
 617
 618     // assert the sco is not NULL
 619     if (sco == NULL)
 620     {
 621         return NULL;
 622     }
 623
 624     // fast path for an existing object
 625     if (sco->scope.cachedAxeUID != NULL)
 626     {
 627         return sco->scope.cachedAxeUID;
 628     }
 629
 630     pAxe = findChildWithKindAt(pFigureUID, __GO_AXES__, input);
 631
 632     /*
 633      * Allocate if necessary
 634      */
 635     if (pAxe == NULL)
 636     {
 637         cloneAxesModel(pFigureUID);
 638         pAxe = findChildWithKindAt(pFigureUID, __GO_AXES__, input);
 639     }
 640
 641     /*
 642      * Setup on first access
 643      */
 644     if (pAxe != NULL)
 645     {
 646         // allocate the polylines through the getter
 647         for (i = 0; i < links_count; i++)
 648         {
 649             getPolyline(pAxe, block, i);
 650         }
 651     }
 652
 653     /*
 654      * then cache with a local storage
 655      */
 656     if (pAxe != NULL && sco->scope.cachedAxeUID == NULL)
 657     {
 658         sco->scope.cachedAxeUID = strdup(pAxe);
 659         releaseGraphicObjectProperty(__GO_PARENT__, pAxe, jni_string, 1);
 660     }
 661     return sco->scope.cachedAxeUID;
 662 }
 663
 664 static char *getPolyline(char *pAxeUID, scicos_block * block, int row)
 665 {
 666     char *pPolyline;
 667     double d__0 = 0.0;
 668     BOOL b__true = TRUE;
 669
 670     int color;
 671
 672     sco_data *sco = (sco_data *) * (block->work);
 673
 674     // assert the sco is not NULL
 675     if (sco == NULL)
 676     {
 677         return NULL;
 678     }
 679
 680     // fast path for an existing object
 681     if (sco->scope.cachedPolylinesUIDs != NULL && sco->scope.cachedPolylinesUIDs[row] != NULL)
 682     {
 683         return sco->scope.cachedPolylinesUIDs[row];
 684     }
 685
 686     pPolyline = findChildWithKindAt(pAxeUID, __GO_POLYLINE__, row);
 687
 688     /*
 689      * Allocate if necessary
 690      */
 691     if (pPolyline == NULL)
 692     {
 693         pPolyline = createGraphicObject(__GO_POLYLINE__);
 694
 695         if (pPolyline != NULL)
 696         {
 697             createDataObject(pPolyline, __GO_POLYLINE__);
 698             setGraphicObjectRelationship(pAxeUID, pPolyline);
 699
 700         }
 701     }
 702
 703     /*
 704      * Setup on first access
 705      */
 706     if (pPolyline != NULL)
 707     {
 708
 709         /*
 710          * Default setup (will crash if removed)
 711          */
 712         {
 713             int polylineSize[2] = { 1, block->ipar[2] };
 714             setGraphicObjectProperty(pPolyline, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, polylineSize, jni_int_vector, 2);
 715         }
 716
 717         setGraphicObjectProperty(pPolyline, __GO_DATA_MODEL_X__, &d__0, jni_double_vector, 1);
 718         setGraphicObjectProperty(pPolyline, __GO_DATA_MODEL_Y__, &d__0, jni_double_vector, 1);
 719
 720         color = block->ipar[3 + row];
 721         if (color > 0)
 722         {
 723             setGraphicObjectProperty(pPolyline, __GO_LINE_MODE__, &b__true, jni_bool, 1);
 724             setGraphicObjectProperty(pPolyline, __GO_LINE_COLOR__, &color, jni_int, 1);
 725         }
 726         else
 727         {
 728             color = -color;
 729             setGraphicObjectProperty(pPolyline, __GO_MARK_MODE__, &b__true, jni_bool, 1);
 730             setGraphicObjectProperty(pPolyline, __GO_MARK_STYLE__, &color, jni_int, 1);
 731         }
 732
 733         {
 734             int iClipState = 1; //on
 735             setGraphicObjectProperty(pPolyline, __GO_CLIP_STATE__, &iClipState, jni_int, 1);
 736         }
 737     }
 738
 739     /*
 740      * then cache with local storage
 741      */
 742     if (pPolyline != NULL && sco->scope.cachedPolylinesUIDs != NULL && sco->scope.cachedPolylinesUIDs[row] == NULL)
 743     {
 744         sco->scope.cachedPolylinesUIDs[row] = strdup(pPolyline);
 745         releaseGraphicObjectProperty(__GO_PARENT__, pPolyline, jni_string, 1);
 746     }
 747     return sco->scope.cachedPolylinesUIDs[row];
 748 }
 749
 750 static BOOL setPolylinesBuffers(scicos_block * block, int input, int maxNumberOfPoints)
 751 {
 752     int i;
 753
 754     char const* pFigureUID;
 755     char *pAxeUID;
 756     char *pPolylineUID;
 757
 758     BOOL result = TRUE;
 759     int polylineSize[2] = { 1, maxNumberOfPoints };
 760     int links_count = block->ipar[15];
 761
 762     pFigureUID = getFigure(block);
 763     pAxeUID = getAxe(pFigureUID, block, input);
 764
 765     for (i = 0; i < links_count; i++)
 766     {
 767         pPolylineUID = getPolyline(pAxeUID, block, i);
 768         result &= setGraphicObjectProperty(pPolylineUID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, polylineSize, jni_int_vector, 2);
 769     }
 770
 771     return result;
 772 }
 773
 774 static BOOL setPolylinesBounds(scicos_block * block, int input, int periodCounter)
 775 {
 776     char const* pFigureUID;
 777     char *pAxeUID;
 778
 779     double dataBounds[6];
 780     double period = block->rpar[3];
 781
 782     dataBounds[0] = periodCounter * period; // xMin
 783     dataBounds[1] = (periodCounter + 1) * period;   // xMax
 784     dataBounds[2] = block->rpar[1]; // yMin
 785     dataBounds[3] = block->rpar[2]; // yMax
 786     dataBounds[4] = -1.0;       // zMin
 787     dataBounds[5] = 1.0;        // zMax
 788
 789     pFigureUID = getFigure(block);
 790     pAxeUID = getAxe(pFigureUID, block, input);
 791     return setGraphicObjectProperty(pAxeUID, __GO_DATA_BOUNDS__, dataBounds, jni_double_vector, 6);
 792 }