Salome HOME
8778402e0d3d8df692d5035e6ee7a1e624bf17e3
[modules/shaper.git] / src / Model / Model_Document.h
1 // Copyright (C) 2014-2019  CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19
20 #ifndef Model_Document_H_
21 #define Model_Document_H_
22
23 #include <Model.h>
24 #include <ModelAPI_Document.h>
25 #include <ModelAPI_Feature.h>
26 #include <ModelAPI_Result.h>
27 #include <ModelAPI_ResultParameter.h>
28
29 #include <TDocStd_Document.hxx>
30 #include <map>
31 #include <set>
32
33 class Handle_Model_Document;
34 class Model_Objects;
35 class ModelAPI_AttributeSelectionList;
36
37 /**\class Model_Document
38  * \ingroup DataModel
39  * \brief Document for internal data structure of any object storage.
40  * Document contains all data that must be stored/retrieved in the file.
41  * Also it provides access to this data: open/save, transactions management etc.
42  */
43 class Model_Document : public ModelAPI_Document
44 {
45  public:
46   //! Returns the kind of the document: "PartSet", "Part", or something else.
47   //! This kind is used for feature buttons enable/disable depending on active document
48   //! (it uses workbench "document" identifier in XML configuration file for this)
49   MODEL_EXPORT virtual const std::string& kind() const {return myKind;}
50
51   //! Loads the OCAF document from the file.
52   //! \param theDirName directory of the loaded file
53   //! \param theFileName a name of the file to load
54   //! \param theThis the common shared pointer to the document to manage with it later
55   //! \returns true if file was loaded successfully
56   MODEL_EXPORT virtual bool load(
57     const char* theDirName, const char* theFileName, DocumentPtr theThis);
58
59   //! Saves the OCAF document to the file.
60   //! \param theDirName directory where the document will be saved
61   //! \param theFileName a name of the document file to store
62   //! \param theResults the result full file names that were stored by "save"
63   //! \returns true if file was stored successfully
64   MODEL_EXPORT virtual bool save(
65     const char* theDirName, const char* theFileName, std::list<std::string>& theResults);
66
67   //! Removes document data
68   //! \param theForever if it is false, document is just hidden
69   //!                   (to keep possibility make it back on Undo/Redo)
70   MODEL_EXPORT virtual void close(const bool theForever = false);
71
72   //! Starts a new operation (opens a transaction)
73   MODEL_EXPORT virtual void startOperation();
74   //! Finishes the previously started operation (closes the transaction)
75   //! \returns true if transaction in this document is not empty and really was performed
76   MODEL_EXPORT virtual bool finishOperation();
77   //! Aborts the operation
78   MODEL_EXPORT virtual void abortOperation();
79   //! Returns true if operation has been started, but not yet finished or aborted
80   MODEL_EXPORT virtual bool isOperation() const;
81   //! Returns true if document was modified (since creation/opening)
82   MODEL_EXPORT virtual bool isModified();
83
84   //! Returns True if there are available Undo-s
85   MODEL_EXPORT virtual bool canUndo();
86   //! Undoes last operation
87   MODEL_EXPORT virtual void undo();
88   //! Returns True if there are available Redo-s
89   MODEL_EXPORT virtual bool canRedo();
90   //! Redoes last operation
91   MODEL_EXPORT virtual void redo();
92
93   //! Adds to the document the new feature of the given feature id
94   //! \param theID creates feature and puts it in the document
95   //! \param theMakeCurrent to make current this new feature in this document
96   MODEL_EXPORT virtual FeaturePtr addFeature(std::string theID, const bool theMakeCurrent = true);
97
98   //! Return a list of features, which refers to the feature
99   //! \param theFeature a feature
100   //! \param theRefs a list of reference features
101   //! \param isSendError a flag whether the error message should be send
102   MODEL_EXPORT virtual void refsToFeature(FeaturePtr theFeature,
103                                           std::set<FeaturePtr>& theRefs,
104                                           const bool isSendError = true);
105
106   //! Removes the feature from the document (with result)
107   //! It is necessary to flush REDISPLAY signal manually after this method because
108   //! the method sends it, but for the performance purpose does not flush it
109   //! \param theFeature a removed feature
110   MODEL_EXPORT virtual void removeFeature(FeaturePtr theFeature);
111
112   //! Moves the feature to make it after the given one in the history.
113   MODEL_EXPORT virtual void moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis);
114
115   //! Returns the first found object in the group by the object name
116   //! \param theGroupID group that contains an object
117   //! \param theName name of the object to search
118   //! \returns null if such object is not found
119   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Object> objectByName(
120     const std::string& theGroupID, const std::string& theName);
121
122   //! Returns the object index in the group. Object must be visible. Otherwise returns -1.
123   //! \param theObject object of this document
124   //! \param theAllowFolder take into account grouping feature by folders
125   //! \returns index started from zero, or -1 if object is invisible or belongs to another document
126   MODEL_EXPORT virtual const int index(std::shared_ptr<ModelAPI_Object> theObject,
127                                        const bool theAllowFolder = false);
128
129   //! Internal sub-document by ID
130   MODEL_EXPORT virtual std::shared_ptr<Model_Document> subDoc(int theDocID);
131
132   ///! Returns the id of the document
133   MODEL_EXPORT virtual const int id() const
134   {
135     return myID;
136   }
137
138   //! Returns the feature in the group by the index (started from zero)
139   //! \param theGroupID group that contains a feature
140   //! \param theIndex zero-based index of feature in the group
141   //! \param theAllowFolder take into account grouping feature by folders
142   MODEL_EXPORT virtual ObjectPtr object(const std::string& theGroupID,
143                                         const int theIndex,
144                                         const bool theAllowFolder = false);
145
146   //! Returns the number of features in the group
147   //! \param theGroupID group of objects
148   //! \param theAllowFolder take into account grouping feature by folders
149   MODEL_EXPORT virtual int size(const std::string& theGroupID, const bool theAllowFolder = false);
150
151   //! Returns the parent object of this child. This may be result or feature, parent of a
152   //! top result. Fast method, that uses internal data structure specifics.
153   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Object> parent(
154     const std::shared_ptr<ModelAPI_Object> theChild);
155
156   //! Returns the feature that is currently edited in this document, normally
157   //! this is the latest created feature
158   //! \param theVisible use visible features only: flag is true for Object Browser functionality
159   //! \returns null if next created feature must be the first
160   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> currentFeature(const bool theVisible);
161
162   //! Sets the current feature: all features below will be disabled, new features
163   //! will be appended after this one.
164   //! \param theCurrent the selected feature as current: below it everything becomes disabled
165   //! \param theVisible use visible features only: flag is true for Object Browser functionality
166   MODEL_EXPORT virtual void setCurrentFeature(std::shared_ptr<ModelAPI_Feature> theCurrent,
167     const bool theVisible);
168
169   //! Makes the current feature one feature upper
170   MODEL_EXPORT virtual void setCurrentFeatureUp();
171
172   //! Returns the number of all features: in the history or not
173   MODEL_EXPORT virtual int numInternalFeatures();
174   //! Returns the feature by zero-based index: features in the history or not
175   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> internalFeature(const int theIndex);
176   //! Performs synchronization of transactions with the module document:
177   //! If some document is not active (by undo of activation) but in memory,
178   //! on activation the transactions must be synchronized because all redo-s performed
179   //! without this participation
180   MODEL_EXPORT virtual void synchronizeTransactions();
181
182   /// Creates construction results
183   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultConstruction> createConstruction(
184       const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
185   /// Creates a body results
186   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultBody> createBody(
187       const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
188   /// Creates a part results
189   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultPart> createPart(
190       const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
191   //! Copies a part result, keeping the reference to origin
192   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultPart> copyPart(
193     const std::shared_ptr<ModelAPI_ResultPart>& theOrigin,
194     const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
195   /// Creates a group result
196   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultGroup> createGroup(
197       const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
198   /// Creates a field result
199   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultField> createField(
200       const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
201   /// Creates a parameter result
202   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultParameter> createParameter(
203       const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
204
205   //! Returns a feature by result (owner of result)
206   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature>
207     feature(const std::shared_ptr<ModelAPI_Result>& theResult);
208
209   //! Creates a folder (group of the features in the object browser)
210   //! \param theAddBefore a feature, the folder is added before
211   //!                     (if empty, the folder is added after the last feature)
212   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> addFolder(
213       std::shared_ptr<ModelAPI_Feature> theAddBefore = std::shared_ptr<ModelAPI_Feature>());
214   //! Removes the folder from the document (all features in the folder will be kept).
215   MODEL_EXPORT virtual void removeFolder(std::shared_ptr<ModelAPI_Folder> theFolder);
216   //! Search a folder above the list of features applicable to store them
217   //! (it means the list of features stored in the folder should be consequential)
218   //! \return Empty pointer if there is no applicable folder
219   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> findFolderAbove(
220       const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures);
221   //! Search a folder below the list of features applicable to store them
222   //! (it means the list of features stored in the folder should be consequential)
223   //! \return Empty pointer if there is no applicable folder
224   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> findFolderBelow(
225       const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures);
226   //! Search a folder containing the given feature.
227   //! Additionally calculates a zero-based index of the feature in this folder.
228   //! \param theFeature feature to search
229   //! \param theIndexInFolder zero-based index in the folder or -1 if the feature is top-level.
230   //! \return the folder containing the feature or empty pointer if the feature is top-level.
231   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> findContainingFolder(
232       const std::shared_ptr<ModelAPI_Feature>& theFeature,
233       int& theIndexInFolder);
234   //! Add a list of features to the folder. The correctness of the adding is not performed
235   //! (such checks have been done in corresponding find.. method).
236   //! \return \c true if the movement is successful
237   MODEL_EXPORT virtual bool moveToFolder(
238       const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
239       const std::shared_ptr<ModelAPI_Folder>& theFolder);
240   //! Remove features from the folder
241   //! \param theFeatures list of features to be removed
242   //! \param theBefore   extract features before the folder (this parameter is applicable only
243   //!                    when all features in the folder are taking out,
244   //!                    in other cases the direction is taken automatically)
245   //! \return \c true if the features have been moved out
246   MODEL_EXPORT virtual bool removeFromFolder(
247       const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
248       const bool theBefore = true);
249
250   ///! Returns true if parametric updater need to execute feature on recomputation
251   ///! On abort, undo or redo it is not necessary: results in document are updated automatically
252   bool executeFeatures() {return myExecuteFeatures;}
253
254   ///! On abort, undo or redo it is not necessary: results in document are updated automatically
255   void setExecuteFeatures(const bool theFlag);
256
257   //! Registers the name of the shape for the topological naming needs
258   void addNamingName(const TDF_Label theLabel, std::string theName);
259   //! Updates the name of some object
260   void changeNamingName(std::string theOldName, const std::string theNewName,
261     const TDF_Label& theLabel);
262   //! Returns the label, keeper of the name  for the topological naming needs
263   TDF_Label findNamingName(std::string theName, ResultPtr theContext);
264   //! Returns the number of the name in the history relatively to the given object (by label).
265   //! Start from 1 (this object).
266   int numberOfNameInHistory(const ObjectPtr& theNameObject, const TDF_Label& theStartFrom);
267   //! Returns the result by name of the result (names of results must be unique, used for naming
268   //! selection by name.
269   ResultPtr findByName(std::string& theName, std::string& theSubShapeName, bool& theUniqueContext);
270
271   ///! Returns all features of the document including the hidden features which are not in
272   ///! history. Not very fast method, for calling once, not in big cycles.
273   MODEL_EXPORT virtual std::list<std::shared_ptr<ModelAPI_Feature> > allFeatures();
274
275   //! Returns all objects of the document including the hidden features which are not in
276   //! history. Not very fast method, for calling once, not in big cycles.
277   MODEL_EXPORT virtual std::list<std::shared_ptr<ModelAPI_Object> > allObjects();
278
279   /// Returns the global identifier of the current transaction (needed for the update algo)
280   MODEL_EXPORT virtual int transactionID();
281   /// Increases the transaction ID
282   MODEL_EXPORT virtual void incrementTransactionID();
283
284   /// Returns true if document is opened and valid
285   MODEL_EXPORT virtual bool isOpened();
286
287   /// Returns the last feature in the document (even not visible or disabled)
288   /// \returns null if there is no features
289   FeaturePtr lastFeature();
290
291   /// Returns the feature that produced the given face of the given result.
292   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> producedByFeature(
293     std::shared_ptr<ModelAPI_Result> theResult,
294     const std::shared_ptr<GeomAPI_Shape>& theShape);
295
296   /// Returns true if theLater is in history of features creation later than theCurrent
297   MODEL_EXPORT virtual bool isLater(FeaturePtr theLater, FeaturePtr theCurrent) const;
298
299   /// Just removes all features without touching the document data (to be able undo)
300   MODEL_EXPORT virtual void eraseAllFeatures();
301
302
303  protected:
304   //! Returns (creates if needed) the general label
305   TDF_Label generalLabel() const;
306
307   //! Creates new document with binary file format
308   Model_Document(const int theID, const std::string theKind);
309
310   //! Returns the internal OCCT document of this interface
311   Handle_TDocStd_Document document()
312   {
313     return myDoc;
314   }
315
316   //! performs compactification of all nested operations into one
317   //! \returns true if resulting transaction is not empty and can be undone
318   void compactNested();
319
320   //! Returns all loaded sub documents
321   const std::set<int> subDocuments() const;
322
323   //! The implementation of undo: with or without recursive calls in the sub-documents
324   void undoInternal(const bool theWithSubs, const bool theSynchronize);
325
326   //! Stores the Id of the current operation (normally is called for the root document)
327   void operationId(const std::string& theId);
328
329   //! Returns the list of Ids of the operations that can be undone (called for the root document)
330   std::list<std::string> undoList() const;
331
332   //! Returns the list of Ids of the operations that can be redone (called for the root document)
333   std::list<std::string> redoList() const;
334
335   //! Internally makes document know that feature was removed or added in history after creation
336   virtual void updateHistory(const std::shared_ptr<ModelAPI_Object> theObject);
337   //! Internally makes document know that feature was removed or added in history after creation
338   virtual void updateHistory(const std::string theGroup);
339
340   //! Returns true if the document is root module document
341   bool isRoot() const;
342
343   //! Sets shared pointer to this
344   void setThis(DocumentPtr theDoc);
345
346   //! Returns the objects manager
347   Model_Objects* objects() {return myObjs;}
348
349   ///! Informs the document that it becomes active and some actions must be performed
350   virtual void setActive(const bool theFlag);
351   //! Returns true if this document is currently active
352   virtual bool isActive() const;
353
354   //! Returns the selection attribute that is used
355   //! for calculation of selection externally from the document
356   std::shared_ptr<ModelAPI_AttributeSelectionList> selectionInPartFeature();
357
358   /// Stores in the document boolean flags: states of the nodes in the object browser.
359   /// Normally is called outside of the transaction, just before "save".
360   virtual void storeNodesState(const std::list<bool>& theStates);
361
362   /// Returns the stored nodes states. Normally it is called just after "open".
363   /// Appends the values to theStates list.
364   virtual void restoreNodesState(std::list<bool>& theStates) const;
365
366   /// Label that contains structures for selection of constructions of another document
367   TDF_Label extConstructionsLabel() const;
368
369   /// searches in this document feature that contains this label
370   FeaturePtr featureByLab(const TDF_Label& theLab);
371   /// searches in this document result that contains this label
372   ResultPtr resultByLab(const TDF_Label& theLab);
373
374   /// returns true if theThis is later in the features tree and dependencies than theOther
375   bool isLaterByDep(FeaturePtr theThis, FeaturePtr theOther);
376
377   /// appends the latest transaction to the previous one (used for AutoUpdate enabling transaction)
378   void appendTransactionToPrevious();
379
380   /// Sets the automatic recomputation flag: true means enabled
381   void setAutoRecomutationState(const bool theState);
382   /// Returns the current automatic recomputation flag: true means enabled
383   bool autoRecomutationState() const;
384
385   friend class Model_Application;
386   friend class Model_Session;
387   friend class Model_Update;
388   friend class Model_AttributeReference;
389   friend class Model_AttributeRefAttr;
390   friend class Model_AttributeRefList;
391   friend class Model_AttributeRefAttrList;
392   friend class Model_AttributeSelection;
393   friend class Model_ResultPart;
394   friend class Model_ResultBody;
395   friend class Model_ResultConstruction;
396   friend class Model_SelectionNaming;
397   friend class Model_BodyBuilder;
398   friend class DFBrowser;
399
400  private:
401   int myID;  ///< identifier of the document in the application
402   std::string myKind;  ///< kind of the document in the application
403   Handle_TDocStd_Document myDoc;  ///< OCAF document
404
405   Model_Objects *myObjs; ///< data manager of this document
406
407   //! counter value of transaction on the last "save" call, used for "IsModified" method
408   int myTransactionSave;
409   //! number of nested transactions performed (list because may be nested inside of nested)
410   //! the list is empty if not nested transaction is performed
411   std::list<int> myNestedNum;
412
413   //! Information related to the every user-transaction
414   struct Transaction {
415     int myOCAFNum; ///< number of OCAF transactions related to each "this" transaction, may be 0
416     std::string myId; ///< user-identifier string of transaction
417     //! default constructor with default Id
418     Transaction(): myOCAFNum(0), myId("") {}
419   };
420
421   //! transaction indexes (related to myTransactionsAfterSave) and info about the real transactions
422   //! in myDocument connected to this operation (may be zero for empty transaction)
423   std::list<Transaction> myTransactions;
424   //! list of info about transactions undone (first is oldest undone)
425   std::list<Transaction> myRedos;
426
427   //! Optimization for finding the shape-label by topological naming names
428   //! The name -> list of labels where this name is appeared (the last created name is last here)
429   std::map<std::string, std::list<TDF_Label> > myNamingNames;
430   //! If it is true, features are not executed on update (on abort, undo, redo)
431   bool myExecuteFeatures;
432
433   bool myIsActive; ///< flag that stores the active/not active state
434
435   //! The selection feature, if needed
436   FeaturePtr mySelectionFeature;
437
438   bool myIsSetCurrentFeature; ///< flag that my current feature is changed right now (recursion)
439 };
440
441 #endif