Validate Label after Size change to follow alignment.
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_champ.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) 2011 - DIGITEO - Bruno JOFRET
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_champ.c                                                      */
17 /* desc : interface for champ (and champ1) routine                        */
18 /*------------------------------------------------------------------------*/
19
20 #include "gw_graphics.h"
21 #include "api_scilab.h"
22 #include "GetCommandArg.h"
23 #include "BuildObjects.h"
24 #include "DefaultCommandArg.h"
25 #include "Champ.h"
26 #include "localization.h"
27 #include "Scierror.h"
28 /*--------------------------------------------------------------------------*/
29 int sci_champ (char *fname, unsigned long fname_len)
30 {
31     return sci_champ_G(fname, C2F(champ), fname_len);
32 }
33 /*--------------------------------------------------------------------------*/
34 int sci_champ1 (char *fname, unsigned long fname_len)
35 {
36     return sci_champ_G(fname, C2F(champ1), fname_len);
37 }
38 /*--------------------------------------------------------------------------*/
39 int sci_champ_G(char *fname,
40                 int (*func) (double *, double *, double *, double *, int *, int *, char *, double *, double *, int),
41                 unsigned long fname_len)
42 {
43     SciErr sciErr;
44     double arfact_def = 1.0;
45     double* arfact = &arfact_def;
46     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
47     static rhs_opts opts[] =
48     {
49         { -1, "arfact", -1, 0, 0, NULL},
50         { -1, "rect", -1, 0, 0, NULL},
51         { -1, "strf", -1, 0, 0, NULL},
52         { -1, NULL, -1, 0, 0, NULL}
53     };
54
55     char   * strf = NULL;
56     double* rect = NULL;
57
58     int* piAddr1 = NULL;
59     int* piAddr2 = NULL;
60     int* piAddr3 = NULL;
61     int* piAddr4 = NULL;
62
63     double* l1 = NULL;
64     double* l2 = NULL;
65     double* l3 = NULL;
66     double* l4 = NULL;
67
68     CheckInputArgument(pvApiCtx, -1, 7);
69     CheckOutputArgument(pvApiCtx, 0, 1);
70
71     if (nbInputArgument(pvApiCtx) <= 0)
72     {
73         sci_demo(fname, fname_len);
74         return 0;
75     }
76     else if (nbInputArgument(pvApiCtx) < 4)
77     {
78         Scierror(999, _("%s: Wrong number of input arguments: At least %d expected.\n"), fname, 4);
79         return 0;
80     }
81
82     if (getOptionals(pvApiCtx, fname, opts) == 0)
83     {
84         return 0;
85     }
86
87     if (FirstOpt() < 5)
88     {
89         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
90         return -1;
91     }
92
93     //get variable address
94     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
95     if (sciErr.iErr)
96     {
97         printError(&sciErr, 0);
98         return 1;
99     }
100
101     // Retrieve a matrix of double at position 1.
102     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
103     if (sciErr.iErr)
104     {
105         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
106         printError(&sciErr, 0);
107         return 1;
108     }
109
110     //get variable address
111     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
112     if (sciErr.iErr)
113     {
114         printError(&sciErr, 0);
115         return 1;
116     }
117
118     // Retrieve a matrix of double at position 2.
119     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
120     if (sciErr.iErr)
121     {
122         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
123         printError(&sciErr, 0);
124         return 1;
125     }
126
127     //get variable address
128     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
129     if (sciErr.iErr)
130     {
131         printError(&sciErr, 0);
132         return 1;
133     }
134
135     // Retrieve a matrix of double at position 3.
136     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
137     if (sciErr.iErr)
138     {
139         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
140         printError(&sciErr, 0);
141         return 1;
142     }
143
144     //get variable address
145     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
146     if (sciErr.iErr)
147     {
148         printError(&sciErr, 0);
149         return 1;
150     }
151
152     // Retrieve a matrix of double at position 4.
153     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
154     if (sciErr.iErr)
155     {
156         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
157         printError(&sciErr, 0);
158         return 1;
159     }
160
161     //CheckSameDims
162     if (m3 != m4 || n3 != n4)
163     {
164         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 3, m3, n3);
165         return 1;
166     }
167
168     //CheckDimProp
169     if (m2 * n2 != n3)
170     {
171         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
172         return 1;
173     }
174
175     //CheckDimProp
176     if (m1 * n1 != m3)
177     {
178         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
179         return 1;
180     }
181
182     if (m3 * n3 == 0)
183     {
184         AssignOutputVariable(pvApiCtx, 1) = 0;
185         ReturnArguments(pvApiCtx);
186         return 0;
187     }
188
189     GetOptionalDoubleArg(pvApiCtx, fname, 5, "arfact", &arfact, 1, opts);
190     GetRect(pvApiCtx, fname, 6, opts, &rect);
191     GetStrf(pvApiCtx, fname, 7, opts, &strf);
192
193     getOrCreateDefaultSubwin();
194
195     if (isDefStrf(strf))
196     {
197         char strfl[4];
198         strcpy(strfl, DEFSTRFN);
199         strf = strfl;
200         if (!isDefRect(rect))
201         {
202             strf[1] = '5';
203         }
204     }
205
206     (*func)((l1), (l2), (l3), (l4), &m3, &n3, strf, rect, arfact, 4L);
207     AssignOutputVariable(pvApiCtx, 1) = 0;
208     ReturnArguments(pvApiCtx);
209     return 0;
210 }
211 /*--------------------------------------------------------------------------*/