#include "XGUI_Workshop.h"
#include "XGUI_ActionsMgr.h"
+#include "XGUI_MenuMgr.h"
#include "XGUI_ColorDialog.h"
+#include "XGUI_DeflectionDialog.h"
#include "XGUI_ContextMenuMgr.h"
#include "XGUI_Displayer.h"
#include "XGUI_ErrorDialog.h"
#include <ModelAPI_AttributeDocRef.h>
#include <ModelAPI_AttributeIntArray.h>
+#include <ModelAPI_AttributeDouble.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Events.h>
#include <ModelAPI_Feature.h>
//#include <PartSetPlugin_Part.h>
#include <Events_Loop.h>
-#include <Events_Error.h>
+#include <Events_InfoMessage.h>
#include <Events_LongOp.h>
#include <ModuleBase_FilterFactory.h>
#include <ModuleBase_OperationAction.h>
#include <ModuleBase_PagedContainer.h>
#include <ModuleBase_WidgetValidated.h>
+#include <ModuleBase_ModelWidget.h>
+#include <ModuleBase_ResultPrs.h>
#include <Config_Common.h>
#include <Config_FeatureMessage.h>
#include <Config_PointerMessage.h>
#include <Config_PropManager.h>
#include <Config_SelectionFilterMessage.h>
+#include <Config_DataModelReader.h>
+#include <Config_Translator.h>
#include <SUIT_ResourceMgr.h>
#include <dlfcn.h>
#endif
-
QString XGUI_Workshop::MOVE_TO_END_COMMAND = QObject::tr("Move to the end");
//#define DEBUG_DELETE
//#define DEBUG_FEATURE_NAME
+//#define DEBUG_CLEAN_HISTORY
XGUI_Workshop::XGUI_Workshop(XGUI_SalomeConnector* theConnector)
: QObject(),
myPropertyPanel(0),
myObjectBrowser(0),
myDisplayer(0)
+ //myViewerSelMode(TopAbs_FACE)
{
+ mySelector = new XGUI_SelectionMgr(this);
+ myModuleConnector = new XGUI_ModuleConnector(this);
+ myOperationMgr = new XGUI_OperationMgr(this, 0);
+ ModuleBase_IWorkshop* aWorkshop = moduleConnector();
+ // Has to be defined first in order to get errors and messages from other components
+ myEventsListener = new XGUI_WorkshopListener(aWorkshop);
+
#ifndef HAVE_SALOME
myMainWindow = new AppElements_MainWindow();
else
QLocale::setDefault( QLocale::system() );
#endif
+ QString aPath = Config_XMLReader::pluginConfigFile().c_str();
+ QDir aDir(aPath);
+
+ // Load translations
+ QStringList aFilters;
+ aFilters << "*_en.ts";
+ QStringList aTsFiles = aDir.entryList(aFilters, QDir::Files);
+ foreach(QString aFileName, aTsFiles) {
+ Config_Translator::load(aFileName.toStdString());
+ }
+
+ myDataModelXMLReader = new Config_DataModelReader();
+ //myDataModelXMLReader->readAll();
myDisplayer = new XGUI_Displayer(this);
- mySelector = new XGUI_SelectionMgr(this);
connect(mySelector, SIGNAL(selectionChanged()), this, SLOT(updateCommandStatus()));
- myOperationMgr = new XGUI_OperationMgr(this, 0);
myActionsMgr = new XGUI_ActionsMgr(this);
+ myMenuMgr = new XGUI_MenuMgr(this);
myErrorDlg = new XGUI_ErrorDialog(QApplication::desktop());
myContextMenuMgr = new XGUI_ContextMenuMgr(this);
connect(myContextMenuMgr, SIGNAL(actionTriggered(const QString&, bool)), this,
SLOT(onContextMenuCommand(const QString&, bool)));
myViewerProxy = new XGUI_ViewerProxy(this);
- connect(myViewerProxy, SIGNAL(selectionChanged()),
- myActionsMgr, SLOT(updateOnViewSelection()));
-
- myModuleConnector = new XGUI_ModuleConnector(this);
+ //connect(myViewerProxy, SIGNAL(selectionChanged()),
+ // myActionsMgr, SLOT(updateOnViewSelection()));
- ModuleBase_IWorkshop* aWorkshop = moduleConnector();
myOperationMgr->setWorkshop(aWorkshop);
myErrorMgr = new XGUI_ErrorMgr(this, aWorkshop);
- myEventsListener = new XGUI_WorkshopListener(aWorkshop);
- connect(myOperationMgr, SIGNAL(operationStarted(ModuleBase_Operation*)),
- SLOT(onOperationStarted(ModuleBase_Operation*)));
connect(myOperationMgr, SIGNAL(operationResumed(ModuleBase_Operation*)),
SLOT(onOperationResumed(ModuleBase_Operation*)));
connect(myOperationMgr, SIGNAL(operationStopped(ModuleBase_Operation*)),
onTrihedronVisibilityChanged(true);
#endif
- connect(this, SIGNAL(errorOccurred(const QString&)), myErrorDlg, SLOT(addError(const QString&)));
- connect(myEventsListener, SIGNAL(errorOccurred(const QString&)),
- myErrorDlg, SLOT(addError(const QString&)));
+ connect(myEventsListener, SIGNAL(errorOccurred(std::shared_ptr<Events_InfoMessage>)),
+ myErrorDlg, SLOT(addError(std::shared_ptr<Events_InfoMessage>)));
//Config_PropManager::registerProp("Visualization", "object_default_color", "Object color",
// Config_Prop::Color, "225,225,225");
- Config_PropManager::registerProp("Visualization", "result_body_color", "Body color",
+ Config_PropManager::registerProp("Visualization", "result_body_color", "Result color",
Config_Prop::Color, ModelAPI_ResultBody::DEFAULT_COLOR());
Config_PropManager::registerProp("Visualization", "result_group_color", "Group color",
Config_Prop::Color, ModelAPI_ResultGroup::DEFAULT_COLOR());
Config_Prop::Color, ModelAPI_ResultConstruction::DEFAULT_COLOR());
Config_PropManager::registerProp("Visualization", "result_part_color", "Part color",
Config_Prop::Color, ModelAPI_ResultPart::DEFAULT_COLOR());
+
+ Config_PropManager::registerProp("Visualization", "body_deflection", "Body deflection coefficient",
+ Config_Prop::Double, ModelAPI_ResultBody::DEFAULT_DEFLECTION());//"0.001");
+
+ Config_PropManager::registerProp("Visualization", "construction_deflection", "Construction deflection coefficient",
+ Config_Prop::Double, ModelAPI_ResultConstruction::DEFAULT_DEFLECTION());//"0.0001");
+
+ if (ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "face-selection", true))
+ myViewerSelMode.append(TopAbs_FACE);
+ if (ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "edge-selection", true))
+ myViewerSelMode.append(TopAbs_EDGE);
+ if (ModuleBase_Preferences::resourceMgr()->booleanValue("Viewer", "vertex-selection", true))
+ myViewerSelMode.append(TopAbs_VERTEX);
+ //IMP: an attempt to use result selection with other selection modes
+ myViewerSelMode.append(ModuleBase_ResultPrs::Sel_Result);//TopAbs_VERTEX);
+ myViewerSelMode.append(TopAbs_COMPSOLID);
}
//******************************************************
XGUI_Workshop::~XGUI_Workshop(void)
{
+#ifdef _DEBUG
+#ifdef MISSED_TRANSLATION
+ // Save Missed translations
+ Config_Translator::saveMissedTranslations();
+#endif
+#endif
+
delete myDisplayer;
+ delete myDataModelXMLReader;
}
//******************************************************
void XGUI_Workshop::startApplication()
{
+ //Initialize event listening
+ myEventsListener->initializeEventListening();
+
+ myDataModelXMLReader->readAll();
initMenu();
Config_PropManager::registerProp("Plugins", "default_path", "Default Path",
Config_Prop::Directory, "");
- //Initialize event listening
- myEventsListener->initializeEventListening();
registerValidators();
updateCommandStatus();
+ // TODO: get default selection mode
+
// activate visualized objects in the viewer
- XGUI_Displayer* aDisplayer = displayer();
- QObjectPtrList aDisplayed = aDisplayer->displayedObjects();
- QIntList aModes;
- module()->activeSelectionModes(aModes);
- aDisplayer->activateObjects(aModes, aDisplayed);
+ activateObjectsSelection(displayer()->displayedObjects());
myOperationMgr->activate();
}
}
}
+//******************************************************
+void XGUI_Workshop::onPreviewActionClicked()
+{
+ ModuleBase_IPropertyPanel* aPanel = propertyPanel();
+ if (aPanel) {
+ ModuleBase_ModelWidget* anActiveWidget = aPanel->activeWidget();
+ if (anActiveWidget && anActiveWidget->getValueState() == ModuleBase_ModelWidget::ModifiedInPP) {
+ anActiveWidget->storeValue();
+ }
+ }
+ std::shared_ptr<Events_Message> aMsg = std::shared_ptr<Events_Message>(
+ new Events_Message(Events_Loop::eventByName(EVENT_PREVIEW_REQUESTED)));
+ Events_Loop::loop()->send(aMsg);
+}
+
//******************************************************
void XGUI_Workshop::deactivateActiveObject(const ObjectPtr& theObject, const bool theUpdateViewer)
{
return aHasNested;
}
-void XGUI_Workshop::setPropertyPanel(ModuleBase_Operation* theOperation)
+void XGUI_Workshop::fillPropertyPanel(ModuleBase_Operation* theOperation)
{
ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
if (!aFOperation)
// check compatibility of feature and widgets
FeaturePtr aFeature = aFOperation->feature();
+ std::string aFeatureKind = aFeature->getKind();
foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
if (!aWidget->attributeID().empty() && !aFeature->attribute(aWidget->attributeID()).get()) {
- std::string anErrorMsg = "The feature '" + aFeature->getKind() + "' has no attribute '"
- + aWidget->attributeID() + "' used by widget '"
- + aWidget->metaObject()->className() + "'.";
- Events_Error::send(anErrorMsg);
+ std::string anErrorMsg = "The feature '%1' has no attribute '%2' used by widget '%3'.";
+ Events_InfoMessage("XGUI_Workshop", anErrorMsg)
+ .arg(aFeatureKind).arg(aWidget->attributeID()).arg(aWidget->metaObject()->className()).send();
myPropertyPanel->cleanContent();
return;
}
}
-
+ // for performance purpose, flush should be done after all controls are filled
+ bool isUpdateFlushed = false;
foreach (ModuleBase_ModelWidget* aWidget, aWidgets) {
bool isStoreValue = !aFOperation->isEditOperation() &&
!aWidget->getDefaultValue().empty() &&
!aWidget->isComputedDefault();
- aWidget->setFeature(aFOperation->feature(), isStoreValue);
+ aWidget->setFeature(aFeature, isStoreValue, isUpdateFlushed);
+ if (!isStoreValue)
+ aWidget->restoreValue();
aWidget->enableFocusProcessing();
}
+ ModuleBase_Tools::flushUpdated(aFeature);
+ // update visible state of Preview button
+#ifdef HAVE_SALOME
+ bool anIsAutoPreview = mySalomeConnector->featureInfo(aFeatureKind.c_str())->isAutoPreview();
+#else
+ AppElements_MainMenu* aMenuBar = mainWindow()->menuObject();
+ AppElements_Command* aCommand = aMenuBar->feature(aFeatureKind.c_str());
+ bool anIsAutoPreview = aCommand && aCommand->featureMessage()->isAutoPreview();
+#endif
+ if (!anIsAutoPreview) {
+ myPropertyPanel->findButton(PROP_PANEL_PREVIEW)->setVisible(true);
+ // send signal about preview should not be computed automatically, click on preview
+ // button should initiate it
+ std::shared_ptr<Events_Message> aMsg = std::shared_ptr<Events_Message>(
+ new Events_Message(Events_Loop::eventByName(EVENT_PREVIEW_BLOCKED)));
+ Events_Loop::loop()->send(aMsg);
+ }
myPropertyPanel->setModelWidgets(aWidgets);
aFOperation->setPropertyPanel(myPropertyPanel);
if (isToConnect) {
connect(aWidget, SIGNAL(valueStateChanged(int)), this, SLOT(onWidgetStateChanged(int)));
connect(aWidget, SIGNAL(valuesChanged()), this, SLOT(onValuesChanged()));
- }
+ connect(aWidget, SIGNAL(objectUpdated()), this, SLOT(onWidgetObjectUpdated()));
+ }
else {
disconnect(aWidget, SIGNAL(valueStateChanged(int)), this, SLOT(onWidgetStateChanged(int)));
disconnect(aWidget, SIGNAL(valuesChanged()), this, SLOT(onValuesChanged()));
+ disconnect(aWidget, SIGNAL(objectUpdated()), this, SLOT(onWidgetObjectUpdated()));
}
}
}
}
-//******************************************************
-void XGUI_Workshop::onOperationStarted(ModuleBase_Operation* theOperation)
-{
- setGrantedFeatures(theOperation);
- myModule->operationStarted(theOperation);
-}
-
//******************************************************
void XGUI_Workshop::onOperationResumed(ModuleBase_Operation* theOperation)
{
setGrantedFeatures(theOperation);
if (theOperation->getDescription()->hasXmlRepresentation()) { //!< No need for property panel
- setPropertyPanel(theOperation);
+ fillPropertyPanel(theOperation);
connectToPropertyPanel(true);
}
updateCommandStatus();
if (aFeature.get()) { // feature may be not created (plugin load fail)
if (myDisplayer->isVisible(aFeature) && !myDisplayer->isActive(aFeature))
anObjects.append(aFeature);
- std::list<ResultPtr> aResults = aFeature->results();
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
std::list<ResultPtr>::const_iterator aIt;
for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
ResultPtr anObject = *aIt;
}
}
}
- QIntList aModes;
- module()->activeSelectionModes(aModes);
- myDisplayer->activateObjects(aModes, anObjects);
+ activateObjectsSelection(anObjects);
}
return;
QStringList aGrantedIds;
- if (isSalomeMode())
- aGrantedIds = mySalomeConnector->nestedActions(theOperation->id());
+ if (isSalomeMode()) {
+ const std::shared_ptr<Config_FeatureMessage>& anInfo =
+ mySalomeConnector->featureInfo(theOperation->id());
+ if (anInfo.get())
+ aGrantedIds = QString::fromStdString(anInfo->nestedFeatures())
+ .split(" ", QString::SkipEmptyParts);
+ }
else
aGrantedIds = myActionsMgr->nestedCommands(theOperation->id());
aFOperation->setGrantedOperationIds(aGrantedIds);
}
-
-/*
- * Saves document with given name.
- */
+//******************************************************
void XGUI_Workshop::saveDocument(const QString& theName, std::list<std::string>& theFileNames)
{
QApplication::restoreOverrideCursor();
QApplication::restoreOverrideCursor();
}
+//******************************************************
bool XGUI_Workshop::abortAllOperations()
{
return myOperationMgr->abortAllOperations();
}
+//******************************************************
+void XGUI_Workshop::operationStarted(ModuleBase_Operation* theOperation)
+{
+ setGrantedFeatures(theOperation);
+ if (!theOperation->getDescription()->hasXmlRepresentation()) { //!< No need for property panel
+ updateCommandStatus();
+ }
+ else {
+ myModule->operationStarted(theOperation);
+ }
+}
+
//******************************************************
void XGUI_Workshop::onOpen()
{
}
//show file dialog, check if readable and open
- myCurrentDir = QFileDialog::getExistingDirectory(desktop(), tr("Select directory"));
+ QString aDirectory = QFileDialog::getExistingDirectory(desktop(), tr("Select directory"));
+ openDirectory(aDirectory);
+}
+
+//******************************************************
+void XGUI_Workshop::openDirectory(const QString& theDirectory)
+{
+ myCurrentDir = theDirectory;
if (myCurrentDir.isEmpty())
return;
+
QFileInfo aFileInfo(myCurrentDir);
if (!aFileInfo.exists() || !aFileInfo.isReadable()) {
QMessageBox::critical(desktop(), tr("Warning"), tr("Unable to open the file."));
myCurrentDir = "";
return;
}
+
QApplication::setOverrideCursor(Qt::WaitCursor);
+ SessionPtr aSession = ModelAPI_Session::get();
aSession->closeAll();
aSession->load(myCurrentDir.toLatin1().constData());
myObjectBrowser->rebuildDataTree();
updateCommandStatus();
+#ifndef HAVE_SALOME
+ myMainWindow->setCurrentDir(myCurrentDir, true);
+#endif
QApplication::restoreOverrideCursor();
}
void XGUI_Workshop::onValuesChanged()
{
ModuleBase_ModelWidget* aSenderWidget = (ModuleBase_ModelWidget*)(sender());
- if (!aSenderWidget || aSenderWidget->canSetValue())
+ if (!aSenderWidget || aSenderWidget->canAcceptFocus())
return;
ModuleBase_ModelWidget* anActiveWidget = 0;
}
}
+void XGUI_Workshop::onWidgetObjectUpdated()
+{
+ operationMgr()->onValidateOperation();
+}
+
ModuleBase_IModule* XGUI_Workshop::loadModule(const QString& theModule)
{
QString libName = QString::fromStdString(library(theModule.toStdString()));
if (!err.isEmpty()) {
if (desktop()) {
- Events_Error::send(err.toStdString());
+ Events_InfoMessage("XGUI_Workshop", err.toStdString()).send();
} else {
qWarning(qPrintable(err));
}
// myModule, SLOT(onBeforeObjectErase(ObjectPtr, AISObjectPtr)));
myModule->createFeatures();
+#ifdef HAVE_SALOME
+ salomeConnector()->createFeatureActions();
+#endif
//myActionsMgr->update();
return true;
}
aObjDock->setStyleSheet(
"::title { position: relative; padding-left: 5px; text-align: left center }");
myObjectBrowser = new XGUI_ObjectsBrowser(aObjDock);
+ myObjectBrowser->setXMLReader(myDataModelXMLReader);
myModule->customizeObjectBrowser(myObjectBrowser);
aObjDock->setWidget(myObjectBrowser);
QAction* aCancelAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Abort);
connect(aCancelAct, SIGNAL(triggered()), myOperationMgr, SLOT(onAbortOperation()));
+
+ QAction* aPreviewAct = myActionsMgr->operationStateAction(XGUI_ActionsMgr::Preview);
+ connect(aPreviewAct, SIGNAL(triggered()), this, SLOT(onPreviewActionClicked()));
+
connect(myPropertyPanel, SIGNAL(keyReleased(QObject*, QKeyEvent*)),
myOperationMgr, SLOT(onKeyReleased(QObject*, QKeyEvent*)));
-
connect(myPropertyPanel, SIGNAL(enterClicked(QObject*)),
myOperationMgr, SLOT(onProcessEnter(QObject*)));
}
moveObjects();
else if (theId == "COLOR_CMD")
changeColor(aObjects);
+ else if (theId == "DEFLECTION_CMD")
+ changeDeflection(aObjects);
else if (theId == "SHOW_CMD") {
showObjects(aObjects, true);
mySelector->updateSelectionBy(ModuleBase_ISelection::Browser);
aObj->setDisplayed(false);
}
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
+ } else if (theId == "SELECT_VERTEX_CMD") {
+ setViewerSelectionMode(TopAbs_VERTEX);
+ } else if (theId == "SELECT_EDGE_CMD") {
+ setViewerSelectionMode(TopAbs_EDGE);
+ } else if (theId == "SELECT_FACE_CMD") {
+ setViewerSelectionMode(TopAbs_FACE);
+ } else if (theId == "SELECT_RESULT_CMD") {
+ //setViewerSelectionMode(-1);
+ //IMP: an attempt to use result selection with other selection modes
+ setViewerSelectionMode(ModuleBase_ResultPrs::Sel_Result);
+ setViewerSelectionMode(TopAbs_COMPSOLID);
+ } else if (theId == "SHOW_RESULTS_CMD") {
+ highlightResults(aObjects);
+ } else if (theId == "SHOW_FEATURE_CMD") {
+ highlightFeature(aObjects);
+ }
+}
+
+//**************************************************************
+void XGUI_Workshop::setViewerSelectionMode(int theMode)
+{
+ if (theMode == -1)
+ myViewerSelMode.clear();
+ else {
+ if (myViewerSelMode.contains(theMode))
+ myViewerSelMode.removeAll(theMode);
+ else
+ myViewerSelMode.append(theMode);
}
+ activateObjectsSelection(myDisplayer->displayedObjects());
+}
+
+//**************************************************************
+void XGUI_Workshop::activateObjectsSelection(const QObjectPtrList& theList)
+{
+ QIntList aModes;
+ module()->activeSelectionModes(aModes);
+ if (aModes.isEmpty() && (myViewerSelMode.length() > 0))
+ aModes.append(myViewerSelMode);
+ myDisplayer->activateObjects(aModes, theList);
}
//**************************************************************
void XGUI_Workshop::deleteObjects()
{
ModuleBase_IModule* aModule = module();
- // 1. allow the module to delete objects, do nothing if it has succeed
+ // allow the module to delete objects, do nothing if it has succeed
if (aModule->deleteObjects()) {
updateCommandStatus();
return;
QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
if (!abortAllOperations())
return;
- // check whether the object can be deleted. There should not be parts which are not loaded
- if (!XGUI_Tools::canRemoveOrRename(desktop(), anObjects))
- return;
bool hasResult = false;
bool hasFeature = false;
bool hasParameter = false;
- bool hasSubFeature = false;
- ModuleBase_Tools::checkObjects(anObjects, hasResult, hasFeature, hasParameter, hasSubFeature);
+ bool hasCompositeOwner = false;
+ ModuleBase_Tools::checkObjects(anObjects, hasResult, hasFeature, hasParameter, hasCompositeOwner);
if (!(hasFeature || hasParameter))
return;
- // 3. delete objects
- std::set<FeaturePtr> anIgnoredFeatures;
- std::set<FeaturePtr> aDirectRefFeatures, aIndirectRefFeatures;
- findReferences(anObjects, aDirectRefFeatures, aIndirectRefFeatures);
-
- bool doDeleteReferences = true;
- if (isDeleteFeatureWithReferences(anObjects, aDirectRefFeatures, aIndirectRefFeatures,
- desktop(), doDeleteReferences)) {
- // start operation
- QString aDescription = contextMenuMgr()->action("DELETE_CMD")->text();
- aDescription += " " + aDescription.arg(XGUI_Tools::unionOfObjectNames(anObjects, ", "));
- ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction(aDescription, module());
- operationMgr()->startOperation(anOpAction);
+ // delete objects
+ std::map<FeaturePtr, std::set<FeaturePtr> > aReferences;
+ std::set<FeaturePtr> aFeatures;
+ ModuleBase_Tools::convertToFeatures(anObjects, aFeatures);
+ ModelAPI_Tools::findAllReferences(aFeatures, aReferences);
+
+ bool aDone = false;
+ QString aDescription = contextMenuMgr()->action("DELETE_CMD")->text() + " %1";
+ aDescription = aDescription.arg(XGUI_Tools::unionOfObjectNames(anObjects, ", "));
+ ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction(aDescription, module());
+
+ operationMgr()->startOperation(anOpAction);
+ std::set<FeaturePtr> aFeatureRefsToDelete;
+ if (ModuleBase_Tools::askToDelete(aFeatures, aReferences, desktop(), aFeatureRefsToDelete)) {
+ // WORKAROUND, should be done before each object remove, if it presents in XGUI_DataModel tree
// It is necessary to clear selection in order to avoid selection changed event during
// deletion and negative consequences connected with processing of already deleted items
mySelector->clearSelection();
- // delete and commit/abort operation in model
- if (deleteFeaturesInternal(anObjects, aDirectRefFeatures, aIndirectRefFeatures,
- anIgnoredFeatures, doDeleteReferences))
- operationMgr()->commitOperation();
- else
- operationMgr()->abortOperation(operationMgr()->currentOperation());
+ if (!aFeatureRefsToDelete.empty())
+ aFeatures.insert(aFeatureRefsToDelete.begin(), aFeatureRefsToDelete.end());
+ aDone = ModelAPI_Tools::removeFeatures(aFeatures, false);
+ }
+ if (aDone)
+ operationMgr()->commitOperation();
+ else
+ operationMgr()->abortOperation(operationMgr()->currentOperation());
+}
+
+//**************************************************************
+void addRefsToFeature(const FeaturePtr& theFeature,
+ const std::map<FeaturePtr, std::set<FeaturePtr> >& theMainList,
+ std::set<FeaturePtr>& theReferences)
+{
+ //if (theReferences.find(theFeature) != theReferences.end())
+ // return;
+ if (theMainList.find(theFeature) == theMainList.end())
+ return; // this feature is not in the selection list, so exists without references to it
+ std::set<FeaturePtr> aMainReferences = theMainList.at(theFeature);
+
+ std::set<FeaturePtr>::const_iterator anIt = aMainReferences.begin(),
+ aLast = aMainReferences.end();
+ for (; anIt != aLast; anIt++) {
+ FeaturePtr aRefFeature = *anIt;
+ if (theReferences.find(aRefFeature) == theReferences.end())
+ theReferences.insert(aRefFeature);
+ addRefsToFeature(aRefFeature, theMainList, theReferences);
}
}
return;
QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
- QObjectPtrList aFeatures;
- foreach (ObjectPtr anObject, anObjects) {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anObject);
- // for parameter result, use the corresponded reature to be removed
- if (!aFeature.get() && anObject->groupName() == ModelAPI_ResultParameter::group()) {
- aFeature = ModelAPI_Feature::feature(anObject);
- }
- aFeatures.append(aFeature);
- }
-
- // 1. find all referenced features
- QList<ObjectPtr> anUnusedObjects;
- std::set<FeaturePtr> aDirectRefFeatures;
- //foreach (ObjectPtr anObject, anObjects) {
- foreach (ObjectPtr anObject, aFeatures) {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anObject);
- // for parameter result, use the corresponded reature to be removed
- //if (!aFeature.get() && anObject->groupName() == ModelAPI_ResultParameter::group()) {
- // aFeature = ModelAPI_Feature::feature(anObject);
- //}
- if (aFeature.get()) {
- std::set<FeaturePtr> alreadyProcessed;
- aDirectRefFeatures.clear();
- XGUI_Tools::refsDirectToFeatureInAllDocuments(aFeature, aFeature, aFeatures,
- aDirectRefFeatures, alreadyProcessed);
- if (aDirectRefFeatures.empty() && !anUnusedObjects.contains(aFeature))
- anUnusedObjects.append(aFeature);
+ std::set<FeaturePtr> aFeatures;
+ ModuleBase_Tools::convertToFeatures(anObjects, aFeatures);
+
+#ifdef DEBUG_CLEAN_HISTORY
+ QStringList anInfo;
+ std::set<FeaturePtr>::const_iterator aFIt;
+ for (aFIt = aFeatures.begin(); aFIt != aFeatures.end(); ++aFIt) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(*aFIt);
+ anInfo.append(aFeature->name().c_str());
+ }
+ QString anInfoStr = anInfo.join(";\t");
+ qDebug(QString("cleanHistory for: [%1] - %2").arg(aFeatures.size()).arg(anInfoStr).toStdString().c_str());
+#endif
+
+ std::map<FeaturePtr, std::set<FeaturePtr> > aReferences;
+ ModelAPI_Tools::findAllReferences(aFeatures, aReferences, true, false);
+ // find for each object whether all reference values are in the map as key, that means that there is
+ // no other reference in the model to this object, so it might be removed by cleaning history
+ // sk_1(ext_1, vertex_1) + (sk_3, bool_1) - cann't be deleted, dependency to bool_1
+ // ext_1(bool_1, sk_3) - cann't be deleted, dependency to bool_1
+ // vertex_1()
+ // sk_2(ext_2) + (bool_1) - cann't be deleted, dependency to bool_1
+ // ext_2(bool_1) - cann't be deleted, dependency to bool_1
+ // sk_3()
+ // Information: bool_1 is not selected
+ std::set<FeaturePtr> anUnusedObjects;
+ std::map<FeaturePtr, std::set<FeaturePtr> >::const_iterator aMainIt = aReferences.begin(),
+ aMainLast = aReferences.end();
+ for (; aMainIt != aMainLast; aMainIt++) {
+ FeaturePtr aMainListFeature = aMainIt->first;
+ std::set<FeaturePtr> aMainRefList = aMainIt->second;
+ std::set<FeaturePtr>::const_iterator aRefIt = aMainRefList.begin(), aRefLast = aMainRefList.end();
+ bool aFeatureOutOfTheList = false;
+ for (; aRefIt != aRefLast && !aFeatureOutOfTheList; aRefIt++) {
+ FeaturePtr aRefFeature = *aRefIt;
+ aFeatureOutOfTheList = aReferences.find(aRefFeature) == aReferences.end();
}
+ if (!aFeatureOutOfTheList)
+ anUnusedObjects.insert(aMainListFeature);
+ }
+
+#ifdef DEBUG_CLEAN_HISTORY
+ anInfo.clear();
+ for (aFIt = anUnusedObjects.begin(); aFIt != anUnusedObjects.end(); ++aFIt) {
+ FeaturePtr aFeature = *aFIt;
+ anInfo.append(aFeature->name().c_str());
}
+ qDebug(QString("unused objects: [%1] - %2").arg(anInfo.size()).arg(anInfo.join(";\t")).toStdString().c_str());
+#endif
- // 2. warn about the references remove, break the delete operation if the user chose it
+ // warn about the references remove, break the delete operation if the user chose it
if (!anUnusedObjects.empty()) {
QStringList aNames;
- foreach (const ObjectPtr& anObject, anUnusedObjects) {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anObject);
+ foreach (const FeaturePtr& aFeature, anUnusedObjects) {
aNames.append(aFeature->name().c_str());
}
+ aNames.sort();
QString anUnusedNames = aNames.join(", ");
QString anActionId = "CLEAN_HISTORY_CMD";
QString aText = QString(tr("Unused features are the following: %1.\nThese features will be deleted.\nWould you like to continue?")
.arg(anUnusedNames));
- /*QString aText;
- if (anUnusedNames.isEmpty()) {
- aMessageBox.setStandardButtons(QMessageBox::Ok);
- aMessageBox.setDefaultButton(QMessageBox::Ok);
-
- aText = QString(tr("All features are relevant, there is nothing to be deleted"));
- }
- else {
- aMessageBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
- aMessageBox.setDefaultButton(QMessageBox::No);
-
- aText = QString(tr("Unused features are the following: %1.\nThese features will be deleted.\nWould you like to continue?")
- .arg(anUnusedNames));
- }*/
-
aMessageBox.setText(aText);
if (aMessageBox.exec() == QMessageBox::No)
return;
ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction(aDescription, module());
operationMgr()->startOperation(anOpAction);
+ // WORKAROUND, should be done before each object remove, if it presents in XGUI_DataModel tree
+ // It is necessary to clear selection in order to avoid selection changed event during
+ // deletion and negative consequences connected with processing of already deleted items
+ mySelector->clearSelection();
+
std::set<FeaturePtr> anIgnoredFeatures;
- if (removeFeatures(anUnusedObjects, anIgnoredFeatures, anActionId)) {
+ if (ModelAPI_Tools::removeFeatures(anUnusedObjects, true)) {
operationMgr()->commitOperation();
}
else {
// moving and negative consequences connected with processing of already moved items
mySelector->clearSelection();
// check whether the object can be moved. There should not be parts which are not loaded
- if (!XGUI_Tools::canRemoveOrRename(desktop(), anObjects))
+ std::set<FeaturePtr> aFeatures;
+ ModuleBase_Tools::convertToFeatures(anObjects, aFeatures);
+ if (!XGUI_Tools::canRemoveOrRename(desktop(), aFeatures))
return;
DocumentPtr anActiveDocument = aMgr->activeDocument();
FeaturePtr aCurrentFeature = anActiveDocument->currentFeature(true);
- foreach (ObjectPtr aObject, anObjects) {
- if (!myModule->canApplyAction(aObject, anActionId))
+ std::set<FeaturePtr>::const_iterator anIt = aFeatures.begin(), aLast = aFeatures.end();
+ for (; anIt != aLast; anIt++) {
+ FeaturePtr aFeature = *anIt;
+ if (!aFeature.get() || !myModule->canApplyAction(aFeature, anActionId))
continue;
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObject);
- if (aFeature.get()) {
- anActiveDocument->moveFeature(aFeature, aCurrentFeature);
- aCurrentFeature = anActiveDocument->currentFeature(true);
- }
+ anActiveDocument->moveFeature(aFeature, aCurrentFeature);
+ aCurrentFeature = anActiveDocument->currentFeature(true);
}
aMgr->finishOperation();
}
//**************************************************************
-void XGUI_Workshop::findReferences(const QObjectPtrList& theList,
- std::set<FeaturePtr>& aDirectRefFeatures,
- std::set<FeaturePtr>& aIndirectRefFeatures)
-{
- foreach (ObjectPtr aDeletedObj, theList) {
- std::set<FeaturePtr> alreadyProcessed;
- XGUI_Tools::refsToFeatureInAllDocuments(aDeletedObj, aDeletedObj, theList, aDirectRefFeatures,
- aIndirectRefFeatures, alreadyProcessed);
- std::set<FeaturePtr> aDifference;
- std::set_difference(aIndirectRefFeatures.begin(), aIndirectRefFeatures.end(),
- aDirectRefFeatures.begin(), aDirectRefFeatures.end(),
- std::inserter(aDifference, aDifference.begin()));
- aIndirectRefFeatures = aDifference;
- }
-}
-
-bool XGUI_Workshop::isDeleteFeatureWithReferences(const QObjectPtrList& theList,
- const std::set<FeaturePtr>& aDirectRefFeatures,
- const std::set<FeaturePtr>& aIndirectRefFeatures,
- QWidget* theParent,
- bool& doDeleteReferences)
+bool XGUI_Workshop::deleteFeatures(const QObjectPtrList& theObjects)
{
- doDeleteReferences = true;
+ std::map<FeaturePtr, std::set<FeaturePtr> > aReferences;
+ std::set<FeaturePtr> aFeatures;
+ ModuleBase_Tools::convertToFeatures(theObjects, aFeatures);
- QString aDirectNames, aIndirectNames;
- if (!aDirectRefFeatures.empty()) {
- QStringList aDirectRefNames;
- foreach (const FeaturePtr& aFeature, aDirectRefFeatures)
- aDirectRefNames.append(aFeature->name().c_str());
- aDirectNames = aDirectRefNames.join(", ");
-
- QStringList aIndirectRefNames;
- foreach (const FeaturePtr& aFeature, aIndirectRefFeatures)
- aIndirectRefNames.append(aFeature->name().c_str());
- aIndirectNames = aIndirectRefNames.join(", ");
- }
-
- bool aCanReplaceParameters = !aDirectRefFeatures.empty();
- QStringList aPartFeatureNames;
- foreach (ObjectPtr aObj, theList) {
- FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
- // invalid feature data means that the feature is already removed in model,
- // we needn't process it. E.g. delete of feature from create operation. The operation abort
- // will delete the operation
- if (!aFeature->data()->isValid())
- continue;
- ResultPtr aFirstResult = aFeature->firstResult();
- std::string aResultGroupName = aFirstResult->groupName();
- if (aResultGroupName == ModelAPI_ResultPart::group())
- aPartFeatureNames.append(aFeature->name().c_str());
-
- if (aCanReplaceParameters && aResultGroupName != ModelAPI_ResultParameter::group())
- aCanReplaceParameters = false;
- }
- QString aPartNames = aPartFeatureNames.join(", ");
-
- QMessageBox aMessageBox(theParent);
- aMessageBox.setWindowTitle(tr("Delete features"));
- aMessageBox.setIcon(QMessageBox::Warning);
- aMessageBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
- aMessageBox.setDefaultButton(QMessageBox::No);
-
- QString aText;
- if (!aDirectNames.isEmpty() || !aIndirectNames.isEmpty()) {
- if (aCanReplaceParameters) {
- aText = QString(tr("Selected parameters are used in the following features: %1.\nThese features will be deleted.\nOr parameters could be replaced by their values.\n")
- .arg(aDirectNames));
- if (!aIndirectNames.isEmpty())
- aText += QString(tr("(Also these features will be deleted: %1)\n")).arg(aIndirectNames);
- QPushButton *aReplaceButton = aMessageBox.addButton(tr("Replace"), QMessageBox::ActionRole);
- } else {
- aText = QString(tr("Selected features are used in the following features: %1.\nThese features will be deleted.\n")).arg(aDirectNames);
- if (!aIndirectNames.isEmpty())
- aText += QString(tr("(Also these features will be deleted: %1)\n")).arg(aIndirectNames);
- }
- }
- if (!aPartNames.isEmpty())
- aText += QString(tr("The following parts will be deleted: %1.\n")).arg(aPartNames);
-
- if (!aText.isEmpty()) {
- aText += "Would you like to continue?";
- aMessageBox.setText(aText);
- aMessageBox.exec();
- QMessageBox::ButtonRole aButtonRole = aMessageBox.buttonRole(aMessageBox.clickedButton());
-
- if (aButtonRole == QMessageBox::NoRole)
- return false;
-
- if (aButtonRole == QMessageBox::ActionRole) {
- foreach (ObjectPtr aObj, theList)
- ModelAPI_ReplaceParameterMessage::send(aObj, this);
- doDeleteReferences = false;
- }
- }
- return true;
-}
-
-bool XGUI_Workshop::deleteFeatures(const QObjectPtrList& theFeatures,
- const std::set<FeaturePtr>& theIgnoredFeatures)
-{
- std::set<FeaturePtr> aDirectRefFeatures, aIndirectRefFeatures;
- findReferences(theFeatures, aDirectRefFeatures, aIndirectRefFeatures);
- return deleteFeaturesInternal(theFeatures, aDirectRefFeatures, aIndirectRefFeatures,
- theIgnoredFeatures);
-}
-
-bool XGUI_Workshop::deleteFeaturesInternal(const QObjectPtrList& theList,
- const std::set<FeaturePtr>& aDirectRefFeatures,
- const std::set<FeaturePtr>& aIndirectRefFeatures,
- const std::set<FeaturePtr>& theIgnoredFeatures,
- const bool doDeleteReferences)
-{
- if (doDeleteReferences) {
- std::set<FeaturePtr> aFeaturesToDelete = aDirectRefFeatures;
- aFeaturesToDelete.insert(aIndirectRefFeatures.begin(), aIndirectRefFeatures.end());
- std::set<FeaturePtr>::const_iterator anIt = aFeaturesToDelete.begin(),
- aLast = aFeaturesToDelete.end();
-#ifdef DEBUG_DELETE
- QStringList anInfo;
-#endif
- for (; anIt != aLast; anIt++) {
- FeaturePtr aFeature = (*anIt);
- DocumentPtr aDoc = aFeature->document();
- if (theIgnoredFeatures.find(aFeature) == theIgnoredFeatures.end()) {
- aDoc->removeFeature(aFeature);
-#ifdef DEBUG_DELETE
- anInfo.append(ModuleBase_Tools::objectInfo(aFeature).toStdString().c_str());
-#endif
- }
- }
-#ifdef DEBUG_DELETE
- qDebug(QString("remove references:%1").arg(anInfo.join("; ")).toStdString().c_str());
- anInfo.clear();
-#endif
- }
-
- QString anActionId = "DELETE_CMD";
- return removeFeatures(theList, theIgnoredFeatures, anActionId);
-}
-
-//**************************************************************
-bool XGUI_Workshop::removeFeatures(const QObjectPtrList& theList,
- const std::set<FeaturePtr>& theIgnoredFeatures,
- const QString& theActionId)
-{
- bool isDone = false;
-
- QString anId = QString::fromStdString(theActionId.toStdString().c_str());
- QStringList anObjectGroups = contextMenuMgr()->actionObjectGroups(anId);
- // 4. remove the parameter features
- foreach (ObjectPtr aObj, theList) {
- // features and parameters can be removed here,
- // the results are removed only by a corresponded feature remove
- std::string aGroupName = aObj->groupName();
- if (!anObjectGroups.contains(aGroupName.c_str()))
- continue;
-
- FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
- if (aFeature) {
- /*// TODO: to learn the workshop to delegate the Part object deletion to the PartSet module
- // part features are removed in the PartSet module. This condition should be moved there
- if (aFeature->getKind() == "Part")
- continue;
- */
- DocumentPtr aDoc = aObj->document();
- if (theIgnoredFeatures.find(aFeature) == theIgnoredFeatures.end()) {
-#ifdef DEBUG_DELETE
- QString anInfoStr = ModuleBase_Tools::objectInfo(aFeature);
- anInfo.append(anInfoStr);
- qDebug(QString("remove feature :%1").arg(anInfoStr).toStdString().c_str());
-#endif
- aDoc->removeFeature(aFeature);
- isDone = true;
- }
- }
- }
-#ifdef DEBUG_DELETE
- qDebug(QString("remove features:%1").arg(anInfo.join("; ")).toStdString().c_str());
-#endif
- return true;
+ return ModelAPI_Tools::removeFeaturesAndReferences(aFeatures);
}
bool hasResults(QObjectPtrList theObjects, const std::set<std::string>& theTypes)
// The order of appending features of the part and the part itself is important
// Append features from a part feature
- foreach (const ResultPtr& aResult, aFeature->results()) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ foreach (const ResultPtr& aResult, aResults) {
ResultPartPtr aResultPart =
std::dynamic_pointer_cast<ModelAPI_ResultPart>(aResult);
if (aResultPart.get() && aResultPart->partDoc().get()) {
std::set<FeaturePtr> aPlacedFeatures(aFeaturesBetween.begin(), aFeaturesBetween.end());
// 2. Get all reference features to the selected object in the document
std::set<FeaturePtr> aRefFeatures;
- XGUI_Tools::refsToFeatureInFeatureDocument(aObject, aRefFeatures);
+ ModuleBase_Tools::refsToFeatureInFeatureDocument(aObject, aRefFeatures);
if (aRefFeatures.empty())
continue;
updateCommandStatus();
}
+//**************************************************************
+bool XGUI_Workshop::canChangeDeflection() const
+{
+ QObjectPtrList aObjects = mySelector->selection()->selectedObjects();
+
+ std::set<std::string> aTypes;
+ aTypes.insert(ModelAPI_ResultGroup::group());
+ aTypes.insert(ModelAPI_ResultConstruction::group());
+ aTypes.insert(ModelAPI_ResultBody::group());
+ aTypes.insert(ModelAPI_ResultPart::group());
+
+ return hasResults(aObjects, aTypes);
+}
+
+void setDeflection(ResultPtr theResult, const double theDeflection)
+{
+ if (!theResult.get())
+ return;
+
+ AttributeDoublePtr aDeflectionAttr = theResult->data()->real(ModelAPI_Result::DEFLECTION_ID());
+ if (aDeflectionAttr.get() != NULL)
+ aDeflectionAttr->setValue(theDeflection);
+}
+
+
+//**************************************************************
+void XGUI_Workshop::changeDeflection(const QObjectPtrList& theObjects)
+{
+ AttributeDoublePtr aDoubleAttr;
+ // 1. find the current color of the object. This is a color of AIS presentation
+ // The objects are iterated until a first valid color is found
+ double aDeflection = -1;
+ foreach(ObjectPtr anObject, theObjects) {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObject);
+ if (aResult.get()) {
+ aDeflection = XGUI_CustomPrs::getResultDeflection(aResult);
+ }
+ else {
+ // TODO: remove the obtaining a color from the AIS object
+ // this does not happen never because:
+ // 1. The color can be changed only on results
+ // 2. The result can be not visualized in the viewer(e.g. Origin Construction)
+ AISObjectPtr anAISObj = myDisplayer->getAISObject(anObject);
+ if (anAISObj.get()) {
+ aDeflection = anAISObj->getDeflection();
+ }
+ }
+ if (aDeflection > 0)
+ break;
+ }
+ if (aDeflection < 0)
+ return;
+
+ if (!abortAllOperations())
+ return;
+ // 2. show the dialog to change the value
+ XGUI_DeflectionDialog* aDlg = new XGUI_DeflectionDialog(desktop());
+ aDlg->setDeflection(aDeflection);
+ aDlg->move(QCursor::pos());
+ bool isDone = aDlg->exec() == QDialog::Accepted;
+ if (!isDone)
+ return;
+
+ // 3. abort the previous operation and start a new one
+ SessionPtr aMgr = ModelAPI_Session::get();
+ QString aDescription = contextMenuMgr()->action("DEFLECTION_CMD")->text();
+ aMgr->startOperation(aDescription.toStdString());
+
+ // 4. set the value to all results
+ aDeflection = aDlg->getDeflection();
+ foreach(ObjectPtr anObj, theObjects) {
+ ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(anObj);
+ if (aResult.get() != NULL) {
+ ResultCompSolidPtr aCompsolidResult = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(aResult);
+ if (aCompsolidResult.get() != NULL) { // change colors for all sub-solids
+ for(int i = 0; i < aCompsolidResult->numberOfSubs(); i++) {
+ setDeflection(aCompsolidResult->subResult(i), aDeflection);
+ }
+ }
+ setDeflection(aResult, aDeflection);
+ }
+ }
+ aMgr->finishOperation();
+ updateCommandStatus();
+}
+
//**************************************************************
#define SET_DISPLAY_GROUP(aGroupName, aDisplay) \
for (int i = 0; i < aDoc->size(aGroupName); i++) { \
return aResult;
}
+void XGUI_Workshop::setStatusBarMessage(const QString& theMessage)
+{
+#ifdef HAVE_SALOME
+ salomeConnector()->putInfo(theMessage, -1);
+#else
+ myMainWindow->putInfo(theMessage, -1);
+#endif
+}
+
void XGUI_Workshop::synchronizeViewer()
{
SessionPtr aMgr = ModelAPI_Session::get();
if (theUpdateViewer)
myDisplayer->updateViewer();
}
+
+void XGUI_Workshop::highlightResults(const QObjectPtrList& theObjects)
+{
+ FeaturePtr aFeature;
+ QObjectPtrList aSelList = theObjects;
+ std::list<ResultPtr> aResList;
+ bool aHasHidden = false;
+ foreach(ObjectPtr aObj, theObjects) {
+ aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+ if (aFeature.get()) {
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aIt;
+ for(aIt = aResList.cbegin(); aIt != aResList.cend(); aIt++) {
+ aHasHidden |= (*aIt)->isConcealed();
+ aSelList.append(*aIt);
+ }
+ }
+ }
+ if (aSelList.count() > theObjects.count()) {
+ // if something was found
+ bool aBlocked = objectBrowser()->blockSignals(true);
+ objectBrowser()->setObjectsSelected(aSelList);
+ objectBrowser()->blockSignals(aBlocked);
+ }
+ if (aHasHidden)
+ QMessageBox::information(desktop(), tr("Find results"),
+ tr("Results not found"), QMessageBox::Ok);
+}
+
+void XGUI_Workshop::highlightFeature(const QObjectPtrList& theObjects)
+{
+ ResultPtr aResult;
+ QObjectPtrList aSelList = theObjects;
+ FeaturePtr aFeature;
+ foreach(ObjectPtr aObj, theObjects) {
+ aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
+ if (aResult.get()) {
+ aFeature = ModelAPI_Feature::feature(aResult);
+ if (aFeature.get()) {
+ aSelList.append(aFeature);
+ }
+ }
+ }
+ if (aSelList.count() > theObjects.count()) {
+ // if something was found
+ bool aBlocked = objectBrowser()->blockSignals(true);
+ objectBrowser()->setObjectsSelected(aSelList);
+ objectBrowser()->blockSignals(aBlocked);
+ }
+}