Config_FeatureReader::Config_FeatureReader(const std::string& theXmlFile,
const std::string& theLibraryName,
+ const std::string& theDocSection,
const char* theEventGenerated)
: Config_XMLReader(theXmlFile),
myLibraryName(theLibraryName),
+ myLibraryDocSection(theDocSection),
myEventGenerated(theEventGenerated ? theEventGenerated : Config_FeatureMessage::GUI_EVENT()),
myIsProcessWidgets(theEventGenerated != NULL)
{
outFeatureMessage->setInternal(isInternal);
std::string aHelpFile = getProperty(theFeatureNode, HELP_FILE);
- if (!aHelpFile.empty())
- outFeatureMessage->setHelpFileName(myLibraryName + "/" + aHelpFile);
+ if (!aHelpFile.empty()) {
+ aHelpFile =
+ (myLibraryDocSection.empty() ? myLibraryName : myLibraryDocSection) + "/" + aHelpFile;
+ outFeatureMessage->setHelpFileName(aHelpFile);
+ }
bool isHideFaces = getBooleanAttribute(theFeatureNode, HIDEFACES_PANEL, false);
outFeatureMessage->setHideFacesPanel(isHideFaces);
/// Constructor
Config_FeatureReader(const std::string& theXmlFile,
const std::string& theLibraryName,
+ const std::string& theDocSection = std::string(),
const char* theEventGenerated = 0);
virtual ~Config_FeatureReader();
/// Returns list of all features defined in reader's file
private:
std::string myLibraryName;
+ std::string myLibraryDocSection;
std::list<std::string> myFeatures;
/// event generated on feature data sending, by default it is Config_FeatureMessage::GUI_EVENT()
MAYBE_UNUSED const static char* PLUGIN_SCRIPT = "script";
MAYBE_UNUSED const static char* PLUGIN_DEPENDENCY = "dependency";
MAYBE_UNUSED const static char* PLUGIN_USES = "uses";
+MAYBE_UNUSED const static char* PLUGIN_DOCSECTION = "docsection";
+MAYBE_UNUSED const static char* PLUGIN_LICENSE = "license";
/*
* Hardcoded xml entities of dataModel.xml
return myFeaturesInFiles;
}
+const std::map<std::string, std::string>& Config_ModuleReader::proprietaryFeatures() const
+{
+ return myProprietaryFeatures;
+}
+
+const std::set<std::string>& Config_ModuleReader::proprietaryPlugins() const
+{
+ return myProprietaryPlugins;
+}
+
const std::set<std::string>& Config_ModuleReader::modulePluginFiles() const
{
return myPluginFiles;
void Config_ModuleReader::addFeature(const std::string& theFeatureName,
const std::string& thePluginConfig)
{
+ if (myProprietaryFeatures.count(theFeatureName)) {
+ myProprietaryFeatures.erase(theFeatureName);
+ }
+
if (myFeaturesInFiles.count(theFeatureName)) {
std::string anErrorMsg = "Can not register feature '%1' in plugin '%2'."
" There is a feature with the same ID.";
myFeaturesInFiles[theFeatureName] = thePluginConfig;
}
+void Config_ModuleReader::addFeatureRequireLicense(const std::string& theFeatureName,
+ const std::string& thePluginConfig)
+{
+ if (myFeaturesInFiles.count(theFeatureName) ||
+ myProprietaryFeatures.count(theFeatureName)) {
+ std::string anErrorMsg = "Can not register feature '%1' in plugin '%2'."
+ " There is a feature with the same ID.";
+ Events_InfoMessage("Config_ModuleReader", anErrorMsg)
+ .arg(theFeatureName).arg(thePluginConfig).send();
+ return;
+ }
+
+ myProprietaryFeatures[theFeatureName] = thePluginConfig;
+}
+
void Config_ModuleReader::processNode(xmlNodePtr theNode)
{
if (isNode(theNode, NODE_PLUGIN, NULL)) {
std::string aPluginLibrary = getProperty(theNode, PLUGIN_LIBRARY);
std::string aPluginScript = getProperty(theNode, PLUGIN_SCRIPT);
std::string aPluginName = addPlugin(aPluginLibrary, aPluginScript, aPluginConf);
+ std::string aPluginDocSection = getProperty(theNode, PLUGIN_DOCSECTION);
std::string aUsesPlugin = getProperty(theNode, PLUGIN_USES);
if (!aUsesPlugin.empty()) { // send information about the plugin dependencies
std::shared_ptr<Config_PluginMessage> aMess(new Config_PluginMessage(
Events_Loop::loop()->send(aMess);
}
- std::list<std::string> aFeatures = importPlugin(aPluginName, aPluginConf);
+ std::string aLicense = getProperty(theNode, PLUGIN_LICENSE);
+ std::transform(aLicense.begin(), aLicense.end(), aLicense.begin(), ::tolower);
+ bool isLicensed = aLicense == "true";
+ if (isLicensed)
+ myProprietaryPlugins.insert(aPluginName);
+
+ std::list<std::string> aFeatures = importPlugin(aPluginName, aPluginConf, aPluginDocSection);
std::list<std::string>::iterator it = aFeatures.begin();
for (; it != aFeatures.end(); it++) {
- addFeature(*it, aPluginConf);
+ if (isLicensed)
+ addFeatureRequireLicense(*it, aPluginConf);
+ else
+ addFeature(*it, aPluginConf);
}
}
}
}
std::list<std::string> Config_ModuleReader::importPlugin(const std::string& thePluginLibrary,
- const std::string& thePluginXmlConf)
+ const std::string& thePluginXmlConf,
+ const std::string& thePluginDocSection)
{
if (thePluginXmlConf.empty()) { //probably a third party library
loadLibrary(thePluginLibrary);
Config_FeatureReader aReader = Config_FeatureReader(thePluginXmlConf,
thePluginLibrary,
+ thePluginDocSection,
myEventGenerated);
aReader.readAll();
return aReader.features();
/// Returns map that describes which file contains a feature
/// (the feature is key, the file is value)
CONFIG_EXPORT const std::map<std::string, std::string>& featuresInFiles() const;
+ /// Returns map containing features, which have licensed.
+ /// The valid license should be confirmed first
+ /// (the feature is key, the file is value)
+ CONFIG_EXPORT const std::map<std::string, std::string>& proprietaryFeatures() const;
+ /// Returns proprietary plugins
+ CONFIG_EXPORT const std::set<std::string>& proprietaryPlugins() const;
/// Returns list of module's xml files
CONFIG_EXPORT const std::set<std::string>& modulePluginFiles() const;
/// Returns module name: an xml attribute from the root of the plugins.xml:
bool hasRequiredModules(xmlNodePtr aNode) const;
/// reads info about plugin's features from plugin xml description
std::list<std::string> importPlugin(const std::string& thePluginLibrary,
- const std::string& thePluginFile);
+ const std::string& thePluginFile,
+ const std::string& thePluginDocSection);
/// stores information about plugin in the internal cache
std::string addPlugin(const std::string& aPluginLibrary,
const std::string& aPluginScript,
/// Save feature in myFeaturesInFiles.
/// Generates an error if the feature name is already registered.
void addFeature(const std::string& theFeatureName, const std::string& thePluginConfig);
+ /// Save feature in myFeaturesRequireLicense.
+ /// Generates an error if the feature name is already registered.
+ void addFeatureRequireLicense(const std::string& theFeatureName,
+ const std::string& thePluginConfig);
private:
std::map<std::string, std::string> myFeaturesInFiles; ///< a feature name is key, a file is value
+ /// list of features, which need a license, and their config files
+ std::map<std::string, std::string> myProprietaryFeatures;
std::set<std::string> myPluginFiles; ///< a feature name is key, a file is value
/// a plugin name is key, a plugin type is value
static std::map<std::string, PluginType> myPluginTypes;
static std::set<std::string> myDependencyModules; ///< set of loaded modules
const char* myEventGenerated; ///< gives ability to send Feature_Messages to various listeners
+
+ std::set<std::string> myProprietaryPlugins; ///< list of plugins protected by license
};
#endif /* CONFIG_XMLMODULEREADER_H_ */
#include <ModelAPI_Session.h>
#include <ModelAPI_ResultPart.h>
#include <ModelAPI_Tools.h>
+#include <ModelAPI_Validator.h>
static const std::wstring THE_NEW_PART_STR(L"New Part");
data()->addAttribute(STEP_MATERIALS_ID(), ModelAPI_AttributeBoolean::typeId());
data()->addAttribute(STEP_COLORS_ID(), ModelAPI_AttributeBoolean::typeId());
data()->addAttribute(STEP_SCALE_INTER_UNITS_ID(), ModelAPI_AttributeBoolean::typeId());
+
+#ifndef HAVE_SALOME
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::IMPORT_TYPE_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_FILE_PATH_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_TARGET_PART_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_TARGET_PARTS_LIST_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_MATERIALS_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_COLORS_ID());
+ ModelAPI_Session::get()->validators()->registerNotObligatory(
+ getKind(), ExchangePlugin_Import::STEP_SCALE_INTER_UNITS_ID());
+#endif
}
/*
**Dialog box to export in STL format**
-The file name and path can be defined in **Export file** field by direct input or browsing with ‘…’ button, which opens Export file dialog box.
+The file name and path can be defined in **Export file** field by direct input or browsing with '...' button, which opens Export file dialog box.
**Object** field contains an exported object which can be selected in a viewer or object browser.
**Dialog box to import file in STEP format**
-The file name and path can be defined in **Import file** field by direct input or browsing with ‘…’ button, which opens **Import file** dialog box.
+The file name and path can be defined in **Import file** field by direct input or browsing with '...' button, which opens **Import file** dialog box.
The **Import to** combobox provides the list of destinations (one of existing Parts or a new Part).
**STEP options** provide the possibility to **Scale to International System Units** as well as to create groups from **Materials** and/or **Colors** if defined in assemblies of the file to import.
const GeomShapePtr theResultShape,
int& theResultIndex,
std::shared_ptr<GeomAlgoAPI_MakeShapeList> theMakeShapeList,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList)
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList)
{
if (!theResultShape)
return;
std::shared_ptr<ModelAPI_ResultBody> aResultBody =
document()->createBody(data(), theResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
theObjects,
theTools,
theMakeShapeList,
setResult(aResultBody, theResultIndex++);
// merge algorithms
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theObjects.front();
- for (std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>::iterator
+ for (std::vector<ModelAPI_Tools::ResultBaseAlgo>::iterator
aRBAIt = theResultBaseAlgoList.begin();
aRBAIt != theResultBaseAlgoList.end(); ++aRBAIt) {
theMakeShapeList->appendAlgo(aRBAIt->makeShape);
const GeomShapePtr theResultShape,
int& theResultIndex,
std::shared_ptr<GeomAlgoAPI_MakeShapeList> theMakeShapeList,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList);
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList);
private:
OperationType myOperationType;
std::string anError;
std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
if (isSimpleMode) {
ListOfShape anObjectList = anObjects.objects();
ListOfShape aToolsList;
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
anObjectList,
aToolsList,
aMakeShapeList,
aResultIndex++;
aToolsList = anObjectList;
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = aBaseShape;
aRBA.makeShape = aMakeShapeList;
// result shape has been deleted, but in another it was modified or stayed.
if (!aResultCompound)
aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
aTools.objects(),
aResultCompound);
#include "FeaturesPlugin_BooleanCut.h"
-#include "FeaturesPlugin_Tools.h"
-
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
return;
}
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
std::string anError;
// result shape has been deleted, but in another it was modified or stayed.
if (!aResultCompound)
aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
aTools.objects(),
aResultCompound);
//
#include "FeaturesPlugin_BooleanFill.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
return;
}
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
// result shape has been deleted, but in another it was modified or stayed.
if (!aResultCompound)
aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
aTools.objects(),
aResultCompound);
#include "FeaturesPlugin_BooleanFuse.h"
-#include "FeaturesPlugin_Tools.h"
-
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeBoolean.h>
#include <ModelAPI_AttributeInteger.h>
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
ListOfShape anEmptyTools;
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
- anOriginalShapes,
- anEmptyTools,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
+ anOriginalShapes,
+ anEmptyTools,
+ aMakeShapeList,
+ aShape);
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody,
- GeomShapePtr(),
- anOriginalShapes,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody,
+ GeomShapePtr(),
+ anOriginalShapes,
+ aMakeShapeList,
+ aShape);
// remove the rest results if there were produced in the previous pass
removeResults(aResultIndex);
#include "FeaturesPlugin_BooleanSmash.h"
-#include "FeaturesPlugin_Tools.h"
-
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
- anOriginalShapes,
- anOriginalShapes,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
+ anOriginalShapes,
+ anOriginalShapes,
+ aMakeShapeList,
+ aShape);
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody,
- GeomShapePtr(),
- anOriginalShapes,
- aMakeShapeList,
- aShape);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody,
+ GeomShapePtr(),
+ anOriginalShapes,
+ aMakeShapeList,
+ aShape);
// remove the rest results if there were produced in the previous pass
removeResults(aResultIndex);
//
#include <FeaturesPlugin_Defeaturing.h>
-#include <FeaturesPlugin_Tools.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
int aResultIndex = 0;
std::string anError;
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape anOriginalShapesList, aResultShapesList;
for (SolidFaces::iterator anIt = aBodiesAndFacesToRemove.begin();
aBaseShapes.push_back(anExp.current());
std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, aBaseShapes, ListOfShape(),
- anAlgo, aResult, "Defeaturing");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, aBaseShapes, ListOfShape(),
+ anAlgo, aResult, "Defeaturing");
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = aParent;
aRBA.makeShape = anAlgo;
// Store deleted shapes after all results has been proceeded. This is to avoid issue when in one
// result shape has been deleted, but in another it was modified or stayed.
GeomShapePtr aResultShapesCompound = GeomAlgoAPI_CompoundBuilder::compound(aResultShapesList);
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBaseAlgoList,
+ ModelAPI_Tools::loadDeletedShapes(aResultBaseAlgoList,
anOriginalShapesList, aResultShapesCompound);
removeResults(aResultIndex);
//
#include "FeaturesPlugin_Extrusion.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_AttributeSelection.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Tools.h>
#include <GeomAlgoAPI_Prism.h>
#include <GeomAlgoAPI_Tools.h>
ResultBodyPtr aResultBody = document()->createBody(data(), theIndex);
// Store modified shapes.
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, theBoundaryShapes, ListOfShape(),
- theMakeShape, theMakeShape->shape());
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, theBoundaryShapes, ListOfShape(),
+ theMakeShape, theMakeShape->shape());
// Store generated edges/faces.
storeGenerationHistory(aResultBody, theBaseShape, theMakeShape);
//
#include <FeaturesPlugin_Fillet1D.h>
-#include <FeaturesPlugin_Tools.h>
#include <GeomAlgoAPI_Fillet1D.h>
#include <GeomAlgoAPI_MapShapesAndAncestors.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_Events.h>
+#include <ModelAPI_Tools.h>
void sendMessageWithFailedShapes(const ListOfShape& theVertices)
{
ResultBodyPtr aResult = document()->createBody(data(), theResultIndex);
ListOfShape anOriginal;
anOriginal.push_back(theWire);
- FeaturesPlugin_Tools::loadModifiedShapes(aResult, anOriginal, ListOfShape(),
- aFilletBuilder, aFilletBuilder->shape(), THE_PREFIX);
+ ModelAPI_Tools::loadModifiedShapes(aResult, anOriginal, ListOfShape(),
+ aFilletBuilder, aFilletBuilder->shape(), THE_PREFIX);
setResult(aResult, theResultIndex);
// store new edges generated from vertices
for (ListOfShape::const_iterator anIt = theVertices.begin(); anIt != theVertices.end(); ++anIt)
//
#include "FeaturesPlugin_FusionFaces.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_ResultConstruction.h>
#include <ModelAPI_Session.h>
#include <ModelAPI_Validator.h>
+#include <ModelAPI_Tools.h>
#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_ShapeExplorer.h>
ListOfShape aBaseShapesList;
aBaseShapesList.push_back(aBaseShape);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, aBaseShapesList, ListOfShape(),
- anAlgo, aResultShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, aBaseShapesList, ListOfShape(),
+ anAlgo, aResultShape);
setResult(aResultBody);
}
#include <ModelAPI_BodyBuilder.h>
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeSelectionList.h>
+#include <ModelAPI_Tools.h>
#include <GeomAlgoAPI_Intersection.h>
#include <GeomAlgoAPI_MakeShapeList.h>
}
std::shared_ptr<ModelAPI_ResultBody> aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
- anObjects,
- ListOfShape(),
- aMakeShapeList,
- aResShape);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
+ anObjects,
+ ListOfShape(),
+ aMakeShapeList,
+ aResShape);
setResult(aResultBody, aResultIndex);
aResultIndex++;
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody,
- GeomShapePtr(),
- anObjects,
- aMakeShapeList,
- aResShape);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody,
+ GeomShapePtr(),
+ anObjects,
+ aMakeShapeList,
+ aResShape);
// remove the rest results if there were produced in the previous pass
removeResults(aResultIndex);
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Rotated");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Rotated");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Translated");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Translated");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
//LoadNamingDS
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Placed");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Placed");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Rotated");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Rotated");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Scaled");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Scaled");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
anObjects.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Scaled");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Scaled");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
{
// Store and name the result.
ResultBodyPtr aResultBody = document()->createBody(data(), theResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, theOriginalShapes, ListOfShape(),
- theAlgo, theTargetShape, "Symmetried");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, theOriginalShapes, ListOfShape(),
+ theAlgo, theTargetShape, "Symmetried");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(theTextureSource, aResultBody);
setResult(aResultBody, theResultIndex++);
#include <GeomValidators_ShapeType.h>
-//==================================================================================================
-void FeaturesPlugin_Tools::loadModifiedShapes(ResultBodyPtr theResultBody,
- const ListOfShape& theBaseShapes,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShape,
- const std::string& theNamePrefix)
-{
- theResultBody->storeModified(theBaseShapes, theResultShape, theMakeShape);
-
- ListOfShape aShapes = theBaseShapes;
- ListOfShape::const_iterator aToolIter = theTools.cbegin();
- for(; aToolIter != theTools.cend(); aToolIter++)
- aShapes.push_back(*aToolIter);
-
- for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); ++anIter)
- {
- theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::VERTEX, theNamePrefix);
- theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::EDGE, theNamePrefix);
- theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::FACE, theNamePrefix);
- }
-}
-
-//==================================================================================================
-void FeaturesPlugin_Tools::loadModifiedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr& theBaseShape,
- const GeomMakeShapePtr& theMakeShape,
- const std::string theName)
-{
- switch(theBaseShape->shapeType()) {
- case GeomAPI_Shape::COMPOUND: {
- for(GeomAPI_ShapeIterator anIt(theBaseShape); anIt.more(); anIt.next())
- {
- loadModifiedShapes(theResultBody,
- anIt.current(),
- theMakeShape,
- theName);
- }
- break;
- }
- case GeomAPI_Shape::COMPSOLID:
- case GeomAPI_Shape::SOLID:
- case GeomAPI_Shape::SHELL: {
- theResultBody->loadModifiedShapes(theMakeShape,
- theBaseShape,
- GeomAPI_Shape::FACE,
- theName);
- }
- case GeomAPI_Shape::FACE:
- case GeomAPI_Shape::WIRE: {
- theResultBody->loadModifiedShapes(theMakeShape,
- theBaseShape,
- GeomAPI_Shape::EDGE,
- theName);
- }
- case GeomAPI_Shape::EDGE: {
- theResultBody->loadModifiedShapes(theMakeShape,
- theBaseShape,
- GeomAPI_Shape::VERTEX,
- theName);
- }
- default: // [to avoid compilation warning]
- break;
- }
-}
-
-//==================================================================================================
-void FeaturesPlugin_Tools::loadDeletedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr theBaseShape,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShapesCompound)
-{
- ListOfShape aShapes = theTools;
- if (theBaseShape.get())
- aShapes.push_front(theBaseShape);
-
- for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); anIter++)
- {
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::VERTEX,
- theResultShapesCompound);
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::EDGE,
- theResultShapesCompound);
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::FACE,
- theResultShapesCompound);
- // store information about deleted solids because of unittest TestBooleanCommon_SolidsHistory
- // on OCCT 7.4.0 : common produces modified compsolid, so, move to the end for removed solids
- // starts to produce whole compsolid
- theResultBody->loadDeletedShapes(theMakeShape,
- *anIter,
- GeomAPI_Shape::SOLID,
- theResultShapesCompound);
- }
-}
-
-//==================================================================================================
-void FeaturesPlugin_Tools::loadDeletedShapes(
- std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
- const ListOfShape& theTools,
- const GeomShapePtr theResultShapesCompound)
-{
- for (std::vector<ResultBaseAlgo>::iterator anIt = theResultBaseAlgoList.begin();
- anIt != theResultBaseAlgoList.end();
- ++anIt)
- {
- ResultBaseAlgo& aRCA = *anIt;
- loadDeletedShapes(aRCA.resultBody,
- aRCA.baseShape,
- theTools,
- aRCA.makeShape,
- theResultShapesCompound);
- }
-}
-
//==================================================================================================
bool FeaturesPlugin_Tools::getShape(const AttributeSelectionListPtr theSelectionList,
const bool theShareTopology,
class FeaturesPlugin_Tools {
public:
- struct ResultBaseAlgo {
- ResultBodyPtr resultBody;
- GeomShapePtr baseShape;
- GeomMakeShapePtr makeShape;
- };
-
-public:
- static void loadModifiedShapes(ResultBodyPtr theResultBody,
- const ListOfShape& theBaseShapes,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShape,
- const std::string& theNamePrefix = "");
-
- static void loadModifiedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr& theBaseShape,
- const GeomMakeShapePtr& theMakeShape,
- const std::string theName);
- /// Stores deleted shapes.
- static void loadDeletedShapes(ResultBodyPtr theResultBody,
- const GeomShapePtr theBaseShape,
- const ListOfShape& theTools,
- const GeomMakeShapePtr& theMakeShape,
- const GeomShapePtr theResultShapesCompound);
-
- /// Stores deleted shapes.
- static void loadDeletedShapes(std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
- const ListOfShape& theTools,
- const GeomShapePtr theResultShapesCompound);
-
/// Obtain shapes from the selection list attribute.
static bool getShape(const std::shared_ptr<ModelAPI_AttributeSelectionList> theSelectionList,
const bool theShareTopology,
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
//LoadNamingDS
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
- aMakeShapeList, *anIt, "Translated");
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalShapes, ListOfShape(),
+ aMakeShapeList, *anIt, "Translated");
// Copy image data, if any
ModelAPI_Tools::copyImageAttribute(aTextureSource, aResultBody);
setResult(aResultBody, aResultIndex++);
std::string anError;
int aResultIndex = 0;
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo> aResultBaseAlgoList;
+ std::vector<ModelAPI_Tools::ResultBaseAlgo> aResultBaseAlgoList;
ListOfShape aResultShapesList;
GeomShapePtr aResultCompound = GeomAlgoAPI_CompoundBuilder::compound(ListOfShape());
}
std::shared_ptr<GeomAlgoAPI_MakeShapeList> aMakeShapeList(new GeomAlgoAPI_MakeShapeList());
- for (std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>::iterator
+ for (std::vector<ModelAPI_Tools::ResultBaseAlgo>::iterator
aRBAIt = aResultBaseAlgoList.begin();
aRBAIt != aResultBaseAlgoList.end(); ++aRBAIt) {
aMakeShapeList->appendAlgo(aRBAIt->makeShape);
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResultCompound)
{
ListOfShape aUsedTools = theTools;
aUsedTools.insert(aUsedTools.end(), thePlanes.begin(), thePlanes.end());
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
aListWithObject,
aUsedTools,
aMakeShapeList,
}
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theObject;
aRBA.makeShape = aMakeShapeList;
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResultCompound)
{
ListOfShape aUsedTools = theTools;
aUsedTools.insert(aUsedTools.end(), thePlanes.begin(), thePlanes.end());
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
aCompSolidList,
aUsedTools,
aMakeShapeList,
++theResultIndex;
}
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theCompsolid;
aRBA.makeShape = aMakeShapeList;
const GeomShapePtr& theCompound,
const ListOfShape& theTools,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResultCompound)
{
ListOfShape aCompoundList;
aCompoundList.push_back(theCompound);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody,
+ ModelAPI_Tools::loadModifiedShapes(aResultBody,
aCompoundList,
theTools,
aMakeShapeList,
++theResultIndex;
}
- FeaturesPlugin_Tools::ResultBaseAlgo aRBA;
+ ModelAPI_Tools::ResultBaseAlgo aRBA;
aRBA.resultBody = aResultBody;
aRBA.baseShape = theCompound;
aRBA.makeShape = aMakeShapeList;
#include <GeomAlgoAPI_Tools.h>
#include <ModelAPI_Feature.h>
+#include <ModelAPI_Tools.h>
class ModelAPI_Attribute;
class ModelAPI_Result;
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResulCompound = GeomShapePtr());
const ListOfShape& theTools,
const ListOfShape& thePlanes,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResulCompound = GeomShapePtr());
const GeomShapePtr& theCompound,
const ListOfShape& theTools,
int& theResultIndex,
- std::vector<FeaturesPlugin_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
+ std::vector<ModelAPI_Tools::ResultBaseAlgo>& theResultBaseAlgoList,
ListOfShape& theResultShapesList,
GeomShapePtr theResulCompound = GeomShapePtr());
//
#include "FeaturesPlugin_VersionedChFi.h"
-#include "FeaturesPlugin_Tools.h"
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_Tools.h>
anObjectHierarchy.topLevelObjects(aTopLevel);
for (ListOfShape::iterator anIt = aTopLevel.begin(); anIt != aTopLevel.end(); ++anIt) {
ResultBodyPtr aResultBody = document()->createBody(data(), aResultIndex);
- FeaturesPlugin_Tools::loadModifiedShapes(aResultBody, anOriginalSolids, ListOfShape(),
- aMakeShapeList, *anIt, aPrefix);
+ ModelAPI_Tools::loadModifiedShapes(aResultBody, anOriginalSolids, ListOfShape(),
+ aMakeShapeList, *anIt, aPrefix);
setResult(aResultBody, aResultIndex++);
for (ListOfShape::iterator aEIt = anEdges.begin(); aEIt != anEdges.end(); ++aEIt) {
aResultBody->loadGeneratedShapes(aMakeShapeList, aBase, GeomAPI_Shape::EDGE, aPrefix, true);
}
- FeaturesPlugin_Tools::loadDeletedShapes(aResultBody, GeomShapePtr(), anOriginalSolids,
- aMakeShapeList, *anIt);
+ ModelAPI_Tools::loadDeletedShapes(aResultBody, GeomShapePtr(), anOriginalSolids,
+ aMakeShapeList, *anIt);
}
removeResults(aResultIndex);
protected:
/// \brief Sets builder type.
/// \param[in] theBuilderType new builder type.
- void setBuilderType(const BuilderType theBuilderType);
+ GEOMALGOAPI_EXPORT void setBuilderType(const BuilderType theBuilderType);
/// \brief Sets status of builder.
/// \param[in] theFlag new status.
- void setDone(const bool theFlag);
+ GEOMALGOAPI_EXPORT void setDone(const bool theFlag);
/// \brief Sets result shape.
/// \param[in] theShape new shape.
- void setShape(const GeomShapePtr theShape);
+ GEOMALGOAPI_EXPORT void setShape(const GeomShapePtr theShape);
/// \return true if passed shape is valid for history.
bool isValidForHistory(const GeomShapePtr theShape);
return ROOT_DOC->redoList();
}
+bool Model_Session::checkLicense(const std::string& thePluginName)
+{
+ return getPlugin(thePluginName);
+}
+
ModelAPI_Plugin* Model_Session::getPlugin(const std::string& thePluginName)
{
if (myPluginObjs.find(thePluginName) == myPluginObjs.end()) {
/// the plugin manager on call of the feature)
MODEL_EXPORT virtual void registerPlugin(ModelAPI_Plugin* thePlugin);
+ /// Verifies the license for the plugin is valid
+ MODEL_EXPORT virtual bool checkLicense(const std::string& thePluginName);
+
/// Processes the configuration file reading
MODEL_EXPORT virtual void processEvent(const std::shared_ptr<Events_Message>& theMessage);
{
return myShapes;
}
+
+
+// ===== ModelAPI_FeaturesLicenseValidMessage =====
+ModelAPI_FeaturesLicenseValidMessage::ModelAPI_FeaturesLicenseValidMessage(
+ const Events_ID theID, const void* theSender)
+ : Events_Message(theID, theSender)
+{}
+
+ModelAPI_FeaturesLicenseValidMessage::~ModelAPI_FeaturesLicenseValidMessage()
+{}
+
+void ModelAPI_FeaturesLicenseValidMessage::setFeatures(const std::set<std::string>& theFeatures)
+{
+ myFeatures = theFeatures;
+}
+
+const std::set<std::string>& ModelAPI_FeaturesLicenseValidMessage::features() const
+{
+ return myFeatures;
+}
/// Event ID that requests updates visual attributes for presentations
MAYBE_UNUSED static const char * EVENT_VISUAL_ATTRIBUTES = "UpdateVisualAttributes";
-
/// Event ID that 1D-fillet failed (comes with ModelAPI_ShapesFailedMessage)
MAYBE_UNUSED static const char * EVENT_OPERATION_SHAPES_FAILED = "OperationShapesFailed";
+/// Event ID that license of specified features is checked and valid
+MAYBE_UNUSED static const char * EVENT_FEATURE_LICENSE_VALID = "FeaturesLicenseValid";
+
/// Message that feature was changed (used for Object Browser update): moved, updated and deleted
class MODELAPI_EXPORT ModelAPI_ObjectUpdatedMessage : public Events_MessageGroup
{
std::list< std::shared_ptr<GeomAPI_Shape> > myShapes;
};
+/// Message that sends the features which license is checked and valid
+class ModelAPI_FeaturesLicenseValidMessage : public Events_Message
+{
+public:
+ /// Creates an message
+ MODELAPI_EXPORT
+ ModelAPI_FeaturesLicenseValidMessage(const Events_ID theID, const void* theSender = 0);
+ /// Default destructor
+ MODELAPI_EXPORT virtual ~ModelAPI_FeaturesLicenseValidMessage();
+ /// Static. Returns EventID of the message.
+ MODELAPI_EXPORT static Events_ID eventId()
+ {
+ return Events_Loop::eventByName(EVENT_FEATURE_LICENSE_VALID);
+ }
+
+ /// Sets list of features with valid license
+ MODELAPI_EXPORT void setFeatures(const std::set<std::string>& theFeatures);
+ /// Returns list of features with valid license
+ MODELAPI_EXPORT const std::set<std::string>& features() const;
+
+private:
+ std::set<std::string> myFeatures;
+};
+
#endif
/// the plugin manager on call of the feature)
virtual void registerPlugin(ModelAPI_Plugin* thePlugin) = 0;
+ /// Verifies the license for the plugin is valid
+ virtual bool checkLicense(const std::string& thePluginName) = 0;
+
/// Returns the root document of the application (that may contains sub-documents)
virtual std::shared_ptr<ModelAPI_Document> moduleDocument() = 0;
#include <Events_Loop.h>
#include <Locale_Convert.h>
+#include <GeomAlgoAPI_MakeShape.h>
#include <GeomAPI_ShapeHierarchy.h>
#include <GeomAPI_ShapeIterator.h>
#include <GeomAPI_ShapeExplorer.h>
return ObjectPtr();
}
+//==================================================================================================
+void loadModifiedShapes(ResultBodyPtr theResultBody,
+ const ListOfShape& theBaseShapes,
+ const ListOfShape& theTools,
+ const GeomMakeShapePtr& theMakeShape,
+ const GeomShapePtr theResultShape,
+ const std::string& theNamePrefix)
+{
+ theResultBody->storeModified(theBaseShapes, theResultShape, theMakeShape);
+
+ ListOfShape aShapes = theBaseShapes;
+ ListOfShape::const_iterator aToolIter = theTools.cbegin();
+ for (; aToolIter != theTools.cend(); aToolIter++)
+ aShapes.push_back(*aToolIter);
+
+ for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); ++anIter)
+ {
+ theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::VERTEX, theNamePrefix);
+ theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::EDGE, theNamePrefix);
+ theResultBody->loadModifiedShapes(theMakeShape, *anIter, GeomAPI_Shape::FACE, theNamePrefix);
+ }
+}
+
+//==================================================================================================
+void loadModifiedShapes(ResultBodyPtr theResultBody,
+ const GeomShapePtr& theBaseShape,
+ const GeomMakeShapePtr& theMakeShape,
+ const std::string theName)
+{
+ switch (theBaseShape->shapeType()) {
+ case GeomAPI_Shape::COMPOUND: {
+ for (GeomAPI_ShapeIterator anIt(theBaseShape); anIt.more(); anIt.next())
+ {
+ loadModifiedShapes(theResultBody,
+ anIt.current(),
+ theMakeShape,
+ theName);
+ }
+ break;
+ }
+ case GeomAPI_Shape::COMPSOLID:
+ case GeomAPI_Shape::SOLID:
+ case GeomAPI_Shape::SHELL: {
+ theResultBody->loadModifiedShapes(theMakeShape,
+ theBaseShape,
+ GeomAPI_Shape::FACE,
+ theName);
+ }
+ case GeomAPI_Shape::FACE:
+ case GeomAPI_Shape::WIRE: {
+ theResultBody->loadModifiedShapes(theMakeShape,
+ theBaseShape,
+ GeomAPI_Shape::EDGE,
+ theName);
+ }
+ case GeomAPI_Shape::EDGE: {
+ theResultBody->loadModifiedShapes(theMakeShape,
+ theBaseShape,
+ GeomAPI_Shape::VERTEX,
+ theName);
+ }
+ default: // [to avoid compilation warning]
+ break;
+ }
+}
+
+//==================================================================================================
+void loadDeletedShapes(ResultBodyPtr theResultBody,
+ const GeomShapePtr theBaseShape,
+ const ListOfShape& theTools,
+ const GeomMakeShapePtr& theMakeShape,
+ const GeomShapePtr theResultShapesCompound)
+{
+ ListOfShape aShapes = theTools;
+ if (theBaseShape.get())
+ aShapes.push_front(theBaseShape);
+
+ for (ListOfShape::const_iterator anIter = aShapes.begin(); anIter != aShapes.end(); anIter++)
+ {
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::VERTEX,
+ theResultShapesCompound);
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::EDGE,
+ theResultShapesCompound);
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::FACE,
+ theResultShapesCompound);
+ // store information about deleted solids because of unittest TestBooleanCommon_SolidsHistory
+ // on OCCT 7.4.0 : common produces modified compsolid, so, move to the end for removed solids
+ // starts to produce whole compsolid
+ theResultBody->loadDeletedShapes(theMakeShape,
+ *anIter,
+ GeomAPI_Shape::SOLID,
+ theResultShapesCompound);
+ }
+}
+
+//==================================================================================================
+void loadDeletedShapes(std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
+ const ListOfShape& theTools,
+ const GeomShapePtr theResultShapesCompound)
+{
+ for (std::vector<ResultBaseAlgo>::iterator anIt = theResultBaseAlgoList.begin();
+ anIt != theResultBaseAlgoList.end();
+ ++anIt)
+ {
+ ResultBaseAlgo& aRCA = *anIt;
+ loadDeletedShapes(aRCA.resultBody,
+ aRCA.baseShape,
+ theTools,
+ aRCA.makeShape,
+ theResultShapesCompound);
+ }
+}
+
bool findVariable(const DocumentPtr& theDocument, FeaturePtr theSearcher,
const std::wstring& theName, double& outValue, ResultParameterPtr& theParam)
{
class ModelAPI_ResultParameter;
class ModelAPI_ResultBody;
+class GeomAlgoAPI_MakeShape;
class GeomAPI_Shape;
class GeomAPI_ShapeHierarchy;
*/
MODELAPI_EXPORT std::string getFeatureError(const std::shared_ptr<ModelAPI_Feature>& theFeature);
+MODELAPI_EXPORT struct ResultBaseAlgo {
+ std::shared_ptr<ModelAPI_ResultBody> resultBody;
+ std::shared_ptr<GeomAPI_Shape> baseShape;
+ std::shared_ptr<GeomAlgoAPI_MakeShape> makeShape;
+};
+
+MODELAPI_EXPORT void loadModifiedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theBaseShapes,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
+ const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
+ const std::shared_ptr<GeomAPI_Shape> theResultShape,
+ const std::string& theNamePrefix = "");
+
+MODELAPI_EXPORT void loadModifiedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+ const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
+ const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
+ const std::string theName);
+/// Stores deleted shapes.
+MODELAPI_EXPORT void loadDeletedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
+ const std::shared_ptr<GeomAPI_Shape> theBaseShape,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
+ const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
+ const std::shared_ptr<GeomAPI_Shape> theResultShapesCompound);
+
+/// Stores deleted shapes.
+MODELAPI_EXPORT void loadDeletedShapes(std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
+ const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
+ const std::shared_ptr<GeomAPI_Shape> theResultShapesCompound);
+
/*!
* Searches for variable with name \param theName in \param theDocument.
* If found, set it value in the \param outValue and returns true.
#include "ModuleBase_Dialog.h"
#include "ModuleBase_IErrorMgr.h"
+#include <Events_InfoMessage.h>
#include <Events_Loop.h>
#include <Events_Message.h>
Config_ModuleReader aXMLReader = Config_ModuleReader();
aXMLReader.readAll();
myFeaturesInFiles = aXMLReader.featuresInFiles();
+ myProprietaryFeatures = aXMLReader.proprietaryFeatures();
+ myProprietaryPlugins = aXMLReader.proprietaryPlugins();
+}
+
+void ModuleBase_IModule::processProprietaryFeatures()
+{
+ std::set<std::string>::iterator it = myFeaturesValidLicense.begin();
+ while (it != myFeaturesValidLicense.end()) {
+ std::map<std::string, std::string>::iterator aFound = myProprietaryFeatures.find(*it);
+ if (aFound == myProprietaryFeatures.end())
+ ++it;
+ else {
+ myFeaturesInFiles[aFound->first] = aFound->second;
+ myProprietaryFeatures.erase(aFound);
+ std::set<std::string>::iterator aRemoveIt = it++;
+ myFeaturesValidLicense.erase(aRemoveIt);
+ }
+ }
+}
+
+void ModuleBase_IModule::loadProprietaryPlugins()
+{
+ for (std::set<std::string>::const_iterator itP = myProprietaryPlugins.begin();
+ itP != myProprietaryPlugins.end(); ++itP) {
+ if (!ModelAPI_Session::get()->checkLicense(*itP))
+ Events_InfoMessage(*itP, "License of %1 plugin is not valid or not exist!").arg(*itP).send();
+ }
}
/// Returns new instance of operation object (used in createOperation for customization)
virtual ModuleBase_Operation* getNewOperation(const std::string& theFeatureId);
+ /// Load plugins required license
+ void loadProprietaryPlugins();
+
+ /// Collect features, which have valid license
+ void processProprietaryFeatures();
+
protected:
/// Reference to workshop
ModuleBase_IWorkshop* myWorkshop;
/// Map of features in XML
std::map<std::string, std::string> myFeaturesInFiles;
+ /// Map of features in XML, which require license but not confirmed yet
+ std::map<std::string, std::string> myProprietaryFeatures;
+ /// Proprietary plugins
+ std::set<std::string> myProprietaryPlugins;
+ /// Features, which have valid license
+ std::set<std::string> myFeaturesValidLicense;
std::map<ModuleBase_SelectionFilterType, Handle(SelectMgr_Filter)> mySelectionFilters;
Events_Loop* aLoop = Events_Loop::loop();
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_DOCUMENT_CHANGED));
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_FEATURE_LICENSE_VALID));
registerSelectionFilter(SF_GlobalFilter, new PartSet_GlobalFilter(myWorkshop));
registerSelectionFilter(SF_FilterInfinite, new PartSet_FilterInfinite(myWorkshop));
ModuleBase_IModule::createFeatures();
myRoot = new PartSet_RootNode();
myRoot->setWorkshop(workshop());
+ ModuleBase_IModule::loadProprietaryPlugins();
}
mySketchMgr->previewSketchPlane()->createSketchPlane(aSketch, myWorkshop);
}
}
+ else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_FEATURE_LICENSE_VALID)) {
+ std::shared_ptr<ModelAPI_FeaturesLicenseValidMessage> aMsg =
+ std::dynamic_pointer_cast<ModelAPI_FeaturesLicenseValidMessage>(theMessage);
+ myFeaturesValidLicense.insert(aMsg->features().begin(), aMsg->features().end());
+ processProprietaryFeatures();
+ }
}
//******************************************************
from .primitives import *
from .gdml import *
from .tests import *
+
+# Add-on features
+
+from .addons import *
+# move functions from .addons to top level (model) package
+import inspect
+for attribute_name in dir(addons):
+ attribute = getattr(addons, attribute_name)
+ if inspect.isfunction(attribute):
+ globals()[attribute_name] = attribute
+del inspect
--- /dev/null
+# Copyright (C) 2015-2020 CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import pkgutil, inspect
+
+__all__ = []
+for loader, module_name, is_pkg in pkgutil.walk_packages(__path__):
+ __all__.append(module_name)
+ module = loader.find_module(module_name).load_module(module_name)
+ globals()[module_name] = module
+
+ for attribute_name in dir(module):
+ attribute = getattr(module, attribute_name)
+ if inspect.isfunction(attribute):
+ globals()[attribute_name] = attribute
+
+del pkgutil, inspect
\ No newline at end of file