GO: replace if-else-if by switch
[scilab.git] / scilab / modules / graphic_objects / src / cpp / NgonPolylineData.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2010 - 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 <iostream>
14
15 #include "NgonPolylineData.hxx"
16 #include "DataProperties.hxx"
17
18 extern "C" {
19 #include "BOOL.h"
20
21 #include <string.h>
22
23 #include "graphicObjectProperties.h"
24 }
25
26 NgonPolylineData::NgonPolylineData(void)
27 {
28     xShift = NULL;
29     yShift = NULL;
30     zShift = NULL;
31
32     xShiftSet = 0;
33     yShiftSet = 0;
34     zShiftSet = 0;
35
36     coordinatesShift = NULL;
37
38     zCoordinatesSet = 0;
39 }
40
41 NgonPolylineData::~NgonPolylineData(void)
42 {
43     if (xShiftSet)
44     {
45         delete [] xShift;
46     }
47
48     if (yShiftSet)
49     {
50         delete [] yShift;
51     }
52
53     if (zShiftSet)
54     {
55         delete [] zShift;
56     }
57 }
58
59 int NgonPolylineData::getPropertyFromName(int propertyName)
60 {
61     switch (propertyName)
62     {
63         case __GO_DATA_MODEL_NUM_ELEMENTS_ARRAY__ :
64             return NUM_ELEMENTS_ARRAY;
65         case __GO_DATA_MODEL_X_COORDINATES_SHIFT__ :
66             return X_COORDINATES_SHIFT;
67         case __GO_DATA_MODEL_Y_COORDINATES_SHIFT__ :
68             return Y_COORDINATES_SHIFT;
69         case __GO_DATA_MODEL_Z_COORDINATES_SHIFT__ :
70             return Z_COORDINATES_SHIFT;
71         case __GO_DATA_MODEL_NUM_ELEMENTS__ :
72             return NUM_ELEMENTS;
73         case __GO_DATA_MODEL_X_COORDINATES_SHIFT_SET__ :
74             return X_COORDINATES_SHIFT_SET;
75         case __GO_DATA_MODEL_Y_COORDINATES_SHIFT_SET__ :
76             return Y_COORDINATES_SHIFT_SET;
77         case __GO_DATA_MODEL_Z_COORDINATES_SHIFT_SET__ :
78             return Z_COORDINATES_SHIFT_SET;
79         case __GO_DATA_MODEL_Z_COORDINATES_SET__ :
80             return Z_COORDINATES_SET;
81         default :
82             return NgonGeneralData::getPropertyFromName(propertyName);
83     }
84
85 }
86
87
88 int NgonPolylineData::setDataProperty(int property, void const* value, int numElements)
89 {
90     switch (property)
91     {
92         case NUM_ELEMENTS_ARRAY :
93             return setNumElementsArray((int const*) value);
94         case X_COORDINATES_SHIFT :
95             return setXCoordinatesShift((double const*) value, numElements);
96         case Y_COORDINATES_SHIFT :
97             return setYCoordinatesShift((double const*) value, numElements);
98         case Z_COORDINATES_SHIFT :
99             return setZCoordinatesShift((double const*) value, numElements);
100         case X_COORDINATES_SHIFT_SET :
101             setXCoordinatesShiftSet(*((int const*) value));
102             break;
103         case Y_COORDINATES_SHIFT_SET :
104             setYCoordinatesShiftSet(*((int const*) value));
105             break;
106         case Z_COORDINATES_SHIFT_SET :
107             setZCoordinatesShiftSet(*((int const*) value));
108             break;
109         case Z_COORDINATES_SET :
110             setZCoordinatesSet(*((int const*) value));
111             break;
112         default :
113             return NgonGeneralData::setDataProperty(property, value, numElements);
114     }
115
116     return 1;
117 }
118
119 void NgonPolylineData::getDataProperty(int property, void **_pvData)
120 {
121     switch (property)
122     {
123         case X_COORDINATES_SHIFT :
124             *_pvData = getXCoordinatesShift();
125             break;
126         case Y_COORDINATES_SHIFT :
127             *_pvData = getYCoordinatesShift();
128             break;
129         case Z_COORDINATES_SHIFT :
130             *_pvData = getZCoordinatesShift();
131             break;
132         case NUM_ELEMENTS :
133             ((int *) *_pvData)[0] = getNumElements();
134             break;
135         case X_COORDINATES_SHIFT_SET :
136             ((int *) *_pvData)[0] = getXCoordinatesShiftSet();
137             break;
138         case Y_COORDINATES_SHIFT_SET :
139             ((int *) *_pvData)[0] = getYCoordinatesShiftSet();
140             break;
141         case Z_COORDINATES_SHIFT_SET :
142             ((int *) *_pvData)[0] = getZCoordinatesShiftSet();
143             break;
144         case Z_COORDINATES_SET :
145             ((int *) *_pvData)[0] = getZCoordinatesSet();
146             break;
147         default :
148             NgonGeneralData::getDataProperty(property, _pvData);
149     }
150 }
151
152 int NgonPolylineData::getNumElements(void)
153 {
154     return numVerticesPerGon;
155 }
156
157 void NgonPolylineData::setZCoordinatesSet(int zCoordinatesSet)
158 {
159     this->zCoordinatesSet = zCoordinatesSet;
160 }
161
162 int NgonPolylineData::getZCoordinatesSet(void)
163 {
164     return this->zCoordinatesSet;
165 }
166
167 double* NgonPolylineData::getXCoordinatesShift(void)
168 {
169     return xShift;
170 }
171
172 int NgonPolylineData::setXCoordinatesShift(double const* data, int numElements)
173 {
174     if (xShiftSet == 0)
175     {
176
177         try
178         {
179             xShift = new double[numVerticesPerGon];
180         }
181         catch (const std::exception& e)
182         {
183             e.what();
184             return 0;
185         }
186
187         xShiftSet = 1;
188     }
189
190     for (int i = 0; i < numVerticesPerGon; i++)
191     {
192         xShift[i] = data[i];
193     }
194
195     return 1;
196 }
197
198 double* NgonPolylineData::getYCoordinatesShift()
199 {
200     return yShift;
201 }
202
203 int NgonPolylineData::setYCoordinatesShift(double const* data, int numElements)
204 {
205     if (yShiftSet == 0)
206     {
207
208         try
209         {
210             yShift = new double[numVerticesPerGon];
211         }
212         catch (const std::exception& e)
213         {
214             e.what();
215             return 0;
216         }
217
218         yShiftSet = 1;
219     }
220
221     for (int i = 0; i < numVerticesPerGon; i++)
222     {
223         yShift[i] = data[i];
224     }
225
226     return 1;
227 }
228
229 double* NgonPolylineData::getZCoordinatesShift()
230 {
231     return zShift;
232 }
233
234 int NgonPolylineData::getXCoordinatesShiftSet(void)
235 {
236     return xShiftSet;
237 }
238
239 void NgonPolylineData::setXCoordinatesShiftSet(int xShiftSet)
240 {
241     if (xShiftSet == 0 && this->xShiftSet == 1)
242     {
243         delete [] xShift;
244         xShift = NULL;
245     }
246
247     this->xShiftSet = xShiftSet;
248 }
249
250 int NgonPolylineData::getYCoordinatesShiftSet(void)
251 {
252     return yShiftSet;
253 }
254
255 void NgonPolylineData::setYCoordinatesShiftSet(int yShiftSet)
256 {
257     if (yShiftSet == 0 && this->yShiftSet == 1)
258     {
259         delete [] yShift;
260         yShift = NULL;
261     }
262
263     this->yShiftSet = yShiftSet;
264 }
265
266 int NgonPolylineData::getZCoordinatesShiftSet(void)
267 {
268     return zShiftSet;
269 }
270
271 void NgonPolylineData::setZCoordinatesShiftSet(int zShiftSet)
272 {
273     if (zShiftSet == 0 && this->zShiftSet == 1)
274     {
275         delete [] zShift;
276         zShift = NULL;
277     }
278
279     this->zShiftSet = zShiftSet;
280 }
281
282 int NgonPolylineData::setZCoordinatesShift(double const* data, int numElements)
283 {
284     if (zShiftSet == 0)
285     {
286
287         try
288         {
289             zShift = new double[numVerticesPerGon];
290         }
291         catch (const std::exception& e)
292         {
293             e.what();
294             return 0;
295         }
296
297         zShiftSet = 1;
298     }
299
300     for (int i = 0; i < numVerticesPerGon; i++)
301     {
302         zShift[i] = data[i];
303     }
304
305     return 1;
306 }
307
308 int NgonPolylineData::setNumElementsArray(int const* numElementsArray)
309 {
310     int newNumElements = 0;
311     int previousNumElements = 0;
312     int result = 1;
313
314     if (numElementsArray[0] != 1)
315     {
316         return 0;
317     }
318
319     newNumElements = numElementsArray[0] * numElementsArray[1];
320     previousNumElements = numGons * numVerticesPerGon;
321
322     if (newNumElements == 0 && previousNumElements > 0)
323     {
324         numVerticesPerGon = 0;
325
326         deleteCoordinatesArrays();
327
328         return 1;
329     }
330
331     if (numGons * numVerticesPerGon != newNumElements)
332     {
333         double* newCoordinates = NULL;
334         double* xShiftNew = NULL;
335         double* yShiftNew = NULL;
336         double* zShiftNew = NULL;
337
338         result = 1;
339
340         try
341         {
342             newCoordinates = new double[3 * newNumElements];
343         }
344         catch (const std::exception& e)
345         {
346             e.what();
347             return 0;
348         }
349
350         if (xShiftSet)
351         {
352             try
353             {
354                 xShiftNew = new double[newNumElements];
355             }
356             catch (const std::exception& e)
357             {
358                 e.what();
359                 result = 0;
360             }
361         }
362
363         if (yShiftSet)
364         {
365             try
366             {
367                 yShiftNew = new double[newNumElements];
368             }
369             catch (const std::exception& e)
370             {
371                 e.what();
372                 result = 0;
373             }
374         }
375
376         if (zShiftSet)
377         {
378             try
379             {
380                 zShiftNew = new double[newNumElements];
381             }
382             catch (const std::exception& e)
383             {
384                 e.what();
385                 result = 0;
386             }
387         }
388
389         if (result)
390         {
391             if (numGons * numVerticesPerGon > 0)
392             {
393                 delete [] coordinates;
394             }
395
396             /*
397              * Initialize the new coordinates' z values to 0 in case
398              * they are not set afterwards.
399              */
400             for (int i = 0; i < newNumElements; i++)
401             {
402                 newCoordinates[2 * newNumElements + i] = 0.0;
403             }
404
405             coordinates = newCoordinates;
406
407             if (xShiftSet)
408             {
409                 copyShiftCoordinatesArray(xShiftNew, xShift, newNumElements);
410                 delete [] xShift;
411                 xShift = xShiftNew;
412             }
413
414             if (yShiftSet)
415             {
416                 copyShiftCoordinatesArray(yShiftNew, yShift, newNumElements);
417                 delete [] yShift;
418                 yShift = yShiftNew;
419             }
420
421             if (zShiftSet)
422             {
423                 copyShiftCoordinatesArray(zShiftNew, zShift, newNumElements);
424                 delete [] zShift;
425                 zShift = zShiftNew;
426             }
427
428             numGons = numElementsArray[0];
429             numVerticesPerGon = numElementsArray[1];
430         }
431         else
432         {
433             /* Delete the temporary arrays and don't set anything */
434             if (newCoordinates != NULL)
435             {
436                 delete [] newCoordinates;
437             }
438
439             if (xShiftNew != NULL)
440             {
441                 delete [] xShiftNew;
442             }
443
444             if (yShiftNew != NULL)
445             {
446                 delete [] yShiftNew;
447             }
448
449             if (zShiftNew != NULL)
450             {
451                 delete [] zShiftNew;
452             }
453
454         }
455
456     }
457
458     return result;
459 }
460
461 void NgonPolylineData::copyShiftCoordinatesArray(double * newShift, double const* oldShift, int numElementsNew)
462 {
463     int numElementsCopied = 0;
464
465     if (numElementsNew < numVerticesPerGon)
466     {
467         numElementsCopied = numElementsNew;
468     }
469     else
470     {
471         numElementsCopied = numVerticesPerGon;
472     }
473
474     for (int i = 0; i < numElementsCopied; i++)
475     {
476         newShift[i] = oldShift[i];
477     }
478
479     for (int i = numElementsCopied; i < numElementsNew; i++)
480     {
481         newShift[i] = 0.0;
482     }
483 }
484
485 void NgonPolylineData::deleteCoordinatesArrays(void)
486 {
487     if (coordinates != NULL)
488     {
489         delete [] coordinates;
490         coordinates = NULL;
491     }
492
493     if (xShiftSet)
494     {
495         delete [] xShift;
496         xShift = NULL;
497         xShiftSet = 0;
498     }
499
500     if (yShiftSet)
501     {
502         delete [] yShift;
503         yShift = NULL;
504         yShiftSet = 0;
505     }
506
507     if (zShiftSet)
508     {
509         delete [] zShift;
510         zShift = NULL;
511         zShiftSet = 0;
512     }
513 }
514