Fix some localization issues
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_matplot1.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Fabrice Leray
4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
5  * Copyright (C) 2012 - DIGITEO - Manuel Juliachs
6  *
7  * This file must be used under the terms of the CeCILL.
8  * This source file is licensed as described in the file COPYING, which
9  * you should have received as part of this distribution.  The terms
10  * are also available at
11  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
12  *
13  */
14
15 /*------------------------------------------------------------------------*/
16 /* file: sci_matplot1.c                                                   */
17 /* desc : interface for matplot1 routine                                  */
18 /*------------------------------------------------------------------------*/
19 #include "api_scilab.h"
20 #include "Scierror.h"
21 #include "localization.h"
22 #include "gw_graphics.h"
23 #include "BuildObjects.h"
24 #include "sciCall.h"
25 #include "Matplot.h"
26
27 /*--------------------------------------------------------------------------*/
28 int sci_matplot1(char * fname, unsigned long fname_len)
29 {
30     SciErr sciErr;
31     int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
32     int* piAddr1 = NULL;
33     int* piAddr2 = NULL;
34     int type;
35     int plottype = -1;
36     int precision;
37
38     double* l1 = NULL;
39     double* l2 = NULL;
40
41     if (nbInputArgument(pvApiCtx) <= 0)
42     {
43         sci_demo(fname, fname_len);
44         return 0;
45     }
46
47     CheckInputArgument(pvApiCtx, 2, 2);
48     //get variable address
49     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
50     if (sciErr.iErr)
51     {
52         printError(&sciErr, 0);
53         return 1;
54     }
55
56     sciErr = getVarType(pvApiCtx, piAddr1, &type);
57     if (sciErr.iErr)
58     {
59         Scierror(999, _("%s: Cannot get the data type.\n"), fname, 1);
60         printError(&sciErr, 0);
61         return 1;
62     }
63
64     switch (type)
65     {
66         case sci_matrix :
67             sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, (double **)&l1);
68             if (sciErr.iErr)
69             {
70                 Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
71                 printError(&sciErr, 0);
72                 return 1;
73             }
74
75             if (m1 * n1 == 0)
76             {
77                 AssignOutputVariable(pvApiCtx, 1) = 0;
78                 ReturnArguments(pvApiCtx);
79                 return 0;
80             }
81
82             plottype = buildMatplotType(MATPLOT_Double, MATPLOT_FORTRAN, MATPLOT_INDEX);
83             break;
84         case sci_ints :
85             sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr1, &precision);
86             if (sciErr.iErr)
87             {
88                 Scierror(999, _("%s: Cannot get the integer type for argument #%d.\n"), fname, 1);
89                 printError(&sciErr, 0);
90                 return 1;
91             }
92
93             switch (precision)
94             {
95                 case SCI_INT8 :
96                     sciErr = getMatrixOfInteger8(pvApiCtx, piAddr1, &m1, &n1, (char **)(&l1));
97                     if (sciErr.iErr)
98                     {
99                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), fname, 1);
100                         printError(&sciErr, 0);
101                         return 1;
102                     }
103                     plottype = buildMatplotType(MATPLOT_Char, MATPLOT_FORTRAN, MATPLOT_RGB_332);
104                     break;
105                 case SCI_UINT8 :
106                     sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddr1, &m1, &n1, (unsigned char **)(&l1));
107                     if (sciErr.iErr)
108                     {
109                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), fname, 1);
110                         printError(&sciErr, 0);
111                         return 1;
112                     }
113                     plottype = buildMatplotType(MATPLOT_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
114                     break;
115                 case SCI_INT16 :
116                     sciErr = getMatrixOfInteger16(pvApiCtx, piAddr1, &m1, &n1, (short **)(&l1));
117                     if (sciErr.iErr)
118                     {
119                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), fname, 1);
120                         printError(&sciErr, 0);
121                         return 1;
122                     }
123                     plottype = buildMatplotType(MATPLOT_Short, MATPLOT_FORTRAN, MATPLOT_RGB_444);
124                     break;
125                 case SCI_UINT16 :
126                     sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddr1, &m1, &n1, (unsigned short **)(&l1));
127                     if (sciErr.iErr)
128                     {
129                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), fname, 1);
130                         printError(&sciErr, 0);
131                         return 1;
132                     }
133                     plottype = buildMatplotType(MATPLOT_UShort, MATPLOT_FORTRAN, MATPLOT_RGBA_4444);
134                     break;
135                 case SCI_INT32 :
136                     sciErr = getMatrixOfInteger32(pvApiCtx, piAddr1, &m1, &n1, (int **)(&l1));
137                     if (sciErr.iErr)
138                     {
139                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), fname, 1);
140                         printError(&sciErr, 0);
141                         return 1;
142                     }
143                     plottype = buildMatplotType(MATPLOT_Int, MATPLOT_FORTRAN, MATPLOT_RGB);
144                     break;
145                 case SCI_UINT32 :
146                     sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddr1, &m1, &n1, (unsigned int **)(&l1));
147                     if (sciErr.iErr)
148                     {
149                         Scierror(202, _("%s: Cannot get the data for argument #%d.\n"), fname, 1);
150                         printError(&sciErr, 0);
151                         return 1;
152                     }
153                     plottype = buildMatplotType(MATPLOT_UInt, MATPLOT_FORTRAN, MATPLOT_RGBA);
154                     break;
155                 default :
156                     Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), fname, 1);
157                     return 1;
158             }
159             break;
160         case sci_mlist :
161             if (isHypermatType(pvApiCtx, piAddr1))
162             {
163                 int htype = 0;
164                 int ndims = 0;
165                 int * dims = NULL;
166
167                 sciErr = getHypermatType(pvApiCtx, piAddr1, &htype);
168                 if (sciErr.iErr)
169                 {
170                     Scierror(202, _("%s: Cannot get the hypermatrix data type for argument #%d.\n"), fname, 1);
171                     return 1;
172                 }
173
174                 if (htype == sci_ints)
175                 {
176                     sciErr = getHypermatOfIntegerPrecision(pvApiCtx, piAddr1, &precision);
177                     if (sciErr.iErr)
178                     {
179                         Scierror(202, _("%s: Cannot get the hypermatrix data type for argument #%d.\n"), fname, 1);
180                         return 1;
181                     }
182
183                     if (precision != SCI_UINT8 && precision != SCI_INT8)
184                     {
185                         Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), fname, 1);
186                         return 1;
187                     }
188
189                     if (precision == SCI_UINT8)
190                     {
191                         sciErr = getHypermatOfUnsignedInteger8(pvApiCtx, piAddr1, &dims, &ndims, (unsigned char **)&l1);
192                     }
193                     else
194                     {
195                         sciErr = getHypermatOfInteger8(pvApiCtx, piAddr1, &dims, &ndims, (char **)&l1);
196                     }
197
198                     if (sciErr.iErr || ndims != 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
199                     {
200                         Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), fname, 1);
201                         return 1;
202                     }
203
204                     m1 = dims[0];
205                     n1 = dims[1];
206                     if (dims[2] == 1)
207                     {
208                         if (precision == SCI_INT8)
209                         {
210                             plottype = buildMatplotType(MATPLOT_HM1_Char, MATPLOT_FORTRAN, MATPLOT_GRAY);
211                         }
212                         else
213                         {
214                             plottype = buildMatplotType(MATPLOT_HM1_UChar, MATPLOT_FORTRAN, MATPLOT_GRAY);
215                         }
216                     }
217                     else if (dims[2] == 3)
218                     {
219                         if (precision == SCI_INT8)
220                         {
221                             plottype = buildMatplotType(MATPLOT_HM3_Char, MATPLOT_FORTRAN, MATPLOT_RGB);
222                         }
223                         else
224                         {
225                             plottype = buildMatplotType(MATPLOT_HM3_UChar, MATPLOT_FORTRAN, MATPLOT_RGB);
226                         }
227                     }
228                     else
229                     {
230                         if (precision == SCI_INT8)
231                         {
232                             plottype = buildMatplotType(MATPLOT_HM4_Char, MATPLOT_FORTRAN, MATPLOT_RGBA);
233                         }
234                         else
235                         {
236                             plottype = buildMatplotType(MATPLOT_HM4_UChar, MATPLOT_FORTRAN, MATPLOT_RGBA);
237                         }
238                     }
239                 }
240                 else if (htype == sci_matrix)
241                 {
242                     sciErr = getHypermatOfDouble(pvApiCtx, piAddr1, &dims, &ndims, (double **)&l1);
243                     if (sciErr.iErr || ndims != 3 || (dims[2] != 1 && dims[2] != 3 && dims[2] != 4))
244                     {
245                         Scierror(202, _("%s: Wrong type for argument %d: A real or integer expected.\n"), fname, 1);
246                         return 1;
247                     }
248
249                     m1 = dims[0];
250                     n1 = dims[1];
251                     if (dims[2] == 1)
252                     {
253                         plottype = buildMatplotType(MATPLOT_HM1_Double, MATPLOT_FORTRAN, MATPLOT_GRAY);
254                     }
255                     else if (dims[2] == 3)
256                     {
257                         plottype = buildMatplotType(MATPLOT_HM3_Double, MATPLOT_FORTRAN, MATPLOT_RGB);
258                     }
259                     else
260                     {
261                         plottype = buildMatplotType(MATPLOT_HM4_Double, MATPLOT_FORTRAN, MATPLOT_RGBA);
262                     }
263                 }
264                 else
265                 {
266                     Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), "data", 1);
267                     return 1;
268                 }
269             }
270             break;
271         default :
272             Scierror(202, _("%s: Wrong type for input argument #%d: A real or integer expected.\n"), fname, 1);
273             return 1;
274     }
275
276     //get variable address
277     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
278     if (sciErr.iErr)
279     {
280         printError(&sciErr, 0);
281         return 1;
282     }
283
284     // Retrieve a matrix of double at position 2.
285     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
286     if (sciErr.iErr)
287     {
288         Scierror(202, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 2);
289         printError(&sciErr, 0);
290         return 1;
291     }
292
293     //CheckLength
294     if (m2 * n2 != 4)
295     {
296         Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 2, m2 * n2);
297         return 1;
298     }
299
300     if (m1 * n1 == 0)
301     {
302         AssignOutputVariable(pvApiCtx, 1) = 0;
303         ReturnArguments(pvApiCtx);
304         return 0;
305     }
306
307     getOrCreateDefaultSubwin();
308
309     /* NG beg */
310     Objmatplot1 ((l1), &m1, &n1, (l2), plottype);
311
312     AssignOutputVariable(pvApiCtx, 1) = 0;
313     ReturnArguments(pvApiCtx);
314     return 0;
315 }
316 /*--------------------------------------------------------------------------*/