GO: replace if-else-if by switch
[scilab.git] / scilab / modules / graphic_objects / src / cpp / NgonGridData.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2010-2012 - DIGITEO - Manuel Juliachs
4  *
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
10  *
11  */
12
13 #include "NgonGridData.hxx"
14
15 extern "C" {
16 #include <string.h>
17 #include <stdlib.h>
18
19 #include "graphicObjectProperties.h"
20 }
21
22 NgonGridData::NgonGridData(void)
23 {
24     numGons = 0;
25
26     /* Grid: must be set to 4 */
27     numVerticesPerGon = 4;
28
29     xCoordinates = NULL;
30     yCoordinates = NULL;
31     zCoordinates = NULL;
32
33     xSize = 0;
34     ySize = 0;
35
36     xDimensions[0] = 0;
37     xDimensions[1] = 0;
38
39     yDimensions[0] = 0;
40     yDimensions[1] = 0;
41
42     /* Set to 0 as a default */
43     zCoordinatesShift = 0.0;
44 }
45
46 NgonGridData::~NgonGridData(void)
47 {
48     if (xSize > 0)
49     {
50         delete [] xCoordinates;
51     }
52
53     if (ySize > 0)
54     {
55         delete [] yCoordinates;
56     }
57
58     if (xSize > 0 && ySize > 0)
59     {
60         delete [] zCoordinates;
61     }
62 }
63
64 int NgonGridData::getPropertyFromName(int propertyName)
65 {
66     switch (propertyName)
67     {
68         case __GO_DATA_MODEL_NUM_X__ :
69             return NUM_X;
70         case __GO_DATA_MODEL_NUM_Y__ :
71             return NUM_Y;
72         case __GO_DATA_MODEL_NUM_Z__ :
73             return NUM_Z;
74         case __GO_DATA_MODEL_X_DIMENSIONS__ :
75             return X_DIMENSIONS;
76         case __GO_DATA_MODEL_Y_DIMENSIONS__ :
77             return Y_DIMENSIONS;
78         case __GO_DATA_MODEL_GRID_SIZE__ :
79             return GRID_SIZE;
80         case __GO_DATA_MODEL_X__ :
81             return X_COORDINATES;
82         case __GO_DATA_MODEL_Y__ :
83             return Y_COORDINATES;
84         case __GO_DATA_MODEL_Z__ :
85             return Z_COORDINATES;
86         case __GO_DATA_MODEL_Z_COORDINATES_SHIFT__ :
87             return Z_COORDINATES_SHIFT;
88         default :
89             return NgonData::getPropertyFromName(propertyName);
90     }
91
92 }
93
94 int NgonGridData::setDataProperty(int property, void const* value, int numElements)
95 {
96     switch (property)
97     {
98         case GRID_SIZE :
99             return setGridSize((int const*) value);
100         case X_COORDINATES :
101             setDataX((double const*) value, numElements);
102             break;
103         case Y_COORDINATES :
104             setDataY((double const*) value, numElements);
105             break;
106         case Z_COORDINATES :
107             setDataZ((double const*) value, numElements);
108             break;
109         case Z_COORDINATES_SHIFT :
110             setZCoordinatesShift((double const*) value);
111             break;
112         default :
113             return NgonData::setDataProperty(property, value, numElements);
114     }
115
116     return 1;
117 }
118
119 void NgonGridData::getDataProperty(int property, void **_pvData)
120 {
121     switch (property)
122     {
123         case NUM_X:
124             ((int *) *_pvData)[0] = getNumX();
125             break;
126         case NUM_Y :
127             ((int *) *_pvData)[0] = getNumY();
128             break;
129         case NUM_Z :
130             ((int *) *_pvData)[0] = getNumZ();
131             break;
132         case X_DIMENSIONS :
133             *_pvData = getXDimensions();
134             break;
135         case Y_DIMENSIONS :
136             *_pvData = getYDimensions();
137             break;
138         case X_COORDINATES :
139             *_pvData = getDataX();
140             break;
141         case Y_COORDINATES :
142             *_pvData = getDataY();
143             break;
144         case Z_COORDINATES :
145             *_pvData = getDataZ();
146             break;
147         case Z_COORDINATES_SHIFT :
148             ((double *) *_pvData)[0] = getZCoordinatesShift();
149             break;
150         default :
151             NgonData::getDataProperty(property, _pvData);
152     }
153 }
154
155 int NgonGridData::setGridSize(int const* gridSize)
156 {
157     int newXSize = 0;
158     int newYSize = 0;
159     int xModified = 0;
160     int yModified = 0;
161     int zModified = 0;
162     int result = 0;
163
164     double* newXCoordinates = NULL;
165     double* newYCoordinates = NULL;
166     double* newZCoordinates = NULL;
167
168     result = 1;
169
170     xModified = 0;
171     yModified = 0;
172     zModified = 0;
173
174     if ((gridSize[0] != 1) && (gridSize[1] != 1))
175     {
176         return 0;
177     }
178
179     if ((gridSize[2] != 1) && (gridSize[3] != 1))
180     {
181         return 0;
182     }
183
184     newXSize = gridSize[0] * gridSize[1];
185     newYSize = gridSize[2] * gridSize[3];
186
187
188     if (newXSize != xSize)
189     {
190         xModified = 1;
191
192         try
193         {
194             newXCoordinates = new double[newXSize];
195         }
196         catch (const std::exception& e)
197         {
198             e.what();
199             result = 0;
200         }
201     }
202
203     if (newYSize != ySize)
204     {
205         yModified = 1;
206
207         try
208         {
209             newYCoordinates = new double[newYSize];
210         }
211         catch (const std::exception& e)
212         {
213             e.what();
214             result = 0;
215         }
216     }
217
218     if (newXSize * newYSize != xSize * ySize)
219     {
220         zModified = 1;
221
222         try
223         {
224             newZCoordinates = new double[newXSize * newYSize];
225         }
226         catch (const std::exception& e)
227         {
228             e.what();
229             result = 0;
230         }
231     }
232
233     if (result)
234     {
235         if (xModified)
236         {
237             if (xSize > 0)
238             {
239                 delete [] xCoordinates;
240             }
241
242             xCoordinates = newXCoordinates;
243             xSize = newXSize;
244         }
245
246         xDimensions[0] = gridSize[0];
247         xDimensions[1] = gridSize[1];
248
249         if (yModified)
250         {
251             if (ySize > 0)
252             {
253                 delete [] yCoordinates;
254             }
255
256             yCoordinates = newYCoordinates;
257             ySize = newYSize;
258         }
259
260         yDimensions[0] = gridSize[2];
261         yDimensions[1] = gridSize[3];
262
263         if (zModified)
264         {
265             if (xSize * ySize > 0)
266             {
267                 delete [] zCoordinates;
268             }
269
270             zCoordinates = newZCoordinates;
271
272             numGons = (xSize - 1) * (ySize - 1);
273         }
274
275     }
276     else
277     {
278         /* Failed allocation(s) */
279
280         if (xModified && (newXCoordinates != NULL))
281         {
282             delete [] newXCoordinates;
283         }
284
285         if (yModified && (newYCoordinates != NULL))
286         {
287             delete [] newYCoordinates;
288         }
289
290         if (zModified && (newZCoordinates != NULL))
291         {
292             delete [] newZCoordinates;
293         }
294
295     }
296
297     return result;
298 }
299
300 int NgonGridData::getNumX(void)
301 {
302     return xSize;
303 }
304
305 int NgonGridData::getNumY(void)
306 {
307     return ySize;
308 }
309
310 int NgonGridData::getNumZ(void)
311 {
312     return xSize * ySize;
313 }
314
315 int* NgonGridData::getXDimensions(void)
316 {
317     return xDimensions;
318 }
319
320 int* NgonGridData::getYDimensions(void)
321 {
322     return yDimensions;
323 }
324
325 void NgonGridData::setDataX(double const* data, int numElements)
326 {
327     if (numElements > xSize)
328     {
329         return;
330     }
331
332     for (int i = 0; i < numElements; i++)
333     {
334         xCoordinates[i] = data[i];
335     }
336 }
337
338 void NgonGridData::setDataY(double const* data, int numElements)
339 {
340     if (numElements > ySize)
341     {
342         return;
343     }
344
345     for (int i = 0; i < numElements; i++)
346     {
347         yCoordinates[i] = data[i];
348     }
349 }
350
351 void NgonGridData::setDataZ(double const* data, int numElements)
352 {
353     if (numElements > xSize * ySize)
354     {
355         return;
356     }
357
358     for (int i = 0; i < numElements; i++)
359     {
360         zCoordinates[i] = data[i];
361     }
362 }
363
364 void NgonGridData::setZCoordinatesShift(double const* data)
365 {
366     zCoordinatesShift = *data;
367 }
368
369 double* NgonGridData::getDataX(void)
370 {
371     return xCoordinates;
372 }
373
374 double* NgonGridData::getDataY(void)
375 {
376     return yCoordinates;
377 }
378
379 double* NgonGridData::getDataZ(void)
380 {
381     return zCoordinates;
382 }
383
384 double NgonGridData::getZCoordinatesShift(void)
385 {
386     return zCoordinatesShift;
387 }