Validate Label after Size change to follow alignment.
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_plot2d1.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  *
6  * This file must be used under the terms of the CeCILL.
7  * This source file is licensed as described in the file COPYING, which
8  * you should have received as part of this distribution.  The terms
9  * are also available at
10  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
11  *
12  */
13
14 /*------------------------------------------------------------------------*/
15 /* file: sci_plot2d1.c                                                    */
16 /* desc : interface for plot2d1, plot2d2, plot2d3 and plot2d4 routines    */
17 /*------------------------------------------------------------------------*/
18
19 #include "gw_graphics.h"
20 #include "api_scilab.h"
21 #include "GetCommandArg.h"
22 #include "DefaultCommandArg.h"
23 #include "sciCall.h"
24 #include "localization.h"
25 #include "Scierror.h"
26 #include "MALLOC.h"
27
28 /*--------------------------------------------------------------------------*/
29 int sci_plot2d1_1 (char *fname, unsigned long fname_len)
30 {
31     return sci_plot2d1_G("plot2d1", 1, fname_len); /* NG */
32 }
33 /*--------------------------------------------------------------------------*/
34 int sci_plot2d1_2 (char *fname, unsigned long fname_len)
35 {
36     return sci_plot2d1_G("plot2d2", 2, fname_len); /* NG */
37 }
38 /*--------------------------------------------------------------------------*/
39 int sci_plot2d1_3 (char *fname, unsigned long fname_len)
40 {
41     return sci_plot2d1_G("plot2d3", 3, fname_len); /* NG */
42 }
43 /*--------------------------------------------------------------------------*/
44 int sci_plot2d1_4 (char *fname, unsigned long fname_len)
45 {
46     return sci_plot2d1_G("plot2d4", 4, fname_len); /* NG */
47 }
48 /*--------------------------------------------------------------------------*/
49 int sci_plot2d1_G(char * fname, int ptype, unsigned long fname_len)
50 {
51     SciErr sciErr;
52     int* piAddrl1 = NULL;
53     double* l1 = NULL;
54     int* piAddrl2 = NULL;
55     double* l2 = NULL;
56     double* lt = NULL;
57
58     int frame_def = 8;
59     int *frame = &frame_def;
60     int axes_def = 1;
61     int *axes = &axes_def;
62     int iskip = 0, test  = 0;
63     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, i = 0, j = 0;
64
65     static rhs_opts opts[] =
66     {
67         { -1, "axesflag", -1, 0, 0, NULL},
68         { -1, "frameflag", -1, 0, 0, NULL},
69         { -1, "leg", -1, 0, 0, NULL},
70         { -1, "logflag", -1, 0, 0, NULL},
71         { -1, "nax", -1, 0, 0, NULL},
72         { -1, "rect", -1, 0, 0, NULL},
73         { -1, "strf", -1, 0, 0, NULL},
74         { -1, "style", -1, 0, 0, NULL},
75         { -1, NULL, -1, 0, 0, NULL}
76     };
77
78     int    * style    = NULL ;
79     double* rect     = NULL ;
80     int    * nax      = NULL ;
81     BOOL     flagNax  = FALSE;
82     char   * strf     = NULL ;
83     char   * legend   = NULL ;
84     char   * logFlags = NULL ;
85
86     if (nbInputArgument(pvApiCtx) <= 0)
87     {
88         /* lauch the default routines depending on the name of the calling function */
89         sci_demo(fname, fname_len);
90         return 0;
91     }
92     CheckInputArgument(pvApiCtx, 1, 9); /* to allow plot2dxx(y) */
93
94
95     iskip = 0;
96     if (getOptionals(pvApiCtx, fname, opts) == 0)
97     {
98         ReturnArguments(pvApiCtx);
99         return 0;
100     }
101
102     if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
103     {
104         /* logflags */
105         GetLogflags(pvApiCtx, fname, 1, opts, &logFlags);
106         iskip = 1;
107     }
108
109     /* added to support plot2dxx([logflags],y) */
110     if (nbInputArgument(pvApiCtx) == 1 + iskip)
111     {
112         if (FirstOpt() <= nbInputArgument(pvApiCtx))
113         {
114             Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 3 + iskip);
115             return (0);
116         }
117
118         sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl2);
119         if (sciErr.iErr)
120         {
121             printError(&sciErr, 0);
122             return 1;
123         }
124
125         // Retrieve a matrix of double at position 1 + iskip.
126         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
127         if (sciErr.iErr)
128         {
129             printError(&sciErr, 0);
130             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
131             return 1;
132         }
133
134         sciErr = allocMatrixOfDouble(pvApiCtx, 2 + iskip, m2, n2, &l1);
135         if (sciErr.iErr)
136         {
137             printError(&sciErr, 0);
138             Scierror(999, _("%s: Memory allocation error.\n"), fname);
139             return 1;
140         }
141
142         if (m2 == 1 && n2 > 1)
143         {
144             m2 = n2;
145             n2 = 1;
146         }
147
148         m1 = m2;
149         n1 = n2;
150
151         for (i = 0; i < m2 ; ++i)
152         {
153             for (j = 0 ; j < n2 ;  ++j)
154             {
155                 *(l1 + i + m2 * j) = (double) i + 1;
156             }
157         }
158     }
159
160
161     if (nbInputArgument(pvApiCtx) >= 2 + iskip)
162     {
163         if (FirstOpt() < 3 + iskip)
164         {
165             Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
166                      fname, 1, 3 + iskip);
167             return (0);
168         }
169
170
171         /* x */
172         sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl1);
173         if (sciErr.iErr)
174         {
175             printError(&sciErr, 0);
176             return 1;
177         }
178
179         // Retrieve a matrix of double at position 1 + iskip.
180         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
181         if (sciErr.iErr)
182         {
183             printError(&sciErr, 0);
184             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
185             return 1;
186         }
187
188         if (iskip == 1)
189         {
190             if (logFlags[0] == 'e')
191             {
192                 m1 = 0;
193                 n1 = 0;
194             }
195         }
196
197         /* y */
198         sciErr = getVarAddressFromPosition(pvApiCtx, 2 + iskip, &piAddrl2);
199         if (sciErr.iErr)
200         {
201             printError(&sciErr, 0);
202             return 1;
203         }
204
205         // Retrieve a matrix of double at position 2 + iskip.
206         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
207         if (sciErr.iErr)
208         {
209             printError(&sciErr, 0);
210             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2 + iskip);
211             return 1;
212         }
213
214         /* if (m2 * n2 == 0) { m1 = 0; n1 = 0;}  */
215
216         test = (m1 * n1 == 0) /* x = [] */
217                /* x,y vectors of same length */
218                || ((m1 == 1 || n1 == 1) && (m2 == 1 || n2 == 1) && (m1 * n1 == m2 * n2))
219                || ((m1 == m2) && (n1 == n2)) /* size(x) == size(y) */
220                /* x vector size(y)==[size(x),.] */
221                || ((m1 == 1 && n1 == m2) || (n1 == 1 && m1 == m2));
222
223         //CheckDimProp
224         if (!test)
225         {
226             Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
227             return 1;
228         }
229
230
231         if (m1 * n1 == 0)
232         {
233             /* default x=1:n */
234             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
235             if (sciErr.iErr)
236             {
237                 printError(&sciErr, 0);
238                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
239                 return 1;
240             }
241
242             if (m2 == 1 && n2 > 1)
243             {
244                 m2 = n2;
245                 n2 = 1;
246             }
247             for (i = 0; i < m2 ; ++i)
248             {
249                 for (j = 0 ; j < n2 ;  ++j)
250                 {
251                     *(lt + i + m2 * j) = (double) i + 1;
252                 }
253             }
254             m1 = m2;
255             n1 = n2;
256             l1 = lt;
257         }
258         else if ((m1 == 1 || n1 == 1) && (m2 != 1 && n2 != 1))
259         {
260             /* a single x vector for mutiple columns for y */
261             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
262             if (sciErr.iErr)
263             {
264                 printError(&sciErr, 0);
265                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
266                 return 1;
267             }
268
269             for (i = 0; i < m2 ; ++i)
270             {
271                 for (j = 0 ; j < n2 ;  ++j)
272                 {
273                     *(lt + i + m2 * j) = l1[i];
274                 }
275             }
276             m1 = m2;
277             n1 = n2;
278             l1 = lt;
279         }
280         else if ((m1 == 1 && n1 == 1) && (n2 != 1))
281         {
282             /* a single y row vector  for a single x */
283             sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n2, &lt);
284             if (sciErr.iErr)
285             {
286                 printError(&sciErr, 0);
287                 Scierror(999, _("%s: Memory allocation error.\n"), fname);
288                 return 1;
289             }
290
291             for (j = 0 ; j < n2 ;  ++j)
292             {
293                 lt[j] = *l1;
294             }
295             n1 = n2;
296             l1 = lt;
297         }
298         else
299         {
300             if (m2 == 1 && n2 > 1)
301             {
302                 m2 = n2;
303                 n2 = 1;
304             }
305             if (m1 == 1 && n1 > 1)
306             {
307                 m1 = n1;
308                 n1 = 1;
309             }
310         }
311     }
312
313     sciGetStyle(pvApiCtx, fname, 3 + iskip, n1, opts, &style);
314     GetStrf(pvApiCtx, fname, 4 + iskip, opts, &strf);
315     GetLegend(pvApiCtx, fname, 5 + iskip, opts, &legend);
316     GetRect(pvApiCtx, fname, 6 + iskip, opts, &rect);
317     GetNax(pvApiCtx, 7 + iskip, opts, &nax, &flagNax);
318     if (iskip == 0)
319     {
320         GetLogflags(pvApiCtx, fname, 8, opts, &logFlags);
321     }
322
323     if (isDefStrf(strf))
324     {
325         char strfl[4];
326         strcpy(strfl, DEFSTRFN);
327
328         strf = strfl;
329         if (!isDefRect(rect))
330         {
331             strfl[1] = '7';
332         }
333         if (!isDefLegend(legend))
334         {
335             strfl[0] = '1';
336         }
337         GetOptionalIntArg(pvApiCtx, fname, 9, "frameflag", &frame, 1, opts);
338         if (frame != &frame_def)
339         {
340             strfl[1] = (char)(*frame + 48);
341         }
342         GetOptionalIntArg(pvApiCtx, fname, 9, "axesflag", &axes, 1, opts);
343         if (axes != &axes_def)
344         {
345             strfl[2] = (char)(*axes + 48);
346         }
347     }
348
349     if (ptype == 0)
350     {
351         ptype = 1;
352     }
353
354     Objplot2d (ptype, logFlags, (l1), (l2), &n1, &m1, style, strf, legend, rect, nax, flagNax);
355
356     // Allocated by sciGetStyle (get_style_arg function in GetCommandArg.c)
357     FREE(style);
358
359     AssignOutputVariable(pvApiCtx, 1) = 0;
360     ReturnArguments(pvApiCtx);
361     return 0;
362 }
363 /*--------------------------------------------------------------------------*/