X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModuleBase%2FModuleBase_WidgetValidated.cpp;h=7e85bce2e5fcdb2eb7e80761627ee2b89510ce6e;hb=397bec888031ab3d5d0578d3094e01f9a052222f;hp=889817706c8c12849cd3d0a88231d4e414f81756;hpb=ed8328e26b6e8f5ecedc8348b5eb7d650c065564;p=modules%2Fshaper.git

diff --git a/src/ModuleBase/ModuleBase_WidgetValidated.cpp b/src/ModuleBase/ModuleBase_WidgetValidated.cpp
index 889817706..7e85bce2e 100644
--- a/src/ModuleBase/ModuleBase_WidgetValidated.cpp
+++ b/src/ModuleBase/ModuleBase_WidgetValidated.cpp
@@ -4,14 +4,19 @@
 #include <ModuleBase_FilterFactory.h>
 #include <ModuleBase_IViewer.h>
 #include <ModuleBase_ISelection.h>
+#include <ModuleBase_WidgetSelectorStore.h>
+#include <ModuleBase_ViewerPrs.h>
 
 #include <ModelAPI_Session.h>
 #include <ModelAPI_Validator.h>
 #include <ModelAPI_AttributeValidator.h>
 #include <ModelAPI_Events.h>
+#include <ModelAPI_ResultCompSolid.h>
+#include <ModelAPI_Tools.h>
 
 #include <SelectMgr_ListIteratorOfListOfFilter.hxx>
 #include <SelectMgr_EntityOwner.hxx>
+#include <StdSelect_BRepOwner.hxx>
 
 #include <Events_Loop.h>
 
@@ -20,79 +25,144 @@
 //#define DEBUG_VALID_STATE
 
 ModuleBase_WidgetValidated::ModuleBase_WidgetValidated(QWidget* theParent,
-                                                       const Config_WidgetAPI* theData,
-                                                       const std::string& theParentId)
- : ModuleBase_ModelWidget(theParent, theData, theParentId), isValidateBlocked(false)
+                                                       ModuleBase_IWorkshop* theWorkshop,
+                                                       const Config_WidgetAPI* theData)
+: ModuleBase_ModelWidget(theParent, theData),
+  myWorkshop(theWorkshop), myIsInValidate(false)
 {
+  myAttributeStore = new ModuleBase_WidgetSelectorStore();
 }
 
 ModuleBase_WidgetValidated::~ModuleBase_WidgetValidated()
 {
+  delete myAttributeStore;
 }
 
 //********************************************************************
-bool ModuleBase_WidgetValidated::setSelection(QList<ModuleBase_ViewerPrs>& theValues)
+ObjectPtr ModuleBase_WidgetValidated::findPresentedObject(const AISObjectPtr& theAIS) const
 {
-  if (theValues.empty())
-    return false;
-  // it removes the processed value from the parameters list
-  ModuleBase_ViewerPrs aValue = theValues.takeFirst();
-  bool isDone = false;
+  return myPresentedObject;
+}
+
+//********************************************************************
+void ModuleBase_WidgetValidated::clearValidatedCash()
+{
+#ifdef DEBUG_VALID_STATE
+  qDebug("clearValidatedCash");
+#endif
+  myValidPrs.clear();
+  myInvalidPrs.clear();
+}
 
