X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_MenuMgr.cpp;h=24953f5a600d23f01f8a94773b53016988133b67;hb=185923a92c76805bc1b410b0f655e214394a8573;hp=e453a552554d43bf271df38a0370c5203fbd917c;hpb=e2c1d6fb594fe1234fa7a0786801d8c1c92d7ac6;p=modules%2Fshaper.git

diff --git a/src/PartSet/PartSet_MenuMgr.cpp b/src/PartSet/PartSet_MenuMgr.cpp
index e453a5525..24953f5a6 100644
--- a/src/PartSet/PartSet_MenuMgr.cpp
+++ b/src/PartSet/PartSet_MenuMgr.cpp
@@ -9,6 +9,8 @@
 #include "PartSet_SketcherMgr.h"
 #include "PartSet_Tools.h"
 
+#include <PartSetPlugin_Part.h>
+
 #include <GeomAPI_Pnt2d.h>
 #include <GeomDataAPI_Point2D.h>
 
@@ -20,19 +22,27 @@
 
 #include <ModuleBase_ISelection.h>
 #include <ModuleBase_Operation.h>
+#include <ModuleBase_OperationAction.h>
+#include <ModuleBase_OperationFeature.h>
+#include <ModuleBase_ViewerPrs.h>
+#include <ModuleBase_Tools.h>
 
 #include <XGUI_ModuleConnector.h>
 #include <XGUI_Workshop.h>
 #include <XGUI_Displayer.h>
+#include <XGUI_DataModel.h>
+#include <XGUI_OperationMgr.h>
+#include <XGUI_ObjectsBrowser.h>
 
 #include <Events_Loop.h>
 #include <ModelAPI_Events.h>
 #include <ModelAPI_Session.h>
-#include <ModelAPI_ResultPart.h>
 #include <ModelAPI_ResultParameter.h>
 
+#include <QMainWindow>
 #include <QAction>
 #include <QMenu>
+#include <QEvent>
 
 #include <TopoDS.hxx>
 #include <BRep_Tool.hxx>
@@ -64,25 +74,22 @@ void PartSet_MenuMgr::createActions()
 {
   QAction* aAction;
 
-  aAction = new QAction(tr("Auxiliary"), this);
+  QWidget* aParent = myModule->workshop()->desktop();
+  aAction = ModuleBase_Tools::createAction(QIcon(), tr("Auxiliary"), aParent);
   aAction->setCheckable(true);
   addAction("AUXILIARY_CMD", aAction);
 
-  aAction = new QAction(QIcon(":icons/activate.png"), tr("Activate"), this);
-  connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onActivatePart(bool)));
+  aAction = ModuleBase_Tools::createAction(QIcon(":icons/activate.png"), tr("Activate"), aParent,
+                                           this, SLOT(onActivatePart(bool)));
   myActions["ACTIVATE_PART_CMD"] = aAction;
 
-  aAction = new QAction(QIcon(":icons/deactivate.png"), tr("Deactivate"), this);
-  connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onActivatePartSet(bool)));
-  myActions["DEACTIVATE_PART_CMD"] = aAction;
-
   // Activate PartSet
-  aAction = new QAction(QIcon(":icons/activate.png"), tr("Activate"), this);
-  connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onActivatePartSet(bool)));
+  aAction = ModuleBase_Tools::createAction(QIcon(":icons/activate.png"), tr("Activate"), aParent,
+                        this, SLOT(onActivatePartSet(bool)));
   myActions["ACTIVATE_PARTSET_CMD"] = aAction;
 
-  aAction = new QAction(QIcon(":icons/edit.png"), tr("Edit..."), this);
-  connect(aAction, SIGNAL(triggered(bool)), this, SLOT(onEdit(bool)));
+  aAction = ModuleBase_Tools::createAction(QIcon(":icons/edit.png"), tr("Edit..."), aParent,
+                         this, SLOT(onEdit(bool)));
   myActions["EDIT_CMD"] = aAction;
 }
 
