-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
-
-// File: Model_Objects.h
-// Created: 15 May 2015
-// Author: Mikhail PONIKAROV
+// 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_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 <TDocStd_Document.hxx>
#include <NCollection_DataMap.hxx>
#include <TDF_Label.hxx>
+#include <TDF_LabelList.hxx>
#include <map>
#include <set>
#include <vector>
-// for TDF_Label map usage
-static Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper);
-static Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2);
+extern int kUNDEFINED_FEATURE_INDEX;
/**\class Model_Objects
* \ingroup DataModel
class Model_Objects
{
public:
- //! Registers the fieature in the data structure
+ //! Registers the feature in the data structure
//! \param theFeature feature that must be added to the data structure
- //! \param theAfterThis the feature will be added after this feature;
+ //! \param theAfterThis the feature will be added after this feature;
//! if it is null, the added feature will be the first
void addFeature(FeaturePtr theFeature, const FeaturePtr theAfterThis);
//! \param theFeature a removed feature
void removeFeature(FeaturePtr theFeature);
+ //! Moves the feature to make it after the given one in the history.
+ void moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis);
+
//! Returns the existing feature by the label
//! \param theLabel base label of the feature
FeaturePtr feature(TDF_Label theLabel) const;
//! \param theName name of the object to search
//! \returns null if such object is not found
std::shared_ptr<ModelAPI_Object> objectByName(
- const std::string& theGroupID, const std::string& theName);
+ const std::string& theGroupID, const std::wstring& theName);
//! Returns the result by the result name
- ResultPtr findByName(const std::string theName);
+ ResultPtr findByName(const std::wstring theName);
//! Returns the object index in the group. Object must be visible. Otherwise returns -1.
//! \param theObject object of this document
+ //! \param theAllowFolder take into account grouping feature by folders
//! \returns index started from zero, or -1 if object is invisible or belongs to another document
- const int index(std::shared_ptr<ModelAPI_Object> theObject);
+ const int index(std::shared_ptr<ModelAPI_Object> theObject,
+ const bool theAllowFolder = false);
//! Returns the feature in the group by the index (started from zero)
//! \param theGroupID group that contains a feature
//! \param theIndex zero-based index of feature in the group
- ObjectPtr object(const std::string& theGroupID, const int theIndex);
+ //! \param theAllowFolder take into account grouping feature by folders
+ ObjectPtr object(const std::string& theGroupID,
+ const int theIndex,
+ const bool theAllowFolder = false);
//! Returns the number of features in the group
- int size(const std::string& theGroupID);
+ //! \param theGroupID group of objects
+ //! \param theAllowFolder take into account grouping feature by folders
+ int size(const std::string& theGroupID, const bool theAllowFolder = false);
+
+ //! Returns the parent object of this child. This may be result or feature, parent of a
+ //! top result. Fast method, that uses internal data structure specifics.
+ std::shared_ptr<ModelAPI_Object> parent(const std::shared_ptr<ModelAPI_Object> theChild);
- ///! Returns all (and disabled) results of the given type. Not fast method (iterates all features).
+ //! Returns all (and disabled) results of the given type.
+ //! Not fast method (iterates all features).
void allResults(const std::string& theGroupID, std::list<ResultPtr>& theResults);
- /// Creates a construction cresults
+ //! Returns the number of all features: in the history or not
+ int numInternalFeatures();
+ //! Returns the feature by zero-based index: features in the history or not
+ std::shared_ptr<ModelAPI_Feature> internalFeature(const int theIndex);
+
+ /// Creates a construction result
std::shared_ptr<ModelAPI_ResultConstruction> createConstruction(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
- /// Creates a body results
+ /// Creates a body result
std::shared_ptr<ModelAPI_ResultBody> createBody(
- const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
- /// Creates a part results
+ const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0,
+ const std::wstring& theNameShape = L"");
+ /// Creates a part result
std::shared_ptr<ModelAPI_ResultPart> createPart(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
- /// Creates a group results
+ /// Copies a part result, keeping the reference to origin
+ std::shared_ptr<ModelAPI_ResultPart> copyPart(
+ const std::shared_ptr<ModelAPI_ResultPart>& theOrigin,
+ const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
+ /// Creates a group result
std::shared_ptr<ModelAPI_ResultGroup> createGroup(
const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
-
+ /// Creates a field result
+ std::shared_ptr<ModelAPI_ResultField> createField(
+ const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theIndex = 0);
+ /// Creates a parameter result
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);
+ /// Creates a folder (group of the features in the object browser)
+ std::shared_ptr<ModelAPI_Folder> createFolder(
+ const std::shared_ptr<ModelAPI_Feature>& theBeforeThis);
+ //! Removes the folder from the document (all features in the folder will be kept).
+ void removeFolder(std::shared_ptr<ModelAPI_Folder> theFolder);
+ //! Search a folder applicable for the list of features
+ //! (it means the list of features stored in the folder should be consequential)
+ //! \param theFeatures list of features to be added to folder
+ //! \param theBelow search the folder below the features (if \c false, search above)
+ //! \return Empty pointer if there is no applicable folder
+ std::shared_ptr<ModelAPI_Folder> findFolder(
+ const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
+ const bool theBelow);
+ //! Search a folder containing the given feature.
+ //! Additionally calculates a zero-based index of the feature in this folder.
+ //! \param theFeature feature to search
+ //! \param theIndexInFolder zero-based index in the folder or -1 if the feature is top-level.
+ //! \return the folder containing the feature or empty pointer if the feature is top-level.
+ std::shared_ptr<ModelAPI_Folder> findContainingFolder(
+ const std::shared_ptr<ModelAPI_Feature>& theFeature,
+ int& theIndexInFolder);
+ //! Add a list of features to the folder. The correctness of the adding is not performed
+ //! (such checks have been done in corresponding find.. method).
+ //! \return \c true if the movement is successful
+ bool moveToFolder(const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
+ const std::shared_ptr<ModelAPI_Folder>& theFolder);
+ //! Remove features from the folder
+ //! \param theFeatures list of features to be removed
+ //! \param theBefore extract features before the folder (this parameter is applicable only
+ //! when all features in the folder are taking out,
+ //! in other cases the direction is taken automatically)
+ //! \return \c true if the features have been moved out
+ bool removeFromFolder(const std::list<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
+ const bool theBefore = true);
+
//! Sets the owner of this manager
void setOwner(DocumentPtr theDoc);
//! Returns the owner of this manager
DocumentPtr owner() {return myDoc;}
- //! Deletes all managed features wit hemmitting of corresponded signal
- ~Model_Objects();
+ //! Deletes all managed features with emitting of corresponded signal
+ virtual ~Model_Objects();
protected:
//! Returns (creates if needed) the features label
TDF_Label featuresLabel() const;
- //! Initializes feature with a unique name in this group (unique name is generated as
+ //! Initializes feature with a unique name in this group (unique name is generated as
//! feature type + "_" + index
void setUniqueName(FeaturePtr theFeature);
+ //! Initializes the folder with an unique name ("Folder_" + index)
+ void setUniqueName(FolderPtr theFolder);
+
//! Synchronizes myFeatures list with the updated document
- //! \param theMarkUpdated causes the "update" event for all features
+ //! \param theUpdated list of labels that are marked as modified, so features must be also
//! \param theUpdateReferences causes the update of back-references
+ //! \param theExecuteFeatures requires re-execute modified persistent features
+ //! (not needed on undo/redo/abort/open)
+ //! \param theOpen - on open nothing must be re-executed, except not persistent results
//! \param theFlush makes flush all events in the end of all modifications of this method
- void synchronizeFeatures(const bool theMarkUpdated, const bool theUpdateReferences,
- const bool theFlush);
+ void synchronizeFeatures(const TDF_LabelList& theUpdated, const bool theUpdateReferences,
+ const bool theOpen, const bool theExecuteFeatures, const bool theFlush);
//! Synchronizes the BackReferences list in Data of Features and Results
void synchronizeBackRefs();
//! Initializes the data fields of the feature
void initData(ObjectPtr theObj, TDF_Label theLab, const int theTag);
- //! Allows to store the result in the data tree of the document (attaches 'data' of result to tree)
+ //! Allows to store the result in the data tree of the document
+ //! (attaches 'data' of result to tree)
void storeResult(std::shared_ptr<ModelAPI_Data> theFeatureData,
std::shared_ptr<ModelAPI_Result> theResult,
- const int theResultIndex = 0);
+ const int theResultIndex = 0,
+ const std::wstring& theNameShape = L"");
//! returns the label of result by index; creates this label if it was not created before
- TDF_Label resultLabel(const std::shared_ptr<ModelAPI_Data>& theFeatureData, const int theResultIndex);
+ TDF_Label resultLabel(const std::shared_ptr<ModelAPI_Data>& theFeatureData,
+ const int theResultIndex);
//! Updates the results list of the feature basing on the current data tree
- void updateResults(FeaturePtr theFeature);
+ //! theProcessed is used to avoid update twice (since the function is recursive)
+ void updateResults(FeaturePtr theFeature, std::set<FeaturePtr>& theProcessed);
/// Internally makes document know that feature was removed or added in history after creation
void updateHistory(const std::shared_ptr<ModelAPI_Object> theObject);
/// Creates the history: up to date with the current state
void createHistory(const std::string& theGroupID);
- /// Returns to the next (from the history point of view) feature, any: invisible or disabled
- /// \param theReverse if it is true, iterates in reverced order (next becomes previous)
- FeaturePtr nextFeature(FeaturePtr theCurrent, const bool theReverse = false);
+ /// Returns the next (from the history point of view) feature, any: invisible or disabled
+ /// \param theCurrent previous to the resulting feature
+ /// \param theReverse if it is true, iterates in reversed order (next becomes previous)
+ /// \param theIndex may be used for optimization: index of theCurrent in references array
+ FeaturePtr nextFeature(FeaturePtr theCurrent, int& theIndex, const bool theReverse = false);
/// Returns to the first (from the history point of view) feature, any: invisible or disabled
FeaturePtr firstFeature();
/// Returns to the last (from the history point of view) feature, any: invisible or disabled
FeaturePtr lastFeature();
+ /// Returns true if theLater is in history of features creation later than theCurrent
+ bool isLater(FeaturePtr theLater, FeaturePtr theCurrent) const;
+
+ /// Returns the next or previous label
+ /// \param theCurrent given label
+ /// \param theReverse if it is true, iterates in reversed order (next becomes previous)
+ TDF_Label nextLabel(TDF_Label theCurrent, int& theIndex, const bool theReverse = false);
+
+ /// Returns the result group identifier of the given feature (for this at least one result must
+ /// be created before)
+ std::string featureResultGroup(FeaturePtr theFeature);
+
+ //! Returns all features of the document including the hidden features which are not in
+ //! history. Not very fast method, for calling once, not in big cycles.
+ std::list<std::shared_ptr<ModelAPI_Feature> > allFeatures();
+
+ //! Returns all objects of the document including the hidden features which are not in
+ //! history. Not very fast method, for calling once, not in big cycles.
+ std::list<std::shared_ptr<ModelAPI_Object> > allObjects();
+
+ //! synchronizes back references for the given object basing on the collected data
+ void synchronizeBackRefsForObject(
+ const std::set<std::shared_ptr<ModelAPI_Attribute>>& theNewRefs, ObjectPtr theObject);
+
+ /// Just removes all features without touching the document data (to be able undo)
+ 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;
+
+ /// Return object representing a folder or empty pointer
+ const ObjectPtr& folder(TDF_Label theLabel) const;
private:
TDF_Label myMain; ///< main label of the data storage
- DocumentPtr myDoc; ///< doc,ument, owner of this objects manager: needed for events creation
+ DocumentPtr myDoc; ///< document, owner of this objects manager: needed for events creation
/// All managed features (not only in history of OB)
/// For optimization mapped by labels
NCollection_DataMap<TDF_Label, FeaturePtr> myFeatures;
+ /// Managed folders
+ NCollection_DataMap<TDF_Label, ObjectPtr> myFolders;
+
/// Map from group id to the array that contains all objects located in history.
- /// Each array is updated by demand from scratch, by browing all the features in the history.
+ /// Each array is updated by demand from scratch, by browsing all the features in the history.
std::map<std::string, std::vector<ObjectPtr> > myHistory;
friend class Model_Document;
friend class Model_AttributeReference;
friend class Model_AttributeRefAttr;
friend class Model_AttributeRefList;
+ friend class Model_AttributeSelection;
+ friend class Model_SelectionNaming;
};
#endif
