X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Validators.cpp;h=76c8e61566cd287be78bc273012f5560eaae313a;hb=f14192492e36f4febc93b2ad7ab7f866cbbdf71b;hp=6d17784f78dbcfc44b31410e0f8fa386089a33f6;hpb=c7ed89ce495c3b8ef952f4afd45da259618d80ca;p=modules%2Fshaper.git diff --git a/src/PartSet/PartSet_Validators.cpp b/src/PartSet/PartSet_Validators.cpp index 6d17784f7..76c8e6156 100644 --- a/src/PartSet/PartSet_Validators.cpp +++ b/src/PartSet/PartSet_Validators.cpp @@ -1,159 +1,464 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: PartSet_Validators.cpp -// Created: 09 July 2014 -// Author: Vitaly SMETANNIKOV +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D +// +// 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 +// #include "PartSet_Validators.h" +#include "PartSet_Tools.h" +#include "PartSet_SketcherMgr.h" + #include #include #include #include #include -#include #include #include +#include +#include + +#include +#include + +#include #include #include #include #include +#include #include +#include #include +#include #include +#include +#include +#include +#include #include +#include #ifdef _DEBUG #include #endif int shapesNbPoints(const ModuleBase_ISelection* theSelection) { - QList aList = theSelection->getSelected(); + QList aList = theSelection->getSelected(ModuleBase_ISelection::Viewer); + ModuleBase_ISelection::filterSelectionOnEqualPoints(aList); + int aCount = 0; - foreach (ModuleBase_ViewerPrs aPrs, aList) { - const TopoDS_Shape& aShape = aPrs.shape(); - if (!aShape.IsNull()) { - if (aShape.ShapeType() == TopAbs_VERTEX) + foreach (ModuleBase_ViewerPrsPtr aPrs, aList) { + const GeomShapePtr& aShape = aPrs->shape(); + if (aShape.get() && !aShape->isNull()) { + if (aShape->shapeType() == GeomAPI_Shape::VERTEX) aCount++; } } return aCount; } -int shapesNbLines(const ModuleBase_ISelection* theSelection) +typedef std::unordered_map ShapeQuantity; + +int shapesNbEdges(const ModuleBase_ISelection* theSelection, ShapeQuantity& theEdges) { - QList aList = theSelection->getSelected(); + QList aList = theSelection->getSelected(ModuleBase_ISelection::Viewer); int aCount = 0; - foreach(ModuleBase_ViewerPrs aPrs, aList) { - const TopoDS_Shape& aShape = aPrs.shape(); - if (!aShape.IsNull()) { - if (aShape.ShapeType() == TopAbs_EDGE) { - TopoDS_Edge aEdge = TopoDS::Edge(aShape); + foreach(ModuleBase_ViewerPrsPtr aPrs, aList) { + const GeomShapePtr& aShape = aPrs->shape(); + if (aShape.get() && !aShape->isNull()) { + if (aShape->shapeType() == GeomAPI_Shape::EDGE) { + const TopoDS_Shape& aTDShape = aShape->impl(); + TopoDS_Edge aEdge = TopoDS::Edge(aTDShape); Standard_Real aStart, aEnd; Handle(Geom_Curve) aCurve = BRep_Tool::Curve(aEdge, aStart, aEnd); GeomAdaptor_Curve aAdaptor(aCurve); - if (aAdaptor.GetType() == GeomAbs_Line) - aCount++; + theEdges[(int)aAdaptor.GetType()] += 1; + aCount++; } } } return aCount; } -bool PartSet_DistanceValidator::isValid(const ModuleBase_ISelection* theSelection) const + +std::shared_ptr sketcherPlane(ModuleBase_Operation* theOperation) { - int aCount = shapesNbPoints(theSelection) + shapesNbLines(theSelection); - return (aCount > 0) && (aCount < 3); + std::shared_ptr aEmptyPln; + if (theOperation) { + ModuleBase_OperationFeature* aFeatureOp = + dynamic_cast(theOperation); + if (aFeatureOp) { + CompositeFeaturePtr aFeature = + std::dynamic_pointer_cast(aFeatureOp->feature()); + if (aFeature && (aFeature->getKind() == SketchPlugin_Sketch::ID())) + return PartSet_Tools::sketchPlane(aFeature); + } + } + return aEmptyPln; } -bool PartSet_LengthValidator::isValid(const ModuleBase_ISelection* theSelection) const + +bool isEmptySelectionValid(ModuleBase_Operation* theOperation) { - int aCount = shapesNbLines(theSelection); - return (aCount > 0) && (aCount < 2); + ModuleBase_OperationFeature* aFeatureOp = + dynamic_cast(theOperation); + // during the create operation empty selection is always valid + if (!aFeatureOp->isEditOperation()) { + return true; + } + else { + if (PartSet_SketcherMgr::isSketchOperation(aFeatureOp)) { + std::shared_ptr aPlane = sketcherPlane(theOperation); + if (aPlane.get()) + return true; + else + return false; + } + else + // in edit operation an empty selection is always valid, performed for re-entrant operrations + return true; + } } -bool PartSet_PerpendicularValidator::isValid(const ModuleBase_ISelection* theSelection) const +bool PartSet_DistanceSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const { - int aCount = shapesNbLines(theSelection); - return (aCount > 0) && (aCount < 3); + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return (aNbPoints >= 0 && aNbPoints < 3) && + (aShapes[GeomAbs_Line] == aNbEdges && aNbEdges >= 0 && aNbEdges < 2); + } } -bool PartSet_ParallelValidator::isValid(const ModuleBase_ISelection* theSelection) const +bool PartSet_LengthSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const { - int aCount = shapesNbLines(theSelection); - return (aCount > 0) && (aCount < 3); + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && (aShapes[GeomAbs_Line] == aNbEdges && aNbEdges == 1); + } } -bool PartSet_RadiusValidator::isValid(const ModuleBase_ISelection* theSelection) const +bool PartSet_PerpendicularSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const { - QList aList = theSelection->getSelected(); - ModuleBase_ViewerPrs aPrs; - int aCount = 0; - foreach (ModuleBase_ViewerPrs aPrs, aList) { - const TopoDS_Shape& aShape = aPrs.shape(); - if (!aShape.IsNull()) { - if (aShape.ShapeType() == TopAbs_EDGE) { - TopoDS_Edge aEdge = TopoDS::Edge(aShape); - Standard_Real aStart, aEnd; - Handle(Geom_Curve) aCurve = BRep_Tool::Curve(aEdge, aStart, aEnd); - GeomAdaptor_Curve aAdaptor(aCurve); - if (aAdaptor.GetType() == GeomAbs_Circle) - aCount++; + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && aShapes[GeomAbs_Line] == aNbEdges && aNbEdges > 0 && aNbEdges < 3; + } +} + +bool PartSet_ParallelSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && aShapes[GeomAbs_Line] == aNbEdges && aNbEdges > 0 && aNbEdges < 3; + } +} + +bool PartSet_RadiusSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && (aShapes[GeomAbs_Circle] == aNbEdges && aNbEdges == 1); + } +} + +bool PartSet_RigidSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + QList aList = + theSelection->getSelected(ModuleBase_ISelection::Viewer); + int aCount = 0; + foreach (ModuleBase_ViewerPrsPtr aPrs, aList) { + ObjectPtr aObj = aPrs->object(); + if (aObj.get()) { + FeaturePtr aFeature = ModelAPI_Feature::feature(aObj); + if (aFeature.get()) { + CompositeFeaturePtr aComp = ModelAPI_Tools::compositeOwner(aFeature); + if (aComp.get() && (aComp->getKind() == SketchPlugin_Sketch::ID())) + aCount++; + } } } + return (aCount == 1); + } +} + + +bool PartSet_CoincidentSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + // Coincident can be applied to points and to lines + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return (aNbPoints >= 0 && aNbPoints < 3) && (aNbEdges >= 0 && aNbEdges < 2); + } +} + +bool PartSet_HVDirSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && (aShapes[GeomAbs_Line] == aNbEdges && aNbEdges == 1); + } +} + +bool PartSet_FilletSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aCount = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aCount > 1 && aNbEdges == 0; + } +} + +bool PartSet_TangentSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && (aNbEdges == 1 || (aNbEdges == 2 && aShapes[GeomAbs_Line] == 1)); + } +} + +bool PartSet_AngleSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && aShapes[GeomAbs_Line] == aNbEdges && aNbEdges > 0 && aNbEdges < 3; + } +} + +bool PartSet_EqualSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && (aNbEdges > 0 && aNbEdges < 3) && + (aShapes[GeomAbs_Line] == aNbEdges || + aShapes[GeomAbs_Circle] == aNbEdges || + aShapes[GeomAbs_Ellipse] == aNbEdges); + } +} + +bool PartSet_CollinearSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbPoints == 0 && aShapes[GeomAbs_Line] == aNbEdges && aNbEdges > 0 && aNbEdges < 3; } - return (aCount > 0) && (aCount < 2); } -bool PartSet_RigidValidator::isValid(const ModuleBase_ISelection* theSelection) const +bool PartSet_MiddlePointSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const { - int aCount = shapesNbLines(theSelection); - return (aCount > 0) && (aCount < 2); + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) + return isEmptySelectionValid(theOperation); + else { + int aNbPoints = shapesNbPoints(theSelection); + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return (aNbPoints >= 0 && aNbPoints < 3) && (aNbEdges >= 0 && aNbEdges < 2); + } } -bool PartSet_DifferentObjectsValidator::isValid(const AttributePtr& theAttribute, - const std::list& theArguments) const +bool PartSet_MultyTranslationSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbEdges > 0; + } +} + +bool PartSet_SplitSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + if (theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0) { + return isEmptySelectionValid(theOperation); + } else { + ShapeQuantity aShapes; + int aNbEdges = shapesNbEdges(theSelection, aShapes); + return aNbEdges > 0; + } +} + +bool PartSet_ProjectionSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + return theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0 && + isEmptySelectionValid(theOperation); +} + +bool PartSet_IntersectionSelection::isValid(const ModuleBase_ISelection* theSelection, + ModuleBase_Operation* theOperation) const +{ + return theSelection->getSelected(ModuleBase_ISelection::Viewer).size() == 0 && + isEmptySelectionValid(theOperation); +} + + +std::string PartSet_DifferentObjectsValidator::errorMessage( + const PartSet_DifferentObjectsValidator::ErrorType& theType, + const std::string& thEqualObject, const std::string& theFirstAttribute, + const std::string& theSecondAttribute) const +{ + std::string anError; + switch (theType) { + case EqualObjects: + anError = "The feature uses one " + thEqualObject + " object in " + + theFirstAttribute + " and " + theSecondAttribute + " attributes."; + break; + case EqualAttributes: + anError = "The feature uses reference to one " + thEqualObject + " attribute in " + + theFirstAttribute + " and " + theSecondAttribute + " attributes."; + break; + case EqualShapes: + anError = "The feature uses one shape in " + + theFirstAttribute + " and " + theSecondAttribute + " attributes."; + break; + case EmptyShapes: + anError = "The feature uses empty shapes in " + + theFirstAttribute + " and " + theSecondAttribute + " attributes."; + break; + break; + default: + break; + } + return anError; +} + +bool PartSet_DifferentObjectsValidator::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const { FeaturePtr aFeature = std::dynamic_pointer_cast(theAttribute->owner()); - // the type of validated attributes should be equal, attributes with different types are not validated + // the type of validated attributes should be equal, attributes with + // different types are not validated // Check RefAttr attributes std::string anAttrType = theAttribute->attributeType(); std::list > anAttrs; if (anAttrType == ModelAPI_AttributeRefAttr::typeId()) { - AttributeRefAttrPtr anAttr = std::dynamic_pointer_cast(theAttribute); + AttributeRefAttrPtr anAttr = + std::dynamic_pointer_cast(theAttribute); bool isObject = anAttr->isObject(); ObjectPtr anObject = anAttr->object(); - AttributePtr anAttributeAttr = anAttr->attr(); anAttrs = aFeature->data()->attributes(ModelAPI_AttributeRefAttr::typeId()); if (anAttrs.size() > 0) { - std::list >::iterator anAttr = anAttrs.begin(); - for(; anAttr != anAttrs.end(); anAttr++) { - if ((*anAttr).get() && (*anAttr)->id() != theAttribute->id()) { + std::list >::iterator anAttrIter = anAttrs.begin(); + for(; anAttrIter != anAttrs.end(); anAttrIter++) { + if ((*anAttrIter).get() && (*anAttrIter)->id() != theAttribute->id()) { std::shared_ptr aRef = - std::dynamic_pointer_cast(*anAttr); + std::dynamic_pointer_cast(*anAttrIter); if (aRef->isObject() != isObject) continue; if (isObject) { - if (aRef->object() == anObject) + if (aRef->object() == anObject) { + theError = errorMessage(EqualObjects, + anObject.get() ? ModelAPI_Tools::toString(anObject->data()->name()) : "", + theAttribute->id(), aRef->id()); return false; + } } else { // the attribute reference - if (aRef->attr() == theAttribute) + AttributePtr anAttributeAttr = anAttr->attr(); + if (aRef->attr() == anAttributeAttr) { + theError = errorMessage(EqualAttributes, + anAttributeAttr.get() ? anAttributeAttr->id() : "", + theAttribute->id(), aRef->id()); return false; + } } } } } } - else if (anAttrType == ModelAPI_AttributeRefAttr::typeId()) { - AttributeSelectionPtr anAttr = std::dynamic_pointer_cast(theAttribute); + else if (anAttrType == ModelAPI_AttributeSelection::typeId()) { + AttributeSelectionPtr anAttr = + std::dynamic_pointer_cast(theAttribute); ResultPtr aContext = anAttr->context(); + FeaturePtr aContextFeature = anAttr->contextFeature(); GeomShapePtr aShape = anAttr->value(); // Check selection attributes @@ -163,19 +468,40 @@ bool PartSet_DifferentObjectsValidator::isValid(const AttributePtr& theAttribute for(; anAttr != anAttrs.end(); anAttr++) { if ((*anAttr).get() && (*anAttr)->id() != theAttribute->id()) { std::shared_ptr aRef = - std::dynamic_pointer_cast(*anAttr); + std::dynamic_pointer_cast(*anAttr); // check the object is already presented if (aRef->context() == aContext) { bool aHasShape = aShape.get() != NULL; - if (!aHasShape || aRef->value()->isEqual(aShape)) + if (!aHasShape || aRef->value()->isEqual(aShape)) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRef->id()); return false; + } + } + // check the whole selected feature contains the result + if (aContextFeature.get()) { + if (aRef->contextFeature().get()) { + if (aContextFeature == aRef->contextFeature()) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRef->id()); + return false; + } + } else if (aRef->context().get() && + aRef->context()->document()->feature(aRef->context()) == aContextFeature) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRef->id()); + return false; + } + } else if (aRef->contextFeature().get() && aContext.get()) { + if (aContext->document()->feature(aContext) == aRef->contextFeature()) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRef->id()); + return false; + } } } } } } else if (anAttrType == ModelAPI_AttributeReference::typeId()) { - AttributeReferencePtr anAttr = std::dynamic_pointer_cast(theAttribute); + AttributeReferencePtr anAttr = + std::dynamic_pointer_cast(theAttribute); ObjectPtr anObject = anAttr->value(); // Check selection attributes anAttrs = aFeature->data()->attributes(ModelAPI_AttributeReference::typeId()); @@ -186,93 +512,178 @@ bool PartSet_DifferentObjectsValidator::isValid(const AttributePtr& theAttribute std::shared_ptr aRef = std::dynamic_pointer_cast(*anAttr); // check the object is already presented - if (aRef->value() == anObject) + if (aRef->value() == anObject) { + theError = errorMessage(EqualObjects, + anObject.get() ? ModelAPI_Tools::toString(anObject->data()->name()) : "", + theAttribute->id(), aRef->id()); return false; + } } return true; } } } - return !featureHasReferences(theAttribute); -} + else if(anAttrType == ModelAPI_AttributeSelectionList::typeId()) { + std::shared_ptr aCurSelList = + std::dynamic_pointer_cast(theAttribute); + anAttrs = aFeature->data()->attributes(ModelAPI_AttributeSelectionList::typeId()); + if(anAttrs.size() > 0) { + std::list>::iterator anAttrItr = anAttrs.begin(); + for(; anAttrItr != anAttrs.end(); anAttrItr++){ + if ((*anAttrItr).get() && (*anAttrItr)->id() != theAttribute->id()){ + std::shared_ptr aRefSelList = + std::dynamic_pointer_cast(*anAttrItr); + for(int i = 0; i < aCurSelList->size(); i++) { + std::shared_ptr aCurSel = aCurSelList->value(i); + ResultPtr aCurSelContext = aCurSel->context(); + FeaturePtr aCurSelFeature = aCurSel->contextFeature(); + ResultBodyPtr aCurSelCompSolidPtr = ModelAPI_Tools::bodyOwner(aCurSelContext); + std::shared_ptr aCurSelCompSolid; + if(aCurSelCompSolidPtr.get()) { + aCurSelCompSolid = aCurSelCompSolidPtr->shape(); + } + for(int j = 0; j < aRefSelList->size(); j++) { + std::shared_ptr aRefSel = aRefSelList->value(j); + ResultPtr aRefSelContext = aRefSel->context(); + FeaturePtr aRefSelFeature = aRefSel->contextFeature(); + ResultBodyPtr aRefSelCompSolidPtr = + ModelAPI_Tools::bodyOwner(aRefSelContext); + std::shared_ptr aRefSelCompSolid; + if (aRefSelCompSolidPtr.get()) { + aRefSelCompSolid = aRefSelCompSolidPtr->shape(); + } + if ((aCurSelCompSolid.get() && aCurSelCompSolid->isEqual(aRefSel->value())) + || (aRefSelCompSolid.get() && aRefSelCompSolid->isEqual(aCurSel->value()))) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), + aRefSel->id()); + return false; + } + if (aCurSelContext == aRefSelContext) { + if (aCurSel->value().get() == NULL || aRefSel->value().get() == NULL) { + theError = errorMessage(EmptyShapes, "", theAttribute->id(), aRefSel->id()); + return false; + } + if (aCurSel->value()->isEqual(aRefSel->value())) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRefSel->id()); + return false; + } + } -bool PartSet_DifferentObjectsValidator::featureHasReferences(const AttributePtr& theAttribute) const -{ - std::list > > allRefs; - if (theAttribute->owner().get() && theAttribute->owner()->data().get()) - theAttribute->owner()->data()->referencesToObjects(allRefs); - // collect object referenced by theAttribute - std::list* anAttrObjs = 0; - std::list > >::iterator aRefIter = allRefs.begin(); - for(; aRefIter != allRefs.end(); aRefIter++) { - if (theAttribute->id() == aRefIter->first) - anAttrObjs = &(aRefIter->second); + // check the whole selected feature contains the result + if (aCurSelFeature.get()) { + if (aRefSelFeature.get()) { + if (aCurSelFeature == aRefSelFeature) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRefSel->id()); + return false; + } + } + else if (aRefSelContext.get() && + aRefSelContext->document()->feature(aRefSelContext) == aCurSelFeature) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRefSel->id()); + return false; + } + } + else if (aRefSelFeature.get() && aCurSelContext.get()) { + if (aCurSelContext->document()->feature(aCurSelContext) == aRefSelFeature) { + theError = errorMessage(EqualShapes, "", theAttribute->id(), aRefSel->id()); + return false; + } + } + } + } + } + } + } } - if (!anAttrObjs || anAttrObjs->empty()) - return false; // theAttribute does not references to anything - // check with all others - for(aRefIter = allRefs.begin(); aRefIter != allRefs.end(); aRefIter++) { - if (theAttribute->id() == aRefIter->first) - continue; // do not check with myself - std::list::iterator aReferenced = aRefIter->second.begin(); - for(; aReferenced != aRefIter->second.end(); aReferenced++) { - std::list::iterator aReferencedByMe = anAttrObjs->begin(); - for(; aReferencedByMe != anAttrObjs->end(); aReferencedByMe++) { - if (*aReferenced == *aReferencedByMe) // found same objects! - return true; + else if (anAttrType == ModelAPI_AttributeRefList::typeId()) { + std::shared_ptr aCurSelList = + std::dynamic_pointer_cast(theAttribute); + anAttrs = aFeature->data()->attributes(ModelAPI_AttributeRefList::typeId()); + if (anAttrs.size() > 0) { + std::list>::iterator anAttrItr = anAttrs.begin(); + for (; anAttrItr != anAttrs.end(); anAttrItr++){ + if ((*anAttrItr).get() && (*anAttrItr)->id() != theAttribute->id()){ + std::shared_ptr aRefSelList = + std::dynamic_pointer_cast(*anAttrItr); + for (int i = 0; i < aCurSelList->size(); i++) { + ObjectPtr aCurSelObject = aCurSelList->object(i); + for (int j = 0; j < aRefSelList->size(); j++) { + if (aCurSelObject == aRefSelList->object(j)) { + theError = errorMessage(EqualObjects, + aCurSelObject.get()? + ModelAPI_Tools::toString(aCurSelObject->data()->name()) : "", + theAttribute->id(), aCurSelList->id()); + return false; + } + } + } + } } } } - return false; + return true; } -bool PartSet_SketchEntityValidator::isValid(const AttributePtr& theAttribute, - const std::list& theArguments) const +bool PartSet_DifferentPointsValidator::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const { - bool isSketchEntities = true; - std::set anEntityKinds; - std::list::const_iterator anIt = theArguments.begin(), aLast = theArguments.end(); - for (; anIt != aLast; anIt++) { - anEntityKinds.insert(*anIt); - } + FeaturePtr aFeature = std::dynamic_pointer_cast(theAttribute->owner()); + + // the type of validated attributes should be equal, attributes with + // different types are not validated + // Check RefAttr attributes + std::string anAttrType = theAttribute->attributeType(); + std::list > anAttrs; + if (anAttrType != ModelAPI_AttributeRefAttr::typeId()) + return true; - std::string anAttributeType = theAttribute->attributeType(); - if (anAttributeType == ModelAPI_AttributeSelectionList::typeId()) { - AttributeSelectionListPtr aSelectionListAttr = - std::dynamic_pointer_cast(theAttribute); - // it filters only selection list attributes - std::string aType = aSelectionListAttr->selectionType().c_str(); - // all context objects should be sketch entities - int aSize = aSelectionListAttr->size(); - for (int i = 0; i < aSelectionListAttr->size() && isSketchEntities; i++) { - AttributeSelectionPtr aSelectAttr = aSelectionListAttr->value(i); - ObjectPtr anObject = aSelectAttr->context(); + // obtain point of the given attribute + AttributePoint2DPtr anAttributePoint = getRefPointAttribute(theAttribute); + if (!anAttributePoint.get() || !anAttributePoint->isInitialized()) + return true; + + // obtain point of the parameter attribute + AttributePoint2DPtr anArgumentPoint = getRefPointAttribute + (aFeature->attribute(theArguments.front())); + + if (!anArgumentPoint.get() || !anArgumentPoint->isInitialized()) + return true; + + return !anAttributePoint->pnt()->isEqual(anArgumentPoint->pnt()); +} + +AttributePoint2DPtr PartSet_DifferentPointsValidator::getRefPointAttribute + (const AttributePtr& theAttribute) const +{ + AttributeRefAttrPtr anAttr = std::dynamic_pointer_cast(theAttribute); + + AttributePoint2DPtr aPointAttribute; + if (anAttr->isObject()) { + ObjectPtr anObject = anAttr->object(); + if (anObject.get()) { FeaturePtr aFeature = ModelAPI_Feature::feature(anObject); - isSketchEntities = anEntityKinds.find(aFeature->getKind()) != anEntityKinds.end(); + if (aFeature->getKind() == SketchPlugin_Point::ID()) + aPointAttribute = std::dynamic_pointer_cast + (aFeature->attribute(SketchPlugin_Point::COORD_ID())); } } - if (anAttributeType == ModelAPI_AttributeRefAttr::typeId()) { - std::shared_ptr aRef = - std::dynamic_pointer_cast(theAttribute); - isSketchEntities = false; - if (aRef->isObject()) { - ObjectPtr anObject = aRef->object(); - if (anObject.get() != NULL) { - FeaturePtr aFeature = ModelAPI_Feature::feature(anObject); - if (aFeature.get() != NULL) - isSketchEntities = anEntityKinds.find(aFeature->getKind()) != anEntityKinds.end(); - } - } + else { + aPointAttribute = std::dynamic_pointer_cast(anAttr->attr()); } - - return isSketchEntities; + return aPointAttribute; } - - -bool PartSet_SameTypeAttrValidator::isValid( - const AttributePtr& theAttribute, const std::list& theArguments ) const +bool PartSet_CoincidentAttr::isValid(const AttributePtr& theAttribute, + const std::list& theArguments, + Events_InfoMessage& theError) const { + if (theAttribute->attributeType() != ModelAPI_AttributeRefAttr::typeId()) { + theError = "The attribute with the %1 type is not processed"; + theError.arg(theAttribute->attributeType()); + return false; + } + // there is a check whether the feature contains a point and a linear edge or two point values std::string aParamA = theArguments.front(); SessionPtr aMgr = ModelAPI_Session::get(); @@ -280,19 +691,53 @@ bool PartSet_SameTypeAttrValidator::isValid( FeaturePtr aFeature = std::dynamic_pointer_cast(theAttribute->owner()); AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast(theAttribute); - if (!aRefAttr) - return false; + QList aCoinsideLines; + QList aCoins; bool isObject = aRefAttr->isObject(); ObjectPtr anObject = aRefAttr->object(); if (isObject && anObject) { FeaturePtr aRefFea = ModelAPI_Feature::feature(anObject); - AttributeRefAttrPtr aOtherAttr = aFeature->data()->refattr(aParamA); ObjectPtr aOtherObject = aOtherAttr->object(); + // if the other attribute is not filled still, the result is true + if (!aOtherObject.get()) + return true; FeaturePtr aOtherFea = ModelAPI_Feature::feature(aOtherObject); - return aRefFea->getKind() == aOtherFea->getKind(); + + // check that both have coincidence + FeaturePtr aConstrFeature; + std::set aCoinList; + const std::set>& aRefsList = aRefFea->data()->refsToMe(); + std::set>::const_iterator aIt; + for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) { + std::shared_ptr aAttr = (*aIt); + aConstrFeature = std::dynamic_pointer_cast(aAttr->owner()); + if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { + AttributeRefAttrPtr aRAttr = std::dynamic_pointer_cast(aAttr); + AttributePtr aAR = aRAttr->attr(); + if (aAR->id() != SketchPlugin_Arc::CENTER_ID()) // ignore constraint to center of arc + aCoinList.insert(aConstrFeature); + QList anIsAttributes; + PartSet_Tools::findCoincidences(aConstrFeature, aCoinsideLines, aCoins, + SketchPlugin_ConstraintCoincidence::ENTITY_A(), + anIsAttributes); + PartSet_Tools::findCoincidences(aConstrFeature, aCoinsideLines, aCoins, + SketchPlugin_ConstraintCoincidence::ENTITY_B(), + anIsAttributes); + } + } + // if there is no coincidence then it is not valid + if (aCoinList.size() > 0) { + QList::const_iterator anIt = aCoinsideLines.begin(), aLast = aCoinsideLines.end(); + bool aValid = false; + for (; anIt != aLast && !aValid; anIt++) { + aValid = *anIt == aOtherFea; + } + if (aValid) + return true; + } } + theError = "There is no a common coincident point."; return false; } -