SET(PROJECT_HEADERS
ModuleBase.h
+ ModuleBase_Filter.h
+ ModuleBase_FilterFactory.h
+ ModuleBase_FilterLinearEdge.h
ModuleBase_Tools.h
ModuleBase_IModule.h
ModuleBase_Operation.h
)
SET(PROJECT_SOURCES
+ ModuleBase_Filter.cpp
+ ModuleBase_FilterFactory.cpp
+ ModuleBase_FilterLinearEdge.cpp
ModuleBase_Tools.cpp
ModuleBase_IModule.cpp
+ ModuleBase_IWorkshop.cpp
ModuleBase_Operation.cpp
ModuleBase_OperationDescription.cpp
ModuleBase_ModelWidget.cpp
ModuleBase_WidgetChoice.cpp
ModuleBase_WidgetFileSelector.cpp
ModuleBase_DoubleSpinBox.cpp
- ModuleBase_WidgetLineEdit.cpp
+ ModuleBase_WidgetLineEdit.cpp
ModuleBase_WidgetMultiSelector.cpp
ModuleBase_ViewerFilters.cpp
ModuleBase_ResultPrs.cpp
--- /dev/null
+// File: ModuleBase_Filter.cpp
+// Created: 10 Dec 2014
+// Author: Natalia ERMOLAEVA
+
+
+#include "ModuleBase_Filter.h"
+
+IMPLEMENT_STANDARD_HANDLE(ModuleBase_Filter, SelectMgr_Filter);
+IMPLEMENT_STANDARD_RTTIEXT(ModuleBase_Filter, SelectMgr_Filter);
+
+Standard_Boolean ModuleBase_Filter::IsOk(const Handle(SelectMgr_EntityOwner)& theOwner) const
+{
+ return Standard_True;
+}
--- /dev/null
+// File: ModuleBase_Filter.h
+// Created: 10 Dec 2014
+// Author: Natalia ERMOLAEVA
+
+#ifndef ModuleBase_Filter_H
+#define ModuleBase_Filter_H
+
+#include "ModuleBase.h"
+
+#include <SelectMgr_Filter.hxx>
+
+/**
+ * This object is assigned by the name
+ * in the XML file to the specific attribute or to the whole feature.
+ * If isOK method of the filter returns "false", it is signalized in user interface
+ * that the processed entity should not be selected.
+ * Filterss must be registered in the filters factory to be
+ * correctly identified by the XML string-ID.
+ */
+DEFINE_STANDARD_HANDLE(ModuleBase_Filter, SelectMgr_Filter);
+class ModuleBase_Filter: public SelectMgr_Filter
+{
+public:
+ Standard_EXPORT ModuleBase_Filter(): SelectMgr_Filter() {}
+
+ Standard_EXPORT virtual Standard_Boolean IsOk(const Handle(SelectMgr_EntityOwner)& theOwner) const;
+
+ DEFINE_STANDARD_RTTI(ModuleBase_Filter)
+};
+
+#endif //ModuleBase_Filter
--- /dev/null
+// File: ModuleBase_FilterFactory.h
+// Created: 10 Dec 2014
+// Author: Natalia ERMOLAEVA
+
+#include "ModuleBase_FilterFactory.h"
+
+#include <Model_FeatureValidator.h>
+#include <ModelAPI_Feature.h>
+#include <ModelAPI_Attribute.h>
+#include <ModelAPI_Data.h>
+#include <ModelAPI_AttributeValidator.h>
+#include <Events_Error.h>
+
+
+void ModuleBase_FilterFactory::registerFilter(const std::string& theID,
+ ModuleBase_Filter* theValidator)
+{
+ /*if (myIDs.find(theID) != myIDs.end()) {
+ Events_Error::send(std::string("Validator ") + theID + " is already registered");
+ } else {
+ myIDs[theID] = theValidator;
+ }*/
+}
+
+void ModuleBase_FilterFactory::assignFilter(const std::string& theID,
+ const std::string& theFeatureID,
+ const std::string& theAttrID)
+{
+ /*
+ // create feature-structures if not exist
+ std::map<std::string, std::map<std::string, AttrValidators> >::iterator aFeature = myAttrs.find(
+ theFeatureID);
+ if (aFeature == myAttrs.end()) {
+ myAttrs[theFeatureID] = std::map<std::string, AttrValidators>();
+ aFeature = myAttrs.find(theFeatureID);
+ }
+ // add attr-structure if not exist, or generate error if already exist
+ std::map<std::string, AttrValidators>::iterator anAttr = aFeature->second.find(theAttrID);
+ if (anAttr == aFeature->second.end()) {
+ aFeature->second[theAttrID] = AttrValidators();
+ }
+ //aFeature->second[theAttrID][theID] = theArguments;
+ */
+}
+
+const SelectMgr_ListOfFilter& ModuleBase_FilterFactory::filters(const std::string& theFeatureID,
+ const std::string& theAttrID/*,
+ std::list<ModuleBase_Filter*>& theFilters/*,
+ std::list<std::list<std::string> >& theArguments*/) const
+{
+ SelectMgr_ListOfFilter aFilters;
+ return aFilters;
+ /* std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeature =
+ myAttrs.find(theFeatureID);
+ if (aFeature != myAttrs.cend()) {
+ std::map<std::string, AttrValidators>::const_iterator anAttr = aFeature->second.find(theAttrID);
+ if (anAttr != aFeature->second.end()) {
+ AttrValidators::const_iterator aValIter = anAttr->second.cbegin();
+ for (; aValIter != anAttr->second.cend(); aValIter++) {
+ std::map<std::string, ModuleBase_Filter*>::const_iterator aFound = myIDs.find(
+ aValIter->first);
+ if (aFound == myIDs.end()) {
+ Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
+ } else {
+ theValidators.push_back(aFound->second);
+ theArguments.push_back(aValIter->second);
+ }
+ }
+ }
+ }*/
+}
+
+ModuleBase_FilterFactory::ModuleBase_FilterFactory()
+{
+ //const static std::string kDefaultId = "Model_FeatureValidator";
+ //registerValidator(kDefaultId, new Model_FeatureValidator);
+}
+
+const ModuleBase_Filter* ModuleBase_FilterFactory::validator(const std::string& theID) const
+{
+/* std::map<std::string, ModuleBase_Filter*>::const_iterator aIt = myIDs.find(theID);
+ if (aIt != myIDs.end()) {
+ return aIt->second;
+ }*/
+ return NULL;
+}
+
+void ModuleBase_FilterFactory::addDefaultValidators(std::list<ModuleBase_Filter*>& theValidators) const
+{
+/* const static std::string kDefaultId = "Model_FeatureValidator";
+ std::map<std::string, ModuleBase_Filter*>::const_iterator it = myIDs.find(kDefaultId);
+ if(it == myIDs.end())
+ return;
+ theValidators.push_back(it->second);*/
+}
+
+bool ModuleBase_FilterFactory::validate(const std::shared_ptr<ModelAPI_Feature>& theFeature) const
+{
+/* const static std::string kDefaultId = "Model_FeatureValidator";
+ // check feature validators first
+ std::map<std::string, AttrValidators>::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<std::string, ModuleBase_Filter*>::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<const ModelAPI_FeatureValidator*>(aValFind->second);
+ if (aFValidator) {
+ if (!aFValidator->isValid(theFeature, aValidator->second))
+ return false;
+ }
+ }
+ }
+ // check default validator
+ std::map<std::string, ModuleBase_Filter*>::const_iterator aDefaultVal = myIDs.find(kDefaultId);
+ if(aDefaultVal != myIDs.end()) {
+ static const std::list<std::string> anEmptyArgList;
+ const ModelAPI_FeatureValidator* aFValidator =
+ dynamic_cast<const ModelAPI_FeatureValidator*>(aDefaultVal->second);
+ if (aFValidator) {
+ if (!aFValidator->isValid(theFeature, anEmptyArgList))
+ return false;
+ }
+ }
+
+ // check all attributes for validity
+ std::shared_ptr<ModelAPI_Data> 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<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeatureIter =
+ myAttrs.find(theFeature->getKind());
+ if (aFeatureIter != myAttrs.cend()) {
+ std::list<std::string> aLtAttributes = aData->attributesIDs(kAllTypes);
+ std::list<std::string>::iterator anAttrIter = aLtAttributes.begin();
+ for (; anAttrIter != aLtAttributes.end(); anAttrIter++) {
+ std::map<std::string, AttrValidators>::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<std::string, ModuleBase_Filter*>::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<const ModelAPI_AttributeValidator*>(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<std::string, ModuleBase_Filter*>::const_iterator it = myIDs.find(kDefaultId);
+ if (it != myIDs.end()) {
+ Model_FeatureValidator* aValidator = dynamic_cast<Model_FeatureValidator*>(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<std::string, ModuleBase_Filter*>::const_iterator it = myIDs.find(kDefaultId);
+ if (it != myIDs.end()) {
+ Model_FeatureValidator* aValidator = dynamic_cast<Model_FeatureValidator*>(it->second);
+ if (aValidator) {
+ return aValidator->isNotObligatory(theFeature, theAttribute);
+ }
+ }*/
+ return false; // default
+}
+
+void ModuleBase_FilterFactory::registerConcealment(std::string theFeature, std::string theAttribute)
+{
+/* std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
+ if (aFind == myConcealed.end()) {
+ std::set<std::string> aNewSet;
+ aNewSet.insert(theAttribute);
+ myConcealed[theFeature] = aNewSet;
+ } else {
+ aFind->second.insert(theAttribute);
+ }*/
+}
+
+bool ModuleBase_FilterFactory::isConcealed(std::string theFeature, std::string theAttribute)
+{
+ /*std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
+ return aFind != myConcealed.end() && aFind->second.find(theAttribute) != aFind->second.end();*/
+ return true;
+}
--- /dev/null
+// File: ModuleBase_FilterFactory.h
+// Created: 10 Dec 2014
+// Author: Natalia ERMOLAEVA
+
+#ifndef ModuleBase_FilterFactory_H
+#define ModeleBase_SelectionFilterFactory_H
+
+#include "ModuleBase.h"
+#include "ModuleBase_IWorkshop.h"
+
+#include <SelectMgr_ListOfFilter.hxx>
+
+#include <map>
+#include <set>
+
+class ModuleBase_Filter;
+
+/**
+ * Allows to get a selection filter by the feature identifier and
+ * 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,
+ * 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<std::string, ModuleBase_Filter*> myIDs; ///< map from ID to registered validator
+ /// validators IDs to list of arguments
+ typedef std::map<std::string, std::list<std::string> > AttrValidators;
+ /// validators IDs by feature ID
+ std::map<std::string, AttrValidators> myFeatures;
+ /// validators IDs and arguments by feature and attribute IDs
+ std::map<std::string, std::map<std::string, AttrValidators> > 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<std::string, std::set<std::string> > myConcealed;
+
+ public:
+ /// Registers the instance of the validator by the ID
+ MODULEBASE_EXPORT virtual void registerFilter(const std::string& theID,
+ ModuleBase_Filter* theValidator);
+
+ /// Assigns validator 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;
+
+ /// Returns registered validator by its Id
+ MODULEBASE_EXPORT virtual const ModuleBase_Filter* validator(const std::string& theID) const;
+
+ /// Returns true if feature and all its attributes are valid.
+ MODULEBASE_EXPORT virtual bool validate(const std::shared_ptr<ModelAPI_Feature>& 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);
+
+protected:
+ void addDefaultValidators(std::list<ModuleBase_Filter*>& theValidators) const;
+ /// Get instance from workshop
+
+ ModuleBase_FilterFactory();
+
+ ~ModuleBase_FilterFactory() {}
+
+ friend class ModuleBase_IWorkshop;
+
+};
+
+#endif //ModuleBase_FilterFactory
--- /dev/null
+// File: ModuleBase_FilterLinearEdge.cpp
+// Created: 10 Dec 2014
+// Author: Natalia ERMOLAEVA
+
+
+#include "ModuleBase_FilterLinearEdge.h"
+#include "ModuleBase_IWorkshop.h"
+
+#include <ModelAPI_Session.h>
+#include <ModelAPI_Document.h>
+#include <ModelAPI_ResultConstruction.h>
+
+#include <AIS_InteractiveObject.hxx>
+#include <AIS_Shape.hxx>
+
+#include <StdSelect_BRepOwner.hxx>
+
+#include <GeomAPI_Edge.h>
+
+#include <BRep_Tool.hxx>
+#include <TopoDS.hxx>
+#include <TopoDS_Edge.hxx>
+#include <Geom_Curve.hxx>
+
+
+IMPLEMENT_STANDARD_HANDLE(ModuleBase_FilterLinearEdge, SelectMgr_Filter);
+IMPLEMENT_STANDARD_RTTIEXT(ModuleBase_FilterLinearEdge, SelectMgr_Filter);
+
+
+Standard_Boolean ModuleBase_FilterLinearEdge::IsOk(const Handle(SelectMgr_EntityOwner)& theOwner) const
+{
+ Standard_Boolean isOk = ModuleBase_Filter::IsOk(theOwner);
+ if (isOk && theOwner->HasSelectable()) {
+ Handle(AIS_InteractiveObject) anAIS =
+ Handle(AIS_InteractiveObject)::DownCast(theOwner->Selectable());
+ if (!anAIS.IsNull()) {
+ Handle(AIS_Shape) aShapeAIS = Handle(AIS_Shape)::DownCast(anAIS);
+ if (aShapeAIS) {
+ const TopoDS_Shape& aShape = aShapeAIS->Shape();
+ if (aShape.ShapeType() == TopAbs_EDGE) {
+ std::shared_ptr<GeomAPI_Edge> anEdge = std::shared_ptr<GeomAPI_Edge>(new GeomAPI_Edge());
+ anEdge->setImpl(new TopoDS_Shape(aShape));
+
+ isOk = anEdge->isLine();
+ }
+ }
+ }
+ }
+ return Standard_False;
+}
--- /dev/null
+// File: ModuleBase_FilterLinearEdge.h
+// Created: 10 Dec 2014
+// Author: Natalia ERMOLAEVA
+
+#ifndef ModuleBase_FilterLinearEdge_H
+#define ModuleBase_FilterLinearEdge_H
+
+#include "ModuleBase.h"
+
+#include "ModuleBase_Filter.h"
+
+/**
+* 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);
+class ModuleBase_FilterLinearEdge: public ModuleBase_Filter
+{
+public:
+ Standard_EXPORT ModuleBase_FilterLinearEdge():
+ ModuleBase_Filter() {}
+
+ Standard_EXPORT virtual Standard_Boolean IsOk(const Handle(SelectMgr_EntityOwner)& theOwner) const;
+
+ DEFINE_STANDARD_RTTI(ModuleBase_FilterLinearEdge)
+
+};
+
+#endif //ModuleBase_FilterLinearEdge
void ModuleBase_IModule::createFeatures()
{
registerValidators();
+ registerFilters();
Config_ModuleReader aXMLReader = Config_ModuleReader();
aXMLReader.readAll();
/// Register validators for this module\r
virtual void registerValidators() {}\r
\r
+ /// Register selection filters for this module\r
+ virtual void registerFilters() {}\r
+\r
/// Returns new instance of operation object (used in createOperation for customization)\r
virtual ModuleBase_Operation* getNewOperation(const std::string& theFeatureId);\r
\r
--- /dev/null
+// File: ModuleBase_ModelWidget.h
+// Created: 25 Apr 2014
+// Author: Natalia ERMOLAEVA
+
+#include "ModuleBase_IWorkshop.h"
+#include "ModuleBase_FilterFactory.h"
+
+ModuleBase_FilterFactory* ModuleBase_IWorkshop::selectionFilters() const
+{
+ static ModuleBase_FilterFactory* aFactory = new ModuleBase_FilterFactory;
+ return aFactory;
+}
class ModuleBase_ISelection;
class ModuleBase_IViewer;
class ModuleBase_Operation;
+class ModuleBase_FilterFactory;
/**
* Class which provides access to Workshop object serveces
//! Returns current viewer
virtual ModuleBase_IViewer* viewer() const = 0;
+ //! Returns the factory of selection filters : the only one instance per application
+ ModuleBase_FilterFactory* selectionFilters() const;
+
//! Returns currently active operation
virtual ModuleBase_Operation* currentOperation() const = 0;
#include <ModuleBase_IWorkshop.h>
#include <ModuleBase_IViewer.h>
#include <ModuleBase_Tools.h>
+#include <ModuleBase_FilterFactory.h>
+#include <ModuleBase_Filter.h>
#include <Config_WidgetAPI.h>
#include <Events_Loop.h>
#include <GeomAPI_Shape.h>
+#include <SelectMgr_ListIteratorOfListOfFilter.hxx>
#include <TopoDS_Shape.hxx>
#include <TopExp_Explorer.hxx>
return;
myIsActive = toActivate;
updateSelectionName();
+ ModuleBase_IViewer* aViewer = myWorkshop->viewer();
if (myIsActive) {
connect(myWorkshop, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
myWorkshop->activateSubShapesSelection(aList);
if (!myObjectTypes.isEmpty()) {
myObjTypeFilter = new ModuleBase_ObjectTypesFilter(myWorkshop, myObjectTypes);
- myWorkshop->viewer()->clearSelectionFilters();
- myWorkshop->viewer()->addSelectionFilter(myObjTypeFilter);
+ aViewer->clearSelectionFilters();
+ aViewer->addSelectionFilter(myObjTypeFilter);
}
}
} else {
disconnect(myWorkshop, SIGNAL(selectionChanged()), this, SLOT(onSelectionChanged()));
if (myUseSubShapes) {
if (!myObjTypeFilter.IsNull()) {
- myWorkshop->viewer()->removeSelectionFilter(myObjTypeFilter);
+ aViewer->removeSelectionFilter(myObjTypeFilter);
myObjTypeFilter.Nullify();
}
myWorkshop->deactivateSubShapesSelection();
}
}
+
+ /*ModuleBase_FilterFactory* aFactory = myWorkshop->selectionFilters();
+ const SelectMgr_ListOfFilter& aFilters = aFactory->filters(parentID(), attributeID());
+ SelectMgr_ListIteratorOfListOfFilter aIt(aFilters);
+ for (; aIt.More(); aIt.Next()) {
+ Handle(ModuleBase_Filter) aFilter = Handle(ModuleBase_Filter)::DownCast(aIt.Value());
+ if (myIsActive)
+ aViewer->addSelectionFilter(aFilter);
+ else
+ aViewer->removeSelectionFilter(aFilter);
+ }*/
}
//********************************************************************
#include <ModuleBase_IViewWindow.h>
#include <ModuleBase_IPropertyPanel.h>
#include <ModuleBase_WidgetEditor.h>
+#include <ModuleBase_FilterFactory.h>
+#include <ModuleBase_FilterLinearEdge.h>
+
#include <ModelAPI_Object.h>
#include <ModelAPI_Events.h>
aFactory->registerValidator("PartSet_DifferentObjects", new PartSet_DifferentObjectsValidator);
}
+void PartSet_Module::registerFilters()
+{
+ //Registering of selection filters
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
+ ModuleBase_FilterFactory* aFactory = aConnector->selectionFilters();
+
+ aFactory->registerFilter("LinearEdgeFilter", new ModuleBase_FilterLinearEdge);
+}
void PartSet_Module::onOperationComitted(ModuleBase_Operation* theOperation)
{
/// Register validators for this module
virtual void registerValidators();
+ /// Register selection filters for this module
+ virtual void registerFilters();
+
private slots:
void onVertexSelected(ObjectPtr theObject, const TopoDS_Shape& theShape);
#include <ModuleBase_WidgetFactory.h>
#include <ModuleBase_Tools.h>
#include <ModuleBase_IViewer.h>
+#include<ModuleBase_FilterFactory.h>
#include <Config_Common.h>
#include <Config_FeatureMessage.h>
#include <Config_PointerMessage.h>
#include <Config_ModuleReader.h>
#include <Config_PropManager.h>
+#include <Config_SelectionFilterMessage.h>
#include <QApplication>
#include <QFileDialog>
aLoop->registerListener(this, Events_Loop::eventByName("CurrentDocumentChanged"));
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TOSHOW));
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TOHIDE));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_SELFILTER_LOADED));
registerValidators();
+
// Calling of loadCustomProps before activating module is required
// by Config_PropManger to restore user-defined path to plugins
ModuleBase_Preferences::loadCustomProps();
// If not found then activate global document
activatePart(ResultPartPtr());
- } else {
+ }
+ else if (theMessage->eventID() == Events_Loop::eventByName(EVENT_SELFILTER_LOADED)) {
+ std::shared_ptr<Config_SelectionFilterMessage> aMsg =
+ std::dynamic_pointer_cast<Config_SelectionFilterMessage>(theMessage);
+ if (aMsg) {
+ if (aMsg->attributeId().empty()) { // feature validator
+ moduleConnector()->selectionFilters()->assignFilter(aMsg->selectionFilterId(), aMsg->featureId(), aMsg->attributeId());
+ } else { // attribute validator
+ moduleConnector()->selectionFilters()->assignFilter(aMsg->selectionFilterId(), aMsg->featureId(), aMsg->attributeId());
+ }
+ }
+ }
+
+
+ else {
//Show error dialog if error message received.
std::shared_ptr<Events_Error> anAppError = std::dynamic_pointer_cast<Events_Error>(theMessage);
if (anAppError) {
