f4312b92f33802c40be8da1eed33020cf4d96cb0
[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  * Copyright (C) 2012 - 2016 - Scilab Enterprises
8  *
9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
11  * This file was originally licensed under the terms of the CeCILL v2.1,
12  * and continues to be available under such terms.
13  * For more information, see the COPYING file which you should have received
14  * along with this program.
15  *
16  */
17
18 /*------------------------------------------------------------------------*/
19 /* file: sci_champ.c                                                      */
20 /* desc : interface for champ (and champ1) routine                        */
21 /*------------------------------------------------------------------------*/
22 #include <string.h>
23 #include "gw_graphics.h"
24 #include "api_scilab.h"
25 #include "GetCommandArg.h"
26 #include "BuildObjects.h"
27 #include "DefaultCommandArg.h"
28 #include "Champ.h"
29 #include "localization.h"
30 #include "Scierror.h"
31 /*--------------------------------------------------------------------------*/
32 int sci_champ (char *fname, void *pvApiCtx)
33 {
34     return sci_champ_G(fname, C2F(champ), pvApiCtx);
35 }
36 /*--------------------------------------------------------------------------*/
37 int sci_champ1 (char *fname, void *pvApiCtx)
38 {
39     return sci_champ_G(fname, C2F(champ1), pvApiCtx);
40 }
41 /*--------------------------------------------------------------------------*/
42 int sci_champ_G(char *fname,
43                 int (*func) (double *, double *, double *, double *, int *, int *, char *, double *, double *, int),
44                 void *pvApiCtx)
45 {
46     SciErr sciErr;
47     double arfact_def = 1.0;
48     double* arfact = &arfact_def;
49     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
50     static rhs_opts opts[] =
51     {
52         { -1, "arfact", -1, 0, 0, NULL},
53         { -1, "rect", -1, 0, 0, NULL},
54         { -1, "strf", -1, 0, 0, NULL},
55         { -1, NULL, -1, 0, 0, NULL}
56     };
57
58     char   * strf = NULL;
59     char strfl[4];
60     double* rect = NULL;
61
62     int* piAddr1 = NULL;
63     int* piAddr2 = NULL;
64     int* piAddr3 = NULL;
65     int* piAddr4 = NULL;
66
67     double* l1 = NULL;
68     double* l2 = NULL;
69     double* l3 = NULL;
70     double* l4 = NULL;
71
72     CheckInputArgument(pvApiCtx, -1, 7);
73     CheckOutputArgument(pvApiCtx, 0, 1);
74
75     if (nbInputArgument(pvApiCtx) <= 0)
76     {
77         sci_demo(fname, pvApiCtx);
78         return 0;
79     }
80     else if (nbInputArgument(pvApiCtx) < 4)
81     {
82         Scierror(999, _("%s: Wrong number of input arguments: At least %d expected.\n"), fname, 4);
83         return 0;
84     }
85
86     if (getOptionals(pvApiCtx, fname, opts) == 0)
87     {
88         return 0;
89     }
90
91     if (FirstOpt(pvApiCtx) < 5)
92     {
93         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
94         return -1;
95     }
96
97     //get variable address
98     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
99     if (sciErr.iErr)
100     {
101         printError(&sciErr, 0);
102         return 1;
103     }
104
105     // Retrieve a matrix of double at position 1.
106     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
107     if (sciErr.iErr)
108     {
109         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
110         printError(&sciErr, 0);
111         return 1;
112     }
113
114     //get variable address
115     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
116     if (sciErr.iErr)
117     {
118         printError(&sciErr, 0);
119         return 1;
120     }
121
122     // Retrieve a matrix of double at position 2.
123     sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
124     if (sciErr.iErr)
125     {
126         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
127         printError(&sciErr, 0);
128         return 1;
129     }
130
131     //get variable address
132     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
133     if (sciErr.iErr)
134     {
135         printError(&sciErr, 0);
136         return 1;
137     }
138
139     // Retrieve a matrix of double at position 3.
140     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
141     if (sciErr.iErr)
142     {
143         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
144         printError(&sciErr, 0);
145         return 1;
146     }
147
148     //get variable address
149     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
150     if (sciErr.iErr)
151     {
152         printError(&sciErr, 0);
153         return 1;
154     }
155
156     // Retrieve a matrix of double at position 4.
157     sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
158     if (sciErr.iErr)
159     {
160         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
161         printError(&sciErr, 0);
162         return 1;
163     }
164
165     //CheckSameDims
166     if (m3 != m4 || n3 != n4)
167     {
168         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 3, m3, n3);
169         return 1;
170     }
171
172     //CheckDimProp
173     if (m2 * n2 != n3)
174     {
175         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
176         return 1;
177     }
178
179     //CheckDimProp
180     if (m1 * n1 != m3)
181     {
182         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
183         return 1;
184     }
185
186     if (m3 * n3 == 0)
187     {
188         AssignOutputVariable(pvApiCtx, 1) = 0;
189         ReturnArguments(pvApiCtx);
190         return 0;
191     }
192
193     if (get_optional_double_arg(pvApiCtx, fname, 5, "arfact", &arfact, 1, opts) == 0)
194     {
195         return 0;
196     }
197     if (get_rect_arg(pvApiCtx, fname, 6, opts, &rect) == 0)
198     {
199         return 0;
200     }
201     if (get_strf_arg(pvApiCtx, fname, 7, opts, &strf) == 0)
202     {
203         return 0;
204     }
205
206     getOrCreateDefaultSubwin();
207
208     if (isDefStrf(strf))
209     {
210         strcpy(strfl, DEFSTRFN);
211         strf = strfl;
212         if (!isDefRect(rect))
213         {
214             strf[1] = '5';
215         }
216     }
217
218     (*func)((l1), (l2), (l3), (l4), &m3, &n3, strf, rect, arfact, 4L);
219     AssignOutputVariable(pvApiCtx, 1) = 0;
220     ReturnArguments(pvApiCtx);
221     return 0;
222 }
223 /*--------------------------------------------------------------------------*/