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