X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_OperationMgr.cpp;h=85892d74b037a2c269a69028b060feadd5e1eaee;hb=f7e22794dc9f7e96ed777cc22c72aebe7eccbe9f;hp=e0692fc0b9bf860cd3ce672ae82adc46e14cc92e;hpb=32d1a4d19ab1a5d7c172e9660130fcf8ecb1e520;p=modules%2Fshaper.git diff --git a/src/XGUI/XGUI_OperationMgr.cpp b/src/XGUI/XGUI_OperationMgr.cpp index e0692fc0b..85892d74b 100644 --- a/src/XGUI/XGUI_OperationMgr.cpp +++ b/src/XGUI/XGUI_OperationMgr.cpp @@ -1,3 +1,5 @@ +// Copyright (C) 2014-20xx CEA/DEN, EDF R&D --> + // File: XGUI_OperationMgr.h // Created: 20 Apr 2014 // Author: Natalia ERMOLAEVA @@ -5,18 +7,21 @@ #include "XGUI_OperationMgr.h" #include "ModuleBase_Operation.h" -#include -#include +#include "ModuleBase_IWorkshop.h" +#include "ModuleBase_IModule.h" + +#include "ModelAPI_CompositeFeature.h" +#include "ModelAPI_Session.h" #include #include #include -XGUI_OperationMgr::XGUI_OperationMgr(QObject* theParent) - : QObject(theParent) +XGUI_OperationMgr::XGUI_OperationMgr(QObject* theParent, + ModuleBase_IWorkshop* theWorkshop) +: QObject(theParent), myIsValidationLock(false), myIsApplyEnabled(false), + myWorkshop(theWorkshop) { - // listen to Escape signal to stop the current operation - qApp->installEventFilter(this); } XGUI_OperationMgr::~XGUI_OperationMgr() @@ -28,11 +33,37 @@ ModuleBase_Operation* XGUI_OperationMgr::currentOperation() const return myOperations.count() > 0 ? myOperations.last() : 0; } +bool XGUI_OperationMgr::isCurrentOperation(ModuleBase_Operation* theOperation) +{ + if(!hasOperation()) + return false; + return currentOperation() == theOperation; +} + bool XGUI_OperationMgr::hasOperation() const { - return (myOperations.count() > 0) && (myOperations.last() != NULL); + return !myOperations.isEmpty() && (myOperations.last() != NULL); } +bool XGUI_OperationMgr::hasOperation(const QString& theId) const +{ + foreach(ModuleBase_Operation* aOp, myOperations) { + if (aOp->id() == theId) + return true; + } + return false; +} + +ModuleBase_Operation* XGUI_OperationMgr::findOperation(const QString& theId) const +{ + foreach(ModuleBase_Operation* aOp, myOperations) { + if (aOp->id() == theId) + return aOp; + } + return 0; +} + + int XGUI_OperationMgr::operationsCount() const { return myOperations.count(); @@ -64,8 +95,7 @@ bool XGUI_OperationMgr::eventFilter(QObject *theObject, QEvent *theEvent) if (theEvent->type() == QEvent::KeyRelease) { QKeyEvent* aKeyEvent = dynamic_cast(theEvent); if(aKeyEvent) { - onKeyReleased(aKeyEvent); - return true; + return onKeyReleased(aKeyEvent); } } return QObject::eventFilter(theObject, theEvent); @@ -73,16 +103,18 @@ bool XGUI_OperationMgr::eventFilter(QObject *theObject, QEvent *theEvent) bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation) { - if (!canStartOperation(theOperation)) - return false; - + if (hasOperation()) + currentOperation()->postpone(); myOperations.append(theOperation); - connect(theOperation, SIGNAL(stopped()), this, SLOT(onOperationStopped())); - connect(theOperation, SIGNAL(started()), this, SIGNAL(operationStarted())); - connect(theOperation, SIGNAL(resumed()), this, SIGNAL(operationResumed())); - connect(theOperation, SIGNAL(activateNextWidget(ModuleBase_ModelWidget*)), this, - SIGNAL(activateNextWidget(ModuleBase_ModelWidget*))); + connect(theOperation, SIGNAL(started()), SLOT(onOperationStarted())); + connect(theOperation, SIGNAL(aborted()), SLOT(onOperationAborted())); + connect(theOperation, SIGNAL(committed()), SLOT(onOperationCommitted())); + connect(theOperation, SIGNAL(stopped()), SLOT(onOperationStopped())); + connect(theOperation, SIGNAL(resumed()), SLOT(onOperationResumed())); + connect(theOperation, SIGNAL(triggered(bool)), SLOT(onOperationTriggered(bool))); + connect(theOperation, SIGNAL(activatedByPreselection()), + SIGNAL(operationActivatedByPreselection())); theOperation->start(); onValidateOperation(); @@ -110,17 +142,24 @@ bool XGUI_OperationMgr::abortAllOperations() return result; } -bool XGUI_OperationMgr::validateOperation(ModuleBase_Operation* theOperation) +bool XGUI_OperationMgr::commitAllOperations() { - //Get operation feature to validate - FeaturePtr aFeature = theOperation->feature(); - //Get validators for the Id - SessionPtr aMgr = ModelAPI_Session::get(); - ModelAPI_ValidatorsFactory* aFactory = aMgr->validators(); - - bool isValid = aFactory->validate(aFeature); - emit operationValidated(isValid); - return isValid; + bool isCompositeCommitted = false; + while (hasOperation()) { + ModuleBase_Operation* anOperation = currentOperation(); + if (isApplyEnabled()) { + onCommitOperation(); + } else { + anOperation->abort(); + } + FeaturePtr aFeature = anOperation->feature(); + CompositeFeaturePtr aComposite = + std::dynamic_pointer_cast(aFeature); + isCompositeCommitted = aComposite.get(); + if (isCompositeCommitted) + break; + } + return true; } void XGUI_OperationMgr::onValidateOperation() @@ -128,12 +167,67 @@ void XGUI_OperationMgr::onValidateOperation() if (!hasOperation()) return; ModuleBase_Operation* anOperation = currentOperation(); - validateOperation(currentOperation()); + if(anOperation) { + bool aCanCommit = myWorkshop->module()->canCommitOperation(); + setApplyEnabled(!myIsValidationLock && aCanCommit && anOperation->isValid()); + } +} + +void XGUI_OperationMgr::setLockValidating(bool toLock) +{ + myIsValidationLock = toLock; + onValidateOperation(); +} + +void XGUI_OperationMgr::setApplyEnabled(const bool theEnabled) +{ + myIsApplyEnabled = theEnabled; + emit validationStateChanged(theEnabled); +} + +bool XGUI_OperationMgr::isApplyEnabled() const +{ + return myIsApplyEnabled; +} + +bool XGUI_OperationMgr::isParentOperationValid() const +{ + bool isValid = false; + // the enable state of the parent operation of the nested one is defined by the rules that + // firstly there are nested operations and secondly the parent operation is valid + ModuleBase_Operation* aPrevOp = 0; + Operations::const_iterator anIt = myOperations.end(); + if (anIt != myOperations.begin()) { // there are items in the operations list + --anIt; + aPrevOp = *anIt; // the last top operation, the operation which is started + if (anIt != myOperations.begin()) { // find the operation where the started operation is nested + --anIt; + aPrevOp = *anIt; + } + } + return aPrevOp && aPrevOp->isValid(); +} + +bool XGUI_OperationMgr::canStopOperation() +{ + ModuleBase_Operation* anOperation = currentOperation(); + if(operationsCount() > 1) //in case of nested (sketch) operation no confirmation needed + return true; + if (anOperation && anOperation->isModified()) { + QString aMessage = tr("%1 operation will be aborted.").arg(anOperation->id()); + int anAnswer = QMessageBox::question(qApp->activeWindow(), + tr("Abort operation"), + aMessage, + QMessageBox::Ok | QMessageBox::Cancel, + QMessageBox::Cancel); + return anAnswer == QMessageBox::Ok; + } + return true; } bool XGUI_OperationMgr::commitOperation() { - if (validateOperation(currentOperation())) { + if (hasOperation() && currentOperation()->isValid()) { onCommitOperation(); return true; } @@ -145,18 +239,19 @@ void XGUI_OperationMgr::resumeOperation(ModuleBase_Operation* theOperation) theOperation->resume(); } -bool XGUI_OperationMgr::canStartOperation(ModuleBase_Operation* theOperation) +bool XGUI_OperationMgr::canStartOperation(QString theId) { bool aCanStart = true; ModuleBase_Operation* aCurrentOp = currentOperation(); if (aCurrentOp) { - if (!theOperation->isGranted()) { - if (!aCurrentOp->isValid(theOperation)) { - if (canAbortOperation()) { + if (!aCurrentOp->isGranted(theId)) { + if (canStopOperation()) { + if (myIsApplyEnabled) + aCurrentOp->commit(); + else aCurrentOp->abort(); - } else { - aCanStart = false; - } + } else { + aCanStart = false; } } } @@ -173,39 +268,57 @@ void XGUI_OperationMgr::onCommitOperation() void XGUI_OperationMgr::onAbortOperation() { - if (hasOperation() && canAbortOperation()) { + if (hasOperation() && canStopOperation()) { currentOperation()->abort(); } } -bool XGUI_OperationMgr::canAbortOperation() +void XGUI_OperationMgr::onOperationStarted() { - ModuleBase_Operation* anOperation = currentOperation(); - if(operationsCount() > 1) //in case of nested (sketch) operation no confirmation needed - return true; - if (anOperation && anOperation->isModified()) { - QString aMessage = tr("%1 operation will be aborted.").arg(anOperation->id()); - int anAnswer = QMessageBox::question(qApp->activeWindow(), - tr("Abort operation"), - aMessage, - QMessageBox::Ok | QMessageBox::Cancel, - QMessageBox::Cancel); - return anAnswer == QMessageBox::Ok; - } - return true; + ModuleBase_Operation* aSenderOperation = dynamic_cast(sender()); + + bool aParentValid = isParentOperationValid(); + // in order to apply is enabled only if there are modifications in the model + // e.g. sketch can be applyed only if at least one nested element modification is finished + bool aCanUndo = ModelAPI_Session::get()->canUndo(); + emit nestedStateChanged(aParentValid && aCanUndo); + + emit operationStarted(aSenderOperation); +} + +void XGUI_OperationMgr::onOperationAborted() +{ + ModuleBase_Operation* aSenderOperation = dynamic_cast(sender()); + emit operationAborted(aSenderOperation); +} + +void XGUI_OperationMgr::onOperationCommitted() +{ + ModuleBase_Operation* aSenderOperation = dynamic_cast(sender()); + // in order to apply is enabled only if there are modifications in the model + // e.g. sketch can be applyed only if at least one nested element create is finished + bool aCanUndo = ModelAPI_Session::get()->canUndo(); + emit nestedStateChanged(myOperations.count() >= 1 && aCanUndo); + emit operationCommitted(aSenderOperation); +} + +void XGUI_OperationMgr::onOperationResumed() +{ + ModuleBase_Operation* aSenderOperation = dynamic_cast(sender()); + emit operationResumed(aSenderOperation); } void XGUI_OperationMgr::onOperationStopped() { ModuleBase_Operation* aSenderOperation = dynamic_cast(sender()); - ModuleBase_Operation* anOperation = currentOperation(); - if (!aSenderOperation || !anOperation || aSenderOperation != anOperation) + ModuleBase_Operation* aCurrentOperation = currentOperation(); + if (!aSenderOperation || !aCurrentOperation || aSenderOperation != aCurrentOperation) return; - myOperations.removeAll(anOperation); - anOperation->deleteLater(); + myOperations.removeAll(aCurrentOperation); + aCurrentOperation->deleteLater(); - emit operationStopped(anOperation); + emit operationStopped(aCurrentOperation); // get last operation which can be resumed ModuleBase_Operation* aResultOp = 0; @@ -219,39 +332,52 @@ void XGUI_OperationMgr::onOperationStopped() } } if (aResultOp) { + bool isModified = aCurrentOperation->isModified(); + aResultOp->setIsModified(isModified); resumeOperation(aResultOp); onValidateOperation(); } } -void XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent) +void XGUI_OperationMgr::onOperationTriggered(bool theState) +{ + ModuleBase_Operation* aSenderOperation = dynamic_cast(sender()); + if (aSenderOperation && !theState) { + ModuleBase_Operation* aCurrentOperation = currentOperation(); + if (aSenderOperation == aCurrentOperation) + aCurrentOperation->abort(); + else { + // it is possible to trigger upper operation(e.g. sketch, current is sketch line) + // all operation from the current to triggered should also be aborted + while(hasOperation()) { + ModuleBase_Operation* aCurrentOperation = currentOperation(); + aCurrentOperation->abort(); + if(aSenderOperation == aCurrentOperation) + break; + } + } + } +} + +bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent) { // Let the manager decide what to do with the given key combination. ModuleBase_Operation* anOperation = currentOperation(); - bool isRestart = false; + bool isAccepted = true; switch (theEvent->key()) { - case Qt::Key_Escape: { - onAbortOperation(); - } - break; case Qt::Key_Return: case Qt::Key_Enter: { - if(anOperation) { - anOperation->activateNextToCurrentWidget(); - } + emit keyEnterReleased(); commitOperation(); } - break; + break; default: + isAccepted = false; break; } - if(anOperation) - anOperation->keyReleased(theEvent->key()); + //if(anOperation) { + // anOperation->keyReleased(theEvent->key()); + //} + return isAccepted; } -void XGUI_OperationMgr::onWidgetActivated(ModuleBase_ModelWidget* theWidget) -{ - ModuleBase_Operation* anOperation = currentOperation(); - if (anOperation) - anOperation->onWidgetActivated(theWidget); -}