-// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2019 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
//
// 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
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or
-// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "XGUI_OperationMgr.h"
+
+#include "XGUI_ActiveControlMgr.h"
+#include "XGUI_ActiveControlSelector.h"
+#include "XGUI_FacesPanelSelector.h"
#include "XGUI_ModuleConnector.h"
#include "XGUI_Workshop.h"
#include "XGUI_ErrorMgr.h"
+#include "XGUI_FacesPanel.h"
#include "XGUI_Tools.h"
#include "XGUI_ObjectsBrowser.h"
#include "XGUI_ContextMenuMgr.h"
/// \param theParent the parent to be deleted when the parent is deleted
/// \param theOperationMgr the class to perform deletion
XGUI_ShortCutListener(QObject* theParent, XGUI_OperationMgr* theOperationMgr)
- : QObject(theParent), myOperationMgr(theOperationMgr)
+ : QObject(theParent), myOperationMgr(theOperationMgr), myIsActive(false)
{
qApp->installEventFilter(this);
}
return myOperations.at(idx - 1);
}
+ModuleBase_ModelWidget* XGUI_OperationMgr::activeWidget() const
+{
+ ModuleBase_ModelWidget* anActiveWidget = 0;
+ ModuleBase_Operation* anOperation = currentOperation();
+ if (anOperation) {
+ ModuleBase_IPropertyPanel* aPanel = anOperation->propertyPanel();
+ if (aPanel)
+ anActiveWidget = aPanel->activeWidget();
+ }
+ return anActiveWidget;
+}
+
bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation)
{
if (hasOperation())
return isStarted;
}
-bool XGUI_OperationMgr::abortAllOperations()
+bool XGUI_OperationMgr::abortAllOperations(const XGUI_MessageKind& theMessageKind)
{
bool aResult = true;
if(!hasOperation())
if (operationsCount() == 1) {
ModuleBase_Operation* aCurrentOperation = currentOperation();
- if (canStopOperation(aCurrentOperation)) {
+ if (canStopOperation(aCurrentOperation, theMessageKind)) {
abortOperation(aCurrentOperation);
}
else
aResult = false;
}
else {
- myActiveMessageBox = createMessageBox(tr("All active operations will be aborted."));
- aResult = myActiveMessageBox->exec() == QMessageBox::Ok;
- myActiveMessageBox = 0;
+ if (theMessageKind == XGUI_AbortOperationMessage) {
+ myActiveMessageBox = createMessageBox(tr("All active operations will be aborted."));
+ aResult = myActiveMessageBox->exec() == QMessageBox::Ok;
+ myActiveMessageBox = 0;
+ }
+ else if (theMessageKind == XGUI_InformationMessage) {
+ QString aMessage = tr("Please validate all your active operations before saving.");
+ myActiveMessageBox = createInformationBox(aMessage);
+ myActiveMessageBox->exec();
+ myActiveMessageBox = 0;
+ aResult = false; // do not perform abort
+ }
while(aResult && hasOperation()) {
abortOperation(currentOperation());
}
while (hasOperation()) {
ModuleBase_Operation* anOperation = currentOperation();
if (XGUI_Tools::workshop(myWorkshop)->errorMgr()->isApplyEnabled()) {
- anOperationProcessed = onCommitOperation();
+ anOperationProcessed = commitOperation();
} else {
abortOperation(anOperation);
anOperationProcessed = true;
onValidateOperation();
}
-bool XGUI_OperationMgr::canStopOperation(ModuleBase_Operation* theOperation)
+bool XGUI_OperationMgr::canStopOperation(ModuleBase_Operation* theOperation,
+ const XGUI_OperationMgr::XGUI_MessageKind& theMessageKind)
{
//in case of nested (sketch) operation no confirmation needed
if (isGrantedOperation(theOperation->id()))
return true;
if (theOperation && theOperation->isModified()) {
- QString aMessage = tr("%1 operation will be aborted.").arg(theOperation->id());
-
- myActiveMessageBox = createMessageBox(aMessage);
- int anAnswer = myActiveMessageBox->exec() == QMessageBox::Ok;
- myActiveMessageBox = 0;
- return anAnswer;
+ QString aTitle = theOperation->getDescription()->description();
+ if (theMessageKind == XGUI_AbortOperationMessage) {
+ QString aMessage = tr("%1 operation will be aborted.").arg(aTitle);
+ myActiveMessageBox = createMessageBox(aMessage);
+ bool aResult = myActiveMessageBox->exec() == QMessageBox::Ok;
+ myActiveMessageBox = 0;
+ return aResult;
+ }
+ else if (theMessageKind == XGUI_InformationMessage) {
+ QString aMessage = tr("Please validate your %1 before saving.").arg(aTitle);
+ myActiveMessageBox = createInformationBox(aMessage);
+ myActiveMessageBox->exec();
+ myActiveMessageBox = 0;
+ return false;
+ }
}
return true;
}
-bool XGUI_OperationMgr::commitOperation()
-{
- //if (hasOperation() && currentOperation()->isValid()) {
- // onCommitOperation();
- // return true;
- //}
- //return false;
- return onCommitOperation();
-}
-
void XGUI_OperationMgr::resumeOperation(ModuleBase_Operation* theOperation)
{
theOperation->resume();
void XGUI_OperationMgr::stopOperation(ModuleBase_Operation* theOperation, bool& isCommitted)
{
- if (XGUI_Tools::workshop(myWorkshop)->errorMgr()->isApplyEnabled() && theOperation->isModified())
+ if (XGUI_Tools::workshop(myWorkshop)->errorMgr()->isApplyEnabled() &&
+ theOperation->isModified()) {
isCommitted = theOperation->commit();
- else {
+ } else {
isCommitted = false;
abortOperation(theOperation);
}
}
}
-bool XGUI_OperationMgr::onCommitOperation()
+bool XGUI_OperationMgr::commitOperation()
{
bool isCommitted = false;
ModuleBase_Operation* anOperation = currentOperation();
}
}
+void XGUI_OperationMgr::onAbortAllOperation()
+{
+ abortAllOperations();
+}
+
void XGUI_OperationMgr::onBeforeOperationStarted()
{
ModuleBase_Operation* aCurrentOperation = dynamic_cast<ModuleBase_Operation*>(sender());
void XGUI_OperationMgr::onOperationAborted()
{
ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
+ XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(myWorkshop);
+ aWorkshop->setStatusBarMessage("");
emit operationAborted(aSenderOperation);
}
bool XGUI_OperationMgr::onKeyReleased(QObject *theObject, QKeyEvent* theEvent)
{
+ bool isAccepted = false;
+
// Let the manager decide what to do with the given key combination.
ModuleBase_Operation* anOperation = currentOperation();
- bool isAccepted = false;
switch (theEvent->key()) {
case Qt::Key_Tab:
case Qt::Key_Backtab:
aContext->HilightNextDetected(aView);
else if ((theEvent->key() == Qt::Key_P))
aContext->HilightPreviousDetected(aView);
+ aViewer->updateHighlight();
+ isAccepted = true;
}
}
}
ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
ModuleBase_ModelWidget* anActiveWgt = aPanel->activeWidget();
if (anActiveWgt)
- isAccepted = anActiveWgt && anActiveWgt->processEscape();
+ {
+ isAccepted = anActiveWgt && anActiveWgt->processAction(ActionEscape);
+ if (isAccepted) {
+ ModuleBase_OperationFeature* aFOperation =
+ dynamic_cast<ModuleBase_OperationFeature*>(currentOperation());
+ if (aFOperation)
+ aFOperation->setNeedToBeAborted(true);
+ }
+ }
+ }
+ if (!isAccepted)
+ {
+ XGUI_ActiveControlSelector* anActiveSelector =
+ XGUI_Tools::workshop(myWorkshop)->activeControlMgr()->activeSelector();
+ if (anActiveSelector && anActiveSelector->getType() == XGUI_FacesPanelSelector::Type())
+ isAccepted = XGUI_Tools::workshop(myWorkshop)->facesPanel()->processAction(ActionEscape);
}
// default Escape button functionality
if (!isAccepted && aOperation) {
if (!aOperation)
return isAccepted;
ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
+ if (!aPanel)
+ return isAccepted;
// the next code is obsolete as we want to process Enter in property panel always
// only property panel enter is processed in order to do not process enter in application dialogs
//bool isPPChild = isChildObject(theObject, aPanel);
}
}
if (!isAborted) {
- isAccepted = anActiveWgt && anActiveWgt->processEnter();
+ isAccepted = anActiveWgt && anActiveWgt->processAction(ActionEnter);
if (!isAccepted) {
isAccepted =
myWorkshop->module()->processEnter(anActiveWgt ? anActiveWgt->attributeID() : "");
if (isPPChildObject) {
anActiveWgt = aPanel->activeWidget();
if (anActiveWgt) {
- isAccepted = anActiveWgt->processDelete();
+ isAccepted = anActiveWgt->processAction(ActionDelete);
}
}
}
}
+ if (!isAccepted)
+ {
+ XGUI_ActiveControlSelector* anActiveSelector =
+ XGUI_Tools::workshop(myWorkshop)->activeControlMgr()->activeSelector();
+ if (anActiveSelector && anActiveSelector->getType() == XGUI_FacesPanelSelector::Type())
+ isAccepted = XGUI_Tools::workshop(myWorkshop)->facesPanel()->processAction(ActionDelete);
+ }
if (!isAccepted) {
// after widget, object browser and viewer should process delete
/// other widgets such as line edit controls should not lead to
aMessageBox->setEscapeButton(QMessageBox::No); // operation manager should process Esc key
return aMessageBox;
-}
\ No newline at end of file
+}
+
+QMessageBox* XGUI_OperationMgr::createInformationBox(const QString& theMessage)
+{
+ QMessageBox * aMessageBox = new QMessageBox(QMessageBox::Question,
+ QObject::tr("Validate operation"), theMessage, QMessageBox::Ok,
+ qApp->activeWindow());
+ aMessageBox->setDefaultButton(QMessageBox::Ok);
+ aMessageBox->setEscapeButton(QMessageBox::No); // operation manager should process Esc key
+
+ return aMessageBox;
+}
