scilab/modules/hdf5/src/cpp/handle_properties.cpp

   1 /*
   2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 * Copyright (C) 2015 - Scilab Enterprises - Antoine ELIAS
   4 *
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  *
   7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
   9  * This file was originally licensed under the terms of the CeCILL v2.1,
  10  * and continues to be available under such terms.
  11  * For more information, see the COPYING file which you should have received
  12  * along with this program.
  13 *
  14 */
  15
  16 #include "handle_properties.hxx"
  17 #include "double.hxx"
  18
  19 extern "C"
  20 {
  21 #include "h5_fileManagement.h"
  22 #include "h5_writeDataToFile.h"
  23 #include "h5_readDataFromFile.h"
  24 #include "h5_attributeConstants.h"
  25
  26 #include "setGraphicObjectProperty.h"
  27 #include "getGraphicObjectProperty.h"
  28 #include "graphicObjectProperties.h"
  29 #include "createGraphicObject.h"
  30 #include "FigureList.h"
  31 #include "CurrentFigure.h"
  32 #include "BuildObjects.h"
  33 #include "Matplot.h"
  34 #include "HandleManagement.h"
  35 }
  36
  37 extern types::InternalType* import_data(int dataset);
  38 extern int export_data(int parent, const std::string& name, types::InternalType* data);
  39
  40 static int getHandleInt(int dataset, const char* prop, int* val)
  41 {
  42     int node = 0;
  43     node = getDataSetIdFromName(dataset, prop);
  44     if (node < 0)
  45     {
  46         return -1;
  47     }
  48
  49     readInteger32Matrix(node, val);
  50     return 0;
  51 }
  52
  53 static int getHandleIntVector(int dataset, const char* prop, int* row, int* col, int** vals)
  54 {
  55     int node = 0;
  56     node = getDataSetIdFromName(dataset, prop);
  57     if (node < 0)
  58     {
  59         return -1;
  60     }
  61
  62     int complex = 0;
  63     int dims = 0;;
  64     int ret = getDatasetInfo(node, &complex, &dims, NULL);
  65     if (ret < 0)
  66     {
  67         closeDataSet(dataset);
  68         return -1;
  69     }
  70
  71
  72     std::vector<int> d(dims);
  73     int size = getDatasetInfo(node, &complex, &dims, d.data());
  74
  75     if (dims == 0 || size <= 0)
  76     {
  77         closeDataSet(node);
  78         return -1;
  79     }
  80
  81     *row = d[0];
  82     *col = d[1];
  83     *vals = new int[size];
  84     readInteger32Matrix(node, *vals);
  85     return 0;
  86 }
  87
  88 static int getHandleBool(int dataset, const char* prop, int* val)
  89 {
  90     int node = 0;
  91     node = getDataSetIdFromName(dataset, prop);
  92     if (node < 0)
  93     {
  94         return -1;
  95     }
  96
  97     readBooleanMatrix(node, val);
  98     return 0;
  99 }
 100
 101 static int getHandleBoolVector(int dataset, const char* prop, int* row, int* col, int** vals)
 102 {
 103     int node = 0;
 104     node = getDataSetIdFromName(dataset, prop);
 105     if (node < 0)
 106     {
 107         return -1;
 108     }
 109
 110     int complex = 0;
 111     int dims = 0;;
 112     int ret = getDatasetInfo(node, &complex, &dims, NULL);
 113     if (ret < 0)
 114     {
 115         closeDataSet(dataset);
 116         return -1;
 117     }
 118
 119
 120     std::vector<int> d(dims);
 121     int size = getDatasetInfo(node, &complex, &dims, d.data());
 122
 123     if (dims == 0 || size <= 0)
 124     {
 125         closeDataSet(node);
 126         return -1;
 127     }
 128
 129     *row = d[0];
 130     *col = d[1];
 131
 132     *vals = new int[size];
 133     readBooleanMatrix(node, *vals);
 134     return 0;
 135 }
 136
 137 static double getHandleDouble(int dataset, const char* prop, double* val)
 138 {
 139     int node = 0;
 140     node = getDataSetIdFromName(dataset, prop);
 141     if (node < 0)
 142     {
 143         return -1;
 144     }
 145
 146     readDoubleMatrix(node, val);
 147     return 0;
 148 }
 149
 150 static int getHandleDoubleVector(int dataset, const char* prop, int* row, int* col, double** vals)
 151 {
 152     int node = 0;
 153     node = getDataSetIdFromName(dataset, prop);
 154     if (node < 0)
 155     {
 156         return -1;
 157     }
 158
 159     int complex = 0;
 160     int dims = 0;;
 161     int ret = getDatasetInfo(node, &complex, &dims, NULL);
 162     if (ret < 0)
 163     {
 164         closeDataSet(dataset);
 165         return -1;
 166     }
 167
 168
 169     std::vector<int> d(dims);
 170     int size = getDatasetInfo(node, &complex, &dims, d.data());
 171
 172     if (dims == 0 || size <= 0)
 173     {
 174         closeDataSet(node);
 175         return -1;
 176     }
 177
 178     *row = d[0];
 179     *col = d[1];
 180
 181     *vals = new double[size];
 182     readDoubleMatrix(node, *vals);
 183     return 0;
 184 }
 185
 186 static int getHandleString(int dataset, const char* prop, char** val)
 187 {
 188     int node = 0;
 189     node = getDataSetIdFromName(dataset, prop);
 190     if (node < 0)
 191     {
 192         return -1;
 193     }
 194
 195     int complex = 0;
 196     int dims = 0;;
 197     int ret = getDatasetInfo(node, &complex, &dims, NULL);
 198     if (ret < 0)
 199     {
 200         closeDataSet(dataset);
 201         return -1;
 202     }
 203
 204
 205     std::vector<int> d(dims);
 206     int size = getDatasetInfo(node, &complex, &dims, d.data());
 207
 208     if (dims == 0 || size <= 0)
 209     {
 210         closeDataSet(node);
 211         return -1;
 212     }
 213
 214     readStringMatrix(node, val);
 215     return node;
 216 }
 217
 218 static int getHandleStringVector(int dataset, const char* prop, int* row, int* col, char*** vals)
 219 {
 220     int node = 0;
 221     node = getDataSetIdFromName(dataset, prop);
 222     if (node < 0)
 223     {
 224         return -1;
 225     }
 226
 227     int complex = 0;
 228     int dims = 0;;
 229     int ret = getDatasetInfo(node, &complex, &dims, NULL);
 230     if (ret < 0)
 231     {
 232         closeDataSet(dataset);
 233         return -1;
 234     }
 235
 236
 237     std::vector<int> d(dims);
 238     int size = getDatasetInfo(node, &complex, &dims, d.data());
 239
 240     if (dims == 0 || size <= 0)
 241     {
 242         closeDataSet(node);
 243         return -1;
 244     }
 245
 246     *row = d[0];
 247     *col = d[1];
 248
 249     *vals = new char*[size];
 250     readStringMatrix(node, *vals);
 251     return node;
 252 }
 253
 254 static int import_handle_generic(int dataset, int uid, int parent, const HandleProp& props, bool childrenFirst);
 255
 256 static void import_userdata(int dataset, int uid)
 257 {
 258     types::InternalType* ud = nullptr;
 259     int node = 0;
 260     node = getDataSetIdFromName(dataset, "userdata");
 261     if (node < 0)
 262     {
 263         //no user data ?
 264         //assign an empty matrix
 265         ud = types::Double::Empty();
 266     }
 267     else
 268     {
 269         ud = import_data(node);
 270     }
 271
 272     //increase ref before trying to delete old value to avoid double free
 273     ud->IncreaseRef();
 274
 275     //get previous value
 276     int size = 0;
 277     int *psize = &size;
 278     int *data = NULL;
 279
 280     getGraphicObjectProperty(uid, __GO_USER_DATA_SIZE__, jni_int, (void **)&psize);
 281     getGraphicObjectProperty(uid, __GO_USER_DATA__, jni_int_vector, (void **)&data);
 282
 283     if (size != 0)
 284     {
 285         types::InternalType* previous = nullptr;
 286         if (size == 1)
 287         {
 288             //32 bits
 289             int* p = (int*)data;
 290             previous = ((types::InternalType*) * p);
 291         }
 292         else
 293         {
 294             //64 bits
 295             long long* p = (long long*)data;
 296             previous = ((types::InternalType*) * p);
 297         }
 298
 299         previous->DecreaseRef();
 300         previous->killMe();
 301     }
 302
 303     //set new value
 304     size = sizeof(void*) / sizeof(int);
 305     setGraphicObjectProperty(uid, __GO_USER_DATA__, &ud, jni_int_vector, size);
 306 }
 307
 308 static void import_handle_tag(int dataset, int uid)
 309 {
 310     char* tag = nullptr;
 311     int node = getHandleString(dataset, "tag", &tag);
 312     setGraphicObjectProperty(uid, __GO_TAG__, tag, jni_string, 1);
 313     freeStringMatrix(node, &tag);
 314 }
 315
 316 static int import_handle_children(int dataset, int parent)
 317 {
 318     //reload children
 319     int children = getDataSetIdFromName(dataset, "children");
 320     int childcount = 0;
 321     getListDims6(children, &childcount);
 322
 323     //reverse order
 324     for (int i = childcount - 1; i >= 0; --i)
 325     {
 326         int c = getDataSetIdFromName(children, std::to_string(i).data());
 327         int newChild = import_handle(c, parent);
 328     }
 329
 330     closeList6(children);
 331     return parent;
 332 }
 333
 334 static int import_handle_generic(int dataset, int uid, int parent, const HandleProp& props, bool childrenFirst)
 335 {
 336     //link current handle with its parent
 337     if (parent != -1)
 338     {
 339         setGraphicObjectRelationship(parent, uid);
 340     }
 341     //restore children before other property in case of properties has an
 342     //effect on children
 343
 344     //reload children
 345     if (childrenFirst)
 346     {
 347         import_handle_children(dataset, uid);
 348     }
 349
 350     for (auto & prop : props)
 351     {
 352         const char* name = prop.first.data();
 353         std::vector<int> info(prop.second);
 354
 355         if (info[0] == SAVE_ONLY)
 356         {
 357             continue;
 358         }
 359
 360         int go = info[1];
 361         int type = info[2];
 362         int row = 0;
 363         int col = 0;
 364
 365         switch (type)
 366         {
 367             case jni_bool:
 368             {
 369                 int val = 0;
 370                 getHandleBool(dataset, name, &val);
 371                 setGraphicObjectProperty(uid, go, &val, jni_bool, 1);
 372                 break;
 373             }
 374             case jni_int:
 375             {
 376                 int val = 0;
 377                 getHandleInt(dataset, name, &val);
 378                 setGraphicObjectProperty(uid, go, &val, jni_int, 1);
 379                 break;
 380             }
 381             case jni_double:
 382             {
 383                 double val = 0;
 384                 getHandleDouble(dataset, name, &val);
 385                 setGraphicObjectProperty(uid, go, &val, jni_double, 1);
 386                 break;
 387             }
 388             case jni_string:
 389             {
 390                 char* data = nullptr;
 391                 int node = getHandleString(dataset, name, &data);
 392                 setGraphicObjectProperty(uid, go, data, jni_string, 1);
 393                 freeStringMatrix(node, &data);
 394                 break;
 395             }
 396             case jni_bool_vector:
 397             {
 398                 int* vals = nullptr;
 399                 getHandleBoolVector(dataset, name, &row, &col, &vals);
 400                 if (vals)
 401                 {
 402                     setGraphicObjectProperty(uid, go, vals, jni_bool_vector, row * col);
 403                     delete[] vals;
 404                 }
 405                 break;
 406             }
 407             case jni_int_vector:
 408             {
 409                 int* vals = nullptr;
 410                 getHandleIntVector(dataset, name, &row, &col, &vals);
 411                 if (vals)
 412                 {
 413                     setGraphicObjectProperty(uid, go, vals, jni_int_vector, row * col);
 414                     delete[] vals;
 415                 }
 416                 break;
 417             }
 418             case jni_double_vector:
 419             {
 420                 double* vals = nullptr;
 421                 getHandleDoubleVector(dataset, name, &row, &col, &vals);
 422                 if (vals)
 423                 {
 424                     setGraphicObjectProperty(uid, go, vals, jni_double_vector, row * col);
 425                     delete[] vals;
 426                 }
 427                 break;
 428             }
 429             case jni_string_vector:
 430             {
 431                 char** vals = nullptr;
 432                 int node = getHandleStringVector(dataset, name, &row, &col, &vals);
 433                 if (vals)
 434                 {
 435                     setGraphicObjectProperty(uid, go, vals, jni_string_vector, row * col);
 436                 }
 437
 438                 freeStringMatrix(node, vals);
 439                 delete[] vals;
 440                 break;
 441             }
 442         }
 443     }
 444
 445     //userdata
 446     import_userdata(dataset, uid);
 447
 448     //tag
 449     import_handle_tag(dataset, uid);
 450
 451     //reload children
 452     if (childrenFirst == false)
 453     {
 454         import_handle_children(dataset, uid);
 455     }
 456
 457     return uid;
 458 }
 459
 460 static int import_handle_border(int dataset);
 461
 462 static int import_handle_border_none(int dataset, int border)
 463 {
 464     closeList6(dataset);
 465     return border;
 466 }
 467
 468 static int import_handle_border_line(int dataset, int border)
 469 {
 470     int status = 0;
 471     //color
 472     char* color = nullptr;
 473     int nc = getHandleString(dataset, "color", &color);
 474     setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_COLOR__, color, jni_string, 1);
 475     freeStringMatrix(nc, &color);
 476
 477     //thickness
 478     int thickness = 0;
 479     status = getHandleInt(dataset, "thickness", &thickness);
 480     if (status != -1)
 481     {
 482         setGraphicObjectProperty(border, __GO_LINE_THICKNESS__, &thickness, jni_int, 1);
 483     }
 484
 485     //rounded
 486     int rounded = 0;
 487     status = getHandleBool(dataset, "rounded", &rounded);
 488     if (status != -1)
 489     {
 490         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_ROUNDED__, &rounded, jni_bool, 1);
 491     }
 492
 493     closeList6(dataset);
 494     return border;
 495 }
 496
 497 static int import_handle_border_bevel(int dataset, int border)
 498 {
 499     char* data = nullptr;
 500     int node = 0;
 501     //type
 502     int type = 0;
 503     getHandleInt(dataset, "type", &type);
 504     setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_TYPE__, &type, jni_int, 1);
 505
 506     //highlight out
 507     node = getHandleString(dataset, "highlight_out", &data);
 508     if (data)
 509     {
 510         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, data, jni_string, 1);
 511     }
 512
 513     freeStringMatrix(node, &data);
 514     data = nullptr;
 515
 516     //highlight in
 517     node = getHandleString(dataset, "highlight_in", &data);
 518     if (data)
 519     {
 520         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_HIGHLIGHT_IN__, data, jni_string, 1);
 521     }
 522
 523     freeStringMatrix(node, &data);
 524     data = nullptr;
 525
 526     //shadow out
 527     node = getHandleString(dataset, "shadow_out", &data);
 528     if (data)
 529     {
 530         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_SHADOW_OUT__, data, jni_string, 1);
 531     }
 532
 533     freeStringMatrix(node, &data);
 534     data = nullptr;
 535
 536     //shadow in
 537     node = getHandleString(dataset, "shadow_in", &data);
 538     if (data)
 539     {
 540         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_SHADOW_IN__, data, jni_string, 1);
 541     }
 542
 543     freeStringMatrix(node, &data);
 544     data = nullptr;
 545
 546     closeList6(dataset);
 547     return border;
 548 }
 549
 550 static int import_handle_border_soft_bevel(int dataset, int border)
 551 {
 552     return import_handle_border_bevel(dataset, border);
 553 }
 554
 555 static int import_handle_border_etched(int dataset, int border)
 556 {
 557     int status = 0;
 558     char* data = nullptr;
 559     int node = 0;
 560
 561     //type
 562     int type = 0;
 563     status = getHandleInt(dataset, "type", &type);
 564     if (status != -1)
 565     {
 566         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_TYPE__, &type, jni_int, 1);
 567     }
 568
 569     //highlight out
 570     node = getHandleString(dataset, "highlight_out", &data);
 571     if (data)
 572     {
 573         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, data, jni_string, 1);
 574     }
 575
 576     freeStringMatrix(node, &data);
 577     data = nullptr;
 578
 579     //shadow out
 580     node = getHandleString(dataset, "shadow_out", &data);
 581     if (data)
 582     {
 583         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_SHADOW_OUT__, data, jni_string, 1);
 584     }
 585
 586     freeStringMatrix(node, &data);
 587     data = nullptr;
 588
 589     closeList6(dataset);
 590     return border;
 591 }
 592
 593 static int import_handle_border_titled(int dataset, int border)
 594 {
 595     char* data = nullptr;
 596     int node = 0;
 597     int status = 0;
 598
 599     //title border
 600     int title_border = getDataSetIdFromName(dataset, "title_border");
 601     if (title_border != -1)
 602     {
 603         int hidden = 1;
 604         int uiborder = import_handle_border(title_border);
 605         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_TITLE__, &uiborder, jni_int, 1);
 606         //force new border to be hide in scilab view
 607         setGraphicObjectProperty(uiborder, __GO_HIDDEN__, &hidden, jni_bool, 1);
 608     }
 609
 610     //title
 611     node = getHandleString(dataset, "title", &data);
 612     if (data)
 613     {
 614         setGraphicObjectProperty(border, __GO_TITLE__, data, jni_string, 1);
 615     }
 616
 617     freeStringMatrix(node, &data);
 618     data = nullptr;
 619
 620     //justification
 621     int justification = 0;
 622     status = getHandleInt(dataset, "justification", &justification);
 623     if (status != -1)
 624     {
 625         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_JUSTIFICATION__, &justification, jni_int, 1);
 626     }
 627
 628     //fontname
 629     node = getHandleString(dataset, "fontname", &data);
 630     if (data)
 631     {
 632         setGraphicObjectProperty(border, __GO_UI_FONTNAME__, data, jni_string, 1);
 633     }
 634
 635     freeStringMatrix(node, &data);
 636     data = nullptr;
 637
 638     //fontangle
 639     node = getHandleString(dataset, "fontangle", &data);
 640     if (data)
 641     {
 642         setGraphicObjectProperty(border, __GO_UI_FONTANGLE__, data, jni_string, 1);
 643     }
 644
 645     freeStringMatrix(node, &data);
 646     data = nullptr;
 647
 648     //fontsize
 649     int fontsize = 0;
 650     status = getHandleInt(dataset, "fontsize", &fontsize);
 651     if (status != -1)
 652     {
 653         setGraphicObjectProperty(border, __GO_UI_FONTSIZE__, &fontsize, jni_int, 1);
 654     }
 655
 656     //fontweight
 657     node = getHandleString(dataset, "fontweight", &data);
 658     if (data)
 659     {
 660         setGraphicObjectProperty(border, __GO_UI_FONTWEIGHT__, data, jni_string, 1);
 661     }
 662
 663     freeStringMatrix(node, &data);
 664     data = nullptr;
 665
 666     //position
 667     int position = 0;
 668     status = getHandleInt(dataset, "position", &position);
 669     if (status != -1)
 670     {
 671         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_POSITION__, &position, jni_int, 1);
 672     }
 673
 674     //color
 675     node = getHandleString(dataset, "color", &data);
 676     if (data)
 677     {
 678         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_COLOR__, data, jni_string, 1);
 679     }
 680
 681     freeStringMatrix(node, &data);
 682     data = nullptr;
 683
 684     closeList6(dataset);
 685     return border;
 686 }
 687
 688 static int import_handle_border_empty(int dataset, int border)
 689 {
 690     int row = 0;
 691     int col = 0;
 692     double* pos = nullptr;
 693
 694     getHandleDoubleVector(dataset, "position", &row, &col, &pos);
 695     if (pos && row * col == 4)
 696     {
 697         setGraphicObjectProperty(border, __GO_POSITION__, pos, jni_double_vector, row * col);
 698     }
 699     delete[] pos;
 700
 701     closeList6(dataset);
 702     return border;
 703 }
 704
 705 static int import_handle_border_compound(int dataset, int border)
 706 {
 707     //out_border
 708     int out_border = getDataSetIdFromName(dataset, "out_border");
 709     if (out_border != -1)
 710     {
 711         int hidden = 1;
 712         int uiborder = import_handle_border(out_border);
 713         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_OUT_BORDER__, &uiborder, jni_int, 1);
 714         //force new border to be hide in scilab view
 715         setGraphicObjectProperty(uiborder, __GO_HIDDEN__, &hidden, jni_bool, 1);
 716     }
 717
 718     //in_border
 719     int in_border = getDataSetIdFromName(dataset, "in_border");
 720     if (in_border != -1)
 721     {
 722         int hidden = 1;
 723         int uiborder = import_handle_border(in_border);
 724         setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_IN_BORDER__, &uiborder, jni_int, 1);
 725         //force new border to be hide in scilab view
 726         setGraphicObjectProperty(uiborder, __GO_HIDDEN__, &hidden, jni_bool, 1);
 727     }
 728
 729     closeList6(dataset);
 730     return border;
 731 }
 732
 733 static int import_handle_border_matte(int dataset, int border)
 734 {
 735     int row = 0;
 736     int col = 0;
 737     double* pos = nullptr;
 738
 739     getHandleDoubleVector(dataset, "position", &row, &col, &pos);
 740     setGraphicObjectProperty(border, __GO_POSITION__, pos, jni_double_vector, row * col);
 741     delete[] pos;
 742
 743     //color
 744     char* data = nullptr;
 745     int nc = getHandleString(dataset, "color", &data);
 746     setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_COLOR__, data, jni_string, 1);
 747     freeStringMatrix(nc, &data);
 748
 749     closeList6(dataset);
 750     return border;
 751 }
 752
 753 static int import_handle_border(int dataset)
 754 {
 755     int border = createGraphicObject(__GO_UI_FRAME_BORDER__);
 756     int style = 0;
 757     getHandleInt(dataset, "style", &style);
 758
 759     setGraphicObjectProperty(border, __GO_UI_FRAME_BORDER_STYLE__, &style, jni_int, 1);
 760
 761     switch (style)
 762     {
 763         default:
 764         case NONE:
 765             return import_handle_border_none(dataset, border);
 766         case LINE:
 767             return import_handle_border_line(dataset, border);
 768         case BEVEL:
 769             return import_handle_border_bevel(dataset, border);
 770         case SOFTBEVEL:
 771             return import_handle_border_soft_bevel(dataset, border);
 772         case ETCHED:
 773             return import_handle_border_etched(dataset, border);
 774         case TITLED:
 775             return import_handle_border_titled(dataset, border);
 776         case EMPTY:
 777             return import_handle_border_empty(dataset, border);
 778         case COMPOUND:
 779             return import_handle_border_compound(dataset, border);
 780         case MATTE:
 781             return import_handle_border_matte(dataset, border);
 782     }
 783 }
 784
 785 static int import_handle_uicontrol(int dataset, int parent)
 786 {
 787     int style = 0;
 788     getHandleInt(dataset, "style", &style);
 789     //uicontrol was created by their style instead of type like others graphic objects.
 790     int uic = createGraphicObject(style);
 791
 792     //some properties must be set before parent ( in import_handle_generic )
 793
 794     //scrollable
 795     int scrollable = 0;
 796     getHandleBool(dataset, "scrollable", &scrollable);
 797     setGraphicObjectProperty(uic, __GO_UI_SCROLLABLE__, &scrollable, jni_bool, 1);
 798
 799     //margins
 800     int row = 0;
 801     int col = 0;
 802
 803     double* margins = nullptr;
 804     getHandleDoubleVector(dataset, "margins", &row, &col, &margins);
 805     setGraphicObjectProperty(uic, __GO_MARGINS__, margins, jni_double_vector, row * col);
 806     delete[] margins;
 807
 808     //constraints
 809
 810     //border_position
 811     int border_position = 0;
 812     getHandleInt(dataset, "border_position", &border_position);
 813     setGraphicObjectProperty(uic, __GO_UI_BORDER_POSITION__, &border_position, jni_int, 1);
 814
 815     //border_size
 816     int* border_size = nullptr;
 817     getHandleIntVector(dataset, "border_size", &row, &col, &border_size);
 818     setGraphicObjectProperty(uic, __GO_UI_BORDER_PREFERREDSIZE__, border_size, jni_int_vector, row * col);
 819     delete[] border_size;
 820
 821     //gridbad_grid
 822     int* gridbad_grid = nullptr;
 823     getHandleIntVector(dataset, "gridbad_grid", &row, &col, &gridbad_grid);
 824     setGraphicObjectProperty(uic, __GO_UI_GRIDBAG_GRID__, gridbad_grid, jni_int_vector, row * col);
 825     delete[] gridbad_grid;
 826
 827     //gridbad_weight
 828     double* gridbad_weight = nullptr;
 829     getHandleDoubleVector(dataset, "gridbad_weight", &row, &col, &gridbad_weight);
 830     setGraphicObjectProperty(uic, __GO_UI_GRIDBAG_WEIGHT__, gridbad_weight, jni_double_vector, row * col);
 831     delete[] gridbad_weight;
 832
 833     //gridbad_fill
 834     int gridbad_fill = 0;
 835     getHandleInt(dataset, "gridbad_fill", &gridbad_fill);
 836     setGraphicObjectProperty(uic, __GO_UI_GRIDBAG_FILL__, &gridbad_fill, jni_int, 1);
 837
 838     //gridbad_anchor
 839     int gridbad_anchor = 0;
 840     getHandleInt(dataset, "gridbad_anchor", &gridbad_anchor);
 841     setGraphicObjectProperty(uic, __GO_UI_GRIDBAG_ANCHOR__, &gridbad_anchor, jni_int, 1);
 842
 843     //gridbad_padding
 844     int* gridbad_padding = nullptr;
 845     getHandleIntVector(dataset, "gridbad_padding", &row, &col, &gridbad_padding);
 846     setGraphicObjectProperty(uic, __GO_UI_GRIDBAG_PADDING__, gridbad_padding, jni_int_vector, row * col);
 847     delete[] gridbad_padding;
 848
 849     //gridbad_size
 850     int* gridbad_size = nullptr;
 851     getHandleIntVector(dataset, "gridbad_size", &row, &col, &gridbad_size);
 852     setGraphicObjectProperty(uic, __GO_UI_GRIDBAG_PREFERREDSIZE__, gridbad_size, jni_int_vector, row * col);
 853     delete[] gridbad_size;
 854
 855     //import "standards" properties
 856     import_handle_generic(dataset, uic, parent, UicontrolHandle::getPropertyList(), false);
 857
 858     //string
 859     char** string = nullptr;
 860     int node = getHandleStringVector(dataset, "string", &row, &col, &string);
 861     setGraphicObjectProperty(uic, __GO_UI_STRING_COLNB__, &col, jni_int, 1);
 862     setGraphicObjectProperty(uic, __GO_UI_STRING__, string, jni_string_vector, row * col);
 863     freeStringMatrix(node, string);
 864     delete[] string;
 865
 866     //border
 867     int dborder = getDataSetIdFromName(dataset, "border");
 868     int border = import_handle_border(dborder);
 869     setGraphicObjectProperty(uic, __GO_UI_FRAME_BORDER__, &border, jni_int, 1);
 870
 871
 872     //value
 873     double* value = nullptr;
 874     getHandleDoubleVector(dataset, "value", &row, &col, &value);
 875     if (value)
 876     {
 877         setGraphicObjectProperty(uic, __GO_UI_VALUE__, value, jni_double_vector, row * col);
 878         delete[] value;
 879     }
 880
 881     closeList6(dataset);
 882     return uic;
 883 }
 884
 885 static int import_handle_uicontextmenu(int dataset, int parent)
 886 {
 887     int menu = createGraphicObject(__GO_UICONTEXTMENU__);
 888
 889     //import "standards" properties
 890     import_handle_generic(dataset, menu, parent, UicontextmenuHandle::getPropertyList(), false);
 891
 892     closeList6(dataset);
 893     return menu;
 894 }
 895
 896 static int import_handle_uimenu(int dataset, int parent)
 897 {
 898     int menu = createGraphicObject(__GO_UIMENU__);
 899
 900     //import "standards" properties
 901     import_handle_generic(dataset, menu, parent, UimenuHandle::getPropertyList(), false);
 902
 903     closeList6(dataset);
 904     return menu;
 905 }
 906
 907 static int import_handle_light(int dataset, int parent)
 908 {
 909     int light = createGraphicObject(__GO_LIGHT__);
 910
 911     //import "standards" properties
 912     import_handle_generic(dataset, light, parent, LightHandle::getPropertyList(), true);
 913
 914     closeList6(dataset);
 915     return light;
 916 }
 917
 918 static int import_handle_axis(int dataset, int parent)
 919 {
 920     int axis = createGraphicObject(__GO_AXIS__);
 921
 922     //import "standards" properties
 923     import_handle_generic(dataset, axis, parent, AxisHandle::getPropertyList(), true);
 924
 925     closeList6(dataset);
 926     return axis;
 927 }
 928
 929 static int import_handle_text(int dataset, int parent)
 930 {
 931     int t = createGraphicObject(__GO_TEXT__);
 932
 933     //import "standards" properties
 934     import_handle_generic(dataset, t, parent, TextHandle::getPropertyList(), true);
 935
 936
 937     //text
 938     int dims[2];
 939     char** text = nullptr;
 940     int textnode = getHandleStringVector(dataset, "text", &dims[0], &dims[1], &text);
 941     setGraphicObjectProperty(t, __GO_TEXT_ARRAY_DIMENSIONS__, dims, jni_int_vector, 2);
 942     setGraphicObjectProperty(t, __GO_TEXT_STRINGS__, text, jni_string_vector, dims[0] * dims[1]);
 943     freeStringMatrix(textnode, text);
 944     delete[] text;
 945     closeList6(dataset);
 946     return t;
 947 }
 948
 949 static int import_handle_legend(int dataset, int parent)
 950 {
 951     int legend = createGraphicObject(__GO_LEGEND__);
 952
 953     //import "standards" properties
 954     import_handle_generic(dataset, legend, parent, LegendHandle::getPropertyList(), true);
 955
 956
 957     //text
 958     int dims[2];
 959     char** text = nullptr;
 960     int textnode = getHandleStringVector(dataset, "text", &dims[0], &dims[1], &text);
 961     setGraphicObjectProperty(legend, __GO_TEXT_ARRAY_DIMENSIONS__, dims, jni_int_vector, 2);
 962     setGraphicObjectProperty(legend, __GO_TEXT_STRINGS__, text, jni_string_vector, dims[0] * dims[1]);
 963     freeStringMatrix(textnode, text);
 964     delete[] text;
 965     //links
 966
 967     //to retore links we need to have the entire hierarchie loaded.
 968     //store links information in a "global" variable and update variable at the end of process.
 969     int node = getDataSetIdFromName(dataset, "links");
 970     int count = 0;
 971     getListDims6(node, &count);
 972
 973     Links::PathList paths;
 974
 975     for (int i = 0; i < count; ++i)
 976     {
 977         int row = 0;
 978         int col = 0;
 979         int* path = nullptr;
 980         getHandleIntVector(node, std::to_string(i).data(), &row, &col, &path);
 981         std::vector<int> res(row * col);
 982         for (int j = 0; j < row * col; ++j)
 983         {
 984             res[j] = path[j];
 985         }
 986
 987         delete[] path;
 988
 989         paths.push_back(res);
 990     }
 991
 992     Links::add(legend, paths);
 993
 994     closeList6(node);
 995     closeList6(dataset);
 996     return legend;
 997 }
 998
 999 static int import_handle_fec(int dataset, int parent)