-  if (isValidSelection(aValue)) {
-    isDone = setSelectionCustom(aValue);
-    // updateObject - to update/redisplay feature
-    // it is commented in order to perfom it outside the method
-    //updateObject(myFeature);
-    // to storeValue()
-    //emit valuesChanged();
+//********************************************************************
+void ModuleBase_WidgetValidated::storeAttributeValue(const AttributePtr& theAttribute)
+{
+  myIsInValidate = true;
+  myAttributeStore->storeAttributeValue(theAttribute, myWorkshop);
+}
+
+//********************************************************************
+void ModuleBase_WidgetValidated::restoreAttributeValue(const AttributePtr& theAttribute,
+                                                       const bool theValid)
+{
+  myIsInValidate = false;
+  myAttributeStore->restoreAttributeValue(theAttribute, myWorkshop);
+}
+
+//********************************************************************
+bool ModuleBase_WidgetValidated::isValidInFilters(const ModuleBase_ViewerPrsPtr& thePrs)
+{
+  bool aValid = true;
+  Handle(SelectMgr_EntityOwner) anOwner = thePrs->owner();
+
+  // if an owner is null, the selection happens in the Object browser.
+  // creates a selection owner on the base of object shape and the object AIS object
+  if (anOwner.IsNull() && thePrs->owner().IsNull() && thePrs->object().get()) {
+    ResultPtr aResult = myWorkshop->selection()->getResult(thePrs);
+    if (aResult.get() && aResult->shape().get()) {
+      // some results have no shape, e.g. the parameter one. So, they should not be validated
+      GeomShapePtr aShape = aResult->shape();
+      const TopoDS_Shape aTDShape = aShape->impl<TopoDS_Shape>();
+      Handle(AIS_InteractiveObject) anIO = myWorkshop->selection()->getIO(thePrs);
+      anOwner = new StdSelect_BRepOwner(aTDShape, anIO);
+      myPresentedObject = aResult;
+    }
+    else
+      aValid = false; // only results with a shape can be filtered
   }
-  return isDone;
+  // checks the owner by the AIS context activated filters
+  if (!anOwner.IsNull()) {
+    // the widget validator filter should be active, but during check by preselection
+    // it is not yet activated, so we need to activate/deactivate it manually
+    bool isActivated = isFilterActivated();
+    if (!isActivated)
+      activateFilters(true);
+
+    Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
+    if (!aContext.IsNull()) {
+      const SelectMgr_ListOfFilter& aFilters = aContext->Filters();
+      SelectMgr_ListIteratorOfListOfFilter anIt(aFilters);
+      for (; anIt.More() && aValid; anIt.Next()) {
+        Handle(SelectMgr_Filter) aFilter = anIt.Value();
+        aValid = aFilter->IsOk(anOwner);
+      }
+    }
+    if (!isActivated)
+      activateFilters(false);
+  }
+
+  // removes created owner
+  if (!anOwner.IsNull() && anOwner != thePrs->owner()) {
+    anOwner.Nullify();
+    myPresentedObject = ObjectPtr();
+  }
+  return aValid;
 }
 
 //********************************************************************
-bool ModuleBase_WidgetValidated::isValidSelection(const ModuleBase_ViewerPrs& theValue)
+AttributePtr ModuleBase_WidgetValidated::attribute() const
+{
+  return myFeature->attribute(attributeID());
+}
+
+//********************************************************************
+bool ModuleBase_WidgetValidated::isValidSelection(const ModuleBase_ViewerPrsPtr& theValue)
 {
   bool aValid = false;
   if (getValidState(theValue, aValid)) {
     return aValid;
   }
-
   aValid = isValidSelectionCustom(theValue);
-  if (!aValid) {
-    storeValidState(theValue, aValid);
-    return aValid;
-  }
+  if (aValid)
+    aValid = isValidSelectionForAttribute(theValue, attribute());
 
-  if (isValidateBlocked)
-    return true;
-  isValidateBlocked = true;
+  storeValidState(theValue, aValid);
+  return aValid;
+}
 
-  DataPtr aData = myFeature->data();
-  AttributePtr anAttribute = myFeature->attribute(attributeID());
+//********************************************************************
+bool ModuleBase_WidgetValidated::isValidSelectionForAttribute(const ModuleBase_ViewerPrsPtr& theValue,
+                                                              const AttributePtr& theAttribute)
+{
+  bool aValid = false;
 
   // stores the current values of the widget attribute
-  Events_Loop* aLoop = Events_Loop::loop();
-  // blocks the flush signals to avoid the temporary objects visualization in the viewer
-  // they should not be shown in order to do not lose highlight by erasing them
-  bool isActive = aLoop->activateFlushes(false);
+  bool isFlushesActived, isAttributeSetInitializedBlocked;
 
-  aData->blockSendAttributeUpdated(true);
-  bool isAttributeBlocked = anAttribute->blockSetInitialized(true);
-  storeAttributeValue();
+  blockAttribute(theAttribute, true, isFlushesActived, isAttributeSetInitializedBlocked);
+
+  storeAttributeValue(theAttribute);
 
   // saves the owner value to the widget attribute
   aValid = setSelectionCustom(theValue);
   if (aValid)
     // checks the attribute validity
-    aValid = isValidAttribute();
+    aValid = isValidAttribute(theAttribute);
 
   // restores the current values of the widget attribute
-  restoreAttributeValue(aValid);
-  aData->blockSendAttributeUpdated(false);
-  anAttribute->blockSetInitialized(isAttributeBlocked);
-  aLoop->activateFlushes(isActive);
+  restoreAttributeValue(theAttribute, aValid);
 
+  blockAttribute(theAttribute, false, isFlushesActived, isAttributeSetInitializedBlocked);
   // In particular case the results are deleted and called as redisplayed inside of this
   // highlight-selection, to they must be flushed as soon as possible.
   // Example: selection of group-vertices subshapes with shift pressend on body. Without
@@ -100,61 +170,79 @@ bool ModuleBase_WidgetValidated::isValidSelection(const ModuleBase_ViewerPrs& th
   //  removed results still in the viewer.
   static Events_ID aDeletedEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED);
   static Events_ID aRedispEvent = Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY);
-  aLoop->flush(aDeletedEvent);
-  aLoop->flush(aRedispEvent);
+  Events_Loop::loop()->flush(aDeletedEvent);
+  Events_Loop::loop()->flush(aRedispEvent);
 
-  storeValidState(theValue, aValid);
-  isValidateBlocked = false;
   return aValid;
 }
 
 //********************************************************************