@@ -97,70 +104,15 @@ void PartSet_MenuMgr::onAction(bool isChecked)
   }
 }
 
-/// Returns point of coincidence feature
-/// \param theFeature the coincidence feature
-/// \param theAttribute the attribute name
-std::shared_ptr<GeomAPI_Pnt2d> getPoint(std::shared_ptr<ModelAPI_Feature>& theFeature,
-                                        const std::string& theAttribute)
+bool PartSet_MenuMgr::addViewerMenu(const QMap<QString, QAction*>& theStdActions,
+                                    QWidget* theParent,
+                                    QMap<int, QAction*>& theMenuActions) const
 {
-  std::shared_ptr<GeomDataAPI_Point2D> aPointAttr;
-
-  if (!theFeature->data())
-    return std::shared_ptr<GeomAPI_Pnt2d>();
-
-  FeaturePtr aFeature;
-  std::shared_ptr<ModelAPI_AttributeRefAttr> anAttr = std::dynamic_pointer_cast<
-      ModelAPI_AttributeRefAttr>(theFeature->data()->attribute(theAttribute));
-  if (anAttr)
-    aFeature = ModelAPI_Feature::feature(anAttr->object());
-
-  if (aFeature && aFeature->getKind() == SketchPlugin_Point::ID())
-    aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
-        aFeature->data()->attribute(SketchPlugin_Point::COORD_ID()));
-
-  else if (anAttr->attr()) {
-    aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(anAttr->attr());
-  }
-  if (aPointAttr.get() != NULL)
-    return aPointAttr->pnt();
-  return std::shared_ptr<GeomAPI_Pnt2d>();
-}
+  int anIndex = 0;
 
-/// Returns list of features connected in a councedence feature point
-/// \param theStartCoin the coincidence feature
-/// \param theList a list which collects lines features
-/// \param theAttr the attribute name
-void findCoincidences(FeaturePtr theStartCoin, QList<FeaturePtr>& theList, std::string theAttr)
-{
-  AttributeRefAttrPtr aPnt = theStartCoin->refattr(theAttr);
-  FeaturePtr aObj = ModelAPI_Feature::feature(aPnt->object());
-  if (!theList.contains(aObj)) {
-    std::shared_ptr<GeomAPI_Pnt2d> aOrig = getPoint(theStartCoin, theAttr);
-    if (aOrig.get() == NULL)
-      return;
-    theList.append(aObj);
-    const std::set<AttributePtr>& aRefsList = aObj->data()->refsToMe();
-    std::set<AttributePtr>::const_iterator aIt;
-    for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
-      std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
-      FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
-      if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { 
-        std::shared_ptr<GeomAPI_Pnt2d> aPnt = getPoint(aConstrFeature, theAttr);
-        if (aPnt.get() && aOrig->isEqual(aPnt)) {
-          findCoincidences(aConstrFeature, theList, SketchPlugin_ConstraintCoincidence::ENTITY_A());
-          findCoincidences(aConstrFeature, theList, SketchPlugin_ConstraintCoincidence::ENTITY_B());
-        }
-      }
-    }
-  }
-}
-
-
-bool PartSet_MenuMgr::addViewerMenu(QMenu* theMenu, const QMap<QString, QAction*>& theStdActions) const
-{
   ModuleBase_Operation* anOperation = myModule->workshop()->currentOperation();
   if (!PartSet_SketcherMgr::isSketchOperation(anOperation) &&
-      !PartSet_SketcherMgr::isNestedSketchOperation(anOperation))
+      !myModule->sketchMgr()->isNestedSketchOperation(anOperation))
     return false;
 
   myCoinsideLines.clear();