1000 {
1001     int fec = createGraphicObject(__GO_FEC__);
1002     createDataObject(fec, __GO_FEC__);
1003
1004     //import "standards" properties
1005     import_handle_generic(dataset, fec, parent, FecHandle::getPropertyList(), true);
1006
1007     //triangles
1008     int coordR = 0;
1009     int coordC = 0;
1010     int valuesR = 0;
1011     int valuesC = 0;
1012     int trianglesR = 0;
1013     int trianglesC = 0;
1014
1015     double* coords = nullptr;
1016     getHandleDoubleVector(dataset, "coords", &coordR, &coordC, &coords);
1017     double* values = nullptr;
1018     getHandleDoubleVector(dataset, "values", &valuesR, &valuesC, &values);
1019     double* triangles = nullptr;
1020     getHandleDoubleVector(dataset, "triangles", &trianglesR, &trianglesC, &triangles);
1021     int realcol = trianglesC - 2;
1022
1023     setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_NUM_VERTICES__, &valuesC, jni_int, 1);
1024     setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_NUM_VERTICES_BY_ELEM__, &realcol, jni_int, 1);
1025     setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_NUM_INDICES__, &trianglesR, jni_int, 1);
1026     //setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_X__, coords, jni_double_vector, coordR);
1027     //setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_Y__, coords + coordR, jni_double_vector, coordR);
1028     setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_COORDINATES__, coords, jni_double_vector, coordC);
1029     setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_FEC_ELEMENTS__, triangles, jni_double_vector, trianglesR);
1030     setGraphicObjectPropertyAndNoWarn(fec, __GO_DATA_MODEL_VALUES__, values, jni_double_vector, valuesC);
1031
1032     delete[] coords;
1033     delete[] values;
1034     delete[] triangles;
1035
1036     closeList6(dataset);
1037     return fec;
1038 }
1039
1040 static int import_handle_matplot(int dataset, int parent)
1041 {
1042     int plot = createGraphicObject(__GO_MATPLOT__);
1043     createDataObject(plot, __GO_MATPLOT__);
1044
1045     //import "standards" properties
1046     import_handle_generic(dataset, plot, parent, MatplotHandle::getPropertyList(), true);
1047
1048     int row = 0;
1049     int col = 0;
1050     //rect
1051     double* rect = nullptr;
1052     getHandleDoubleVector(dataset, "rect", &row, &col, &rect);
1053     double tmp = rect[1];
1054     rect[1] = rect[2];
1055     rect[2] = tmp;
1056
1057     //data
1058     getHandleInt(dataset, "num_x", &row);
1059     getHandleInt(dataset, "num_y", &col);
1060     double* data = nullptr;
1061     int data_x = 0;
1062     int data_y = 0;
1063     getHandleDoubleVector(dataset, "data", &data_x, &data_y, &data);
1064
1065     int grid[4];
1066     grid[0] = col;
1067     grid[1] = 1;
1068     grid[2] = row;
1069     grid[3] = 1;
1070
1071     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_GRID_SIZE__, grid, jni_int_vector, 4);
1072
1073     double scale[2];
1074     setGraphicObjectProperty(plot, __GO_MATPLOT_TRANSLATE__, rect, jni_double_vector, 2);
1075     scale[0] = (rect[2] - rect[0]) / (col - 1.0);
1076     scale[1] = (rect[3] - rect[1]) / (row - 1.0);
1077     setGraphicObjectProperty(plot, __GO_MATPLOT_SCALE__, scale, jni_double_vector, 2);
1078
1079     setGraphicObjectProperty(plot, __GO_DATA_MODEL_MATPLOT_BOUNDS__, rect, jni_double_vector, 4);
1080
1081     setGraphicObjectProperty(plot, __GO_DATA_MODEL_MATPLOT_IMAGE_DATA__, data, jni_double_vector, data_x * data_y);
1082
1083     delete[] rect;
1084     delete[] data;
1085
1086     closeList6(dataset);
1087     return plot;
1088 }
1089
1090 static int import_handle_grayplot(int dataset, int parent)
1091 {
1092     int plot = createGraphicObject(__GO_GRAYPLOT__);
1093     createDataObject(plot, __GO_GRAYPLOT__);
1094
1095     //import "standards" properties
1096     import_handle_generic(dataset, plot, parent, GrayplotHandle::getPropertyList(), true);
1097
1098     int row = 0;
1099     int col = 0;
1100     double* dataX = nullptr;
1101     double* dataY = nullptr;
1102     double* dataZ = nullptr;
1103     getHandleDoubleVector(dataset, "data_x", &row, &col, &dataX);
1104     getHandleDoubleVector(dataset, "data_y", &row, &col, &dataY);
1105     getHandleDoubleVector(dataset, "data_z", &row, &col, &dataZ);
1106
1107     int grid[4];
1108     grid[0] = row;
1109     grid[1] = 1;
1110     grid[2] = col;
1111     grid[3] = 1;
1112
1113     //set dimensions
1114     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_GRID_SIZE__, grid, jni_int_vector, 4);
1115
1116     //set data
1117     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_X__, dataX, jni_double_vector, row);
1118     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_Y__, dataY, jni_double_vector, col);
1119     setGraphicObjectProperty(plot, __GO_DATA_MODEL_Z__, dataZ, jni_double_vector, row * col);
1120
1121     closeList6(dataset);
1122     return plot;
1123 }
1124
1125 static int import_handle_segs(int dataset, int parent)
1126 {
1127     int segs = createGraphicObject(__GO_SEGS__);
1128
1129     //import "standards" properties
1130     import_handle_generic(dataset, segs, parent, SegsHandle::getPropertyList(), true);
1131
1132     closeList6(dataset);
1133     return segs;
1134 }
1135
1136 static int import_handle_arc(int dataset, int parent)
1137 {
1138     int arc = createGraphicObject(__GO_ARC__);
1139
1140     //import "standards" properties
1141     import_handle_generic(dataset, arc, parent, ArcHandle::getPropertyList(), true);
1142
1143     closeList6(dataset);
1144     return arc;
1145 }
1146
1147 static int import_handle_rectangle(int dataset, int parent)
1148 {
1149     int rect = createGraphicObject(__GO_RECTANGLE__);
1150
1151     //import "standards" properties
1152     import_handle_generic(dataset, rect, parent, RectangleHandle::getPropertyList(), true);
1153
1154     closeList6(dataset);
1155     return rect;
1156 }
1157
1158 static int import_handle_compound(int dataset, int parent)
1159 {
1160     int compound = createGraphicObject(__GO_COMPOUND__);
1161
1162     //import "standards" properties
1163     import_handle_generic(dataset, compound, parent, CompoundHandle::getPropertyList(), true);
1164
1165     closeList6(dataset);
1166     return compound;
1167 }
1168
1169 static int import_handle_datatip(int dataset, int parent)
1170 {
1171     int datatip = createGraphicObject(__GO_DATATIP__);
1172     //set parent manually, these no real releationship between datatip and parent
1173     setGraphicObjectProperty(datatip, __GO_PARENT__, &parent, jni_int, 1);
1174
1175     //data
1176     int index = 0;
1177     getHandleInt(dataset, "data_index", &index);
1178     double indexes[2];
1179     indexes[0] = index;
1180     indexes[1] = 0;
1181
1182     setGraphicObjectProperty(datatip, __GO_DATATIP_INDEXES__, indexes, jni_double_vector, 2);
1183
1184     //import "standards" properties
1185     import_handle_generic(dataset, datatip, -1, DatatipHandle::getPropertyList(), true);
1186
1187     closeList6(dataset);
1188     return datatip;
1189 }
1190
1191 static int import_handle_datatips(int dataset, int uid)
1192 {
1193     int datatip = getDataSetIdFromName(dataset, "datatips");
1194     int count = 0;
1195     getListDims6(datatip, &count);
1196
1197     std::vector<int> datatips(count);
1198     for (int i = 0; i < count; ++i)
1199     {
1200         int d = getDataSetIdFromName(datatip, std::to_string(i).data());
1201         datatips[i] = import_handle_datatip(d, uid);
1202     }
1203
1204     setGraphicObjectProperty(uid, __GO_DATATIPS__, datatips.data(), jni_int_vector, count);
1205
1206     closeList6(datatip);
1207     return uid;
1208 }
1209
1210 static int import_polyline_shift(int dataset, int uid, const std::string& name, int go_set, int go_data)
1211 {
1212     int row = 0;
1213     int col = 0;
1214     int set = 0;
1215     double* data = nullptr;
1216
1217     getHandleDoubleVector(dataset, name.data(), &row, &col, &data);
1218     if (row * col != 0)
1219     {
1220         set = 1;
1221         setGraphicObjectProperty(uid, go_data, data, jni_double_vector, row * col);
1222     }
1223     else
1224     {
1225         set = 0;
1226     }
1227
1228     delete[] data;
1229     setGraphicObjectProperty(uid, go_set, &set, jni_int, 1);
1230     return uid;
1231 }
1232
1233 static int import_handle_polyline(int dataset, int parent)
1234 {
1235     int polyline = createGraphicObject(__GO_POLYLINE__);
1236     createDataObject(polyline, __GO_POLYLINE__);
1237
1238     //import "standards" properties
1239     import_handle_generic(dataset, polyline, parent, PolylineHandle::getPropertyList(), true);
1240
1241
1242     //x_shift
1243     import_polyline_shift(dataset, polyline, "x_shift", __GO_DATA_MODEL_X_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_X_COORDINATES_SHIFT__);
1244     //y_shift
1245     import_polyline_shift(dataset, polyline, "y_shift", __GO_DATA_MODEL_Y_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Y_COORDINATES_SHIFT__);
1246     //z_shift
1247     import_polyline_shift(dataset, polyline, "z_shift", __GO_DATA_MODEL_Z_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Z_COORDINATES_SHIFT__);
1248
1249
1250     //interp_color_vector
1251     {
1252         int row = 0;
1253         int col = 0;
1254         int set = 0;
1255         int* data = nullptr;
1256
1257         getHandleIntVector(dataset, "interp_color_vector", &row, &col, &data);
1258         if (row * col != 0)
1259         {
1260             set = 1;
1261             setGraphicObjectProperty(polyline, __GO_INTERP_COLOR_VECTOR__, data, jni_double_vector, row * col);
1262         }
1263         else
1264         {
1265             set = 0;
1266         }
1267
1268         delete[] data;
1269         setGraphicObjectProperty(polyline, __GO_INTERP_COLOR_VECTOR_SET__, &set, jni_bool, 1);
1270     }
1271
1272     //data
1273     {
1274         int numElementsArray[2];
1275         int size = 0;
1276         double* dataX = nullptr;
1277         double* dataY = nullptr;
1278         double* dataZ = nullptr;
1279         getHandleDoubleVector(dataset, "data_x", &numElementsArray[0], &numElementsArray[1], &dataX);
1280         size = numElementsArray[0] * numElementsArray[1];
1281         getHandleDoubleVector(dataset, "data_y", &numElementsArray[0], &numElementsArray[1], &dataY);
1282
1283         if (numElementsArray[0] * numElementsArray[1] != size)
1284         {
1285             std::cout << "size trouble !!!" << std::endl;
1286         }
1287
1288         setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
1289         setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_X__, dataX, jni_double_vector, size);
1290         setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_Y__, dataY, jni_double_vector, size);
1291
1292         //data z
1293         int zSet = 0;
1294         numElementsArray[0] = 0;
1295         numElementsArray[1] = 0;
1296         getHandleDoubleVector(dataset, "data_z", &numElementsArray[0], &numElementsArray[1], &dataZ);
1297         if (numElementsArray[0] * numElementsArray[1] != 0)
1298         {
1299             setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_Z__, dataZ, jni_double_vector, size);
1300             zSet = 1;
1301         }
1302
1303         setGraphicObjectProperty(polyline, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zSet, jni_int, 1);
1304
1305         delete[] dataX;
1306         delete[] dataY;
1307         delete[] dataZ;
1308     }
1309
1310     //datatips
1311     import_handle_datatips(dataset, polyline);
1312
1313     closeList6(dataset);
1314     return polyline;
1315 }
1316
1317 static int import_handle_surface(int dataset, int uid, int parent)
1318 {
1319     //import "standards" properties
1320     import_handle_generic(dataset, uid, parent, SurfaceHandle::getPropertyList(), true);
1321     return uid;
1322 }
1323
1324 static int import_handle_plot3d(int dataset, int parent)
1325 {
1326     int plot = createGraphicObject(__GO_PLOT3D__);
1327     createDataObject(plot, __GO_PLOT3D__);
1328     import_handle_surface(dataset, plot, parent);
1329
1330     //data
1331     int xR = 0, xC = 0;
1332     double* dataX = nullptr;
1333     int yR = 0, yC = 0;
1334     double* dataY = nullptr;
1335     int zR = 0, zC = 0;
1336     double* dataZ = nullptr;
1337
1338     getHandleDoubleVector(dataset, "data_x", &xR, &xC, &dataX);
1339     getHandleDoubleVector(dataset, "data_y", &yR, &yC, &dataY);
1340     getHandleDoubleVector(dataset, "data_z", &zR, &zC, &dataZ);
1341
1342     int gridSize[4];
1343     int result;
1344
1345     gridSize[0] = xR;
1346     gridSize[1] = xC;
1347     gridSize[2] = yR;
1348     gridSize[3] = yC;
1349
1350     result = setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
1351
1352     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_X__, dataX, jni_double_vector, xR * xC);
1353     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_Y__, dataY, jni_double_vector, yR * yC);
1354     setGraphicObjectProperty(plot, __GO_DATA_MODEL_Z__, dataZ, jni_double_vector, zR * zC);
1355
1356     delete[] dataX;
1357     delete[] dataY;
1358     delete[] dataZ;
1359
1360
1361     closeList6(dataset);
1362     return plot;
1363 }
1364
1365 static int import_handle_fac3d(int dataset, int parent)
1366 {
1367     int fac = createGraphicObject(__GO_FAC3D__);
1368     createDataObject(fac, __GO_FAC3D__);
1369
1370     import_handle_surface(dataset, fac, parent);
1371
1372     //data
1373     int xR = 0, xC = 0;
1374     double* dataX = nullptr;
1375     int yR = 0, yC = 0;
1376     double* dataY = nullptr;
1377     int zR = 0, zC = 0;
1378     double* dataZ = nullptr;
1379
1380     getHandleDoubleVector(dataset, "data_x", &xR, &xC, &dataX);
1381     getHandleDoubleVector(dataset, "data_y", &yR, &yC, &dataY);
1382     getHandleDoubleVector(dataset, "data_z", &zR, &zC, &dataZ);
1383
1384     int cR = 0;
1385     int cC = 0;
1386     double* colors = nullptr;
1387     getHandleDoubleVector(dataset, "colors", &cR, &cC, &colors);
1388     int cSize = cR * cC;
1389
1390     int numElementsArray[3];
1391
1392     numElementsArray[0] = xC;
1393     numElementsArray[1] = xR;
1394     numElementsArray[2] = cSize;
1395
1396     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 3);
1397
1398     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_X__, dataX, jni_double_vector, xR * xC);
1399     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_Y__, dataY, jni_double_vector, yR * yC);
1400     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_Z__, dataZ, jni_double_vector, zR * zC);
1401     setGraphicObjectProperty(fac, __GO_DATA_MODEL_COLORS__, colors, jni_double_vector, cSize);
1402
1403     delete[] dataX;
1404     delete[] dataY;
1405     delete[] dataZ;
1406     delete[] colors;
1407
1408
1409     //cdata_mapping
1410     int cdata = 0;
1411     getHandleInt(dataset, "cdata_mapping", &cdata);
1412     setGraphicObjectProperty(fac, __GO_DATA_MAPPING__, &cdata, jni_int, 1);
1413
1414
1415     closeList6(dataset);
1416     return fac;
1417 }
1418
1419
1420 static int import_handle_champ(int dataset, int parent)
1421 {
1422     //need to get properties and call a "creator" :x
1423
1424     int champ = createGraphicObject(__GO_CHAMP__);
1425
1426     //data
1427     int row = 0;
1428     int col = 0;
1429     int dims[2];
1430     int num = 0;
1431     double* baseX = nullptr;
1432     getHandleDoubleVector(dataset, "base_x", &row, &col, &baseX);
1433     dims[0] = col;
1434
1435     double* baseY = nullptr;
1436     getHandleDoubleVector(dataset, "base_y", &row, &col, &baseY);
1437     dims[1] = col;
1438     num = dims[0] * dims[1];
1439
1440     double* directionX = nullptr;
1441     getHandleDoubleVector(dataset, "direction_x", &row, &col, &directionX);
1442
1443     double* directionY = nullptr;
1444     getHandleDoubleVector(dataset, "direction_y", &row, &col, &directionY);
1445
1446     setGraphicObjectProperty(champ, __GO_NUMBER_ARROWS__, &num, jni_int, 1);
1447     setGraphicObjectProperty(champ, __GO_CHAMP_DIMENSIONS__, dims, jni_int_vector, 2);
1448     setGraphicObjectProperty(champ, __GO_BASE_X__, baseX, jni_double_vector, dims[0]);
1449     setGraphicObjectProperty(champ, __GO_BASE_Y__, baseY, jni_double_vector, dims[1]);
1450     setGraphicObjectProperty(champ, __GO_DIRECTION_X__, directionX, jni_double_vector, dims[0] * dims[1]);
1451     setGraphicObjectProperty(champ, __GO_DIRECTION_Y__, directionY, jni_double_vector, dims[0] * dims[1]);
1452
1453     delete[] baseX;
1454     delete[] baseY;
1455     delete[] directionX;
1456     delete[] directionY;
1457
1458     //import "standards" properties
1459     import_handle_generic(dataset, champ, parent, ChampHandle::getPropertyList(), true);
1460
1461     closeList6(dataset);
1462     return champ;
1463 }
1464 static int import_handle_label(int dataset, int uid)
1465 {
1466     //import "standards" properties
1467     //do not create releationship between parent
1468     import_handle_generic(dataset, uid, -1, LabelHandle::getPropertyList(), true);
1469
1470     //text
1471     std::vector<int> dims(2);
1472     char** data = nullptr;
1473     int node = getHandleStringVector(dataset, "text", &dims[0], &dims[1], &data);
1474
1475     setGraphicObjectProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, dims.data(), jni_int_vector, 2);
1476     setGraphicObjectProperty(uid, __GO_TEXT_STRINGS__, data, jni_string_vector, dims[0] * dims[1]);
1477     freeStringMatrix(node, data);
1478     delete[] data;
1479
1480     closeList6(dataset);
1481     return uid;
1482 }
1483
1484 static int import_handle_axes(int dataset, int parent)
1485 {
1486     //how to manage call by %h_copy ?
1487
1488     int axes = createSubWin(parent);
1489
1490     //hide current axes
1491     int visible = 0;
1492     setGraphicObjectProperty(axes, __GO_VISIBLE__, &visible, jni_bool, 1);
1493
1494     //import "standards" properties
1495     import_handle_generic(dataset, axes, parent, AxesHandle::getPropertyList(), true);
1496
1497     //title
1498     int title = 0;
1499     int *ptitle = &title;
1500     int nodeTitle = getDataSetIdFromName(dataset, "title");
1501     getGraphicObjectProperty(axes, __GO_TITLE__, jni_int, (void **)&ptitle);
1502     import_handle_label(nodeTitle, title);
1503
1504     //x_label
1505     int x_label = 0;
1506     int *px_label = &x_label;
1507     int nodeX = getDataSetIdFromName(dataset, "x_label");
1508     getGraphicObjectProperty(axes, __GO_X_AXIS_LABEL__, jni_int, (void **)&px_label);
1509     import_handle_label(nodeX, x_label);
1510
1511     //y_label
1512     int y_label = 0;
1513     int *py_label = &y_label;
1514     int nodeY = getDataSetIdFromName(dataset, "y_label");
1515     getGraphicObjectProperty(axes, __GO_Y_AXIS_LABEL__, jni_int, (void **)&py_label);
1516     import_handle_label(nodeY, y_label);
1517
1518     //z_label
1519     int z_label = 0;
1520     int *pz_label = &z_label;
1521     int nodeZ = getDataSetIdFromName(dataset, "z_label");
1522     getGraphicObjectProperty(axes, __GO_Z_AXIS_LABEL__, jni_int, (void **)&pz_label);
1523     import_handle_label(nodeZ, z_label);
1524
1525     //set real visible state
1526     getHandleInt(dataset, "visible", &visible);
1527     setGraphicObjectProperty(axes, __GO_VISIBLE__, &visible, jni_bool, 1);
1528
1529     closeList6(dataset);
1530     return axes;
1531 }
1532
1533 static int import_handle_layout_options(int dataset, int frame)
1534 {
1535     int layout_type = 0;
1536     getHandleInt(dataset, "layout", &layout_type);
1537     int row = 0;
1538     int col = 0;
1539     int* data = nullptr;
1540
1541     switch (layout_type)
1542     {
1543         case 2: //grid
1544         {
1545             int node = getDataSetIdFromName(dataset, "layout_options");
1546             getHandleIntVector(node, "grid", &row, &col, &data);
1547             if (data && row * col == 2)
1548             {
1549                 setGraphicObjectProperty(frame, __GO_GRID_OPT_GRID__, data, jni_int_vector, 2);
1550             }
1551
1552             delete[] data;
1553             data = nullptr;
1554
1555             getHandleIntVector(node, "padding", &row, &col, &data);
1556             if (data && row * col == 2)
1557             {
1558                 setGraphicObjectProperty(frame, __GO_GRID_OPT_PADDING__, data, jni_int_vector, 2);
1559             }
1560
1561             delete[] data;
1562             data = nullptr;
1563
1564             closeList6(node);
1565             break;
1566         }
1567         case 3: //border
1568         {
1569             int node = getDataSetIdFromName(dataset, "layout_options");
1570             getHandleIntVector(node, "padding", &row, &col, &data);
1571             if (data && row * col == 2)
1572             {
1573                 setGraphicObjectProperty(frame, __GO_BORDER_OPT_PADDING__, data, jni_int_vector, 2);
1574             }
1575
1576             delete[] data;
1577             data = nullptr;
1578
1579             closeList6(node);
1580             break;
1581         }
1582     }
1583
1584     return frame;
1585 }
1586
1587 static int import_handle_figure(int dataset, int parent)
1588 {
1589     //some properties must be set @ creation time
1590     int menubar = 0;
1591     getHandleInt(dataset, "menubar", &menubar);
1592     int toolbar = 0;
1593     getHandleInt(dataset, "toolbar", &toolbar);
1594     int dockable = 0;
1595     getHandleBool(dataset, "dockable", &dockable);
1596     int default_axes = 0;
1597     getHandleBool(dataset, "default_axes", &default_axes);
1598
1599     //force visible true FOR DEBUG ONLY
1600     int visible = 0;
1601
1602     //create a new hidden figure
1603     int fig = createFigure(dockable, menubar, toolbar, default_axes, visible);
1604     int id = getValidDefaultFigureId();
1605     setGraphicObjectProperty(fig, __GO_ID__, &id, jni_int, 1);
1606
1607     int menu = 0;
1608     getHandleBool(dataset, "menubar_visible", &menu);
1609     int notmenu = !menu;
1610     int info = 0;
1611     getHandleBool(dataset, "infobar_visible", &info);
1612     int notinfo = !info;
1613     int tool = 0;
1614     getHandleBool(dataset, "toolbar_visible", &tool);
1615     int nottool = !tool;
1616
1617     //force inverse flag
1618     setGraphicObjectProperty(fig, __GO_MENUBAR_VISIBLE__, &notmenu, jni_bool, 1);
1619     setGraphicObjectProperty(fig, __GO_INFOBAR_VISIBLE__, &notinfo, jni_bool, 1);
1620     setGraphicObjectProperty(fig, __GO_TOOLBAR_VISIBLE__, &nottool, jni_bool, 1);
1621
1622     //set real value
1623     setGraphicObjectProperty(fig, __GO_MENUBAR_VISIBLE__, &menu, jni_bool, 1);
1624     setGraphicObjectProperty(fig, __GO_INFOBAR_VISIBLE__, &info, jni_bool, 1);
1625     setGraphicObjectProperty(fig, __GO_TOOLBAR_VISIBLE__, &tool, jni_bool, 1);
1626
1627     //import "standards" properties
1628     import_handle_generic(dataset, fig, -1, FigureHandle::getPropertyList(), true);
1629
1630     import_handle_layout_options(dataset, fig);
1631     closeList6(dataset);
1632     return fig;
1633 }
1634
1635 int import_handle(int dataset, int parent)
1636 {
1637     //get type
1638     int type = 0;
1639     getHandleInt(dataset, "type", &type);
1640     switch (type)
1641     {
1642         case __GO_FIGURE__:
1643         {
1644             return import_handle_figure(dataset, parent);
1645         }
1646         case __GO_AXES__:
1647         {
1648             return import_handle_axes(dataset, parent);
1649         }
1650         case __GO_CHAMP__:
1651         {
1652             return import_handle_champ(dataset, parent);
1653         }
1654         case __GO_FAC3D__:
1655         {
1656             return import_handle_fac3d(dataset, parent);
1657         }
1658         case __GO_PLOT3D__:
1659         {
1660             return import_handle_plot3d(dataset, parent);
1661         }
1662         case __GO_COMPOUND__:
1663         {
1664             return import_handle_compound(dataset, parent);
1665         }
1666         case __GO_POLYLINE__:
1667         {
1668             return import_handle_polyline(dataset, parent);
1669         }
1670         case __GO_RECTANGLE__:
1671         {
1672             return import_handle_rectangle(dataset, parent);
1673         }
1674         case __GO_ARC__:
1675         {
1676             return import_handle_arc(dataset, parent);
1677         }
1678         case __GO_SEGS__:
1679         {
1680             return import_handle_segs(dataset, parent);
1681         }
1682         case __GO_GRAYPLOT__:
1683         {
1684             return import_handle_grayplot(dataset, parent);
1685         }
1686         case __GO_MATPLOT__:
1687         {
1688             return import_handle_matplot(dataset, parent);
1689         }
1690         case __GO_FEC__:
1691         {
1692             return import_handle_fec(dataset, parent);
1693         }
1694         case __GO_LEGEND__:
1695         {
1696             return import_handle_legend(dataset, parent);
1697         }
1698         case __GO_TEXT__:
1699         {
1700             return import_handle_text(dataset, parent);
1701         }
1702         case __GO_AXIS__:
1703         {
1704             return import_handle_axis(dataset, parent);
1705         }
1706         case __GO_LIGHT__:
1707         {
1708             return import_handle_light(dataset, parent);
1709         }
1710         case __GO_UIMENU__:
1711         {
1712             return import_handle_uimenu(dataset, parent);
1713         }
1714         case __GO_UICONTEXTMENU__:
1715         {
1716             return import_handle_uicontextmenu(dataset, parent);
1717         }
1718         case __GO_UICONTROL__:
1719         {
1720             return import_handle_uicontrol(dataset, parent);
1721         }
1722     }
1723     return -1;
1724 }
1725
1726 void update_link_path(int legend, Links::PathList& paths)
1727 {
1728     //find legend parent axes ( origin of path items )
1729     int type = 0;
1730     int* ptype = &type;
1731     int axes = legend; //start point
1732     int* paxes = &axes;
1733     getGraphicObjectProperty(legend, __GO_PARENT_AXES__, jni_int, (void**)&paxes);
1734     std::vector<int> links;
1735     //loop on child following path index
1736     for (auto & path : paths)
1737     {
1738         int current = axes;
1739         for (int j = 0; j < path.size(); ++j)
1740         {
1741             int index = path[path.size() - 1 - j];
1742             int count = 0;
1743             int* pcount = &count;
1744             getGraphicObjectProperty(current, __GO_CHILDREN_COUNT__, jni_int, (void**)&pcount);
1745             if (count == 0 || index >= count)
1746             {
1747                 getGraphicObjectProperty(current, __GO_TYPE__, jni_int, (void**)&ptype);
1748                 break;
1749             }
1750
1751             int* children = nullptr;
1752             getGraphicObjectProperty(current, __GO_CHILDREN__, jni_int_vector, (void**)&children);
1753
1754             current = children[index];
1755
1756             releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
1757         }
1758
1759         links.push_back(current);
1760     }
1761
1762     setGraphicObjectProperty(legend, __GO_LINKS__, links.data(), jni_int_vector, static_cast<int>(links.size()));
1763 }
1764
1765 static bool getHandleBoolProperty(int uid, int prop, int* data)
1766 {
1767     int val = 0;
1768     int* pVal = &val;
1769     getGraphicObjectProperty(uid, prop, jni_bool, (void **)&pVal);
1770     if (pVal == nullptr)
1771     {
1772         return false;
1773     }
1774
1775     *data = val;
1776     return true;
1777 }
1778
1779 static bool getHandleIntProperty(int uid, int prop, int* data)
1780 {
1781     int val = 0;
1782     int* pVal = &val;
1783     getGraphicObjectProperty(uid, prop, jni_int, (void **)&pVal);
1784     if (pVal == nullptr)
1785     {
1786         return false;
1787     }
1788
1789     *data = val;
1790     return true;
1791 }
1792
1793 static bool getHandleDoubleProperty(int uid, int prop, double* data)
1794 {
1795     double val = 0;
1796     double* pVal = &val;
1797     getGraphicObjectProperty(uid, prop, jni_double, (void **)&pVal);
1798     if (pVal == nullptr)
1799     {
1800         return false;
1801     }
1802
1803     *data = val;
1804     return true;
1805 }
1806
1807 static void getHandleStringProperty(int uid, int prop, char** str)
1808 {
1809     getGraphicObjectProperty(uid, prop, jni_string, (void **)str);
1810 }
1811
1812
1813 static void getHandleBoolVectorProperty(int uid, int prop, int** vals)
1814 {
1815     getGraphicObjectProperty(uid, prop, jni_bool_vector, (void **)vals);
1816 }
1817
1818 static void getHandleIntVectorProperty(int uid, int prop, int** vals)
1819 {
1820     getGraphicObjectProperty(uid, prop, jni_int_vector, (void **)vals);
1821 }
1822
1823 static void getHandleDoubleVectorProperty(int uid, int prop, double** vals)
1824 {
1825     getGraphicObjectProperty(uid, prop, jni_double_vector, (void **)vals);
1826 }
1827
1828 static void getHandleStringVectorProperty(int uid, int prop, char*** vals)
1829 {
1830     getGraphicObjectProperty(uid, prop, jni_string_vector, (void **)vals);
1831 }
1832
1833 static bool export_handle_generic(int parent, int uid, const HandleProp& props);
1834 static bool export_handle_layout_options(int parent, int uid);
1835 static bool export_handle_userdata(int parent, int uid);
1836 static bool export_handle_tag(int parent, int uid);
1837 static bool export_handle_figure(int parent, int uid);
1838 static bool export_handle_axes(int parent, int uid);
1839 static bool export_handle_label(int parent, int uid);
1840 static bool export_handle_champ(int parent, int uid);
1841 static bool export_handle_children(int parent, int uid);
1842
1843 static bool export_handle_generic(int parent, int uid, const HandleProp& props)
1844 {
1845     for (auto & prop : props)
1846     {
1847         const char* name = prop.first.data();
1848         std::vector<int> info(prop.second);
1849
1850         //scalar variable
1851         if (info.size() == 3)
1852         {
1853             int go = info[1];
1854             int type = info[2];
1855
1856             switch (type)
1857             {
1858                 case jni_bool:
1859                 {
1860                     std::vector<int> dims = {1, 1};
1861                     int val = 0;
1862                     getHandleBoolProperty(uid, go, &val);
1863                     writeBooleanMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), &val);
1864                     break;
1865                 }
1866                 case jni_double:
1867                 {
1868                     std::vector<int> dims = {1, 1};
1869                     double val = 0;
1870                     getHandleDoubleProperty(uid, go, &val);
1871                     writeDoubleMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), &val);
1872                     break;
1873                 }
1874                 case jni_int:
1875                 {
1876                     std::vector<int> dims = {1, 1};
1877                     int val = 0;
1878                     getHandleIntProperty(uid, go, &val);
1879                     writeIntegerMatrix6(parent, name, H5T_NATIVE_INT32, "32", static_cast<int>(dims.size()), dims.data(), &val);
1880                     break;
1881                 }
1882                 case jni_string:
1883                 {
1884                     std::vector<int> dims = {1, 1};
1885                     char* val;
1886                     getHandleStringProperty(uid, go, &val);
1887                     writeStringMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), &val);
1888                     releaseGraphicObjectProperty(go, val, jni_string, 1);
1889                     break;
1890                 }
1891             }
1892         }
1893         else //vector variable
1894         {
1895             int go = info[1];
1896             int type = info[2];
1897             int row = info[3];
1898             int col = info.size() > 3 ? info[4] : -1;
1899
1900             if (row < 0)
1901             {
1902                 row = -row;
1903             }
1904             else
1905             {
1906                 getHandleIntProperty(uid, row, &row);
1907             }
1908
1909             if (col < 0)
1910             {
1911                 col = -col;
1912             }
1913             else
1914             {
1915                 getHandleIntProperty(uid, col, &col);
1916             }
1917
1918             switch (type)
1919             {
1920                 case jni_bool_vector:
1921                 {
1922                     std::vector<int> dims = {row, col};
1923                     int* vals;
1924                     getHandleBoolVectorProperty(uid, go, &vals);
1925                     writeBooleanMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), vals);
1926                     releaseGraphicObjectProperty(go, vals, jni_bool_vector, row * col);
1927                     break;
1928                 }
1929                 case jni_double_vector:
1930                 {
1931                     std::vector<int> dims = {row, col};
1932                     double* vals;
1933                     getHandleDoubleVectorProperty(uid, go, &vals);
1934                     writeDoubleMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), vals);
1935                     releaseGraphicObjectProperty(go, vals, jni_double_vector, row * col);
1936                     break;
1937                 }
1938                 case jni_int_vector:
1939                 {
1940                     std::vector<int> dims = {row, col};
1941                     int* vals;
1942                     getHandleIntVectorProperty(uid, go, &vals);
1943                     writeIntegerMatrix6(parent, name, H5T_NATIVE_INT32, "32", static_cast<int>(dims.size()), dims.data(), vals);
1944                     releaseGraphicObjectProperty(go, vals, jni_int_vector, row * col);
1945                     break;
1946                 }
1947                 case jni_string_vector:
1948                 {
1949                     std::vector<int> dims = {row, col};
1950                     char** vals;
1951                     getHandleStringVectorProperty(uid, go, &vals);
1952                     writeStringMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), vals);
1953                     releaseGraphicObjectProperty(go, vals, jni_string_vector, row * col);
1954                     break;
1955                 }
1956                 default:
1957                 {
1958                     break;
1959                 }
1960             }
1961         }
1962     }
1963
1964     //user_data
1965     export_handle_userdata(parent, uid);
1966     //tag
1967     export_handle_tag(parent, uid);
1968     //children
1969     export_handle_children(parent, uid);
1970     return true;
1971 }
1972
1973 static bool export_handle_layout_options(int parent, int uid)
1974 {
1975     int layout_type = 0;
1976     getHandleIntProperty(uid, __GO_LAYOUT__, &layout_type);
1977     if (layout_type == 0 || layout_type == 1) //LAYOUT_NONE or LAYOUT_GRIDBAG
1978     {
1979         //nothing to save
1980         return true;
1981     }
1982
1983     int layout = openList6(parent, "layout_options", g_SCILAB_CLASS_HANDLE);
1984
1985     switch (layout_type)
1986     {
1987         case 2: //grid
1988         {
1989             std::vector<int> dims = {1, 2};
1990             int* grid = nullptr;
1991             getHandleIntVectorProperty(uid, __GO_GRID_OPT_GRID__, &grid);
1992             writeIntegerMatrix6(layout, "grid", H5T_NATIVE_INT32, "32", 2, dims.data(), grid);
1993             releaseGraphicObjectProperty(__GO_GRID_OPT_GRID__, grid, jni_int_vector, 2);
1994
1995             int* pad = nullptr;
1996             getHandleIntVectorProperty(uid, __GO_GRID_OPT_PADDING__, &pad);
1997             writeIntegerMatrix6(layout, "padding", H5T_NATIVE_INT32, "32", 2, dims.data(), pad);
1998             releaseGraphicObjectProperty(__GO_GRID_OPT_PADDING__, pad, jni_int_vector, 2);
1999             break;
2000         }
2001         case 3: //border
2002         {
2003             std::vector<int> dims = {1, 2};
2004             int* pad = nullptr;
2005             getHandleIntVectorProperty(uid, __GO_BORDER_OPT_PADDING__, &pad);
2006             writeIntegerMatrix6(layout, "padding", H5T_NATIVE_INT32, "32", 2, dims.data(), pad);
2007             releaseGraphicObjectProperty(__GO_BORDER_OPT_PADDING__, pad, jni_int_vector, 2);
2008             break;
2009         }
2010     }
2011
2012     closeList6(layout);
2013
2014     return true;
2015 }
2016 static bool export_handle_tag(int parent, int uid)
2017 {
2018     char* tag = nullptr;
2019     getHandleStringProperty(uid, __GO_TAG__, &tag);
2020     int dims[2];
2021     dims[0] = 1;
2022     dims[1] = 1;
2023     writeStringMatrix6(parent, "tag", 2, dims, &tag);
2024     releaseGraphicObjectProperty(__GO_TAG__, tag, jni_string, 1);
2025     return true;
2026 }
2027
2028 static bool export_handle_userdata(int parent, int uid)
2029 {
2030
2031     int size = 0;
2032     getHandleIntProperty(uid, __GO_USER_DATA_SIZE__, &size);
2033
2034     if (size == 0)
2035     {
2036         std::vector<int> dims = {0, 0};
2037         writeDoubleMatrix6(parent, "userdata", 2, dims.data(), NULL);
2038     }
2039     else
2040     {
2041         int *data = NULL;
2042         getHandleIntVectorProperty(uid, __GO_USER_DATA__, &data);
2043
2044         types::InternalType* pUD = nullptr;
2045         if (size == 1)
2046         {
2047             //32 bits
2048             int* p = (int*)data;
2049             pUD = ((types::InternalType*) * p);
2050         }
2051         else
2052         {
2053             //64 bits
2054             long long* p = (long long*)data;
2055             pUD = ((types::InternalType*) * p);
2056         }
2057
2058         export_data(parent, "userdata", pUD);
2059         //do not release, data is a reference on data in model
2060         //releaseGraphicObjectProperty(__GO_USER_DATA__, data, jni_int_vector, size);
2061     }
2062
2063     return true;
2064 }
2065
2066 static bool export_handle_datatips(int parent, int uid)
2067 {
2068     int count = 0;
2069     getHandleIntProperty(uid, __GO_DATATIPS_COUNT__, &count);
2070     int node = openList6(parent, "datatips", g_SCILAB_CLASS_HANDLE);
2071     int* datatips = nullptr;
2072
2073     if (count != 0)
2074     {
2075         getHandleIntVectorProperty(uid, __GO_DATATIPS__, &datatips);
2076     }
2077
2078     for (int i = 0; i < count; ++i)
2079     {
2080         if (export_handle(node, std::to_string(i), datatips[i]) == false)
2081         {
2082             releaseGraphicObjectProperty(__GO_DATATIPS__, datatips, jni_int_vector, count);
2083             closeList6(node);
2084             return false;
2085         }
2086     }
2087
2088     releaseGraphicObjectProperty(__GO_DATATIPS__, datatips, jni_int_vector, count);
2089     closeList6(node);
2090     return true;
2091 }
2092
2093 static bool export_handle_border(int dataset, int uid);
2094
2095 static bool export_handle_border_none(int dataset, int uid)
2096 {
2097     //nothing to do
2098     closeList6(dataset);
2099     return true;
2100 }
2101
2102 static bool export_handle_border_line(int dataset, int uid)
2103 {
2104     bool ret = false;
2105     int dims[2];
2106     dims[0] = 1;
2107     dims[1] = 1;
2108
2109     //color
2110     char* color = nullptr;
2111     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_COLOR__, &color);
2112     writeStringMatrix6(dataset, "color", 2, dims, &color);
2113     releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_COLOR__, color, jni_string, 1);
2114
2115     //thickness
2116     int thickness = 0;
2117     ret = getHandleIntProperty(uid, __GO_LINE_THICKNESS__, &thickness);
2118     if (ret)
2119     {
2120         writeIntegerMatrix6(dataset, "thickness", H5T_NATIVE_INT32, "32", 2, dims, &thickness);
2121     }
2122
2123     //rounded
2124     int rounded = 0;
2125     ret = getHandleBoolProperty(uid, __GO_UI_FRAME_BORDER_ROUNDED__, &rounded);
2126     if (ret)
2127     {
2128         writeBooleanMatrix6(dataset, "rounded", 2, dims, &rounded);
2129     }
2130
2131     closeList6(dataset);
2132     return true;
2133 }
2134
2135 static bool export_handle_border_bevel(int dataset, int uid)
2136 {
2137     bool ret = false;
2138     int dims[2];
2139     dims[0] = 1;
2140     dims[1] = 1;
2141     char* data = nullptr;
2142
2143     //type
2144     int type = 0;
2145     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_TYPE__, &type);
2146     if (ret)
2147     {
2148         writeIntegerMatrix6(dataset, "type", H5T_NATIVE_INT32, "32", 2, dims, &type);
2149     }
2150
2151     //highlight out
2152     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, &data);
2153     if (data)
2154     {
2155         writeStringMatrix6(dataset, "highlight_out", 2, dims, &data);
2156         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, data, jni_string, 1);
2157     }
2158
2159     //highlight in
2160     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_HIGHLIGHT_IN__, &data);
2161     if (data)
2162     {
2163         writeStringMatrix6(dataset, "highlight_in", 2, dims, &data);
2164         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_HIGHLIGHT_IN__, data, jni_string, 1);
2165     }
2166
2167     //shadow out
2168     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_SHADOW_OUT__, &data);
2169     if (data)
2170     {
2171         writeStringMatrix6(dataset, "shadow_out", 2, dims, &data);
2172         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_SHADOW_OUT__, data, jni_string, 1);
2173     }
2174
2175     //shadow in
2176     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_SHADOW_IN__, &data);
2177     if (data)
2178     {
2179         writeStringMatrix6(dataset, "shadow_in", 2, dims, &data);
2180         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_SHADOW_IN__, data, jni_string, 1);
2181     }
2182     closeList6(dataset);
2183     return true;
2184 }
2185
2186 static bool export_handle_border_soft_bevel(int dataset, int uid)
2187 {
2188     return export_handle_border_bevel(dataset, uid);
2189 }
2190
2191 static bool export_handle_border_etched(int dataset, int uid)
2192 {
2193     bool ret = false;
2194     int dims[2];
2195     dims[0] = 1;
2196     dims[1] = 1;
2197     char* data = nullptr;
2198
2199     //type
2200     int type = 0;
2201     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_TYPE__, &type);
2202     if (ret)
2203     {
2204         writeIntegerMatrix6(dataset, "type", H5T_NATIVE_INT32, "32", 2, dims, &type);
2205     }
2206
2207     //highlight out
2208     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, &data);
2209     if (data)
2210     {
2211         writeStringMatrix6(dataset, "highlight_out", 2, dims, &data);
2212         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, data, jni_string, 1);
2213     }
2214
2215     //shadow out
2216     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_SHADOW_OUT__, &data);
2217     if (data)
2218     {
2219         writeStringMatrix6(dataset, "shadow_out", 2, dims, &data);
2220         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_SHADOW_OUT__, data, jni_string, 1);
2221     }
2222
2223     closeList6(dataset);
2224     return true;
2225 }
2226
2227 static bool export_handle_border_titled(int dataset, int uid)
2228 {
2229     bool ret = false;
2230     int dims[2];
2231     dims[0] = 1;
2232     dims[1] = 1;
2233     char* data = nullptr;
2234
2235     //title_border
2236     int title = 0;
2237     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_TITLE__, &title);
2238     if (ret)
2239     {
2240         int node = openList6(dataset, "title_border", g_SCILAB_CLASS_HANDLE);
2241         export_handle_border(node, title);
2242     }
2243
2244     //title
2245     getHandleStringProperty(uid, __GO_TITLE__, &data);
2246     if (data)
2247     {
2248         writeStringMatrix6(dataset, "title", 2, dims, &data);
2249         releaseGraphicObjectProperty(__GO_TITLE__, data, jni_string, 1);
2250     }
2251
2252     //justification
2253     int justification = 0;
2254     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_JUSTIFICATION__, &justification);
2255     if (ret)
2256     {
2257         writeIntegerMatrix6(dataset, "justification", H5T_NATIVE_INT32, "32", 2, dims, &justification);
2258     }
2259
2260     //fontname
2261     getHandleStringProperty(uid, __GO_UI_FONTNAME__, &data);
2262     if (data)
2263     {
2264         writeStringMatrix6(dataset, "fontname", 2, dims, &data);
2265         releaseGraphicObjectProperty(__GO_UI_FONTNAME__, data, jni_string, 1);
2266         data = nullptr;
2267     }
2268
2269     //fontangle
2270     getHandleStringProperty(uid, __GO_UI_FONTANGLE__, &data);
2271     if (data)
2272     {
2273         writeStringMatrix6(dataset, "fontangle", 2, dims, &data);
2274         releaseGraphicObjectProperty(__GO_UI_FONTANGLE__, data, jni_string, 1);
2275         data = nullptr;
2276     }
2277
2278     //fontsize
2279     int fonsize = 0;
2280     ret = getHandleIntProperty(uid, __GO_UI_FONTSIZE__, &fonsize);
2281     if (ret)
2282     {
2283         writeIntegerMatrix6(dataset, "fontsize", H5T_NATIVE_INT32, "32", 2, dims, &fonsize);
2284     }
2285
2286     //fontweight
2287     getHandleStringProperty(uid, __GO_UI_FONTWEIGHT__, &data);
2288     if (data)
2289     {
2290         writeStringMatrix6(dataset, "fontweight", 2, dims, &data);
2291         releaseGraphicObjectProperty(__GO_UI_FONTWEIGHT__, data, jni_string, 1);
2292         data = nullptr;
2293     }
2294
2295     //position
2296     int position = 0;
2297     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_POSITION__, &position);
2298     if (ret)
2299     {
2300         writeIntegerMatrix6(dataset, "position", H5T_NATIVE_INT32, "32", 2, dims, &position);
2301     }
2302
2303     //color
2304     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_COLOR__, &data);
2305     if (data)
2306     {
2307         writeStringMatrix6(dataset, "color", 2, dims, &data);
2308         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_COLOR__, data, jni_string, 1);
2309         data = nullptr;
2310     }
2311
2312     closeList6(dataset);
2313     return true;
2314 }
2315
2316 static bool export_handle_border_empty(int dataset, int uid)
2317 {
2318     int dims[2];
2319     dims[0] = 1;
2320     dims[1] = 4;
2321     double* pos = nullptr;
2322
2323     //position
2324     getHandleDoubleVectorProperty(uid, __GO_POSITION__, &pos);
2325     if (pos)
2326     {
2327         writeDoubleMatrix6(dataset, "position", 2, dims, pos);
2328         releaseGraphicObjectProperty(__GO_POSITION__, pos, jni_double_vector, 4);
2329     }
2330
2331     closeList6(dataset);
2332     return true;
2333 }
2334
2335 static bool export_handle_border_compound(int dataset, int uid)
2336 {
2337     bool ret = false;
2338     //out_border
2339     int out_border = 0;
2340
2341     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_OUT_BORDER__, &out_border);
2342     if (ret)
2343     {
2344         int node = openList6(dataset, "out_border", g_SCILAB_CLASS_HANDLE);
2345         export_handle_border(node, out_border);
2346
2347         //title_border
2348         int in_border = 0;
2349         getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_IN_BORDER__, &in_border);
2350         node = openList6(dataset, "in_border", g_SCILAB_CLASS_HANDLE);
2351         export_handle_border(node, in_border);
2352     }
2353
2354     closeList6(dataset);
2355     return true;
2356 }
2357
2358 static bool export_handle_border_matte(int dataset, int uid)
2359 {
2360     int dims[2];
2361     dims[0] = 1;
2362     dims[1] = 4;
2363     char* data = nullptr;
2364     double* pos = nullptr;
2365
2366     //position
2367     dims[0] = 1;
2368     dims[1] = 4;
2369     getHandleDoubleVectorProperty(uid, __GO_POSITION__, &pos);
2370     writeDoubleMatrix6(dataset, "position", 2, dims, pos);
2371     releaseGraphicObjectProperty(__GO_POSITION__, pos, jni_double_vector, 4);
2372
2373     //color
2374     dims[0] = 1;
2375     dims[1] = 1;
2376     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_COLOR__, &data);
2377     writeStringMatrix6(dataset, "color", 2, dims, &data);
2378     releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_COLOR__, data, jni_string, 1);
2379
2380     closeList6(dataset);
2381     return true;
2382 }
2383
2384 static bool export_handle_border(int dataset, int uid)
2385 {
2386     int style = 0;
2387     getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_STYLE__, &style);
2388     int dims[2];
2389     dims[0] = 1;
2390     dims[1] = 1;
2391
2392     writeIntegerMatrix6(dataset, "style", H5T_NATIVE_INT32, "32", 2, dims, &style);
2393
2394     switch (style)
2395     {
2396         default:
2397         case NONE:
2398             return export_handle_border_none(dataset, uid);
2399         case LINE:
2400             return export_handle_border_line(dataset, uid);
2401         case BEVEL:
2402             return export_handle_border_bevel(dataset, uid);
2403         case SOFTBEVEL:
2404             return export_handle_border_soft_bevel(dataset, uid);
2405         case ETCHED:
2406             return export_handle_border_etched(dataset, uid);
2407         case TITLED:
2408             return export_handle_border_titled(dataset, uid);
2409         case EMPTY:
2410             return export_handle_border_empty(dataset, uid);
2411         case COMPOUND:
2412             return export_handle_border_compound(dataset, uid);
2413         case MATTE:
2414             return export_handle_border_matte(dataset, uid);
2415     }
2416 }
2417
2418 static bool export_handle_uicontrol(int parent, int uid)
2419 {
2420     bool ret = false;
2421     if (export_handle_generic(parent, uid, UicontrolHandle::getPropertyList()) == false)
2422     {
2423         return false;
2424     }
2425
2426     //string
2427     int size = 0;
2428     getHandleIntProperty(uid, __GO_UI_STRING_SIZE__, &size);
2429     int col = 0;
2430     getHandleIntProperty(uid, __GO_UI_STRING_COLNB__, &col);
2431
2432     int dims[2];
2433
2434     if (col == 0)
2435     {
2436         dims[0] = 1;
2437         dims[1] = 1;
2438         char* empty = "";
2439         writeStringMatrix6(parent, "string", 2, dims, &empty);
2440
2441     }
2442     else
2443     {
2444         int row = size / col;
2445         dims[0] = row;
2446         dims[1] = col;
2447         char** string = nullptr;
2448         getHandleStringVectorProperty(uid, __GO_UI_STRING__, &string);
2449         writeStringMatrix6(parent, "string", 2, dims, string);
2450         releaseGraphicObjectProperty(__GO_UI_STRING__, string, jni_string_vector, size);
2451     }
2452
2453     //border
2454     int border = 0;
2455     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER__, &border);
2456     if (ret)
2457     {
2458         int ub = openList6(parent, "border", g_SCILAB_CLASS_HANDLE);
2459         export_handle_border(ub, border);
2460     }
2461
2462     closeList6(parent);
2463     return true;
2464 }
2465
2466
2467 static bool export_handle_uicontextmenu(int parent, int uid)
2468 {
2469     if (export_handle_generic(parent, uid, UicontextmenuHandle::getPropertyList()) == false)
2470     {
2471         return false;
2472     }
2473
2474     closeList6(parent);
2475     return true;
2476 }
2477
2478 static bool export_handle_uimenu(int parent, int uid)
2479 {
2480     if (export_handle_generic(parent, uid, UimenuHandle::getPropertyList()) == false)
2481     {
2482         return false;
2483     }
2484
2485     closeList6(parent);
2486     return true;
2487 }
2488
2489 static bool export_handle_light(int parent, int uid)
2490 {
2491     if (export_handle_generic(parent, uid, LightHandle::getPropertyList()) == false)
2492     {
2493         return false;
2494     }
2495
2496     closeList6(parent);
2497     return true;
2498 }
2499
2500 static bool export_handle_axis(int parent, int uid)
2501 {
2502     if (export_handle_generic(parent, uid, AxisHandle::getPropertyList()) == false)
2503     {
2504         return false;
2505     }
2506
2507     closeList6(parent);
2508     return true;
2509 }
2510
2511 static bool export_handle_text(int parent, int uid)
2512 {
2513     if (export_handle_generic(parent, uid, TextHandle::getPropertyList()) == false)
2514     {
2515         return false;
2516     }
2517
2518     //text
2519     int* dims = nullptr;
2520     getHandleIntVectorProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, &dims);
2521     char** text;
2522     getHandleStringVectorProperty(uid, __GO_TEXT_STRINGS__, &text);
2523     writeStringMatrix6(parent, "text", 2, dims, text);
2524     closeList6(parent);
2525     return true;
2526 }
2527
2528 //find parent axes of a entity and return path ( via children index )
2529 bool get_entity_path(int entity, std::vector<int>& path)
2530 {
2531     path.clear();
2532
2533     while (true)
2534     {
2535         int parent = 0;
2536         getHandleIntProperty(entity, __GO_PARENT__, &parent);
2537         int count = 0;
2538         getHandleIntProperty(parent, __GO_CHILDREN_COUNT__, &count);
2539         //get children of parent to find "my" index
2540         int* children = nullptr;
2541         getHandleIntVectorProperty(parent, __GO_CHILDREN__, &children);
2542         bool find = false;
2543         for (int i = 0; i < count; ++i)
2544         {
2545             if (children[i] == entity)
2546             {
2547                 path.push_back(i);
2548                 find = true;
2549                 break;
2550             }
2551         }
2552
2553         releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
2554         if (find == false)
2555         {
2556             return false;
2557         }
2558
2559         int type = 0;
2560         getHandleIntProperty(parent, __GO_TYPE__, &type);
2561         if (type == __GO_AXES__)
2562         {
2563             break;
2564         }
2565
2566         entity = parent;
2567     }
2568
2569     return true;
2570 }
2571
2572 static bool export_handle_legend(int parent, int uid)
2573 {
2574     if (export_handle_generic(parent, uid, LegendHandle::getPropertyList()) == false)
2575     {
2576         return false;
2577     }
2578
2579     //links
2580     int node = openList6(parent, "links", g_SCILAB_CLASS_HANDLE);
2581     int link = 0;
2582     getHandleIntProperty(uid, __GO_LINKS_COUNT__, &link);
2583     int* links = nullptr;
2584     getHandleIntVectorProperty(uid, __GO_LINKS__, &links);
2585     for (int i = 0; i < link; ++i)
2586     {
2587         std::vector<int> path;
2588         if (get_entity_path(links[i], path))
2589         {
2590             int dims[2];
2591             dims[0] = 1;
2592             dims[1] = static_cast<int>(path.size());
2593             writeIntegerMatrix6(node, std::to_string(i).data(), H5T_NATIVE_INT32, "32", 2, dims, path.data());
2594         }
2595     }
2596
2597     releaseGraphicObjectProperty(__GO_LINKS__, links, jni_int_vector, link);
2598     closeList6(node);
2599
2600     //text
2601     int* dims = nullptr;
2602     getHandleIntVectorProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, &dims);
2603     char** text;
2604     getHandleStringVectorProperty(uid, __GO_TEXT_STRINGS__, &text);
2605     writeStringMatrix6(parent, "text", 2, dims, text);
2606     closeList6(parent);
2607     return true;
2608 }
2609
2610 static bool export_handle_fec(int parent, int uid)
2611 {
2612     if (export_handle_generic(parent, uid, FecHandle::getPropertyList()) == false)
2613     {
2614         return false;
2615     }
2616
2617     //triangles
2618     int indices = 0;
2619     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_INDICES__, &indices);
2620     int vect = 0;
2621     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_VERTICES_BY_ELEM__, &vect);
2622     double* triangles = nullptr;
2623     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_FEC_ELEMENTS__, &triangles);
2624
2625     int dims[2];
2626     dims[0] = indices;
2627     dims[1] = vect + 2;
2628     writeDoubleMatrix6(parent, "triangles", 2, dims, triangles);
2629     releaseGraphicObjectProperty(__GO_DATA_MODEL_FEC_ELEMENTS__, triangles, jni_double_vector, dims[0] * dims[1]);
2630
2631     closeList6(parent);
2632     return true;
2633 }
2634
2635 static bool export_handle_matplot(int parent, int uid)
2636 {
2637     if (export_handle_generic(parent, uid, MatplotHandle::getPropertyList()) == false)
2638     {
2639         return false;
2640     }
2641
2642     int row = 0;
2643     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_X__, &row);
2644     int col = 0;
2645     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_Y__, &col);
2646     int datatype = 0;
2647     getHandleIntProperty(uid, __GO_DATA_MODEL_MATPLOT_DATA_TYPE__, &datatype);
2648     int imagetype = 0;
2649     getHandleIntProperty(uid, __GO_DATA_MODEL_MATPLOT_IMAGE_TYPE__, &imagetype);
2650     int size = (row - 1) * (col - 1);
2651
2652     //data can be char, uchar, short, ushort, ... hide in a double*
2653     //save double like this but need to compute exact dimensions to
2654     //store it
2655
2656     double* data = nullptr;
2657     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &data);
2658
2659     switch (datatype)
2660     {
2661         case MATPLOT_Char:
2662         case MATPLOT_HM1_Char:
2663         case MATPLOT_HM1_UChar:
2664             size /= (sizeof(double) / sizeof(char));
2665             break;
2666         case MATPLOT_HM3_Char:
2667         case MATPLOT_HM3_UChar:
2668             size /= (sizeof(double) / sizeof(char));
2669             size *= 3;
2670             break;
2671
2672         case MATPLOT_HM3_Double:
2673             size *= 3;
2674             break;
2675         case MATPLOT_HM4_Char:
2676         case MATPLOT_HM4_UChar:
2677             size /= (sizeof(double) / sizeof(char));
2678             size *= 4;
2679             break;
2680         case MATPLOT_HM4_Double:
2681             size *= 4;
2682             break;
2683         case MATPLOT_UChar:
2684             size /= (sizeof(double) / sizeof(char));
2685             if ((ImageType)imagetype == MATPLOT_RGB)
2686             {
2687                 size *= 3;
2688             }
2689             else if ((GLType)imagetype == MATPLOT_GL_RGBA)
2690             {
2691                 size *= 4;
2692             }
2693             break;
2694         case MATPLOT_Int:
2695         case MATPLOT_UInt:
2696             size /= (sizeof(double) / sizeof(int));
2697             break;
2698         case MATPLOT_Short:
2699         case MATPLOT_UShort:
2700             size /= (sizeof(double) / sizeof(short));
2701             break;
2702         case MATPLOT_Double:
2703         case MATPLOT_HM1_Double:
2704         default:
2705             break;
2706     }
2707
2708     int dims[2];
2709     dims[0] = 1;
2710     dims[1] = size;
2711
2712     writeDoubleMatrix6(parent, "data", 2, dims, data);
2713     releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, data, jni_double_vector, size);
2714     closeList6(parent);
2715     return true;
2716 }
2717
2718 static bool export_handle_grayplot(int parent, int uid)
2719 {
2720     if (export_handle_generic(parent, uid, GrayplotHandle::getPropertyList()) == false)
2721     {
2722         return false;
2723     }
2724
2725     int row = 0;
2726     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_X__, &row);
2727     int col = 0;
2728     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_Y__, &col);
2729
2730     double* dataX = nullptr;
2731     double* dataY = nullptr;
2732     double* dataZ = nullptr;
2733
2734     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
2735     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
2736     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
2737
2738     int dims[2];
2739     dims[0] = 1;
2740     dims[1] = row;
2741     writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
2742
2743     dims[0] = 1;
2744     dims[1] = col;
2745     writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
2746
2747     dims[0] = row;
2748     dims[1] = col;
2749     writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
2750
2751     closeList6(parent);
2752     return true;
2753 }
2754
2755 static bool export_handle_segs(int parent, int uid)
2756 {
2757     if (export_handle_generic(parent, uid, SegsHandle::getPropertyList()) == false)
2758     {
2759         return false;
2760     }
2761
2762     closeList6(parent);
2763     return true;
2764 }
2765
2766 static bool export_handle_arc(int parent, int uid)
2767 {
2768     if (export_handle_generic(parent, uid, ArcHandle::getPropertyList()) == false)
2769     {
2770         return false;
2771     }
2772
2773     closeList6(parent);
2774     return true;
2775 }
2776
2777 static bool export_handle_rectangle(int parent, int uid)
2778 {
2779     if (export_handle_generic(parent, uid, RectangleHandle::getPropertyList()) == false)
2780     {
2781         return false;
2782     }
2783
2784     closeList6(parent);
2785     return true;
2786 }
2787
2788 static bool export_handle_datatip(int parent, int uid)
2789 {
2790     if (export_handle_generic(parent, uid, DatatipHandle::getPropertyList()) == false)
2791     {
2792         return false;
2793     }
2794
2795     closeList6(parent);
2796     return true;
2797 }
2798
2799 static bool export_handle_polyline_shift(int parent, int uid, const std::string& name, int go_set, int go_data)
2800 {
2801     int set = 0;
2802     getHandleBoolProperty(uid, go_set, &set);
2803     if (set)
2804     {
2805         int count = 0;
2806         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_ELEMENTS__, &count);
2807         double* data = nullptr;
2808         getHandleDoubleVectorProperty(uid, go_data, &data);
2809
2810         int dims[2];
2811         dims[0] = 1;
2812         dims[1] = count;
2813         writeDoubleMatrix6(parent, name.data(), 2, dims, data);
2814
2815         releaseGraphicObjectProperty(uid, data, jni_double_vector, count);
2816     }
2817     else
2818     {
2819         int dims[2];
2820         dims[0] = 0;
2821         dims[1] = 0;
2822         writeDoubleMatrix6(parent, name.data(), 2, dims, NULL);
2823     }
2824
2825     return true;
2826 }
2827
2828 static bool export_handle_polyline(int parent, int uid)
2829 {
2830     if (export_handle_datatips(parent, uid) == false)
2831     {
2832         return false;
2833     }
2834
2835     if (export_handle_generic(parent, uid, PolylineHandle::getPropertyList()) == false)
2836     {
2837         return false;
2838     }
2839
2840     //x_shift
2841     export_handle_polyline_shift(parent, uid, "x_shift", __GO_DATA_MODEL_X_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_X_COORDINATES_SHIFT__);
2842     //y_shift
2843     export_handle_polyline_shift(parent, uid, "y_shift", __GO_DATA_MODEL_Y_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Y_COORDINATES_SHIFT__);
2844     //z_shift
2845     export_handle_polyline_shift(parent, uid, "z_shift", __GO_DATA_MODEL_Z_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Z_COORDINATES_SHIFT__);
2846
2847     //interp_color_vector
2848     int set = 0;
2849     getHandleBoolProperty(uid, __GO_INTERP_COLOR_VECTOR_SET__, &set);
2850     if (set)
2851     {
2852         int count = 0;
2853         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_ELEMENTS__, &count);
2854         int* data = nullptr;
2855         getHandleIntVectorProperty(uid, __GO_INTERP_COLOR_VECTOR__, &data);
2856
2857         int dims[2];
2858         dims[0] = 1;
2859         dims[1] = count;
2860         writeIntegerMatrix6(parent, "interp_color_vector", H5T_NATIVE_INT32, "32", 2, dims, data);
2861         releaseGraphicObjectProperty(uid, data, jni_int_vector, count);
2862     }
2863     else
2864     {
2865         int dims[2];
2866         dims[0] = 0;
2867         dims[1] = 0;
2868         writeIntegerMatrix6(parent, "interp_color_vector", H5T_NATIVE_INT32, "32", 2, dims, NULL);
2869     }
2870
2871     //data
2872     int count = 0;
2873     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_ELEMENTS__, &count);
2874
2875     int dims[2];
2876     dims[0] = 1;
2877     dims[1] = count;
2878
2879     double* dataX = nullptr;
2880     double* dataY = nullptr;
2881     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
2882     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
2883
2884     writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
2885     writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
2886
2887     releaseGraphicObjectProperty(__GO_DATA_MODEL_X__, dataX, jni_double_vector, count);
2888     releaseGraphicObjectProperty(__GO_DATA_MODEL_Y__, dataY, jni_double_vector, count);
2889
2890     getHandleIntProperty(uid, __GO_DATA_MODEL_Z_COORDINATES_SET__, &set);
2891     if (set)
2892     {
2893         double* dataZ = nullptr;
2894         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
2895         writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
2896         releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, dataZ, jni_double_vector, count);
2897     }
2898     else
2899     {
2900         //[]
2901         dims[0] = 0;
2902         dims[1] = 0;
2903         writeDoubleMatrix6(parent, "data_z", 2, dims, NULL);
2904     }
2905
2906     closeList6(parent);
2907     return true;
2908 }
2909
2910 static bool export_handle_surface(int parent, int uid)
2911 {
2912     return export_handle_generic(parent, uid, SurfaceHandle::getPropertyList());
2913 }
2914
2915 static bool export_handle_plot3d(int parent, int uid)
2916 {
2917     bool ret = export_handle_surface(parent, uid);
2918     if (ret)
2919     {
2920         double* colors = NULL;
2921         double* dataX = NULL;
2922         double* dataY = NULL;
2923         double* dataZ = NULL;
2924
2925         //data
2926         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
2927         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
2928         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
2929
2930         int row = 0;
2931         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_X__, &row);
2932         int col = 0;
2933         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_Y__, &col);
2934
2935         int* xDims = nullptr;
2936         int* yDims = nullptr;
2937         getHandleIntVectorProperty(uid, __GO_DATA_MODEL_X_DIMENSIONS__, &xDims);
2938         getHandleIntVectorProperty(uid, __GO_DATA_MODEL_Y_DIMENSIONS__, &yDims);
2939
2940         int dims[2];
2941         dims[0] = xDims[0];
2942         dims[1] = xDims[1];
2943         writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
2944         releaseGraphicObjectProperty(__GO_DATA_MODEL_X__, dataX, jni_double_vector, dims[0] * dims[1]);
2945
2946         dims[0] = yDims[0];
2947         dims[1] = yDims[1];
2948         writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
2949         releaseGraphicObjectProperty(__GO_DATA_MODEL_Y__, dataY, jni_double_vector, dims[0] * dims[1]);
2950
2951         dims[0] = row;
2952         dims[1] = col;
2953         writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
2954         releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, dataZ, jni_double_vector, dims[0] * dims[1]);
2955
2956         releaseGraphicObjectProperty(__GO_DATA_MODEL_X_DIMENSIONS__, xDims, jni_int_vector, 2);
2957         releaseGraphicObjectProperty(__GO_DATA_MODEL_Y_DIMENSIONS__, dataZ, jni_int_vector, 2);
2958     }
2959
2960     closeList6(parent);
2961     return ret;
2962 }
2963
2964 static bool export_handle_fac3d(int parent, int uid)
2965 {
2966     bool ret = export_handle_surface(parent, uid);
2967     if (ret)
2968     {
2969         double* colors = NULL;
2970         double* dataX = NULL;
2971         double* dataY = NULL;
2972         double* dataZ = NULL;
2973
2974         //data
2975         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
2976         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
2977         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
2978
2979         int row = 0;
2980         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_VERTICES_PER_GON__, &row);
2981         int col = 0;
2982         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_GONS__, &col);
2983
2984         int dims[2];
2985         dims[0] = row;
2986         dims[1] = col;
2987
2988         writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
2989         writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
2990         writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
2991
2992         releaseGraphicObjectProperty(__GO_DATA_MODEL_X__, dataX, jni_double_vector, dims[0] * dims[1]);
2993         releaseGraphicObjectProperty(__GO_DATA_MODEL_Y__, dataY, jni_double_vector, dims[0] * dims[1]);
2994         releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, dataZ, jni_double_vector, dims[0] * dims[1]);
2995
2996         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_COLORS__, &colors);
2997         if (colors)
2998         {
2999             int numColors = 0;
3000             getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_COLORS__, &numColors);
3001             if (numColors == col)
3002             {
3003                 dims[0] = 1;
3004             }
3005             else
3006             {
3007                 dims[0] = row;
3008             }
3009
3010             dims[1] = col;
3011         }
3012         else
3013         {
3014             //export []
3015             dims[0] = 0;
3016             dims[1] = 0;
3017         }
3018
3019         writeDoubleMatrix6(parent, "colors", 2, dims, colors);
3020         releaseGraphicObjectProperty(__GO_DATA_MODEL_COLORS__, colors, jni_double_vector, dims[0] * dims[1]);
3021
3022         //cdata_mapping
3023         int cdata = 0;
3024         getHandleIntProperty(uid, __GO_DATA_MAPPING__, &cdata);
3025         dims[0] = 1;
3026         dims[1] = 1;
3027         writeIntegerMatrix6(parent, "cdata_mapping", H5T_NATIVE_INT32, "32", 2, dims, &cdata);
3028
3029     }
3030
3031     closeList6(parent);
3032     return ret;
3033 }
3034
3035
3036 static bool export_handle_champ(int parent, int uid)
3037 {
3038     if (export_handle_generic(parent, uid, ChampHandle::getPropertyList()) == false)
3039     {
3040         return false;
3041     }
3042
3043     //data
3044     int* dimensions = NULL;
3045     double* arrowBasesX = NULL;
3046     double* arrowBasesY = NULL;
3047     double* arrowDirectionsX = NULL;
3048     double* arrowDirectionsY = NULL;
3049     int dims[2];
3050     getHandleIntVectorProperty(uid, __GO_CHAMP_DIMENSIONS__, &dimensions);
3051
3052     //base X
3053     getHandleDoubleVectorProperty(uid, __GO_BASE_X__, &arrowBasesX);
3054     dims[0] = 1;
3055     dims[1] = dimensions[0];
3056     writeDoubleMatrix(parent, "base_x", 2, dims, arrowBasesX);
3057     releaseGraphicObjectProperty(__GO_BASE_X__, arrowBasesX, jni_double_vector, dims[1]);
3058
3059     //base y
3060     getHandleDoubleVectorProperty(uid, __GO_BASE_Y__, &arrowBasesY);
3061     dims[0] = 1;
3062     dims[1] = dimensions[1];
3063     writeDoubleMatrix(parent, "base_y", 2, dims, arrowBasesY);
3064     releaseGraphicObjectProperty(__GO_BASE_Y__, arrowBasesY, jni_double_vector, dims[1]);
3065
3066     //direction x
3067     getHandleDoubleVectorProperty(uid, __GO_DIRECTION_X__, &arrowDirectionsX);
3068     dims[0] = dimensions[0];
3069     dims[1] = dimensions[1];
3070     writeDoubleMatrix(parent, "direction_x", 2, dims, arrowDirectionsX);
3071     releaseGraphicObjectProperty(__GO_DIRECTION_X__, arrowDirectionsX, jni_double_vector, dims[0] * dims[1]);
3072
3073     //direction y
3074     getHandleDoubleVectorProperty(uid, __GO_DIRECTION_Y__, &arrowDirectionsY);
3075     dims[0] = dimensions[0];
3076     dims[1] = dimensions[1];
3077     writeDoubleMatrix(parent, "direction_y", 2, dims, arrowDirectionsY);
3078     releaseGraphicObjectProperty(__GO_DIRECTION_Y__, arrowDirectionsY, jni_double_vector, dims[0] * dims[1]);
3079
3080     releaseGraphicObjectProperty(__GO_CHAMP_DIMENSIONS__, dimensions, jni_int_vector, 2);
3081     closeList6(parent);
3082     return true;
3083 }
3084 static bool export_handle_label(int parent, int uid)
3085 {
3086     if (export_handle_generic(parent, uid, LabelHandle::getPropertyList()) == false)
3087     {
3088         return false;
3089     }
3090
3091     //text
3092     int* dimensions = nullptr;
3093     char** text = nullptr;
3094
3095     getHandleIntVectorProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, &dimensions);
3096     getHandleStringVectorProperty(uid, __GO_TEXT_STRINGS__, &text);
3097
3098     std::vector<int> dims = {dimensions[0], dimensions[1]};
3099     releaseGraphicObjectProperty(__GO_TEXT_ARRAY_DIMENSIONS__, dimensions, jni_int_vector, 2);
3100
3101     writeStringMatrix6(parent, "text", 2, dims.data(), text);
3102     releaseGraphicObjectProperty(__GO_TEXT_STRINGS__, text, jni_string_vector, dims[0] * dims[1]);
3103
3104     closeList6(parent);
3105     return true;
3106 }
3107 static bool export_handle_axes(int parent, int uid)
3108 {
3109     if (export_handle_generic(parent, uid, AxesHandle::getPropertyList()) == false)
3110     {
3111         return false;
3112     }
3113
3114     //title
3115     int title = 0;
3116     getHandleIntProperty(uid, __GO_TITLE__, &title);
3117     export_handle(parent, "title", title);
3118
3119     //x_label
3120     int x_label = 0;
3121     getHandleIntProperty(uid, __GO_X_AXIS_LABEL__, &x_label);
3122     export_handle(parent, "x_label", x_label);
3123
3124     //y_label
3125     int y_label = 0;
3126     getHandleIntProperty(uid, __GO_Y_AXIS_LABEL__, &y_label);
3127     export_handle(parent, "y_label", y_label);
3128
3129     //z_label
3130     int z_label = 0;
3131     getHandleIntProperty(uid, __GO_Z_AXIS_LABEL__, &z_label);
3132     export_handle(parent, "z_label", z_label);
3133
3134
3135     closeList6(parent);
3136     return true;
3137 }
3138
3139 static bool export_handle_figure(int parent, int uid)
3140 {
3141     if (export_handle_generic(parent, uid, FigureHandle::getPropertyList()) == false)
3142     {
3143         return false;
3144     }
3145
3146     //layout_options
3147     export_handle_layout_options(parent, uid);
3148
3149     closeList6(parent);
3150     return true;
3151 }
3152
3153 static bool export_handle_compound(int parent, int uid)
3154 {
3155     if (export_handle_generic(parent, uid, CompoundHandle::getPropertyList()) == false)
3156     {
3157         return false;
3158     }
3159
3160     closeList6(parent);
3161     return true;
3162 }
3163
3164 bool export_handle(int parent, const std::string& name, int uid)
3165 {
3166     //get handle type
3167     int type = 0;
3168     getHandleIntProperty(uid, __GO_TYPE__, &type);
3169
3170     //create handle node in __refs__
3171     int h = openList6(parent, name.data(), g_SCILAB_CLASS_HANDLE);
3172
3173     bool ret = false;
3174     switch (type)
3175     {
3176         case __GO_FIGURE__:
3177         {
3178             ret = export_handle_figure(h, uid);
3179             break;
3180         }
3181         case __GO_AXES__:
3182         {
3183             ret = export_handle_axes(h, uid);
3184             break;
3185         }
3186         case __GO_LABEL__:
3187         {
3188             ret = export_handle_label(h, uid);
3189             break;
3190         }
3191         case __GO_CHAMP__:
3192         {
3193             ret = export_handle_champ(h, uid);
3194             break;
3195         }
3196         case __GO_FAC3D__:
3197         {
3198             ret = export_handle_fac3d(h, uid);
3199             break;
3200         }
3201         case __GO_PLOT3D__:
3202         {
3203             ret = export_handle_plot3d(h, uid);
3204             break;
3205         }
3206         case __GO_POLYLINE__:
3207         {
3208             ret = export_handle_polyline(h, uid);
3209             break;
3210         }
3211         case __GO_DATATIP__:
3212         {
3213             ret = export_handle_datatip(h, uid);
3214             break;
3215         }
3216         case __GO_COMPOUND__:
3217         {
3218             ret = export_handle_compound(h, uid);
3219             break;
3220         }
3221         case __GO_RECTANGLE__:
3222         {
3223             ret = export_handle_rectangle(h, uid);
3224             break;
3225         }
3226         case __GO_ARC__:
3227         {
3228             ret = export_handle_arc(h, uid);
3229             break;
3230         }
3231         case __GO_SEGS__:
3232         {
3233             ret = export_handle_segs(h, uid);
3234             break;
3235         }
3236         case __GO_GRAYPLOT__:
3237         {
3238             ret = export_handle_grayplot(h, uid);
3239             break;
3240         }
3241         case __GO_MATPLOT__:
3242         {
3243             ret = export_handle_matplot(h, uid);
3244             break;
3245         }
3246         case __GO_FEC__:
3247         {
3248             ret = export_handle_fec(h, uid);
3249             break;
3250         }
3251         case __GO_LEGEND__:
3252         {
3253             ret = export_handle_legend(h, uid);
3254             break;
3255         }
3256         case __GO_TEXT__:
3257         {
3258             ret = export_handle_text(h, uid);
3259             break;
3260         }
3261         case __GO_AXIS__:
3262         {
3263             ret = export_handle_axis(h, uid);
3264             break;
3265         }
3266         case __GO_LIGHT__:
3267         {
3268             ret = export_handle_light(h, uid);
3269             break;
3270         }
3271         case __GO_UIMENU__:
3272         {
3273             ret = export_handle_uimenu(h, uid);
3274             break;
3275         }
3276         case __GO_UICONTEXTMENU__:
3277         {
3278             ret = export_handle_uicontextmenu(h, uid);
3279             break;
3280         }
3281         case __GO_UICONTROL__:
3282         {
3283             ret = export_handle_uicontrol(h, uid);
3284             break;
3285         }
3286         default:
3287         {
3288         }
3289
3290     }
3291
3292     return ret;
3293 }
3294
3295 static bool export_handle_children(int parent, int uid)
3296 {
3297     int count = 0;
3298     getHandleIntProperty(uid, __GO_CHILDREN_COUNT__, &count);
3299     int node = openList6(parent, "children", g_SCILAB_CLASS_HANDLE);
3300     int* children = nullptr;
3301
3302     if (count != 0)
3303     {
3304         getHandleIntVectorProperty(uid, __GO_CHILDREN__, &children);
3305     }
3306
3307     int index = 0;
3308     for (int i = 0; i < count; ++i)
3309     {
3310         int child = children[i];
3311         int hidden = 0;
3312         getHandleBoolProperty(child, __GO_HIDDEN__, &hidden);
3313         if (hidden == 0)
3314         {
3315             if (export_handle(node, std::to_string(index), child) == false)
3316             {
3317                 releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
3318                 closeList6(node);
3319                 return false;
3320             }
3321
3322             ++index;
3323         }
3324     }
3325
3326     releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
3327     closeList6(node);
3328     return true;
3329 }
3330
3331 int add_current_entity(int dataset)
3332 {
3333     int type = 0;
3334     getHandleInt(dataset, "type", &type);
3335
3336     switch (type)
3337     {
3338         case __GO_FIGURE__:
3339             return import_handle(dataset, -1);
3340             break;
3341         case __GO_AXES__:
3342         {
3343             //add handle to current figure
3344             getOrCreateDefaultSubwin();
3345             int iCurrentFigure = getCurrentFigure();
3346             return import_handle(dataset, iCurrentFigure);
3347             break;
3348         }
3349         default:
3350             //add handle as child of current axes ( take care of compound ! )
3351             return -1;
3352     }
3353 }