]> SALOME platform Git repositories - modules/gui.git/blob - src/SalomeApp/SalomeApp_Study.cxx
Salome HOME
Fix for the "22595: [CEA 1177] Misleading error message" issue.
[modules/gui.git] / src / SalomeApp / SalomeApp_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 "SalomeApp_Study.h"
24
25 #include "SalomeApp_Module.h"
26 #include "SalomeApp_DataObject.h"
27 #include "SalomeApp_DataModel.h"
28 #include "SalomeApp_Application.h"
29 #include "SalomeApp_Engine_i.h"
30 #include "SalomeApp_VisualState.h"
31
32 // temporary commented
33 //#include <OB_Browser.h>
34
35 #include <QCoreApplication>
36 #include <QEvent>
37 #include <QFileInfo>
38 #include "SALOME_Event.h"
39 #include "Basics_Utils.hxx"
40
41 #include <SUIT_ResourceMgr.h>
42 #include <SUIT_TreeModel.h>
43 #include <SUIT_DataBrowser.h>
44 #include <SUIT_MessageBox.h>
45 #include <SUIT_Session.h>
46 #include <SUIT_Desktop.h>
47
48 #include <LightApp_Displayer.h>
49
50 #include "utilities.h"
51
52 #include "SALOMEDS_Tool.hxx"
53
54 #include "SALOMEDSClient_ClientFactory.hxx"
55
56 #include <SALOMEconfig.h>
57 #include CORBA_SERVER_HEADER(SALOME_Exception)
58
59 //#define NOTIFY_BY_EVENT
60
61 class ObserverEvent : public QEvent
62 {
63 public:
64   ObserverEvent(const char* theID, CORBA::Long event):QEvent(QEvent::User)
65   {
66     _anID=theID;
67     _event=event;
68   }
69
70   std::string _anID;
71   CORBA::Long _event;
72 };
73
74 class SalomeApp_Study::Observer_i : public virtual POA_SALOMEDS::Observer, QObject
75 {
76   typedef std::map<std::string, SalomeApp_DataObject*>           EntryMap;
77   typedef std::map<std::string, SalomeApp_DataObject*>::iterator EntryMapIter;
78
79 public:
80
81   Observer_i(_PTR(Study) aStudyDS, SalomeApp_Study* aStudy):QObject(aStudy)
82   {
83     myStudyDS=aStudyDS;
84     myStudy=aStudy;
85     fillEntryMap();
86   }
87
88   SUIT_DataObject* findObject( const char* theID ) const
89   {
90     EntryMap::const_iterator it = entry2SuitObject.find( theID );
91     return it != entry2SuitObject.end() ? it->second : 0;
92   }
93
94   virtual void notifyObserverID(const char* theID, CORBA::Long event)
95   {
96 #ifdef NOTIFY_BY_EVENT
97     QCoreApplication::postEvent(this,new ObserverEvent(theID,event));
98 #else
99     notifyObserverID_real(theID,event);
100 #endif
101   }
102
103   virtual bool event(QEvent *event)
104   {
105     if (event->type() == QEvent::User )
106     {
107       //START_TIMING(notify);
108       notifyObserverID_real(static_cast<ObserverEvent *>(event)->_anID.c_str(),static_cast<ObserverEvent *>(event)->_event);
109       //END_TIMING(notify,100);
110     }
111     return true;
112   }
113
114   void notifyObserverID_real(const std::string& theID, long event)
115   {
116     SalomeApp_DataObject* suit_obj = 0;
117
118     switch(event) {
119     case 1:
120       { //Add sobject
121         _PTR(SObject) aSObj = myStudyDS->FindObjectID(theID);
122         _PTR(SComponent) aSComp = aSObj->GetFatherComponent();
123
124         if (!aSComp || aSComp->IsNull()) {
125           MESSAGE("Entry " << theID << " has not father component. Problem ??");
126           return;
127         }
128
129         // Mantis issue 0020136: Drag&Drop in OB
130         _PTR(UseCaseBuilder) aUseCaseBuilder = myStudyDS->GetUseCaseBuilder();
131         if (aUseCaseBuilder->IsUseCaseNode(aSComp)) { // BEGIN: work with tree nodes structure
132           if (!aUseCaseBuilder->IsUseCaseNode(aSObj)) {
133             // tree node is not yet set, it is a normal situation
134             return;
135           }
136
137           _PTR(SObject) aFatherSO = aUseCaseBuilder->GetFather(aSObj);
138           if (!aFatherSO || aFatherSO->IsNull()) {
139             MESSAGE("Father SObject is not found. Problem ??");
140             return;
141           }
142
143           std::string parent_id = aFatherSO->GetID();
144           EntryMapIter it = entry2SuitObject.find(parent_id.c_str());
145
146           if (it == entry2SuitObject.end()) {
147             MESSAGE("Father data object is not found. Problem ??");
148             return;
149           }
150
151           SalomeApp_DataObject* aFatherDO = it->second;
152
153           it = entry2SuitObject.find(theID);
154           if (it != entry2SuitObject.end()) { // this SOobject is already added somethere
155             suit_obj = it->second;
156             SUIT_DataObject* oldFather = suit_obj->parent();
157             if (oldFather) {
158               oldFather->removeChild(suit_obj, false);
159               SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( myStudy->application() );
160               SUIT_AbstractModel* model = dynamic_cast<SUIT_AbstractModel*>(app->objectBrowser()->model());
161               model->forgetObject( suit_obj );
162                 
163               if (SalomeApp_DataObject* oldFatherSA = dynamic_cast<SalomeApp_DataObject*>(oldFather)) {
164                 oldFatherSA->updateItem();
165               }
166             }
167           }
168           else {
169             suit_obj = new SalomeApp_DataObject(aSObj);
170             entry2SuitObject[theID] = suit_obj;
171           }
172
173           suit_obj->updateItem();
174           // define position in the data tree (in aFatherDO) to insert the aSObj
175           int pos = -1;
176           //int childDataObjCount = aFatherDO->childCount();
177           _PTR(UseCaseIterator) aUseCaseIter = aUseCaseBuilder->GetUseCaseIterator(aFatherSO);
178           for (int cur = 0; aUseCaseIter->More() && pos < 0; cur++, aUseCaseIter->Next()) {
179             if (aUseCaseIter->Value()->GetID() == theID) {
180               pos = cur;
181               break;
182             }
183           }
184
185           aFatherDO->insertChildAtPos(suit_obj, pos);
186           //aFatherDO->insertChild(suit_obj, pos);
187           aFatherDO->updateItem();
188
189           /* Define visibility state */
190           bool isComponent = dynamic_cast<SalomeApp_ModuleObject*>( suit_obj ) != 0;
191           if ( suit_obj && !isComponent && myStudy->visibilityState( theID.c_str() ) == Qtx::UnpresentableState ) {
192             QString moduleTitle = ((CAM_Application*)myStudy->application())->moduleTitle(suit_obj->componentDataType());
193             if (!moduleTitle.isEmpty()) {
194               LightApp_Displayer* aDisplayer = LightApp_Displayer::FindDisplayer(moduleTitle,false);
195               if (aDisplayer) {
196                 if(aDisplayer->canBeDisplayed(theID.c_str())) {
197                   myStudy->setVisibilityState( theID.c_str(), Qtx::HiddenState ); //hide the just added object
198                   //MESSAGE("Object with entry : "<< theID <<" CAN be displayed !!!");
199                 }
200                 else
201                   MESSAGE("Object with entry : "<< theID <<" CAN'T be displayed !!!");
202               }
203             }
204           }
205         } // END: work with tree nodes structure
206         else { // BEGIN: work with study structure
207           EntryMapIter it = entry2SuitObject.find( theID );
208           if ( it != entry2SuitObject.end() ) {
209             MESSAGE("Entry " << theID << " is already added. Problem ??");
210             return;
211           }
212
213           int last2Pnt_pos = theID.rfind( ":" );
214           std::string parent_id = theID.substr( 0, last2Pnt_pos );
215           int tag = atoi( theID.substr( last2Pnt_pos+1 ).c_str() );
216
217           if ( parent_id.length() == 3 ) // "0:1" - root item?
218           {
219             // It's probably a SComponent
220             if ( theID == aSComp->GetID() )
221               suit_obj = new SalomeApp_ModuleObject( aSComp );
222             else
223               suit_obj = new SalomeApp_DataObject( aSObj );
224           }
225           else
226           {
227             suit_obj = new SalomeApp_DataObject( aSObj );
228           }
229
230           it = entry2SuitObject.find( parent_id );
231           if ( it != entry2SuitObject.end() ) {
232             SalomeApp_DataObject* father = it->second;
233             father->insertChildAtTag( suit_obj, tag );
234           }
235           else {
236             if ( parent_id.length() == 3 ) // "0:1" - root item?
237             {
238               // This should be for a module
239               SUIT_DataObject* father=myStudy->root();
240               father->appendChild(suit_obj);
241             }
242             else
243             {
244               MESSAGE("SHOULD NEVER GET HERE!!!");
245
246               //Try to find the SalomeApp_DataObject object parent
247               std::string root_id = parent_id.substr( 0, 4 );
248               std::string obj_id = parent_id.substr( 4 );
249
250               std::string anID;
251               std::string::size_type debut = 0;
252               std::string::size_type fin;
253               SalomeApp_DataObject* anObj = dynamic_cast<SalomeApp_DataObject*>( myStudy->root() );
254               while ( 1 ) {
255                 fin = obj_id.find_first_of( ':', debut );
256                 if ( fin == std::string::npos ) {
257                   //last id
258                   anObj = dynamic_cast<SalomeApp_DataObject*>(anObj->childObject(atoi(obj_id.substr(debut).c_str())-1));
259                   entry2SuitObject[parent_id] = anObj;
260                   break;
261                 }
262                 anID = root_id + obj_id.substr( 0, fin );
263                 EntryMapIter it2 = entry2SuitObject.find( anID );
264                 if ( it2 == entry2SuitObject.end() ) {
265                   //the ID is not known in entry2SuitObject
266                   anObj = dynamic_cast<SalomeApp_DataObject*>(anObj->childObject(atoi(obj_id.substr(debut, fin-debut).c_str())-1));
267                   entry2SuitObject[anID] = anObj;
268                 }
269                 else
270                   anObj = it2->second;
271                 debut = fin+1;
272               }
273               anObj->insertChildAtTag( suit_obj, tag );
274             }
275           }
276           entry2SuitObject[theID] = suit_obj;
277         } // END: work with study structure
278         break;
279       }
280     case 2:
281       { // Remove sobject
282         EntryMapIter it = entry2SuitObject.find( theID );
283         if ( it != entry2SuitObject.end() )
284         {
285           suit_obj = it->second;
286           // VSR: object is not removed, since SALOMEDS::SObject is not actually removed,
287           //      only its attributes are cleared;
288           //      thus, the object can be later reused
289           suit_obj->updateItem();
290           //SUIT_DataObject* father=suit_obj->parent();
291           //if(father)
292           //  father->removeChild(suit_obj);
293           //entry2SuitObject.erase(it);
294         }
295         else
296         {
297           MESSAGE("Want to remove an unknown object" << theID);
298         }
299         break;
300       }
301     case 0:
302       { //modify sobject
303         //MESSAGE("Want to modify an object "  << theID);
304         EntryMapIter it = entry2SuitObject.find( theID );
305         if ( it != entry2SuitObject.end() )
306         {
307           suit_obj = it->second;
308           suit_obj->updateItem();
309         }
310         else
311         {
312           MESSAGE("Want to modify an unknown object"  << theID);
313         }
314         break;
315       }
316     case 5: //IOR of the object modified
317       {
318         EntryMapIter it = entry2SuitObject.find( theID );
319         if ( it != entry2SuitObject.end() )
320           suit_obj = it->second;
321
322         /* Define visibility state */
323         bool isComponent = dynamic_cast<SalomeApp_ModuleObject*>( suit_obj ) != 0;
324         if ( suit_obj && !isComponent ) {
325           QString moduleTitle = ((CAM_Application*)myStudy->application())->moduleTitle(suit_obj->componentDataType());
326           if (!moduleTitle.isEmpty()) {
327             LightApp_Displayer* aDisplayer = LightApp_Displayer::FindDisplayer(moduleTitle,false);
328             if (aDisplayer) {
329               if(aDisplayer->canBeDisplayed(theID.c_str())) {
330                 myStudy->setVisibilityState( theID.c_str(), Qtx::HiddenState );
331                 //MESSAGE("Object with entry : "<< theID <<" CAN be displayed !!!");
332               }
333               else
334                 MESSAGE("Object with entry : "<< theID <<" CAN'T be displayed !!!");
335             }
336           }
337         }
338         break;
339       }
340 #ifndef DISABLE_PYCONSOLE
341     case 6: //NoteBook variables were modified
342       {
343         myStudy->onNoteBookVarUpdate( QString( theID.c_str() ) );
344         break;
345       }
346 #endif
347     default:MESSAGE("Unknown event: "  << event);break;
348     } //switch
349   } //notifyObserverID_real
350
351 private:
352   void fillEntryMap()
353   {
354     entry2SuitObject.clear();
355     SUIT_DataObject* o = myStudy->root();
356     while (o) {
357       SalomeApp_DataObject* so = dynamic_cast<SalomeApp_DataObject*>( o );
358       if ( so ) {
359         std::string entry = so->entry().toLatin1().constData();
360         if ( entry.size() )
361           entry2SuitObject[entry] = so;
362       }
363       if ( o->childCount() > 0 ) {
364         // parse the children
365         o = o->firstChild();
366       }
367       else if ( o->nextBrother() > 0 ) {
368         o = o->nextBrother();
369       }
370       else {
371         // step to the next appropriate parent
372         o = o->parent();
373         while ( o ) {
374           if ( o->nextBrother() ) {
375             o = o->nextBrother();
376             break;
377           }
378           o = o->parent();
379         }
380       }
381     }
382   }
383
384 private:
385   _PTR(Study)      myStudyDS;
386   SalomeApp_Study* myStudy;
387   EntryMap         entry2SuitObject;
388 };
389
390
391 /*!
392   Constructor.
393 */
394 SalomeApp_Study::SalomeApp_Study( SUIT_Application* app )
395 : LightApp_Study( app ), myObserver( 0 )
396 {
397 }
398
399 /*!
400   Destructor.
401 */
402 SalomeApp_Study::~SalomeApp_Study()
403 {
404   if ( myObserver ) {
405     PortableServer::ObjectId_var oid = myObserver->_default_POA()->servant_to_id( myObserver );
406     myObserver->_default_POA()->deactivate_object( oid.in() );
407   }
408 }
409
410 #ifndef DISABLE_PYCONSOLE
411 void SalomeApp_Study::onNoteBookVarUpdate( QString theVarName)
412 {
413   emit notebookVarUpdated( theVarName );
414 }
415 #endif
416
417 /*!
418   Gets study id.
419 */
420 int SalomeApp_Study::id() const
421 {
422   int id = -1;
423   if ( studyDS() )
424     id = studyDS()->StudyId();
425   return id;
426 }
427
428 /*!
429   Get study name.
430 */
431 QString SalomeApp_Study::studyName() const
432 {
433   // redefined from SUIT_Study to update study name properly since
434   // it can be changed outside of GUI
435   // TEMPORARILY SOLUTION: better to be implemented with help of SALOMEDS observers
436   if ( studyDS() ) {
437     QString newName = QString::fromUtf8(studyDS()->Name().c_str());
438     if ( LightApp_Study::studyName() != newName ) {
439       SalomeApp_Study* that = const_cast<SalomeApp_Study*>( this );
440       that->setStudyName( newName );
441       ((SalomeApp_Application*)application())->updateDesktopTitle();
442     }
443   }
444   return LightApp_Study::studyName();
445 }
446
447 /*!
448   Gets studyDS pointer.
449 */
450 _PTR(Study) SalomeApp_Study::studyDS() const
451 {
452   return myStudyDS;
453 }
454
455 /*!
456   Create document.
457 */
458 bool SalomeApp_Study::createDocument( const QString& theStr )
459 {
460   MESSAGE( "createDocument" );
461
462   // initialize myStudyDS, read HDF file
463   QString aName = newStudyName();
464
465   _PTR(Study) study;
466   try {
467     study = _PTR(Study)( SalomeApp_Application::studyMgr()->NewStudy( aName.toUtf8().data() ) );
468   }
469   catch(const SALOME_Exception& ex) {
470     SUIT_MessageBox::critical( SUIT_Session::session()->activeApplication()->desktop(),
471                                tr("ERR_ERROR"), tr(ex.what()));
472     return false;
473   } 
474   catch(...) {
475     SUIT_MessageBox::critical( SUIT_Session::session()->activeApplication()->desktop(),
476                                tr("ERR_ERROR"), tr("CREATE_DOCUMENT_PROBLEM"));
477     return false;
478   }
479
480   if ( !study )
481     return false;
482
483   setStudyDS( study );
484   setStudyName( aName );
485
486   // create myRoot
487   SalomeApp_RootObject* aRoot=new SalomeApp_RootObject( this );
488 #ifdef WITH_SALOMEDS_OBSERVER
489   aRoot->setToSynchronize(false);
490 #endif
491   setRoot( aRoot );
492
493   bool aRet = CAM_Study::createDocument( theStr );
494
495 #ifdef WITH_SALOMEDS_OBSERVER
496   myObserver = new Observer_i(myStudyDS,this);
497   //attach an observer to the study with notification of modifications
498   myStudyDS->attach(myObserver->_this(),true);
499 #endif
500
501   emit created( this );
502
503   return aRet;
504 }
505
506 /*!
507   Opens document
508   \param theFileName - name of file
509 */
510 bool SalomeApp_Study::openDocument( const QString& theFileName )
511 {
512   MESSAGE( "openDocument" );
513
514   // initialize myStudyDS, read HDF file
515   _PTR(Study) study;
516   try {
517     study = _PTR(Study) ( SalomeApp_Application::studyMgr()->Open( theFileName.toUtf8().data() ) );
518   }
519   catch(const SALOME_Exception& ex) {
520     SUIT_MessageBox::critical( SUIT_Session::session()->activeApplication()->desktop(),
521                                tr("ERR_ERROR"), tr(ex.what()));
522     return false;
523   } 
524   catch(...) {
525     SUIT_MessageBox::critical( SUIT_Session::session()->activeApplication()->desktop(),
526                                tr("ERR_ERROR"), tr("OPEN_DOCUMENT_PROBLEM"));
527     return false;
528   }
529
530   if ( !study )
531     return false;
532
533   setStudyDS( study );
534
535   setRoot( new SalomeApp_RootObject( this ) ); // create myRoot
536
537   // update loaded data models: call open() and update() on them.
538   ModelList dm_s;
539   dataModels( dm_s );
540   QListIterator<CAM_DataModel*> it( dm_s );
541   while ( it.hasNext() )
542     openDataModel( studyName(), it.next() );
543
544   // this will build a SUIT_DataObject-s tree under myRoot member field
545   // passing "false" in order NOT to rebuild existing data models' trees - it was done in previous step
546   // but tree that corresponds to not-loaded data models will be updated any way.
547   ((SalomeApp_Application*)application())->updateObjectBrowser( false );
548
549 #ifdef WITH_SALOMEDS_OBSERVER
550   dynamic_cast<SalomeApp_RootObject*>( root() )->setToSynchronize(false);
551   myObserver = new Observer_i(myStudyDS,this);
552   //attach an observer to the study with notification of modifications
553   myStudyDS->attach(myObserver->_this(),true);
554 #endif
555
556   bool res = CAM_Study::openDocument( theFileName );
557
558   emit opened( this );
559   study->IsSaved(true);
560
561   bool restore = application()->resourceMgr()->booleanValue( "Study", "store_visual_state", true );
562   if ( restore ) {
563     std::vector<int> savePoints = getSavePoints();
564     if ( savePoints.size() > 0 )
565       SalomeApp_VisualState( (SalomeApp_Application*)application() ).restoreState( savePoints[savePoints.size()-1] );
566   }
567
568   ((SalomeApp_Application*)application())->updateObjectBrowser( true );
569   return res;
570 }
571
572 /*!
573   Connects GUI study to SALOMEDS one already loaded into StudyManager
574   \param theStudyName - name of study
575 */
576 bool SalomeApp_Study::loadDocument( const QString& theStudyName )
577 {
578   MESSAGE( "loadDocument" );
579
580   // obtain myStudyDS from StudyManager
581   _PTR(Study) study ( SalomeApp_Application::studyMgr()->GetStudyByName( theStudyName.toUtf8().data() ) );
582   if ( !study )
583     return false;
584
585   setStudyDS( study );
586
587   setRoot( new SalomeApp_RootObject( this ) ); // create myRoot
588
589   //SRN: BugID IPAL9021, put there the same code as in a method openDocument
590
591   // update loaded data models: call open() and update() on them.
592   ModelList dm_s;
593   dataModels( dm_s );
594
595   QListIterator<CAM_DataModel*> it( dm_s );
596   while ( it.hasNext() )
597     openDataModel( studyName(), it.next() );
598
599   // this will build a SUIT_DataObject-s tree under myRoot member field
600   // passing "false" in order NOT to rebuild existing data models' trees - it was done in previous step
601   // but tree that corresponds to not-loaded data models will be updated any way.
602   ((SalomeApp_Application*)application())->updateObjectBrowser( false );
603
604 #ifdef WITH_SALOMEDS_OBSERVER
605   dynamic_cast<SalomeApp_RootObject*>( root() )->setToSynchronize(false);
606   myObserver = new Observer_i(myStudyDS,this);
607   //attach an observer to the study with notification of modifications
608   myStudyDS->attach(myObserver->_this(),true);
609 #endif
610
611   bool res = CAM_Study::openDocument( theStudyName );
612   
613   //rnv: to fix the "0051779: TC7.2.0: Save operation works incorrectly for study loaded from data server"
614   //     mark study as "not saved" after call openDocument( ... ) method.
615   setIsSaved(false);
616   emit opened( this );
617
618   bool restore = application()->resourceMgr()->booleanValue( "Study", "store_visual_state", true );
619   if ( restore ) {
620     std::vector<int> savePoints = getSavePoints();
621     if ( savePoints.size() > 0 )
622       SalomeApp_VisualState( (SalomeApp_Application*)application() ).restoreState( savePoints[savePoints.size()-1] );
623   }
624
625   //SRN: BugID IPAL9021: End
626   return res;
627 }
628
629 /*!
630   Saves document
631   \param theFileName - name of file
632 */
633 bool SalomeApp_Study::saveDocumentAs( const QString& theFileName )
634 {
635   bool store = application()->resourceMgr()->booleanValue( "Study", "store_visual_state", false );
636   if ( store )
637     SalomeApp_VisualState( (SalomeApp_Application*)application() ).storeState();
638
639   ModelList list; dataModels( list );
640
641   QListIterator<CAM_DataModel*> it( list );
642   QStringList listOfFiles;
643   while ( it.hasNext() ) {
644     // Cast to LightApp class in order to give a chance
645     // to light modules to save their data
646     if ( LightApp_DataModel* aModel = 
647          dynamic_cast<LightApp_DataModel*>( it.next() ) ) {
648       listOfFiles.clear();
649       aModel->saveAs( theFileName, this, listOfFiles );
650       if ( !listOfFiles.isEmpty() )
651         saveModuleData(aModel->module()->name(), listOfFiles);
652     }
653   }
654
655   // save SALOMEDS document
656   SUIT_ResourceMgr* resMgr = application()->resourceMgr();
657   if( !resMgr )
658     return false;
659
660   bool isMultiFile = resMgr->booleanValue( "Study", "multi_file", false );
661   bool isAscii = resMgr->booleanValue( "Study", "ascii_file", false );
662   bool res = (isAscii ?
663     SalomeApp_Application::studyMgr()->SaveAsASCII( theFileName.toUtf8().data(), studyDS(), isMultiFile ) :
664     SalomeApp_Application::studyMgr()->SaveAs     ( theFileName.toUtf8().data(), studyDS(), isMultiFile ))
665     && CAM_Study::saveDocumentAs( theFileName );
666
667   res = res && saveStudyData(theFileName);
668
669   if ( res )
670     emit saved( this );
671
672   return res;
673 }
674
675 /*!
676   Saves previously opened document
677 */
678 bool SalomeApp_Study::saveDocument()
679 {
680   bool store = application()->resourceMgr()->booleanValue( "Study", "store_visual_state", true );
681   if ( store )
682     SalomeApp_VisualState( (SalomeApp_Application*)application() ).storeState();
683
684   ModelList list; dataModels( list );
685
686   QListIterator<CAM_DataModel*> it( list );
687   QStringList listOfFiles;
688   while ( it.hasNext() ) {
689     // Cast to LightApp class in order to give a chance
690     // to light modules to save their data
691     if ( LightApp_DataModel* aModel = 
692          dynamic_cast<LightApp_DataModel*>( it.next() ) ) {
693       listOfFiles.clear();
694       aModel->save(listOfFiles);
695       if ( !listOfFiles.isEmpty() )
696         saveModuleData(aModel->module()->name(), listOfFiles);
697     }
698   }
699
700   // save SALOMEDS document
701   SUIT_ResourceMgr* resMgr = application()->resourceMgr();
702   if( !resMgr )
703     return false;
704
705   bool isMultiFile = resMgr->booleanValue( "Study", "multi_file", false );
706   bool isAscii = resMgr->booleanValue( "Study", "ascii_file", false );
707   bool res = (isAscii ?
708     SalomeApp_Application::studyMgr()->SaveASCII( studyDS(), isMultiFile ) :
709     SalomeApp_Application::studyMgr()->Save     ( studyDS(), isMultiFile )) && CAM_Study::saveDocument();
710
711   res = res && saveStudyData(studyName());
712   if ( res )
713     emit saved( this );
714
715   return res;
716 }
717
718 /*!
719   Closes document
720 */
721 void SalomeApp_Study::closeDocument(bool permanently)
722 {
723   LightApp_Study::closeDocument(permanently);
724
725   // close SALOMEDS document
726   _PTR(Study) studyPtr = studyDS();
727   if ( studyPtr )
728   {
729     if ( myObserver )
730       myStudyDS->detach( myObserver->_this() );
731     if ( permanently ) {
732       SalomeApp_Application::studyMgr()->Close( studyPtr );
733     }
734     SALOMEDSClient_Study* aStudy = 0;
735     setStudyDS( _PTR(Study)(aStudy) );
736   }
737 }
738
739 /*!
740   Dump study operation. Writes a Python dump file using
741   SALOMEDS services. Additionally, gives a chance to light modules
742   to participate in dump study operation.
743
744   \param theFileName - full path to the output Python file
745   \param toPublish - if true, all objects are published in a study 
746   by the output script, including those not orignally present 
747   in the current study.
748   \param isMultiFile - if true, each module's dump is written into 
749   a separate Python file, otherwise a single output file is written
750   \param toSaveGUI - if true, the GUI state is written
751
752   \return - true if the operation succeeds, and false otherwise.
753 */
754 bool SalomeApp_Study::dump( const QString& theFileName, 
755                             bool toPublish, 
756                             bool isMultiFile,
757                             bool toSaveGUI )
758 {
759   int savePoint;
760   _PTR(AttributeParameter) ap;
761   _PTR(IParameters) ip = ClientFactory::getIParameters(ap);
762   _PTR(Study) aStudy = studyDS();
763
764   if( ip->isDumpPython( aStudy ) ) 
765     ip->setDumpPython( aStudy ); //Unset DumpPython flag.
766
767   if ( toSaveGUI ) { //SRN: Store a visual state of the study at the save point for DumpStudy method
768     ip->setDumpPython( aStudy );
769     //SRN: create a temporary save point
770     savePoint = SalomeApp_VisualState( 
771       dynamic_cast<SalomeApp_Application*>( application() ) ).storeState(); 
772   }
773
774   // Issue 21377 - Each data model is asked to dump its data not present in SALOMEDS study.
775   // This is an optional but important step, it gives a chance to light modules
776   // to dump their data as a part of common dump study operation
777   ModelList list; 
778   dataModels( list );
779
780   QListIterator<CAM_DataModel*> it( list );
781   QStringList listOfFiles;
782   while ( it.hasNext() ) {
783     if ( LightApp_DataModel* aModel = 
784          dynamic_cast<LightApp_DataModel*>( it.next() ) ) {
785       listOfFiles.clear();
786       if ( aModel->dumpPython( theFileName, this, isMultiFile, listOfFiles ) && 
787            !listOfFiles.isEmpty() )
788         // This call simply passes the data model's dump output to SalomeApp_Engine servant.
789         // This code is shared with persistence mechanism.
790         // NOTE: this should be revised if behavior of saveModuleData() changes!
791         saveModuleData(aModel->module()->name(), listOfFiles);
792     }
793   }
794
795   // Now dump SALOMEDS part that also involves SalomeApp_Engine in case if 
796   // any light module is present in the current configuration
797   QFileInfo aFileInfo( theFileName );
798   bool res = aStudy->DumpStudy( aFileInfo.absolutePath().toUtf8().data(),
799                                 aFileInfo.baseName().toUtf8().data(),
800                                 toPublish,
801                                 isMultiFile);
802   if ( toSaveGUI )
803     removeSavePoint( savePoint ); //SRN: remove the created temporary save point.
804
805   // Issue 21377 - Clean up light module data in SalomeApp_Engine servant
806   // This code is shared with persistence mechanism.
807   // NOTE: this should be revised if behavior of saveStudyData() changes!
808   saveStudyData( theFileName );
809
810   return res;
811 }
812
813 /*!
814   \return true, if study is modified in comparison with last open/save
815 */
816 bool SalomeApp_Study::isModified() const
817 {
818   bool isAnyChanged = studyDS() && studyDS()->IsModified();
819   if (!isAnyChanged)
820     isAnyChanged = LightApp_Study::isModified();
821
822   return isAnyChanged;
823 }
824
825 /*!
826   Set study modified to \a on.
827  */
828 void SalomeApp_Study::Modified()
829 {
830   if(_PTR(Study) aStudy = studyDS())
831     aStudy->Modified();
832   LightApp_Study::Modified();
833 }
834
835 /*!
836   \return if data model is saved
837 */
838 bool SalomeApp_Study::isSaved() const
839 {
840   bool isAllSaved = studyDS() && studyDS()->GetPersistentReference().size();
841   if (!isAllSaved)
842     isAllSaved = LightApp_Study::isSaved();
843
844   return isAllSaved;
845 }
846
847 /*!
848   Saves data of module
849   \param theModuleName - name of module
850   \param theListOfFiles - list of files to be saved
851 */
852 void SalomeApp_Study::saveModuleData( QString theModuleName, QStringList theListOfFiles )
853 {
854   int aNb = theListOfFiles.count();
855   if ( aNb == 0 )
856     return;
857
858   std::vector<std::string> aListOfFiles ( aNb );
859   int anIndex = 0;
860   for ( QStringList::Iterator it = theListOfFiles.begin(); it != theListOfFiles.end(); ++it ) {
861     if ( (*it).isEmpty() )
862       continue;
863     aListOfFiles[anIndex] = (*it).toUtf8().data();
864     anIndex++;
865   }
866   SetListOfFiles(theModuleName.toStdString().c_str(), aListOfFiles);
867 }
868
869 /*!
870   Loads data of module
871   \param theModuleName - name of module
872   \param theListOfFiles - list of files to be loaded
873 */
874 void SalomeApp_Study::openModuleData( QString theModuleName, QStringList& theListOfFiles )
875 {
876   std::vector<std::string> aListOfFiles =  GetListOfFiles( theModuleName.toStdString().c_str() );
877
878   int i, aLength = aListOfFiles.size() - 1;
879   if ( aLength < 0 )
880     return;
881
882   //Get a temporary directory for saved a file
883   theListOfFiles.append(aListOfFiles[0].c_str());
884
885   for(i = 0; i < aLength; i++)
886     theListOfFiles.append(aListOfFiles[i+1].c_str());
887 }
888
889 /*!
890   Re-implemented from LightApp_Study, actually does not save anything but
891   simply cleans up light modules' data
892 */
893 bool SalomeApp_Study::saveStudyData( const QString& theFileName )
894 {
895   ModelList list; dataModels( list );
896   QListIterator<CAM_DataModel*> it( list );
897   std::vector<std::string> listOfFiles(0);
898   while ( it.hasNext() ){
899     LightApp_DataModel* aLModel = 
900       dynamic_cast<LightApp_DataModel*>( it.next() );
901     // It is safe to call SetListOfFiles() for any kind of module
902     // because SetListOfFiles() does nothing for full modules :)
903     if ( aLModel )
904       SetListOfFiles(aLModel->module()->name().toStdString().c_str(), listOfFiles);
905   }
906   return true;
907 }
908
909 /*!
910   Loads data for study
911 */
912 bool SalomeApp_Study::openStudyData( const QString& theFileName )
913 {
914  return true;
915 }
916
917 /*!
918   Set studyDS.
919 */
920 void SalomeApp_Study::setStudyDS( const _PTR(Study)& s )
921 {
922   myStudyDS = s;
923 }
924
925 /*!
926   Virtual method re-implemented from LightApp_Study in order to create
927   the module object connected to SALOMEDS - SalomeApp_ModuleObject.
928
929   \param theDataModel - data model instance to create a module object for
930   \param theParent - the module object's parent (normally it's the study root)
931   \return the module object instance
932   \sa LightApp_Study class, LightApp_DataModel class
933 */
934 CAM_ModuleObject* SalomeApp_Study::createModuleObject( LightApp_DataModel* theDataModel, 
935                                                        SUIT_DataObject* theParent ) const
936 {
937   SalomeApp_Study* that = const_cast<SalomeApp_Study*>( this );
938   
939   // Ensure that SComponent instance is published in the study for the given module
940   // This line causes automatic creation of SalomeApp_ModuleObject in case if
941   // WITH_SALOMEDS_OBSERVER is defined
942   that->addComponent( theDataModel );
943   
944   // SalomeApp_ModuleObject might have been created by SALOMEDS observer
945   // or by someone else so check if it exists first of all
946   CAM_ModuleObject* res = 0;
947
948   DataObjectList children = root()->children();
949   DataObjectList::const_iterator anIt = children.begin(), aLast = children.end();
950   for( ; !res && anIt!=aLast; anIt++ )
951   {
952     SalomeApp_ModuleObject* obj = dynamic_cast<SalomeApp_ModuleObject*>( *anIt );
953     if ( obj && obj->componentDataType() == theDataModel->module()->name() )
954       res = obj;
955   }
956
957   if ( !res ){
958     _PTR(Study) aStudy = studyDS();
959     if ( !aStudy )
960       return res;
961
962     _PTR(SComponent) aComp = aStudy->FindComponent( 
963       theDataModel->module()->name().toStdString() );
964     if ( !aComp )
965       return res;
966
967     res = new SalomeApp_ModuleObject( theDataModel, aComp, theParent );
968   }
969
970   return res;
971 }
972
973 /*!
974   Insert data model.
975 */
976 void SalomeApp_Study::dataModelInserted (const CAM_DataModel* dm)
977 {
978   MESSAGE("SalomeApp_Study::dataModelInserted() : module name() = " << dm->module()->name().toStdString());
979
980   CAM_Study::dataModelInserted(dm);
981
982   //  addComponent(dm);
983 }
984
985 /*!
986   Create SComponent for module, using default engine (CORBAless)
987 */
988 void SalomeApp_Study::addComponent(const CAM_DataModel* dm)
989 {
990   SalomeApp_Module* aModule = dynamic_cast<SalomeApp_Module*>( dm->module() );
991   // 1. aModule == 0 means that this is a light module (no CORBA enigine)
992   if (!aModule) {
993     // Check SComponent existance
994     _PTR(Study) aStudy = studyDS();
995     if (!aStudy)
996       return;
997
998     std::string aCompDataType = dm->module()->name().toStdString();
999
1000     _PTR(SComponent) aComp = aStudy->FindComponent(aCompDataType);
1001     if (!aComp) {
1002       // Create SComponent
1003       _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
1004       aComp = aBuilder->NewComponent(aCompDataType);
1005       aBuilder->SetName(aComp, dm->module()->moduleName().toStdString());
1006       QString anIconName = dm->module()->iconName();
1007       if (!anIconName.isEmpty()) {
1008         _PTR(AttributePixMap) anAttr = aBuilder->FindOrCreateAttribute(aComp, "AttributePixMap");
1009         if (anAttr)
1010           anAttr->SetPixMap(anIconName.toStdString());
1011       }
1012
1013       // Set default engine IOR
1014       // Issue 21377 - using separate engine for each type of light module
1015       std::string anEngineIOR = SalomeApp_Engine_i::EngineIORForComponent( aCompDataType.c_str(),
1016                                                                            true );
1017       aBuilder->DefineComponentInstance(aComp, anEngineIOR);
1018       //SalomeApp_DataModel::BuildTree( aComp, root(), this, /*skipExisitng=*/true );
1019       SalomeApp_DataModel::synchronize( aComp, this );
1020     }
1021     else {
1022       _PTR(StudyBuilder) aBuilder = aStudy->NewBuilder();
1023       aBuilder->SetName(aComp, dm->module()->moduleName().toStdString());
1024       QString anIconName = dm->module()->iconName();
1025       if (!anIconName.isEmpty()) {
1026         _PTR(AttributePixMap) anAttr = aBuilder->FindOrCreateAttribute(aComp, "AttributePixMap");
1027         if (anAttr)
1028           anAttr->SetPixMap(anIconName.toStdString());
1029       }
1030       // Set default engine IOR
1031     }
1032   }
1033 }
1034
1035 /*!
1036   Open data model
1037 */
1038 bool SalomeApp_Study::openDataModel( const QString& studyName, CAM_DataModel* dm )
1039 {
1040   if (!dm)
1041     return false;
1042
1043   //  SalomeApp_DataModel* aDM = (SalomeApp_DataModel*)(dm);
1044   SalomeApp_Module* aModule = dynamic_cast<SalomeApp_Module*>( dm->module() );
1045   _PTR(Study)       aStudy = studyDS(); // shared_ptr cannot be used here
1046   _PTR(SComponent)  aSComp;
1047   QString anEngine;
1048   // 1. aModule == 0 means that this is a light module (no CORBA enigine)
1049   if (!aModule) {
1050     // Issue 21377 - using separate engine for each type of light module
1051     std::string aCompDataType = dm->module()->name().toStdString();
1052     anEngine = SalomeApp_Engine_i::EngineIORForComponent( aCompDataType.c_str(), true ).c_str();
1053     aSComp = aStudy->FindComponent( aCompDataType );
1054   }
1055   else {
1056     SalomeApp_DataModel* aDM = dynamic_cast<SalomeApp_DataModel*>( dm );
1057     if ( aDM ) {
1058       QString anId = aDM->getRootEntry( this );
1059       if ( anId.isEmpty() )
1060         return true; // Probably nothing to load
1061       anEngine = aDM->getModule()->engineIOR();
1062       if ( anEngine.isEmpty() )
1063         return false;
1064       aSComp = aStudy->FindComponentID( std::string( anId.toLatin1() ) );
1065     }
1066   }
1067   if ( aSComp ) {
1068     _PTR(StudyBuilder) aBuilder( aStudy->NewBuilder() );
1069     if ( aBuilder ) {
1070       try {
1071         aBuilder->LoadWith( aSComp, std::string( anEngine.toLatin1() ) );
1072       }
1073       catch( const SALOME::SALOME_Exception& ) {
1074         // Oops, something went wrong while loading -> return an error
1075         return false;
1076       }
1077       // Something has been read -> create data model tree
1078       //SalomeApp_DataModel* aDM = dynamic_cast<SalomeApp_DataModel*>( dm );
1079       // aDM->buildTree( aSComp, 0, this );
1080     }
1081   } else {
1082     // Don't return false here, for there might be no data
1083     // for a given component in the study yet
1084   }
1085   QStringList listOfFiles;
1086   openModuleData(dm->module()->name(), listOfFiles);
1087   if (dm && dm->open(studyName, this, listOfFiles)) {
1088     // Remove the files and temporary directory, created
1089     // for this module by LightApp_Engine_i::Load()
1090     bool isMultiFile = false; // TODO: decide, how to access this parameter
1091     RemoveTemporaryFiles( dm->module()->name().toStdString().c_str(), isMultiFile );
1092
1093     // Something has been read -> create data model tree
1094     LightApp_DataModel* aDM = dynamic_cast<LightApp_DataModel*>( dm );
1095     if ( aDM )
1096       aDM->update(NULL, this);
1097     return true;
1098   }
1099   return false;
1100 }
1101
1102 /*!
1103   Create new study name.
1104 */
1105 QString SalomeApp_Study::newStudyName() const
1106 {
1107   std::vector<std::string> studies = SalomeApp_Application::studyMgr()->GetOpenStudies();
1108   QString prefix( "Study%1" ), newName, curName;
1109   int i = 1, j, n = studies.size();
1110   while ( newName.isEmpty() ){
1111     curName = prefix.arg( i );
1112     for ( j = 0 ; j < n; j++ ){
1113       if ( !strcmp( studies[j].c_str(), curName.toLatin1() ) )
1114         break;
1115     }
1116     if ( j == n )
1117       newName = curName;
1118     else
1119       i++;
1120   }
1121   return newName;
1122 }
1123
1124 /*!
1125   Note that this method does not create or activate SalomeApp_Engine_i instance,
1126   therefore it can be called safely for any kind of module, but for full
1127   modules it returns an empty list.
1128   \return list of files used by module: to be used by CORBAless modules
1129   \param theModuleName - name of module
1130 */
1131 std::vector<std::string> SalomeApp_Study::GetListOfFiles( const char* theModuleName  ) const
1132 {
1133   // Issue 21377 - using separate engine for each type of light module
1134   SalomeApp_Engine_i* aDefaultEngine = SalomeApp_Engine_i::GetInstance( theModuleName, false );
1135   if (aDefaultEngine)
1136     return aDefaultEngine->GetListOfFiles(id());
1137
1138   std::vector<std::string> aListOfFiles;
1139   return aListOfFiles;
1140 }
1141
1142 /*!
1143   Sets list of files used by module: to be used by CORBAless modules.
1144   Note that this method does not create or activate SalomeApp_Engine_i instance,
1145   therefore it can be called safely for any kind of module, but for full
1146   modules it simply does nothing.
1147   \param theModuleName - name of module
1148   \param theListOfFiles - list of files
1149 */
1150 void SalomeApp_Study::SetListOfFiles ( const char* theModuleName,
1151                                        const std::vector<std::string> theListOfFiles )
1152 {
1153   // Issue 21377 - using separate engine for each type of light module
1154   SalomeApp_Engine_i* aDefaultEngine = SalomeApp_Engine_i::GetInstance( theModuleName, false );
1155   if (aDefaultEngine)
1156     aDefaultEngine->SetListOfFiles(theListOfFiles, id());
1157 }
1158
1159 /*!
1160   \return temporary directory for saving files of modules
1161 */
1162 std::string SalomeApp_Study::GetTmpDir ( const char* theURL, const bool  isMultiFile )
1163 {
1164   std::string anURLDir = SALOMEDS_Tool::GetDirFromPath(theURL);
1165   std::string aTmpDir = isMultiFile ? anURLDir : SALOMEDS_Tool::GetTmpDir();
1166   return aTmpDir;
1167 }
1168
1169 /*!
1170   Removes temporary files
1171 */
1172 void SalomeApp_Study::RemoveTemporaryFiles ( const char* theModuleName, const bool isMultiFile ) const
1173 {
1174   if (isMultiFile)
1175     return;
1176
1177   std::vector<std::string> aListOfFiles = GetListOfFiles( theModuleName );
1178   if (aListOfFiles.size() > 0) {
1179     std::string aTmpDir = aListOfFiles[0];
1180
1181     const int n = aListOfFiles.size() - 1;
1182     SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
1183     aSeq->length(n);
1184     for (int i = 0; i < n; i++)
1185       aSeq[i] = CORBA::string_dup(aListOfFiles[i + 1].c_str());
1186
1187     SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true);
1188   }
1189 }
1190
1191 #ifndef DISABLE_PYCONSOLE
1192 /*!
1193   Mark the study as saved in the file
1194   \param theFileName - the name of file
1195 */
1196 void SalomeApp_Study::updateFromNotebook( const QString& theFileName, bool isSaved )
1197 {
1198   setStudyName(theFileName);
1199   studyDS()->Name(theFileName.toStdString());
1200   setIsSaved( isSaved );
1201 }
1202 #endif
1203
1204 LightApp_DataObject* SalomeApp_Study::findObjectByEntry( const QString& theEntry )
1205 {
1206   LightApp_DataObject* o = 0;
1207   if ( myObserver ) {
1208     o = dynamic_cast<LightApp_DataObject*>( myObserver->findObject( theEntry.toLatin1().constData() ) );
1209   }
1210   if ( !o ) {
1211     o = LightApp_Study::findObjectByEntry( theEntry );
1212   }
1213   return o;
1214 }
1215
1216 /*!
1217   Deletes all references to object
1218   \param obj - object
1219 */
1220 void SalomeApp_Study::deleteReferencesTo( _PTR( SObject ) obj )
1221 {
1222   _PTR(StudyBuilder) sb = studyDS()->NewBuilder();
1223   std::vector<_PTR(SObject)> aRefs = studyDS()->FindDependances( obj );
1224   for( int i=0, n=aRefs.size(); i<n; i++ )
1225   {
1226     _PTR( SObject ) o = aRefs[i];
1227     if( o->GetFatherComponent()->ComponentDataType()==obj->GetFatherComponent()->ComponentDataType() )
1228     {
1229       sb->RemoveReference( o );
1230       sb->RemoveObjectWithChildren( o );
1231     }
1232   }
1233 }
1234
1235 /*!
1236   \return real entry by entry of reference
1237   \param entry - entry of reference object
1238 */
1239 QString SalomeApp_Study::referencedToEntry( const QString& entry ) const
1240 {
1241   _PTR(SObject) obj = studyDS()->FindObjectID( entry.toStdString() );
1242   _PTR(SObject) refobj;
1243
1244   if( obj && obj->ReferencedObject( refobj ) )
1245     return refobj->GetID().c_str();
1246   return LightApp_Study::referencedToEntry( entry );
1247 }
1248
1249 /*!
1250   \return component data type for entry
1251 */
1252 QString SalomeApp_Study::componentDataType( const QString& entry ) const
1253 {
1254   _PTR(SObject) obj( studyDS()->FindObjectID( entry.toStdString() ) );
1255   if ( !obj )
1256     return LightApp_Study::componentDataType( entry );
1257   return obj->GetFatherComponent()->ComponentDataType().c_str();
1258 }
1259
1260 /*!
1261   \return true if entry corresponds to component
1262 */
1263 bool SalomeApp_Study::isComponent( const QString& entry ) const
1264 {
1265   _PTR(SObject) obj( studyDS()->FindObjectID( entry.toStdString() ) );
1266   return obj && QString( obj->GetID().c_str() ) == obj->GetFatherComponent()->GetID().c_str();
1267 }
1268
1269 /*!
1270   \return entries of object children
1271 */
1272 void SalomeApp_Study::children( const QString& entry, QStringList& child_entries ) const
1273 {
1274   _PTR(SObject) SO = studyDS()->FindObjectID( entry.toStdString() );
1275   _PTR(ChildIterator) anIter ( studyDS()->NewChildIterator( SO ) );
1276   anIter->InitEx( true );
1277   while( anIter->More() )
1278   {
1279     _PTR(SObject) val( anIter->Value() );
1280     child_entries.append( val->GetID().c_str() );
1281     anIter->Next();
1282   }
1283 }
1284
1285 /*!
1286   Fills list with components names
1287   \param comp - list to be filled
1288 */
1289 void SalomeApp_Study::components( QStringList& comps ) const
1290 {
1291   for( _PTR(SComponentIterator) it ( studyDS()->NewComponentIterator() ); it->More(); it->Next() )
1292   {
1293     _PTR(SComponent) aComponent ( it->Value() );
1294     // skip the magic "Interface Applicative" component
1295     if ( aComponent && aComponent->ComponentDataType() != getVisualComponentName().toLatin1().constData() )
1296       comps.append( aComponent->ComponentDataType().c_str() );
1297   }
1298 }
1299
1300 /*!
1301   Get the entry for the given module
1302   \param comp - list to be filled
1303   \return module root's entry
1304 */
1305 QString SalomeApp_Study::centry( const QString& comp ) const
1306 {
1307   QString e;
1308   for( _PTR(SComponentIterator) it ( studyDS()->NewComponentIterator() ); it->More() && e.isEmpty(); it->Next() )
1309   {
1310     _PTR(SComponent) aComponent ( it->Value() );
1311     if ( aComponent && comp == aComponent->ComponentDataType().c_str() )
1312       e = aComponent->GetID().c_str();
1313   }
1314   return e;
1315 }
1316
1317 /*!
1318   \return a list of saved points' IDs
1319 */
1320 std::vector<int> SalomeApp_Study::getSavePoints()
1321 {
1322   std::vector<int> v;
1323
1324   _PTR(SObject) so = studyDS()->FindComponent( getVisualComponentName().toLatin1().constData() );
1325   if(!so) return v;
1326
1327   _PTR(StudyBuilder) builder = studyDS()->NewBuilder();
1328   _PTR(ChildIterator) anIter ( studyDS()->NewChildIterator( so ) );
1329   for(; anIter->More(); anIter->Next())
1330   {
1331     _PTR(SObject) val( anIter->Value() );
1332     _PTR(GenericAttribute) genAttr;
1333     if(builder->FindAttribute(val, genAttr, "AttributeParameter")) v.push_back(val->Tag());
1334   }
1335
1336   return v;
1337 }
1338
1339 /*!
1340   Removes a given save point
1341 */
1342 void SalomeApp_Study::removeSavePoint(int savePoint)
1343 {
1344   if(savePoint <= 0) return;
1345  _PTR(AttributeParameter) AP = studyDS()->GetCommonParameters(getVisualComponentName().toLatin1().constData(), savePoint);
1346   _PTR(SObject) so = AP->GetSObject();
1347   _PTR(StudyBuilder) builder = studyDS()->NewBuilder();
1348   builder->RemoveObjectWithChildren(so);
1349 }
1350
1351 /*!
1352   \return a name of save point
1353 */
1354 QString SalomeApp_Study::getNameOfSavePoint(int savePoint)
1355 {
1356   _PTR(AttributeParameter) AP = studyDS()->GetCommonParameters(getVisualComponentName().toLatin1().constData(), savePoint);
1357   _PTR(IParameters) ip = ClientFactory::getIParameters(AP);
1358   return ip->getProperty("AP_SAVEPOINT_NAME").c_str();
1359 }
1360
1361 /*!
1362   Sets a name of save point
1363 */
1364 void SalomeApp_Study::setNameOfSavePoint(int savePoint, const QString& nameOfSavePoint)
1365 {
1366   _PTR(AttributeParameter) AP = studyDS()->GetCommonParameters(getVisualComponentName().toLatin1().constData(), savePoint);
1367   _PTR(IParameters) ip = ClientFactory::getIParameters(AP);
1368   ip->setProperty("AP_SAVEPOINT_NAME", nameOfSavePoint.toStdString());
1369 }
1370
1371 /*!
1372  * \brief Restores the study state
1373  */
1374 void SalomeApp_Study::restoreState(int savePoint)
1375 {
1376   SalomeApp_VisualState((SalomeApp_Application*)application()).restoreState(savePoint);
1377 }
1378
1379
1380 /*!
1381   Slot: called on change of a root of a data model. Redefined from CAM_Study
1382 */
1383 void SalomeApp_Study::updateModelRoot( const CAM_DataModel* dm )
1384 {
1385   LightApp_Study::updateModelRoot( dm );
1386
1387   // calling updateSavePointDataObjects in order to set correct order of "Gui states" object
1388   // it must always be the last one.
1389   ((SalomeApp_Application*)application())->updateSavePointDataObjects( this );
1390 }