96744dbe0bae1933119113287bc9e61b149a0cd0
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_grayplot.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_grayplot.c                                                   */
20 /* desc : interface for grayplot 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 "sciCall.h"
29 #include "localization.h"
30 #include "Scierror.h"
31
32 /*--------------------------------------------------------------------------*/
33 int sci_grayplot(char *fname, void *pvApiCtx)
34 {
35     SciErr sciErr;
36     int frame_def = 8;
37     int *frame = &frame_def;
38     int axes_def = 1;
39     int *axes = &axes_def;
40     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
41     static rhs_opts opts[] =
42     {
43         { -1, "axesflag", -1, 0, 0, NULL},
44         { -1, "frameflag", -1, 0, 0, NULL},
45         { -1, "logflag", -1, 0, 0, NULL},
46         { -1, "nax", -1, 0, 0, NULL},
47         { -1, "rect", -1, 0, 0, NULL},
48         { -1, "strf", -1, 0, 0, NULL},
49         { -1, NULL, -1, 0, 0, NULL}
50     };
51
52     char   * strf    = NULL ;
53     char strfl[4];
54     double* rect    = NULL ;
55     int    * nax     = NULL ;
56     BOOL     flagNax = FALSE;
57     char* logFlags = NULL;
58
59     int* piAddr1 = NULL;
60     int* piAddr2 = NULL;
61     int* piAddr3 = NULL;
62
63     double* l1 = NULL;
64     double* l2 = NULL;
65     double* l3 = NULL;
66
67     if (nbInputArgument(pvApiCtx) <= 0)
68     {
69         sci_demo(fname, pvApiCtx);
70         return 0;
71     }
72     CheckInputArgument(pvApiCtx, 3, 7);
73
74     if (getOptionals(pvApiCtx, fname, opts) == 0)
75     {
76         ReturnArguments(pvApiCtx);
77         return 0;
78     }
79
80     if (FirstOpt(pvApiCtx) < 4)
81     {
82         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
83                  fname, 1, 4);
84         return -1;
85     }
86     //get variable address
87     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
88     if (sciErr.iErr)
89     {
90         printError(&sciErr, 0);
91         return 1;
92     }
93
94     // Retrieve a matrix of double at position 1.
95     sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
96     if (sciErr.iErr)
97     {
98         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
99         printError(&sciErr, 0);
100         return 1;
101     }
102
103     //CheckVector
104     if (m1 != 1 && n1 != 1)
105     {
106         Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 1);
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     //CheckVector
128     if (m2 != 1 && n2 != 1)
129     {
130         Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2);
131         return 1;
132     }
133
134     //get variable address
135     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
136     if (sciErr.iErr)
137     {
138         printError(&sciErr, 0);
139         return 1;
140     }
141
142     // Retrieve a matrix of double at position 3.
143     sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
144     if (sciErr.iErr)
145     {
146         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 3);
147         printError(&sciErr, 0);
148         return 1;
149     }
150
151     if (m3 * n3 == 0)
152     {
153         AssignOutputVariable(pvApiCtx, 1) = 0;
154         ReturnArguments(pvApiCtx);
155         return 0;
156     }
157
158     //CheckDimProp
159     if (m2 * n2 != n3)
160     {
161         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
162         return 1;
163     }
164
165     //CheckDimProp
166     if (m1 * n1 != m3)
167     {
168         Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
169         return 1;
170     }
171
172
173     if (get_strf_arg(pvApiCtx, fname, 4, opts, &strf) == 0)
174     {
175         return 0;
176     }
177     if (get_rect_arg(pvApiCtx, fname, 5, opts, &rect) == 0)
178     {
179         return 0;
180     }
181     if (get_nax_arg(pvApiCtx, 6, opts, &nax, &flagNax)==0)
182     {
183         return 0;
184     }
185     if (get_logflags_arg(pvApiCtx, fname, 7, opts, &logFlags) == 0)
186     {
187         return 0;
188     }
189
190     getOrCreateDefaultSubwin();
191
192     if (isDefStrf(strf))
193     {
194         strcpy(strfl, DEFSTRFN);
195
196         strf = strfl;
197         if (!isDefRect(rect))
198         {
199             strfl[1] = '7';
200         }
201
202         if (get_optional_int_arg(pvApiCtx, fname, 7, "frameflag", &frame, 1, opts) == 0)
203         {
204             return 0;
205         }
206         if (frame != &frame_def)
207         {
208             strfl[1] = (char)(*frame + 48);
209         }
210         if (get_optional_int_arg(pvApiCtx, fname, 7, "axesflag", &axes, 1, opts) == 0)
211         {
212             return 0;
213         }
214         if (axes != &axes_def)
215         {
216             strfl[2] = (char)(*axes + 48);
217         }
218     }
219
220     Objgrayplot ((l1), (l2), (l3), &m3, &n3, strf, rect, nax, flagNax, logFlags);
221
222     AssignOutputVariable(pvApiCtx, 1) = 0;
223     ReturnArguments(pvApiCtx);
224     return 0;
225 }
226 /*--------------------------------------------------------------------------*/