3e05991bdd0bbd10263044f726e260dd81d8c172
[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
40     int dstyle = -1, m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 1, n3 = 1;
41     int *style = NULL, flag = 0;
42     int m4 = 0, n4 = 0, mn2 = 0;
43     double arsize = -1.0;
44
45     CheckInputArgument(pvApiCtx, 2, 4);
46
47     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
48     if (sciErr.iErr)
49     {
50         printError(&sciErr, 0);
51         return 1;
52     }
53
54     // Retrieve a matrix of double at position 1.
55     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
56     if (sciErr.iErr)
57     {
58         printError(&sciErr, 0);
59         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
60         return 1;
61     }
62
63     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
64     if (sciErr.iErr)
65     {
66         printError(&sciErr, 0);
67         return 1;
68     }
69
70     // Retrieve a matrix of double at position 2.
71     sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
72     if (sciErr.iErr)
73     {
74         printError(&sciErr, 0);
75         Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
76         return 1;
77     }
78
79     mn2 = m2 * n2;
80     //CheckSameDims
81     if (m1 != m2 || n1 != n2)
82     {
83         Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
84         return 1;
85     }
86
87     if (mn2 == 0)
88     {
89         AssignOutputVariable(pvApiCtx, 1) = 0;
90         ReturnArguments(pvApiCtx);
91         return 0;
92     }
93
94     if (nbInputArgument(pvApiCtx) >= 3)
95     {
96         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
97         if (sciErr.iErr)
98         {
99             printError(&sciErr, 0);
100             return 1;
101         }
102
103         // Retrieve a matrix of double at position 3.
104         sciErr = getMatrixOfDouble(pvApiCtx, piAddrl3, &m3, &n3, &l3);
105         if (sciErr.iErr)
106         {
107             printError(&sciErr, 0);
108             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
109             return 1;
110         }
111
112         //CheckScalar
113         if (m3 != 1 || n3 != 1)
114         {
115             Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 3);
116             return 1;
117         }
118
119         arsize = *l3;
120     }
121
122     if (nbInputArgument(pvApiCtx) >= 4)
123     {
124         sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
125         if (sciErr.iErr)
126         {
127             printError(&sciErr, 0);
128             return 1;
129         }
130
131         // Retrieve a matrix of double at position 4.
132         sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr4, &m4, &n4, &l4);
133         if (sciErr.iErr)
134         {
135             printError(&sciErr, 0);
136             Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
137             return 1;
138         }
139
140         //CheckVector
141         if (m4 != 1 && n4 != 1)
142         {
143             Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 4);
144             return 1;
145         }
146
147         if (m4 * n4 == 1)
148         {
149             dstyle = *(int*)(l4);
150         }
151         if (m4 * n4 != 1 && m2 * n2 / 2 != m4 * n4)
152         {
153             Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 4, m2 * n2 / 2);
154             return 0;
155         }
156     }
157     /* NG beg */
158     if (nbInputArgument(pvApiCtx) == 4 && m4 * n4 != 1)
159     {
160         style = (int*)(l4);
161         flag = 1;
162     }
163     else
164     {
165         style = &dstyle;
166         flag = 0;
167     }
168
169     getOrCreateDefaultSubwin();
170
171     Objsegs(style, flag, mn2, (l1), (l2), NULL, arsize);
172
173     AssignOutputVariable(pvApiCtx, 1) = 0;
174     ReturnArguments(pvApiCtx);
175     return 0;
176 }
177 /*--------------------------------------------------------------------------*/