-bool ModuleBase_WidgetValidated::isValidSelectionCustom(const ModuleBase_ViewerPrs& thePrs)
+bool ModuleBase_WidgetValidated::isValidSelectionCustom(const ModuleBase_ViewerPrsPtr& thePrs)
 {
   return true;
 }
 
 //********************************************************************
-bool ModuleBase_WidgetValidated::isValidAttribute() const
+bool ModuleBase_WidgetValidated::isValidAttribute(const AttributePtr& theAttribute) const
 {
   SessionPtr aMgr = ModelAPI_Session::get();
   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
-  std::list<ModelAPI_Validator*> aValidators;
-  std::list<std::list<std::string> > anArguments;
-  aFactory->validators(myFeature->getKind(), attributeID(), aValidators, anArguments);
+  std::string aValidatorID, anError;
+  return aFactory->validate(theAttribute, aValidatorID, anError);
+}
 
-  DataPtr aData = myFeature->data();
-  AttributePtr anAttribute = myFeature->attribute(attributeID());
+bool ModuleBase_WidgetValidated::isFilterActivated() const
+{
+  bool isActivated = false;
 
-  std::list<ModelAPI_Validator*>::iterator aValidator = aValidators.begin();
-  std::list<std::list<std::string> >::iterator aArgs = anArguments.begin();
-  bool aValid = true;
-  for (; aValidator != aValidators.end() && aValid; aValidator++, aArgs++) {
-    const ModelAPI_AttributeValidator* aAttrValidator =
-        dynamic_cast<const ModelAPI_AttributeValidator*>(*aValidator);
-    if (aAttrValidator) {
-      aValid = aAttrValidator->isValid(anAttribute, *aArgs);
-    }
-  }
-  return aValid;
+  Handle(SelectMgr_Filter) aSelFilter = myWorkshop->validatorFilter();
+  ModuleBase_IViewer* aViewer = myWorkshop->viewer();
+
+  return aViewer->hasSelectionFilter(aSelFilter);
 }
 
-void ModuleBase_WidgetValidated::activateFilters(ModuleBase_IWorkshop* theWorkshop,
-                                                 const bool toActivate)
+bool ModuleBase_WidgetValidated::activateFilters(const bool toActivate)
 {
-  ModuleBase_IViewer* aViewer = theWorkshop->viewer();
+  ModuleBase_IViewer* aViewer = myWorkshop->viewer();
+
+  Handle(SelectMgr_Filter) aSelFilter = myWorkshop->validatorFilter();
+  bool aHasSelectionFilter = aViewer->hasSelectionFilter(aSelFilter);
 
-  Handle(SelectMgr_Filter) aSelFilter = theWorkshop->validatorFilter();
   if (toActivate)
     aViewer->addSelectionFilter(aSelFilter);
   else {
     aViewer->removeSelectionFilter(aSelFilter);
-    clearValidState();
+    clearValidatedCash();
   }
+
+  return aHasSelectionFilter;
 }
 
 //********************************************************************
