Bug 9859 fixed: It was not possible to draw arrows in 3D with xarrows
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_xarrows.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_xarrows.h                                                    */
16 /* desc : interface for xarrows routine                                   */
17 /*------------------------------------------------------------------------*/
18
19 #include "gw_graphics.h"
20 #include "sciCall.h"
21 #include "api_scilab.h"
22 #include "localization.h"
23 #include "Scierror.h"
24 #include "HandleManagement.h"
25 #include "BuildObjects.h"
26 /*--------------------------------------------------------------------------*/
27 int sci_xarrows(char *fname, unsigned long fname_len)
28 {
29     SciErr sciErr;
30
31     int* piAddrl1 = NULL;
32     double* l1 = NULL;
33     int* piAddrl2 = NULL;
34     double* l2 = NULL;
35     int* piAddrl3 = NULL;
36     double* l3 = NULL;
37     int* piAddr4 = NULL;
38     int* l4 = NULL;
39     double* dl4 = NULL;
40
41     int dstyle = -1, m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 1, n3 = 1;
42     int *style = NULL, flag = 0;
43     int m4 = 0, n4 = 0, mn2 = 0;
44     double arsize = -1.0;
45     double * zptr = NULL;
46     int stylePos = 4;
47     int *piAddr = NULL;
48
49     CheckInputArgument(pvApiCtx, 2, 5);
50
51     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
52     if (sciErr.iErr)
53     {
54         printError(&sciErr, 0);
55         return 1;
56     }
57
58     // Retrieve a matrix of double at position 1.
59     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
60     if (sciErr.iErr)
61     {
62         printError(&sciErr, 0);
63         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
64         return 1;
65     }
66
67     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
68     if (sciErr.iErr)
69     {
70         printError(&sciErr, 0);
71         return 1;
72     }
73
74     // Retrieve a matrix of double at position 2.
75     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
76     if (sciErr.iErr)
77     {
78         printError(&sciErr, 0);
79         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
80         return 1;
81     }
82
83     mn2 = m2 * n2;
84     //CheckSameDims
85     if (m1 != m2 || n1 != n2)
86     {
87         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
88         return 1;
89     }
90
91     if (mn2 == 0)
92     {
93         AssignOutputVariable(pvApiCtx, 1) = 0;
94         ReturnArguments(pvApiCtx);
95         return 0;
96     }
97
98     if (nbInputArgument(pvApiCtx) >= 3)
99     {
100         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
101         if (sciErr.iErr)
102         {
103             printError(&sciErr, 0);
104             return 1;
105         }
106
107         // Retrieve a matrix of double at position 3.
108         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl3, &m3, &n3, &l3);
109         if (sciErr.iErr)
110         {
111             printError(&sciErr, 0);
112             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
113             return 1;
114         }
115
116         if (m3 == m1 && n3 == n1)
117         {
118             zptr = l3;
119             if (nbInputArgument(pvApiCtx) >= 4)
120             {
121                 sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
122                 if (sciErr.iErr)
123                 {
124                     printError(&sciErr, 0);
125                     return 1;
126                 }
127
128                 // Retrieve a matrix of double at position 4.
129                 sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &dl4);
130                 if (sciErr.iErr)
131                 {
132                     printError(&sciErr, 0);
133                     Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
134                     return 1;
135                 }
136
137                 if (m4 != 1 || n4 != 1)
138                 {
139                     Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4);
140                     return 1;
141                 }
142             }
143             arsize = *dl4;
144             stylePos = 5;
145         }
146         else if (m3 == 1 && n3 == 1)
147         {
148             if (nbInputArgument(pvApiCtx) > 4)
149             {
150                 Scierror(999, _("%s: Wrong number of input arguments: at least %d expected.\n"), fname, 4);
151                 return 1;
152             }
153
154             arsize = *l3;
155         }
156         else
157         {
158             Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix or a scalar expected.\n"), fname, 3, m1, n1);
159             return 1;
160         }
161     }
162
163     if (nbInputArgument(pvApiCtx) >= stylePos)
164     {
165         sciErr = getVarAddressFromPosition(pvApiCtx, stylePos, &piAddr);
166         if (sciErr.iErr)
167         {
168             printError(&sciErr, 0);
169             return 1;
170         }
171
172         // Retrieve a matrix of double at position 4 or 5.
173         sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr, &m4, &n4, &l4);
174         if (sciErr.iErr)
175         {
176             printError(&sciErr, 0);
177             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, stylePos);
178             return 1;
179         }
180
181         //CheckVector
182         if (m4 != 1 && n4 != 1)
183         {
184             Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, stylePos);
185             return 1;
186         }
187
188         if (m4 * n4 == 1)
189         {
190             dstyle = *(int*)(l4);
191         }
192         if (m4 * n4 != 1 && m2 * n2 / 2 != m4 * n4)
193         {
194             Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, stylePos, m2 * n2 / 2);
195             return 0;
196         }
197     }
198
199     /* NG beg */
200     if (nbInputArgument(pvApiCtx) == stylePos && m4 * n4 != 1)
201     {
202         style = (int*)(l4);
203         flag = 1;
204     }
205     else
206     {
207         style = &dstyle;
208         flag = 0;
209     }
210
211     getOrCreateDefaultSubwin();
212
213     Objsegs(style, flag, mn2, (l1), (l2), zptr, arsize);
214
215     AssignOutputVariable(pvApiCtx, 1) = 0;
216     ReturnArguments(pvApiCtx);
217     return 0;
218 }
219 /*--------------------------------------------------------------------------*/