src/XGUI/XGUI_OperationMgr.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:        XGUI_OperationMgr.h
   4 // Created:     20 Apr 2014
   5 // Author:      Natalia ERMOLAEVA
   6
   7 #include "XGUI_OperationMgr.h"
   8
   9 #include "ModuleBase_Operation.h"
  10
  11 #include <QMessageBox>
  12 #include <QApplication>
  13 #include <QKeyEvent>
  14
  15 XGUI_OperationMgr::XGUI_OperationMgr(QObject* theParent)
  16     : QObject(theParent), myIsValidationLock(false)
  17 {
  18 }
  19
  20 XGUI_OperationMgr::~XGUI_OperationMgr()
  21 {
  22 }
  23
  24 ModuleBase_Operation* XGUI_OperationMgr::currentOperation() const
  25 {
  26   return myOperations.count() > 0 ? myOperations.last() : 0;
  27 }
  28
  29 bool XGUI_OperationMgr::isCurrentOperation(ModuleBase_Operation* theOperation)
  30 {
  31   if(!hasOperation())
  32     return false;
  33   return currentOperation() == theOperation;
  34 }
  35
  36 bool XGUI_OperationMgr::hasOperation() const
  37 {
  38   return !myOperations.isEmpty() && (myOperations.last() != NULL);
  39 }
  40
  41 bool XGUI_OperationMgr::hasOperation(const QString& theId) const
  42 {
  43   foreach(ModuleBase_Operation* aOp, myOperations) {
  44     if (aOp->id() == theId)
  45       return true;
  46   }
  47   return false;
  48 }
  49
  50 ModuleBase_Operation* XGUI_OperationMgr::findOperation(const QString& theId) const
  51 {
  52   foreach(ModuleBase_Operation* aOp, myOperations) {
  53     if (aOp->id() == theId)
  54       return aOp;
  55   }
  56   return 0;
  57 }
  58
  59
  60 int XGUI_OperationMgr::operationsCount() const
  61 {
  62   return myOperations.count();
  63 }
  64
  65 QStringList XGUI_OperationMgr::operationList() const
  66 {
  67   QStringList result;
  68   foreach(ModuleBase_Operation* eachOperation, myOperations) {
  69     FeaturePtr aFeature = eachOperation->feature();
  70     if(aFeature) {
  71       result << QString::fromStdString(aFeature->getKind());
  72     }
  73   }
  74   return result;
  75 }
  76
  77 ModuleBase_Operation* XGUI_OperationMgr::previousOperation(ModuleBase_Operation* theOperation) const
  78 {
  79   int idx = myOperations.lastIndexOf(theOperation);
  80   if(idx == -1 || idx == 0) {
  81     return NULL;
  82   }
  83   return myOperations.at(idx - 1);
  84 }
  85
  86 bool XGUI_OperationMgr::eventFilter(QObject *theObject, QEvent *theEvent)
  87 {
  88   if (theEvent->type() == QEvent::KeyRelease) {
  89     QKeyEvent* aKeyEvent = dynamic_cast<QKeyEvent*>(theEvent);
  90     if(aKeyEvent) {
  91       return onKeyReleased(aKeyEvent);
  92     }
  93   }
  94   return QObject::eventFilter(theObject, theEvent);
  95 }
  96
  97 bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation)
  98 {
  99   if (hasOperation())
 100     currentOperation()->postpone();
 101   myOperations.append(theOperation);
 102
 103   connect(theOperation, SIGNAL(started()), SLOT(onOperationStarted()));
 104   connect(theOperation, SIGNAL(aborted()), SLOT(onOperationAborted()));
 105   connect(theOperation, SIGNAL(committed()), SLOT(onOperationCommitted()));
 106   connect(theOperation, SIGNAL(stopped()), SLOT(onOperationStopped()));
 107   connect(theOperation, SIGNAL(resumed()), SLOT(onOperationResumed()));
 108   connect(theOperation, SIGNAL(activatedByPreselection()),
 109           SIGNAL(operationActivatedByPreselection()));
 110
 111   theOperation->start();
 112   onValidateOperation();
 113   return true;
 114 }
 115
 116 bool XGUI_OperationMgr::abortAllOperations()
 117 {
 118   if(!hasOperation()) {
 119     return true;
 120   } else if (operationsCount() == 1) {
 121     onAbortOperation();
 122     return true;
 123   }
 124   QString aMessage = tr("All active operations will be aborted.");
 125   int anAnswer = QMessageBox::question(qApp->activeWindow(),
 126                                        tr("Abort operation"),
 127                                        aMessage,
 128                                        QMessageBox::Ok | QMessageBox::Cancel,
 129                                        QMessageBox::Cancel);
 130   bool result = anAnswer == QMessageBox::Ok;
 131   while(result && hasOperation()) {
 132     currentOperation()->abort();
 133   }
 134   return result;
 135 }
 136
 137 void XGUI_OperationMgr::onValidateOperation()
 138 {
 139   if (!hasOperation())
 140     return;
 141   ModuleBase_Operation* anOperation = currentOperation();
 142   if(anOperation && (!myIsValidationLock)) {
 143     bool isValid = anOperation->isValid();
 144     emit operationValidated(isValid);
 145   }
 146 }
 147
 148 bool XGUI_OperationMgr::commitOperation()
 149 {
 150   if (hasOperation() && currentOperation()->isValid()) {
 151     onCommitOperation();
 152     return true;
 153   }
 154   return false;
 155 }
 156
 157 void XGUI_OperationMgr::resumeOperation(ModuleBase_Operation* theOperation)
 158 {
 159   theOperation->resume();
 160 }
 161
 162 bool XGUI_OperationMgr::canStartOperation(QString theId)
 163 {
 164   bool aCanStart = true;
 165   ModuleBase_Operation* aCurrentOp = currentOperation();
 166   if (aCurrentOp) {
 167     if (!aCurrentOp->isGranted(theId)) {
 168       if (canAbortOperation()) {
 169         aCurrentOp->abort();
 170       } else {
 171         aCanStart = false;
 172       }
 173     }
 174   }
 175   return aCanStart;
 176 }
 177
 178
 179 void XGUI_OperationMgr::onCommitOperation()
 180 {
 181   ModuleBase_Operation* anOperation = currentOperation();
 182   if (anOperation)
 183     anOperation->commit();
 184 }
 185
 186 void XGUI_OperationMgr::onAbortOperation()
 187 {
 188   if (hasOperation() && canAbortOperation()) {
 189     currentOperation()->abort();
 190   }
 191 }
 192
 193 bool XGUI_OperationMgr::canAbortOperation()
 194 {
 195   ModuleBase_Operation* anOperation = currentOperation();
 196   if(operationsCount() > 1) //in case of nested (sketch) operation no confirmation needed
 197     return true;
 198   if (anOperation && anOperation->isModified()) {
 199     QString aMessage = tr("%1 operation will be aborted.").arg(anOperation->id());
 200     int anAnswer = QMessageBox::question(qApp->activeWindow(),
 201                                          tr("Abort operation"),
 202                                          aMessage,
 203                                          QMessageBox::Ok | QMessageBox::Cancel,
 204                                          QMessageBox::Cancel);
 205     return anAnswer == QMessageBox::Ok;
 206   }
 207   return true;
 208 }
 209
 210 void XGUI_OperationMgr::onOperationStarted()
 211 {
 212   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 213   emit operationStarted(aSenderOperation);
 214 }
 215
 216 void XGUI_OperationMgr::onOperationAborted()
 217 {
 218   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 219   emit operationAborted(aSenderOperation);
 220 }
 221
 222 void XGUI_OperationMgr::onOperationCommitted()
 223 {
 224   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 225   emit operationCommitted(aSenderOperation);
 226 }
 227
 228 void XGUI_OperationMgr::onOperationResumed()
 229 {
 230   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 231   emit operationResumed(aSenderOperation);
 232 }
 233
 234 void XGUI_OperationMgr::onOperationStopped()
 235 {
 236   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 237   ModuleBase_Operation* anOperation = currentOperation();
 238   if (!aSenderOperation || !anOperation || aSenderOperation != anOperation)
 239     return;
 240
 241   myOperations.removeAll(anOperation);
 242   anOperation->deleteLater();
 243
 244   emit operationStopped(anOperation);
 245
 246   // get last operation which can be resumed
 247   ModuleBase_Operation* aResultOp = 0;
 248   QListIterator<ModuleBase_Operation*> anIt(myOperations);
 249   anIt.toBack();
 250   while (anIt.hasPrevious()) {
 251     ModuleBase_Operation* anOp = anIt.previous();
 252     if (anOp) {
 253       aResultOp = anOp;
 254       break;
 255     }
 256   }
 257   if (aResultOp) {
 258     resumeOperation(aResultOp);
 259     onValidateOperation();
 260   }
 261 }
 262
 263 bool XGUI_OperationMgr::onKeyReleased(QKeyEvent* theEvent)
 264 {
 265   // Let the manager decide what to do with the given key combination.
 266   ModuleBase_Operation* anOperation = currentOperation();
 267   bool isAccepted = true;
 268   switch (theEvent->key()) {
 269     case Qt::Key_Return:
 270     case Qt::Key_Enter: {
 271       emit keyEnterReleased();
 272       commitOperation();
 273     }
 274       break;
 275     default:
 276       isAccepted = false;
 277       break;
 278   }
 279   //if(anOperation) {
 280   //  anOperation->keyReleased(theEvent->key());
 281   //}
 282   return isAccepted;
 283 }
 284