-void ModuleBase_WidgetValidated::storeValidState(const ModuleBase_ViewerPrs& theValue, const bool theValid)
+void ModuleBase_WidgetValidated::blockAttribute(const AttributePtr& theAttribute,
+                                                const bool& theToBlock,
+                                                bool& isFlushesActived,
+                                                bool& isAttributeSetInitializedBlocked)
+{
+  Events_Loop* aLoop = Events_Loop::loop();
+  DataPtr aData = myFeature->data();
+  if (theToBlock) {
+    // blocks the flush signals to avoid the temporary objects visualization in the viewer
+    // they should not be shown in order to do not lose highlight by erasing them
+    isFlushesActived = aLoop->activateFlushes(false);
+
+    aData->blockSendAttributeUpdated(true);
+    isAttributeSetInitializedBlocked = theAttribute->blockSetInitialized(true);
+  }
+  else {
+    aData->blockSendAttributeUpdated(false);
+    theAttribute->blockSetInitialized(isAttributeSetInitializedBlocked);
+    aLoop->activateFlushes(isFlushesActived);
+  }
+}
+
+//********************************************************************
+void ModuleBase_WidgetValidated::storeValidState(const ModuleBase_ViewerPrsPtr& theValue, const bool theValid)
 {
   bool aValidPrs = myInvalidPrs.contains(theValue);
   bool anInvalidPrs = myInvalidPrs.contains(theValue);
@@ -180,7 +268,7 @@ void ModuleBase_WidgetValidated::storeValidState(const ModuleBase_ViewerPrs& the
 }
 
 //********************************************************************
-bool ModuleBase_WidgetValidated::getValidState(const ModuleBase_ViewerPrs& theValue, bool& theValid)
+bool ModuleBase_WidgetValidated::getValidState(const ModuleBase_ViewerPrsPtr& theValue, bool& theValid)
 {
   bool aValidPrs = myValidPrs.contains(theValue);
   bool anInvalidPrs = myInvalidPrs.contains(theValue);
@@ -194,12 +282,74 @@ bool ModuleBase_WidgetValidated::getValidState(const ModuleBase_ViewerPrs& theVa
 }
 
 //********************************************************************
-void ModuleBase_WidgetValidated::clearValidState()
+QList<ModuleBase_ViewerPrsPtr> ModuleBase_WidgetValidated::getFilteredSelected()
 {
-#ifdef DEBUG_VALID_STATE
-  qDebug("clearValidState");
-#endif
-  myValidPrs.clear();
-  myInvalidPrs.clear();
+  QList<ModuleBase_ViewerPrsPtr> aSelected = myWorkshop->selection()->getSelected(
+                                                       ModuleBase_ISelection::Viewer);
+
+  QList<ModuleBase_ViewerPrsPtr> anOBSelected = myWorkshop->selection()->getSelected(
+                                                       ModuleBase_ISelection::Browser);
+  // filter the OB presentations
+  filterPresentations(anOBSelected);
+  if (!anOBSelected.isEmpty())
+    ModuleBase_ISelection::appendSelected(anOBSelected, aSelected);
+
+  filterCompSolids(aSelected);
+
+  return aSelected;
+}
+
+//********************************************************************
+void ModuleBase_WidgetValidated::filterPresentations(QList<ModuleBase_ViewerPrsPtr>& theValues)
+{
+  QList<ModuleBase_ViewerPrsPtr> aValidatedValues;
+
+  QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
+  bool isDone = false;
+  for (; anIt != aLast; anIt++) {
+    if (isValidInFilters(*anIt))
+      aValidatedValues.append(*anIt);
+  }
+  if (aValidatedValues.size() != theValues.size()) {
+    theValues.clear();
+    theValues = aValidatedValues;
+  }
 }
 
+//********************************************************************
+void ModuleBase_WidgetValidated::filterCompSolids(QList<ModuleBase_ViewerPrsPtr>& theValues)
+{
+  std::set<ResultCompSolidPtr> aCompSolids;
+  QList<ModuleBase_ViewerPrsPtr> aValidatedValues;
+
+  // Collect compsolids.
+  QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
+  for (; anIt != aLast; anIt++) {
+    const ModuleBase_ViewerPrsPtr& aViewerPrs = *anIt;
+    ObjectPtr anObject = aViewerPrs->object();
+    ResultCompSolidPtr aResultCompSolid = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(anObject);
+    if(aResultCompSolid.get()) {
+      aCompSolids.insert(aResultCompSolid);
+    }
+  }
+
+  // Filter sub-solids of compsolids.
+  anIt = theValues.begin();
+  for (; anIt != aLast; anIt++) {
+    const ModuleBase_ViewerPrsPtr& aViewerPrs = *anIt;
+    ObjectPtr anObject = aViewerPrs->object();
+    ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
+    ResultCompSolidPtr aResCompSolidPtr = ModelAPI_Tools::compSolidOwner(aResult);
+    if(aResCompSolidPtr.get() && (aCompSolids.find(aResCompSolidPtr) != aCompSolids.end())) {
+      // Skip sub-solid of compsolid.
+      continue;
+    } else {
+      aValidatedValues.append(*anIt);
+    }
+  }
+
+  if (aValidatedValues.size() != theValues.size()) {
+    theValues.clear();
+    theValues = aValidatedValues;
+  }
+}