#include <ModuleBase_WidgetFactory.h>
#include <ModuleBase_Tools.h>
#include <ModuleBase_IViewer.h>
-#include<ModuleBase_FilterFactory.h>
+#include <ModuleBase_FilterFactory.h>
#include <ModuleBase_PageBase.h>
+#include <ModuleBase_Tools.h>
#include <Config_Common.h>
#include <Config_FeatureMessage.h>
#include <dlfcn.h>
#endif
+//#define DEBUG_FEATURE_CREATED
+//#define DEBUG_FEATURE_REDISPLAY
+
QMap<QString, QString> XGUI_Workshop::myIcons;
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_TOHIDE));
aLoop->registerListener(this, Events_Loop::eventByName(EVENT_SELFILTER_LOADED));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_UPDATE_VIEWER_BLOCKED));
+ aLoop->registerListener(this, Events_Loop::eventByName(EVENT_UPDATE_VIEWER_UNBLOCKED));
+
registerValidators();
// Calling of loadCustomProps before activating module is required
aMsg->parameters());
}
}
+ } else if (theMessage->eventID() == Events_Loop::eventByName(EVENT_UPDATE_VIEWER_BLOCKED)) {
+ // the viewer's update context will not happens until viewer updated is emitted
+ myDisplayer->enableUpdateViewer(false);
+ } else if (theMessage->eventID() == Events_Loop::eventByName(EVENT_UPDATE_VIEWER_UNBLOCKED)) {
+ // the viewer's update context is unblocked, the viewer's update works
+ myDisplayer->enableUpdateViewer(true);
} else {
//Show error dialog if error message received.
std::shared_ptr<Events_Error> anAppError = std::dynamic_pointer_cast<Events_Error>(theMessage);
{
std::set<ObjectPtr> aObjects = theMsg->objects();
std::set<ObjectPtr>::const_iterator aIt;
+
+#ifdef DEBUG_FEATURE_REDISPLAY
+ QStringList anInfo;
+ for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
+ anInfo.append(ModuleBase_Tools::objectInfo((*aIt)));
+ }
+ QString anInfoStr = anInfo.join(", ");
+ qDebug(QString("onFeatureRedisplayMsg: %1, %2").arg(aObjects.size()).arg(anInfoStr).toStdString().c_str());
+#endif
+
for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
ObjectPtr aObj = (*aIt);
+ // Hide the object if it is invalid or concealed one
bool aHide = !aObj->data() || !aObj->data()->isValid();
if (!aHide) { // check that this is not hidden result
ResultPtr aRes = std::dynamic_pointer_cast<ModelAPI_Result>(aObj);
if (aHide)
myDisplayer->erase(aObj, false);
else {
- if (myDisplayer->isVisible(aObj)) {
+ // Redisplay the visible object or the object of the current operation
+ bool isVisibleObject = myDisplayer->isVisible(aObj);
+ #ifdef DEBUG_FEATURE_REDISPLAY
+ //QString anObjInfo = ModuleBase_Tools::objectInfo((aObj));
+ //qDebug(QString("visible=%1 : display= %2").arg(isVisibleObject).arg(anObjInfo).toStdString().c_str());
+ #endif
+
+ if (isVisibleObject) { // redisplay visible object
displayObject(aObj); // In order to update presentation
if (myOperationMgr->hasOperation()) {
ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
aOperation->hasObject(aObj) && myDisplayer->isActive(aObj))
myDisplayer->deactivate(aObj);
}
- } else {
- if (myOperationMgr->hasOperation()) {
+ } else { // display object if the current operation has it
+ ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
+ if (aOperation && aOperation->hasObject(aObj)) {
ModuleBase_Operation* aOperation = myOperationMgr->currentOperation();
- if (myModule->canDisplayObject(aObj)) {
- displayObject(aObj);
+ if (displayObject(aObj)) {
// Deactivate object of current operation from selection
if (myDisplayer->isActive(aObj))
myDisplayer->deactivate(aObj);
void XGUI_Workshop::onFeatureCreatedMsg(const std::shared_ptr<ModelAPI_ObjectUpdatedMessage>& theMsg)
{
std::set<ObjectPtr> aObjects = theMsg->objects();
-
std::set<ObjectPtr>::const_iterator aIt;
- bool aHasPart = false;
- bool isDisplayed = false;
+#ifdef DEBUG_FEATURE_CREATED
+ QStringList anInfo;
for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
+ anInfo.append(ModuleBase_Tools::objectInfo((*aIt)));
+ }
+ QString anInfoStr = anInfo.join(", ");
+ qDebug(QString("onFeatureCreatedMsg: %1, %2").arg(aObjects.size()).arg(anInfoStr).toStdString().c_str());
+#endif
- ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aIt);
- if (aPart) {
- aHasPart = true;
+ //bool aHasPart = false;
+ bool isDisplayed = false;
+ for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) {
+ ObjectPtr anObject = *aIt;
+ // the validity of the data should be checked here in order to avoid display of the objects,
+ // which were created, then deleted, but flush for the creation event happens after that
+ if (!anObject->data() || !anObject->data()->isValid())
+ continue;
+ //ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aIt);
+ //if (aPart) {
+ //aHasPart = true;
// If a feature is created from the aplication's python console
// it doesn't stored in the operation mgr and doesn't displayed
- } else if (myModule->canDisplayObject(*aIt)) {
- displayObject(*aIt);
- isDisplayed = true;
- }
+ //} else {
+ isDisplayed = displayObject(*aIt);
+ //}
}
if (myObjectBrowser)
myObjectBrowser->processEvent(theMsg);
// Activate objects created by current operation
// in order to clean selection modes
- QIntList aModes;
- myDisplayer->activateObjects(aModes);
+ // the deactivation should be pefromed in the same place, where the mode is activated,
+ // e.g. activation in the current widget activation, deactivation - in the widget's deactivation
+ //QIntList aModes;
+ //myDisplayer->activateObjects(aModes);
myModule->operationStopped(theOperation);
}
//******************************************************
void XGUI_Workshop::onRedo(int theTimes)
{
+ // the viewer update should be blocked in order to avoid the features blinking. For the created
+ // feature a results are created, the flush of the created signal caused the viewer redisplay for
+ // each created result. After a redisplay signal is flushed. So, the viewer update is blocked until
+ // redo of all possible objects happens
+ bool isUpdateEnabled = myDisplayer->enableUpdateViewer(false);
+
objectBrowser()->treeView()->setCurrentIndex(QModelIndex());
SessionPtr aMgr = ModelAPI_Session::get();
if (aMgr->isOperation())
aMgr->redo();
}
updateCommandStatus();
+
+ // unblock the viewer update functionality and make update on purpose
+ myDisplayer->enableUpdateViewer(isUpdateEnabled);
+ myDisplayer->updateViewer();
}
//******************************************************
myModule = loadModule(moduleName);
if (!myModule)
return false;
+
+ connect(myDisplayer, SIGNAL(objectDisplayed(ObjectPtr, AISObjectPtr)),
+ myModule, SLOT(onObjectDisplayed(ObjectPtr, AISObjectPtr)));
+ connect(myDisplayer, SIGNAL(beforeObjectErase(ObjectPtr, AISObjectPtr)),
+ myModule, SLOT(onBeforeObjectErase(ObjectPtr, AISObjectPtr)));
+
myModule->createFeatures();
myActionsMgr->update();
return true;
} else if (theId == "DEACTIVATE_PART_CMD")
activatePart(ResultPartPtr());
else if (theId == "DELETE_CMD")
- deleteObjects(aObjects);
+ deleteObjects();
else if (theId == "COLOR_CMD")
changeColor(aObjects);
else if (theId == "SHOW_CMD")
//}
//**************************************************************
-void XGUI_Workshop::deleteObjects(const QObjectPtrList& theList)
+void XGUI_Workshop::deleteObjects()
{
ModuleBase_IModule* aModule = module();
+ // 1. allow the module to delete objects, do nothing if it has succeed
if (aModule->deleteObjects())
return;
if (!isActiveOperationAborted())
return;
+ QObjectPtrList anObjects = mySelector->selection()->selectedObjects();
+ // 1. start operation
+ QString aDescription = contextMenuMgr()->action("DELETE_CMD")->text();
+ aDescription += tr(" %1");
+ QStringList aObjectNames;
+ foreach (ObjectPtr aObj, anObjects) {
+ if (!aObj->data().get())
+ continue;
+ aObjectNames << QString::fromStdString(aObj->data()->name());
+ }
+ aDescription = aDescription.arg(aObjectNames.join(", "));
- QMainWindow* aDesktop = isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
- std::set<FeaturePtr> aRefFeatures;
- foreach (ObjectPtr aObj, theList)
+ SessionPtr aMgr = ModelAPI_Session::get();
+ aMgr->startOperation(aDescription.toStdString());
+ // 2. close the documents of the removed parts if the result part is in a list of selected objects
+ foreach (ObjectPtr aObj, anObjects)
{
ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
if (aPart) {
- // TODO: check for what there is this condition. It is placed here historicaly because
- // ther is this condition during remove features.
- } else {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
- if (aFeature.get() != NULL) {
- aObj->document()->refsToFeature(aFeature, aRefFeatures, false);
+ DocumentPtr aDoc = aObj->document();
+ if (aDoc == aMgr->activeDocument()) {
+ aDoc->close();
}
}
}
+ // 3. delete objects
+ QMainWindow* aDesktop = isSalomeMode() ? salomeConnector()->desktop() : myMainWindow;
+ std::set<FeaturePtr> anIgnoredFeatures;
+ if (deleteFeatures(anObjects, anIgnoredFeatures, aDesktop, true)) {
+ myDisplayer->updateViewer();
+ aMgr->finishOperation();
+ updateCommandStatus();
+ }
+ else {
+ aMgr->abortOperation();
+ }
+}
- if (!aRefFeatures.empty()) {
+//**************************************************************
+bool XGUI_Workshop::deleteFeatures(const QObjectPtrList& theList,
+ std::set<FeaturePtr> theIgnoredFeatures,
+ QWidget* theParent,
+ const bool theAskAboutDeleteReferences)
+{
+ // 1. find all referenced features
+ std::set<FeaturePtr> aRefFeatures;
+ foreach (ObjectPtr aObj, theList) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
+ if (aFeature.get() != NULL) {
+ aObj->document()->refsToFeature(aFeature, aRefFeatures, false);
+ }
+ }
+ // 2. warn about the references remove, break the delete operation if the user chose it
+ if (theAskAboutDeleteReferences && !aRefFeatures.empty()) {
QStringList aRefNames;
std::set<FeaturePtr>::const_iterator anIt = aRefFeatures.begin(),
aLast = aRefFeatures.end();
for (; anIt != aLast; anIt++) {
- FeaturePtr aFeature = (*anIt);
- std::string aFName = aFeature->data()->name().c_str();
- std::string aName = (*anIt)->name().c_str();
aRefNames.append((*anIt)->name().c_str());
}
QString aNames = aRefNames.join(", ");
QMessageBox::StandardButton aRes = QMessageBox::warning(
- aDesktop, tr("Delete features"),
+ theParent, tr("Delete features"),
QString(tr("Selected features are used in the following features: %1.\
These features will be deleted also. Would you like to continue?")).arg(aNames),
QMessageBox::No | QMessageBox::Yes, QMessageBox::No);
if (aRes != QMessageBox::Yes)
- return;
+ return false;
}
- QString aDescription = tr("Delete %1");
- QStringList aObjectNames;
- foreach (ObjectPtr aObj, theList) {
- if (!aObj->data().get())
- continue;
- aObjectNames << QString::fromStdString(aObj->data()->name());
- }
- aDescription = aDescription.arg(aObjectNames.join(", "));
- SessionPtr aMgr = ModelAPI_Session::get();
- aMgr->startOperation(aDescription.toStdString());
+ // 3. remove referenced features
std::set<FeaturePtr>::const_iterator anIt = aRefFeatures.begin(),
aLast = aRefFeatures.end();
for (; anIt != aLast; anIt++) {
- FeaturePtr aRefFeature = (*anIt);
- DocumentPtr aDoc = aRefFeature->document();
- aDoc->removeFeature(aRefFeature);
- }
-
+ FeaturePtr aFeature = (*anIt);
+ DocumentPtr aDoc = aFeature->document();
+ if (theIgnoredFeatures.find(aFeature) == theIgnoredFeatures.end())
+ aDoc->removeFeature(aFeature);
+ }
- foreach (ObjectPtr aObj, theList)
- {
- DocumentPtr aDoc = aObj->document();
- ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
- if (aPart) {
- if (aDoc == aMgr->activeDocument()) {
- aDoc->close();
- }
- } else {
- FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
- if (aFeature) {
+ // 4. remove the parameter features
+ foreach (ObjectPtr aObj, theList) {
+ FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
+ if (aFeature) {
+ DocumentPtr aDoc = aObj->document();
+ if (theIgnoredFeatures.find(aFeature) == theIgnoredFeatures.end())
aDoc->removeFeature(aFeature);
- }
}
}
-
- myDisplayer->updateViewer();
- aMgr->finishOperation();
- updateCommandStatus();
+ return true;
}
bool hasResults(QObjectPtrList theObjects, const std::set<std::string>& theTypes)
}
//**************************************************************
-void XGUI_Workshop::displayObject(ObjectPtr theObj)
+bool XGUI_Workshop::displayObject(ObjectPtr theObj)
{
+ if (!myModule->canDisplayObject(theObj))
+ return false;
+
ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theObj);
if (aBody.get() != NULL) {
int aNb = myDisplayer->objectsCount();
viewer()->fitAll();
} else
myDisplayer->display(theObj, false);
+
+ return true;
}
void XGUI_Workshop::addHistoryMenu(QObject* theObject, const char* theSignal, const char* theSlot)
