X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModuleBase%2FModuleBase_WidgetValidated.cpp;h=7e85bce2e5fcdb2eb7e80761627ee2b89510ce6e;hb=397bec888031ab3d5d0578d3094e01f9a052222f;hp=caadc6be7582cc17eb8121963161c657c171b058;hpb=af851100774c4ff33b515c884abe0cd03c3f0528;p=modules%2Fshaper.git diff --git a/src/ModuleBase/ModuleBase_WidgetValidated.cpp b/src/ModuleBase/ModuleBase_WidgetValidated.cpp index caadc6be7..7e85bce2e 100644 --- a/src/ModuleBase/ModuleBase_WidgetValidated.cpp +++ b/src/ModuleBase/ModuleBase_WidgetValidated.cpp @@ -1,75 +1,168 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D #include #include #include #include +#include +#include #include #include #include #include +#include +#include #include #include +#include #include #include +//#define DEBUG_VALID_STATE + ModuleBase_WidgetValidated::ModuleBase_WidgetValidated(QWidget* theParent, - const Config_WidgetAPI* theData, - const std::string& theParentId) - : ModuleBase_ModelWidget(theParent, theData, theParentId) + 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(ModuleBase_ViewerPrs theValue) +ObjectPtr ModuleBase_WidgetValidated::findPresentedObject(const AISObjectPtr& theAIS) const { - bool isDone = false; + return myPresentedObject; +} + +//******************************************************************** +void ModuleBase_WidgetValidated::clearValidatedCash() +{ +#ifdef DEBUG_VALID_STATE + qDebug("clearValidatedCash"); +#endif + myValidPrs.clear(); + myInvalidPrs.clear(); +} + +//******************************************************************** +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(); + 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 + } + // 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); + } - if (isValidSelection(theValue)) { - isDone = setSelectionCustom(theValue); - updateObject(myFeature); - emit valuesChanged(); + // removes created owner + if (!anOwner.IsNull() && anOwner != thePrs->owner()) { + anOwner.Nullify(); + myPresentedObject = ObjectPtr(); } - return isDone; + return aValid; } //******************************************************************** -bool ModuleBase_WidgetValidated::isValidSelection(const ModuleBase_ViewerPrs& theValue) +AttributePtr ModuleBase_WidgetValidated::attribute() const { - DataPtr aData = myFeature->data(); - AttributePtr anAttribute = myFeature->attribute(attributeID()); + 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) + aValid = isValidSelectionForAttribute(theValue, attribute()); + + 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 - aLoop->activateFlushes(false); + bool isFlushesActived, isAttributeSetInitializedBlocked; - aData->blockSendAttributeUpdated(true); - bool isAttributeBlocked = anAttribute->blockSetInitialized(true); - storeAttributeValue(); + blockAttribute(theAttribute, true, isFlushesActived, isAttributeSetInitializedBlocked); - // saves the owner value to the widget attribute - bool aValid = setSelectionCustom(theValue); + 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(true); + 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 @@ -77,67 +170,186 @@ 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); return aValid; } //******************************************************************** -bool ModuleBase_WidgetValidated::isValidAttribute() const +bool ModuleBase_WidgetValidated::isValidSelectionCustom(const ModuleBase_ViewerPrsPtr& thePrs) +{ + return true; +} + +//******************************************************************** +bool ModuleBase_WidgetValidated::isValidAttribute(const AttributePtr& theAttribute) const { SessionPtr aMgr = ModelAPI_Session::get(); ModelAPI_ValidatorsFactory* aFactory = aMgr->validators(); - std::list aValidators; - std::list > 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::iterator aValidator = aValidators.begin(); - std::list >::iterator aArgs = anArguments.begin(); - bool aValid = true; - for (; aValidator != aValidators.end() && aValid; aValidator++, aArgs++) { - const ModelAPI_AttributeValidator* aAttrValidator = - dynamic_cast(*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) const +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 + else { aViewer->removeSelectionFilter(aSelFilter); + clearValidatedCash(); + } + + return aHasSelectionFilter; } -QList ModuleBase_WidgetValidated::getSelectedEntitiesOrObjects( - ModuleBase_ISelection* theSelection) const +//******************************************************************** +void ModuleBase_WidgetValidated::blockAttribute(const AttributePtr& theAttribute, + const bool& theToBlock, + bool& isFlushesActived, + bool& isAttributeSetInitializedBlocked) { - QList aSelectedPrs; + 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); - // find selected presentation either in the viewer or in OB - // the selection in OCC viewer - the selection of a sub-shapes in the viewer - aSelectedPrs = theSelection->getSelected(); - if (aSelectedPrs.empty()) { - // the selection in Object Browser - QObjectPtrList anObjects = theSelection->selectedObjects(); - QObjectPtrList::const_iterator anIt = anObjects.begin(), aLast = anObjects.end(); - for (; anIt != aLast; anIt++) { - ObjectPtr anObject = *anIt; - if (anObject.get() != NULL) { - aSelectedPrs.append(ModuleBase_ViewerPrs(anObject, TopoDS_Shape(), NULL)); - } + 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); + + if (theValid) { + if (!aValidPrs) + myValidPrs.append(theValue); + // the commented code will be useful when the valid state of the presentation + // will be changable between activate/deactivate. Currently it does not happen. + //if (anInvalidPrs) + // myInvalidPrs.removeOne(theValue); + } + else { // !theValid + if (!anInvalidPrs) + myInvalidPrs.append(theValue); + //if (!aValidPrs) + // myValidPrs.removeOne(theValue); + } +#ifdef DEBUG_VALID_STATE + qDebug(QString("storeValidState: myValidPrs.size() = %1, myInvalidPrs.size() = %2").arg(myValidPrs.count()) + .arg(myInvalidPrs.count()).toStdString().c_str()); +#endif +} + +//******************************************************************** +bool ModuleBase_WidgetValidated::getValidState(const ModuleBase_ViewerPrsPtr& theValue, bool& theValid) +{ + bool aValidPrs = myValidPrs.contains(theValue); + bool anInvalidPrs = myInvalidPrs.contains(theValue); + + if (aValidPrs) + theValid = true; + else if (anInvalidPrs) + theValid = false; + + return aValidPrs || anInvalidPrs; +} + +//******************************************************************** +QList ModuleBase_WidgetValidated::getFilteredSelected() +{ + QList aSelected = myWorkshop->selection()->getSelected( + ModuleBase_ISelection::Viewer); + + QList 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& theValues) +{ + QList aValidatedValues; + + QList::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& theValues) +{ + std::set aCompSolids; + QList aValidatedValues; + + // Collect compsolids. + QList::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(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(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); } } - return aSelectedPrs; + + if (aValidatedValues.size() != theValues.size()) { + theValues.clear(); + theValues = aValidatedValues; + } }