src/XGUI/XGUI_OperationMgr.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:        XGUI_OperationMgr.cpp
   4 // Created:     20 Apr 2014
   5 // Author:      Natalia ERMOLAEVA
   6
   7 #include "XGUI_OperationMgr.h"
   8 #include "XGUI_ModuleConnector.h"
   9 #include "XGUI_Workshop.h"
  10 #include "XGUI_ErrorMgr.h"
  11 #include "XGUI_Tools.h"
  12 #include "XGUI_ObjectsBrowser.h"
  13 #include "XGUI_ContextMenuMgr.h"
  14
  15 #include <ModuleBase_IPropertyPanel.h>
  16 #include <ModuleBase_ModelWidget.h>
  17 #include "ModuleBase_Operation.h"
  18 #include "ModuleBase_IWorkshop.h"
  19 #include "ModuleBase_IModule.h"
  20 #include <ModuleBase_IViewer.h>
  21 #include "ModuleBase_OperationDescription.h"
  22 #include "ModuleBase_OperationFeature.h"
  23 #include "ModuleBase_Tools.h"
  24
  25 #include "ModelAPI_CompositeFeature.h"
  26 #include "ModelAPI_Session.h"
  27
  28 #include <XGUI_PropertyPanel.h>
  29 #include <QToolButton>
  30 #include <QLineEdit>
  31
  32 #include <QMessageBox>
  33 #include <QApplication>
  34 #include <QKeyEvent>
  35
  36 //#define DEBUG_CURRENT_FEATURE
  37
  38 /// Processes "Delete" key event of application. This key is used by several application actions.
  39 /// There is a logical order of the actions processing. So the key can not be set for actions
  40 /// as a shortcut. The class listens the key event and call operation manager processor.
  41 class XGUI_ShortCutListener : public QObject
  42 {
  43 public:
  44   /// Constructor
  45   /// \param theParent the parent to be deleted when the parent is deleted
  46   /// \param theOperationMgr the class to perform deletion
  47   XGUI_ShortCutListener(QObject* theParent, XGUI_OperationMgr* theOperationMgr)
  48     : QObject(theParent), myOperationMgr(theOperationMgr)
  49   {
  50     qApp->installEventFilter(this);
  51   }
  52   ~XGUI_ShortCutListener() {}
  53
  54   /// Switch on short cut listener
  55   void setActive(const bool theIsActive) { myIsActive = theIsActive; }
  56
  57   /// Redefinition of virtual function to process Delete key release
  58   virtual bool eventFilter(QObject *theObject, QEvent *theEvent)
  59   {
  60     bool isAccepted = false;
  61     if (myIsActive && theEvent->type() == QEvent::KeyRelease) {
  62       QKeyEvent* aKeyEvent = dynamic_cast<QKeyEvent*>(theEvent);
  63       if(aKeyEvent) {
  64         switch (aKeyEvent->key()) {
  65           case Qt::Key_Delete: {
  66             isAccepted = myOperationMgr->onProcessDelete(theObject);
  67           }
  68         }
  69       }
  70     }
  71     if (!isAccepted)
  72       isAccepted = QObject::eventFilter(theObject, theEvent);
  73     return isAccepted;
  74   }
  75
  76 private:
  77   XGUI_OperationMgr* myOperationMgr; /// processor for key event
  78   bool myIsActive; /// boolean state whether the event filter perform own signal processing
  79 };
  80
  81 XGUI_OperationMgr::XGUI_OperationMgr(QObject* theParent,
  82                                      ModuleBase_IWorkshop* theWorkshop)
  83 : QObject(theParent), myWorkshop(theWorkshop)
  84 {
  85   /// we need to install filter to the application in order to react to 'Delete' key button
  86   /// this key can not be a short cut for a corresponded action because we need to set
  87   /// the actions priority
  88   myShortCutListener = new XGUI_ShortCutListener(theParent, this);
  89 }
  90
  91 XGUI_OperationMgr::~XGUI_OperationMgr()
  92 {
  93 }
  94
  95 void XGUI_OperationMgr::activate()
  96 {
  97   myShortCutListener->setActive(true);
  98 }
  99
 100 void XGUI_OperationMgr::deactivate()
 101 {
 102   myShortCutListener->setActive(false);
 103 }
 104
 105 ModuleBase_Operation* XGUI_OperationMgr::currentOperation() const
 106 {
 107   return myOperations.count() > 0 ? myOperations.last() : 0;
 108 }
 109
 110 bool XGUI_OperationMgr::isCurrentOperation(ModuleBase_Operation* theOperation)
 111 {
 112   if(!hasOperation())
 113     return false;
 114   return currentOperation() == theOperation;
 115 }
 116
 117 bool XGUI_OperationMgr::hasOperation() const
 118 {
 119   return !myOperations.isEmpty() && (myOperations.last() != NULL);
 120 }
 121
 122 bool XGUI_OperationMgr::hasOperation(const QString& theId) const
 123 {
 124   foreach(ModuleBase_Operation* aOp, myOperations) {
 125     if (aOp->id() == theId)
 126       return true;
 127   }
 128   return false;
 129 }
 130
 131 ModuleBase_Operation* XGUI_OperationMgr::findOperation(const QString& theId) const
 132 {
 133   QList<ModuleBase_Operation*>::const_iterator anIt = myOperations.end();
 134   while (anIt != myOperations.begin()) {
 135     --anIt;
 136     ModuleBase_Operation* anOperation = *anIt;
 137     if (anOperation->id() == theId)
 138       return anOperation;
 139   }
 140   return 0;
 141 }
 142
 143
 144 int XGUI_OperationMgr::operationsCount() const
 145 {
 146   return myOperations.count();
 147 }
 148
 149 QStringList XGUI_OperationMgr::operationList() const
 150 {
 151   QStringList result;
 152   foreach(ModuleBase_Operation* eachOperation, myOperations) {
 153     ModuleBase_OperationFeature* aFOperation =
 154       dynamic_cast<ModuleBase_OperationFeature*>(eachOperation);
 155     if (aFOperation) {
 156       FeaturePtr aFeature = aFOperation->feature();
 157       if(aFeature) {
 158         result << QString::fromStdString(aFeature->getKind());
 159       }
 160     }
 161   }
 162   return result;
 163 }
 164
 165 ModuleBase_Operation* XGUI_OperationMgr::previousOperation(ModuleBase_Operation* theOperation) const
 166 {
 167   int idx = myOperations.lastIndexOf(theOperation);
 168   if(idx == -1 || idx == 0) {
 169     return NULL;
 170   }
 171   return myOperations.at(idx - 1);
 172 }
 173
 174 bool XGUI_OperationMgr::eventFilter(QObject *theObject, QEvent *theEvent)
 175 {
 176   bool isAccepted = false;
 177   if (theEvent->type() == QEvent::KeyRelease) {
 178     QKeyEvent* aKeyEvent = dynamic_cast<QKeyEvent*>(theEvent);
 179     if(aKeyEvent)
 180       isAccepted = onKeyReleased(theObject, aKeyEvent);
 181   }
 182   if (!isAccepted)
 183     isAccepted = QObject::eventFilter(theObject, theEvent);
 184
 185   return isAccepted;
 186 }
 187
 188 bool XGUI_OperationMgr::startOperation(ModuleBase_Operation* theOperation)
 189 {
 190   if (hasOperation())
 191     currentOperation()->postpone();
 192   myOperations.append(theOperation);
 193
 194   connect(theOperation, SIGNAL(beforeStarted()), SLOT(onBeforeOperationStarted()));
 195   connect(theOperation, SIGNAL(beforeAborted()), SLOT(onBeforeOperationAborted()));
 196   connect(theOperation, SIGNAL(beforeCommitted()), SLOT(onBeforeOperationCommitted()));
 197
 198   connect(theOperation, SIGNAL(started()), SLOT(onOperationStarted()));
 199   connect(theOperation, SIGNAL(aborted()), SLOT(onOperationAborted()));
 200   connect(theOperation, SIGNAL(committed()), SLOT(onOperationCommitted()));
 201
 202   connect(theOperation, SIGNAL(stopped()), SLOT(onOperationStopped()));
 203   connect(theOperation, SIGNAL(resumed()), SLOT(onOperationResumed()));
 204
 205   bool isStarted = theOperation->start();
 206   if (isStarted)
 207     onValidateOperation();
 208   return isStarted;
 209 }
 210
 211 bool XGUI_OperationMgr::abortAllOperations()
 212 {
 213   bool aResult = true;
 214   if(!hasOperation())
 215     return aResult;
 216
 217   if (operationsCount() == 1) {
 218     ModuleBase_Operation* aCurrentOperation = currentOperation();
 219     if (canStopOperation(aCurrentOperation)) {
 220       abortOperation(aCurrentOperation);
 221     }
 222     else
 223       aResult = false;
 224   }
 225   else {
 226     aResult = QMessageBox::question(qApp->activeWindow(),
 227                                     tr("Abort operation"),
 228                                     tr("All active operations will be aborted."),
 229                                     QMessageBox::Ok | QMessageBox::Cancel,
 230                                     QMessageBox::Cancel) == QMessageBox::Ok;
 231     while(aResult && hasOperation()) {
 232       abortOperation(currentOperation());
 233     }
 234   }
 235   return aResult;
 236 }
 237
 238 bool XGUI_OperationMgr::commitAllOperations()
 239 {
 240   bool isCompositeCommitted = false, anOperationProcessed = false;
 241   while (hasOperation()) {
 242     ModuleBase_Operation* anOperation = currentOperation();
 243     if (XGUI_Tools::workshop(myWorkshop)->errorMgr()->isApplyEnabled()) {
 244       anOperationProcessed = onCommitOperation();
 245     } else {
 246       abortOperation(anOperation);
 247       anOperationProcessed = true;
 248     }
 249     ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
 250                                                                             (anOperation);
 251     if (aFOperation) {
 252       FeaturePtr aFeature = aFOperation->feature();
 253       CompositeFeaturePtr aComposite =
 254           std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aFeature);
 255       isCompositeCommitted = aComposite.get();
 256       if (isCompositeCommitted)
 257         break;
 258     }
 259     // not processed[committed] operation might be used in composite feature,
 260     // so the while will be stopped by the previous check.
 261     // this code is not necessary, but logically should be done when the processing will not
 262     // be done for not composite feature by some reasons
 263     if (!anOperationProcessed)
 264       break;
 265   }
 266   return true;
 267 }
 268
 269 void XGUI_OperationMgr::onValidateOperation()
 270 {
 271   if (!hasOperation())
 272     return;
 273   ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
 274                                                                           (currentOperation());
 275   if(aFOperation && aFOperation->feature().get())
 276     XGUI_Tools::workshop(myWorkshop)->errorMgr()->updateActions(aFOperation->feature());
 277 }
 278
 279 void XGUI_OperationMgr::updateApplyOfOperations(ModuleBase_Operation* theOperation)
 280 {
 281   XGUI_ErrorMgr* anErrorMgr = XGUI_Tools::workshop(myWorkshop)->errorMgr();
 282   if (theOperation) {
 283     ModuleBase_OperationFeature* aFOperation =
 284       dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
 285     if (aFOperation)
 286       anErrorMgr->updateAcceptAllAction(aFOperation->feature());
 287   }
 288   else {
 289     foreach(ModuleBase_Operation* anOperation, myOperations) {
 290       if (anOperation)
 291         updateApplyOfOperations(anOperation);
 292     }
 293   }
 294   // Apply button of the current operation should also be updated
 295   onValidateOperation();
 296 }
 297
 298 bool XGUI_OperationMgr::canStopOperation(ModuleBase_Operation* theOperation)
 299 {
 300   //in case of nested (sketch) operation no confirmation needed
 301   if (isGrantedOperation(theOperation->id()))
 302     return true;
 303   if (theOperation && theOperation->isModified()) {
 304     QString aMessage = tr("%1 operation will be aborted.").arg(theOperation->id());
 305     int anAnswer = QMessageBox::question(qApp->activeWindow(),
 306                                          tr("Abort operation"),
 307                                          aMessage,
 308                                          QMessageBox::Ok | QMessageBox::Cancel,
 309                                          QMessageBox::Cancel);
 310     return anAnswer == QMessageBox::Ok;
 311   }
 312   return true;
 313 }
 314
 315 bool XGUI_OperationMgr::commitOperation()
 316 {
 317   //if (hasOperation() && currentOperation()->isValid()) {
 318   //  onCommitOperation();
 319   //  return true;
 320   //}
 321   //return false;
 322   return onCommitOperation();
 323 }
 324
 325 void XGUI_OperationMgr::resumeOperation(ModuleBase_Operation* theOperation)
 326 {
 327   theOperation->resume();
 328 }
 329
 330 bool XGUI_OperationMgr::isGrantedOperation(const QString& theId)
 331 {
 332   bool isGranted = false;
 333
 334   QListIterator<ModuleBase_Operation*> anIt(myOperations);
 335   anIt.toBack();
 336   ModuleBase_Operation* aPreviousOperation = 0;
 337   while (anIt.hasPrevious() && !isGranted) {
 338     ModuleBase_Operation* anOp = anIt.previous();
 339     if (anOp)
 340       isGranted = anOp->isGranted(theId);
 341   }
 342   return isGranted;
 343 }
 344
 345 void XGUI_OperationMgr::setCurrentFeature(const FeaturePtr& theFeature)
 346 {
 347   SessionPtr aMgr = ModelAPI_Session::get();
 348   DocumentPtr aDoc = aMgr->activeDocument();
 349   bool aIsOp = aMgr->isOperation();
 350   if (!aIsOp)
 351     aMgr->startOperation(QString("Set current feature: %1")
 352     .arg(theFeature->getKind().c_str()).toStdString());
 353   aDoc->setCurrentFeature(theFeature, false);
 354   if (!aIsOp)
 355     aMgr->finishOperation();
 356 }
 357
 358 bool XGUI_OperationMgr::canStartOperation(const QString& theId, bool& isCommitted)
 359 {
 360   bool aCanStart = true;
 361   isCommitted = false;
 362   ModuleBase_Operation* aCurrentOp = currentOperation();
 363   if (aCurrentOp) {
 364     bool aGranted = aCurrentOp->isGranted(theId);
 365     // the started operation is granted for the current one,
 366     // e.g. current - Sketch, started - Line
 367     if (aGranted) {
 368       aCanStart = true;
 369     }
 370     else {
 371       if (!isGrantedOperation(theId)) {
 372         // the operation is not granted in the current list of operations
 373         // e.g. Edit Parameter when Sketch, Line in Sketch is active.
 374         aCanStart = abortAllOperations();
 375       }
 376       else if (canStopOperation(aCurrentOp)) {
 377         // the started operation is granted in the parrent operation,
 378         // e.g. current - Line in Sketch, started Circle
 379         stopOperation(aCurrentOp, isCommitted);
 380       } else {
 381         aCanStart = false;
 382       }
 383     }
 384   }
 385   return aCanStart;
 386 }
 387
 388 void XGUI_OperationMgr::stopOperation(ModuleBase_Operation* theOperation, bool& isCommitted)
 389 {
 390   if (XGUI_Tools::workshop(myWorkshop)->errorMgr()->isApplyEnabled() && theOperation->isModified())
 391     isCommitted = theOperation->commit();
 392   else {
 393     isCommitted = false;
 394     abortOperation(theOperation);
 395   }
 396 }
 397
 398 void XGUI_OperationMgr::abortOperation(ModuleBase_Operation* theOperation)
 399 {
 400   ModuleBase_Operation* aCurrentOperation = currentOperation();
 401   if (theOperation == aCurrentOperation)
 402     theOperation->abort();
 403   else {
 404     // it is possible to trigger upper operation(e.g. sketch, current is sketch line)
 405     // all operation from the current to triggered should also be aborted
 406     // operations over the parameter one are not aborted(e.g. extrusion cut, sketch abort)
 407     while(hasOperation()) {
 408       ModuleBase_Operation* aCurrentOperation = currentOperation();
 409       aCurrentOperation->abort();
 410       if(theOperation == aCurrentOperation)
 411         break;
 412     }
 413   }
 414 }
 415
 416 bool XGUI_OperationMgr::onCommitOperation()
 417 {
 418   bool isCommitted = false;
 419   ModuleBase_Operation* anOperation = currentOperation();
 420   if (anOperation && myWorkshop->module()->canCommitOperation())
 421     isCommitted = anOperation->commit();
 422   return isCommitted;
 423 }
 424
 425 void XGUI_OperationMgr::onAbortOperation()
 426 {
 427   ModuleBase_Operation* aCurrentOperation = currentOperation();
 428   if (aCurrentOperation && canStopOperation(aCurrentOperation)) {
 429     abortOperation(aCurrentOperation);
 430   }
 431 }
 432
 433 void XGUI_OperationMgr::onBeforeOperationStarted()
 434 {
 435   ModuleBase_Operation* aCurrentOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 436   if (!aCurrentOperation)
 437     return;
 438
 439   /// Set current feature and remeber old current feature
 440   ModuleBase_OperationFeature* aFOperation =
 441     dynamic_cast<ModuleBase_OperationFeature*>(aCurrentOperation);
 442   if (aFOperation) {
 443     SessionPtr aMgr = ModelAPI_Session::get();
 444     DocumentPtr aDoc = aMgr->activeDocument();
 445     // the parameter of current feature should be false, we should use all feature, not only
 446     // visible in order to correctly save the previous feature of the nested operation, where the
 447     // features can be not visible in the tree. The problem case is Edit sketch entitity(line)
 448     // in the Sketch, created in ExtrusionCut operation. The entity disappears by commit.
 449     // When sketch entity operation started, the sketch should be cashed here as the current.
 450     // Otherwise(the flag is true), the ExtrusionCut is cashed, when commit happens, the sketch
 451     // is disabled, sketch entity is disabled as extrusion cut is created earliest then sketch.
 452     // As a result the sketch disappears from the viewer.
 453     // However after commit it is displayed back.
 454     aFOperation->setPreviousCurrentFeature(aDoc->currentFeature(false));
 455
 456 #ifdef DEBUG_CURRENT_FEATURE
 457     FeaturePtr aFeature = aFOperation->feature();
 458     QString aKind = aFeature ? aFeature->getKind().c_str() : "";
 459     qDebug(QString("onBeforeOperationStarted(), edit operation = %1, feature = %2")
 460             .arg(aFOperation->isEditOperation())
 461             .arg(ModuleBase_Tools::objectInfo(aFeature)).toStdString().c_str());
 462
 463     qDebug(QString("\tdocument->currentFeature(false) = %1").arg(
 464             ModuleBase_Tools::objectInfo(
 465             ModelAPI_Session::get()->activeDocument()->currentFeature(false)))
 466             .toStdString().c_str());
 467 #endif
 468
 469     if (aFOperation->isEditOperation()) {// it should be performed by the feature edit only
 470       // in create operation, the current feature is changed by addFeature()
 471       aDoc->setCurrentFeature(aFOperation->feature(), false);
 472       // this is the only place where flushes must be called after setCurrentFeature for the
 473       // current moment: after this the opertion is not finished, so, the ObjectBrowser
 474       // state may be corrupted (issue #1457)
 475       static Events_Loop* aLoop = Events_Loop::loop();
 476       static Events_ID aCreateEvent = aLoop->eventByName(EVENT_OBJECT_CREATED);
 477       aLoop->flush(aCreateEvent);
 478       static Events_ID aDeleteEvent = aLoop->eventByName(EVENT_OBJECT_DELETED);
 479       aLoop->flush(aDeleteEvent);
 480     }
 481
 482 #ifdef DEBUG_CURRENT_FEATURE
 483     qDebug("\tdocument->setCurrentFeature");
 484     qDebug(QString("\tdocument->currentFeature(false) = %1").arg(
 485             ModuleBase_Tools::objectInfo(
 486             ModelAPI_Session::get()->activeDocument()->currentFeature(false)))
 487             .toStdString().c_str());
 488 #endif
 489   }
 490 }
 491
 492 void XGUI_OperationMgr::onOperationStarted()
 493 {
 494   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 495   updateApplyOfOperations(aSenderOperation);
 496   XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(myWorkshop);
 497   aWorkshop->operationStarted(aSenderOperation);
 498 }
 499
 500 void XGUI_OperationMgr::onBeforeOperationAborted()
 501 {
 502   onBeforeOperationCommitted();
 503 }
 504
 505 void XGUI_OperationMgr::onOperationAborted()
 506 {
 507   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 508   emit operationAborted(aSenderOperation);
 509 }
 510
 511 void XGUI_OperationMgr::onBeforeOperationCommitted()
 512 {
 513   ModuleBase_Operation* aCurrentOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 514   if (!aCurrentOperation)
 515     return;
 516
 517   /// Restore the previous current feature
 518   ModuleBase_OperationFeature* aFOperation =
 519     dynamic_cast<ModuleBase_OperationFeature*>(aCurrentOperation);
 520   if (aFOperation) {
 521 #ifdef DEBUG_CURRENT_FEATURE
 522     QString aKind = aFOperation->feature()->getKind().c_str();
 523     qDebug(QString("onBeforeOperationCommitted(), edit operation = %1, feature = %2")
 524             .arg(aFOperation->isEditOperation())
 525             .arg(ModuleBase_Tools::objectInfo(aFOperation->feature())).toStdString().c_str());
 526
 527     qDebug(QString("\tdocument->currentFeature(false) = %1").arg(
 528             ModuleBase_Tools::objectInfo(
 529             ModelAPI_Session::get()->activeDocument()->currentFeature(false)))
 530             .toStdString().c_str());
 531 #endif
 532
 533     if (aFOperation->isEditOperation()) {
 534       /// Restore the previous current feature
 535       setCurrentFeature(aFOperation->previousCurrentFeature());
 536     }
 537     else { // create operation
 538       // the Top created feature should stays the current. In nested operations,
 539       // like Line in the Sketch or
 540       // Sketch in ExtrusionCut, a previous feature should be restored on commit.
 541       // It is performed here
 542       // in order to perform it in the current transaction without opening a new one.
 543       if (myOperations.front() != aFOperation)
 544         setCurrentFeature(aFOperation->previousCurrentFeature());
 545     }
 546 #ifdef DEBUG_CURRENT_FEATURE
 547     qDebug("\tdocument->setCurrentFeature");
 548     qDebug(QString("\tdocument->currentFeature(false) = %1").arg(
 549            ModuleBase_Tools::objectInfo(
 550            ModelAPI_Session::get()->activeDocument()->currentFeature(false)))
 551            .toStdString().c_str());
 552 #endif
 553     ModuleBase_IModule* aModule = myWorkshop->module();
 554     if (aModule)
 555       aModule->beforeOperationStopped(aFOperation);
 556   }
 557 }
 558
 559 void XGUI_OperationMgr::onOperationCommitted()
 560 {
 561   // apply state for all features from the stack of operations should be updated
 562   updateApplyOfOperations();
 563
 564   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 565   emit operationCommitted(aSenderOperation);
 566 }
 567
 568 void XGUI_OperationMgr::onOperationResumed()
 569 {
 570   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 571   emit operationResumed(aSenderOperation);
 572 }
 573
 574 void XGUI_OperationMgr::onOperationStopped()
 575 {
 576   ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
 577   ModuleBase_Operation* aCurrentOperation = currentOperation();
 578   if (!aSenderOperation || !aCurrentOperation || aSenderOperation != aCurrentOperation)
 579     return;
 580
 581   myOperations.removeAll(aCurrentOperation);
 582   aCurrentOperation->deleteLater();
 583
 584   emit operationStopped(aCurrentOperation);
 585
 586   // get last operation which can be resumed
 587   ModuleBase_Operation* aResultOp = 0;
 588   QListIterator<ModuleBase_Operation*> anIt(myOperations);
 589   anIt.toBack();
 590   while (anIt.hasPrevious()) {
 591     ModuleBase_Operation* anOp = anIt.previous();
 592     if (anOp) {
 593       aResultOp = anOp;
 594       break;
 595     }
 596   }
 597   if (aResultOp) {
 598     bool isModified = aCurrentOperation->isModified();
 599     aResultOp->setIsModified(aResultOp->isModified() || isModified);
 600     resumeOperation(aResultOp);
 601     onValidateOperation();
 602   }
 603 }
 604
 605 bool XGUI_OperationMgr::onKeyReleased(QObject *theObject, QKeyEvent* theEvent)
 606 {
 607   // Let the manager decide what to do with the given key combination.
 608   ModuleBase_Operation* anOperation = currentOperation();
 609   bool isAccepted = false;
 610   switch (theEvent->key()) {
 611     case Qt::Key_Return:
 612     case Qt::Key_Enter: {
 613       isAccepted = onProcessEnter(theObject);
 614     }
 615     break;
 616     case Qt::Key_N:
 617     case Qt::Key_P: {
 618       bool noModifiers = (theEvent->modifiers() == Qt::NoModifier);
 619       if (noModifiers) {
 620         ModuleBase_IViewer* aViewer = myWorkshop->viewer();
 621         Handle(AIS_InteractiveContext) aContext = aViewer->AISContext();
 622         if (!aContext.IsNull()) {
 623           Handle(V3d_View) aView = aViewer->activeView();
 624           if ((theEvent->key() == Qt::Key_N))
 625             aContext->HilightNextDetected(aView);
 626           else if ((theEvent->key() == Qt::Key_P))
 627             aContext->HilightPreviousDetected(aView);
 628         }
 629       }
 630     }
 631     break;
 632     break;
 633     default:
 634       isAccepted = false;
 635       break;
 636   }
 637   //if(anOperation) {
 638   //  anOperation->keyReleased(theEvent->key());
 639   //}
 640   return isAccepted;
 641 }
 642
 643 bool XGUI_OperationMgr::onProcessEnter(QObject* theObject)
 644 {
 645   bool isAccepted = false;
 646   ModuleBase_Operation* aOperation = currentOperation();
 647   // to avoid enter processing when operation has not been started yet
 648   if (!aOperation)
 649     return isAccepted;
 650   ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
 651   // only property panel enter is processed in order to do not process enter in application dialogs
 652   bool isPPChild = isChildObject(theObject, aPanel);
 653   if (!isPPChild)
 654     return isAccepted;
 655
 656   ModuleBase_ModelWidget* anActiveWgt = aPanel->activeWidget();
 657   bool isAborted = false;
 658   if (!anActiveWgt) {
 659     QWidget* aFocusWidget = aPanel->focusWidget();
 660     QToolButton* aCancelBtn =
 661       dynamic_cast<XGUI_PropertyPanel*>(aPanel)->findButton(PROP_PANEL_CANCEL);
 662     if (aFocusWidget && aCancelBtn && aFocusWidget == aCancelBtn) {
 663       abortOperation(aOperation);
 664       isAccepted = true;
 665       isAborted = true;
 666     }
 667   }
 668   if (!isAborted) {
 669     isAccepted = anActiveWgt && anActiveWgt->processEnter();
 670     if (!isAccepted) {
 671       isAccepted =
 672         myWorkshop->module()->processEnter(anActiveWgt ? anActiveWgt->attributeID() : "");
 673       if (!isAccepted) {
 674         /// functionality is similar to Apply click
 675         ModuleBase_OperationFeature* aFOperation =
 676           dynamic_cast<ModuleBase_OperationFeature*>(currentOperation());
 677         if (!aFOperation ||
 678             myWorkshop->module()->getFeatureError(aFOperation->feature()).isEmpty()) {
 679           // key released is emitted to apply the current value to the model
 680           // if it was modified in PP
 681           emit keyEnterReleased();
 682           commitOperation();
 683           isAccepted = true;
 684         }
 685         else
 686           isAccepted = false;
 687       }
 688     }
 689   }
 690   return isAccepted;
 691 }
 692
 693 bool editorControl(QObject* theObject)
 694 {
 695   QLineEdit* aLineEdit = dynamic_cast<QLineEdit*>(theObject);
 696   return aLineEdit;
 697 }
 698
 699 bool XGUI_OperationMgr::onProcessDelete(QObject* theObject)
 700 {
 701   bool isAccepted = false;
 702   ModuleBase_Operation* aOperation = currentOperation();
 703   ModuleBase_ModelWidget* anActiveWgt = 0;
 704   // firstly the widget should process Delete action
 705   ModuleBase_IPropertyPanel* aPanel;
 706   bool isPPChildObject = false;
 707   if (aOperation) {
 708     aPanel = aOperation->propertyPanel();
 709     if (aPanel) {
 710       isPPChildObject = isChildObject(theObject, aPanel);
 711       // process delete in active widget only if delete sender is child of property panel
 712       // it is necessary for the case when OB is shown, user perform selection and click Delete
 713       if (isPPChildObject) {
 714         anActiveWgt = aPanel->activeWidget();
 715         if (anActiveWgt) {
 716           isAccepted = anActiveWgt->processDelete();
 717         }
 718       }
 719     }
 720   }
 721   if (!isAccepted) {
 722     // after widget, object browser and viewer should process delete
 723     /// other widgets such as line edit controls should not lead to
 724     /// processing delete by workshop
 725     XGUI_ObjectsBrowser* aBrowser = XGUI_Tools::workshop(myWorkshop)->objectBrowser();
 726     QWidget* aViewPort = myWorkshop->viewer()->activeViewPort();
 727     bool isToDeleteObject = false;
 728     XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(myWorkshop);
 729     XGUI_ContextMenuMgr* aContextMenuMgr = aWorkshop->contextMenuMgr();
 730     if (theObject == aBrowser->treeView()) {
 731       aContextMenuMgr->updateObjectBrowserMenu();
 732       isToDeleteObject = aContextMenuMgr->action("DELETE_CMD")->isEnabled();
 733     }
 734     else if (isChildObject(theObject, aViewPort)) {
 735       aContextMenuMgr->updateViewerMenu();
 736       isToDeleteObject = aContextMenuMgr->action("DELETE_CMD")->isEnabled();
 737     }
 738     else if (isPPChildObject) {
 739       // property panel child object is processed to process delete performed on Apply button of PP
 740       isToDeleteObject = true;
 741     }
 742     else if (editorControl(theObject)) {
 743       isToDeleteObject = false; /// Line Edit of Rename operation in ObjectBrowser
 744       isAccepted = true;
 745     }
 746
 747     if (isToDeleteObject) {
 748       aWorkshop->deleteObjects();
 749       isAccepted = true;
 750     }
 751   }
 752
 753   return isAccepted;
 754 }
 755
 756 bool XGUI_OperationMgr::isChildObject(const QObject* theObject, const QObject* theParent)
 757 {
 758   bool isPPChild = false;
 759   if (theParent && theObject) {
 760     QObject* aParent = (QObject*)theObject;
 761     while (aParent ) {
 762       isPPChild = aParent == theParent;
 763       if (isPPChild)
 764         break;
 765       aParent = aParent->parent();
 766     }
 767   }
 768   return isPPChild;
 769 }