From 52273c075ec39fb4b5ba28e30acdc7b69b32d644 Mon Sep 17 00:00:00 2001 From: nds Date: Mon, 15 Dec 2014 12:44:38 +0300 Subject: [PATCH] The Linear filter applying --- src/ModuleBase/ModuleBase_FilterFactory.cpp | 194 ++++-------------- src/ModuleBase/ModuleBase_FilterFactory.h | 68 ++---- .../ModuleBase_FilterLinearEdge.cpp | 6 +- src/ModuleBase/ModuleBase_FilterLinearEdge.h | 2 +- .../ModuleBase_WidgetShapeSelector.cpp | 15 +- src/XGUI/XGUI_Workshop.cpp | 5 +- 6 files changed, 73 insertions(+), 217 deletions(-) diff --git a/src/ModuleBase/ModuleBase_FilterFactory.cpp b/src/ModuleBase/ModuleBase_FilterFactory.cpp index 86213407f..891d74370 100644 --- a/src/ModuleBase/ModuleBase_FilterFactory.cpp +++ b/src/ModuleBase/ModuleBase_FilterFactory.cpp @@ -7,210 +7,86 @@ #include "ModuleBase_FilterFactory.h" #include -#include +//#include #include #include #include -#include +//#include #include void ModuleBase_FilterFactory::registerFilter(const std::string& theID, Handle(ModuleBase_Filter) theFilter) { - /*if (myIDs.find(theID) != myIDs.end()) { - Events_Error::send(std::string("Validator ") + theID + " is already registered"); + if (myIDs.find(theID) != myIDs.end()) { + Events_Error::send(std::string("Filter ") + theID + " is already registered"); } else { - myIDs[theID] = theValidator; - }*/ + myIDs[theID] = theFilter; + } } void ModuleBase_FilterFactory::assignFilter(const std::string& theID, - const std::string& theFeatureID, - const std::string& theAttrID) + const std::string& theFeatureID, + const std::string& theAttrID) { - /* // create feature-structures if not exist - std::map >::iterator aFeature = myAttrs.find( + std::map >::iterator aFeature = myAttrs.find( theFeatureID); if (aFeature == myAttrs.end()) { - myAttrs[theFeatureID] = std::map(); + myAttrs[theFeatureID] = std::map(); aFeature = myAttrs.find(theFeatureID); } // add attr-structure if not exist, or generate error if already exist - std::map::iterator anAttr = aFeature->second.find(theAttrID); + std::map::iterator anAttr = aFeature->second.find(theAttrID); if (anAttr == aFeature->second.end()) { - aFeature->second[theAttrID] = AttrValidators(); + aFeature->second[theAttrID] = AttrFilters(); } - //aFeature->second[theAttrID][theID] = theArguments; - */ + aFeature->second[theAttrID][theID] = std::list(); } -const SelectMgr_ListOfFilter& ModuleBase_FilterFactory::filters(const std::string& theFeatureID, - const std::string& theAttrID/*, - std::list& theFilters/*, - std::list >& theArguments*/) const +void ModuleBase_FilterFactory::filters(const std::string& theFeatureID, + const std::string& theAttrID, + SelectMgr_ListOfFilter& theFilters/*, + std::list& theFilters/*, + std::list >& theArguments*/) const { SelectMgr_ListOfFilter aFilters; - return aFilters; - /* std::map >::const_iterator aFeature = + + std::map >::const_iterator aFeature = myAttrs.find(theFeatureID); if (aFeature != myAttrs.cend()) { - std::map::const_iterator anAttr = aFeature->second.find(theAttrID); + std::map::const_iterator anAttr = aFeature->second.find(theAttrID); if (anAttr != aFeature->second.end()) { - AttrValidators::const_iterator aValIter = anAttr->second.cbegin(); + AttrFilters::const_iterator aValIter = anAttr->second.cbegin(); for (; aValIter != anAttr->second.cend(); aValIter++) { std::map::const_iterator aFound = myIDs.find( aValIter->first); if (aFound == myIDs.end()) { - Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered"); + Events_Error::send(std::string("Filter ") + aValIter->first + " was not registered"); } else { - theValidators.push_back(aFound->second); - theArguments.push_back(aValIter->second); + Handle(ModuleBase_Filter) aFilter = aFound->second; + if (aFilter.IsNull()) + continue; + + theFilters.Append(aFilter);//aFound->second); + //theArguments.push_back(aValIter->second); } } } - }*/ + } } ModuleBase_FilterFactory::ModuleBase_FilterFactory() { - //const static std::string kDefaultId = "Model_FeatureValidator"; - //registerValidator(kDefaultId, new Model_FeatureValidator); + //const static std::string kDefaultId = "Model_FeatureFilter"; + //registerFilter(kDefaultId, new Model_FeatureFilter); } -const Handle(ModuleBase_Filter) ModuleBase_FilterFactory::validator(const std::string& theID) const +const Handle(ModuleBase_Filter) ModuleBase_FilterFactory::filter(const std::string& theID) const { -/* std::map::const_iterator aIt = myIDs.find(theID); + std::map::const_iterator aIt = myIDs.find(theID); if (aIt != myIDs.end()) { return aIt->second; - }*/ - return NULL; -} - -void ModuleBase_FilterFactory::addDefaultValidators(std::list& theValidators) const -{ -/* const static std::string kDefaultId = "Model_FeatureValidator"; - std::map::const_iterator it = myIDs.find(kDefaultId); - if(it == myIDs.end()) - return; - theValidators.push_back(it->second);*/ -} - -bool ModuleBase_FilterFactory::validate(const std::shared_ptr& theFeature) const -{ -/* const static std::string kDefaultId = "Model_FeatureValidator"; - // check feature validators first - std::map::const_iterator aFeature = - myFeatures.find(theFeature->getKind()); - if (aFeature != myFeatures.end()) { - AttrValidators::const_iterator aValidator = aFeature->second.begin(); - for(; aValidator != aFeature->second.end(); aValidator++) { - std::map::const_iterator aValFind = - myIDs.find(aValidator->first); - if (aValFind == myIDs.end()) { - Events_Error::send(std::string("Validator ") + aValidator->first + " was not registered"); - continue; - } - const ModelAPI_FeatureValidator* aFValidator = - dynamic_cast(aValFind->second); - if (aFValidator) { - if (!aFValidator->isValid(theFeature, aValidator->second)) - return false; - } - } - } - // check default validator - std::map::const_iterator aDefaultVal = myIDs.find(kDefaultId); - if(aDefaultVal != myIDs.end()) { - static const std::list anEmptyArgList; - const ModelAPI_FeatureValidator* aFValidator = - dynamic_cast(aDefaultVal->second); - if (aFValidator) { - if (!aFValidator->isValid(theFeature, anEmptyArgList)) - return false; - } - } - - // check all attributes for validity - std::shared_ptr aData = theFeature->data(); - // Validity of data is checked by "Model_FeatureValidator" (kDefaultId) - // if (!aData || !aData->isValid()) - // return false; - static const std::string kAllTypes = ""; - std::map >::const_iterator aFeatureIter = - myAttrs.find(theFeature->getKind()); - if (aFeatureIter != myAttrs.cend()) { - std::list aLtAttributes = aData->attributesIDs(kAllTypes); - std::list::iterator anAttrIter = aLtAttributes.begin(); - for (; anAttrIter != aLtAttributes.end(); anAttrIter++) { - std::map::const_iterator anAttr = - aFeatureIter->second.find(*anAttrIter); - if (anAttr != aFeatureIter->second.end()) { - AttrValidators::const_iterator aValIter = anAttr->second.cbegin(); - for (; aValIter != anAttr->second.cend(); aValIter++) { - std::map::const_iterator aFound = myIDs.find( - aValIter->first); - if (aFound == myIDs.end()) { - Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered"); - } else { - const ModelAPI_AttributeValidator* anAttrValidator = - dynamic_cast(aFound->second); - if (anAttrValidator) { - AttributePtr anAttribute = theFeature->data()->attribute(*anAttrIter); - if (!anAttrValidator->isValid(anAttribute, aValIter->second)) { - return false; - } - } - } - } - } - } } - */ - return true; -} - -void ModuleBase_FilterFactory::registerNotObligatory(std::string theFeature, std::string theAttribute) -{ -/* const static std::string kDefaultId = "Model_FeatureValidator"; - std::map::const_iterator it = myIDs.find(kDefaultId); - if (it != myIDs.end()) { - Model_FeatureValidator* aValidator = dynamic_cast(it->second); - if (aValidator) { - aValidator->registerNotObligatory(theFeature, theAttribute); - } - }*/ -} - -bool ModuleBase_FilterFactory::isNotObligatory(std::string theFeature, std::string theAttribute) -{ -/* const static std::string kDefaultId = "Model_FeatureValidator"; - std::map::const_iterator it = myIDs.find(kDefaultId); - if (it != myIDs.end()) { - Model_FeatureValidator* aValidator = dynamic_cast(it->second); - if (aValidator) { - return aValidator->isNotObligatory(theFeature, theAttribute); - } - }*/ - return false; // default -} - -void ModuleBase_FilterFactory::registerConcealment(std::string theFeature, std::string theAttribute) -{ -/* std::map >::iterator aFind = myConcealed.find(theFeature); - if (aFind == myConcealed.end()) { - std::set aNewSet; - aNewSet.insert(theAttribute); - myConcealed[theFeature] = aNewSet; - } else { - aFind->second.insert(theAttribute); - }*/ -} - -bool ModuleBase_FilterFactory::isConcealed(std::string theFeature, std::string theAttribute) -{ - /*std::map >::iterator aFind = myConcealed.find(theFeature); - return aFind != myConcealed.end() && aFind->second.find(theAttribute) != aFind->second.end();*/ - return true; + return NULL; } diff --git a/src/ModuleBase/ModuleBase_FilterFactory.h b/src/ModuleBase/ModuleBase_FilterFactory.h index e1f71dc34..d0d627639 100644 --- a/src/ModuleBase/ModuleBase_FilterFactory.h +++ b/src/ModuleBase/ModuleBase_FilterFactory.h @@ -21,68 +21,40 @@ * the attribute identifier (if attribute is validated). * All accessible filters must be registered by the ID string first. * The instance of this factory can be get in the Workshop interface. - * Keeps the validator objects alive and just returns one of it by request. - * All the needed information is provided to the validator as an argument, + * Keeps the filter objects alive and just returns one of it by request. + * All the needed information is provided to the filter as an argument, * this allows to work with them independently from the feature specific object. */ class ModuleBase_FilterFactory : public QObject { - public: - - //ModuleBase_FilterFactory(); - //virtual ~ModuleBase_FilterFactory() {} - - private: - std::map myIDs; ///< map from ID to registered validator - /// validators IDs to list of arguments - typedef std::map > AttrValidators; - /// validators IDs by feature ID - std::map myFeatures; - /// validators IDs and arguments by feature and attribute IDs - std::map > myAttrs; - /// Stores the registered attributes that leads to the concealment of referenced objects in - /// data tree. Map from feature kind to set of attribute IDs. - std::map > myConcealed; + std::map myIDs; ///< map from ID to registered filter + /// filters IDs to list of arguments + typedef std::map > AttrFilters; + /// filters IDs by feature ID + std::map myFeatures; + /// filters IDs and arguments by feature and attribute IDs + std::map > myAttrs; public: - /// Registers the instance of the validator by the ID + /// Registers the instance of the filter by the ID MODULEBASE_EXPORT virtual void registerFilter(const std::string& theID, - Handle_ModuleBase_Filter theValidator); + Handle_ModuleBase_Filter theFilter); - /// Assigns validator to the attribute of the feature + /// Assigns filter to the attribute of the feature MODULEBASE_EXPORT virtual void assignFilter(const std::string& theID, - const std::string& theFeatureID, - const std::string& theAttrID); - - /// Provides a validator for the attribute, returns NULL if no validator - MODULEBASE_EXPORT const SelectMgr_ListOfFilter& filters(const std::string& theFeatureID, - const std::string& theAttrID) const; + const std::string& theFeatureID, + const std::string& theAttrID); - /// Returns registered validator by its Id - MODULEBASE_EXPORT virtual const Handle_ModuleBase_Filter validator(const std::string& theID) const; + /// Provides a filter for the attribute, returns NULL if no filter + MODULEBASE_EXPORT void filters(const std::string& theFeatureID, + const std::string& theAttrID, + SelectMgr_ListOfFilter& theFilters) const; - /// Returns true if feature and all its attributes are valid. - MODULEBASE_EXPORT virtual bool validate(const std::shared_ptr& theFeature) const; - - /// register that this attribute in feature is not obligatory for the feature execution - /// so, it is not needed for the standard validation mechanism - virtual void registerNotObligatory(std::string theFeature, std::string theAttribute); - - /// Returns true if the attribute in feature is not obligatory for the feature execution - virtual bool isNotObligatory(std::string theFeature, std::string theAttribute); - - /// register that this attribute conceals in the object browser - /// all referenced features after execution - virtual void registerConcealment(std::string theFeature, std::string theAttribute); - - /// Returns true that it was registered that attribute conceals the referenced result - virtual bool isConcealed(std::string theFeature, std::string theAttribute); + /// Returns registered filter by its Id + MODULEBASE_EXPORT virtual const Handle_ModuleBase_Filter filter(const std::string& theID) const; protected: - void addDefaultValidators(std::list& theValidators) const; - /// Get instance from workshop - ModuleBase_FilterFactory(); ~ModuleBase_FilterFactory() {} diff --git a/src/ModuleBase/ModuleBase_FilterLinearEdge.cpp b/src/ModuleBase/ModuleBase_FilterLinearEdge.cpp index 59dc35038..97f5ffa9a 100644 --- a/src/ModuleBase/ModuleBase_FilterLinearEdge.cpp +++ b/src/ModuleBase/ModuleBase_FilterLinearEdge.cpp @@ -25,8 +25,8 @@ #include -IMPLEMENT_STANDARD_HANDLE(ModuleBase_FilterLinearEdge, SelectMgr_Filter); -IMPLEMENT_STANDARD_RTTIEXT(ModuleBase_FilterLinearEdge, SelectMgr_Filter); +IMPLEMENT_STANDARD_HANDLE(ModuleBase_FilterLinearEdge, ModuleBase_Filter); +IMPLEMENT_STANDARD_RTTIEXT(ModuleBase_FilterLinearEdge, ModuleBase_Filter); Standard_Boolean ModuleBase_FilterLinearEdge::IsOk(const Handle(SelectMgr_EntityOwner)& theOwner) const @@ -48,5 +48,5 @@ Standard_Boolean ModuleBase_FilterLinearEdge::IsOk(const Handle(SelectMgr_Entity } } } - return Standard_False; + return isOk; } diff --git a/src/ModuleBase/ModuleBase_FilterLinearEdge.h b/src/ModuleBase/ModuleBase_FilterLinearEdge.h index 286542c92..7f3b798f8 100644 --- a/src/ModuleBase/ModuleBase_FilterLinearEdge.h +++ b/src/ModuleBase/ModuleBase_FilterLinearEdge.h @@ -15,7 +15,7 @@ * A filter which provides filtering of selection in 3d viewer. * Installing of this filter lets to select only object of requested type */ -DEFINE_STANDARD_HANDLE(ModuleBase_FilterLinearEdge, SelectMgr_Filter); +DEFINE_STANDARD_HANDLE(ModuleBase_FilterLinearEdge, ModuleBase_Filter); class ModuleBase_FilterLinearEdge: public ModuleBase_Filter { public: diff --git a/src/ModuleBase/ModuleBase_WidgetShapeSelector.cpp b/src/ModuleBase/ModuleBase_WidgetShapeSelector.cpp index 315edde7f..49fe8cf55 100644 --- a/src/ModuleBase/ModuleBase_WidgetShapeSelector.cpp +++ b/src/ModuleBase/ModuleBase_WidgetShapeSelector.cpp @@ -434,17 +434,24 @@ void ModuleBase_WidgetShapeSelector::activateSelection(bool toActivate) myWorkshop->deactivateSubShapesSelection(); } } - - /*ModuleBase_FilterFactory* aFactory = myWorkshop->selectionFilters(); - const SelectMgr_ListOfFilter& aFilters = aFactory->filters(parentID(), attributeID()); + // apply filters loaded from the XML definition of the widget + ModuleBase_FilterFactory* aFactory = myWorkshop->selectionFilters(); + SelectMgr_ListOfFilter aFilters; + aFactory->filters(parentID(), attributeID(), aFilters); SelectMgr_ListIteratorOfListOfFilter aIt(aFilters); for (; aIt.More(); aIt.Next()) { + Handle(SelectMgr_Filter) aSelFilter = aIt.Value(); + if (aSelFilter.IsNull()) + continue; + Handle(ModuleBase_Filter) aFilter = Handle(ModuleBase_Filter)::DownCast(aIt.Value()); + if (aFilter.IsNull()) + continue; if (myIsActive) aViewer->addSelectionFilter(aFilter); else aViewer->removeSelectionFilter(aFilter); - }*/ + } } //******************************************************************** diff --git a/src/XGUI/XGUI_Workshop.cpp b/src/XGUI/XGUI_Workshop.cpp index 39d1254f3..42308e373 100644 --- a/src/XGUI/XGUI_Workshop.cpp +++ b/src/XGUI/XGUI_Workshop.cpp @@ -431,10 +431,11 @@ void XGUI_Workshop::processEvent(const std::shared_ptr& theMessa std::shared_ptr aMsg = std::dynamic_pointer_cast(theMessage); if (aMsg) { + ModuleBase_FilterFactory* aFactory = moduleConnector()->selectionFilters(); if (aMsg->attributeId().empty()) { // feature validator - moduleConnector()->selectionFilters()->assignFilter(aMsg->selectionFilterId(), aMsg->featureId(), aMsg->attributeId()); + //aFactory->assignFilter(aMsg->selectionFilterId(), aMsg->featureId()); } else { // attribute validator - moduleConnector()->selectionFilters()->assignFilter(aMsg->selectionFilterId(), aMsg->featureId(), aMsg->attributeId()); + aFactory->assignFilter(aMsg->selectionFilterId(), aMsg->featureId(), aMsg->attributeId()); } } } -- 2.39.2