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

diff --git a/src/ModuleBase/ModuleBase_WidgetValidated.cpp b/src/ModuleBase/ModuleBase_WidgetValidated.cpp
index d549ac306..7e85bce2e 100644
--- a/src/ModuleBase/ModuleBase_WidgetValidated.cpp
+++ b/src/ModuleBase/ModuleBase_WidgetValidated.cpp
@@ -4,11 +4,15 @@
 #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>
@@ -22,65 +26,58 @@
 
 ModuleBase_WidgetValidated::ModuleBase_WidgetValidated(QWidget* theParent,
                                                        ModuleBase_IWorkshop* theWorkshop,
-                                                       const Config_WidgetAPI* theData,
-                                                       const std::string& theParentId)
-: ModuleBase_ModelWidget(theParent, theData, theParentId),
+                                                       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,
-                                              const bool theToValidate)
+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;
-
-  if (!theToValidate || isValidInFilters(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();
-  }
-  return isDone;
+  return myPresentedObject;
 }
 
 //********************************************************************
-ObjectPtr ModuleBase_WidgetValidated::findPresentedObject(const AISObjectPtr& theAIS) const
+void ModuleBase_WidgetValidated::clearValidatedCash()
 {
-  return myPresentedObject;
+#ifdef DEBUG_VALID_STATE
+  qDebug("clearValidatedCash");
+#endif
+  myValidPrs.clear();
+  myInvalidPrs.clear();
 }
 
 //********************************************************************
-void ModuleBase_WidgetValidated::storeAttributeValue()
+void ModuleBase_WidgetValidated::storeAttributeValue(const AttributePtr& theAttribute)
 {
   myIsInValidate = true;
+  myAttributeStore->storeAttributeValue(theAttribute, myWorkshop);
 }
 
 //********************************************************************
-void ModuleBase_WidgetValidated::restoreAttributeValue(const bool theValid)
+void ModuleBase_WidgetValidated::restoreAttributeValue(const AttributePtr& theAttribute,
+                                                       const bool theValid)
 {
   myIsInValidate = false;
+  myAttributeStore->restoreAttributeValue(theAttribute, myWorkshop);
 }
 
 //********************************************************************
-bool ModuleBase_WidgetValidated::isValidInFilters(const ModuleBase_ViewerPrs& thePrs)
+bool ModuleBase_WidgetValidated::isValidInFilters(const ModuleBase_ViewerPrsPtr& thePrs)
 {
   bool aValid = true;
-  Handle(SelectMgr_EntityOwner) anOwner = thePrs.owner();
+  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()) {
+  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
@@ -101,18 +98,21 @@ bool ModuleBase_WidgetValidated::isValidInFilters(const ModuleBase_ViewerPrs& th
     if (!isActivated)
       activateFilters(true);
 
-    const SelectMgr_ListOfFilter& aFilters = myWorkshop->viewer()->AISContext()->Filters();
-    SelectMgr_ListIteratorOfListOfFilter anIt(aFilters);
-    for (; anIt.More() && aValid; anIt.Next()) {
-      Handle(SelectMgr_Filter) aFilter = anIt.Value();
-      aValid = aFilter->IsOk(anOwner);
+    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()) {
+  if (!anOwner.IsNull() && anOwner != thePrs->owner()) {
     anOwner.Nullify();
     myPresentedObject = ObjectPtr();
   }
@@ -120,44 +120,49 @@ bool ModuleBase_WidgetValidated::isValidInFilters(const ModuleBase_ViewerPrs& th
 }
 
 //********************************************************************
-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());
 
-  DataPtr aData = myFeature->data();
-  AttributePtr anAttribute = myFeature->attribute(attributeID());
+  storeValidState(theValue, aValid);
+  return aValid;
+}
+
+//********************************************************************
+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;
+
+  blockAttribute(theAttribute, true, isFlushesActived, isAttributeSetInitializedBlocked);
 
-  aData->blockSendAttributeUpdated(true);
-  bool isAttributeBlocked = anAttribute->blockSetInitialized(true);
-  storeAttributeValue();
+  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
@@ -165,27 +170,25 @@ 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);
   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();
-  AttributePtr anAttribute = myFeature->attribute(attributeID());
   std::string aValidatorID, anError;
-  return aFactory->validate(anAttribute, aValidatorID, anError);
+  return aFactory->validate(theAttribute, aValidatorID, anError);
 }
 
 bool ModuleBase_WidgetValidated::isFilterActivated() const
@@ -198,21 +201,48 @@ bool ModuleBase_WidgetValidated::isFilterActivated() const
   return aViewer->hasSelectionFilter(aSelFilter);
 }
 
-void ModuleBase_WidgetValidated::activateFilters(const bool toActivate)
+bool ModuleBase_WidgetValidated::activateFilters(const bool toActivate)
 {
   ModuleBase_IViewer* aViewer = myWorkshop->viewer();
 
   Handle(SelectMgr_Filter) aSelFilter = myWorkshop->validatorFilter();
+  bool aHasSelectionFilter = aViewer->hasSelectionFilter(aSelFilter);
+
   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);
@@ -238,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);
@@ -252,37 +282,29 @@ 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_ViewerPrs> ModuleBase_WidgetValidated::getFilteredSelected()
-{
-  QList<ModuleBase_ViewerPrs> aSelected = myWorkshop->selection()->getSelected(
+  QList<ModuleBase_ViewerPrsPtr> aSelected = myWorkshop->selection()->getSelected(
                                                        ModuleBase_ISelection::Viewer);
 
-  QList<ModuleBase_ViewerPrs> anOBSelected = myWorkshop->selection()->getSelected(
+  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_ViewerPrs>& theValues)
+void ModuleBase_WidgetValidated::filterPresentations(QList<ModuleBase_ViewerPrsPtr>& theValues)
 {
-  QList<ModuleBase_ViewerPrs> aValidatedValues;
+  QList<ModuleBase_ViewerPrsPtr> aValidatedValues;
 
-  QList<ModuleBase_ViewerPrs>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
+  QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
   bool isDone = false;
   for (; anIt != aLast; anIt++) {
     if (isValidInFilters(*anIt))
@@ -293,3 +315,41 @@ void ModuleBase_WidgetValidated::filterPresentations(QList<ModuleBase_ViewerPrs>
     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;
+  }
+}