X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FXGUI%2FXGUI_OperationMgr.cpp;h=3e6c412235cbbcaef8a5b84a0576d08f1632c321;hb=220bd2b37119be1c65abf88a88792445cb9d99f8;hp=15f90b947906cb81852dba24da26aa4b28173696;hpb=c6d14d2a20ee81e36d7d8b2245b50c7767bc03ac;p=modules%2Fshaper.git diff --git a/src/XGUI/XGUI_OperationMgr.cpp b/src/XGUI/XGUI_OperationMgr.cpp index 15f90b947..3e6c41223 100644 --- a/src/XGUI/XGUI_OperationMgr.cpp +++ b/src/XGUI/XGUI_OperationMgr.cpp @@ -8,6 +8,7 @@ #include "XGUI_ModuleConnector.h" #include "XGUI_Workshop.h" #include "XGUI_ErrorMgr.h" +#include #include #include @@ -31,16 +32,73 @@ //#define DEBUG_CURRENT_FEATURE +/// Processes "Delete" key event of application. This key is used by several application actions. +/// There is a logical order of the actions processing. So the key can not be set for actions +/// as a shortcut. The class listens the key event and call operation manager processor. +class XGUI_ShortCutListener : public QObject +{ +public: + /// Constructor + /// \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) + { + qApp->installEventFilter(this); + } + ~XGUI_ShortCutListener() {} + + /// Switch on short cut listener + void setActive(const bool theIsActive) { myIsActive = theIsActive; } + + /// Redefinition of virtual function to process Delete key release + virtual bool eventFilter(QObject *theObject, QEvent *theEvent) + { + bool isAccepted = false; + if (myIsActive && theEvent->type() == QEvent::KeyRelease) { + QKeyEvent* aKeyEvent = dynamic_cast(theEvent); + if(aKeyEvent) { + switch (aKeyEvent->key()) { + case Qt::Key_Delete: { + isAccepted = myOperationMgr->onProcessDelete(theObject); + } + } + } + } + if (!isAccepted) + isAccepted = QObject::eventFilter(theObject, theEvent); + return isAccepted; + } + +private: + XGUI_OperationMgr* myOperationMgr; /// processor for key event + bool myIsActive; /// boolean state whether the event filter perform own signal processing +}; + XGUI_OperationMgr::XGUI_OperationMgr(QObject* theParent, ModuleBase_IWorkshop* theWorkshop) : QObject(theParent), myWorkshop(theWorkshop) { + /// we need to install filter to the application in order to react to 'Delete' key button + /// this key can not be a short cut for a corresponded action because we need to set + /// the actions priority + myShortCutListener = new XGUI_ShortCutListener(theParent, this); } XGUI_OperationMgr::~XGUI_OperationMgr() { } +void XGUI_OperationMgr::activate() +{ + myShortCutListener->setActive(true); +} + +void XGUI_OperationMgr::deactivate() +{ + myShortCutListener->setActive(false); +} + ModuleBase_Operation* XGUI_OperationMgr::currentOperation() const { return myOperations.count() > 0 ? myOperations.last() : 0; @@ -108,13 +166,16 @@ ModuleBase_Operation* XGUI_OperationMgr::previousOperation(ModuleBase_Operation* bool XGUI_OperationMgr::eventFilter(QObject *theObject, QEvent *theEvent) { + bool isAccepted = false; if (theEvent->type() == QEvent::KeyRelease) { QKeyEvent* aKeyEvent = dynamic_cast(theEvent); - if(aKeyEvent) { - return onKeyReleased(aKeyEvent); - } + if(aKeyEvent) + isAccepted = onKeyReleased(theObject, aKeyEvent); } - return QObject::eventFilter(theObject, theEvent); + if (!isAccepted) + isAccepted = QObject::eventFilter(theObject, theEvent); + + return isAccepted; } bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation) @@ -497,17 +558,15 @@ void XGUI_OperationMgr::onOperationStopped() } } -bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent) +bool XGUI_OperationMgr::onKeyReleased(QObject *theObject, QKeyEvent* theEvent) { - QObject* aSender = sender(); - // Let the manager decide what to do with the given key combination. ModuleBase_Operation* anOperation = currentOperation(); - bool isAccepted = true; + bool isAccepted = false; switch (theEvent->key()) { case Qt::Key_Return: case Qt::Key_Enter: { - isAccepted = onProcessEnter(); + isAccepted = onProcessEnter(theObject); } break; case Qt::Key_N: @@ -525,7 +584,7 @@ bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent) } } } - + break; break; default: isAccepted = false; @@ -537,28 +596,39 @@ bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent) return isAccepted; } -bool XGUI_OperationMgr::onProcessEnter() +bool XGUI_OperationMgr::onProcessEnter(QObject* theObject) { - bool isAccepted = true; + bool isAccepted = false; ModuleBase_Operation* aOperation = currentOperation(); ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); - ModuleBase_ModelWidget* aActiveWgt = aPanel->activeWidget(); + // only property panel enter is processed in order to do not process enter in application dialogs + bool isPPChild = isChildObject(theObject, aPanel); + if (!isPPChild) + return isAccepted; + + ModuleBase_ModelWidget* anActiveWgt = aPanel->activeWidget(); bool isAborted = false; - if (!aActiveWgt) { + if (!anActiveWgt) { QWidget* aFocusWidget = aPanel->focusWidget(); QToolButton* aCancelBtn = aPanel->findChild(PROP_PANEL_CANCEL); if (aFocusWidget && aCancelBtn && aFocusWidget == aCancelBtn) { abortOperation(aOperation); + isAccepted = true; isAborted = true; } } if (!isAborted) { - if (!aActiveWgt || !aActiveWgt->processEnter()) { - if (!myWorkshop->module()->processEnter(aActiveWgt ? aActiveWgt->attributeID() : "")) { + isAccepted = anActiveWgt && anActiveWgt->processEnter(); + if (!isAccepted) { + isAccepted = myWorkshop->module()->processEnter(anActiveWgt ? anActiveWgt->attributeID() : ""); + if (!isAccepted) { + /// functionality is similar to Apply click ModuleBase_OperationFeature* aFOperation = dynamic_cast(currentOperation()); if (!aFOperation || myWorkshop->module()->getFeatureError(aFOperation->feature()).isEmpty()) { + // key released is emitted to apply the current value to the model if it was modified in PP emit keyEnterReleased(); commitOperation(); + isAccepted = true; } else isAccepted = false; @@ -568,9 +638,62 @@ bool XGUI_OperationMgr::onProcessEnter() return isAccepted; } +bool XGUI_OperationMgr::onProcessDelete(QObject* theObject) +{ + bool isAccepted = false; + ModuleBase_Operation* aOperation = currentOperation(); + ModuleBase_ModelWidget* anActiveWgt = 0; + // firstly the widget should process Delete action + ModuleBase_IPropertyPanel* aPanel; + bool isPPChildObject = false; + if (aOperation) { + aPanel = aOperation->propertyPanel(); + if (aPanel) { + isPPChildObject = isChildObject(theObject, aPanel); + // process delete in active widget only if delete sender is child of property panel + // it is necessary for the case when OB is shown, user perform selection and click Delete + if (isPPChildObject) { + anActiveWgt = aPanel->activeWidget(); + if (anActiveWgt) { + isAccepted = anActiveWgt->processDelete(); + } + } + } + } + if (!isAccepted) { + // after widget, object browser and viewer should process delete + /// other widgets such as line edit controls should not lead to + /// processing delete by workshop + XGUI_ObjectsBrowser* aBrowser = workshop()->objectBrowser(); + QWidget* aViewPort = myWorkshop->viewer()->activeViewPort(); + // property panel child object is processed to process delete performed on Apply button of PP + if (theObject == aBrowser->treeView() || + isChildObject(theObject, aViewPort) || + isPPChildObject) + workshop()->deleteObjects(); + isAccepted = true; + } + + return isAccepted; +} + XGUI_Workshop* XGUI_OperationMgr::workshop() const { XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); return aConnector->workshop(); } +bool XGUI_OperationMgr::isChildObject(const QObject* theObject, const QObject* theParent) +{ + bool isPPChild = false; + if (theParent && theObject) { + QObject* aParent = (QObject*)theObject; + while (aParent ) { + isPPChild = aParent == theParent; + if (isPPChild) + break; + aParent = aParent->parent(); + } + } + return isPPChild; +}