{
data()->addAttribute(OBJECTS(), ModelAPI_AttributeSelectionList::typeId());
data()->addAttribute(NUMBER(), ModelAPI_AttributeInteger::typeId());
+
+ AttributeIntegerPtr aNameNumAttr = std::dynamic_pointer_cast<ModelAPI_AttributeInteger>(
+ data()->addAttribute(NAME_SUFFIX(), ModelAPI_AttributeInteger::typeId()));
+ if (!aNameNumAttr->isInitialized()){
+ aNameNumAttr->setValue(0);
+ }
}
static GeomShapePtr shapeOfSelection(AttributeSelectionPtr theSel) {
std::wstring aBaseName = aSel->context() ? aSel->context()->data()->name() :
aSel->contextFeature()->firstResult()->data()->name();
std::wstring aName;
- int anInd = 0;
+ int aNameNum = integer(NAME_SUFFIX())->value();
+ int anInd = aNameNum;
do {
anInd++;
std::wostringstream aNameStr;
std::shared_ptr<ModelAPI_ResultBody> aResultBody =
document()->createBody(data(), aResultIndex);
- aResultBody->data()->setName(aName);
+ aResultBody->data()->setName(aName, false);
// to make sub-results also names with a similar name temporarily rename the feature
std::wstring anOrigName = name();
- data()->setName(aBaseName);
+ data()->setName(aBaseName, false);
aResultBody->store(aResult);
- data()->setName(anOrigName);
+ data()->setName(anOrigName, false);
aResultBody->loadFirstLevel(aResult, "Copy");
setResult(aResultBody, aResultIndex++);
}
/// \ingroup Plugins
/// \brief This feature copies the selected results and sub-results (for the whole feature selected
/// all results of this feature are copied). The referenced arguments of this feature are
-/// not concealed. The difference with \94Recover\94 feature is that not concealed results may
-/// be selected and in the history behavior: the \93Move to the End\94 of groups will move to
+/// not concealed. The difference with �Recover� feature is that not concealed results may
+/// be selected and in the history behavior: the �Move to the End� of groups will move to
/// all copy-results.
class FeaturesPlugin_Copy : public ModelAPI_Feature, public ModelAPI_FeatureCopyInterface
return MY_NUMBER;
}
+ /// Integer attribute that contains the number of copies of original object that was created before
+ /// (used for creating copies of persistent object)
+ inline static const std::string NAME_SUFFIX()
+ {
+ static std::string MY_NAME_NUMBER("name_suffix");
+ return MY_NAME_NUMBER;
+ }
+
/// Performs the algorithm and stores results it in the data structure.
FEATURESPLUGIN_EXPORT virtual void execute();
return face()->isSameGeometry(theShape);
else if (isEdge())
return edge()->isSameGeometry(theShape);
+ else if (isVertex())
+ return vertex()->isEqual(theShape);
+ else
+ {
+ //check only bounding boxes and amounts of subshapes
+ return isProbablySameGeometry(theShape);
+ }
return false;
}
+bool GeomAPI_Shape::isSameSize(const std::shared_ptr<GeomAPI_Shape> theShape) const
+{
+ if (!theShape.get())
+ return false;
+
+ if(theShape->shapeType() != shapeType())
+ return false;
+
+ double aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ;
+ computeSize(aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ);
+
+ double aSMinX, aSMinY, aSMinZ, aSMaxX, aSMaxY, aSMaxZ;
+ theShape->computeSize(aSMinX, aSMinY, aSMinZ, aSMaxX, aSMaxY, aSMaxZ);
+
+ if(fabs(aMinX-aSMinX) > Precision::Confusion() ||
+ fabs(aMinY-aSMinY) > Precision::Confusion() ||
+ fabs(aMinZ-aSMinZ) > Precision::Confusion() ||
+ fabs(aMaxX-aSMaxX) > Precision::Confusion() ||
+ fabs(aMaxY-aSMaxY) > Precision::Confusion() ||
+ fabs(aMaxZ-aSMaxZ) > Precision::Confusion()){
+ return false;
+ }
+ return true;
+
+}
+
+bool GeomAPI_Shape::isSameAmountOfSubs(const std::shared_ptr<GeomAPI_Shape> theShape) const
+{
+ if (!theShape.get())
+ return false;
+
+ if(theShape->shapeType() != shapeType())
+ return false;
+
+
+ if(theShape->subShapes(GeomAPI_Shape::COMPOUND).size() != subShapes(GeomAPI_Shape::COMPOUND).size() ||
+ theShape->subShapes(GeomAPI_Shape::COMPSOLID).size() != subShapes(GeomAPI_Shape::COMPSOLID).size() ||
+ theShape->subShapes(GeomAPI_Shape::SOLID).size() != subShapes(GeomAPI_Shape::SOLID).size() ||
+ theShape->subShapes(GeomAPI_Shape::SHELL).size() != subShapes(GeomAPI_Shape::SHELL).size() ||
+ theShape->subShapes(GeomAPI_Shape::FACE).size() != subShapes(GeomAPI_Shape::FACE).size() ||
+ theShape->subShapes(GeomAPI_Shape::WIRE).size() != subShapes(GeomAPI_Shape::WIRE).size() ||
+ theShape->subShapes(GeomAPI_Shape::EDGE).size() != subShapes(GeomAPI_Shape::EDGE).size() ||
+ theShape->subShapes(GeomAPI_Shape::VERTEX).size() != subShapes(GeomAPI_Shape::VERTEX).size()){
+ return false;
+ }
+ return true;
+}
+
+bool GeomAPI_Shape::isProbablySameGeometry(const std::shared_ptr<GeomAPI_Shape> theShape) const
+{
+ if (!theShape.get())
+ return false;
+
+ if(theShape->shapeType() != shapeType())
+ return false;
+
+ if(!isSameAmountOfSubs(theShape) || !isSameSize(theShape))
+ return false;
+
+ return true;
+}
+
bool GeomAPI_Shape::isVertex() const
{
const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
GEOMAPI_EXPORT
virtual bool isSame(const std::shared_ptr<GeomAPI_Shape> theShape) const;
- /// Returns \c true if shapes have same underlying geometry
+ /// Returns \c true if shapes have same underlying geometry (vertex,edge,face only)
GEOMAPI_EXPORT
virtual bool isSameGeometry(const std::shared_ptr<GeomAPI_Shape> theShape) const;
+ /// Returns \c true if bounding boxes of the shapes are equal (compared shapes should be the same type)
+ GEOMAPI_EXPORT
+ virtual bool isSameSize(const std::shared_ptr<GeomAPI_Shape> theShape) const;
+
+ /// Returns \c true if shapes have the same amounts of each type of subshapes (compared shapes should be the same type)
+ GEOMAPI_EXPORT
+ virtual bool isSameAmountOfSubs(const std::shared_ptr<GeomAPI_Shape> theShape) const;
+
+ /// Returns \c true if shapes (probably) have same underlying geometry (shell, solid, compound, compsolid)
+ /// Compare bounding boxes and amounts of subshapes
+ GEOMAPI_EXPORT
+ virtual bool isProbablySameGeometry(const std::shared_ptr<GeomAPI_Shape> theShape) const;
+
/// Returns whether the shape is a vertex
GEOMAPI_EXPORT
virtual bool isVertex() const;
#include <Geom_TrimmedCurve.hxx>
#include <BRep_Builder.hxx>
+#include <utility>
+
//#define DEB_NAMING 1
#ifdef DEB_NAMING
#include <BRepTools.hxx>
ModelAPI_AttributeSelection::reset();
myRef.reset();
}
+
+bool Model_AttributeSelection::isCopyToSwallow()
+{
+ ResultPtr aContext = context();
+ if (aContext.get())
+ {
+ return ModelAPI_Tools::isCopyToSwallow(aContext);
+ }
+ return false;
+}
+
+std::pair<ResultPtr, std::shared_ptr<GeomAPI_Shape>> Model_AttributeSelection::getOriginalContext()
+{
+ auto aThisPair = std::make_pair(context(), value());
+ if(!isCopyToSwallow())
+ return aThisPair;
+
+ ResultPtr aCopyContext = context();
+ ObjectPtr anOriginalObject = ModelAPI_Tools::getOriginalObject(aCopyContext);
+
+
+ ResultPtr anOriginaResult = std::dynamic_pointer_cast<ModelAPI_Result>(anOriginalObject); //it should be original object
+ GeomShapePtr aGeomObj = value();
+ GeomAPI_Shape::ShapeType aCurType = aGeomObj->shapeType();
+ ListOfShape anOrigSubs = anOriginaResult->shape()->subShapes(aCurType,true);
+ for(auto anOrigSub: anOrigSubs)
+ {
+ if(anOrigSub->isSameGeometry(aGeomObj))
+ {
+ return std::make_pair(anOriginaResult, anOrigSub);
+ }
+ }
+
+ return aThisPair;
+}
\ No newline at end of file
/// Resets attribute to deafult state
MODEL_EXPORT virtual void reset();
+ /// Return true if context of the atribute is a copy of persistent result
+ MODEL_EXPORT virtual bool isCopyToSwallow();
+
+ /// Return original context and shape of this copy atribute
+ MODEL_EXPORT virtual std::pair<ResultPtr, std::shared_ptr<GeomAPI_Shape>> getOriginalContext();
+
protected:
/// Objects are created for features automatically
MODEL_EXPORT Model_AttributeSelection(TDF_Label& theLabel);
#include <TNaming_NamedShape.hxx>
#include <NCollection_List.hxx>
+
/// GUID for UAttribute that indicates the list has "To add all elements that share the same
/// topology" flag enabled
static const Standard_GUID kIS_GEOMETRICAL_SELECTION("f16987b6-e6c8-435c-99fa-03a7e0b06e83");
// remove attribute if something is wrong
myLab.ForgetAttribute(TDataStd_ReferenceList::GetID());
}
+
+bool Model_AttributeSelectionList::isContainCopiesToSwallow()
+{
+ for(int anIndex = size() - 1; anIndex >= 0; anIndex--)
+ {
+ AttributeSelectionPtr anAttr = value(anIndex);
+ if(anAttr->isCopyToSwallow())
+ {
+ return true;
+ }
+ }
+ return false;
+}
/// Sets a selection filters feature if it is defined for this selection list
MODEL_EXPORT virtual void setFilters(FiltersFeaturePtr theFeature);
+ /// Return true if contain at least one attr witch context is a copy of persistent result.
+ MODEL_EXPORT virtual bool isContainCopiesToSwallow();
+
protected:
/// Objects are created for features automatically
MODEL_EXPORT Model_AttributeSelectionList(TDF_Label& theLabel);
return L""; // not defined
}
-void Model_Data::setName(const std::wstring& theName)
+void Model_Data::setName(const std::wstring& theName, bool isUserDefined)
{
bool isModified = false;
std::wstring anOldName = name();
// check the name of result is defined by user
// (name of result does not composed of the name of feature and the result index)
- bool isUserDefined = true;
+ //bool isUserDefined = true;
ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
- if (aResult) {
+ if (aResult && isUserDefined) {
std::wstring aDefaultName = ModelAPI_Tools::getDefaultName(aResult, false).first;
isUserDefined = aDefaultName != theName;
}
/// Returns the name of the feature visible by the user in the object browser
MODEL_EXPORT virtual std::wstring name();
/// Defines the name of the feature visible by the user in the object browser
- MODEL_EXPORT virtual void setName(const std::wstring& theName);
+ MODEL_EXPORT virtual void setName(const std::wstring& theName, bool isUserDefined = true);
/// Return \c true if the object has been renamed by the user
MODEL_EXPORT virtual bool hasUserDefinedName() const;
/// Returns version of the feature (empty string if not applicable)
setCurrentFeature(aMain, false);
}
myObjs->synchronizeBackRefs();
+ processPersistentResult(true);
Events_Loop* aLoop = Events_Loop::loop();
static const Events_ID kCreatedEvent = aLoop->eventByName(EVENT_OBJECT_CREATED);
static const Events_ID kUpdatedEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED);
subDoc(*aSubIter)->abortOperation();
// references may be changed because they are set in attributes on the fly
myObjs->synchronizeFeatures(aDeltaLabels, true, false, false, isRoot());
+ processPersistentResult();
}
bool Model_Document::isOperation() const
{
return !generalLabel().FindChild(TAG_CURRENT_TRANSACTION).IsAttribute(kAutoRecomputationID);
}
+
+bool Model_Document::processPersistentResult(const bool isAddedNewCopy)
+{
+ std::list<FeaturePtr> aSubFeatures = allFeatures();
+ for(auto& aFeat: aSubFeatures){
+ if(aFeat->lastResult() && aFeat->lastResult()->isPersistent()){
+ ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aFeat->lastResult());
+ if(aBody)
+ aBody->nullifyTempCopy();
+
+ if(isAddedNewCopy)
+ ModelAPI_Tools::increaseCopyAmount(aFeat->lastResult());
+ }
+ }
+}
/// Returns the current automatic recomputation flag: true means enabled
bool autoRecomutationState() const;
+ /// Process persistent result: do some necessary actions with persistent results while finish/abort operation
+ bool processPersistentResult(const bool isAddedNewCopy = false);
+
friend class Model_Application;
friend class Model_Session;
friend class Model_Update;
}
}
-void Model_Objects::synchronizeBackRefs()
-{
+void Model_Objects::synchronizeBackRefs(){
// collect all back references in the separated container: to update everything at once,
// without additional Concealment switching on and off: only the final modification
// if this attribute exists, the connected topology flag must be recomputed
Standard_GUID kUpdateConnectedTopology("01ef7a45-0bec-4266-b0b4-4aa570921818");
+// consts for creating copy
+const std::string COPY_FEATURE = "Copy";
+const std::string COPY_ATTR_OBJECTS = "objects";
+const std::string COPY_ATTR_NUMBER = "number";
+const std::string COPY_ATTR_NAMESUF = "name_suffix";
+
Model_ResultBody::Model_ResultBody() : ModelAPI_ResultBody()
{
myBuilder = new Model_BodyBuilder(this);
myLastConcealed = false;
+ myTempCopy = nullptr;
+ myIsBlockedNewCopy = false;
updateSubs(shape()); // in case of open, etc.
}
}
}
+std::shared_ptr<ModelAPI_Result> Model_ResultBody::getCopyToSwallow()
+{
+ if(!isPersistent() || myIsBlockedNewCopy)
+ return nullptr;
+
+ std::shared_ptr<Model_Document> aDoc = std::dynamic_pointer_cast<Model_Document>(document());
+ if(!aDoc)
+ return nullptr;
+
+ if(myTempCopy)
+ return myTempCopy;
+
+ ResultPtr aCopyResult(nullptr);
+ FeaturePtr aCopyFeature = aDoc->addFeature(COPY_FEATURE);
+ if(aCopyFeature){
+ myIsBlockedNewCopy = true;
+ ResultPtr context = std::dynamic_pointer_cast<ModelAPI_Result>(shared_from_this());
+ aCopyFeature->selectionList(COPY_ATTR_OBJECTS)->append(context, shape());
+ aCopyFeature->integer(COPY_ATTR_NUMBER)->setValue(1);
+ aCopyFeature->integer(COPY_ATTR_NAMESUF)->setValue(ModelAPI_Tools::getCopyAmount(context));
+ aCopyFeature->setInHistory(aCopyFeature,false);
+ aCopyFeature->execute();
+ aCopyFeature->data()->execState(ModelAPI_StateDone);
+ aCopyResult = aCopyFeature->lastResult();
+ ModelAPI_Tools::setIsCopyToSwallow(aCopyResult, true);
+ ModelAPI_Tools::setOriginalObject(aCopyResult, context);
+ myTempCopy = aCopyResult;
+ myIsBlockedNewCopy = false;
+ }
+ return myTempCopy;
+}
+
+void Model_ResultBody::nullifyTempCopy()
+{
+ myTempCopy = nullptr;
+}
+
void Model_ResultBody::computeOldForSub(const GeomShapePtr& theSub,
const std::list<GeomShapePtr>& theAllOlds, std::list<GeomShapePtr>& theOldForSub)
{
* of result must be optimized.
* Also provides a container of sub-body result in case it is compound or compsolid.
*/
-class Model_ResultBody : public ModelAPI_ResultBody
+class Model_ResultBody : public ModelAPI_ResultBody, public std::enable_shared_from_this<Model_ResultBody>
{
/// Sub-bodies if this is compsolid or compound: zero-based index to subs
std::vector<ResultBodyPtr> mySubs;
bool myIsGenerated;
/// Map from old shape to list of new shapes, cash for computeOldForSub method
TopTools_DataMapOfShapeListOfShape myHistoryCash;
+ /// Store temporary copy of persistent result during one operation
+ std::shared_ptr<ModelAPI_Result> myTempCopy;
+ /// Auxiliary, helps to prevent creating copy when it is prohibited (for example prevent recursive copy)
+ bool myIsBlockedNewCopy;
public:
/// Returns empty vector if not found.
MODEL_EXPORT virtual const std::vector<int>& findShapeColor(const std::wstring& theShapeName);
+ /// For persistent result - creates/return a copy of this result, so the copy can be swallowed
+ /// by the new feature instead of original result
+ MODEL_EXPORT virtual std::shared_ptr<ModelAPI_Result> getCopyToSwallow();
+
+ MODEL_EXPORT virtual void nullifyTempCopy();
+
+
protected:
/// Makes a body on the given feature
Model_ResultBody();
#include <Model_Tools.h>
#include <Model_Data.h>
+#include <Model_Document.h>
#include <ModelAPI_Document.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Result.h>
#include <ModelAPI_Session.h>
+#include <ModelAPI_AttributeSelection.h>
+#include <ModelAPI_AttributeSelectionList.h>
+#include <ModelAPI_Tools.h>
+#include <GeomAPI_Shape.h>
#include <ConstructionPlugin_Axis.h>
#include <ConstructionPlugin_Plane.h>
}
}
}
+
+void Model_Tools::substituteSelectionWithCopy(FeaturePtr &theFeature, ResultPtr &theResult, AttributeSelectionPtr &theSelAttr)
+{
+ if(!theResult || !theResult->isPersistent() || !theSelAttr)
+ return;
+
+ //if the result of the feature already a copy to be swallowed - skip
+ if(ModelAPI_Tools::isCopyToSwallow(theFeature->lastResult()))
+ return;
+
+ ResultBodyPtr aBodyRes = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theResult);
+ ResultPtr aCopyResult = aBodyRes->getCopyToSwallow();
+
+ if(aCopyResult){
+ GeomShapePtr aGeomObj = theSelAttr->value();
+ GeomAPI_Shape::ShapeType aCurType = aGeomObj->shapeType();
+ ListOfShape aCopySubs = aCopyResult->shape()->subShapes(aCurType,true);
+ for(auto aCopySub: aCopySubs)
+ {
+ if(aCopySub->isSameGeometry(aGeomObj))
+ {
+ theSelAttr->setValue(aCopyResult, aCopySub);
+ return;
+ }
+ }
+ }
+}
#include <TDF_Label.hxx>
#include <TDF_RelocationTable.hxx>
+#include <ModelAPI_Result.h>
+#include <ModelAPI_Feature.h>
+#include <ModelAPI_AttributeSelection.h>
#include <memory>
#include <set>
static void labelsOfCoordinates(
std::set<TCollection_AsciiString>& theCoordinateLabels,
Handle(TDF_RelocationTable) theRelocTable);
+
+ /// Create a copy of persistent result and substitute the original selecttion attribute with a copy.
+ /// \param theFeature a feature that wants to swallow the result
+ /// \param theResult a persistent result to copy
+ /// \param theSelAttr an attribute to substitute
+ static void substituteSelectionWithCopy(FeaturePtr &theFeature, ResultPtr &theResult, AttributeSelectionPtr &theSelAttr);
};
#endif
#include <Model_Document.h>
#include <Model_Data.h>
#include <Model_Objects.h>
+#include <Model_Tools.h>
#include <ModelAPI_Feature.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Document.h>
if (!theFeature->data()->isValid())
return false; // delete an extrusion created on the sketch
-
bool isNotExecuted = theFeature->isPersistentResult() &&
!std::dynamic_pointer_cast<Model_Document>((theFeature)->document())->executeFeatures();
if (isNotExecuted) {
ObjectPtr aContext = aSel->context();
// update argument only if the referenced object is ready to use
if (aContext.get() && !aContext->isDisabled()) {
+ std::shared_ptr<ModelAPI_Result> resultPtr = std::dynamic_pointer_cast<ModelAPI_Result>(aContext);
+ if(resultPtr && resultPtr->isPersistent()){
+ Model_Tools::substituteSelectionWithCopy(theFeature, resultPtr, aSel);
+ }
if (isReason(theFeature, aContext)) {
+
if (!aSel->update()) { // this must be done on execution since it may be long operation
bool isObligatory = !aFactory->isNotObligatory(
theFeature->getKind(), theFeature->data()->id(aSel)) &&
std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(aSel->value(a));
if (aSelAttr) {
ObjectPtr aContext = aSelAttr->context();
+
+ std::shared_ptr<ModelAPI_Result> resultPtr = std::dynamic_pointer_cast<ModelAPI_Result>(aContext);
+ if(resultPtr && resultPtr->isPersistent()){
+ Model_Tools::substituteSelectionWithCopy(theFeature, resultPtr, aSelAttr);
+ }
+
// update argument only if the referenced object is ready to use
if (aContext.get() && !aContext->isDisabled()) {
if (isReason(theFeature, aContext)) {
#include <map>
class ModelAPI_Object;
+class ModelAPI_Result;
class ModelAPI_Feature;
class ModelAPI_CompositeFeature;
class Model_Objects;
#include "ModelAPI_Attribute.h"
#include <ModelAPI_Result.h>
+#include <utility>
+
class GeomAPI_Edge;
class GeomAPI_Pnt;
/// Returns theRemove true if this attribute must be removed (become deleted)
MODELAPI_EXPORT virtual void updateInHistory(bool& theRemove) = 0;
+ /// Return true if context of the atribute is a copy of persistent result
+ MODELAPI_EXPORT virtual bool isCopyToSwallow() = 0;
+
+ /// Return original context and shape of this copy atribute
+ MODELAPI_EXPORT virtual std::pair<ResultPtr, std::shared_ptr<GeomAPI_Shape>> getOriginalContext() = 0;
+
+
protected:
/// Objects are created for features automatically
MODELAPI_EXPORT ModelAPI_AttributeSelection();
#include <ModelAPI_Result.h>
#include <ModelAPI_Filter.h>
+#include <list>
+#include <utility>
+
class GeomAPI_Pnt;
class GeomAPI_Shape;
myMakeCopy = theFlag;
}
+ /// Return true if contain at least one attr witch context is a copy of persistent result.
+ MODELAPI_EXPORT virtual bool isContainCopiesToSwallow() = 0;
+
protected:
/// Default constructor
MODELAPI_EXPORT ModelAPI_AttributeSelectionList() : ModelAPI_Attribute()
/// Returns the name of the feature visible by the user in the object browser
virtual std::wstring name() = 0;
/// Defines the name of the feature visible by the user in the object browser
- virtual void setName(const std::wstring& theName) = 0;
+ virtual void setName(const std::wstring& theName, bool isUserDefined = true) = 0;
/// Return \c true if the object has been renamed by the user
virtual bool hasUserDefinedName() const = 0;
#include <ModelAPI_AttributeIntArray.h>
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeBoolean.h>
+#include <ModelAPI_AttributeInteger.h>
+#include <ModelAPI_AttributeReference.h>
#include <GeomAPI_Shape.h>
// Add the "Bring To Front" attribute to the Result base class, as we may support it in the future
// for all type of results. Actually, only ResultGroups are supported.
aData->addAttribute(BRING_TO_FRONT_ID(), ModelAPI_AttributeBoolean::typeId())->setIsArgument(false);
+
+ AttributeBooleanPtr aIsPersistentAttr = std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(
+ aData->addAttribute(IS_PERSISTENT_ID(), ModelAPI_AttributeBoolean::typeId()));
+ aIsPersistentAttr->setIsArgument(false);
+ if (!aIsPersistentAttr->isInitialized()){
+ aIsPersistentAttr->setValue(false);
+ }
+
+ AttributeBooleanPtr aCopyAttr = std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(
+ aData->addAttribute(IS_COPY_TO_SWALLOW(), ModelAPI_AttributeBoolean::typeId()));
+ aCopyAttr->setIsArgument(false);
+ if (!aCopyAttr->isInitialized()){
+ aCopyAttr->setValue(false);
+ }
+
+ AttributeReferencePtr anOrigRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ aData->addAttribute(ORIGINAL_REFERENCE(), ModelAPI_AttributeReference::typeId()));
+ anOrigRefAttr->setIsArgument(false);
+ if (!anOrigRefAttr->isInitialized()){
+ anOrigRefAttr->setValue(nullptr);
+ }
+
+ AttributeIntegerPtr aCopyAmountAttr = std::dynamic_pointer_cast<ModelAPI_AttributeInteger>(
+ aData->addAttribute(COPY_AMOUNT(), ModelAPI_AttributeInteger::typeId()));
+ aCopyAmountAttr->setIsArgument(false);
+
+ if (!aCopyAmountAttr->isInitialized()){
+ aCopyAmountAttr->setValue(0);
+ }
}
bool ModelAPI_Result::setDisabled(std::shared_ptr<ModelAPI_Result> theThis, const bool theFlag)
return myIsDisabled;
}
+void ModelAPI_Result::setPersistent(const bool theValue)
+{
+ AttributeBooleanPtr aAttr = data()->boolean(ModelAPI_Result::IS_PERSISTENT_ID());
+ if (aAttr.get() != NULL) {
+ aAttr->setValue(theValue);
+ }
+}
+
+bool ModelAPI_Result::isPersistent()
+{
+ AttributeBooleanPtr aAttr = data()->boolean(ModelAPI_Result::IS_PERSISTENT_ID());
+ if (aAttr.get() != NULL) {
+ return aAttr->value();
+ }
+ return false;
+}
+
bool ModelAPI_Result::isConcealed()
{
return myIsConcealed;
}
}
+// std::shared_ptr<ModelAPI_Result> ModelAPI_Result::createCopyToSwallow()
+// {
+// return std::shared_ptr<ModelAPI_Result>();
+// }
+
+
std::shared_ptr<GeomAPI_Shape> ModelAPI_Result::shape()
{
return std::shared_ptr<GeomAPI_Shape>();
*/
class ModelAPI_Result : public ModelAPI_Object
{
+// std::shared_ptr<ModelAPI_Result> myTempCopy;
+// bool myIsCreatingCopy;
bool myIsConcealed; ///< the result is concealed from the data tree (referenced by other objects)
protected:
bool myIsDisabled; ///< the result is disabled: removed for the user, but keeps the general info
return MY_BRING_TO_FRONT_ID;
}
+ /// Reference to the IsPersistent flag of the result.
+ /// Persistent means the result will remain even after generating a new feature from it.
+ /// The bool value is used.
+ inline static const std::string& IS_PERSISTENT_ID()
+ {
+ static const std::string MY_IS_PERSISTENT_ID("Is_persistent");
+ return MY_IS_PERSISTENT_ID;
+ }
+
+ ///True if the result is a copy of persistent result.
+ /// The bool value is used.
+ inline static const std::string& IS_COPY_TO_SWALLOW()
+ {
+ static const std::string MY_COPY_TO_SWALLOW("is_copy_to_swallow");
+ return MY_COPY_TO_SWALLOW;
+ }
+
+ /// If this result is a copy to swallow - stores the original result in this attribute
+ /// The reference value is used.
+ inline static const std::string& ORIGINAL_REFERENCE()
+ {
+ static const std::string MY_ORIGINAL_REFERENCE("original_reference");
+ return MY_ORIGINAL_REFERENCE;
+ }
+
+ /// Reference to the amount of copies of the result.
+ /// The int value is used.
+ inline static const std::string& COPY_AMOUNT()
+ {
+ static const std::string MY_COPY_AMOUNT("Copy_amount");
+ return MY_COPY_AMOUNT;
+ }
+
/// Returns true if the result is concealed from the data tree (referenced by other objects)
MODELAPI_EXPORT virtual bool isConcealed();
/// Returns the result is disabled or not.
MODELAPI_EXPORT virtual bool isDisabled();
+ /// Set whether the result should be persistent or not (persistent means the result will
+ /// remain even after generating a new feature from it)
+ MODELAPI_EXPORT virtual void setPersistent(const bool theValue);
+
+ /// Returns the result is persistent or not.
+ MODELAPI_EXPORT virtual bool isPersistent();
+
+// /// For persistent result - creates a copy to be swallowed by the new feature instead of original result
+// MODELAPI_EXPORT virtual std::shared_ptr<ModelAPI_Result> createCopyToSwallow();
+
/// Request for initialization of data model of the result: adding all attributes
MODELAPI_EXPORT virtual void initAttributes();
MODELAPI_EXPORT virtual const std::vector<int>& findShapeColor(
const std::wstring& theShapeName) = 0;
+ /// For persistent result - creates/return a copy of this result, so the copy can be swallowed
+ // by the new feature instead of original result
+ MODELAPI_EXPORT virtual std::shared_ptr<ModelAPI_Result> getCopyToSwallow() = 0;
+
+ MODELAPI_EXPORT virtual void nullifyTempCopy() = 0;
+
protected:
/// Default constructor accessible only from Model_Objects
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeImage.h>
#include <ModelAPI_AttributeIntArray.h>
+#include <ModelAPI_AttributeInteger.h>
+#include <ModelAPI_AttributeReference.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_CompositeFeature.h>
#include <ModelAPI_Document.h>
}
}
+//**************************************************************
double getTransparency(const std::shared_ptr<ModelAPI_Result>& theResult)
{
double aTransparency = -1;
return aTransparency;
}
+//**************************************************************
+void increaseCopyAmount(std::shared_ptr<ModelAPI_Result> theResult)
+{
+ if (!theResult.get())
+ return;
+
+ AttributeIntegerPtr anAttribute = theResult->data()->integer(ModelAPI_Result::COPY_AMOUNT());
+ if (anAttribute.get() != NULL) {
+ int aCurrentValue = anAttribute->value();
+ anAttribute->setValue(++aCurrentValue);
+ }
+
+}
+
+//**************************************************************
+int getCopyAmount(std::shared_ptr<ModelAPI_Result> theResult)
+{
+ int anAmountOfCopies = 0;
+ if (theResult.get() != NULL &&
+ theResult->data()->attribute(ModelAPI_Result::COPY_AMOUNT()).get() != NULL) {
+ AttributeIntegerPtr anIntAttr = theResult->data()->integer(ModelAPI_Result::COPY_AMOUNT());
+ if (anIntAttr.get() && anIntAttr->isInitialized()) {
+ anAmountOfCopies = anIntAttr->value();
+ }
+ }
+ return anAmountOfCopies;
+}
+
+//******************************************************
+void setIsCopyToSwallow(std::shared_ptr<ModelAPI_Result> theResult, bool theFlag)
+{
+ if (!theResult.get())
+ return;
+
+ AttributeBooleanPtr aAttr = theResult->data()->boolean(ModelAPI_Result::IS_COPY_TO_SWALLOW());
+ if (aAttr.get() != NULL) {
+ aAttr->setValue(theFlag);
+ }
+}
+
+//******************************************************
+bool isCopyToSwallow(std::shared_ptr<ModelAPI_Result> theResult)
+{
+ if (!theResult.get())
+ return false;
+
+ AttributeBooleanPtr aAttr = theResult->data()->boolean(ModelAPI_Result::IS_COPY_TO_SWALLOW());
+ if (aAttr.get() != NULL) {
+ return aAttr->value();
+ }
+ return false;
+}
+
+//******************************************************
+void setOriginalObject(std::shared_ptr<ModelAPI_Result> theCopyResult, std::shared_ptr<ModelAPI_Result> theOriginalResult)
+{
+ if (!theCopyResult.get())
+ return;
+
+ AttributeReferencePtr aAttr = theCopyResult->data()->reference(ModelAPI_Result::ORIGINAL_REFERENCE());
+ if (aAttr.get() != NULL) {
+ aAttr->setValue(theOriginalResult);
+ }
+}
+
+//******************************************************
+ObjectPtr getOriginalObject(std::shared_ptr<ModelAPI_Result> theCopyResult)
+{
+ if (!theCopyResult.get())
+ return;
+
+ AttributeReferencePtr aAttr = theCopyResult->data()->reference(ModelAPI_Result::ORIGINAL_REFERENCE());
+ if (aAttr.get() != NULL) {
+ return aAttr->value();
+ }
+ return nullptr;
+}
+
void copyVisualizationAttrs(
std::shared_ptr<ModelAPI_Result> theSource, std::shared_ptr<ModelAPI_Result> theDest)
{
MODELAPI_EXPORT bool isBringToFront(std::shared_ptr<ModelAPI_Result> theResult);
+/*! Increase copy amount of the result
+* \param[in] theResult a result object
+*/
+MODELAPI_EXPORT void increaseCopyAmount(std::shared_ptr<ModelAPI_Result> theResult);
+
+MODELAPI_EXPORT int getCopyAmount(std::shared_ptr<ModelAPI_Result> theResult);
+
+/*! Set result is copy or not
+* \param[in] theResult a result object
+*/
+MODELAPI_EXPORT void setIsCopyToSwallow(std::shared_ptr<ModelAPI_Result> theResult, bool theFlag);
+
+MODELAPI_EXPORT bool isCopyToSwallow(std::shared_ptr<ModelAPI_Result> theResult);
+
+/*! Set the original result to a copy result
+* \param[in] theCopyResult a copy result object
+* \param[in] theOriginalResult an original result object
+*/
+MODELAPI_EXPORT void setOriginalObject(std::shared_ptr<ModelAPI_Result> theCopyResult, std::shared_ptr<ModelAPI_Result> theOriginalResult);
+
+MODELAPI_EXPORT ObjectPtr getOriginalObject(std::shared_ptr<ModelAPI_Result> theCopyResult);
+
/*! Returns current transparency in the given result
* \param theResult a result object
* \return a transparency value or -1 if it was not defined
GeomShapePtr& theShape, ResultPtr& theContext)
{
if (theAttrSelect->isInitialized()) {
- theShape = theAttrSelect->value();
- theContext = theAttrSelect->context();
+ // if(theAttrSelect->isCopyToSwallow())
+ // {
+ // auto aPairContextShape = theAttrSelect->getOriginalContext();
+ // theContext = aPairContextShape.first;
+ // theShape = aPairContextShape.second;
+ // }
+ // else
+ // {
+ theShape = theAttrSelect->value();
+ theContext = theAttrSelect->context();
+ //}
+
if (!theShape.get())
theShape = theContext->shape();
dumpFolder(aFolder);
else {
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anObjIt);
- if (aFeature) // dump common feature
+ if (aFeature){ // dump common feature
dumpFeature(aFeature);
+ if(aFeature->lastResult() && aFeature->lastResult()->isPersistent())
+ *this << aFeature << ".defaultResult().setPersistent(True)" << std::endl;
+ }
+
}
}
}
else {
FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anIt);
if (aFeature)
+ {
dumpFeature(aFeature, true);
+ }
}
}
myDumpPostponedInProgress = false;
GeomShapePtr aShape;
std::string aShapeTypeStr;
+ ResultPtr aContext;
bool isAdded = false;
+ bool isCopy = false;
for(int anIndex = 0; anIndex < theAttrSelList->size(); ++anIndex) {
AttributeSelectionPtr anAttribute = theAttrSelList->value(anIndex);
- aShape = anAttribute->value();
- if(!aShape.get()) {
- ResultPtr aContext = anAttribute->context();
- if (aContext.get())
- aShape = aContext->shape();
+ if(anAttribute->isCopyToSwallow())
+ {
+ isCopy = true;
+ auto aPairContextShape = anAttribute->getOriginalContext();
+ aContext = aPairContextShape.first;
+ aShape = aPairContextShape.second;
+ theAttrSelList->append(aContext,aShape);
+ anAttribute = theAttrSelList->value(theAttrSelList->size()-1);
}
+ else
+ {
+ aShape = anAttribute->value();
+ if(!aShape.get()) {
+ aContext = anAttribute->context();
+ if (aContext.get())
+ aShape = aContext->shape();
+ }
- if(!aShape.get()) {
- continue;
- }
+ if(!aShape.get()) {
+ continue;
+ }
- if(isAdded) {
- // print each attribute on separate line with the appropriate shift
- if (aNbSpaces > 0) {
- std::string aSpaces(aNbSpaces + 1, ' ');
- *myDumpStorage << ",\n" << aSpaces;
- } else
- *myDumpStorage << ", ";
- } else {
- isAdded = true;
+ if(isAdded) {
+ // print each attribute on separate line with the appropriate shift
+ if (aNbSpaces > 0) {
+ std::string aSpaces(aNbSpaces + 1, ' ');
+ *myDumpStorage << ",\n" << aSpaces;
+ } else
+ *myDumpStorage << ", ";
+ } else {
+ isAdded = true;
+ }
}
*this << anAttribute;
+ if(isCopy)
+ {
+ theAttrSelList->removeLast();
+ }
}
// check selection list is obtained by filters
}
ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(aResult);
if (aBody.get() && aBody->isConnectedTopology())
- return QIcon(":pictures/compoundofsolids.png");
- return QIcon(":pictures/compound.png");
+ return aResult->isPersistent()? QIcon(":pictures/compoundofsolids_persistent.png") : QIcon(":pictures/compoundofsolids.png");
+ return aResult->isPersistent()? QIcon(":pictures/compound_persistent.png") : QIcon(":pictures/compound.png");
}
- case GeomAPI_Shape::COMPSOLID: return QIcon(":pictures/compsolid.png");
- case GeomAPI_Shape::SOLID: return QIcon(":pictures/solid.png");
- case GeomAPI_Shape::SHELL: return QIcon(":pictures/shell.png");
- case GeomAPI_Shape::FACE: return QIcon(":pictures/face.png");
- case GeomAPI_Shape::WIRE: return QIcon(":pictures/wire.png");
- case GeomAPI_Shape::EDGE: return QIcon(":pictures/edge.png");
- case GeomAPI_Shape::VERTEX: return QIcon(":pictures/vertex.png");
+ case GeomAPI_Shape::COMPSOLID: return aResult->isPersistent()? QIcon(":pictures/compsolid_persistent.png") : QIcon(":pictures/compsolid.png");
+ case GeomAPI_Shape::SOLID: return aResult->isPersistent()? QIcon(":pictures/solid_persistent.png") : QIcon(":pictures/solid.png");
+ case GeomAPI_Shape::SHELL: return aResult->isPersistent()? QIcon(":pictures/shell_persistent.png") : QIcon(":pictures/shell.png");
+ case GeomAPI_Shape::FACE: return aResult->isPersistent()? QIcon(":pictures/face_persistent.png") : QIcon(":pictures/face.png");
+ case GeomAPI_Shape::WIRE: return aResult->isPersistent()? QIcon(":pictures/wire_persistent.png") : QIcon(":pictures/wire.png");
+ case GeomAPI_Shape::EDGE: return aResult->isPersistent()? QIcon(":pictures/edge_persistent.png") :QIcon(":pictures/edge.png");
+ case GeomAPI_Shape::VERTEX: return aResult->isPersistent()? QIcon(":pictures/vertex_persistent.png") :QIcon(":pictures/vertex.png");
default: // [to avoid compilation warning]
break;
}
anAction->setCheckable(true);
addAction("BRING_TO_FRONT_CMD", anAction);
+ anAction = ModuleBase_Tools::createAction(QIcon(), tr("Is persistent"), aDesktop);
+ anAction->setCheckable(true);
+ addAction("PERSISTENT_CMD", anAction);
+
mySeparator1 = ModuleBase_Tools::createAction(QIcon(), "", aDesktop);
mySeparator1->setSeparator(true);
action("SHOW_ISOLINES_CMD")->setEnabled(true);
action("SHOW_ISOLINES_CMD")->setChecked(ModelAPI_Tools::isShownIsoLines(aResult));
action("ISOLINES_CMD")->setEnabled(true);
+
+ action("PERSISTENT_CMD")->setEnabled(true);
+ action("PERSISTENT_CMD")->setChecked(aResult->isPersistent());
}
if (!hasFeature) {
bool aHasSubResults = ModelAPI_Tools::hasSubResults(aResult);
action("BRING_TO_FRONT_CMD")->setEnabled(hasGroupsOnly);
action("SHOW_ISOLINES_CMD")->setEnabled(true);
action("ISOLINES_CMD")->setEnabled(true);
+ action("PERSISTENT_CMD")->setEnabled(true);
}
if (hasFeature && myWorkshop->canMoveFeature()) {
action("MOVE_CMD")->setEnabled(true);
aList.append(action("SHOW_ISOLINES_CMD"));
aList.append(action("ISOLINES_CMD"));
aList.append(action("SHOW_FEATURE_CMD"));
+ aList.append(action("PERSISTENT_CMD"));
aList.append(mySeparator3);
aList.append(action("DELETE_CMD"));
// Result body menu
aList.append(action("TRANSPARENCY_CMD"));
aList.append(action("SHOW_ISOLINES_CMD"));
aList.append(action("ISOLINES_CMD"));
+ aList.append(action("PERSISTENT_CMD"));
aList.append(mySeparator3);
aList.append(action("SET_VIEW_NORMAL_CMD"));
aList.append(action("SET_VIEW_INVERTEDNORMAL_CMD"));
anActions.append(action("SHOW_ISOLINES_CMD"));
anActions.append(action("ISOLINES_CMD"));
anActions.append(action("CLEAN_HISTORY_CMD"));
+ anActions.append(action("PERSISTENT_CMD"));
anActions.append(action("DELETE_CMD"));
}
#ifdef _DEBUG
mySelector->clearSelection();
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
}
+ else if (theId == "PERSISTENT_CMD") {
+ foreach(ObjectPtr aObj, anObjects) {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
+ if (aResult.get())
+ aResult->setPersistent(!aResult->isPersistent());
+ }
+ mySelector->clearSelection();
+ }
else if (theId == "DEFLECTION_CMD")
changeDeflection(anObjects);
else if (theId == "TRANSPARENCY_CMD")
<file>pictures/result.png</file>
<file>pictures/find_result.png</file>
+ <file>pictures/compsolid_persistent.png</file>
+ <file>pictures/compoundofsolids_persistent.png</file>
+ <file>pictures/solid_persistent.png</file>
+ <file>pictures/edge_persistent.png</file>
+ <file>pictures/vertex_persistent.png</file>
+ <file>pictures/face_persistent.png</file>
+ <file>pictures/compound_persistent.png</file>
+ <file>pictures/shell_persistent.png</file>
+ <file>pictures/wire_persistent.png</file>
+
<file>pictures/eyeclosed.png</file>
<file>pictures/eyemiclosed.png</file>
<file>pictures/eyeopen.png</file>
