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