@@ -170,66 +122,52 @@ bool PartSet_MenuMgr::addViewerMenu(QMenu* theMenu, const QMap<QString, QAction*
   bool hasAttribute = false;
   bool hasFeature = false;
 
-  QList<ModuleBase_ViewerPrs> aPrsList = aSelection->getSelected();
-  TopoDS_Shape aShape;
-  ResultPtr aResult;
-  FeaturePtr aFeature;
-  foreach(ModuleBase_ViewerPrs aPrs, aPrsList) {
-    aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aPrs.object());
-    if (aResult.get() != NULL) {
-      aShape = aPrs.shape();
-      if (aShape.IsEqual(aResult->shape()->impl<TopoDS_Shape>()))
-        hasFeature = true;
-      else
-        hasAttribute = true;
-    } else {
-      aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aPrs.object());
-      hasFeature = (aFeature.get() != NULL);
+  QList<ModuleBase_ViewerPrsPtr> aPrsList = aSelection->getSelected(ModuleBase_ISelection::Viewer);
+  if (aPrsList.size() > 1) {
+    hasFeature = true;
+  } else if (aPrsList.size() == 1) {
+    ResultPtr aResult;
+    FeaturePtr aFeature;
+    foreach(ModuleBase_ViewerPrsPtr aPrs, aPrsList) {
+      aResult = std::dynamic_pointer_cast<ModelAPI_Result>(aPrs->object());
+      if (aResult.get() != NULL) {
+        const GeomShapePtr& aShape = aPrs->shape();
+        if (aShape.get() && aShape->isEqual(aResult->shape()))
+          hasFeature = true;
+        else
+          hasAttribute = true;
+      } else {
+        aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aPrs->object());
+        hasFeature = (aFeature.get() != NULL);
+      }
     }
-  }
 
-  if (aPrsList.size() == 1) {
-    TopoDS_Shape aShape = aPrsList.first().shape();
-    if ((!aShape.IsNull()) && aShape.ShapeType() == TopAbs_VERTEX) {
+    const GeomShapePtr& aShape = aPrsList.first()->shape();
+    if (aShape.get() && !aShape->isNull() && aShape->shapeType() == GeomAPI_Shape::VERTEX) {
       // Find 2d coordinates
       FeaturePtr aSketchFea = myModule->sketchMgr()->activeSketch();
       if (aSketchFea->getKind() == SketchPlugin_Sketch::ID()) {
-        gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aShape));
+        const TopoDS_Shape& aTDShape = aShape->impl<TopoDS_Shape>();
+        gp_Pnt aPnt = BRep_Tool::Pnt(TopoDS::Vertex(aTDShape));
         std::shared_ptr<GeomAPI_Pnt> aPnt3d(new GeomAPI_Pnt(aPnt.X(), aPnt.Y(), aPnt.Z()));
         std::shared_ptr<GeomAPI_Pnt2d> aSelPnt = PartSet_Tools::convertTo2D(aSketchFea, aPnt3d);
 
         // Find coincident in these coordinates
-        ObjectPtr aObj = aPrsList.first().object();
+        ObjectPtr aObj = aPrsList.first()->object();
         FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
-        const std::set<AttributePtr>& aRefsList = aFeature->data()->refsToMe();
-        std::set<AttributePtr>::const_iterator aIt;
-        FeaturePtr aCoincident;
-        for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
-          std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
-          FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
-          if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { 
-            std::shared_ptr<GeomAPI_Pnt2d> a2dPnt = 
-              getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A());
-            if (a2dPnt.get() && aSelPnt->isEqual(a2dPnt)) { 
-              aCoincident = aConstrFeature;
-              break;
-            } else {
-              a2dPnt = getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_B());
-              if (a2dPnt.get() && aSelPnt->isEqual(a2dPnt)) { 
-                aCoincident = aConstrFeature;
-                break;
-              }
-            }
-          }
-        }
+        FeaturePtr aCoincident = PartSet_Tools::findFirstCoincidence(aFeature, aSelPnt);
         // If we have coincidence then add Detach menu
         if (aCoincident.get() != NULL) {
+          QList<FeaturePtr> aCoins;
           mySelectedFeature = aCoincident;
-          findCoincidences(mySelectedFeature, myCoinsideLines, SketchPlugin_ConstraintCoincidence::ENTITY_A());
-          findCoincidences(mySelectedFeature, myCoinsideLines, SketchPlugin_ConstraintCoincidence::ENTITY_B());
+          PartSet_Tools::findCoincidences(mySelectedFeature, myCoinsideLines, aCoins,
+                                          SketchPlugin_ConstraintCoincidence::ENTITY_A());
+          PartSet_Tools::findCoincidences(mySelectedFeature, myCoinsideLines, aCoins,
+                                          SketchPlugin_ConstraintCoincidence::ENTITY_B());
           if (myCoinsideLines.size() > 0) {
             aIsDetach = true;
-            QMenu* aSubMenu = theMenu->addMenu(tr("Detach"));
+            QMenu* aSubMenu = new QMenu(tr("Detach"), theParent);
+            theMenuActions[anIndex++] = aSubMenu->menuAction();
             QAction* aAction;
             int i = 0;
             foreach (FeaturePtr aCoins, myCoinsideLines) {
@@ -240,25 +178,45 @@ bool PartSet_MenuMgr::addViewerMenu(QMenu* theMenu, const QMap<QString, QAction*
             connect(aSubMenu, SIGNAL(hovered(QAction*)), SLOT(onLineHighlighted(QAction*)));
             connect(aSubMenu, SIGNAL(aboutToHide()), SLOT(onDetachMenuHide()));
             connect(aSubMenu, SIGNAL(triggered(QAction*)), SLOT(onLineDetach(QAction*)));
-          } 
+          }
         }
       }
     }
   }
