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