]> SALOME platform Git repositories - modules/shaper.git/blob - src/Model/Model_Document.h
Salome HOME
Improve code coverage for elliptic arcs.
[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   /// Returns the next (from the history point of view) feature, any: invisible or disabled
303   /// \param theCurrent previous to the resulting feature
304   /// \param theReverse if it is true, iterates in reversed order (next becomes previous)
305   MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> nextFeature(
306     std::shared_ptr<ModelAPI_Feature> theCurrent, const bool theReverse = false) const;
307
308  protected:
309   //! Returns (creates if needed) the general label
310   TDF_Label generalLabel() const;
311
312   //! Creates new document with binary file format
313   Model_Document(const int theID, const std::string theKind);
314
315   //! Returns the internal OCCT document of this interface
316   Handle_TDocStd_Document document()
317   {
318     return myDoc;
319   }
320
321   //! performs compactification of all nested operations into one
322   //! \returns true if resulting transaction is not empty and can be undone
323   void compactNested();
324
325   //! Returns all loaded sub documents
326   const std::set<int> subDocuments() const;
327
328   //! The implementation of undo: with or without recursive calls in the sub-documents
329   void undoInternal(const bool theWithSubs, const bool theSynchronize);
330
331   //! Stores the Id of the current operation (normally is called for the root document)
332   void operationId(const std::string& theId);
333
334   //! Returns the list of Ids of the operations that can be undone (called for the root document)
335   std::list<std::string> undoList() const;
336
337   //! Returns the list of Ids of the operations that can be redone (called for the root document)
338   std::list<std::string> redoList() const;
339
340   //! Internally makes document know that feature was removed or added in history after creation
341   virtual void updateHistory(const std::shared_ptr<ModelAPI_Object> theObject);
342   //! Internally makes document know that feature was removed or added in history after creation
343   virtual void updateHistory(const std::string theGroup);
344
345   //! Returns true if the document is root module document
346   bool isRoot() const;
347
348   //! Sets shared pointer to this
349   void setThis(DocumentPtr theDoc);
350
351   //! Returns the objects manager
352   Model_Objects* objects() {return myObjs;}
353
354   ///! Informs the document that it becomes active and some actions must be performed
355   virtual void setActive(const bool theFlag);
356   //! Returns true if this document is currently active
357   virtual bool isActive() const;
358
359   //! Returns the selection attribute that is used
360   //! for calculation of selection externally from the document
361   std::shared_ptr<ModelAPI_AttributeSelectionList> selectionInPartFeature();
362
363   /// Stores in the document boolean flags: states of the nodes in the object browser.
364   /// Normally is called outside of the transaction, just before "save".
365   virtual void storeNodesState(const std::list<bool>& theStates);
366
367   /// Returns the stored nodes states. Normally it is called just after "open".
368   /// Appends the values to theStates list.
369   virtual void restoreNodesState(std::list<bool>& theStates) const;
370
371   /// Label that contains structures for selection of constructions of another document
372   TDF_Label extConstructionsLabel() const;
373
374   /// searches in this document feature that contains this label
375   FeaturePtr featureByLab(const TDF_Label& theLab);
376   /// searches in this document result that contains this label
377   ResultPtr resultByLab(const TDF_Label& theLab);
378
379   /// returns true if theThis is later in the features tree and dependencies than theOther
380   bool isLaterByDep(FeaturePtr theThis, FeaturePtr theOther);
381
382   /// appends the latest transaction to the previous one (used for AutoUpdate enabling transaction)
383   void appendTransactionToPrevious();
384
385   /// Sets the automatic recomputation flag: true means enabled
386   void setAutoRecomutationState(const bool theState);
387   /// Returns the current automatic recomputation flag: true means enabled
388   bool autoRecomutationState() const;
389
390   friend class Model_Application;
391   friend class Model_Session;
392   friend class Model_Update;
393   friend class Model_AttributeReference;
394   friend class Model_AttributeRefAttr;
395   friend class Model_AttributeRefList;
396   friend class Model_AttributeRefAttrList;
397   friend class Model_AttributeSelection;
398   friend class Model_AttributeSelectionList;
399   friend class Model_ResultPart;
400   friend class Model_ResultBody;
401   friend class Model_ResultConstruction;
402   friend class Model_SelectionNaming;
403   friend class Model_BodyBuilder;
404   friend class DFBrowser;
405
406  private:
407   int myID;  ///< identifier of the document in the application
408   std::string myKind;  ///< kind of the document in the application
409   Handle_TDocStd_Document myDoc;  ///< OCAF document
410
411   Model_Objects *myObjs; ///< data manager of this document
412
413   //! counter value of transaction on the last "save" call, used for "IsModified" method
414   int myTransactionSave;
415   //! number of nested transactions performed (list because may be nested inside of nested)
416   //! the list is empty if not nested transaction is performed
417   std::list<int> myNestedNum;
418
419   //! Information related to the every user-transaction
420   struct Transaction {
421     int myOCAFNum; ///< number of OCAF transactions related to each "this" transaction, may be 0
422     std::string myId; ///< user-identifier string of transaction
423     //! default constructor with default Id
424     Transaction(): myOCAFNum(0), myId("") {}
425   };
426
427   //! transaction indexes (related to myTransactionsAfterSave) and info about the real transactions
428   //! in myDocument connected to this operation (may be zero for empty transaction)
429   std::list<Transaction> myTransactions;
430   //! list of info about transactions undone (first is oldest undone)
431   std::list<Transaction> myRedos;
432
433   //! Optimization for finding the shape-label by topological naming names
434   //! The name -> list of labels where this name is appeared (the last created name is last here)
435   std::map<std::string, std::list<TDF_Label> > myNamingNames;
436   //! If it is true, features are not executed on update (on abort, undo, redo)
437   bool myExecuteFeatures;
438
439   bool myIsActive; ///< flag that stores the active/not active state
440
441   //! The selection feature, if needed
442   FeaturePtr mySelectionFeature;
443
444   bool myIsSetCurrentFeature; ///< flag that my current feature is changed right now (recursion)
445 };
446
447 #endif