-  if ((!aIsDetach) && hasFeature) {
-    theMenu->addAction(theStdActions["DELETE_CMD"]);
+  if (!hasAttribute) {
+    bool isAuxiliary;
+    if (canSetAuxiliary(isAuxiliary)) {
+      QAction* anAction = action("AUXILIARY_CMD");
+      theMenuActions[anIndex++] = anAction;
+      anAction->setChecked(isAuxiliary);
+    }
   }
-  if (hasAttribute)
-    return true;
-  bool isAuxiliary;
-  if (canSetAuxiliary(isAuxiliary)) {
-    QAction* anAction = action("AUXILIARY_CMD");
-    theMenu->addAction(anAction);
-    anAction->setChecked(isAuxiliary);
+
+  if (!aIsDetach && hasFeature) {
+    // Delete item should be the last in the list of actions
+    theMenuActions[1000] = theStdActions["DELETE_CMD"];
   }
+
   return true;
 }
 
+void PartSet_MenuMgr::updateViewerMenu(const QMap<QString, QAction*>& theStdActions)
+{
+  ModuleBase_Operation* anOperation = myModule->workshop()->currentOperation();
+
+  bool isActiveSketch = PartSet_SketcherMgr::isSketchOperation(anOperation) ||
+                        myModule->sketchMgr()->isNestedSketchOperation(anOperation);
+  if (isActiveSketch) {
+    theStdActions["WIREFRAME_CMD"]->setEnabled(false);
+    theStdActions["SHADING_CMD"]->setEnabled(false);
+    theStdActions["SHOW_ONLY_CMD"]->setEnabled(false);
+    theStdActions["SHOW_CMD"]->setEnabled(false);
+    theStdActions["HIDE_CMD"]->setEnabled(false);
+    theStdActions["HIDEALL_CMD"]->setEnabled(false);
+  }
+}
+
+
 void PartSet_MenuMgr::onLineHighlighted(QAction* theAction)
 {
   if (myPrevId != -1) {
@@ -288,57 +246,66 @@ QColor PartSet_MenuMgr::setLineColor(int theId, const QColor theColor, bool theU
 }
 
 
-void PartSet_MenuMgr::onLineDetach(QAction* theAction)
+void addRefCoincidentFeatures(const std::set<AttributePtr>& theRefList,
+  std::shared_ptr<GeomAPI_Pnt2d>& theRefPnt,
+  QObjectPtrList& theOutList)
 {
-  int aId = theAction->data().toInt();
-  FeaturePtr aLine = myCoinsideLines.at(aId);
-  std::shared_ptr<GeomAPI_Pnt2d> aOrig = getPoint(mySelectedFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A());
-  if (aOrig.get() == NULL)
-    aOrig = getPoint(mySelectedFeature, SketchPlugin_ConstraintCoincidence::ENTITY_B());
-  
-  gp_Pnt aOr = aOrig->impl<gp_Pnt>();
-  const std::set<AttributePtr>& aRefsList = aLine->data()->refsToMe();
-
-  QObjectPtrList aToDelFeatures;
   std::set<AttributePtr>::const_iterator aIt;
-  // Find all coincedences corresponded to the selected line in the selected point
-  for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
+  for (aIt = theRefList.cbegin(); aIt != theRefList.cend(); ++aIt) {
     std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
     FeaturePtr aConstrFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
-    if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) { 
-      std::shared_ptr<GeomAPI_Pnt2d> aPnt = getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_A());
-      if (aPnt.get() == NULL)
-        aPnt = getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_B());
+    if (aConstrFeature->getKind() == SketchPlugin_ConstraintCoincidence::ID()) {
+      std::shared_ptr<GeomAPI_Pnt2d> aPnt = PartSet_Tools::getCoincedencePoint(aConstrFeature);
       if (aPnt.get() == NULL)
         return;
       gp_Pnt aP = aPnt->impl<gp_Pnt>();
-      if (aOrig->isEqual(aPnt)) {
-        aToDelFeatures.append(aConstrFeature);
-      } else {
-        aPnt = getPoint(aConstrFeature, SketchPlugin_ConstraintCoincidence::ENTITY_B());
-        aP = aPnt->impl<gp_Pnt>();
-        if (aOrig->isEqual(aPnt)) {
-          aToDelFeatures.append(aConstrFeature);
-          break;
-        }
+      if (theRefPnt->isEqual(aPnt) && (!theOutList.contains(aConstrFeature))) {
+        theOutList.append(aConstrFeature);
       }
     }
   }
+}
+
+void PartSet_MenuMgr::onLineDetach(QAction* theAction)
+{
+  int aId = theAction->data().toInt();
+  FeaturePtr aLine = myCoinsideLines.at(aId);
+  std::shared_ptr<GeomAPI_Pnt2d> aOrig = PartSet_Tools::getCoincedencePoint(mySelectedFeature);
+  if (!aOrig.get())
+    return;
+
+  const std::set<AttributePtr>& aRefsList = aLine->data()->refsToMe();
+
+  QObjectPtrList aToDelFeatures;
+
+  addRefCoincidentFeatures(aRefsList, aOrig, aToDelFeatures);
+
+  const std::list<ResultPtr>& aResults = aLine->results();
+  std::list<ResultPtr>::const_iterator aResIt;
+  for (aResIt = aResults.cbegin(); aResIt != aResults.cend(); aResIt++) {
+    ResultPtr aResult = (*aResIt);
+    const std::set<AttributePtr>& aRefList = aResult->data()->refsToMe();
+    addRefCoincidentFeatures(aRefList, aOrig, aToDelFeatures);
+  }
   if (aToDelFeatures.size() > 0) {
     XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(myModule->workshop());
     XGUI_Workshop* aWorkshop = aConnector->workshop();
     ModuleBase_Operation* anOperation = myModule->workshop()->currentOperation();
-    if (PartSet_SketcherMgr::isNestedSketchOperation(anOperation))
-      anOperation->abort();
 
-    SessionPtr aMgr = ModelAPI_Session::get();
-    std::set<FeaturePtr> anIgnoredFeatures;
-    anIgnoredFeatures.insert(myModule->sketchMgr()->activeSketch());
+    ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction(
+                                   tr("Detach %1").arg(aLine->data()->name().c_str()), myModule);
+    bool isSketchOp = PartSet_SketcherMgr::isSketchOperation(anOperation);
+    XGUI_OperationMgr* anOpMgr = aConnector->workshop()->operationMgr();
+    // the active nested sketch operation should be aborted unconditionally
+    // the Delete action should be additionally granted for the Sketch operation
+    // in order to do not abort/commit it
+    if (!anOpMgr->canStartOperation(tr("Detach")))
+      return; // the objects are processed but can not be deleted
+
+    anOpMgr->startOperation(anOpAction);
+    aWorkshop->deleteFeatures(aToDelFeatures);
 
-    QString aName = tr("Detach %1").arg(aLine->data()->name().c_str());
-    aMgr->startOperation(aName.toStdString());
-    aWorkshop->deleteFeatures(aToDelFeatures, anIgnoredFeatures);
-    aMgr->finishOperation();
+    anOpMgr->commitOperation();
   }
   myCoinsideLines.clear();
 }
@@ -354,22 +321,26 @@ void PartSet_MenuMgr::onDetachMenuHide()
   myPrevId = -1;
 }
 
-  
+
 void PartSet_MenuMgr::setAuxiliary(const bool isChecked)
 {
   ModuleBase_Operation* anOperation = myModule->workshop()->currentOperation();
 
+  CompositeFeaturePtr aSketch = myModule->sketchMgr()->activeSketch();
   bool isActiveSketch = PartSet_SketcherMgr::isSketchOperation(anOperation) ||
-                        PartSet_SketcherMgr::isNestedSketchOperation(anOperation);
+                        myModule->sketchMgr()->isNestedSketchOperation(anOperation);
   if (!isActiveSketch)
     return;
 
   QObjectPtrList anObjects;
   bool isUseTransaction = false;
   // 1. change auxiliary type of a created feature
-  if (PartSet_SketcherMgr::isNestedCreateOperation(anOperation) &&
-    PartSet_SketcherMgr::isEntity(anOperation->id().toStdString()) ) {
-    anObjects.append(anOperation->feature());
+  if (myModule->sketchMgr()->isNestedCreateOperation(anOperation, aSketch) &&
+      PartSet_SketcherMgr::isEntity(anOperation->id().toStdString()) ) {
+      ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+                                                               (anOperation);
+      if (aFOperation)
+        anObjects.append(aFOperation->feature());
   }
   else {
     isUseTransaction = true;
@@ -379,14 +350,19 @@ void PartSet_MenuMgr::setAuxiliary(const bool isChecked)
   }
 
   QAction* anAction = action("AUXILIARY_CMD");
-  SessionPtr aMgr = ModelAPI_Session::get();
+  //SessionPtr aMgr = ModelAPI_Session::get();
+  ModuleBase_OperationAction* anOpAction = 0;
+  XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(myModule->workshop());
+  XGUI_OperationMgr* anOpMgr = aConnector->workshop()->operationMgr();
   if (isUseTransaction) {
-    if (PartSet_SketcherMgr::isNestedSketchOperation(anOperation))
-      anOperation->abort();
-    aMgr->startOperation(anAction->text().toStdString());
-  }
-  myModule->sketchMgr()->storeSelection();
+    anOpAction = new ModuleBase_OperationAction(anAction->text(), myModule);
+    bool isSketchOp = PartSet_SketcherMgr::isSketchOperation(anOperation);
+
+    if (!anOpMgr->canStartOperation(anOpAction->id()))
+      return; // the objects are processed but can not be deleted
 
+    anOpMgr->startOperation(anOpAction);
+  }
   if (anObjects.size() > 0) {
     QObjectPtrList::const_iterator anIt = anObjects.begin(), aLast = anObjects.end();
     for (; anIt != aLast; anIt++) {
@@ -397,23 +373,19 @@ void PartSet_MenuMgr::setAuxiliary(const bool isChecked)
         if (aSketchFeature.get() != NULL) {
           std::string anAttribute = SketchPlugin_SketchEntity::AUXILIARY_ID();
 
-          std::shared_ptr<ModelAPI_AttributeBoolean> anAuxiliaryAttr = 
-            std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(aSketchFeature->data()->attribute(anAttribute));
+          std::shared_ptr<ModelAPI_AttributeBoolean> anAuxiliaryAttr =
+            std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(
+            aSketchFeature->data()->attribute(anAttribute));
           if (anAuxiliaryAttr)
             anAuxiliaryAttr->setValue(isChecked);
         }
       }
     }
   }
-  if (isUseTransaction) {
-    aMgr->finishOperation();
-    XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(myModule->workshop());
-    XGUI_Workshop* aWorkshop = aConnector->workshop();
-    aWorkshop->updateCommandStatus();
-  }
+  if (isUseTransaction)
+    anOpMgr->commitOperation();
 
   Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
-  myModule->sketchMgr()->restoreSelection();
 }
 
 bool PartSet_MenuMgr::canSetAuxiliary(bool& theValue) const
