Model_Objects.h

// Copyright (C) 2014-2025  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_Objects_H_
#define Model_Objects_H_
 
#include <Model.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Folder.h>
#include <ModelAPI_Result.h>
#include <ModelAPI_ResultParameter.h>
 
#include <NCollection_DataMap.hxx>
#include <TDF_Label.hxx>
#include <TDF_LabelList.hxx>
#include <map>
#include <set>
#include <vector>
 
extern int kUNDEFINED_FEATURE_INDEX;
 
class Model_Objects
{
 public:
  void addFeature(FeaturePtr theFeature, const FeaturePtr theAfterThis);
 
  void refsToFeature(FeaturePtr theFeature,
                     std::set<FeaturePtr>& theRefs,
                     const bool isSendError = true);
 
  void removeFeature(FeaturePtr theFeature);
 
  void moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis);
 
  FeaturePtr feature(TDF_Label theLabel) const;
 
  ObjectPtr object(TDF_Label theLabel);
 
  std::shared_ptr<ModelAPI_Object> objectByName(
    const std::string& theGroupID, const std::wstring& theName);
 
  ResultPtr findByName(const std::wstring theName);
 
 
  const int index(std::shared_ptr<ModelAPI_Object> theObject,
                  const bool theAllowFolder = false);
 
  ObjectPtr object(const std::string& theGroupID,
                   const int theIndex,
                   const bool theAllowFolder = false);
 
  int size(const std::string& theGroupID, const bool theAllowFolder = false);
 
  std::shared_ptr<ModelAPI_Object> parent(const std::shared_ptr<ModelAPI_Object> theChild);
 
  void allResults(const std::string& theGroupID, std::list<ResultPtr>& theResults);
 
  int numInternalFeatures();
  std::shared_ptr<ModelAPI_Feature> internalFeature(const int theIndex);
 
  std::shared_ptr<ModelAPI_ResultConstruction> createConstruction(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  std::shared_ptr<ModelAPI_ResultBody> createBody(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0,
      const std::wstring& theNameShape = L"");
  std::shared_ptr<ModelAPI_ResultPart> createPart(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  std::shared_ptr<ModelAPI_ResultPart> copyPart(
      const std::shared_ptr<ModelAPI_ResultPart>& theOrigin,
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  std::shared_ptr<ModelAPI_ResultGroup> createGroup(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  std::shared_ptr<ModelAPI_ResultField> createField(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
  std::shared_ptr<ModelAPI_ResultParameter> createParameter(
      const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
 
  std::shared_ptr<ModelAPI_Feature>
    feature(const std::shared_ptr<ModelAPI_Result>& theResult);
 
  std::shared_ptr<ModelAPI_Folder> createFolder(
      const std::shared_ptr<ModelAPI_Feature>& theBeforeThis);
  void removeFolder(std::shared_ptr<ModelAPI_Folder> theFolder);
  std::shared_ptr<ModelAPI_Folder> findFolder(
      const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
      const bool theBelow);
  std::shared_ptr<ModelAPI_Folder> findContainingFolder(
      const std::shared_ptr<ModelAPI_Feature>& theFeature,
      int& theIndexInFolder);
  bool moveToFolder(const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
                    const std::shared_ptr<ModelAPI_Folder>& theFolder);
  bool removeFromFolder(const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
                        const bool theBefore = true);
 
  void storeSubShapeWithColor(std::shared_ptr<ModelAPI_Result> theResult,
                              std::shared_ptr<GeomAPI_Shape>   theSubShape,
                              const std::vector<int>&          theColor);
 
  std::vector<int> getSubShapeColor(std::shared_ptr<ModelAPI_Result> theResult,
                                    std::shared_ptr<GeomAPI_Shape>   theSubShape);
 
  void getColoredSubShapes(const std::shared_ptr<ModelAPI_Result> theResult,
    std::map<std::shared_ptr<GeomAPI_Shape>, std::vector<int>>& theColoredSubShapes);
 
  void removeSubShapeColors(const std::shared_ptr<ModelAPI_Result> theResult);
 
  void setOwner(DocumentPtr theDoc);
 
  DocumentPtr owner() {return myDoc;}
 
  virtual ~Model_Objects();
 
 protected:
 
  TDF_Label featuresLabel() const;
 
  //TDF_Label shapesFromResult(std::shared_ptr<ModelAPI_Result> theResult) const;
  TDF_Label coloredSubShapesLabel(std::shared_ptr<ModelAPI_Result> theResult) const;
 
  TDF_Label coloredSubShapeLabel(TDF_Label& theSubShapesLabel,
                                 const int  theSubShapeIndex);
 
  const int coloredSubShapeIndex(std::shared_ptr<ModelAPI_Result> theResult,
                                 std::shared_ptr<GeomAPI_Shape>   theSubShape);
 
  void setUniqueName(FeaturePtr theFeature);
 
  void setUniqueName(FolderPtr theFolder);
 
  void synchronizeFeatures(const TDF_LabelList& theUpdated, const bool theUpdateReferences,
    const bool theOpen, const bool theExecuteFeatures, const bool theFlush);
  void synchronizeBackRefs();
 
  Model_Objects(TDF_Label theMainLab);
 
  void initData(ObjectPtr theObj, TDF_Label theLab, const int theTag);
 
  void storeResult(std::shared_ptr<ModelAPI_Data> theFeatureData,
                   std::shared_ptr<ModelAPI_Result> theResult,
                   const int theResultIndex = 0,
                   const std::wstring& theNameShape = L"");
 
  TDF_Label resultLabel(const std::shared_ptr<ModelAPI_Data>& theFeatureData,
                        const int theResultIndex);
 
  void updateResults(FeaturePtr theFeature, std::set<FeaturePtr>& theProcessed);
 
  void updateHistory(const std::shared_ptr<ModelAPI_Object> theObject);
 
  void updateHistory(const std::string theGroup);
 
  void clearHistory(ObjectPtr theObj);
 
  void createHistory(const std::string& theGroupID);
 
  FeaturePtr nextFeature(FeaturePtr theCurrent, int& theIndex, const bool theReverse = false);
  FeaturePtr firstFeature();
  FeaturePtr lastFeature();
  bool isLater(FeaturePtr theLater, FeaturePtr theCurrent) const;
 
  TDF_Label nextLabel(TDF_Label theCurrent, int& theIndex, const bool theReverse = false);
 
  std::string featureResultGroup(FeaturePtr theFeature);
 
  std::list<std::shared_ptr<ModelAPI_Feature> > allFeatures();
 
  std::list<std::shared_ptr<ModelAPI_Object> > allObjects();
 
  void synchronizeBackRefsForObject(
    const std::set<std::shared_ptr<ModelAPI_Attribute>>& theNewRefs, ObjectPtr theObject);
 
  virtual void eraseAllFeatures();
 
  // Check whether the predefined-image of the result had user-defined name.
  // If yes, return this name.
  bool hasCustomName(DataPtr theFeatureData,
                     ResultPtr theResult,
                     int theResultIndex,
                     std::wstring& theParentName) const;
 
  const ObjectPtr& folder(TDF_Label theLabel) const;
 
 private:
  TDF_Label myMain; 
 
  DocumentPtr myDoc; 
 
  NCollection_DataMap<TDF_Label, FeaturePtr> myFeatures;
 
  NCollection_DataMap<TDF_Label, ObjectPtr> myFolders;
 
  std::map<std::string, std::vector<ObjectPtr> > myHistory;
 
  friend class Model_Document;
  friend class Model_Session;
  friend class Model_Update;
  friend class Model_AttributeReference;
  friend class Model_AttributeRefAttr;
  friend class Model_AttributeRefList;
  friend class Model_AttributeSelection;
  friend class Model_SelectionNaming;
};
 
#endif