Merge remote-tracking branch 'origin/master' into YaSp
[scilab.git] / scilab / modules / graphics / sci_gateway / c / sci_delete.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - ENPC - Jean-Philipe Chancelier
4  * Copyright (C) 2006 - INRIA - Fabrice Leray
5  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
6  * Copyright (C) 2011 - DIGITEO - Bruno JOFRET
7  *
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at
12  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
13  *
14  */
15
16 /*------------------------------------------------------------------------*/
17 /* file: sci_delete.c                                                     */
18 /* desc : interface for delete routine                                    */
19 /*------------------------------------------------------------------------*/
20
21 #include "MALLOC.h"
22 #include "gw_graphics.h"
23 #include "api_scilab.h"
24 #include "DestroyObjects.h"
25 #include "SetProperty.h"
26 #include "GetProperty.h"
27 #include "DrawObjects.h"
28 #include "Interaction.h"
29 #include "localization.h"
30 #include "Scierror.h"
31 #include "HandleManagement.h"
32 #include "FigureList.h"
33 #include "deleteGraphicObject.h"
34 #include "CurrentObject.h"
35 #include "CurrentFigure.h"
36 #include "BuildObjects.h"
37
38 #include "AxesModel.h"
39 #include "FigureModel.h"
40
41 #include "getGraphicObjectProperty.h"
42 #include "graphicObjectProperties.h"
43 #include "getConsoleIdentifier.h"
44 #include "CurrentSubwin.h"
45 #include "sciprint.h"
46
47 #include "os_strdup.h"
48 /*--------------------------------------------------------------------------*/
49 int sci_delete(char *fname, void* pvApiCtx)
50 {
51     SciErr sciErr;
52
53     int* piAddrl1 = NULL;
54     long long* l1 = NULL;
55     int* piAddrl2 = NULL;
56     char* l2 = NULL;
57
58     int m1 = 0, n1 = 0;
59     unsigned long hdl = 0;
60     int nb_handles = 0, i = 0, dont_overload = 0;
61     char *pobjUID = NULL;
62     char* pFigureUID = NULL;
63     char** childrenUID = NULL;
64     int iChildrenCount = 0;
65     int* childrencount = &iChildrenCount;
66     int iHidden = 0;
67     int *piHidden = &iHidden;
68
69     char *pstParentUID = NULL;
70     int iParentType = -1;
71     int *piParentType = &iParentType;
72     int iObjType = -1;
73     int *piObjType = &iObjType;
74
75     CheckInputArgument(pvApiCtx, 0, 1);
76     CheckOutputArgument(pvApiCtx, 0, 1);
77
78     if (nbInputArgument(pvApiCtx) == 0)               /* Delete current object */
79     {
80         pobjUID = (char*)getCurrentObject();
81         if (pobjUID == NULL)
82         {
83             //No current object, we can leave
84             AssignOutputVariable(pvApiCtx, 1) = 0;
85             ReturnArguments(pvApiCtx);
86             return 0;
87         }
88
89         hdl = (unsigned long)getHandle(pobjUID);
90         dont_overload = 1;
91         nb_handles = 1;
92     }
93     else
94     {
95         sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
96         if (sciErr.iErr)
97         {
98             printError(&sciErr, 0);
99             return 1;
100         }
101
102         switch (getInputArgumentType(pvApiCtx, 1))
103         {
104             case sci_handles:      /* delete Entity given by a handle */
105
106                 // Retrieve a matrix of handle at position 1.
107                 sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1); /* Gets the Handle passed as argument */
108                 if (sciErr.iErr)
109                 {
110                     printError(&sciErr, 0);
111                     Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
112                     return 1;
113                 }
114
115                 nb_handles = m1 * n1;
116
117                 if (nbInputArgument(pvApiCtx) == 2)
118                 {
119                     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
120                     if (sciErr.iErr)
121                     {
122                         printError(&sciErr, 0);
123                         return 1;
124                     }
125
126                     // Retrieve a matrix of double at position 2.
127                     if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))   /* Gets the command name */
128                     {
129                         Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
130                         return 1;
131                     }
132                 }
133                 hdl = (unsigned long) * (l1); /* Puts the value of the Handle to hdl */
134                 break;
135             case sci_strings:      /* delete("all") */
136                 CheckInputArgument(pvApiCtx, 1, 1);
137                 sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl2);
138                 if (sciErr.iErr)
139                 {
140                     printError(&sciErr, 0);
141                     return 1;
142                 }
143
144                 // Retrieve a matrix of double at position 1.
145                 if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
146                 {
147                     Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
148                     return 1;
149                 }
150
151                 if (strcmp((l2), "all") == 0)
152                 {
153                     int i = 0;
154                     int iFigureNumber = sciGetNbFigure();
155
156                     if (iFigureNumber == 0)
157                     {
158                         //no graphic windows, we can leave
159                         AssignOutputVariable(pvApiCtx, 1) = 0;
160                         ReturnArguments(pvApiCtx);
161                         return 0;
162                     }
163
164                     pFigureUID = (char*)getCurrentFigure();
165
166                     getGraphicObjectProperty(pFigureUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&childrencount);
167
168                     getGraphicObjectProperty(pFigureUID, __GO_CHILDREN__, jni_string_vector, (void **)&childrenUID);
169
170                     for (i = 0; i < childrencount[0]; ++i)
171                     {
172                         getGraphicObjectProperty(childrenUID[i], __GO_HIDDEN__, jni_bool, (void **)&piHidden);
173                         if (iHidden == 0)
174                         {
175                             deleteGraphicObject(childrenUID[i]);
176                         }
177                     }
178                     /*
179                      * Clone a new Axes object using the Axes model which is then
180                      * attached to the 'cleaned' Figure.
181                      */
182                     cloneAxesModel(pFigureUID);
183
184                     AssignOutputVariable(pvApiCtx, 1) = 0;
185                     ReturnArguments(pvApiCtx);
186
187                     return 0;
188                 }
189                 else
190                 {
191                     Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 1, "all");
192                     return 0;
193                 }
194                 break;
195             default:
196                 // Overload
197                 OverLoad(1);
198                 return 0;
199         }
200     }
201
202     for (i = 0; i < nb_handles; i++)
203     {
204         char* pstTemp = NULL;
205         if (nbInputArgument(pvApiCtx) != 0)
206         {
207             hdl = (unsigned long) * (l1 + i); /* Puts the value of the Handle to hdl */
208         }
209
210         pobjUID = (char*)getObjectFromHandle(hdl);
211
212         if (pobjUID == NULL)
213         {
214             Scierror(999, _("%s: The handle is not valid.\n"), fname);
215             return 0;
216         }
217
218         if (isFigureModel(pobjUID) || isAxesModel(pobjUID))
219         {
220             Scierror(999, _("This object cannot be deleted.\n"));
221             return 0;
222         }
223
224         /* Object type */
225         getGraphicObjectProperty(pobjUID, __GO_TYPE__, jni_int, (void **)&piObjType);
226         if (iObjType == __GO_AXES__)
227         {
228             /* Parent object */
229             getGraphicObjectProperty(pobjUID, __GO_PARENT__, jni_string, (void **)&pstParentUID);
230             /* Parent type */
231             getGraphicObjectProperty(pstParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
232         }
233
234         if (iObjType == __GO_LABEL__)
235         {
236             Scierror(999, _("A Label object cannot be deleted.\n"));
237             return 0;
238         }
239
240         //bug #11485 : duplicate pobjUID before delete it.
241         pstTemp = os_strdup(pobjUID);
242         deleteGraphicObject(pobjUID);
243
244         /*
245          ** All figure must have at least one axe child.
246          ** If the last one is removed, add a new default one.
247          */
248         if (iObjType == __GO_AXES__ && iParentType == __GO_FIGURE__)
249         {
250             int iChild = 0;
251             int iChildCount = 0;
252             int *piChildCount = &iChildCount;
253             char **pstChildren = NULL;
254             int iChildType = -1;
255             int *piChildType = &iChildType;
256             int iAxesFound = 0;
257
258             getGraphicObjectProperty(pstParentUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&piChildCount);
259             getGraphicObjectProperty(pstParentUID, __GO_CHILDREN__, jni_string_vector, (void **)&pstChildren);
260             for (iChild = 0; iChild < iChildCount; iChild++)
261             {
262                 getGraphicObjectProperty(pstChildren[iChild], __GO_TYPE__, jni_int, (void **)&piChildType);
263                 if (iChildType == __GO_AXES__)
264                 {
265                     if (strcmp(getCurrentSubWin(), pstTemp) == 0) // Current axes has been deleted
266                     {
267                         setCurrentSubWin(pstChildren[iChild]);
268                     }
269                     iAxesFound = 1;
270                     break;
271                 }
272             }
273             if (!iAxesFound)
274             {
275                 /*
276                  * Clone a new Axes object using the Axes model which is then
277                  * attached to the newly created Figure.
278                  */
279                 cloneAxesModel(pstParentUID);
280             }
281         }
282
283         FREE(pstTemp);
284     }
285
286     if (!dont_overload)
287     {
288         // Overload
289         OverLoad(1);
290     }
291     else
292     {
293         AssignOutputVariable(pvApiCtx, 1) = 0;
294         ReturnArguments(pvApiCtx);
295     }
296
297     if (l2)
298     {
299         freeAllocatedSingleString(l2);
300     }
301
302     return 0;
303 }