@@ -421,21 +393,25 @@ bool PartSet_MenuMgr::canSetAuxiliary(bool& theValue) const
   bool anEnabled = false;
   ModuleBase_Operation* anOperation = myModule->workshop()->currentOperation();
 
+  CompositeFeaturePtr aSketch = myModule->sketchMgr()->activeSketch();
   bool isActiveSketch = PartSet_SketcherMgr::isSketchOperation(anOperation) ||
-                        PartSet_SketcherMgr::isNestedSketchOperation(anOperation);
+                        myModule->sketchMgr()->isNestedSketchOperation(anOperation);
   if (!isActiveSketch)
     return anEnabled;
 
   QObjectPtrList anObjects;
   // 1. change auxiliary type of a created feature
-  if (PartSet_SketcherMgr::isNestedCreateOperation(anOperation) &&
+  if (myModule->sketchMgr()->isNestedCreateOperation(anOperation, aSketch) &&
     PartSet_SketcherMgr::isEntity(anOperation->id().toStdString()) ) {
-    anObjects.append(anOperation->feature());
+    ModuleBase_OperationFeature* aFOperation =
+      dynamic_cast<ModuleBase_OperationFeature*>(anOperation);
+    if (aFOperation)
+      anObjects.append(aFOperation->feature());
   }
   else {
     /// The operation should not be aborted here, because the method does not changed
     /// the auxilliary state, but checks the possibility to perform this
-    ///if (PartSet_SketcherMgr::isNestedSketchOperation(anOperation))
+    ///if (myModule->sketchMgr()->isNestedSketchOperation(anOperation))
     ///  anOperation->abort();
     // 2. change auxiliary type of selected sketch entities
     ModuleBase_ISelection* aSelection = myModule->workshop()->selection();
@@ -454,8 +430,9 @@ bool PartSet_MenuMgr::canSetAuxiliary(bool& theValue) const
         if (aSketchFeature.get() != NULL) {
           std::string anAttribute = SketchPlugin_SketchEntity::AUXILIARY_ID();
 
-          std::shared_ptr<ModelAPI_AttributeBoolean> anAuxiliaryAttr = 
-            std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(aSketchFeature->data()->attribute(anAttribute));
+          std::shared_ptr<ModelAPI_AttributeBoolean> anAuxiliaryAttr =
+            std::dynamic_pointer_cast<ModelAPI_AttributeBoolean>(
+            aSketchFeature->data()->attribute(anAttribute));
           if (anAuxiliaryAttr)
             isNotAuxiliaryFound = !anAuxiliaryAttr->value();
         }
@@ -468,19 +445,66 @@ bool PartSet_MenuMgr::canSetAuxiliary(bool& theValue) const
 
 void PartSet_MenuMgr::onActivatePart(bool)
 {
+  if (myModule->workshop()->currentOperation())
+    return;
   QObjectPtrList aObjects = myModule->workshop()->selection()->selectedObjects();
   if (aObjects.size() > 0) {
-    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObjects.first());
-    if (aPart) {
-      aPart->activate();
+    ObjectPtr aObj = aObjects.first();
+    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aObj);
+    if (!aPart.get()) {
+      FeaturePtr aPartFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObj);
+      if (aPartFeature.get() && (aPartFeature->getKind() == PartSetPlugin_Part::ID())) {
+        aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(aPartFeature->firstResult());
+      }
+    }
+    if (aPart.get()) {
+      activatePart(aPart);
+      myModule->workshop()->updateCommandStatus();
     }
   }
 }
 
