Fix some localization issues
[scilab.git] / scilab / modules / graphics / src / c / getHandleProperty / set_data_property.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2002-2004 - INRIA - Djalel Abdemouche
4  * Copyright (C) 2004-2006 - INRIA - Fabrice Leray
5  * Copyright (C) 2006 - INRIA - Allan Cornet
6  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
7  * Copyright (C) 2010 - DIGITEO - Bruno JOFRET
8  * Copyright (C) 2010-2011 - DIGITEO - Manuel Juliachs
9  *
10  * This file must be used under the terms of the CeCILL.
11  * This source file is licensed as described in the file COPYING, which
12  * you should have received as part of this distribution.  The terms
13  * are also available at
14  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
15  *
16  */
17
18 /*------------------------------------------------------------------------*/
19 /* file: set_data_property.c                                              */
20 /* desc : function to modify in Scilab the data field of                  */
21 /*        a handle                                                        */
22 /*------------------------------------------------------------------------*/
23
24 #include <string.h>
25
26 #include "setHandleProperty.h"
27 #include "SetProperty.h"
28 #include "GetProperty.h"
29 #include "getPropertyAssignedValue.h"
30 #include "Scierror.h"
31 #include "localization.h"
32 #include "SetPropertyStatus.h"
33 #include "BasicAlgos.h"
34 #include "set_data_property.h"
35 #include "MALLOC.h"
36 #include "sci_types.h"
37 #include "api_scilab.h"
38
39 #include "graphicObjectProperties.h"
40 #include "setGraphicObjectProperty.h"
41 #include "getGraphicObjectProperty.h"
42 #include "Matplot.h"
43
44
45 /*--------------------------------------------------------------------------*/
46 /* F.Leray 29.04.05 */
47 /* the champ data is now set as a tlist (like for surface objects) */
48 /* setchampdata(pobj,cstk(l2), &l3, &numrow3, &numcol3, fname) */
49 int setchampdata(void* _pvCtx, char* pobjUID, AssignedList * tlist)
50 {
51     int nbRow[4];
52     int nbCol[4];
53
54     int numberArrows = 0;
55     int dimensions[2];
56
57     double* vx  = NULL;
58     double* vy  = NULL;
59     double* vfx = NULL;
60     double* vfy = NULL;
61
62     /* get parameters */
63     vx  = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &nbRow[0], &nbCol[0]);
64     vy  = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &nbRow[1], &nbCol[1]);
65     vfx = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &nbRow[2], &nbCol[2]);
66     vfy = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &nbRow[3], &nbCol[3]);
67
68     /* check dim */
69     if (nbCol[0] != 1 || nbCol[1] != 1)
70     {
71         Scierror(999, _("%s: Wrong type for input argument #%d: Columns vectors expected.\n"), "Tlist", 1);
72         return SET_PROPERTY_ERROR;
73     }
74
75     numberArrows = nbRow[0] * nbRow[1];
76     dimensions[0] = nbRow[0];
77     dimensions[1] = nbRow[1];
78
79     if (nbRow[2] != nbRow[0] || nbCol[2] != nbRow[1] || nbRow[3] != nbRow[2] || nbCol[3] != nbCol[2])
80     {
81         Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Incompatible lengths.\n"), "Tlist", 3, 4);
82         return SET_PROPERTY_ERROR;
83     }
84
85     if (nbRow[0] * nbCol[0] == 0 || nbRow[1] * nbCol[1] == 0 || nbRow[2] * nbCol[2] == 0 || nbRow[3] * nbCol[3] == 0)
86     {
87         return sciReturnEmptyMatrix(_pvCtx);
88     }
89
90     /* Update the champ's number of arrows and dimensions then set the coordinates */
91     setGraphicObjectProperty(pobjUID, __GO_NUMBER_ARROWS__, &numberArrows, jni_int, 1);
92     setGraphicObjectProperty(pobjUID, __GO_CHAMP_DIMENSIONS__, dimensions, jni_int_vector, 2);
93
94     setGraphicObjectProperty(pobjUID, __GO_BASE_X__, vx, jni_double_vector, dimensions[0]);
95     setGraphicObjectProperty(pobjUID, __GO_BASE_Y__, vy, jni_double_vector, dimensions[1]);
96     setGraphicObjectProperty(pobjUID, __GO_DIRECTION_X__, vfx, jni_double_vector, dimensions[0]*dimensions[1]);
97     setGraphicObjectProperty(pobjUID, __GO_DIRECTION_Y__, vfy, jni_double_vector, dimensions[0]*dimensions[1]);
98
99     return SET_PROPERTY_SUCCEED;
100 }
101
102 /*--------------------------------------------------------------------------*/
103 /* F.Leray 29.04.05 */
104 /* the grayplot data is now set as a tlist (like for surface and champ objects) */
105 /* setgrayplot(pobj,cstk(l2), &l3, &numrow3, &numcol3, fname) */
106 int setgrayplotdata(void* _pvCtx, char* pobjUID, AssignedList * tlist)
107 {
108     BOOL result;
109
110     int nbRow[3];
111     int nbCol[3];
112     int gridSize[4];
113
114     double* pvecx = NULL;
115     double* pvecy = NULL;
116     double* pvecz = NULL;
117
118     pvecx = getDoubleMatrixFromList(_pvCtx, tlist, 2, &nbRow[0], &nbCol[0]);
119     pvecy = getDoubleMatrixFromList(_pvCtx, tlist, 3, &nbRow[1], &nbCol[1]);
120     pvecz = getDoubleMatrixFromList(_pvCtx, tlist, 4, &nbRow[2], &nbCol[2]);
121
122     if (nbCol[0] != 1 || nbCol[1] != 1)
123     {
124         Scierror(999, _("%s: Wrong type for input argument #%d: Column vector expected.\n"), "Tlist", 1);
125         return SET_PROPERTY_ERROR;
126     }
127
128     if (nbRow[2] != nbRow[0] || nbCol[2] != nbRow[1])
129     {
130         Scierror(999, _("%s: Wrong size for input argument #%d: Incompatible length.\n"), "Tlist", 3);
131         /* Was previously: */
132 #if 0
133         Scierror(999, _("%s: Wrong size for input argument #%d: Incompatible length.\n"), "Tlist", "Tlist", 3);
134 #endif
135         return 0;
136     }
137
138     if (nbRow[0] * nbCol[0] == 0 || nbRow[1] * nbCol[1] == 0 || nbRow[2] * nbCol[2] == 0)
139     {
140         return sciReturnEmptyMatrix(_pvCtx);
141     }
142
143     /*
144      * Update the x and y vectors dimensions
145      * These vectors are column ones
146      */
147     gridSize[0] = nbRow[0];
148     gridSize[1] = 1;
149     gridSize[2] = nbRow[1];
150     gridSize[3] = 1;
151
152     /* Resizes the coordinates arrays if required */
153     result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
154
155     if (result == FALSE)
156     {
157         Scierror(999, _("%s: No more memory.\n"), "setgrayplotdata");
158         return SET_PROPERTY_ERROR;
159     }
160
161     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, nbRow[0]);
162     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, nbRow[1]);
163     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Z__, pvecz, jni_double_vector, nbRow[2]*nbCol[2]);
164
165     return SET_PROPERTY_SUCCEED;
166 }
167 /*--------------------------------------------------------------------------*/
168 /* set3ddata(pobj,cstk(l2), &l3, &numrow3, &numcol3) */
169 int set3ddata(void* _pvCtx, char* pobjUID, AssignedList * tlist)
170 {
171     int type = -1;
172     int *piType = &type;
173
174     int m1, n1, m2, n2, m3, n3;
175     int m3n, n3n;
176     int isFac3d;
177
178     double* pvecx = NULL;
179     double* pvecy = NULL;
180     double* pvecz = NULL;
181     int dimvectx = 0;
182     int dimvecty = 0;
183
184     double* inputColors;
185     int nbInputColors;
186
187     // number of specified colors
188     int nc = 0;
189
190     int izcol;
191
192     /* no copy now we just perform tests on the matrices */
193     pvecx = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m1, &n1);
194     pvecy = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m2, &n2);
195     pvecz = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m3, &n3);
196
197     if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1)
198     {
199         if (!(m1 == m2 && m2 == m3 && n1 == n2 && n2 == n3))
200         {
201             Scierror(999, _("%s: Wrong size for input arguments #%d, #%d and #%d: Incompatible lengths.\n"), "Tlist", 1, 2, 3);
202             return SET_PROPERTY_ERROR;
203         }
204     }
205     else
206     {
207         if (m2 * n2 != n3)
208         {
209             Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Incompatible lengths.\n"), "Tlist", 2, 3);
210             return SET_PROPERTY_ERROR;
211         }
212         if (m1 * n1 != m3)
213         {
214             Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Incompatible lengths.\n"), "Tlist", 1, 3);
215             return SET_PROPERTY_ERROR;
216         }
217         if (m1 * n1 <= 1 || m2 * n2 <= 1)
218         {
219             Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Should be >= %d.\n"), "Tlist", 1, 2, 2);
220             return SET_PROPERTY_ERROR;
221         }
222     }
223
224     if (m1 * n1 == 0 || m2 * n2 == 0 || m3 * n3 == 0)
225     {
226         return sciReturnEmptyMatrix(_pvCtx);
227     }
228
229     /* get color size if exists */
230     if (getAssignedListNbElement(tlist) == 4)
231     {
232         getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m3n, &n3n);
233         if (m3n * n3n == m3 * n3)
234         {
235             /* the color is a matrix, with same size as Z */
236             izcol = 2;
237         }
238         else if (m3n * n3n == n3 && (m3n == 1 || n3n == 1))
239         {
240             /* a vector with as many colors as facets */
241             izcol = 1;
242         }
243         else
244         {
245             Scierror(999, _("Wrong size for %s element: A %d-by-%d matrix or a vector of size %d expected.\n"), "color", m3, n3, n3);
246             return SET_PROPERTY_ERROR;
247         }
248     }
249     else
250     {
251         m3n = 0;
252         n3n = 0;
253         izcol = 0;
254     }
255
256     getGraphicObjectProperty(pobjUID, __GO_TYPE__, jni_int, (void **)&piType);
257
258     if (type == __GO_FAC3D__)
259     {
260         isFac3d = 1;
261     }
262     else
263     {
264         isFac3d = 0;
265     }
266
267     if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1) /* NG beg */
268     {
269         /* case isfac=1;*/
270         if (isFac3d == 0)
271         {
272             Scierror(999, _("Cannot change the %s of graphic object: its type is %s.\n"), "typeof3d", "SCI_PLOT3D");
273             return SET_PROPERTY_ERROR;
274         }
275     }
276     else
277     {
278         /* case isfac=0;*/
279         if (isFac3d == 1)
280         {
281             Scierror(999, _("Cannot change the %s of graphic object: its type is %s.\n"), "typeof3d", "SCI_FAC3D");
282             return SET_PROPERTY_ERROR;
283         }
284     }
285
286     /* check the monotony on x and y */
287
288     if (isFac3d == 1)
289     {
290         /* x is considered as a matrix */
291         dimvectx = -1;
292     }
293     else if (m1 == 1) /* x is a row vector */
294     {
295         dimvectx = n1;
296     }
297     else if (n1 == 1) /* x is a column vector */
298     {
299         dimvectx = m1;
300     }
301     else /* x is a matrix */
302     {
303         dimvectx = -1;
304     }
305
306     if (dimvectx > 1)
307     {
308         int monotony = checkMonotony(pvecx, dimvectx);
309         if (monotony == 0)
310         {
311             Scierror(999, _("%s: Wrong value: Vector is not monotonous.\n"), "Objplot3d");
312             return SET_PROPERTY_ERROR;
313         }
314
315         /* To be implemented within the MVC */
316 #if 0
317         psurf->flag_x = monotony;
318 #endif
319     }
320
321     if (isFac3d == 1)
322     {
323         /* x is considered as a matrix */
324         dimvecty = -1;
325     }
326     else if (m2 == 1) /* y is a row vector */
327     {
328         dimvecty = n2;
329     }
330     else if (n2 == 1) /* y is a column vector */
331     {
332         dimvecty = m2;
333     }
334     else /* y is a matrix */
335     {
336         dimvecty = -1;
337     }
338
339     if (dimvecty > 1)
340     {
341         int monotony = checkMonotony(pvecy, dimvecty);
342         if (monotony == 0)
343         {
344             Scierror(999, _("%s: Wrong value: Vector is not monotonous.\n"), "Objplot3d");
345             return SET_PROPERTY_ERROR;
346         }
347
348         /* To be implemented within the MVC */
349 #if 0
350         psurf->flag_y = monotony;
351 #endif
352     }
353
354     /* get the values now */
355     rewindAssignedList(tlist);
356
357     pvecx = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m1, &n1);
358     pvecy = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m2, &n2);
359     pvecz = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m3, &n3);
360
361     if (isFac3d == 1)
362     {
363         int numElementsArray[3];
364         int result;
365
366         numElementsArray[0] = n1;
367         numElementsArray[1] = m1;
368         numElementsArray[2] = m3n * n3n;
369
370         result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__, numElementsArray, jni_int_vector, 3);
371
372         if (result == 0)
373         {
374             Scierror(999, _("%s: No more memory.\n"), "set3ddata");
375             return SET_PROPERTY_ERROR;
376         }
377     }
378     else if (isFac3d == 0)
379     {
380         int gridSize[4];
381         int result;
382
383         gridSize[0] = m1;
384         gridSize[1] = n1;
385         gridSize[2] = m2;
386         gridSize[3] = n2;
387
388         result = setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
389
390         if (result == 0)
391         {
392             Scierror(999, _("%s: No more memory.\n"), "set3ddata");
393             return SET_PROPERTY_ERROR;
394         }
395     }
396
397     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_X__, pvecx, jni_double_vector, m1 * n1);
398     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Y__, pvecy, jni_double_vector, m2 * n2);
399     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_Z__, pvecz, jni_double_vector, m3 * n3);
400
401     if (getAssignedListNbElement(tlist) == 4) /* F.Leray There is a color matrix */
402     {
403         inputColors = getCurrentDoubleMatrixFromList(_pvCtx, tlist, &m3n, &n3n);
404         nbInputColors = m3n * n3n;
405     }
406     else
407     {
408         inputColors = NULL;
409         nbInputColors = 0;
410     }
411
412     /*
413      * Plot 3d case not treated for now
414      * To be implemented
415      */
416     if (isFac3d == 1)
417     {
418         setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_COLORS__, inputColors, jni_double_vector, nbInputColors);
419     }
420
421     /* Color vector/matrix dimensions: to be checked for MVC implementation */
422 #if 0
423     psurf->m3n = m3n; /* If m3n and n3n are 0, then it means that no color matrix/vector was in input*/
424     psurf->n3n = n3n;
425 #endif
426
427     return SET_PROPERTY_SUCCEED;
428 }
429 /*--------------------------------------------------------------------------*/
430 int set_data_property(void* _pvCtx, char* pobjUID, void* _pvData, int valueType, int nbRow, int nbCol)
431 {
432     int type = -1;
433     int *piType = &type;
434
435     getGraphicObjectProperty(pobjUID, __GO_TYPE__, jni_int, (void **)&piType);
436
437     if (type == __GO_CHAMP__)
438     {
439         AssignedList* tlist = NULL;
440         int status = -1;
441
442         if (!(valueType  == sci_tlist))
443         {
444             Scierror(999, _("Wrong type for input argument: A tlist expected.\n"));
445             return SET_PROPERTY_ERROR;
446         }
447
448         /* we should have 4 properties in the tlist */
449         tlist = createAssignedList(_pvCtx, 3, 4);
450         if (tlist == NULL)
451         {
452             return SET_PROPERTY_ERROR;
453         }
454
455         status = setchampdata(_pvCtx, pobjUID, tlist);
456         destroyAssignedList(tlist);
457         return status;
458     }
459     else if (type == __GO_GRAYPLOT__)
460     {
461         AssignedList * tlist = NULL;
462         int status = -1;
463
464         if (!(valueType  == sci_tlist))
465         {
466             Scierror(999, _("Wrong type for input argument: A tlist expected.\n"));
467             return SET_PROPERTY_ERROR;
468         }
469
470         /* we should have 3 properties in the tlist */
471         tlist = createAssignedList(_pvCtx, 3, 3);
472         if (tlist == NULL)
473         {
474             return SET_PROPERTY_ERROR;
475         }
476
477         status = setgrayplotdata(_pvCtx, pobjUID, tlist);
478         destroyAssignedList(tlist);
479         return status;
480     }
481     else if (type == __GO_FAC3D__ || type == __GO_PLOT3D__)
482     {
483         AssignedList * tlist = NULL;
484         int status = -1;
485         int listSize = 0;
486
487         if (!(valueType  == sci_tlist))
488         {
489             Scierror(999, _("Wrong type for input argument: A tlist expected.\n"));
490             return SET_PROPERTY_ERROR;
491         }
492
493         listSize = getStackListNbElement(_pvCtx, 3);
494
495         if (listSize == 3)
496         {
497             tlist = createAssignedList(_pvCtx, 3, 3);
498         }
499         else if (listSize == 4)
500         {
501             tlist = createAssignedList(_pvCtx, 3, 4);
502         }
503         else
504         {
505             Scierror(999, _("Wrong size for input argument: %d or %d expected.\n"), 4, 5);
506             return SET_PROPERTY_ERROR;
507         }
508
509         if (tlist == NULL)
510         {
511             return SET_PROPERTY_ERROR;
512         }
513
514         status = set3ddata(_pvCtx, pobjUID, tlist);
515         destroyAssignedList(tlist);
516         return status;
517
518     }
519     else if (type == __GO_MATPLOT__)
520     {
521         int datatype = 0;
522         int * piDataType = &datatype;
523         int imagetype = 0;
524         int * piImageType = &imagetype;
525         int dataorder = 0;
526         int * piDataOrder = &dataorder;
527         int plottype = -1;
528         int gridSize[4];
529         int numX = 0;
530         int *piNumX = &numX;
531         int numY = 0;
532         int *piNumY = &numY;
533         getGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_X__, jni_int, (void **)&piNumX);
534         getGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_NUM_Y__, jni_int, (void **)&piNumY);
535         getGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_DATA_TYPE__, jni_int, (void **)&piDataType);
536         getGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_IMAGE_TYPE__, jni_int, (void **)&piImageType);
537         getGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_DATA_ORDER__, jni_int, (void **)&piDataOrder);
538
539         gridSize[1] = 1;
540         gridSize[3] = 1;
541
542         if (valueType == sci_mlist)
543         {
544             if (isHypermatType(_pvCtx, _pvData))
545             {
546                 int htype = 0;
547                 int ndims = 0;
548                 int * dims = NULL;
549                 int precision;
550                 SciErr sciErr;
551                 void * l1 = NULL;
552
553                 sciErr = getHypermatType(_pvCtx, _pvData, &htype);
554                 if (sciErr.iErr)
555                 {
556                     Scierror(202, _("%s: Cannot get the hypermatrix data type for argument #%d.\n"), "data", 1);
557                     return 1;
558                 }
559
560                 if (htype == sci_ints)
561                 {
562                     sciErr = getHypermatOfIntegerPrecision(_pvCtx, _pvData, &precision);
563                     if (sciErr.iErr)
564                     {
565                         Scierror(202, _("%s: Cannot get the hypermatrix data type for argument #%d.\n"), "data", 1);
566                         return 1;
567                     }
568
569                     if (precision != SCI_UINT8 && precision != SCI_INT8)
570                     {
571                         Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "data", 1);
572                         return 1;
573                     }
574
575                     if (precision == SCI_UINT8)
576                     {
577                         sciErr = getHypermatOfUnsignedInteger8(_pvCtx, _pvData, &dims, &ndims, (unsigned char **)&l1);
578                     }
579                     else
580                     {
581                         sciErr = getHypermatOfInteger8(_pvCtx, _pvData, &dims, &ndims, (char **)&l1);
582                     }
583
584                     if (sciErr.iErr || ndims != 3 || (dims[1] != 1 && dims[2] != 3 && dims[2] != 4))
585                     {
586                         Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "data", 1);
587                         return 1;
588                     }
589
590                     if (dims[2] == 1)
591                     {
592                         if (precision == SCI_INT8 && (DataType)datatype != MATPLOT_HM1_Char)
593                         {
594                             plottype = buildMatplotType(MATPLOT_HM1_Char, (DataOrder)dataorder, (ImageType)imagetype);
595                         }
596                         else if (precision == SCI_UINT8 && (DataType)datatype != MATPLOT_HM1_UChar)
597                         {
598                             plottype = buildMatplotType(MATPLOT_HM1_UChar, (DataOrder)dataorder, (ImageType)imagetype);
599                         }
600                     }
601                     else if (dims[2] == 3)
602                     {
603                         if (precision == SCI_INT8 && (DataType)datatype != MATPLOT_HM3_Char)
604                         {
605                             plottype = buildMatplotType(MATPLOT_HM3_Char, (DataOrder)dataorder, (ImageType)imagetype);
606                         }
607                         else if (precision == SCI_UINT8 && (DataType)datatype != MATPLOT_HM3_UChar)
608                         {
609                             plottype = buildMatplotType(MATPLOT_HM3_UChar, (DataOrder)dataorder, (ImageType)imagetype);
610                         }
611                     }
612                     else if (dims[2] == 4)
613                     {
614                         if (precision == SCI_INT8 && (DataType)datatype != MATPLOT_HM4_Char)
615                         {
616                             plottype = buildMatplotType(MATPLOT_HM4_Char, (DataOrder)dataorder, (ImageType)imagetype);
617                         }
618                         else if (precision == SCI_UINT8 && (DataType)datatype != MATPLOT_HM4_UChar)
619                         {
620                             plottype = buildMatplotType(MATPLOT_HM4_UChar, (DataOrder)dataorder, (ImageType)imagetype);
621                         }
622                     }
623                 }
624                 else if (htype == sci_matrix)
625                 {
626                     sciErr = getHypermatOfDouble(_pvCtx, _pvData, &dims, &ndims, (double **)&l1);
627
628                     if (sciErr.iErr || ndims != 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
629                     {
630                         Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "data", 1);
631                         return 1;
632                     }
633
634                     if (dims[2] == 1 && (DataType)datatype != MATPLOT_HM1_Double)
635                     {
636                         plottype = buildMatplotType(MATPLOT_HM1_Double, (DataOrder)dataorder, (ImageType)imagetype);
637                     }
638                     else if (dims[2] == 3 && (DataType)datatype != MATPLOT_HM3_Double)
639                     {
640                         plottype = buildMatplotType(MATPLOT_HM3_Double, (DataOrder)dataorder, (ImageType)imagetype);
641                     }
642                     else if (dims[2] == 4 && (DataType)datatype != MATPLOT_HM4_Double)
643                     {
644                         plottype = buildMatplotType(MATPLOT_HM4_Double, (DataOrder)dataorder, (ImageType)imagetype);
645                     }
646                 }
647                 else
648                 {
649                     Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "data", 1);
650                     return 1;
651                 }
652
653                 if (numX != dims[1] + 1 || numY != dims[0] + 1)
654                 {
655                     gridSize[0] = dims[1] + 1;
656                     gridSize[2] = dims[0] + 1;
657                     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
658                 }
659
660                 if (plottype != -1)
661                 {
662                     setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_DATA_INFOS__, &plottype, jni_int, 1);
663                 }
664                 setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_IMAGE_DATA__, l1, jni_double_vector, dims[0] * dims[1]);
665             }
666         }
667         else if (valueType == sci_ints)
668         {
669             int m = 0;
670             int n = 0;
671             void * l = NULL;
672             SciErr sciErr;
673             int precision;
674
675             sciErr = getMatrixOfIntegerPrecision(_pvCtx, _pvData, &precision);
676             if (sciErr.iErr)
677             {
678                 Scierror(999, _("%s: Cannot get the integer type for argument #%d.\n"), "data", 1);
679                 printError(&sciErr, 0);
680                 return 1;
681             }
682
683             switch (precision)
684             {
685                 case SCI_INT8 :
686                     sciErr = getMatrixOfInteger8(_pvCtx, _pvData, &m, &n, (char **)(&l));
687                     if (sciErr.iErr)
688                     {
689                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), "data", 1);
690                         printError(&sciErr, 0);
691                         return 1;
692                     }
693                     if ((DataType)datatype != MATPLOT_Char)
694                     {
695                         plottype = buildMatplotType(MATPLOT_Char, (DataOrder)dataorder, (ImageType)imagetype);
696                     }
697                     break;
698                 case SCI_UINT8 :
699                     sciErr = getMatrixOfUnsignedInteger8(_pvCtx, _pvData, &m, &n, (unsigned char **)(&l));
700                     if (sciErr.iErr)
701                     {
702                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), "data", 1);
703                         printError(&sciErr, 0);
704                         return 1;
705                     }
706                     if ((DataType)datatype != MATPLOT_UChar)
707                     {
708                         plottype = buildMatplotType(MATPLOT_UChar, (DataOrder)dataorder, (ImageType)imagetype);
709                     }
710                     break;
711                 case SCI_INT16 :
712                     sciErr = getMatrixOfInteger16(_pvCtx, _pvData, &m, &n, (short **)(&l));
713                     if (sciErr.iErr)
714                     {
715                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), "data", 1);
716                         printError(&sciErr, 0);
717                         return 1;
718                     }
719                     if ((DataType)datatype != MATPLOT_Short)
720                     {
721                         plottype = buildMatplotType(MATPLOT_Short, (DataOrder)dataorder, (ImageType)imagetype);
722                     }
723                     break;
724                 case SCI_UINT16 :
725                     sciErr = getMatrixOfUnsignedInteger16(_pvCtx, _pvData, &m, &n, (unsigned short **)(&l));
726                     if (sciErr.iErr)
727                     {
728                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), "data", 1);
729                         printError(&sciErr, 0);
730                         return 1;
731                     }
732                     if ((DataType)datatype != MATPLOT_UShort)
733                     {
734                         plottype = buildMatplotType(MATPLOT_UShort, (DataOrder)dataorder, (ImageType)imagetype);
735                     }
736                     break;
737                 case SCI_INT32 :
738                     sciErr = getMatrixOfInteger32(_pvCtx, _pvData, &m, &n, (int **)(&l));
739                     if (sciErr.iErr)
740                     {
741                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), "data", 1);
742                         printError(&sciErr, 0);
743                         return 1;
744                     }
745                     if ((DataType)datatype != MATPLOT_Int)
746                     {
747                         plottype = buildMatplotType(MATPLOT_Int, (DataOrder)dataorder, (ImageType)imagetype);
748                     }
749                     break;
750                 case SCI_UINT32 :
751                     sciErr = getMatrixOfUnsignedInteger32(_pvCtx, _pvData, &m, &n, (unsigned int **)(&l));
752                     if (sciErr.iErr)
753                     {
754                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), "data", 1);
755                         printError(&sciErr, 0);
756                         return 1;
757                     }
758                     if ((DataType)datatype != MATPLOT_UInt)
759                     {
760                         plottype = buildMatplotType(MATPLOT_UInt, (DataOrder)dataorder, (ImageType)imagetype);
761                     }
762                     break;
763                 default :
764                     Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "data", 1);
765                     return 1;
766             }
767
768             if (precision == SCI_INT8 || precision == SCI_UINT8)
769             {
770                 if ((ImageType)imagetype == MATPLOT_RGB)
771                 {
772                     const int mb3 = m / 3;
773                     if (mb3 * 3 == m)
774                     {
775                         m = mb3;
776                     }
777                     else
778                     {
779                         Scierror(202, _("%s: Wrong size for input argument #%d: The number of rows must be a multiple of 3.\n"), "data", 1);
780                         return 1;
781                     }
782                 }
783                 else if ((ImageType)imagetype == MATPLOT_RGBA)
784                 {
785                     const int mb4 = m / 4;
786                     if (mb4 * 4 == m)
787                     {
788                         m = mb4;
789                     }
790                     else
791                     {
792                         Scierror(202, _("%s: Wrong size for input argument #%d: The number of rows must be a multiple of 4.\n"), "data", 1);
793                         return 1;
794                     }
795                 }
796             }
797
798             if (numX != n + 1 || numY != m + 1)
799             {
800                 gridSize[0] = n + 1;
801                 gridSize[2] = m + 1;
802                 setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
803             }
804
805             if (plottype != -1)
806             {
807                 setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_DATA_INFOS__, &plottype, jni_int, 1);
808             }
809
810             setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_IMAGE_DATA__, l, jni_double_vector, m * n);
811         }
812         else if (valueType == sci_matrix)
813         {
814             if (numX != nbCol + 1 || numY != nbRow + 1)
815             {
816                 gridSize[0] = nbCol + 1;
817                 gridSize[2] = nbRow + 1;
818                 setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_GRID_SIZE__, gridSize, jni_int_vector, 4);
819             }
820
821             if ((DataType)datatype != MATPLOT_Double)
822             {
823                 plottype = buildMatplotType(MATPLOT_Double, (DataOrder)dataorder, (ImageType)imagetype);
824                 setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_DATA_INFOS__, &plottype, jni_int, 1);
825             }
826
827             setGraphicObjectProperty(pobjUID, __GO_DATA_MODEL_MATPLOT_IMAGE_DATA__, _pvData, jni_double_vector, nbRow * nbCol);
828         }
829     }
830     else  /* F.Leray 02.05.05 : "data" case for others (using sciGetPoint routine inside GetProperty.c) */
831     {
832         if (valueType != sci_matrix)
833         {
834             Scierror(999, _("Incompatible type for property ''%s''.\n"), "data");
835             return SET_PROPERTY_ERROR;
836         }
837
838         return sciSetPoint(pobjUID, (double*)_pvData, &nbRow, &nbCol);
839     }
840     return SET_PROPERTY_ERROR;
841 }
842 /*------------------------------------------------------------------------*/