Model_Document.h

// Copyright (C) 2014-2023  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef Model_Document_H_
#define Model_Document_H_
 
#include <Model.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Result.h>
#include <ModelAPI_ResultParameter.h>
 
#include <TDocStd_Document.hxx>
#include <map>
#include <set>
 
class Handle_Model_Document;
class Model_Objects;
class ModelAPI_AttributeSelectionList;
 
class Model_Document : public ModelAPI_Document
{
 public:
  MODEL_EXPORT virtual const std::string& kind() const {return myKind;}
 
  MODEL_EXPORT virtual bool load(
    const char* theDirName, const char* theFileName, DocumentPtr theThis);
 
  MODEL_EXPORT virtual bool importPart(const char* theFileName,
                                   std::list<std::shared_ptr<ModelAPI_Feature> >& theImported,
                                   bool theCheckOnly = false);
 
  MODEL_EXPORT virtual bool save(
    const char* theDirName, const char* theFileName, std::list<std::string>& theResults);
 
  MODEL_EXPORT virtual bool save(const char* theFilename,
    const std::list<std::shared_ptr<ModelAPI_Feature> >& theExportFeatures) const;
 
  MODEL_EXPORT virtual void close(const bool theForever = false);
 
  MODEL_EXPORT virtual void startOperation();
  MODEL_EXPORT virtual bool finishOperation();
  MODEL_EXPORT virtual void abortOperation();
  MODEL_EXPORT virtual bool isOperation() const;
  MODEL_EXPORT virtual bool isModified();
 
  MODEL_EXPORT virtual bool canUndo();
  MODEL_EXPORT virtual void undo();
  MODEL_EXPORT virtual bool canRedo();
  MODEL_EXPORT virtual void redo();
  MODEL_EXPORT virtual void clearUndoRedo();
 
  MODEL_EXPORT virtual FeaturePtr addFeature(std::string theID, const bool theMakeCurrent = true);
 
  MODEL_EXPORT virtual void refsToFeature(FeaturePtr theFeature,
                                          std::set<FeaturePtr>& theRefs,
                                          const bool isSendError = true);
 
  MODEL_EXPORT virtual void removeFeature(FeaturePtr theFeature);
 
  MODEL_EXPORT virtual void moveFeature(
    FeaturePtr theMoved, FeaturePtr theAfterThis, const bool theSplit = false);
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Object> objectByName(
    const std::string& theGroupID, const std::wstring& theName);
 
  MODEL_EXPORT virtual const int index(std::shared_ptr<ModelAPI_Object> theObject,
                                       const bool theAllowFolder = false);
 
  MODEL_EXPORT virtual std::shared_ptr<Model_Document> subDoc(int theDocID);
 
  MODEL_EXPORT virtual const int id() const
  {
    return myID;
  }
 
  MODEL_EXPORT virtual ObjectPtr object(const std::string& theGroupID,
                                        const int theIndex,
                                        const bool theAllowFolder = false);
 
  MODEL_EXPORT virtual int size(const std::string& theGroupID, const bool theAllowFolder = false);
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Object> parent(
    const std::shared_ptr<ModelAPI_Object> theChild);
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> currentFeature(const bool theVisible);
 
  MODEL_EXPORT virtual void setCurrentFeature(std::shared_ptr<ModelAPI_Feature> theCurrent,
    const bool theVisible);
 
  MODEL_EXPORT virtual void setCurrentFeatureUp();
 
