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 void updateXYDataBounds(double rect[6], int axes = -1)
1234 {
1235     int firstPlot = 0;
1236     int * piFirstPlot = &firstPlot;
1237     if (axes == -1)
1238     {
1239         axes = getOrCreateDefaultSubwin();
1240     }
1241
1242     getGraphicObjectProperty(axes, __GO_FIRST_PLOT__, jni_bool, (void **)&piFirstPlot);
1243     if (firstPlot)
1244     {
1245         rect[4] = 0;
1246         rect[5] = 0;
1247     }
1248     else
1249     {
1250         double * dataBounds = NULL;
1251         getGraphicObjectProperty(axes, __GO_DATA_BOUNDS__, jni_double_vector, (void **)&dataBounds);
1252
1253         rect[0] = Min(rect[0], dataBounds[0]);
1254         rect[1] = Max(rect[1], dataBounds[1]);
1255         rect[2] = Min(rect[2], dataBounds[2]);
1256         rect[3] = Max(rect[3], dataBounds[3]);
1257         rect[4] = dataBounds[4];
1258         rect[5] = dataBounds[5];
1259     }
1260
1261     setGraphicObjectProperty(axes, __GO_DATA_BOUNDS__, rect, jni_double_vector, 6);
1262 }
1263
1264 static int mustUpdate(int axes = -1)
1265 {
1266     int iTmp = 0;
1267     int * piTmp = &iTmp;
1268     if (axes == -1)
1269     {
1270         axes = getOrCreateDefaultSubwin();
1271     }
1272
1273     getGraphicObjectProperty(axes, __GO_AUTO_SCALE__, jni_bool, (void **)&piTmp);
1274     return iTmp;
1275 }
1276
1277 void MiniMaxi(const double vect[], int n, double * const min, double * const max)
1278 {
1279     int i = 0;
1280     double _min = DBL_MAX;
1281     double _max = -DBL_MAX;
1282     for (; i < n; i++)
1283     {
1284         /*    if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] < vmin)  */
1285         if (finite(vect[i]) == 1)
1286         {
1287             if (vect[i] < _min)
1288             {
1289                 _min = vect[i];
1290             }
1291             if (vect[i] > _max)
1292             {
1293                 _max = vect[i];
1294             }
1295         }
1296     }
1297
1298     *min = _min;
1299     *max = _max;
1300 }
1301
1302
1303 static int import_handle_polyline(int dataset, int parent)
1304 {
1305     int polyline = createGraphicObject(__GO_POLYLINE__);
1306     createDataObject(polyline, __GO_POLYLINE__);
1307
1308     //import "standards" properties
1309     import_handle_generic(dataset, polyline, parent, PolylineHandle::getPropertyList(), true);
1310
1311     //x_shift
1312     import_polyline_shift(dataset, polyline, "x_shift", __GO_DATA_MODEL_X_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_X_COORDINATES_SHIFT__);
1313     //y_shift
1314     import_polyline_shift(dataset, polyline, "y_shift", __GO_DATA_MODEL_Y_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Y_COORDINATES_SHIFT__);
1315     //z_shift
1316     import_polyline_shift(dataset, polyline, "z_shift", __GO_DATA_MODEL_Z_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Z_COORDINATES_SHIFT__);
1317
1318
1319     //interp_color_vector
1320     {
1321         int row = 0;
1322         int col = 0;
1323         int set = 0;
1324         int* data = nullptr;
1325
1326         getHandleIntVector(dataset, "interp_color_vector", &row, &col, &data);
1327         if (row * col != 0)
1328         {
1329             set = 1;
1330             setGraphicObjectProperty(polyline, __GO_INTERP_COLOR_VECTOR__, data, jni_double_vector, row * col);
1331         }
1332         else
1333         {
1334             set = 0;
1335         }
1336
1337         delete[] data;
1338         setGraphicObjectProperty(polyline, __GO_INTERP_COLOR_VECTOR_SET__, &set, jni_bool, 1);
1339     }
1340
1341     //data
1342     {
1343         int numElementsArray[2];
1344         int size = 0;
1345         double* dataX = nullptr;
1346         double* dataY = nullptr;
1347         double* dataZ = nullptr;
1348         getHandleDoubleVector(dataset, "data_x", &numElementsArray[0], &numElementsArray[1], &dataX);
1349         size = numElementsArray[0] * numElementsArray[1];
1350         getHandleDoubleVector(dataset, "data_y", &numElementsArray[0], &numElementsArray[1], &dataY);
1351
1352         if (numElementsArray[0] * numElementsArray[1] != size)
1353         {
1354             std::cout << "size trouble !!!" << std::endl;
1355         }
1356
1357         setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 2);
1358         setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_X__, dataX, jni_double_vector, size);
1359         setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_Y__, dataY, jni_double_vector, size);
1360
1361         //data z
1362         int zSet = 0;
1363         numElementsArray[0] = 0;
1364         numElementsArray[1] = 0;
1365         getHandleDoubleVector(dataset, "data_z", &numElementsArray[0], &numElementsArray[1], &dataZ);
1366         if (numElementsArray[0] * numElementsArray[1] != 0)
1367         {
1368             setGraphicObjectPropertyAndNoWarn(polyline, __GO_DATA_MODEL_Z__, dataZ, jni_double_vector, size);
1369             zSet = 1;
1370         }
1371
1372         setGraphicObjectProperty(polyline, __GO_DATA_MODEL_Z_COORDINATES_SET__, &zSet, jni_int, 1);
1373
1374         //update parent axes data_bounds
1375         if (mustUpdate())
1376         {
1377             double rect[6];
1378
1379             MiniMaxi(dataX, size, rect, rect + 1);
1380             MiniMaxi(dataY, size, rect + 2, rect + 3);
1381
1382             updateXYDataBounds(rect);
1383         }
1384
1385         delete[] dataX;
1386         delete[] dataY;
1387         delete[] dataZ;
1388     }
1389
1390     //datatips
1391     import_handle_datatips(dataset, polyline);
1392
1393     closeList6(dataset);
1394     return polyline;
1395 }
1396
1397 static int import_handle_surface(int dataset, int uid, int parent)
1398 {
1399     //import "standards" properties
1400     import_handle_generic(dataset, uid, parent, SurfaceHandle::getPropertyList(), true);
1401     return uid;
1402 }
1403
1404 static int import_handle_plot3d(int dataset, int parent)
1405 {
1406     int plot = createGraphicObject(__GO_PLOT3D__);
1407     createDataObject(plot, __GO_PLOT3D__);
1408     import_handle_surface(dataset, plot, parent);
1409
1410     //data
1411     int xR = 0, xC = 0;
1412     double* dataX = nullptr;
1413     int yR = 0, yC = 0;
1414     double* dataY = nullptr;
1415     int zR = 0, zC = 0;
1416     double* dataZ = nullptr;
1417
1418     getHandleDoubleVector(dataset, "data_x", &xR, &xC, &dataX);
1419     getHandleDoubleVector(dataset, "data_y", &yR, &yC, &dataY);
1420     getHandleDoubleVector(dataset, "data_z", &zR, &zC, &dataZ);
1421
1422     int gridSize[4];
1423     int result;
1424
1425     gridSize[0] = xR;
1426     gridSize[1] = xC;
1427     gridSize[2] = yR;
1428     gridSize[3] = yC;
1429
1430     result = setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
1431
1432     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_X__, dataX, jni_double_vector, xR * xC);
1433     setGraphicObjectPropertyAndNoWarn(plot, __GO_DATA_MODEL_Y__, dataY, jni_double_vector, yR * yC);
1434     setGraphicObjectProperty(plot, __GO_DATA_MODEL_Z__, dataZ, jni_double_vector, zR * zC);
1435
1436     delete[] dataX;
1437     delete[] dataY;
1438     delete[] dataZ;
1439
1440
1441     closeList6(dataset);
1442     return plot;
1443 }
1444
1445 static int import_handle_fac3d(int dataset, int parent)
1446 {
1447     int fac = createGraphicObject(__GO_FAC3D__);
1448     createDataObject(fac, __GO_FAC3D__);
1449
1450     import_handle_surface(dataset, fac, parent);
1451
1452     //data
1453     int xR = 0, xC = 0;
1454     double* dataX = nullptr;
1455     int yR = 0, yC = 0;
1456     double* dataY = nullptr;
1457     int zR = 0, zC = 0;
1458     double* dataZ = nullptr;
1459
1460     getHandleDoubleVector(dataset, "data_x", &xR, &xC, &dataX);
1461     getHandleDoubleVector(dataset, "data_y", &yR, &yC, &dataY);
1462     getHandleDoubleVector(dataset, "data_z", &zR, &zC, &dataZ);
1463
1464     int cR = 0;
1465     int cC = 0;
1466     double* colors = nullptr;
1467     getHandleDoubleVector(dataset, "colors", &cR, &cC, &colors);
1468     int cSize = cR * cC;
1469
1470     int numElementsArray[3];
1471
1472     numElementsArray[0] = xC;
1473     numElementsArray[1] = xR;
1474     numElementsArray[2] = cSize;
1475
1476     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 3);
1477
1478     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_X__, dataX, jni_double_vector, xR * xC);
1479     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_Y__, dataY, jni_double_vector, yR * yC);
1480     setGraphicObjectPropertyAndNoWarn(fac, __GO_DATA_MODEL_Z__, dataZ, jni_double_vector, zR * zC);
1481     setGraphicObjectProperty(fac, __GO_DATA_MODEL_COLORS__, colors, jni_double_vector, cSize);
1482
1483     delete[] dataX;
1484     delete[] dataY;
1485     delete[] dataZ;
1486     delete[] colors;
1487
1488
1489     //cdata_mapping
1490     int cdata = 0;
1491     getHandleInt(dataset, "cdata_mapping", &cdata);
1492     setGraphicObjectProperty(fac, __GO_DATA_MAPPING__, &cdata, jni_int, 1);
1493
1494
1495     closeList6(dataset);
1496     return fac;
1497 }
1498
1499
1500 static int import_handle_champ(int dataset, int parent)
1501 {
1502     //need to get properties and call a "creator" :x
1503
1504     int champ = createGraphicObject(__GO_CHAMP__);
1505
1506     //data
1507     int row = 0;
1508     int col = 0;
1509     int dims[2];
1510     int num = 0;
1511     double* baseX = nullptr;
1512     getHandleDoubleVector(dataset, "base_x", &row, &col, &baseX);
1513     dims[0] = col;
1514
1515     double* baseY = nullptr;
1516     getHandleDoubleVector(dataset, "base_y", &row, &col, &baseY);
1517     dims[1] = col;
1518     num = dims[0] * dims[1];
1519
1520     double* directionX = nullptr;
1521     getHandleDoubleVector(dataset, "direction_x", &row, &col, &directionX);
1522
1523     double* directionY = nullptr;
1524     getHandleDoubleVector(dataset, "direction_y", &row, &col, &directionY);
1525
1526     setGraphicObjectProperty(champ, __GO_NUMBER_ARROWS__, &num, jni_int, 1);
1527     setGraphicObjectProperty(champ, __GO_CHAMP_DIMENSIONS__, dims, jni_int_vector, 2);
1528     setGraphicObjectProperty(champ, __GO_BASE_X__, baseX, jni_double_vector, dims[0]);
1529     setGraphicObjectProperty(champ, __GO_BASE_Y__, baseY, jni_double_vector, dims[1]);
1530     setGraphicObjectProperty(champ, __GO_DIRECTION_X__, directionX, jni_double_vector, dims[0] * dims[1]);
1531     setGraphicObjectProperty(champ, __GO_DIRECTION_Y__, directionY, jni_double_vector, dims[0] * dims[1]);
1532
1533     delete[] baseX;
1534     delete[] baseY;
1535     delete[] directionX;
1536     delete[] directionY;
1537
1538     //import "standards" properties
1539     import_handle_generic(dataset, champ, parent, ChampHandle::getPropertyList(), true);
1540
1541     closeList6(dataset);
1542     return champ;
1543 }
1544 static int import_handle_label(int dataset, int uid)
1545 {
1546     //import "standards" properties
1547     //do not create releationship between parent
1548     import_handle_generic(dataset, uid, -1, LabelHandle::getPropertyList(), true);
1549
1550     //text
1551     std::vector<int> dims(2);
1552     char** data = nullptr;
1553     int node = getHandleStringVector(dataset, "text", &dims[0], &dims[1], &data);
1554
1555     setGraphicObjectProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, dims.data(), jni_int_vector, 2);
1556     setGraphicObjectProperty(uid, __GO_TEXT_STRINGS__, data, jni_string_vector, dims[0] * dims[1]);
1557     freeStringMatrix(node, data);
1558     delete[] data;
1559
1560     closeList6(dataset);
1561     return uid;
1562 }
1563
1564 static int import_handle_axes(int dataset, int parent)
1565 {
1566     //how to manage call by %h_copy ?
1567
1568     int axes = createSubWin(parent);
1569
1570     //hide current axes
1571     int visible = 0;
1572     setGraphicObjectProperty(axes, __GO_VISIBLE__, &visible, jni_bool, 1);
1573
1574     //import "standards" properties
1575     import_handle_generic(dataset, axes, parent, AxesHandle::getPropertyList(), true);
1576
1577     //title
1578     int title = 0;
1579     int *ptitle = &title;
1580     int nodeTitle = getDataSetIdFromName(dataset, "title");
1581     getGraphicObjectProperty(axes, __GO_TITLE__, jni_int, (void **)&ptitle);
1582     import_handle_label(nodeTitle, title);
1583
1584     //x_label
1585     int x_label = 0;
1586     int *px_label = &x_label;
1587     int nodeX = getDataSetIdFromName(dataset, "x_label");
1588     getGraphicObjectProperty(axes, __GO_X_AXIS_LABEL__, jni_int, (void **)&px_label);
1589     import_handle_label(nodeX, x_label);
1590
1591     //y_label
1592     int y_label = 0;
1593     int *py_label = &y_label;
1594     int nodeY = getDataSetIdFromName(dataset, "y_label");
1595     getGraphicObjectProperty(axes, __GO_Y_AXIS_LABEL__, jni_int, (void **)&py_label);
1596     import_handle_label(nodeY, y_label);
1597
1598     //z_label
1599     int z_label = 0;
1600     int *pz_label = &z_label;
1601     int nodeZ = getDataSetIdFromName(dataset, "z_label");
1602     getGraphicObjectProperty(axes, __GO_Z_AXIS_LABEL__, jni_int, (void **)&pz_label);
1603     import_handle_label(nodeZ, z_label);
1604
1605     //set real visible state
1606     getHandleInt(dataset, "visible", &visible);
1607     setGraphicObjectProperty(axes, __GO_VISIBLE__, &visible, jni_bool, 1);
1608
1609     closeList6(dataset);
1610     return axes;
1611 }
1612
1613 static int import_handle_layout_options(int dataset, int frame)
1614 {
1615     int layout_type = 0;
1616     getHandleInt(dataset, "layout", &layout_type);
1617     int row = 0;
1618     int col = 0;
1619     int* data = nullptr;
1620
1621     switch (layout_type)
1622     {
1623         case 2: //grid
1624         {
1625             int node = getDataSetIdFromName(dataset, "layout_options");
1626             getHandleIntVector(node, "grid", &row, &col, &data);
1627             if (data && row * col == 2)
1628             {
1629                 setGraphicObjectProperty(frame, __GO_GRID_OPT_GRID__, data, jni_int_vector, 2);
1630             }
1631
1632             delete[] data;
1633             data = nullptr;
1634
1635             getHandleIntVector(node, "padding", &row, &col, &data);
1636             if (data && row * col == 2)
1637             {
1638                 setGraphicObjectProperty(frame, __GO_GRID_OPT_PADDING__, data, jni_int_vector, 2);
1639             }
1640
1641             delete[] data;
1642             data = nullptr;
1643
1644             closeList6(node);
1645             break;
1646         }
1647         case 3: //border
1648         {
1649             int node = getDataSetIdFromName(dataset, "layout_options");
1650             getHandleIntVector(node, "padding", &row, &col, &data);
1651             if (data && row * col == 2)
1652             {
1653                 setGraphicObjectProperty(frame, __GO_BORDER_OPT_PADDING__, data, jni_int_vector, 2);
1654             }
1655
1656             delete[] data;
1657             data = nullptr;
1658
1659             closeList6(node);
1660             break;
1661         }
1662     }
1663
1664     return frame;
1665 }
1666
1667 static int import_handle_figure(int dataset, int parent)
1668 {
1669     //some properties must be set @ creation time
1670     int menubar = 0;
1671     getHandleInt(dataset, "menubar", &menubar);
1672     int toolbar = 0;
1673     getHandleInt(dataset, "toolbar", &toolbar);
1674     int dockable = 0;
1675     getHandleBool(dataset, "dockable", &dockable);
1676     int default_axes = 0;
1677     getHandleBool(dataset, "default_axes", &default_axes);
1678
1679     //force visible true FOR DEBUG ONLY
1680     int visible = 0;
1681
1682     //create a new hidden figure
1683     int fig = createFigure(dockable, menubar, toolbar, default_axes, visible);
1684     int id = getValidDefaultFigureId();
1685     setGraphicObjectProperty(fig, __GO_ID__, &id, jni_int, 1);
1686
1687     int menu = 0;
1688     getHandleBool(dataset, "menubar_visible", &menu);
1689     int notmenu = !menu;
1690     int info = 0;
1691     getHandleBool(dataset, "infobar_visible", &info);
1692     int notinfo = !info;
1693     int tool = 0;
1694     getHandleBool(dataset, "toolbar_visible", &tool);
1695     int nottool = !tool;
1696
1697     //force inverse flag
1698     setGraphicObjectProperty(fig, __GO_MENUBAR_VISIBLE__, &notmenu, jni_bool, 1);
1699     setGraphicObjectProperty(fig, __GO_INFOBAR_VISIBLE__, &notinfo, jni_bool, 1);
1700     setGraphicObjectProperty(fig, __GO_TOOLBAR_VISIBLE__, &nottool, jni_bool, 1);
1701
1702     //set real value
1703     setGraphicObjectProperty(fig, __GO_MENUBAR_VISIBLE__, &menu, jni_bool, 1);
1704     setGraphicObjectProperty(fig, __GO_INFOBAR_VISIBLE__, &info, jni_bool, 1);
1705     setGraphicObjectProperty(fig, __GO_TOOLBAR_VISIBLE__, &tool, jni_bool, 1);
1706
1707     //import "standards" properties
1708     import_handle_generic(dataset, fig, -1, FigureHandle::getPropertyList(), true);
1709
1710     import_handle_layout_options(dataset, fig);
1711     closeList6(dataset);
1712     return fig;
1713 }
1714
1715 int import_handle(int dataset, int parent)
1716 {
1717     //get type
1718     int type = 0;
1719     getHandleInt(dataset, "type", &type);
1720     switch (type)
1721     {
1722         case __GO_FIGURE__:
1723         {
1724             return import_handle_figure(dataset, parent);
1725         }
1726         case __GO_AXES__:
1727         {
1728             return import_handle_axes(dataset, parent);
1729         }
1730         case __GO_CHAMP__:
1731         {
1732             return import_handle_champ(dataset, parent);
1733         }
1734         case __GO_FAC3D__:
1735         {
1736             return import_handle_fac3d(dataset, parent);
1737         }
1738         case __GO_PLOT3D__:
1739         {
1740             return import_handle_plot3d(dataset, parent);
1741         }
1742         case __GO_COMPOUND__:
1743         {
1744             return import_handle_compound(dataset, parent);
1745         }
1746         case __GO_POLYLINE__:
1747         {
1748             return import_handle_polyline(dataset, parent);
1749         }
1750         case __GO_RECTANGLE__:
1751         {
1752             return import_handle_rectangle(dataset, parent);
1753         }
1754         case __GO_ARC__:
1755         {
1756             return import_handle_arc(dataset, parent);
1757         }
1758         case __GO_SEGS__:
1759         {
1760             return import_handle_segs(dataset, parent);
1761         }
1762         case __GO_GRAYPLOT__:
1763         {
1764             return import_handle_grayplot(dataset, parent);
1765         }
1766         case __GO_MATPLOT__:
1767         {
1768             return import_handle_matplot(dataset, parent);
1769         }
1770         case __GO_FEC__:
1771         {
1772             return import_handle_fec(dataset, parent);
1773         }
1774         case __GO_LEGEND__:
1775         {
1776             return import_handle_legend(dataset, parent);
1777         }
1778         case __GO_TEXT__:
1779         {
1780             return import_handle_text(dataset, parent);
1781         }
1782         case __GO_AXIS__:
1783         {
1784             return import_handle_axis(dataset, parent);
1785         }
1786         case __GO_LIGHT__:
1787         {
1788             return import_handle_light(dataset, parent);
1789         }
1790         case __GO_UIMENU__:
1791         {
1792             return import_handle_uimenu(dataset, parent);
1793         }
1794         case __GO_UICONTEXTMENU__:
1795         {
1796             return import_handle_uicontextmenu(dataset, parent);
1797         }
1798         case __GO_UICONTROL__:
1799         {
1800             return import_handle_uicontrol(dataset, parent);
1801         }
1802     }
1803     return -1;
1804 }
1805
1806 void update_link_path(int legend, Links::PathList& paths)
1807 {
1808     //find legend parent axes ( origin of path items )
1809     int type = 0;
1810     int* ptype = &type;
1811     int axes = legend; //start point
1812     int* paxes = &axes;
1813     getGraphicObjectProperty(legend, __GO_PARENT_AXES__, jni_int, (void**)&paxes);
1814     std::vector<int> links;
1815     //loop on child following path index
1816     for (auto & path : paths)
1817     {
1818         int current = axes;
1819         for (int j = 0; j < path.size(); ++j)
1820         {
1821             int index = path[path.size() - 1 - j];
1822             int count = 0;
1823             int* pcount = &count;
1824             getGraphicObjectProperty(current, __GO_CHILDREN_COUNT__, jni_int, (void**)&pcount);
1825             if (count == 0 || index >= count)
1826             {
1827                 getGraphicObjectProperty(current, __GO_TYPE__, jni_int, (void**)&ptype);
1828                 break;
1829             }
1830
1831             int* children = nullptr;
1832             getGraphicObjectProperty(current, __GO_CHILDREN__, jni_int_vector, (void**)&children);
1833
1834             current = children[index];
1835
1836             releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
1837         }
1838
1839         links.push_back(current);
1840     }
1841
1842     setGraphicObjectProperty(legend, __GO_LINKS__, links.data(), jni_int_vector, static_cast<int>(links.size()));
1843 }
1844
1845 static bool getHandleBoolProperty(int uid, int prop, int* data)
1846 {
1847     int val = 0;
1848     int* pVal = &val;
1849     getGraphicObjectProperty(uid, prop, jni_bool, (void **)&pVal);
1850     if (pVal == nullptr)
1851     {
1852         return false;
1853     }
1854
1855     *data = val;
1856     return true;
1857 }
1858
1859 static bool getHandleIntProperty(int uid, int prop, int* data)
1860 {
1861     int val = 0;
1862     int* pVal = &val;
1863     getGraphicObjectProperty(uid, prop, jni_int, (void **)&pVal);
1864     if (pVal == nullptr)
1865     {
1866         return false;
1867     }
1868
1869     *data = val;
1870     return true;
1871 }
1872
1873 static bool getHandleDoubleProperty(int uid, int prop, double* data)
1874 {
1875     double val = 0;
1876     double* pVal = &val;
1877     getGraphicObjectProperty(uid, prop, jni_double, (void **)&pVal);
1878     if (pVal == nullptr)
1879     {
1880         return false;
1881     }
1882
1883     *data = val;
1884     return true;
1885 }
1886
1887 static void getHandleStringProperty(int uid, int prop, char** str)
1888 {
1889     getGraphicObjectProperty(uid, prop, jni_string, (void **)str);
1890 }
1891
1892
1893 static void getHandleBoolVectorProperty(int uid, int prop, int** vals)
1894 {
1895     getGraphicObjectProperty(uid, prop, jni_bool_vector, (void **)vals);
1896 }
1897
1898 static void getHandleIntVectorProperty(int uid, int prop, int** vals)
1899 {
1900     getGraphicObjectProperty(uid, prop, jni_int_vector, (void **)vals);
1901 }
1902
1903 static void getHandleDoubleVectorProperty(int uid, int prop, double** vals)
1904 {
1905     getGraphicObjectProperty(uid, prop, jni_double_vector, (void **)vals);
1906 }
1907
1908 static void getHandleStringVectorProperty(int uid, int prop, char*** vals)
1909 {
1910     getGraphicObjectProperty(uid, prop, jni_string_vector, (void **)vals);
1911 }
1912
1913 static bool export_handle_generic(int parent, int uid, const HandleProp& props);
1914 static bool export_handle_layout_options(int parent, int uid);
1915 static bool export_handle_userdata(int parent, int uid);
1916 static bool export_handle_tag(int parent, int uid);
1917 static bool export_handle_figure(int parent, int uid);
1918 static bool export_handle_axes(int parent, int uid);
1919 static bool export_handle_label(int parent, int uid);
1920 static bool export_handle_champ(int parent, int uid);
1921 static bool export_handle_children(int parent, int uid);
1922
1923 static bool export_handle_generic(int parent, int uid, const HandleProp& props)
1924 {
1925     for (auto & prop : props)
1926     {
1927         const char* name = prop.first.data();
1928         std::vector<int> info(prop.second);
1929
1930         //scalar variable
1931         if (info.size() == 3)
1932         {
1933             int go = info[1];
1934             int type = info[2];
1935
1936             switch (type)
1937             {
1938                 case jni_bool:
1939                 {
1940                     std::vector<int> dims = {1, 1};
1941                     int val = 0;
1942                     getHandleBoolProperty(uid, go, &val);
1943                     writeBooleanMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), &val);
1944                     break;
1945                 }
1946                 case jni_double:
1947                 {
1948                     std::vector<int> dims = {1, 1};
1949                     double val = 0;
1950                     getHandleDoubleProperty(uid, go, &val);
1951                     writeDoubleMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), &val);
1952                     break;
1953                 }
1954                 case jni_int:
1955                 {
1956                     std::vector<int> dims = {1, 1};
1957                     int val = 0;
1958                     getHandleIntProperty(uid, go, &val);
1959                     writeIntegerMatrix6(parent, name, H5T_NATIVE_INT32, "32", static_cast<int>(dims.size()), dims.data(), &val);
1960                     break;
1961                 }
1962                 case jni_string:
1963                 {
1964                     std::vector<int> dims = {1, 1};
1965                     char* val;
1966                     getHandleStringProperty(uid, go, &val);
1967                     writeStringMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), &val);
1968                     releaseGraphicObjectProperty(go, val, jni_string, 1);
1969                     break;
1970                 }
1971             }
1972         }
1973         else //vector variable
1974         {
1975             int go = info[1];
1976             int type = info[2];
1977             int row = info[3];
1978             int col = info.size() > 3 ? info[4] : -1;
1979
1980             if (row < 0)
1981             {
1982                 row = -row;
1983             }
1984             else
1985             {
1986                 getHandleIntProperty(uid, row, &row);
1987             }
1988
1989             if (col < 0)
1990             {
1991                 col = -col;
1992             }
1993             else
1994             {
1995                 getHandleIntProperty(uid, col, &col);
1996             }
1997
1998             switch (type)
1999             {
2000                 case jni_bool_vector:
2001                 {
2002                     std::vector<int> dims = {row, col};
2003                     int* vals;
2004                     getHandleBoolVectorProperty(uid, go, &vals);
2005                     writeBooleanMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), vals);
2006                     releaseGraphicObjectProperty(go, vals, jni_bool_vector, row * col);
2007                     break;
2008                 }
2009                 case jni_double_vector:
2010                 {
2011                     std::vector<int> dims = {row, col};
2012                     double* vals;
2013                     getHandleDoubleVectorProperty(uid, go, &vals);
2014                     writeDoubleMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), vals);
2015                     releaseGraphicObjectProperty(go, vals, jni_double_vector, row * col);
2016                     break;
2017                 }
2018                 case jni_int_vector:
2019                 {
2020                     std::vector<int> dims = {row, col};
2021                     int* vals;
2022                     getHandleIntVectorProperty(uid, go, &vals);
2023                     writeIntegerMatrix6(parent, name, H5T_NATIVE_INT32, "32", static_cast<int>(dims.size()), dims.data(), vals);
2024                     releaseGraphicObjectProperty(go, vals, jni_int_vector, row * col);
2025                     break;
2026                 }
2027                 case jni_string_vector:
2028                 {
2029                     std::vector<int> dims = {row, col};
2030                     char** vals;
2031                     getHandleStringVectorProperty(uid, go, &vals);
2032                     writeStringMatrix6(parent, name, static_cast<int>(dims.size()), dims.data(), vals);
2033                     releaseGraphicObjectProperty(go, vals, jni_string_vector, row * col);
2034                     break;
2035                 }
2036                 default:
2037                 {
2038                     break;
2039                 }
2040             }
2041         }
2042     }
2043
2044     //user_data
2045     export_handle_userdata(parent, uid);
2046     //tag
2047     export_handle_tag(parent, uid);
2048     //children
2049     export_handle_children(parent, uid);
2050     return true;
2051 }
2052
2053 static bool export_handle_layout_options(int parent, int uid)
2054 {
2055     int layout_type = 0;
2056     getHandleIntProperty(uid, __GO_LAYOUT__, &layout_type);
2057     if (layout_type == 0 || layout_type == 1) //LAYOUT_NONE or LAYOUT_GRIDBAG
2058     {
2059         //nothing to save
2060         return true;
2061     }
2062
2063     int layout = openList6(parent, "layout_options", g_SCILAB_CLASS_HANDLE);
2064
2065     switch (layout_type)
2066     {
2067         case 2: //grid
2068         {
2069             std::vector<int> dims = {1, 2};
2070             int* grid = nullptr;
2071             getHandleIntVectorProperty(uid, __GO_GRID_OPT_GRID__, &grid);
2072             writeIntegerMatrix6(layout, "grid", H5T_NATIVE_INT32, "32", 2, dims.data(), grid);
2073             releaseGraphicObjectProperty(__GO_GRID_OPT_GRID__, grid, jni_int_vector, 2);
2074
2075             int* pad = nullptr;
2076             getHandleIntVectorProperty(uid, __GO_GRID_OPT_PADDING__, &pad);
2077             writeIntegerMatrix6(layout, "padding", H5T_NATIVE_INT32, "32", 2, dims.data(), pad);
2078             releaseGraphicObjectProperty(__GO_GRID_OPT_PADDING__, pad, jni_int_vector, 2);
2079             break;
2080         }
2081         case 3: //border
2082         {
2083             std::vector<int> dims = {1, 2};
2084             int* pad = nullptr;
2085             getHandleIntVectorProperty(uid, __GO_BORDER_OPT_PADDING__, &pad);
2086             writeIntegerMatrix6(layout, "padding", H5T_NATIVE_INT32, "32", 2, dims.data(), pad);
2087             releaseGraphicObjectProperty(__GO_BORDER_OPT_PADDING__, pad, jni_int_vector, 2);
2088             break;
2089         }
2090     }
2091
2092     closeList6(layout);
2093
2094     return true;
2095 }
2096 static bool export_handle_tag(int parent, int uid)
2097 {
2098     char* tag = nullptr;
2099     getHandleStringProperty(uid, __GO_TAG__, &tag);
2100     int dims[2];
2101     dims[0] = 1;
2102     dims[1] = 1;
2103     writeStringMatrix6(parent, "tag", 2, dims, &tag);
2104     releaseGraphicObjectProperty(__GO_TAG__, tag, jni_string, 1);
2105     return true;
2106 }
2107
2108 static bool export_handle_userdata(int parent, int uid)
2109 {
2110
2111     int size = 0;
2112     getHandleIntProperty(uid, __GO_USER_DATA_SIZE__, &size);
2113
2114     if (size == 0)
2115     {
2116         std::vector<int> dims = {0, 0};
2117         writeDoubleMatrix6(parent, "userdata", 2, dims.data(), NULL);
2118     }
2119     else
2120     {
2121         int *data = NULL;
2122         getHandleIntVectorProperty(uid, __GO_USER_DATA__, &data);
2123
2124         types::InternalType* pUD = nullptr;
2125         if (size == 1)
2126         {
2127             //32 bits
2128             int* p = (int*)data;
2129             pUD = ((types::InternalType*) * p);
2130         }
2131         else
2132         {
2133             //64 bits
2134             long long* p = (long long*)data;
2135             pUD = ((types::InternalType*) * p);
2136         }
2137
2138         export_data(parent, "userdata", pUD);
2139         //do not release, data is a reference on data in model
2140         //releaseGraphicObjectProperty(__GO_USER_DATA__, data, jni_int_vector, size);
2141     }
2142
2143     return true;
2144 }
2145
2146 static bool export_handle_datatips(int parent, int uid)
2147 {
2148     int count = 0;
2149     getHandleIntProperty(uid, __GO_DATATIPS_COUNT__, &count);
2150     int node = openList6(parent, "datatips", g_SCILAB_CLASS_HANDLE);
2151     int* datatips = nullptr;
2152
2153     if (count != 0)
2154     {
2155         getHandleIntVectorProperty(uid, __GO_DATATIPS__, &datatips);
2156     }
2157
2158     for (int i = 0; i < count; ++i)
2159     {
2160         if (export_handle(node, std::to_string(i), datatips[i]) == false)
2161         {
2162             releaseGraphicObjectProperty(__GO_DATATIPS__, datatips, jni_int_vector, count);
2163             closeList6(node);
2164             return false;
2165         }
2166     }
2167
2168     releaseGraphicObjectProperty(__GO_DATATIPS__, datatips, jni_int_vector, count);
2169     closeList6(node);
2170     return true;
2171 }
2172
2173 static bool export_handle_border(int dataset, int uid);
2174
2175 static bool export_handle_border_none(int dataset, int uid)
2176 {
2177     //nothing to do
2178     closeList6(dataset);
2179     return true;
2180 }
2181
2182 static bool export_handle_border_line(int dataset, int uid)
2183 {
2184     bool ret = false;
2185     int dims[2];
2186     dims[0] = 1;
2187     dims[1] = 1;
2188
2189     //color
2190     char* color = nullptr;
2191     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_COLOR__, &color);
2192     writeStringMatrix6(dataset, "color", 2, dims, &color);
2193     releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_COLOR__, color, jni_string, 1);
2194
2195     //thickness
2196     int thickness = 0;
2197     ret = getHandleIntProperty(uid, __GO_LINE_THICKNESS__, &thickness);
2198     if (ret)
2199     {
2200         writeIntegerMatrix6(dataset, "thickness", H5T_NATIVE_INT32, "32", 2, dims, &thickness);
2201     }
2202
2203     //rounded
2204     int rounded = 0;
2205     ret = getHandleBoolProperty(uid, __GO_UI_FRAME_BORDER_ROUNDED__, &rounded);
2206     if (ret)
2207     {
2208         writeBooleanMatrix6(dataset, "rounded", 2, dims, &rounded);
2209     }
2210
2211     closeList6(dataset);
2212     return true;
2213 }
2214
2215 static bool export_handle_border_bevel(int dataset, int uid)
2216 {
2217     bool ret = false;
2218     int dims[2];
2219     dims[0] = 1;
2220     dims[1] = 1;
2221     char* data = nullptr;
2222
2223     //type
2224     int type = 0;
2225     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_TYPE__, &type);
2226     if (ret)
2227     {
2228         writeIntegerMatrix6(dataset, "type", H5T_NATIVE_INT32, "32", 2, dims, &type);
2229     }
2230
2231     //highlight out
2232     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, &data);
2233     if (data)
2234     {
2235         writeStringMatrix6(dataset, "highlight_out", 2, dims, &data);
2236         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, data, jni_string, 1);
2237     }
2238
2239     //highlight in
2240     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_HIGHLIGHT_IN__, &data);
2241     if (data)
2242     {
2243         writeStringMatrix6(dataset, "highlight_in", 2, dims, &data);
2244         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_HIGHLIGHT_IN__, data, jni_string, 1);
2245     }
2246
2247     //shadow out
2248     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_SHADOW_OUT__, &data);
2249     if (data)
2250     {
2251         writeStringMatrix6(dataset, "shadow_out", 2, dims, &data);
2252         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_SHADOW_OUT__, data, jni_string, 1);
2253     }
2254
2255     //shadow in
2256     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_SHADOW_IN__, &data);
2257     if (data)
2258     {
2259         writeStringMatrix6(dataset, "shadow_in", 2, dims, &data);
2260         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_SHADOW_IN__, data, jni_string, 1);
2261     }
2262     closeList6(dataset);
2263     return true;
2264 }
2265
2266 static bool export_handle_border_soft_bevel(int dataset, int uid)
2267 {
2268     return export_handle_border_bevel(dataset, uid);
2269 }
2270
2271 static bool export_handle_border_etched(int dataset, int uid)
2272 {
2273     bool ret = false;
2274     int dims[2];
2275     dims[0] = 1;
2276     dims[1] = 1;
2277     char* data = nullptr;
2278
2279     //type
2280     int type = 0;
2281     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_TYPE__, &type);
2282     if (ret)
2283     {
2284         writeIntegerMatrix6(dataset, "type", H5T_NATIVE_INT32, "32", 2, dims, &type);
2285     }
2286
2287     //highlight out
2288     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, &data);
2289     if (data)
2290     {
2291         writeStringMatrix6(dataset, "highlight_out", 2, dims, &data);
2292         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_HIGHLIGHT_OUT__, data, jni_string, 1);
2293     }
2294
2295     //shadow out
2296     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_SHADOW_OUT__, &data);
2297     if (data)
2298     {
2299         writeStringMatrix6(dataset, "shadow_out", 2, dims, &data);
2300         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_SHADOW_OUT__, data, jni_string, 1);
2301     }
2302
2303     closeList6(dataset);
2304     return true;
2305 }
2306
2307 static bool export_handle_border_titled(int dataset, int uid)
2308 {
2309     bool ret = false;
2310     int dims[2];
2311     dims[0] = 1;
2312     dims[1] = 1;
2313     char* data = nullptr;
2314
2315     //title_border
2316     int title = 0;
2317     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_TITLE__, &title);
2318     if (ret)
2319     {
2320         int node = openList6(dataset, "title_border", g_SCILAB_CLASS_HANDLE);
2321         export_handle_border(node, title);
2322     }
2323
2324     //title
2325     getHandleStringProperty(uid, __GO_TITLE__, &data);
2326     if (data)
2327     {
2328         writeStringMatrix6(dataset, "title", 2, dims, &data);
2329         releaseGraphicObjectProperty(__GO_TITLE__, data, jni_string, 1);
2330     }
2331
2332     //justification
2333     int justification = 0;
2334     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_JUSTIFICATION__, &justification);
2335     if (ret)
2336     {
2337         writeIntegerMatrix6(dataset, "justification", H5T_NATIVE_INT32, "32", 2, dims, &justification);
2338     }
2339
2340     //fontname
2341     getHandleStringProperty(uid, __GO_UI_FONTNAME__, &data);
2342     if (data)
2343     {
2344         writeStringMatrix6(dataset, "fontname", 2, dims, &data);
2345         releaseGraphicObjectProperty(__GO_UI_FONTNAME__, data, jni_string, 1);
2346         data = nullptr;
2347     }
2348
2349     //fontangle
2350     getHandleStringProperty(uid, __GO_UI_FONTANGLE__, &data);
2351     if (data)
2352     {
2353         writeStringMatrix6(dataset, "fontangle", 2, dims, &data);
2354         releaseGraphicObjectProperty(__GO_UI_FONTANGLE__, data, jni_string, 1);
2355         data = nullptr;
2356     }
2357
2358     //fontsize
2359     int fonsize = 0;
2360     ret = getHandleIntProperty(uid, __GO_UI_FONTSIZE__, &fonsize);
2361     if (ret)
2362     {
2363         writeIntegerMatrix6(dataset, "fontsize", H5T_NATIVE_INT32, "32", 2, dims, &fonsize);
2364     }
2365
2366     //fontweight
2367     getHandleStringProperty(uid, __GO_UI_FONTWEIGHT__, &data);
2368     if (data)
2369     {
2370         writeStringMatrix6(dataset, "fontweight", 2, dims, &data);
2371         releaseGraphicObjectProperty(__GO_UI_FONTWEIGHT__, data, jni_string, 1);
2372         data = nullptr;
2373     }
2374
2375     //position
2376     int position = 0;
2377     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_POSITION__, &position);
2378     if (ret)
2379     {
2380         writeIntegerMatrix6(dataset, "position", H5T_NATIVE_INT32, "32", 2, dims, &position);
2381     }
2382
2383     //color
2384     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_COLOR__, &data);
2385     if (data)
2386     {
2387         writeStringMatrix6(dataset, "color", 2, dims, &data);
2388         releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_COLOR__, data, jni_string, 1);
2389         data = nullptr;
2390     }
2391
2392     closeList6(dataset);
2393     return true;
2394 }
2395
2396 static bool export_handle_border_empty(int dataset, int uid)
2397 {
2398     int dims[2];
2399     dims[0] = 1;
2400     dims[1] = 4;
2401     double* pos = nullptr;
2402
2403     //position
2404     getHandleDoubleVectorProperty(uid, __GO_POSITION__, &pos);
2405     if (pos)
2406     {
2407         writeDoubleMatrix6(dataset, "position", 2, dims, pos);
2408         releaseGraphicObjectProperty(__GO_POSITION__, pos, jni_double_vector, 4);
2409     }
2410
2411     closeList6(dataset);
2412     return true;
2413 }
2414
2415 static bool export_handle_border_compound(int dataset, int uid)
2416 {
2417     bool ret = false;
2418     //out_border
2419     int out_border = 0;
2420
2421     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_OUT_BORDER__, &out_border);
2422     if (ret)
2423     {
2424         int node = openList6(dataset, "out_border", g_SCILAB_CLASS_HANDLE);
2425         export_handle_border(node, out_border);
2426
2427         //title_border
2428         int in_border = 0;
2429         getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_IN_BORDER__, &in_border);
2430         node = openList6(dataset, "in_border", g_SCILAB_CLASS_HANDLE);
2431         export_handle_border(node, in_border);
2432     }
2433
2434     closeList6(dataset);
2435     return true;
2436 }
2437
2438 static bool export_handle_border_matte(int dataset, int uid)
2439 {
2440     int dims[2];
2441     dims[0] = 1;
2442     dims[1] = 4;
2443     char* data = nullptr;
2444     double* pos = nullptr;
2445
2446     //position
2447     dims[0] = 1;
2448     dims[1] = 4;
2449     getHandleDoubleVectorProperty(uid, __GO_POSITION__, &pos);
2450     writeDoubleMatrix6(dataset, "position", 2, dims, pos);
2451     releaseGraphicObjectProperty(__GO_POSITION__, pos, jni_double_vector, 4);
2452
2453     //color
2454     dims[0] = 1;
2455     dims[1] = 1;
2456     getHandleStringProperty(uid, __GO_UI_FRAME_BORDER_COLOR__, &data);
2457     writeStringMatrix6(dataset, "color", 2, dims, &data);
2458     releaseGraphicObjectProperty(__GO_UI_FRAME_BORDER_COLOR__, data, jni_string, 1);
2459
2460     closeList6(dataset);
2461     return true;
2462 }
2463
2464 static bool export_handle_border(int dataset, int uid)
2465 {
2466     int style = 0;
2467     getHandleIntProperty(uid, __GO_UI_FRAME_BORDER_STYLE__, &style);
2468     int dims[2];
2469     dims[0] = 1;
2470     dims[1] = 1;
2471
2472     writeIntegerMatrix6(dataset, "style", H5T_NATIVE_INT32, "32", 2, dims, &style);
2473
2474     switch (style)
2475     {
2476         default:
2477         case NONE:
2478             return export_handle_border_none(dataset, uid);
2479         case LINE:
2480             return export_handle_border_line(dataset, uid);
2481         case BEVEL:
2482             return export_handle_border_bevel(dataset, uid);
2483         case SOFTBEVEL:
2484             return export_handle_border_soft_bevel(dataset, uid);
2485         case ETCHED:
2486             return export_handle_border_etched(dataset, uid);
2487         case TITLED:
2488             return export_handle_border_titled(dataset, uid);
2489         case EMPTY:
2490             return export_handle_border_empty(dataset, uid);
2491         case COMPOUND:
2492             return export_handle_border_compound(dataset, uid);
2493         case MATTE:
2494             return export_handle_border_matte(dataset, uid);
2495     }
2496 }
2497
2498 static bool export_handle_uicontrol(int parent, int uid)
2499 {
2500     bool ret = false;
2501     if (export_handle_generic(parent, uid, UicontrolHandle::getPropertyList()) == false)
2502     {
2503         return false;
2504     }
2505
2506     //string
2507     int size = 0;
2508     getHandleIntProperty(uid, __GO_UI_STRING_SIZE__, &size);
2509     int col = 0;
2510     getHandleIntProperty(uid, __GO_UI_STRING_COLNB__, &col);
2511
2512     int dims[2];
2513
2514     if (col == 0)
2515     {
2516         dims[0] = 1;
2517         dims[1] = 1;
2518         char* empty = "";
2519         writeStringMatrix6(parent, "string", 2, dims, &empty);
2520
2521     }
2522     else
2523     {
2524         int row = size / col;
2525         dims[0] = row;
2526         dims[1] = col;
2527         char** string = nullptr;
2528         getHandleStringVectorProperty(uid, __GO_UI_STRING__, &string);
2529         writeStringMatrix6(parent, "string", 2, dims, string);
2530         releaseGraphicObjectProperty(__GO_UI_STRING__, string, jni_string_vector, size);
2531     }
2532
2533     //border
2534     int border = 0;
2535     ret = getHandleIntProperty(uid, __GO_UI_FRAME_BORDER__, &border);
2536     if (ret)
2537     {
2538         int ub = openList6(parent, "border", g_SCILAB_CLASS_HANDLE);
2539         export_handle_border(ub, border);
2540     }
2541
2542     closeList6(parent);
2543     return true;
2544 }
2545
2546
2547 static bool export_handle_uicontextmenu(int parent, int uid)
2548 {
2549     if (export_handle_generic(parent, uid, UicontextmenuHandle::getPropertyList()) == false)
2550     {
2551         return false;
2552     }
2553
2554     closeList6(parent);
2555     return true;
2556 }
2557
2558 static bool export_handle_uimenu(int parent, int uid)
2559 {
2560     if (export_handle_generic(parent, uid, UimenuHandle::getPropertyList()) == false)
2561     {
2562         return false;
2563     }
2564
2565     closeList6(parent);
2566     return true;
2567 }
2568
2569 static bool export_handle_light(int parent, int uid)
2570 {
2571     if (export_handle_generic(parent, uid, LightHandle::getPropertyList()) == false)
2572     {
2573         return false;
2574     }
2575
2576     closeList6(parent);
2577     return true;
2578 }
2579
2580 static bool export_handle_axis(int parent, int uid)
2581 {
2582     if (export_handle_generic(parent, uid, AxisHandle::getPropertyList()) == false)
2583     {
2584         return false;
2585     }
2586
2587     closeList6(parent);
2588     return true;
2589 }
2590
2591 static bool export_handle_text(int parent, int uid)
2592 {
2593     if (export_handle_generic(parent, uid, TextHandle::getPropertyList()) == false)
2594     {
2595         return false;
2596     }
2597
2598     //text
2599     int* dims = nullptr;
2600     getHandleIntVectorProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, &dims);
2601     char** text;
2602     getHandleStringVectorProperty(uid, __GO_TEXT_STRINGS__, &text);
2603     writeStringMatrix6(parent, "text", 2, dims, text);
2604     closeList6(parent);
2605     return true;
2606 }
2607
2608 //find parent axes of a entity and return path ( via children index )
2609 bool get_entity_path(int entity, std::vector<int>& path)
2610 {
2611     path.clear();
2612
2613     while (true)
2614     {
2615         int parent = 0;
2616         getHandleIntProperty(entity, __GO_PARENT__, &parent);
2617         int count = 0;
2618         getHandleIntProperty(parent, __GO_CHILDREN_COUNT__, &count);
2619         //get children of parent to find "my" index
2620         int* children = nullptr;
2621         getHandleIntVectorProperty(parent, __GO_CHILDREN__, &children);
2622         bool find = false;
2623         for (int i = 0; i < count; ++i)
2624         {
2625             if (children[i] == entity)
2626             {
2627                 path.push_back(i);
2628                 find = true;
2629                 break;
2630             }
2631         }
2632
2633         releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
2634         if (find == false)
2635         {
2636             return false;
2637         }
2638
2639         int type = 0;
2640         getHandleIntProperty(parent, __GO_TYPE__, &type);
2641         if (type == __GO_AXES__)
2642         {
2643             break;
2644         }
2645
2646         entity = parent;
2647     }
2648
2649     return true;
2650 }
2651
2652 static bool export_handle_legend(int parent, int uid)
2653 {
2654     if (export_handle_generic(parent, uid, LegendHandle::getPropertyList()) == false)
2655     {
2656         return false;
2657     }
2658
2659     //links
2660     int node = openList6(parent, "links", g_SCILAB_CLASS_HANDLE);
2661     int link = 0;
2662     getHandleIntProperty(uid, __GO_LINKS_COUNT__, &link);
2663     int* links = nullptr;
2664     getHandleIntVectorProperty(uid, __GO_LINKS__, &links);
2665     for (int i = 0; i < link; ++i)
2666     {
2667         std::vector<int> path;
2668         if (get_entity_path(links[i], path))
2669         {
2670             int dims[2];
2671             dims[0] = 1;
2672             dims[1] = static_cast<int>(path.size());
2673             writeIntegerMatrix6(node, std::to_string(i).data(), H5T_NATIVE_INT32, "32", 2, dims, path.data());
2674         }
2675     }
2676
2677     releaseGraphicObjectProperty(__GO_LINKS__, links, jni_int_vector, link);
2678     closeList6(node);
2679
2680     //text
2681     int* dims = nullptr;
2682     getHandleIntVectorProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, &dims);
2683     char** text;
2684     getHandleStringVectorProperty(uid, __GO_TEXT_STRINGS__, &text);
2685     writeStringMatrix6(parent, "text", 2, dims, text);
2686     closeList6(parent);
2687     return true;
2688 }
2689
2690 static bool export_handle_fec(int parent, int uid)
2691 {
2692     if (export_handle_generic(parent, uid, FecHandle::getPropertyList()) == false)
2693     {
2694         return false;
2695     }
2696
2697     //triangles
2698     int indices = 0;
2699     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_INDICES__, &indices);
2700     int vect = 0;
2701     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_VERTICES_BY_ELEM__, &vect);
2702     double* triangles = nullptr;
2703     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_FEC_ELEMENTS__, &triangles);
2704
2705     int dims[2];
2706     dims[0] = indices;
2707     dims[1] = vect + 2;
2708     writeDoubleMatrix6(parent, "triangles", 2, dims, triangles);
2709     releaseGraphicObjectProperty(__GO_DATA_MODEL_FEC_ELEMENTS__, triangles, jni_double_vector, dims[0] * dims[1]);
2710
2711     closeList6(parent);
2712     return true;
2713 }
2714
2715 static bool export_handle_matplot(int parent, int uid)
2716 {
2717     if (export_handle_generic(parent, uid, MatplotHandle::getPropertyList()) == false)
2718     {
2719         return false;
2720     }
2721
2722     int row = 0;
2723     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_X__, &row);
2724     int col = 0;
2725     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_Y__, &col);
2726     int datatype = 0;
2727     getHandleIntProperty(uid, __GO_DATA_MODEL_MATPLOT_DATA_TYPE__, &datatype);
2728     int imagetype = 0;
2729     getHandleIntProperty(uid, __GO_DATA_MODEL_MATPLOT_IMAGE_TYPE__, &imagetype);
2730     int size = (row - 1) * (col - 1);
2731
2732     //data can be char, uchar, short, ushort, ... hide in a double*
2733     //save double like this but need to compute exact dimensions to
2734     //store it
2735
2736     double* data = nullptr;
2737     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &data);
2738
2739     switch (datatype)
2740     {
2741         case MATPLOT_Char:
2742         case MATPLOT_HM1_Char:
2743         case MATPLOT_HM1_UChar:
2744             size /= (sizeof(double) / sizeof(char));
2745             break;
2746         case MATPLOT_HM3_Char:
2747         case MATPLOT_HM3_UChar:
2748             size /= (sizeof(double) / sizeof(char));
2749             size *= 3;
2750             break;
2751
2752         case MATPLOT_HM3_Double:
2753             size *= 3;
2754             break;
2755         case MATPLOT_HM4_Char:
2756         case MATPLOT_HM4_UChar:
2757             size /= (sizeof(double) / sizeof(char));
2758             size *= 4;
2759             break;
2760         case MATPLOT_HM4_Double:
2761             size *= 4;
2762             break;
2763         case MATPLOT_UChar:
2764             size /= (sizeof(double) / sizeof(char));
2765             if ((ImageType)imagetype == MATPLOT_RGB)
2766             {
2767                 size *= 3;
2768             }
2769             else if ((GLType)imagetype == MATPLOT_GL_RGBA)
2770             {
2771                 size *= 4;
2772             }
2773             break;
2774         case MATPLOT_Int:
2775         case MATPLOT_UInt:
2776             size /= (sizeof(double) / sizeof(int));
2777             break;
2778         case MATPLOT_Short:
2779         case MATPLOT_UShort:
2780             size /= (sizeof(double) / sizeof(short));
2781             break;
2782         case MATPLOT_Double:
2783         case MATPLOT_HM1_Double:
2784         default:
2785             break;
2786     }
2787
2788     int dims[2];
2789     dims[0] = 1;
2790     dims[1] = size;
2791
2792     writeDoubleMatrix6(parent, "data", 2, dims, data);
2793     releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, data, jni_double_vector, size);
2794     closeList6(parent);
2795     return true;
2796 }
2797
2798 static bool export_handle_grayplot(int parent, int uid)
2799 {
2800     if (export_handle_generic(parent, uid, GrayplotHandle::getPropertyList()) == false)
2801     {
2802         return false;
2803     }
2804
2805     int row = 0;
2806     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_X__, &row);
2807     int col = 0;
2808     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_Y__, &col);
2809
2810     double* dataX = nullptr;
2811     double* dataY = nullptr;
2812     double* dataZ = nullptr;
2813
2814     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
2815     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
2816     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
2817
2818     int dims[2];
2819     dims[0] = 1;
2820     dims[1] = row;
2821     writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
2822
2823     dims[0] = 1;
2824     dims[1] = col;
2825     writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
2826
2827     dims[0] = row;
2828     dims[1] = col;
2829     writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
2830
2831     closeList6(parent);
2832     return true;
2833 }
2834
2835 static bool export_handle_segs(int parent, int uid)
2836 {
2837     if (export_handle_generic(parent, uid, SegsHandle::getPropertyList()) == false)
2838     {
2839         return false;
2840     }
2841
2842     closeList6(parent);
2843     return true;
2844 }
2845
2846 static bool export_handle_arc(int parent, int uid)
2847 {
2848     if (export_handle_generic(parent, uid, ArcHandle::getPropertyList()) == false)
2849     {
2850         return false;
2851     }
2852
2853     closeList6(parent);
2854     return true;
2855 }
2856
2857 static bool export_handle_rectangle(int parent, int uid)
2858 {
2859     if (export_handle_generic(parent, uid, RectangleHandle::getPropertyList()) == false)
2860     {
2861         return false;
2862     }
2863
2864     closeList6(parent);
2865     return true;
2866 }
2867
2868 static bool export_handle_datatip(int parent, int uid)
2869 {
2870     if (export_handle_generic(parent, uid, DatatipHandle::getPropertyList()) == false)
2871     {
2872         return false;
2873     }
2874
2875     closeList6(parent);
2876     return true;
2877 }
2878
2879 static bool export_handle_polyline_shift(int parent, int uid, const std::string& name, int go_set, int go_data)
2880 {
2881     int set = 0;
2882     getHandleBoolProperty(uid, go_set, &set);
2883     if (set)
2884     {
2885         int count = 0;
2886         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_ELEMENTS__, &count);
2887         double* data = nullptr;
2888         getHandleDoubleVectorProperty(uid, go_data, &data);
2889
2890         int dims[2];
2891         dims[0] = 1;
2892         dims[1] = count;
2893         writeDoubleMatrix6(parent, name.data(), 2, dims, data);
2894
2895         releaseGraphicObjectProperty(uid, data, jni_double_vector, count);
2896     }
2897     else
2898     {
2899         int dims[2];
2900         dims[0] = 0;
2901         dims[1] = 0;
2902         writeDoubleMatrix6(parent, name.data(), 2, dims, NULL);
2903     }
2904
2905     return true;
2906 }
2907
2908 static bool export_handle_polyline(int parent, int uid)
2909 {
2910     if (export_handle_datatips(parent, uid) == false)
2911     {
2912         return false;
2913     }
2914
2915     if (export_handle_generic(parent, uid, PolylineHandle::getPropertyList()) == false)
2916     {
2917         return false;
2918     }
2919
2920     //x_shift
2921     export_handle_polyline_shift(parent, uid, "x_shift", __GO_DATA_MODEL_X_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_X_COORDINATES_SHIFT__);
2922     //y_shift
2923     export_handle_polyline_shift(parent, uid, "y_shift", __GO_DATA_MODEL_Y_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Y_COORDINATES_SHIFT__);
2924     //z_shift
2925     export_handle_polyline_shift(parent, uid, "z_shift", __GO_DATA_MODEL_Z_COORDINATES_SHIFT_SET__, __GO_DATA_MODEL_Z_COORDINATES_SHIFT__);
2926
2927     //interp_color_vector
2928     int set = 0;
2929     getHandleBoolProperty(uid, __GO_INTERP_COLOR_VECTOR_SET__, &set);
2930     if (set)
2931     {
2932         int count = 0;
2933         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_ELEMENTS__, &count);
2934         int* data = nullptr;
2935         getHandleIntVectorProperty(uid, __GO_INTERP_COLOR_VECTOR__, &data);
2936
2937         int dims[2];
2938         dims[0] = 1;
2939         dims[1] = count;
2940         writeIntegerMatrix6(parent, "interp_color_vector", H5T_NATIVE_INT32, "32", 2, dims, data);
2941         releaseGraphicObjectProperty(uid, data, jni_int_vector, count);
2942     }
2943     else
2944     {
2945         int dims[2];
2946         dims[0] = 0;
2947         dims[1] = 0;
2948         writeIntegerMatrix6(parent, "interp_color_vector", H5T_NATIVE_INT32, "32", 2, dims, NULL);
2949     }
2950
2951     //data
2952     int count = 0;
2953     getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_ELEMENTS__, &count);
2954
2955     int dims[2];
2956     dims[0] = 1;
2957     dims[1] = count;
2958
2959     double* dataX = nullptr;
2960     double* dataY = nullptr;
2961     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
2962     getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
2963
2964     writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
2965     writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
2966
2967     releaseGraphicObjectProperty(__GO_DATA_MODEL_X__, dataX, jni_double_vector, count);
2968     releaseGraphicObjectProperty(__GO_DATA_MODEL_Y__, dataY, jni_double_vector, count);
2969
2970     getHandleIntProperty(uid, __GO_DATA_MODEL_Z_COORDINATES_SET__, &set);
2971     if (set)
2972     {
2973         double* dataZ = nullptr;
2974         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
2975         writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
2976         releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, dataZ, jni_double_vector, count);
2977     }
2978     else
2979     {
2980         //[]
2981         dims[0] = 0;
2982         dims[1] = 0;
2983         writeDoubleMatrix6(parent, "data_z", 2, dims, NULL);
2984     }
2985
2986     closeList6(parent);
2987     return true;
2988 }
2989
2990 static bool export_handle_surface(int parent, int uid)
2991 {
2992     return export_handle_generic(parent, uid, SurfaceHandle::getPropertyList());
2993 }
2994
2995 static bool export_handle_plot3d(int parent, int uid)
2996 {
2997     bool ret = export_handle_surface(parent, uid);
2998     if (ret)
2999     {
3000         double* colors = NULL;
3001         double* dataX = NULL;
3002         double* dataY = NULL;
3003         double* dataZ = NULL;
3004
3005         //data
3006         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
3007         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
3008         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
3009
3010         int row = 0;
3011         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_X__, &row);
3012         int col = 0;
3013         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_Y__, &col);
3014
3015         int* xDims = nullptr;
3016         int* yDims = nullptr;
3017         getHandleIntVectorProperty(uid, __GO_DATA_MODEL_X_DIMENSIONS__, &xDims);
3018         getHandleIntVectorProperty(uid, __GO_DATA_MODEL_Y_DIMENSIONS__, &yDims);
3019
3020         int dims[2];
3021         dims[0] = xDims[0];
3022         dims[1] = xDims[1];
3023         writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
3024         releaseGraphicObjectProperty(__GO_DATA_MODEL_X__, dataX, jni_double_vector, dims[0] * dims[1]);
3025
3026         dims[0] = yDims[0];
3027         dims[1] = yDims[1];
3028         writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
3029         releaseGraphicObjectProperty(__GO_DATA_MODEL_Y__, dataY, jni_double_vector, dims[0] * dims[1]);
3030
3031         dims[0] = row;
3032         dims[1] = col;
3033         writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
3034         releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, dataZ, jni_double_vector, dims[0] * dims[1]);
3035
3036         releaseGraphicObjectProperty(__GO_DATA_MODEL_X_DIMENSIONS__, xDims, jni_int_vector, 2);
3037         releaseGraphicObjectProperty(__GO_DATA_MODEL_Y_DIMENSIONS__, dataZ, jni_int_vector, 2);
3038     }
3039
3040     closeList6(parent);
3041     return ret;
3042 }
3043
3044 static bool export_handle_fac3d(int parent, int uid)
3045 {
3046     bool ret = export_handle_surface(parent, uid);
3047     if (ret)
3048     {
3049         double* colors = NULL;
3050         double* dataX = NULL;
3051         double* dataY = NULL;
3052         double* dataZ = NULL;
3053
3054         //data
3055         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_X__, &dataX);
3056         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Y__, &dataY);
3057         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_Z__, &dataZ);
3058
3059         int row = 0;
3060         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_VERTICES_PER_GON__, &row);
3061         int col = 0;
3062         getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_GONS__, &col);
3063
3064         int dims[2];
3065         dims[0] = row;
3066         dims[1] = col;
3067
3068         writeDoubleMatrix6(parent, "data_x", 2, dims, dataX);
3069         writeDoubleMatrix6(parent, "data_y", 2, dims, dataY);
3070         writeDoubleMatrix6(parent, "data_z", 2, dims, dataZ);
3071
3072         releaseGraphicObjectProperty(__GO_DATA_MODEL_X__, dataX, jni_double_vector, dims[0] * dims[1]);
3073         releaseGraphicObjectProperty(__GO_DATA_MODEL_Y__, dataY, jni_double_vector, dims[0] * dims[1]);
3074         releaseGraphicObjectProperty(__GO_DATA_MODEL_Z__, dataZ, jni_double_vector, dims[0] * dims[1]);
3075
3076         getHandleDoubleVectorProperty(uid, __GO_DATA_MODEL_COLORS__, &colors);
3077         if (colors)
3078         {
3079             int numColors = 0;
3080             getHandleIntProperty(uid, __GO_DATA_MODEL_NUM_COLORS__, &numColors);
3081             if (numColors == col)
3082             {
3083                 dims[0] = 1;
3084             }
3085             else
3086             {
3087                 dims[0] = row;
3088             }
3089
3090             dims[1] = col;
3091         }
3092         else
3093         {
3094             //export []
3095             dims[0] = 0;
3096             dims[1] = 0;
3097         }
3098
3099         writeDoubleMatrix6(parent, "colors", 2, dims, colors);
3100         releaseGraphicObjectProperty(__GO_DATA_MODEL_COLORS__, colors, jni_double_vector, dims[0] * dims[1]);
3101
3102         //cdata_mapping
3103         int cdata = 0;
3104         getHandleIntProperty(uid, __GO_DATA_MAPPING__, &cdata);
3105         dims[0] = 1;
3106         dims[1] = 1;
3107         writeIntegerMatrix6(parent, "cdata_mapping", H5T_NATIVE_INT32, "32", 2, dims, &cdata);
3108
3109     }
3110
3111     closeList6(parent);
3112     return ret;
3113 }
3114
3115
3116 static bool export_handle_champ(int parent, int uid)
3117 {
3118     if (export_handle_generic(parent, uid, ChampHandle::getPropertyList()) == false)
3119     {
3120         return false;
3121     }
3122
3123     //data
3124     int* dimensions = NULL;
3125     double* arrowBasesX = NULL;
3126     double* arrowBasesY = NULL;
3127     double* arrowDirectionsX = NULL;
3128     double* arrowDirectionsY = NULL;
3129     int dims[2];
3130     getHandleIntVectorProperty(uid, __GO_CHAMP_DIMENSIONS__, &dimensions);
3131
3132     //base X
3133     getHandleDoubleVectorProperty(uid, __GO_BASE_X__, &arrowBasesX);
3134     dims[0] = 1;
3135     dims[1] = dimensions[0];
3136     writeDoubleMatrix(parent, "base_x", 2, dims, arrowBasesX);
3137     releaseGraphicObjectProperty(__GO_BASE_X__, arrowBasesX, jni_double_vector, dims[1]);
3138
3139     //base y
3140     getHandleDoubleVectorProperty(uid, __GO_BASE_Y__, &arrowBasesY);
3141     dims[0] = 1;
3142     dims[1] = dimensions[1];
3143     writeDoubleMatrix(parent, "base_y", 2, dims, arrowBasesY);
3144     releaseGraphicObjectProperty(__GO_BASE_Y__, arrowBasesY, jni_double_vector, dims[1]);
3145
3146     //direction x
3147     getHandleDoubleVectorProperty(uid, __GO_DIRECTION_X__, &arrowDirectionsX);
3148     dims[0] = dimensions[0];
3149     dims[1] = dimensions[1];
3150     writeDoubleMatrix(parent, "direction_x", 2, dims, arrowDirectionsX);
3151     releaseGraphicObjectProperty(__GO_DIRECTION_X__, arrowDirectionsX, jni_double_vector, dims[0] * dims[1]);
3152
3153     //direction y
3154     getHandleDoubleVectorProperty(uid, __GO_DIRECTION_Y__, &arrowDirectionsY);
3155     dims[0] = dimensions[0];
3156     dims[1] = dimensions[1];
3157     writeDoubleMatrix(parent, "direction_y", 2, dims, arrowDirectionsY);
3158     releaseGraphicObjectProperty(__GO_DIRECTION_Y__, arrowDirectionsY, jni_double_vector, dims[0] * dims[1]);
3159
3160     releaseGraphicObjectProperty(__GO_CHAMP_DIMENSIONS__, dimensions, jni_int_vector, 2);
3161     closeList6(parent);
3162     return true;
3163 }
3164 static bool export_handle_label(int parent, int uid)
3165 {
3166     if (export_handle_generic(parent, uid, LabelHandle::getPropertyList()) == false)
3167     {
3168         return false;
3169     }
3170
3171     //text
3172     int* dimensions = nullptr;
3173     char** text = nullptr;
3174
3175     getHandleIntVectorProperty(uid, __GO_TEXT_ARRAY_DIMENSIONS__, &dimensions);
3176     getHandleStringVectorProperty(uid, __GO_TEXT_STRINGS__, &text);
3177
3178     std::vector<int> dims = {dimensions[0], dimensions[1]};
3179     releaseGraphicObjectProperty(__GO_TEXT_ARRAY_DIMENSIONS__, dimensions, jni_int_vector, 2);
3180
3181     writeStringMatrix6(parent, "text", 2, dims.data(), text);
3182     releaseGraphicObjectProperty(__GO_TEXT_STRINGS__, text, jni_string_vector, dims[0] * dims[1]);
3183
3184     closeList6(parent);
3185     return true;
3186 }
3187 static bool export_handle_axes(int parent, int uid)
3188 {
3189     if (export_handle_generic(parent, uid, AxesHandle::getPropertyList()) == false)
3190     {
3191         return false;
3192     }
3193
3194     //title
3195     int title = 0;
3196     getHandleIntProperty(uid, __GO_TITLE__, &title);
3197     export_handle(parent, "title", title);
3198
3199     //x_label
3200     int x_label = 0;
3201     getHandleIntProperty(uid, __GO_X_AXIS_LABEL__, &x_label);
3202     export_handle(parent, "x_label", x_label);
3203
3204     //y_label
3205     int y_label = 0;
3206     getHandleIntProperty(uid, __GO_Y_AXIS_LABEL__, &y_label);
3207     export_handle(parent, "y_label", y_label);
3208
3209     //z_label
3210     int z_label = 0;
3211     getHandleIntProperty(uid, __GO_Z_AXIS_LABEL__, &z_label);
3212     export_handle(parent, "z_label", z_label);
3213
3214
3215     closeList6(parent);
3216     return true;
3217 }
3218
3219 static bool export_handle_figure(int parent, int uid)
3220 {
3221     if (export_handle_generic(parent, uid, FigureHandle::getPropertyList()) == false)
3222     {
3223         return false;
3224     }
3225
3226     //layout_options
3227     export_handle_layout_options(parent, uid);
3228
3229     closeList6(parent);
3230     return true;
3231 }
3232
3233 static bool export_handle_compound(int parent, int uid)
3234 {
3235     if (export_handle_generic(parent, uid, CompoundHandle::getPropertyList()) == false)
3236     {
3237         return false;
3238     }
3239
3240     closeList6(parent);
3241     return true;
3242 }
3243
3244 bool export_handle(int parent, const std::string& name, int uid)
3245 {
3246     //get handle type
3247     int type = 0;
3248     getHandleIntProperty(uid, __GO_TYPE__, &type);
3249
3250     //create handle node in __refs__
3251     int h = openList6(parent, name.data(), g_SCILAB_CLASS_HANDLE);
3252
3253     bool ret = false;
3254     switch (type)
3255     {
3256         case __GO_FIGURE__:
3257         {
3258             ret = export_handle_figure(h, uid);
3259             break;
3260         }
3261         case __GO_AXES__:
3262         {
3263             ret = export_handle_axes(h, uid);
3264             break;
3265         }
3266         case __GO_LABEL__:
3267         {
3268             ret = export_handle_label(h, uid);
3269             break;
3270         }
3271         case __GO_CHAMP__:
3272         {
3273             ret = export_handle_champ(h, uid);
3274             break;
3275         }
3276         case __GO_FAC3D__:
3277         {
3278             ret = export_handle_fac3d(h, uid);
3279             break;
3280         }
3281         case __GO_PLOT3D__:
3282         {
3283             ret = export_handle_plot3d(h, uid);
3284             break;
3285         }
3286         case __GO_POLYLINE__:
3287         {
3288             ret = export_handle_polyline(h, uid);
3289             break;
3290         }
3291         case __GO_DATATIP__:
3292         {
3293             ret = export_handle_datatip(h, uid);
3294             break;
3295         }
3296         case __GO_COMPOUND__:
3297         {
3298             ret = export_handle_compound(h, uid);
3299             break;
3300         }
3301         case __GO_RECTANGLE__:
3302         {
3303             ret = export_handle_rectangle(h, uid);
3304             break;
3305         }
3306         case __GO_ARC__:
3307         {
3308             ret = export_handle_arc(h, uid);
3309             break;
3310         }
3311         case __GO_SEGS__:
3312         {
3313             ret = export_handle_segs(h, uid);
3314             break;
3315         }
3316         case __GO_GRAYPLOT__:
3317         {
3318             ret = export_handle_grayplot(h, uid);
3319             break;
3320         }
3321         case __GO_MATPLOT__:
3322         {
3323             ret = export_handle_matplot(h, uid);
3324             break;
3325         }
3326         case __GO_FEC__:
3327         {
3328             ret = export_handle_fec(h, uid);
3329             break;
3330         }
3331         case __GO_LEGEND__:
3332         {
3333             ret = export_handle_legend(h, uid);
3334             break;
3335         }
3336         case __GO_TEXT__:
3337         {
3338             ret = export_handle_text(h, uid);
3339             break;
3340         }
3341         case __GO_AXIS__:
3342         {
3343             ret = export_handle_axis(h, uid);
3344             break;
3345         }
3346         case __GO_LIGHT__:
3347         {
3348             ret = export_handle_light(h, uid);
3349             break;
3350         }
3351         case __GO_UIMENU__:
3352         {
3353             ret = export_handle_uimenu(h, uid);
3354             break;
3355         }
3356         case __GO_UICONTEXTMENU__:
3357         {
3358             ret = export_handle_uicontextmenu(h, uid);
3359             break;
3360         }
3361         case __GO_UICONTROL__:
3362         {
3363             ret = export_handle_uicontrol(h, uid);
3364             break;
3365         }
3366         default:
3367         {
3368         }
3369
3370     }
3371
3372     return ret;
3373 }
3374
3375 static bool export_handle_children(int parent, int uid)
3376 {
3377     int count = 0;
3378     getHandleIntProperty(uid, __GO_CHILDREN_COUNT__, &count);
3379     int node = openList6(parent, "children", g_SCILAB_CLASS_HANDLE);
3380     int* children = nullptr;
3381
3382     if (count != 0)
3383     {
3384         getHandleIntVectorProperty(uid, __GO_CHILDREN__, &children);
3385     }
3386
3387     int index = 0;
3388     for (int i = 0; i < count; ++i)
3389     {
3390         int child = children[i];
3391         int hidden = 0;
3392         getHandleBoolProperty(child, __GO_HIDDEN__, &hidden);
3393         if (hidden == 0)
3394         {
3395             if (export_handle(node, std::to_string(index), child) == false)
3396             {
3397                 releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
3398                 closeList6(node);
3399                 return false;
3400             }
3401
3402             ++index;
3403         }
3404     }
3405
3406     releaseGraphicObjectProperty(__GO_CHILDREN__, children, jni_int_vector, count);
3407     closeList6(node);
3408     return true;
3409 }
3410
3411 int add_current_entity(int dataset)
3412 {
3413     int type = 0;
3414     getHandleInt(dataset, "type", &type);
3415
3416     switch (type)
3417     {
3418         case __GO_FIGURE__:
3419         {
3420             return import_handle(dataset, -1);
3421         }
3422         case __GO_AXES__:
3423         {
3424             //add handle to current figure
3425             getOrCreateDefaultSubwin();
3426             int iCurrentFigure = getCurrentFigure();
3427             return import_handle(dataset, iCurrentFigure);
3428         }
3429         case __GO_COMPOUND__:
3430         {
3431             int axes = getOrCreateDefaultSubwin();
3432             return import_handle(dataset, axes);
3433         }
3434         default:
3435             //add handle as child of current axes ( take care of compound ! )
3436             return -1;
3437     }
3438 }