7ce75265363dba28cdd7d5168a821a4a14185d39
[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     if (property == NUM_ELEMENTS_ARRAY)
91     {
92         return setNumElementsArray((int const*) value);
93     }
94     else if (property == X_COORDINATES_SHIFT)
95     {
96         return setXCoordinatesShift((double const*) value, numElements);
97     }
98     else if (property == Y_COORDINATES_SHIFT)
99     {
100         return setYCoordinatesShift((double const*) value, numElements);
101     }
102     else if (property == Z_COORDINATES_SHIFT)
103     {
104         return setZCoordinatesShift((double const*) value, numElements);
105     }
106     else if (property == X_COORDINATES_SHIFT_SET)
107     {
108         setXCoordinatesShiftSet(*((int const*) value));
109     }
110     else if (property == Y_COORDINATES_SHIFT_SET)
111     {
112         setYCoordinatesShiftSet(*((int const*) value));
113     }
114     else if (property == Z_COORDINATES_SHIFT_SET)
115     {
116         setZCoordinatesShiftSet(*((int const*) value));
117     }
118     else if (property == Z_COORDINATES_SET)
119     {
120         setZCoordinatesSet(*((int const*) value));
121     }
122     else
123     {
124         return NgonGeneralData::setDataProperty(property, value, numElements);
125     }
126
127     return 1;
128 }
129
130 void NgonPolylineData::getDataProperty(int property, void **_pvData)
131 {
132     if (property == X_COORDINATES_SHIFT)
133     {
134         *_pvData = getXCoordinatesShift();
135     }
136     else if (property == Y_COORDINATES_SHIFT)
137     {
138         *_pvData = getYCoordinatesShift();
139     }
140     else if (property == Z_COORDINATES_SHIFT)
141     {
142         *_pvData = getZCoordinatesShift();
143     }
144     else if (property == NUM_ELEMENTS)
145     {
146         ((int *) *_pvData)[0] = getNumElements();
147     }
148     else if (property == X_COORDINATES_SHIFT_SET)
149     {
150         ((int *) *_pvData)[0] = getXCoordinatesShiftSet();
151     }
152     else if (property == Y_COORDINATES_SHIFT_SET)
153     {
154         ((int *) *_pvData)[0] = getYCoordinatesShiftSet();
155     }
156     else if (property == Z_COORDINATES_SHIFT_SET)
157     {
158         ((int *) *_pvData)[0] = getZCoordinatesShiftSet();
159     }
160     else if (property == Z_COORDINATES_SET)
161     {
162         ((int *) *_pvData)[0] = getZCoordinatesSet();
163     }
164     else
165     {
166         NgonGeneralData::getDataProperty(property, _pvData);
167     }
168
169 }
170
171 int NgonPolylineData::getNumElements(void)
172 {
173     return numVerticesPerGon;
174 }
175
176 void NgonPolylineData::setZCoordinatesSet(int zCoordinatesSet)
177 {
178     this->zCoordinatesSet = zCoordinatesSet;
179 }
180
181 int NgonPolylineData::getZCoordinatesSet(void)
182 {
183     return this->zCoordinatesSet;
184 }
185
186 double* NgonPolylineData::getXCoordinatesShift(void)
187 {
188     return xShift;
189 }
190
191 int NgonPolylineData::setXCoordinatesShift(double const* data, int numElements)
192 {
193     if (xShiftSet == 0)
194     {
195
196         try
197         {
198             xShift = new double[numVerticesPerGon];
199         }
200         catch (const std::exception& e)
201         {
202             e.what();
203             return 0;
204         }
205
206         xShiftSet = 1;
207     }
208
209     for (int i = 0; i < numVerticesPerGon; i++)
210     {
211         xShift[i] = data[i];
212     }
213
214     return 1;
215 }
216
217 double* NgonPolylineData::getYCoordinatesShift()
218 {
219     return yShift;
220 }
221
222 int NgonPolylineData::setYCoordinatesShift(double const* data, int numElements)
223 {
224     if (yShiftSet == 0)
225     {
226
227         try
228         {
229             yShift = new double[numVerticesPerGon];
230         }
231         catch (const std::exception& e)
232         {
233             e.what();
234             return 0;
235         }
236
237         yShiftSet = 1;
238     }
239
240     for (int i = 0; i < numVerticesPerGon; i++)
241     {
242         yShift[i] = data[i];
243     }
244
245     return 1;
246 }
247
248 double* NgonPolylineData::getZCoordinatesShift()
249 {
250     return zShift;
251 }
252
253 int NgonPolylineData::getXCoordinatesShiftSet(void)
254 {
255     return xShiftSet;
256 }
257
258 void NgonPolylineData::setXCoordinatesShiftSet(int xShiftSet)
259 {
260     if (xShiftSet == 0 && this->xShiftSet == 1)
261     {
262         delete [] xShift;
263         xShift = NULL;
264     }
265
266     this->xShiftSet = xShiftSet;
267 }
268
269 int NgonPolylineData::getYCoordinatesShiftSet(void)
270 {
271     return yShiftSet;
272 }
273
274 void NgonPolylineData::setYCoordinatesShiftSet(int yShiftSet)
275 {
276     if (yShiftSet == 0 && this->yShiftSet == 1)
277     {
278         delete [] yShift;
279         yShift = NULL;
280     }
281
282     this->yShiftSet = yShiftSet;
283 }
284
285 int NgonPolylineData::getZCoordinatesShiftSet(void)
286 {
287     return zShiftSet;
288 }
289
290 void NgonPolylineData::setZCoordinatesShiftSet(int zShiftSet)
291 {
292     if (zShiftSet == 0 && this->zShiftSet == 1)
293     {
294         delete [] zShift;
295         zShift = NULL;
296     }
297
298     this->zShiftSet = zShiftSet;
299 }
300
301 int NgonPolylineData::setZCoordinatesShift(double const* data, int numElements)
302 {
303     if (zShiftSet == 0)
304     {
305
306         try
307         {
308             zShift = new double[numVerticesPerGon];
309         }
310         catch (const std::exception& e)
311         {
312             e.what();
313             return 0;
314         }
315
316         zShiftSet = 1;
317     }
318
319     for (int i = 0; i < numVerticesPerGon; i++)
320     {
321         zShift[i] = data[i];
322     }
323
324     return 1;
325 }
326
327 int NgonPolylineData::setNumElementsArray(int const* numElementsArray)
328 {
329     int newNumElements = 0;
330     int previousNumElements = 0;
331     int result = 1;
332
333     if (numElementsArray[0] != 1)
334     {
335         return 0;
336     }
337
338     newNumElements = numElementsArray[0] * numElementsArray[1];
339     previousNumElements = numGons * numVerticesPerGon;
340
341     if (newNumElements == 0 && previousNumElements > 0)
342     {
343         numVerticesPerGon = 0;
344
345         deleteCoordinatesArrays();
346
347         return 1;
348     }
349
350     if (numGons*numVerticesPerGon != newNumElements)
351     {
352         double* newCoordinates = NULL;
353         double* xShiftNew = NULL;
354         double* yShiftNew = NULL;
355         double* zShiftNew = NULL;
356
357         result = 1;
358
359         try
360         {
361             newCoordinates = new double[3 * newNumElements];
362         }
363         catch (const std::exception& e)
364         {
365             e.what();
366             return 0;
367         }
368
369         if (xShiftSet)
370         {
371             try
372             {
373                 xShiftNew = new double[newNumElements];
374             }
375             catch (const std::exception& e)
376             {
377                 e.what();
378                 result = 0;
379             }
380         }
381
382         if (yShiftSet)
383         {
384             try
385             {
386                 yShiftNew = new double[newNumElements];
387             }
388             catch (const std::exception& e)
389             {
390                 e.what();
391                 result = 0;
392             }
393         }
394
395         if (zShiftSet)
396         {
397             try
398             {
399                 zShiftNew = new double[newNumElements];
400             }
401             catch (const std::exception& e)
402             {
403                 e.what();
404                 result = 0;
405             }
406         }
407
408         if (result)
409         {
410             if (numGons * numVerticesPerGon > 0)
411             {
412                 delete [] coordinates;
413             }
414
415             /*
416              * Initialize the new coordinates' z values to 0 in case
417              * they are not set afterwards.
418              */
419             for (int i = 0; i < newNumElements; i++)
420             {
421                 newCoordinates[2 * newNumElements + i] = 0.0;
422             }
423
424             coordinates = newCoordinates;
425
426             if (xShiftSet)
427             {
428                 copyShiftCoordinatesArray(xShiftNew, xShift, newNumElements);
429                 delete [] xShift;
430                 xShift = xShiftNew;
431             }
432
433             if (yShiftSet)
434             {
435                 copyShiftCoordinatesArray(yShiftNew, yShift, newNumElements);
436                 delete [] yShift;
437                 yShift = yShiftNew;
438             }
439
440             if (zShiftSet)
441             {
442                 copyShiftCoordinatesArray(zShiftNew, zShift, newNumElements);
443                 delete [] zShift;
444                 zShift = zShiftNew;
445             }
446
447             numGons = numElementsArray[0];
448             numVerticesPerGon = numElementsArray[1];
449         }
450         else
451         {
452             /* Delete the temporary arrays and don't set anything */
453             if (newCoordinates != NULL)
454             {
455                 delete [] newCoordinates;
456             }
457
458             if (xShiftNew != NULL)
459             {
460                 delete [] xShiftNew;
461             }
462
463             if (yShiftNew != NULL)
464             {
465                 delete [] yShiftNew;
466             }
467
468             if (zShiftNew != NULL)
469             {
470                 delete [] zShiftNew;
471             }
472
473         }
474
475     }
476
477     return result;
478 }
479
480 void NgonPolylineData::copyShiftCoordinatesArray(double * newShift, double const* oldShift, int numElementsNew)
481 {
482     int numElementsCopied = 0;
483
484     if (numElementsNew < numVerticesPerGon)
485     {
486         numElementsCopied = numElementsNew;
487     }
488     else
489     {
490         numElementsCopied = numVerticesPerGon;
491     }
492
493     for (int i = 0; i < numElementsCopied; i++)
494     {
495         newShift[i] = oldShift[i];
496     }
497
498     for (int i = numElementsCopied; i < numElementsNew; i++)
499     {
500         newShift[i] = 0.0;
501     }
502 }
503
504 void NgonPolylineData::deleteCoordinatesArrays(void)
505 {
506     if (coordinates != NULL)
507     {
508         delete [] coordinates;
509         coordinates = NULL;
510     }
511
512     if (xShiftSet)
513     {
514         delete [] xShift;
515         xShift = NULL;
516         xShiftSet = 0;
517     }
518
519     if (yShiftSet)
520     {
521         delete [] yShift;
522         yShift = NULL;
523         yShiftSet = 0;
524     }
525
526     if (zShiftSet)
527     {
528         delete [] zShift;
529         zShift = NULL;
530         zShiftSet = 0;
531     }
532 }
533