  MODEL_EXPORT virtual int numInternalFeatures();
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> internalFeature(const int theIndex);
  MODEL_EXPORT virtual void synchronizeTransactions();
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultConstruction> createConstruction(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultBody> createBody(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultPart> createPart(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultPart> copyPart(
    const std::shared_ptr<ModelAPI_ResultPart>& theOrigin,
    const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultGroup> createGroup(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultField> createField(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_ResultParameter> createParameter(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature>
    feature(const std::shared_ptr<ModelAPI_Result>& theResult);
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> addFolder(
      std::shared_ptr<ModelAPI_Feature> theAddBefore = std::shared_ptr<ModelAPI_Feature>());
  MODEL_EXPORT virtual void removeFolder(std::shared_ptr<ModelAPI_Folder> theFolder);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> findFolderAbove(
      const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> findFolderBelow(
      const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures);
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Folder> findContainingFolder(
      const std::shared_ptr<ModelAPI_Feature>& theFeature,
      int& theIndexInFolder);
  MODEL_EXPORT virtual bool moveToFolder(
      const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
      const std::shared_ptr<ModelAPI_Folder>& theFolder);
  MODEL_EXPORT virtual bool removeFromFolder(
      const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
      const bool theBefore = true);
 
  bool executeFeatures() {return myExecuteFeatures;}
 
  void setExecuteFeatures(const bool theFlag);
 
  void addNamingName(const TDF_Label theLabel, std::wstring theName);
  void changeNamingName(std::wstring theOldName, const std::wstring theNewName,
    const TDF_Label& theLabel);
  TDF_Label findNamingName(std::wstring theName, ResultPtr theContext);
  int numberOfNameInHistory(const ObjectPtr& theNameObject, const TDF_Label& theStartFrom);
  ResultPtr findByName(std::wstring& theName,
                       std::wstring& theSubShapeName,
                       bool& theUniqueContext);
 
  MODEL_EXPORT virtual std::list<std::shared_ptr<ModelAPI_Feature> > allFeatures();
 
  MODEL_EXPORT virtual std::list<std::shared_ptr<ModelAPI_Object> > allObjects();
 
  MODEL_EXPORT virtual int transactionID();
  MODEL_EXPORT virtual void incrementTransactionID();
 
  MODEL_EXPORT virtual bool isOpened();
 
  FeaturePtr lastFeature();
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> producedByFeature(
    std::shared_ptr<ModelAPI_Result> theResult,
    const std::shared_ptr<GeomAPI_Shape>& theShape);
 
  MODEL_EXPORT virtual bool isLater(FeaturePtr theLater, FeaturePtr theCurrent) const;
 
  MODEL_EXPORT virtual void eraseAllFeatures();
 
  MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Feature> nextFeature(
    std::shared_ptr<ModelAPI_Feature> theCurrent, const bool theReverse = false) const;
 
  ~Model_Document();
 
 protected:
  TDF_Label generalLabel() const;
 
  Model_Document(const int theID, const std::string theKind);
 
  Handle_TDocStd_Document document()
  {
    return myDoc;
  }
 
  void compactNested();
 
  const std::set<int> subDocuments() const;
 
  void undoInternal(const bool theWithSubs, const bool theSynchronize);
 
  void operationId(const std::string& theId);
 
  std::list<std::string> undoList() const;
 
  std::list<std::string> redoList() const;
 
  virtual void updateHistory(const std::shared_ptr<ModelAPI_Object> theObject);
  virtual void updateHistory(const std::string theGroup);
 
  bool isRoot() const;
 
  void setThis(DocumentPtr theDoc);
 
  Model_Objects* objects() {return myObjs;}
 
  virtual void setActive(const bool theFlag);
  virtual bool isActive() const;
 
  std::shared_ptr<ModelAPI_AttributeSelectionList> selectionInPartFeature();
 
  virtual void storeNodesState(const std::list<bool>& theStates);
 
  virtual void restoreNodesState(std::list<bool>& theStates) const;
 
  TDF_Label extConstructionsLabel() const;
 
  FeaturePtr featureByLab(const TDF_Label& theLab);
  ResultPtr resultByLab(const TDF_Label& theLab);
 
  bool isLaterByDep(FeaturePtr theThis, FeaturePtr theOther);
 
  void appendTransactionToPrevious();
 
  void setAutoRecomutationState(const bool theState);
  bool autoRecomutationState() const;
 
  friend class Model_Application;
  friend class Model_Session;
  friend class Model_Update;
  friend class Model_AttributeReference;
  friend class Model_AttributeRefAttr;
  friend class Model_AttributeRefList;
  friend class Model_AttributeRefAttrList;
  friend class Model_AttributeSelection;
  friend class Model_AttributeSelectionList;
  friend class Model_ResultPart;
  friend class Model_ResultBody;
  friend class Model_ResultConstruction;
  friend class Model_SelectionNaming;
  friend class Model_BodyBuilder;
  friend class DFBrowser;
 
 private:
  int myID;  
  std::string myKind;  
  Handle_TDocStd_Document myDoc;  
 
  Model_Objects *myObjs; 
 
  int myTransactionSave;
  std::list<int> myNestedNum;
 
  struct Transaction {
    int myOCAFNum; 
    std::string myId; 
    Transaction(): myOCAFNum(0), myId("") {}
  };
 
  std::list<Transaction> myTransactions;
  std::list<Transaction> myRedos;
 
  std::map<std::wstring, std::list<TDF_Label> > myNamingNames;
  bool myExecuteFeatures;
 
  bool myIsActive; 
 
  FeaturePtr mySelectionFeature;
 
  bool myIsSetCurrentFeature; 
};
 
#endif