src/LightApp/LightApp_Study.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 // This library is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU Lesser General Public
   8 // License as published by the Free Software Foundation; either
   9 // version 2.1 of the License, or (at your option) any later version.
  10 //
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // Lesser General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU Lesser General Public
  17 // License along with this library; if not, write to the Free Software
  18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22
  23 #include "LightApp_Study.h"
  24
  25 #include "CAM_DataModel.h"
  26 #include "CAM_Module.h"
  27 #include "LightApp_Application.h"
  28 #include "LightApp_DataModel.h"
  29 #include "LightApp_DataObject.h"
  30 #include "LightApp_HDFDriver.h"
  31
  32 #include "SUIT_ResourceMgr.h"
  33 #include "SUIT_DataObjectIterator.h"
  34 #include "SUIT_DataBrowser.h"
  35 #include "SUIT_TreeModel.h"
  36
  37 #include <set>
  38
  39 /*!
  40   Constructor.
  41 */
  42 LightApp_Study::LightApp_Study( SUIT_Application* app )
  43 : CAM_Study( app )
  44 {
  45   // HDF persistence
  46   myDriver = new LightApp_HDFDriver();
  47   //myDriver = new LightApp_Driver();
  48 }
  49
  50 /*!
  51   Destructor.
  52 */
  53 LightApp_Study::~LightApp_Study()
  54 {
  55   delete myDriver; myDriver = 0;
  56 }
  57
  58 /*!
  59   Create document.
  60 */
  61 bool LightApp_Study::createDocument( const QString& theStr )
  62 {
  63   setStudyName( QString( "Study%1" ).arg( LightApp_Application::studyId() ) );
  64
  65   // create myRoot
  66   setRoot( new LightApp_RootObject( this ) );
  67
  68   bool aRet = CAM_Study::createDocument( theStr );
  69
  70   emit created( this );
  71
  72   return aRet;
  73 }
  74
  75 /*!
  76   Opens document
  77 */
  78 bool LightApp_Study::openDocument( const QString& theFileName )
  79 {
  80   myDriver->ClearDriverContents();
  81   // create files for models from theFileName
  82   if( !openStudyData(theFileName))
  83     return false;
  84
  85   setRoot( new LightApp_RootObject( this ) ); // create myRoot
  86
  87   // update loaded data models: call open() and update() on them.
  88   ModelList dm_s;
  89   dataModels( dm_s );
  90   QListIterator<CAM_DataModel*> it( dm_s );
  91   while ( it.hasNext() )
  92     openDataModel( studyName(), it.next() );
  93   // this will build a SUIT_DataObject-s tree under myRoot member field
  94   // passing "false" in order NOT to rebuild existing data models' trees - it was done in previous step
  95   // but tree that corresponds to not-loaded data models will be updated any way.
  96   ((LightApp_Application*)application())->updateObjectBrowser( false );
  97
  98   bool res = CAM_Study::openDocument( theFileName );
  99
 100   emit opened( this );
 101   return res;
 102 }
 103
 104 /*!
 105   Loads document
 106 */
 107 bool LightApp_Study::loadDocument( const QString& theStudyName )
 108 {
 109   myDriver->ClearDriverContents();
 110   if( !openStudyData(theStudyName))
 111     return false;
 112
 113   setRoot( new LightApp_RootObject( this ) ); // create myRoot
 114
 115   //SRN: BugID IPAL9021, put there the same code as in a method openDocument
 116
 117   // update loaded data models: call open() and update() on them.
 118   ModelList dm_s;
 119   dataModels( dm_s );
 120
 121   QListIterator<CAM_DataModel*> it( dm_s );
 122   while ( it.hasNext() )
 123     openDataModel( studyName(), it.next() );
 124
 125   // this will build a SUIT_DataObject-s tree under myRoot member field
 126   // passing "false" in order NOT to rebuild existing data models' trees - it was done in previous step
 127   // but tree that corresponds to not-loaded data models will be updated any way.
 128   ((LightApp_Application*)application())->updateObjectBrowser( false );
 129
 130   bool res = CAM_Study::openDocument( theStudyName );
 131   emit opened( this );
 132   //SRN: BugID IPAL9021: End
 133   return res;
 134 }
 135
 136 /*!
 137   Saves document
 138 */
 139 bool LightApp_Study::saveDocumentAs( const QString& theFileName )
 140 {
 141   SUIT_ResourceMgr* resMgr = application()->resourceMgr();
 142   if( !resMgr )
 143     return false;
 144
 145   ModelList list;
 146   dataModels( list );
 147
 148   QStringList listOfFiles;
 149   bool isMultiFile = resMgr->booleanValue( "Study", "multi_file", false );
 150   QListIterator<CAM_DataModel*> itList( list );
 151   while ( itList.hasNext() )
 152   {
 153     LightApp_DataModel* aModel = (LightApp_DataModel*)itList.next();
 154     if ( !aModel ) continue;
 155
 156     std::vector<std::string> anOldList = myDriver->GetListOfFiles( aModel->module()->name().toLatin1().constData() );
 157     listOfFiles.clear();
 158     aModel->saveAs( theFileName, this, listOfFiles );
 159     if ( !listOfFiles.isEmpty() )
 160       saveModuleData(aModel->module()->name(), listOfFiles);
 161
 162     // Remove files if necessary. File is removed if it was in the list of files before
 163     // saving and it is not contained in the list after saving. This provides correct
 164     // removing previous temporary files. These files are not removed before saving
 165     // because they may be required for it.
 166
 167     std::vector<std::string> aNewList = myDriver->GetListOfFiles( aModel->module()->name().toLatin1().constData() );
 168
 169     std::set<std::string> aNewNames;
 170     std::set<std::string> toRemove;
 171     int i, n;
 172     for( i = 0, n = aNewList.size(); i < n; i++ )
 173       aNewNames.insert( aNewList[ i ] );
 174     for( i = 0, n = anOldList.size(); i < n; i++ )
 175     {
 176       if ( i == 0 ) // directory is always inserted in list
 177         toRemove.insert( anOldList[ i ] );
 178       else if ( aNewNames.find( anOldList[ i ] ) == aNewNames.end() )
 179         toRemove.insert( anOldList[ i ] );
 180     }
 181
 182     std::vector<std::string> toRemoveList( toRemove.size() );
 183     std::set<std::string>::iterator anIter;
 184     for( anIter = toRemove.begin(), i = 0; anIter != toRemove.end(); ++anIter, ++i )
 185       toRemoveList[ i ] = *anIter;
 186
 187
 188     myDriver->RemoveFiles( toRemoveList, isMultiFile );
 189   }
 190
 191   bool res = saveStudyData(theFileName);
 192   res = res && CAM_Study::saveDocumentAs( theFileName );
 193   //SRN: BugID IPAL9377, removed usage of uninitialized variable <res>
 194   if ( res )
 195     emit saved( this );
 196
 197   return res;
 198 }
 199
 200 /*!
 201   Saves document
 202 */
 203 bool LightApp_Study::saveDocument()
 204 {
 205   ModelList list; dataModels( list );
 206
 207   myDriver->ClearDriverContents();
 208   QStringList listOfFiles;
 209   QListIterator<CAM_DataModel*> itList( list );
 210   while ( itList.hasNext() ) {
 211     LightApp_DataModel* aModel = (LightApp_DataModel*)itList.next();
 212     if ( !aModel ) continue;
 213
 214     listOfFiles.clear();
 215     aModel->save( listOfFiles );
 216     saveModuleData(aModel->module()->name(), listOfFiles);
 217   }
 218
 219   bool res = saveStudyData(studyName());
 220   res = res && CAM_Study::saveDocument();
 221   if (res)
 222     emit saved( this );
 223
 224   return res;
 225 }
 226
 227 /*!
 228   Closes document
 229 */
 230 void LightApp_Study::closeDocument(bool permanently)
 231 {
 232   // Inform everybody that this study is going to close when it's most safe to,
 233   // i.e. in the very beginning
 234   emit closed( this );
 235
 236   CAM_Study::closeDocument(permanently);
 237
 238   // Remove temporary files
 239   myDriver->ClearDriverContents();
 240 }
 241
 242 /*!
 243   \return real entry by entry of reference
 244   \param entry - entry of reference object
 245 */
 246 QString LightApp_Study::referencedToEntry( const QString& entry ) const
 247 {
 248   return entry;
 249 }
 250
 251 /*!
 252   \return entries of object children
 253 */
 254 void LightApp_Study::children( const QString&, QStringList& ) const
 255 {
 256 }
 257
 258 /*!
 259   \return true if entry corresponds to component
 260 */
 261 bool LightApp_Study::isComponent( const QString& entry ) const
 262 {
 263   if( !root() )
 264     return false;
 265
 266   DataObjectList ch;
 267   root()->children( ch );
 268   DataObjectList::const_iterator anIt = ch.begin(), aLast = ch.end();
 269   for( ; anIt!=aLast; anIt++ )
 270   {
 271     LightApp_DataObject* obj = dynamic_cast<LightApp_DataObject*>( *anIt );
 272     if( obj && obj->entry()==entry )
 273       return true;
 274   }
 275   return false;
 276 }
 277
 278 /*!
 279   \return component data type for entry
 280 */
 281 QString LightApp_Study::componentDataType( const QString& entry ) const
 282 {
 283   LightApp_DataObject* aCurObj;
 284   for ( SUIT_DataObjectIterator it( root(), SUIT_DataObjectIterator::DepthLeft ); it.current(); ++it ) {
 285     aCurObj = dynamic_cast<LightApp_DataObject*>( it.current() );
 286     if ( aCurObj && aCurObj->entry() == entry ) {
 287       return aCurObj->componentDataType();
 288     }
 289   }
 290   return "";
 291 }
 292
 293 /*!
 294   \return true if study is modified
 295 */
 296 bool LightApp_Study::isModified() const
 297 {
 298   bool isAnyChanged = CAM_Study::isModified();
 299   ModelList list; dataModels( list );
 300
 301   LightApp_DataModel* aModel = 0;
 302   QListIterator<CAM_DataModel*> it( list );
 303   while ( it.hasNext() && !isAnyChanged ) {
 304     aModel = dynamic_cast<LightApp_DataModel*>( it.next() );
 305     if ( aModel )
 306       isAnyChanged = aModel->isModified();
 307   }
 308   return isAnyChanged;
 309 }
 310
 311 /*!
 312   \return true if data model is saved
 313 */
 314 bool LightApp_Study::isSaved() const
 315 {
 316   return CAM_Study::isSaved();
 317 }
 318
 319 /*!
 320   Creates SComponent for module, necessary for SalomeApp study
 321 */
 322 void LightApp_Study::addComponent(const CAM_DataModel* dm)
 323 {
 324 }
 325
 326 /*!
 327   Saves list file for module 'theModuleName'
 328 */
 329 void LightApp_Study::saveModuleData(QString theModuleName, QStringList theListOfFiles)
 330 {
 331   int aNb = theListOfFiles.count();
 332   if ( aNb == 0 )
 333     return;
 334
 335   std::vector<std::string> aListOfFiles ( aNb );
 336   int anIndex = 0;
 337   for ( QStringList::Iterator it = theListOfFiles.begin(); it != theListOfFiles.end(); ++it ) {
 338     if ( (*it).isEmpty() )
 339       continue;
 340     aListOfFiles[anIndex] = (*it).toLatin1().constData();
 341     anIndex++;
 342   }
 343   myDriver->SetListOfFiles(theModuleName.toLatin1().constData(), aListOfFiles);
 344 }
 345
 346 /*!
 347   Gets list of file for module 'theModuleNam'
 348 */
 349 void LightApp_Study::openModuleData(QString theModuleName, QStringList& theListOfFiles)
 350 {
 351   std::vector<std::string> aListOfFiles =  myDriver->GetListOfFiles(theModuleName.toLatin1().constData());
 352   int i, aLength = aListOfFiles.size() - 1;
 353   if (aLength < 0)
 354     return;
 355
 356   //Get a temporary directory for saved a file
 357   theListOfFiles.append(aListOfFiles[0].c_str());
 358   for(i = 0; i < aLength; i++)
 359     theListOfFiles.append(aListOfFiles[i+1].c_str());
 360 }
 361
 362 /*!
 363   Saves data from study
 364 */
 365 bool LightApp_Study::saveStudyData( const QString& theFileName )
 366 {
 367   ModelList list; dataModels( list );
 368   SUIT_ResourceMgr* resMgr = application()->resourceMgr();
 369   if( !resMgr )
 370     return false;
 371   bool isMultiFile = resMgr->booleanValue( "Study", "multi_file", false );
 372
 373   bool aRes = myDriver->SaveDatasInFile(theFileName.toLatin1(), isMultiFile);
 374   return aRes;
 375 }
 376
 377 /*!
 378   Opens data for study
 379 */
 380 bool LightApp_Study::openStudyData( const QString& theFileName )
 381 {
 382   SUIT_ResourceMgr* resMgr = application()->resourceMgr();
 383   if( !resMgr )
 384     return false;
 385   bool isMultiFile = resMgr->booleanValue( "Study", "multi_file", false );
 386
 387   bool aRes = myDriver->ReadDatasFromFile(theFileName.toLatin1(), isMultiFile);
 388   return aRes;
 389 }
 390
 391 /*!
 392   Opens data model
 393 */
 394 bool LightApp_Study::openDataModel( const QString& studyName, CAM_DataModel* dm )
 395 {
 396   if (!dm)
 397     return false;
 398
 399   QStringList listOfFiles;
 400   openModuleData(dm->module()->name(), listOfFiles);
 401   if (dm && dm->open(studyName, this, listOfFiles)) {
 402     // Something has been read -> create data model tree
 403     LightApp_DataModel* aDM = dynamic_cast<LightApp_DataModel*>( dm );
 404     if ( aDM )
 405       aDM->update(NULL, this);
 406     return true;
 407   }
 408   return false;
 409 }
 410
 411 /*!
 412   \return temporary directory for saving files of modules
 413 */
 414 std::string LightApp_Study::GetTmpDir (const char* theURL,
 415                                        const bool  isMultiFile)
 416 {
 417   return myDriver->GetTmpDir(theURL, isMultiFile);
 418 }
 419
 420 /*!
 421   \return list of files necessary for module
 422   \param theModuleName - name of module
 423 */
 424 std::vector<std::string> LightApp_Study::GetListOfFiles(const char* theModuleName) const
 425 {
 426   std::vector<std::string> aListOfFiles;
 427   aListOfFiles = myDriver->GetListOfFiles(theModuleName);
 428   return aListOfFiles;
 429 }
 430
 431 /*!
 432   Sets list of files necessary for module
 433   \param theModuleName - name of module
 434   \param theListOfFiles - list of files
 435 */
 436 void LightApp_Study::SetListOfFiles (const char* theModuleName, const std::vector<std::string> theListOfFiles)
 437 {
 438   myDriver->SetListOfFiles(theModuleName, theListOfFiles);
 439 }
 440
 441 /*!
 442   Removes temporary files
 443 */
 444 void LightApp_Study::RemoveTemporaryFiles (const char* theModuleName, const bool isMultiFile) const
 445 {
 446   if (isMultiFile)
 447     return;
 448   bool isDirDeleted = true;
 449   myDriver->RemoveTemporaryFiles(theModuleName, isDirDeleted);
 450 }
 451
 452 /*!
 453   Virtual method that creates the root object (module object) for the given data model.
 454   The type of the created object depends on the study class, therefore data model classes
 455   should not create their module objects directly and should instead use
 456   LightApp_DataModel::createModuleObject() that in its turn relies on this method.
 457
 458   \param theDataModel - data model instance to create a module object for
 459   \param theParent - the module object's parent (normally it's the study root)
 460   \return the module object instance
 461   \sa LightApp_DataModel class, SalomeApp_Study class, LightApp_ModuleObject class
 462 */
 463 CAM_ModuleObject* LightApp_Study::createModuleObject( LightApp_DataModel* theDataModel,
 464                                                       SUIT_DataObject* theParent ) const
 465 {
 466   // Calling addComponent() for symmetry with SalomeApp_Study
 467   // Currently it has empty implementation, but maybe in the future things will change...
 468   LightApp_Study* that = const_cast<LightApp_Study*>( this );
 469   that->addComponent( theDataModel );
 470
 471   // Avoid creating multiple module objects for the same module
 472   CAM_ModuleObject* res = 0;
 473
 474   DataObjectList children = root()->children();
 475   DataObjectList::const_iterator anIt = children.begin(), aLast = children.end();
 476   for( ; !res && anIt!=aLast; anIt++ )
 477   {
 478     LightApp_ModuleObject* obj = dynamic_cast<LightApp_ModuleObject*>( *anIt );
 479     if ( obj && obj->name() == theDataModel->module()->moduleName() )
 480       res = obj;
 481   }
 482
 483   if ( !res ){
 484     res = new LightApp_ModuleObject( theDataModel, theParent );
 485   }
 486
 487   return res;
 488 }
 489
 490 /*!
 491   Fills list with components names
 492   \param comp - list to be filled
 493 */
 494 void LightApp_Study::components( QStringList& comp ) const
 495 {
 496   DataObjectList children = root()->children();
 497   DataObjectList::const_iterator anIt = children.begin(), aLast = children.end();
 498   for( ; anIt!=aLast; anIt++ )
 499   {
 500     LightApp_DataObject* obj = dynamic_cast<LightApp_DataObject*>( *anIt );
 501     if ( obj && obj->entry() != getVisualComponentName() )
 502       comp.append( obj->entry() );
 503   }
 504 }
 505
 506 /*!
 507   Get the entry for the given module
 508   \param comp - list to be filled
 509   \return module root's entry
 510 */
 511 QString LightApp_Study::centry( const QString& comp ) const
 512 {
 513   QString e;
 514   ModelList dmlist;
 515   dataModels( dmlist );
 516   QListIterator<CAM_DataModel*> it( dmlist );
 517   while ( it.hasNext() && e.isEmpty() ) {
 518     CAM_DataModel* dm = it.next();
 519     if ( dm->module() && dm->module()->name() == comp ) {
 520       LightApp_DataObject* r = dynamic_cast<LightApp_DataObject*>( dm->root() );
 521       if ( r ) e = r->entry();
 522     }
 523   }
 524   return e;
 525 }
 526
 527 /*!
 528   \return a name of the component where visual parameters are stored
 529 */
 530 QString LightApp_Study::getVisualComponentName() const
 531 {
 532   return "Interface Applicative";
 533 }
 534
 535
 536
 537
 538
 539 /*!
 540   Set a visual property of the object
 541   \param theViewId - Id of the viewer namager
 542   \param theEntry - Entry of the object
 543   \param thePropName - the name of the visual property
 544   \param theValue - the value of the visual property
 545 */
 546 void LightApp_Study::setObjectProperty(int theViewId, QString theEntry, QString thePropName, QVariant theValue) {
 547
 548   //Try to find viewer manager in the map
 549   ViewMgrMap::Iterator v_it = myViewMgrMap.find(theViewId);
 550   if(v_it == myViewMgrMap.end()) {
 551
 552     //1) Create property map
 553     PropMap aPropMap;
 554     aPropMap.insert(thePropName, theValue);
 555
 556     //2) Create object map
 557     ObjMap anObjMap;
 558     anObjMap.insert(theEntry,aPropMap);
 559
 560     //3) Insert in the view manager map
 561     myViewMgrMap.insert(theViewId, anObjMap);
 562
 563   } else {
 564     ObjMap& anObjMap = v_it.value();
 565     ObjMap::Iterator o_it = anObjMap.find(theEntry);
 566     if(o_it == anObjMap.end()) {
 567       //1) Create property map
 568       PropMap aPropMap;
 569       aPropMap.insert(thePropName, theValue);
 570
 571       //2) Insert in the object map
 572       anObjMap.insert(theEntry, aPropMap);
 573     } else {
 574       PropMap& aPropMap = o_it.value();
 575       aPropMap.insert(thePropName, theValue);
 576     }
 577   }
 578 }
 579
 580 /*!
 581   Get a visual property of the object identified by theViewMgrId, theEntry and thePropName.
 582   \param theViewMgrId - Id of the viewer manager.
 583   \param theEntry - Entry of the object.
 584   \param thePropName - the name of the visual property.
 585   \param theDefValue - the default value of the visual property.
 586   \return value of the visual propetry. If value is't found then return theDefValue.
 587 */
 588 QVariant LightApp_Study::getObjectProperty(int theViewMgrId, QString theEntry, QString thePropName, QVariant theDefValue) const {
 589   QVariant& aResult = theDefValue;
 590   ViewMgrMap::ConstIterator v_it = myViewMgrMap.find(theViewMgrId);
 591   if(v_it != myViewMgrMap.end()){
 592     const ObjMap& anObjectMap = v_it.value();
 593     ObjMap::ConstIterator o_it = anObjectMap.find(theEntry);
 594     if(o_it != anObjectMap.end()) {
 595       const PropMap& aPropMap = o_it.value();
 596       PropMap::ConstIterator p_it = aPropMap.find(thePropName);
 597       if(p_it != aPropMap.end()) {
 598         aResult = p_it.value();
 599       }
 600     }
 601   }
 602   return aResult;
 603 }
 604
 605 /*!
 606   Remove view manager with all objects.
 607   \param theViewMgrId - Id of the viewer manager.
 608 */
 609 void LightApp_Study::removeViewMgr( int theViewMgrId ) {
 610   myViewMgrMap.remove(theViewMgrId);
 611 }
 612
 613
 614 /*!
 615   Get a map of the properties of the object identified by theViewMgrId and theEntry.
 616   \param theViewMgrId - Id of the viewer manager.
 617   \param theEntry - Entry of the object.
 618   \return a map of the properties of the object.
 619 */
 620 const PropMap& LightApp_Study::getObjectPropMap(int theViewMgrId, QString theEntry) {
 621   ViewMgrMap::Iterator v_it = myViewMgrMap.find(theViewMgrId);
 622   if (v_it != myViewMgrMap.end()) {
 623     ObjMap& anObjectMap = v_it.value();
 624     ObjMap::Iterator o_it = anObjectMap.find(theEntry);
 625     if(o_it != anObjectMap.end()) {
 626       return o_it.value();
 627     } else {
 628       PropMap aPropMap;
 629       anObjectMap.insert(theEntry, aPropMap);
 630       return anObjectMap.find(theEntry).value();
 631     }
 632   } else {
 633     PropMap aPropMap;
 634     ObjMap anObjMap;
 635     anObjMap.insert(theEntry,aPropMap);
 636     myViewMgrMap.insert(theViewMgrId, anObjMap);
 637
 638     ObjMap& anObjectMap = myViewMgrMap.find(theViewMgrId).value();
 639     return anObjectMap.find(theEntry).value();
 640   }
 641 }
 642
 643 /*!
 644   Set a map of the properties of the object identified by theViewMgrId and theEntry.
 645   \param theViewMgrId - Id of the viewer manager.
 646   \param theEntry - Entry of the object.
 647 */
 648 void LightApp_Study::setObjectPropMap(int theViewMgrId, QString theEntry, PropMap thePropMap) {
 649   //Try to find viewer manager in the map
 650   ViewMgrMap::Iterator v_it = myViewMgrMap.find(theViewMgrId);
 651   if(v_it == myViewMgrMap.end()) {
 652
 653     //1) Create object map
 654     ObjMap anObjMap;
 655     anObjMap.insert(theEntry,thePropMap);
 656
 657     //3) Insert in the view manager map
 658     myViewMgrMap.insert(theViewMgrId, anObjMap);
 659   } else {
 660     ObjMap& anObjMap = v_it.value();
 661     anObjMap.insert(theEntry,thePropMap);
 662   }
 663 }
 664
 665 /*!
 666    Remove object's properties from all view managers.
 667   \param theEntry - Entry of the object.
 668 */
 669 void LightApp_Study::removeObjectFromAll( QString theEntry ) {
 670   ViewMgrMap::Iterator v_it = myViewMgrMap.begin();
 671   for( ;v_it != myViewMgrMap.end(); v_it++ ) {
 672     v_it.value().remove(theEntry);
 673   }
 674 }
 675
 676 /*!
 677   Get all objects and it's properties from view manager identified by theViewMgrId.
 678   \param theEntry - Entry of the object.
 679 */
 680 const ObjMap& LightApp_Study::getObjectMap ( int theViewMgrId ) {
 681   ViewMgrMap::Iterator v_it = myViewMgrMap.find(theViewMgrId);
 682   if( v_it == myViewMgrMap.end() ) {
 683     ObjMap anObjMap;
 684     myViewMgrMap.insert(theViewMgrId , anObjMap);
 685     return myViewMgrMap.find(theViewMgrId).value();
 686   }
 687   return v_it.value();
 688 }
 689
 690 /*!
 691   Set 'visibility state' property of the object.
 692   \param theEntry - Entry of the object.
 693   \param theState - visibility status
 694 */
 695 void LightApp_Study::setVisibilityState(const QString& theEntry, Qtx::VisibilityState theState) {
 696   LightApp_Application* app = (LightApp_Application*)application();
 697   if(!app)
 698     return;
 699   SUIT_DataBrowser* db = app->objectBrowser();
 700   if(!db)
 701     return;
 702
 703   SUIT_AbstractModel* treeModel = dynamic_cast<SUIT_AbstractModel*>(db->model());
 704
 705   if(treeModel)
 706     treeModel->setVisibilityState(theEntry,theState);
 707 }
 708
 709 /*!
 710   Set 'visibility state' property for all object.
 711   \param theEntry - Entry of the object.
 712 */
 713 void LightApp_Study::setVisibilityStateForAll(Qtx::VisibilityState theState) {
 714
 715   LightApp_Application* app = (LightApp_Application*)application();
 716   if(!app)
 717     return;
 718   SUIT_DataBrowser* db = app->objectBrowser();
 719   if(!db)
 720     return;
 721
 722   SUIT_AbstractModel* treeModel = dynamic_cast<SUIT_AbstractModel*>(db->model());
 723
 724   if(treeModel)
 725     treeModel->setVisibilityStateForAll(theState);
 726 }
 727
 728 /*!
 729   Get 'visibility state' property of the object.
 730   \param theEntry - Entry of the object.
 731   \return 'visibility state' property of the object.
 732 */
 733 Qtx::VisibilityState LightApp_Study::visibilityState(const QString& theEntry) const {
 734   LightApp_Application* app = (LightApp_Application*)application();
 735   if(app) {
 736
 737     SUIT_DataBrowser* db = app->objectBrowser();
 738     if(db) {
 739       SUIT_AbstractModel* treeModel = dynamic_cast<SUIT_AbstractModel*>(db->model());
 740       if(treeModel)
 741         return treeModel->visibilityState(theEntry);
 742     }
 743   }
 744   return Qtx::UnpresentableState;
 745 }
 746
 747 /*!
 748   Find a data object by the specified entry.
 749   \param theEntry - Entry of the object.
 750   \return data object.
 751 */
 752 LightApp_DataObject* LightApp_Study::findObjectByEntry( const QString& theEntry )
 753 {
 754   LightApp_DataObject* aCurObj;
 755   for ( SUIT_DataObjectIterator it( root(), SUIT_DataObjectIterator::DepthLeft ); it.current(); ++it ) {
 756     aCurObj = dynamic_cast<LightApp_DataObject*>( it.current() );
 757     if ( aCurObj && aCurObj->entry() == theEntry )
 758       return aCurObj;
 759   }
 760   return NULL;
 761 }