af96aeb594c84758b71ab17715b24d1d7f3a3ba5
[scilab.git] / scilab / modules / graphic_objects / src / cpp / ScilabView.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2011-2011 - DIGITEO - Bruno JOFRET
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-en.txt
10  *
11  */
12
13 #include <iostream>
14 #include <map>
15 #include <cstring>
16 #include <limits.h>
17
18 #include "ScilabView.hxx"
19 #include "CallGraphicController.hxx"
20
21 extern "C"
22 {
23 #include "createGraphicObject.h"
24 #include "setGraphicObjectProperty.h"
25 #include "getGraphicObjectProperty.h"
26 #include "graphicObjectProperties.h"
27 #include "getScilabJavaVM.h"
28 #include "deleteGraphicObject.h"
29 }
30
31 /**
32  * C Wrapping functions
33  * \{
34  */
35 void ScilabNativeView__createObject(char const* pstId)
36 {
37     ScilabView::createObject(pstId);
38 }
39
40 void ScilabNativeView__deleteObject(char const*pstId)
41 {
42     ScilabView::deleteObject(pstId);
43 }
44
45 void ScilabNativeView__updateObject(char const* pstId, int iProperty)
46 {
47     ScilabView::updateObject(pstId, iProperty);
48 }
49
50 void ScilabNativeView__setCurrentFigure(char const* pstId)
51 {
52     ScilabView::setCurrentFigure(pstId);
53 }
54
55 void ScilabNativeView__setCurrentSubWin(char const* pstId)
56 {
57     ScilabView::setCurrentSubWin(pstId);
58 }
59
60 void ScilabNativeView__setCurrentObject(char const* pstId)
61 {
62     ScilabView::setCurrentObject(pstId);
63 }
64
65 int ScilabNativeView__getValidDefaultFigureId()
66 {
67     return ScilabView::getValidDefaultFigureId();
68 }
69
70 /**
71  * \}
72  */
73
74 int ScilabView::getValidDefaultFigureId()
75 {
76     if (m_figureList.empty())
77     {
78         return 0;
79     }
80     else
81     {
82         int max = INT_MIN;
83         for (__figureList_iterator it = m_figureList.begin(); it != m_figureList.end(); ++it)
84         {
85             if (it->second > max)
86             {
87                 max = it->second;
88             }
89         }
90
91         return max + 1;
92     }
93 }
94
95 bool ScilabView::isEmptyFigureList()
96 {
97     return m_figureList.empty();
98 }
99
100 char const* ScilabView::getFigureFromIndex(int figNum)
101 {
102     __figureList_iterator it;
103
104     for (it = m_figureList.begin(); it != m_figureList.end(); ++it)
105     {
106         if (it->second == figNum)
107         {
108             return it->first.c_str();
109         }
110     }
111     return NULL;
112 }
113
114 bool ScilabView::existsFigureId(int id)
115 {
116     __figureList_iterator it;
117
118     for (it = m_figureList.begin(); it != m_figureList.end(); ++it)
119     {
120         if (it->second == id)
121         {
122             return true;
123         }
124     }
125     return false;
126 }
127
128 void ScilabView::getFiguresId(int ids[])
129 {
130     __figureList_iterator it;
131     int i = (int)(m_figureList.size() - 1);
132
133     for (it = m_figureList.begin(); it != m_figureList.end(); ++it, --i)
134     {
135         //std::cerr << "[ScilabView] DEBUG " << it->first << " <-> " << it->second << std::endl;
136         ids[i] = it->second;
137     }
138 }
139
140 int ScilabView::getNbFigure(void)
141 {
142     return (int)m_figureList.size();
143
144 }
145
146 void ScilabView::createObject(char const* pstId)
147 {
148     //std::cerr << "[ScilabView] ++ createObject UID=" << pstId << std::endl;
149     int iType = -1;
150     int *piType = &iType;
151
152     getGraphicObjectProperty(pstId, __GO_TYPE__, jni_int, (void **)&piType);
153     if (iType != -1 && iType == __GO_FIGURE__)
154     {
155         m_figureList[pstId] = -1;
156         setCurrentFigure(pstId);
157     }
158
159     // Register object handle.
160     getObjectHandle(pstId);
161 }
162
163 void ScilabView::deleteObject(char const* pstId)
164 {
165     //std::cerr << "[ScilabView] -- deleteObject UID=" << pstId << std::endl;
166     int iType = -1;
167     int *piType = &iType;
168     char *pstParentUID = NULL;
169
170     getGraphicObjectProperty(pstId, __GO_TYPE__, jni_int, (void **)&piType);
171
172     /*
173     ** If deleting a figure, remove from figure list.
174     */
175     if (iType != -1 && iType == __GO_FIGURE__)
176     {
177         m_figureList.erase(pstId);
178     }
179
180     /*
181     ** If deleting current figure find another current one,
182     ** if there is no more figure : NULL
183     */
184     if (m_currentFigure == pstId) // Deleting current figure
185     {
186         char* pstrAxesUID = NULL;
187
188         if (getNbFigure() != 0)
189         {
190             m_currentFigure = m_figureList.rbegin()->first;
191             getGraphicObjectProperty(m_currentFigure.c_str(), __GO_SELECTED_CHILD__, jni_string,  (void**)&pstrAxesUID);
192             setCurrentSubWin(pstrAxesUID);
193         }
194         else
195         {
196             setCurrentFigure(NULL);
197             setCurrentSubWin(NULL);
198         }
199     }
200
201     /*
202     ** If deleting current entity, set parent as new current.
203     */
204     if (m_currentObject == pstId) // Deleting current object
205     {
206         getGraphicObjectProperty(pstId, __GO_PARENT__, jni_string, (void **)&pstParentUID);
207         setCurrentObject(pstParentUID);
208     }
209
210     // Remove the corresponding handle.
211     m_uidList.erase(m_handleList.find(pstId)->second);
212     m_handleList.erase(pstId);
213
214     deleteDataObject(pstId);
215 }
216
217 void ScilabView::updateObject(char const* pstId, int iProperty)
218 {
219     //std::cerr << "[ScilabView] == updateObject UID=" << pstId << " PROPERTY=" << pstProperty << std::endl;
220
221     /*
222      ** Take care of update if the value update is ID and object type is a Figure I manage.
223      */
224     if (iProperty == __GO_ID__ && m_figureList.find(pstId) != m_figureList.end())
225     {
226         int iNewId = 0;
227         int *piNewId = &iNewId;
228
229         getGraphicObjectProperty(pstId, __GO_ID__, jni_int, (void **)&piNewId);
230
231         m_figureList[pstId] = iNewId;
232         //std::cerr << "### [ScilabView] updateMap UID=" << pstId << " id=" << iNewId << std::endl;
233     }
234 }
235
236 /*
237 ** Register ScilabView to Controller.
238 ** Must be done after Graphics models are created.
239 */
240 void ScilabView::registerToController(void)
241 {
242     org_scilab_modules_graphic_objects::CallGraphicController::registerScilabView(getScilabJavaVM());
243     m_figureList.get_allocator().allocate(4096);
244     m_handleList.get_allocator().allocate(4096);
245     m_uidList.get_allocator().allocate(4096);
246 }
247
248 /*
249 ** Reove ScilabView from Controller.
250 */
251 void ScilabView::unregisterToController(void)
252 {
253     org_scilab_modules_graphic_objects::CallGraphicController::unregisterScilabView(getScilabJavaVM());
254 }
255
256 /*
257 ** Set Current Figure UID
258 */
259 void ScilabView::setCurrentFigure(char const* UID)
260 {
261     if (UID == NULL)
262     {
263         m_currentFigure = std::string();
264     }
265     else
266     {
267         m_currentFigure = UID;
268     }
269 }
270
271 /*
272 ** Get Current Figure UID
273 */
274 char const* ScilabView::getCurrentFigure()
275 {
276     //std::cerr << "[ScilaView] currentFigure = " << (m_currentFigure == NULL ? "NULL !!" : m_currentFigure) << std::endl;
277     if (m_currentFigure.length() == 0)
278     {
279         return NULL;
280     }
281     return m_currentFigure.c_str();
282 }
283
284 /*
285 ** Set Current Object UID
286 */
287 void ScilabView::setCurrentObject(char const* UID)
288 {
289     if (UID == NULL)
290     {
291         m_currentObject = std::string();
292     }
293     else
294     {
295         m_currentObject = UID;
296     }
297 }
298
299 /*
300 ** Get Current Figure UID
301 */
302 char const* ScilabView::getCurrentObject()
303 {
304     //std::cerr << "[ScilaView] currentObject = " << m_currentObject << std::endl;
305     if (m_currentFigure.length() == 0)
306     {
307         return NULL;
308     }
309     return m_currentObject.c_str();
310 }
311
312 /*
313 ** Set Current SubWin UID
314 */
315 void ScilabView::setCurrentSubWin(char const* UID)
316 {
317     if (UID == NULL)
318     {
319         m_currentSubWin = std::string();
320     }
321     else
322     {
323         m_currentSubWin = UID;
324     }
325 }
326
327 /*
328 ** Get Current Figure UID
329 */
330 char const* ScilabView::getCurrentSubWin()
331 {
332     //std::cerr << "[ScilaView] currentSubWin = " << m_currentSubWin << std::endl;
333     if (m_currentSubWin.length() == 0)
334     {
335         return NULL;
336     }
337     return m_currentSubWin.c_str();
338 }
339
340 /*
341 ** Scilab only can store long as handle
342 */
343 long ScilabView::getObjectHandle(char const* UID)
344 {
345     /*
346      * if (UID != NULL)
347      * {
348      * std::cerr << "UID = " << UID << std::endl;
349      * }
350      * else
351      * {
352      * std::cerr << "UID is null :-S" << std::endl;
353      * }
354      * __handleList_iterator it2;
355      * std::cerr << "[DEBUG] +++ handleMap +++" << std::endl;
356      * for (it2 = m_handleList.begin() ; it2 != m_handleList.end() ; ++it2)
357      * {
358      * std::cerr << "UID " << it2->first << " <-> handle " << it2->second << std::endl;
359      * }
360      * std::cerr << "[DEBUG] +++ handleMap +++" << std::endl;
361      */
362     __handleList_iterator it = m_handleList.find(UID);
363
364     if (it != m_handleList.end())
365     {
366         return it->second;
367     }
368
369     // increase maximum value
370     // register new handle and return it.
371     m_topHandleValue++;
372     m_handleList[UID] = m_topHandleValue;
373     m_uidList[m_topHandleValue] = UID;
374
375     return m_topHandleValue;
376 }
377
378 char const* ScilabView::getObjectFromHandle(long handle)
379 {
380     __uidList_iterator it = m_uidList.find(handle);
381     if (it == m_uidList.end())
382     {
383         return NULL;
384     }
385
386     return it->second.c_str();
387 }
388
389 char const* ScilabView::getFigureModel(void)
390 {
391     //std::cerr << "[ScilabView] getFigureModel = " << (m_figureModel == NULL ? "!! NULL !!" : m_figureModel) << std::endl;
392     if (m_figureModel.length() == 0)
393     {
394         return NULL;
395     }
396     return m_figureModel.c_str();
397 }
398
399 void ScilabView::setFigureModel(char const* UID)
400 {
401     m_figureModel = UID;
402 }
403
404 char const* ScilabView::getAxesModel(void)
405 {
406     //std::cerr << "[ScilabView] getAxesModel = " << (m_axesModel == NULL ? "!! NULL !!" : m_axesModel) << std::endl;
407     if (m_axesModel.length() == 0)
408     {
409         return NULL;
410     }
411     return m_axesModel.c_str();
412 }
413
414 void ScilabView::setAxesModel(char const* UID)
415 {
416     m_axesModel = UID;
417 }
418
419 /*
420 ** Allocate static class variable.
421 */
422 ScilabView::__figureList ScilabView::m_figureList = *new __figureList();
423 ScilabView::__handleList ScilabView::m_handleList = *new __handleList();
424 ScilabView::__uidList ScilabView::m_uidList = *new __uidList();
425 long ScilabView::m_topHandleValue = 0;
426 std::string ScilabView::m_currentFigure;
427 std::string ScilabView::m_currentObject;
428 std::string ScilabView::m_currentSubWin;
429 std::string ScilabView::m_figureModel;
430 std::string ScilabView::m_axesModel;