\r
bool getBooleanAttribute(xmlNodePtr theNode, const char* theAttributeName, bool theDefault)\r
{\r
- std::string prop = getProperty(theNode, theAttributeName);\r
- std::transform(prop.begin(), prop.end(), prop.begin(), ::tolower);\r
+ std::string prop = normalize(getProperty(theNode, theAttributeName));\r
bool result = theDefault;\r
if (prop == "true" || prop == "1") {\r
result = true;\r
}\r
return result;\r
}\r
+\r
+CONFIG_EXPORT std::string normalize(const char* theString)\r
+{\r
+ if (!theString)\r
+ return std::string();\r
+ return normalize(std::string(theString));\r
+}\r
+\r
+CONFIG_EXPORT std::string normalize(const std::string& theString)\r
+{\r
+ std::string result = theString;\r
+ std::transform(result.begin(), result.end(), result.begin(), ::tolower);\r
+ return result;\r
+}\r
const char* theAttributeName,
bool theDefault);
+/*
+ * Returns normalized (lower case) version of string.
+ * Should be used for case insensitive string matching.
+ */
+CONFIG_EXPORT std::string normalize(const char* theString);
+CONFIG_EXPORT std::string normalize(const std::string& theString);
+
#endif
const static char* PLUGIN_CONFIG = "configuration";
const static char* PLUGIN_LIBRARY = "library";
const static char* PLUGIN_SCRIPT = "script";
+const static char* PLUGIN_PLATFORM = "platform";
+
+const static char* PLUGIN_PLATFORM_SALOME = "salome";
+const static char* PLUGIN_PLATFORM_NEWGEOM = "openparts";
+
+
#endif /* CONFIG_KEYWORDS_H_ */
//Necessary for cerr
#include <iostream>
+#include <algorithm>
#ifdef WIN32
#include <windows.h>
+#pragma warning(disable : 4996) // for getenv
#else
#include <dlfcn.h>
#endif
: Config_XMLReader(PLUGIN_FILE),
myEventGenerated(theEventGenerated)
{
+ myHaveSalome = false;
+ char* anEnv = getenv("SALOME_ROOT_DIR");
+ std::string value = normalize(anEnv);
+ if (!value.empty()) {
+ myHaveSalome = true;
+ }
+
}
Config_ModuleReader::~Config_ModuleReader()
void Config_ModuleReader::processNode(xmlNodePtr theNode)
{
if (isNode(theNode, NODE_PLUGIN, NULL)) {
+ bool isAvailable = isAvaliableOnThisPlatform(getProperty(theNode, PLUGIN_PLATFORM));
+ if (!isAvailable)
+ return;
std::string aPluginConf = getProperty(theNode, PLUGIN_CONFIG);
std::string aPluginLibrary = getProperty(theNode, PLUGIN_LIBRARY);
std::string aPluginScript = getProperty(theNode, PLUGIN_SCRIPT);
}
if(!aPluginName.empty()) {
myPluginTypes[aPluginName] = aType;
-
}
+
return aPluginName;
}
}
}
+bool Config_ModuleReader::isAvaliableOnThisPlatform(const std::string& thePluginPlatform)
+{
+ bool result = true;
+ PluginPlatform aPlatform = All;
+ std::string aPlatformName = normalize(thePluginPlatform) ;
+ if (aPlatformName == PLUGIN_PLATFORM_SALOME) {
+ aPlatform = Salome;
+ } else if (aPlatformName == PLUGIN_PLATFORM_NEWGEOM) {
+ aPlatform = OpenParts;
+ } else if (!thePluginPlatform.empty()) {
+ Events_Error::send("Unknown platform: " + thePluginPlatform);
+ }
+ if (aPlatform == All) {
+ result = true;
+ } else if (myHaveSalome) {
+ result = aPlatform == Salome;
+ } else {
+ result = aPlatform == OpenParts;
+ }
+ return result;
+
+}
+
void Config_ModuleReader::loadScript(const std::string theFileName)
{
/* aquire python thread */
Intrenal = 1,
Python = 2
};
+ enum PluginPlatform {
+ All = 0,
+ OpenParts = 1,
+ Salome = 2
+ };
public:
CONFIG_EXPORT Config_ModuleReader(const char* theEventGenerated = 0);
void processNode(xmlNodePtr aNode);
bool processChildren(xmlNodePtr aNode);
+ bool isAvaliableOnThisPlatform(const std::string& thePluginPlatform);
std::list<std::string> importPlugin(const std::string& thePluginLibrary,
const std::string& thePluginFile);
std::string addPlugin(const std::string& aPluginLibrary,
std::map<std::string, std::string> myFeaturesInFiles;
static std::map<std::string, PluginType> myPluginTypes;
const char* myEventGenerated;
+ bool myHaveSalome;
};
<plugin library="ConstructionPlugin" configuration="plugin-Construction.xml"/>
<plugin library="FeaturesPlugin" configuration="plugin-Features.xml"/>
<plugin library="ExchangePlugin" configuration="plugin-Exchange.xml"/>
- <plugin script="ConnectorPlugin" configuration="plugin-Connector.xml"/>
+ <plugin script="ConnectorPlugin" configuration="plugin-Connector.xml" platform="Salome"/>
<plugin library="SketchSolver"/>
<plugin library="GeomValidators"/>
<plugin library="DFBrowser" internal="true"/>
id="ExportToGEOM"
title="Export to GEOM"
tooltip="Exports all bodies into GEOM module"
- icon=":pictures/part_ico.png"/>
+ icon=":icons/geom_export.png"/>
</group>
</workbench>
</plugin>
\ No newline at end of file
#include <XGUI_ModuleConnector.h>
#include <XGUI_Displayer.h>
#include <XGUI_Workshop.h>
+#include <XGUI_Selection.h>
#include <ModuleBase_IViewer.h>
#include <ModuleBase_IWorkshop.h>
#include <SketchPlugin_ConstraintRadius.h>
#include <SketchPlugin_ConstraintRigid.h>
+#include <SelectMgr_IndexedMapOfOwner.hxx>
+#include <StdSelect_BRepOwner.hxx>
+
#include <ModelAPI_Events.h>
#include <QMouseEvent>
std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
if (aSketchFeature) {
+ // save the previous selection
+ /*ModuleBase_IWorkshop* aWorkshop = myModule->workshop();
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(aWorkshop);
+ XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
+ QIntList anActivatedModes;
+
+ ResultPtr aResult = aSketchFeature->firstResult();
+
+ aDisplayer->getModesOfActivation(aResult, anActivatedModes);
+
+ std::list<AttributePtr> aSelectedAttributes;
+ getCurrentSelection(aSketchFeature, myCurrentSketch, aWorkshop, aSelectedAttributes);*/
+ // save the previous selection: end
+
+
aSketchFeature->move(dX, dY);
ModelAPI_EventCreator::get()->sendUpdated(aSketchFeature, anEvent);
+ /*
+ // TODO: the selection restore should be after the AIS presentation is rebuilt
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_MOVED));
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+
+ // restore the previous selection
+ aResult = aSketchFeature->firstResult();
+ aDisplayer->activate(aResult, anActivatedModes);
+
+ SelectMgr_IndexedMapOfOwner anOwnersToSelect;
+ getSelectionOwners(aSketchFeature, myCurrentSketch, aWorkshop, aSelectedAttributes,
+ anOwnersToSelect);
+
+ ModuleBase_IViewer* aViewer = aWorkshop->viewer();
+ Handle(AIS_InteractiveContext) aContext = aViewer->AISContext();
+ for (Standard_Integer i = 1, n = anOwnersToSelect.Extent(); i <= n; i++)
+ aContext->AddOrRemoveSelected(anOwnersToSelect(i), false); // SetSelected()
+
+ aContext->UpdateCurrentViewer();
+ // restore the previous selection*/
}
}
+ // TODO: set here
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_MOVED));
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
}
{
myPlaneFilter->setPlane(thePln->impl<gp_Pln>());
}
+
+void PartSet_SketcherMgr::getCurrentSelection(const ObjectPtr& theObject,
+ const FeaturePtr& theSketch,
+ ModuleBase_IWorkshop* theWorkshop,
+ std::list<AttributePtr>& theSelectedAttributes)
+{
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+ if (aFeature.get() == NULL)
+ return;
+
+ ModuleBase_IViewer* aViewer = theWorkshop->viewer();
+ Handle(AIS_InteractiveContext) aContext = aViewer->AISContext();
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(theWorkshop);
+ XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
+
+ // TODO: check all results and IPresentable feature
+ ResultPtr aResult = aFeature->firstResult();
+
+ bool isVisibleSketch = aDisplayer->isVisible(aResult);
+ AISObjectPtr aAISObj = aDisplayer->getAISObject(aResult);
+
+ if (aAISObj.get() != NULL) {
+ Handle(AIS_InteractiveObject) anAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+ for (aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected())
+ {
+ Handle(StdSelect_BRepOwner) aBRepOwner = Handle(StdSelect_BRepOwner)::DownCast(
+ aContext->SelectedOwner());
+ if (aBRepOwner.IsNull()) continue;
+
+ Handle(AIS_InteractiveObject) anIO = Handle(AIS_InteractiveObject)::DownCast(
+ aBRepOwner->Selectable());
+ if (anIO != anAISIO) continue;
+
+ if (aBRepOwner->HasShape()) {
+ const TopoDS_Shape& aShape = aBRepOwner->Shape();
+ TopAbs_ShapeEnum aShapeType = aShape.ShapeType();
+ if (aShapeType == TopAbs_VERTEX) {
+ AttributePtr aPntAttr = PartSet_Tools::findAttributeBy2dPoint(theObject,
+ aShape, theSketch);
+ if (aPntAttr.get() != NULL)
+ theSelectedAttributes.push_back(aPntAttr);
+ }
+ }
+ }
+ }
+}
+
+void PartSet_SketcherMgr::getSelectionOwners(const ObjectPtr& theObject,
+ const FeaturePtr& theSketch,
+ ModuleBase_IWorkshop* theWorkshop,
+ const std::list<AttributePtr>& theSelectedAttributes,
+ SelectMgr_IndexedMapOfOwner& anOwnersToSelect)
+{
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+ if (aFeature.get() == NULL)
+ return;
+
+ ModuleBase_IViewer* aViewer = theWorkshop->viewer();
+ Handle(AIS_InteractiveContext) aContext = aViewer->AISContext();
+ XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(theWorkshop);
+ XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
+
+ // TODO: check all results and IPresentable feature
+ ResultPtr aResult = aFeature->firstResult();
+
+ bool isVisibleSketch = aDisplayer->isVisible(aResult);
+ AISObjectPtr aAISObj = aDisplayer->getAISObject(aResult);
+
+ if (aAISObj.get() != NULL) {
+ Handle(AIS_InteractiveObject) anAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+
+ SelectMgr_IndexedMapOfOwner aSelectedOwners;
+
+ XGUI_Selection::entityOwners(anAISIO, aContext, aSelectedOwners);
+ for ( Standard_Integer i = 1, n = aSelectedOwners.Extent(); i <= n; i++ ) {
+ Handle(StdSelect_BRepOwner) anOwner = Handle(StdSelect_BRepOwner)::DownCast(aSelectedOwners(i));
+ if ( anOwner.IsNull() || !anOwner->HasShape() )
+ continue;
+ const TopoDS_Shape& aShape = anOwner->Shape();
+ TopAbs_ShapeEnum aShapeType = aShape.ShapeType();
+ if (aShapeType == TopAbs_VERTEX) {
+ AttributePtr aPntAttr = PartSet_Tools::findAttributeBy2dPoint(aFeature, aShape, theSketch);
+ if (aPntAttr.get() != NULL) {
+ std::list<AttributePtr>::const_iterator anIt = theSelectedAttributes.begin(),
+ aLast = theSelectedAttributes.end();
+ for (; anIt != aLast; anIt++) {
+ AttributePtr anAttrIt = *anIt;
+ if (anAttrIt.get() == aPntAttr.get()) {
+ anOwnersToSelect.Add(anOwner);
+ }
+ }
+ }
+ }
+ }
+ }
+}
#include <ModelAPI_CompositeFeature.h>
#include <ModuleBase_ViewerFilters.h>
+#include <ModuleBase_Definitions.h>
#include <GeomAPI_Pln.h>
+#include <SelectMgr_IndexedMapOfOwner.hxx>
#include <QObject>
#include <QList>
void get2dPoint(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent,
double& theX, double& theY);
+ /// Obtains the current selection of the object in the workshop viewer
+ /// It includes the selection in all modes of activation, even local context - vertexes, edges
+ /// The result is a list of attributes of the feature of the object
+ /// In addition, it retuns a list of selection modes, where the object is activated
+ /// \param theObject a feature or result object
+ /// \param theSketch a current sketch feature
+ /// \param theWorkshop a workshop to have an access to AIS context and displayer
+ /// \param theSelectedAttributes an out list of selected attributes
+ static void getCurrentSelection(const ObjectPtr& theObject,
+ const FeaturePtr& theSketch,
+ ModuleBase_IWorkshop* theWorkshop,
+ std::list<AttributePtr>& theSelectedAttributes);
+
+ /// Applyes the current selection to the object in the workshop viewer
+ /// It includes the selection in all modes of activation, even local context - vertexes, edges
+ /// The result is a list of attributes of the feature of the object
+ /// In addition, it retuns a list of selection modes, where the object is activated
+ /// \param theObject a feature or result object
+ /// \param theSketch a current sketch feature
+ /// \param theWorkshop a workshop to have an access to AIS context and displayer
+ /// \param theSelectedAttributes an out list of selected attributes
+ static void getSelectionOwners(const ObjectPtr& theObject,
+ const FeaturePtr& theSketch,
+ ModuleBase_IWorkshop* theWorkshop,
+ const std::list<AttributePtr>& theSelectedAttributes,
+ SelectMgr_IndexedMapOfOwner& anOwnersToSelect);
private:
PartSet_Module* myModule;
<file>icons/shape_group.png</file>
<file>icons/fixed.png</file>
<file>icons/placement.png</file>
+ <file>icons/geom_export.png</file>
</qresource>
</RCC>
}
}
+void XGUI_Displayer::getModesOfActivation(ObjectPtr theObject, QIntList& theModes)
+{
+ if (!isVisible(theObject))
+ return;
+
+ Handle(AIS_InteractiveContext) aContext = AISContext();
+ if (aContext.IsNull())
+ return;
+
+ AISObjectPtr aAISObj = getAISObject(theObject);
+
+ if (aAISObj.get() != NULL) {
+ Handle(AIS_InteractiveObject) anAISIO = aAISObj->impl<Handle(AIS_InteractiveObject)>();
+ TColStd_ListOfInteger aTColModes;
+ aContext->ActivatedModes(anAISIO, aTColModes);
+ TColStd_ListIteratorOfListOfInteger itr( aTColModes );
+ for (; itr.More(); itr.Next() ) {
+ theModes.append(itr.Value());
+ }
+ }
+}
+
void XGUI_Displayer::activateObjects(const QIntList& theModes)
{
// In order to avoid doblications of selection modes
void updateViewer();
/// Searches the interactive object by feature
- /// \param theFeature the feature or NULL if it not visualized
+ /// \param theFeature the object or presentable feature
/// \return theIO an interactive object
AISObjectPtr getAISObject(ObjectPtr theFeature) const;
/// \param theModes - modes on which it has to be activated (can be empty)
void activate(ObjectPtr theFeature, const QIntList& theModes);
+ /// Returns the modes of activation
+ /// \param theFeature the feature or NULL if it not visualized
+ /// \param theModes - modes on which it is activated (can be empty)
+ void getModesOfActivation(ObjectPtr theObject, QIntList& theModes);
+
/// Activates the given object with default modes
void activate(ObjectPtr theFeature);
#include <AIS_InteractiveContext.hxx>
+#include <SelectMgr_Selection.hxx>
+#include <SelectBasics_SensitiveEntity.hxx>
+#include <TColStd_ListIteratorOfListOfInteger.hxx>
+
#include <set>
XGUI_Selection::XGUI_Selection(XGUI_Workshop* theWorkshop)
}
}
}
+
+//**************************************************************
+void XGUI_Selection::entityOwners(const Handle(AIS_InteractiveObject)& theObject,
+ const Handle(AIS_InteractiveContext)& theContext,
+ SelectMgr_IndexedMapOfOwner& theOwners)
+{
+ if (theObject.IsNull() || theContext.IsNull())
+ return;
+
+ TColStd_ListOfInteger aModes;
+ theContext->ActivatedModes(theObject, aModes);
+
+ TColStd_ListIteratorOfListOfInteger anIt(aModes);
+ for (; anIt.More(); anIt.Next()) {
+ int aMode = anIt.Value();
+ if (!theObject->HasSelection(aMode))
+ continue;
+
+ Handle(SelectMgr_Selection) aSelection = theObject->Selection(aMode);
+ for (aSelection->Init(); aSelection->More(); aSelection->Next()) {
+ Handle(SelectBasics_SensitiveEntity) anEntity = aSelection->Sensitive();
+ if (anEntity.IsNull())
+ continue;
+ Handle(SelectMgr_EntityOwner) anOwner =
+ Handle(SelectMgr_EntityOwner)::DownCast(anEntity->OwnerId());
+ if (!anOwner.IsNull())
+ theOwners.Add(anOwner);
+ }
+ }
+}
#include <NCollection_List.hxx>
#include <TopoDS_Shape.hxx>
+#include <SelectMgr_IndexedMapOfOwner.hxx>
+
class XGUI_Workshop;
class XGUI_EXPORT XGUI_Selection : public ModuleBase_ISelection
virtual void selectedShapes(NCollection_List<TopoDS_Shape>& theShapes,
std::list<ObjectPtr>& theOwners) const;
+ //! Returns a list of selection entity owners of the interactive object
+ /// It depends on the modes, in which the object is activated in the context
+ /// \param theObject an object
+ /// \param theContext a viewer interactive context
+ /// \param theOwners a map of entity owners
+ static void entityOwners(const Handle_AIS_InteractiveObject& theObject,
+ const Handle_AIS_InteractiveContext& theContext,
+ SelectMgr_IndexedMapOfOwner& theOwners);
+
private:
XGUI_Workshop* myWorkshop;
};
