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                     AssignOutputVariable(pvApiCtx, 1) = 0;
180                     ReturnArguments(pvApiCtx);
181
182                     return 0;
183                 }
184                 else
185                 {
186                     Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 1, "all");
187                     return 0;
188                 }
189                 break;
190             default:
191                 // Overload
192                 OverLoad(1);
193                 return 0;
194         }
195     }
196
197     for (i = 0; i < nb_handles; i++)
198     {
199         char* pstTemp = NULL;
200         if (nbInputArgument(pvApiCtx) != 0)
201         {
202             hdl = (unsigned long) * (l1 + i); /* Puts the value of the Handle to hdl */
203         }
204
205         pobjUID = (char*)getObjectFromHandle(hdl);
206
207         if (pobjUID == NULL)
208         {
209             Scierror(999, _("%s: The handle is not valid.\n"), fname);
210             return 0;
211         }
212
213         if (isFigureModel(pobjUID) || isAxesModel(pobjUID))
214         {
215             Scierror(999, _("This object cannot be deleted.\n"));
216             return 0;
217         }
218
219         /* Object type */
220         getGraphicObjectProperty(pobjUID, __GO_TYPE__, jni_int, (void **)&piObjType);
221         if (iObjType == __GO_AXES__)
222         {
223             /* Parent object */
224             getGraphicObjectProperty(pobjUID, __GO_PARENT__, jni_string, (void **)&pstParentUID);
225             /* Parent type */
226             getGraphicObjectProperty(pstParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
227         }
228
229         if (iObjType == __GO_LABEL__)
230         {
231             Scierror(999, _("A Label object cannot be deleted.\n"));
232             return 0;
233         }
234
235         //bug #11485 : duplicate pobjUID before delete it.
236         pstTemp = os_strdup(pobjUID);
237         deleteGraphicObject(pobjUID);
238
239         /*
240          ** All figure must have at least one axe child.
241          ** If the last one is removed, add a new default one.
242          */
243         if (iObjType == __GO_AXES__ && iParentType == __GO_FIGURE__)
244         {
245             int iChild = 0;
246             int iChildCount = 0;
247             int *piChildCount = &iChildCount;
248             char **pstChildren = NULL;
249             int iChildType = -1;
250             int *piChildType = &iChildType;
251             int iAxesFound = 0;
252
253             getGraphicObjectProperty(pstParentUID, __GO_CHILDREN_COUNT__, jni_int, (void **)&piChildCount);
254             getGraphicObjectProperty(pstParentUID, __GO_CHILDREN__, jni_string_vector, (void **)&pstChildren);
255             for (iChild = 0; iChild < iChildCount; iChild++)
256             {
257                 getGraphicObjectProperty(pstChildren[iChild], __GO_TYPE__, jni_int, (void **)&piChildType);
258                 if (iChildType == __GO_AXES__)
259                 {
260                     if (strcmp(getCurrentSubWin(), pstTemp) == 0) // Current axes has been deleted
261                     {
262                         setCurrentSubWin(pstChildren[iChild]);
263                     }
264                     iAxesFound = 1;
265                     break;
266                 }
267             }
268             if (!iAxesFound)
269             {
270                 /*
271                  * Clone a new Axes object using the Axes model which is then
272                  * attached to the newly created Figure.
273                  */
274                 cloneAxesModel(pstParentUID);
275             }
276         }
277
278         FREE(pstTemp);
279     }
280
281     if (!dont_overload)
282     {
283         // Overload
284         OverLoad(1);
285     }
286     else
287     {
288         AssignOutputVariable(pvApiCtx, 1) = 0;
289         ReturnArguments(pvApiCtx);
290     }
291
292     if (l2)
293     {
294         freeAllocatedSingleString(l2);
295     }
296
297     return 0;
298 }