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;