+void PartSet_MenuMgr::activatePart(ResultPartPtr thePart) const
+{
+  bool isFirstLoad = !thePart->partDoc().get();
+  thePart->activate();
+  if (isFirstLoad) {
+    XGUI_Workshop* aWorkshop = myModule->getWorkshop();
+    XGUI_ObjectsBrowser* aObjBrowser = aWorkshop->objectBrowser();
+    DocumentPtr aDoc = thePart->partDoc();
+    std::list<bool> aStates;
+    aDoc->restoreNodesState(aStates);
+    aObjBrowser->setStateForDoc(aDoc, aStates);
+  }
+}
+
 void PartSet_MenuMgr::onActivatePartSet(bool)
+{
+  if (myModule->workshop()->currentOperation())
+    return;
+  activatePartSet();
+}
+
+void PartSet_MenuMgr::activatePartSet() const
 {
   SessionPtr aMgr = ModelAPI_Session::get();
+  bool isNewTransaction = !aMgr->isOperation();
+  // activation may cause changes in current features in document, so it must be in transaction
+  if (isNewTransaction)
+    aMgr->startOperation("Activation");
   aMgr->setActiveDocument(aMgr->moduleDocument());
+  if (isNewTransaction) aMgr->finishOperation();
+
+  myModule->workshop()->updateCommandStatus();
+}
+
+void PartSet_MenuMgr::grantedOperationIds(ModuleBase_Operation* theOperation,
+                                          QStringList& theIds) const
+{
+  if (PartSet_SketcherMgr::isSketchOperation(theOperation)) {
+    theIds.append(tr("Detach"));
+    theIds.append(tr("Auxiliary"));
+  }
 }
 
 void PartSet_MenuMgr::onEdit(bool)
@@ -488,7 +512,7 @@ void PartSet_MenuMgr::onEdit(bool)
   QObjectPtrList aObjects = myModule->workshop()->selection()->selectedObjects();
   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aObjects.first());
   if (aFeature == NULL) {
-    ResultParameterPtr aParam = 
+    ResultParameterPtr aParam =
       std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aObjects.first());
     if (aParam.get() != NULL) {
       aFeature = ModelAPI_Feature::feature(aParam);
@@ -497,3 +521,13 @@ void PartSet_MenuMgr::onEdit(bool)
   if (aFeature.get() != NULL)
     myModule->editFeature(aFeature);
 }
+
+bool PartSet_MenuMgr::eventFilter(QObject* theObj, QEvent* theEvent)
+{
+  if (theEvent->type() == QEvent::MouseButtonDblClick) {
+    SessionPtr aMgr = ModelAPI_Session::get();
+    if (aMgr->activeDocument() != aMgr->moduleDocument())
+      activatePartSet();
+  }
+  return QObject::eventFilter(theObj, theEvent);
+}
\ No newline at end of file