8e909e2279a349293070d13c3920522d40f4c452
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_xstringb.c
1
2 /*
3  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
4  * Copyright (C) 2006 - INRIA - Fabrice Leray
5  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
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_xstringb.c                                                   */
20 /* desc : interface for xstringb routine                                  */
21 /*------------------------------------------------------------------------*/
22 #include <string.h>
23 #include "gw_graphics.h"
24 #include "api_scilab.h"
25 #include "Scierror.h"
26 #include "sciCall.h"
27 #include "freeArrayOfString.h"
28 #include "localization.h"
29 /*--------------------------------------------------------------------------*/
30 int sci_xstringb(char *fname, void *pvApiCtx)
31 {
32     SciErr sciErr;
33
34     int* piAddrl1 = NULL;
35     double* l1 = NULL;
36     int* piAddrl2 = NULL;
37     double* l2 = NULL;
38     int* piAddrStr = NULL;
39     int* piAddrl4 = NULL;
40     double* l4 = NULL;
41     int* piAddrl5 = NULL;
42     double* l5 = NULL;
43     int* piAddrl6 = NULL;
44     char* l6 = NULL;
45
46     int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, m5 = 0, n5 = 0, m6 = 0, n6 = 0;
47     BOOL autoSize = TRUE ;
48     double x = 0., y = 0., w = 0., hx = 0.;
49     char **Str = NULL;
50     double rect[4], angle = 0.;
51     long hdlstr = 0;
52     double userSize[2] ;
53     int textBoxMode = 1; // 0 : off | 1 : centered | 2 : filled
54
55     if ( nbInputArgument(pvApiCtx) <= 0 )
56     {
57         /* demo */
58         sci_demo(fname, pvApiCtx);
59         return 0 ;
60     }
61
62     CheckInputArgument(pvApiCtx, 5, 6);
63
64     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
65     if (sciErr.iErr)
66     {
67         printError(&sciErr, 0);
68         return 1;
69     }
70
71     // Retrieve a matrix of double at position 1.
72     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
73     if (sciErr.iErr)
74     {
75         printError(&sciErr, 0);
76         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
77         return 1;
78     }
79
80     //CheckScalar
81     if (m1 != 1 || n1 != 1)
82     {
83         Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 1);
84         return 1;
85     }
86
87     x = *l1;
88     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
89     if (sciErr.iErr)
90     {
91         printError(&sciErr, 0);
92         return 1;
93     }
94
95     // Retrieve a matrix of double at position 2.
96     // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int l2".
97     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
98     if (sciErr.iErr)
99     {
100         printError(&sciErr, 0);
101         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
102         return 1;
103     }
104
105     //CheckScalar
106     if (m2 != 1 || n2 != 1)
107     {
108         Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 2);
109         return 1;
110     }
111
112     y = *l2;
113     sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrStr);
114     if (sciErr.iErr)
115     {
116         printError(&sciErr, 0);
117         return 1;
118     }
119
120     // Retrieve a matrix of string at position 3.
121     if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m3, &n3, &Str))
122     {
123         Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 3);
124         return 1;
125     }
126
127     if ( m3 * n3 == 0 )
128     {
129         AssignOutputVariable(pvApiCtx, 1) = 0;
130         ReturnArguments(pvApiCtx);
131         freeArrayOfString(Str, m3 * n3);
132         return 0;
133     }
134
135     sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrl4);
136     if (sciErr.iErr)
137     {
138         printError(&sciErr, 0);
139         freeArrayOfString(Str, m3 * n3);
140         return 1;
141     }
142
143     // Retrieve a matrix of double at position 4.
144     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl4, &m4, &n4, &l4);
145     if (sciErr.iErr)
146     {
147         printError(&sciErr, 0);
148         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 4);
149         freeArrayOfString(Str, m3 * n3);
150         return 1;
151     }
152
153     //CheckScalar
154     if (m4 != 1 || n4 != 1)
155     {
156         Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4);
157         freeArrayOfString(Str, m3 * n3);
158         return 1;
159     }
160
161     w = *l4;
162     sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrl5);
163     if (sciErr.iErr)
164     {
165         printError(&sciErr, 0);
166         freeArrayOfString(Str, m3 * n3);
167         return 1;
168     }
169
170     // Retrieve a matrix of double at position 5.
171     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl5, &m5, &n5, &l5);
172     if (sciErr.iErr)
173     {
174         printError(&sciErr, 0);
175         Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 5);
176         freeArrayOfString(Str, m3 * n3);
177         return 1;
178     }
179
180     //CheckScalar
181     if (m5 != 1 || n5 != 1)
182     {
183         Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 5);
184         freeArrayOfString(Str, m3 * n3);
185         return 1;
186     }
187
188     hx = *l5;
189
190     if (nbInputArgument(pvApiCtx) == 6)
191     {
192         sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddrl6);
193         if (sciErr.iErr)
194         {
195             printError(&sciErr, 0);
196             freeArrayOfString(Str, m3 * n3);
197             return 1;
198         }
199
200         // Retrieve a string at position 6.
201         if (isScalar(pvApiCtx, piAddrl6) == 0)
202         {
203             Scierror(999, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 6);
204             freeArrayOfString(Str, m3 * n3);
205             return 1;
206         }
207
208         if (getAllocatedSingleString(pvApiCtx, piAddrl6, &l6))
209         {
210             Scierror(202, _("%s: Wrong type for argument #%d: string expected.\n"), fname, 6);
211             freeArrayOfString(Str, m3 * n3);
212             return 1;
213         }
214
215         if (strcmp(l6, "fill") == 0 )
216         {
217             autoSize = FALSE ;
218             textBoxMode = 2;
219         }
220         else
221         {
222             Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 6, "fill");
223             freeAllocatedSingleString(l6);
224             freeArrayOfString(Str, m3 * n3);
225             return 0;
226         }
227
228         freeAllocatedSingleString(l6);
229     }
230
231     userSize[0] = w ;
232     userSize[1] = hx ;
233     Objstring (Str, m3, n3, x, y, &angle, rect, autoSize, userSize, &hdlstr, textBoxMode, NULL, NULL, FALSE, TRUE, FALSE, ALIGN_CENTER);
234
235     freeArrayOfString(Str, m3 * n3);
236
237     AssignOutputVariable(pvApiCtx, 1) = 0;
238     ReturnArguments(pvApiCtx);
239
240     return 0;
241
242 }
243 /*--------------------------------------------------------------------------*/