X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Module.cpp;h=2b92c351a5ec2fdf8a88d31fd0c77168050d70cb;hb=6f84fd29d85b783864cdbb3ac9fdd6a3ad3cbb7c;hp=2c055ffd6ccde652922c808d6135edd44103ead9;hpb=7888a06fef94771979d7a204246480224e41065f;p=modules%2Fshaper.git

diff --git a/src/PartSet/PartSet_Module.cpp b/src/PartSet/PartSet_Module.cpp
index 2c055ffd6..2b92c351a 100644
--- a/src/PartSet/PartSet_Module.cpp
+++ b/src/PartSet/PartSet_Module.cpp
@@ -1,53 +1,58 @@
+// Copyright (C) 2014-20xx CEA/DEN, EDF R&D
+
 #include "PartSet_Module.h"
-#include <PartSet_OperationSketch.h>
 #include <PartSet_WidgetSketchLabel.h>
 #include <PartSet_Validators.h>
 #include <PartSet_Tools.h>
 #include <PartSet_WidgetPoint2d.h>
 #include <PartSet_WidgetPoint2dDistance.h>
 #include <PartSet_WidgetShapeSelector.h>
+#include <PartSet_SketcherMgr.h>
 
 #include <ModuleBase_Operation.h>
 #include <ModuleBase_IViewer.h>
 #include <ModuleBase_IViewWindow.h>
 #include <ModuleBase_IPropertyPanel.h>
+#include <ModuleBase_WidgetEditor.h>
+#include <ModuleBase_FilterFactory.h>
+#include <ModuleBase_FilterLinearEdge.h>
+#include <ModuleBase_FilterFace.h>
+#include <ModuleBase_FilterMulti.h>
+#include <ModuleBase_FilterCustom.h>
+#include <ModuleBase_FilterNoConsructionSubShapes.h>
 
 #include <ModelAPI_Object.h>
 #include <ModelAPI_Events.h>
 #include <ModelAPI_Validator.h>
 #include <ModelAPI_Data.h>
 #include <ModelAPI_Session.h>
+#include <ModelAPI_ShapeValidator.h>
 
 #include <GeomDataAPI_Point2D.h>
 #include <GeomDataAPI_Point.h>
 #include <GeomDataAPI_Dir.h>
 
-#include <XGUI_MainWindow.h>
 #include <XGUI_Displayer.h>
-#include <XGUI_Viewer.h>
 #include <XGUI_Workshop.h>
 #include <XGUI_OperationMgr.h>
-#include <XGUI_ViewPort.h>
-#include <XGUI_ActionsMgr.h>
-#include <XGUI_ViewerProxy.h>
-#include <XGUI_ContextMenuMgr.h>
 #include <XGUI_PropertyPanel.h>
 #include <XGUI_ModuleConnector.h>
 #include <XGUI_Tools.h>
 
-#include <SketchPlugin_Line.h>
+#include <SketchPlugin_Feature.h>
 #include <SketchPlugin_Sketch.h>
-#include <SketchPlugin_Point.h>
-#include <SketchPlugin_Arc.h>
-#include <SketchPlugin_Circle.h>
+#include <SketchPlugin_Line.h>
+//#include <SketchPlugin_Arc.h>
+//#include <SketchPlugin_Circle.h>
 #include <SketchPlugin_ConstraintLength.h>
 #include <SketchPlugin_ConstraintDistance.h>
 #include <SketchPlugin_ConstraintParallel.h>
 #include <SketchPlugin_ConstraintPerpendicular.h>
 #include <SketchPlugin_ConstraintRadius.h>
-#include <SketchPlugin_ConstraintRigid.h>
+//#include <SketchPlugin_ConstraintRigid.h>
 
 #include <Events_Loop.h>
+#include <Config_PropManager.h>
 
 #include <StdSelect_TypeOfFace.hxx>
 #include <TopoDS_Vertex.hxx>
@@ -68,23 +73,6 @@
 #include <QDebug>
 #endif
 
-
-/// Returns list of unique objects by sum of objects from List1 and List2
-QList<ObjectPtr> getSumList(const QList<ModuleBase_ViewerPrs>& theList1,
-                                       const QList<ModuleBase_ViewerPrs>& theList2)
-{
-  QList<ObjectPtr> aRes;
-  foreach (ModuleBase_ViewerPrs aPrs, theList1) {
-    if (!aRes.contains(aPrs.object()))
-      aRes.append(aPrs.object());
-  }
-  foreach (ModuleBase_ViewerPrs aPrs, theList2) {
-    if (!aRes.contains(aPrs.object()))
-      aRes.append(aPrs.object());
-  }
-  return aRes;
-}
-
 /*!Create and return new instance of XGUI_Module*/
 extern "C" PARTSET_EXPORT ModuleBase_IModule* createModule(ModuleBase_IWorkshop* theWshop)
 {
@@ -93,25 +81,20 @@ extern "C" PARTSET_EXPORT ModuleBase_IModule* createModule(ModuleBase_IWorkshop*
 
 PartSet_Module::PartSet_Module(ModuleBase_IWorkshop* theWshop)
   : ModuleBase_IModule(theWshop), 
-  myIsDragging(false), myRestartingMode(RM_None), myDragDone(false)
+  myRestartingMode(RM_None)
 {
   //myWorkshop = dynamic_cast<XGUI_Workshop*>(theWshop);
-  ModuleBase_IViewer* aViewer = aViewer = theWshop->viewer();
-  connect(aViewer, SIGNAL(mousePress(ModuleBase_IViewWindow*, QMouseEvent*)),
-          this, SLOT(onMousePressed(ModuleBase_IViewWindow*, QMouseEvent*)));
-
-  connect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
-          this, SLOT(onMouseReleased(ModuleBase_IViewWindow*, QMouseEvent*)));
-
-  connect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
-          this, SLOT(onMouseMoved(ModuleBase_IViewWindow*, QMouseEvent*)));
+  mySketchMgr = new PartSet_SketcherMgr(this);
 
   XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(theWshop);
   XGUI_Workshop* aWorkshop = aConnector->workshop();
 
   XGUI_OperationMgr* anOpMgr = aWorkshop->operationMgr();
   connect(anOpMgr, SIGNAL(keyEnterReleased()), this, SLOT(onEnterReleased()));
+  connect(anOpMgr, SIGNAL(operationActivatedByPreselection()),
+          this, SLOT(onOperationActivatedByPreselection()));
 
+  ModuleBase_IViewer* aViewer = theWshop->viewer();
   connect(aViewer, SIGNAL(keyRelease(ModuleBase_IViewWindow*, QKeyEvent*)),
           this, SLOT(onKeyRelease(ModuleBase_IViewWindow*, QKeyEvent*)));
 }
@@ -120,8 +103,6 @@ PartSet_Module::~PartSet_Module()
 {
   if (!myDocumentShapeFilter.IsNull())
     myDocumentShapeFilter.Nullify();
-  if (!myPlaneFilter.IsNull())
-    myPlaneFilter.Nullify();
 }
 
 void PartSet_Module::registerValidators()
@@ -134,14 +115,45 @@ void PartSet_Module::registerValidators()
   aFactory->registerValidator("PartSet_PerpendicularValidator", new PartSet_PerpendicularValidator);
   aFactory->registerValidator("PartSet_ParallelValidator", new PartSet_ParallelValidator);
   aFactory->registerValidator("PartSet_RadiusValidator", new PartSet_RadiusValidator);
+  aFactory->registerValidator("PartSet_RigidValidator", new PartSet_RigidValidator);
   aFactory->registerValidator("PartSet_DifferentObjects", new PartSet_DifferentObjectsValidator);
+  aFactory->registerValidator("PartSet_DifferentShapes", new ModelAPI_ShapeValidator);
+  aFactory->registerValidator("PartSet_SketchValidator", new PartSet_SketchValidator);
+}
+
+void PartSet_Module::registerFilters()
+{
+  //Registering of selection filters
+  XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
+  ModuleBase_FilterFactory* aFactory = aConnector->selectionFilters();
+
+  aFactory->registerFilter("EdgeFilter", new ModuleBase_FilterLinearEdge);
+  aFactory->registerFilter("FaceFilter", new ModuleBase_FilterFace);
+  aFactory->registerFilter("MultiFilter", new ModuleBase_FilterMulti);
+  Handle(SelectMgr_Filter) aSelectFilter = new ModuleBase_FilterNoConsructionSubShapes(workshop());
+  aFactory->registerFilter("NoConstructionSubShapesFilter",
+            new ModuleBase_FilterCustom(aSelectFilter));
 }
 
+void PartSet_Module::registerProperties()
+{
+  Config_PropManager::registerProp("Sketch planes", "planes_size", "Size", Config_Prop::Double,
+                                   PLANE_SIZE);
+  Config_PropManager::registerProp("Sketch planes", "planes_thickness", "Thickness",
+                                   Config_Prop::Integer, SKETCH_WIDTH);
+}
 
-void PartSet_Module::onOperationComitted(ModuleBase_Operation* theOperation) 
+void PartSet_Module::operationCommitted(ModuleBase_Operation* theOperation) 
 {
   if (theOperation->isEditOperation())
     return;
+  // the selection is cleared after commit the create operation
+  // in order to do not use the same selected objects in the restarted operation
+  // for common behaviour, the selection is cleared even if the operation is not restarted
+  Handle(AIS_InteractiveContext) aContext = myWorkshop->viewer()->AISContext();
+  if (!aContext.IsNull())
+    aContext->ClearSelected();
+
   /// Restart sketcher operations automatically
   FeaturePtr aFeature = theOperation->feature();
   std::shared_ptr<SketchPlugin_Feature> aSPFeature = 
@@ -150,6 +162,7 @@ void PartSet_Module::onOperationComitted(ModuleBase_Operation* theOperation)
                      myRestartingMode == RM_EmptyFeatureUsed)) {
     myLastOperationId = theOperation->id();
     myLastFeature = myRestartingMode == RM_LastFeatureUsed ? theOperation->feature() : FeaturePtr();
+    
     launchOperation(myLastOperationId);
   }
   breakOperationSequence();
@@ -162,92 +175,63 @@ void PartSet_Module::breakOperationSequence()
   myRestartingMode = RM_None;
 }
 
-void PartSet_Module::onOperationAborted(ModuleBase_Operation* theOperation)
+void PartSet_Module::operationAborted(ModuleBase_Operation* theOperation)
 {
   breakOperationSequence();
 }
 
-void PartSet_Module::onOperationStarted(ModuleBase_Operation* theOperation)
+void PartSet_Module::operationStarted(ModuleBase_Operation* theOperation)
 {
   if (theOperation->id().toStdString() == SketchPlugin_Sketch::ID()) {
-    // Display all sketcher sub-Objects
-    myCurrentSketch = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(theOperation->feature());
-    XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
-    XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
-
-    for (int i = 0; i < myCurrentSketch->numberOfSubs(); i++) {
-      FeaturePtr aFeature = myCurrentSketch->subFeature(i);
-      std::list<ResultPtr> aResults = aFeature->results();
-      std::list<ResultPtr>::const_iterator aIt;
-      for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
-        aDisplayer->display((*aIt), false);
-      }
-      aDisplayer->display(aFeature);
-    }
-    // Hide sketcher result
-    std::list<ResultPtr> aResults = myCurrentSketch->results();
-    std::list<ResultPtr>::const_iterator aIt;
-    for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
-      aDisplayer->erase((*aIt), false);
-    }
-    aDisplayer->erase(myCurrentSketch);
-
-
-    if (myPlaneFilter.IsNull()) 
-      myPlaneFilter = new ModuleBase_ShapeInPlaneFilter();
-    myWorkshop->viewer()->addSelectionFilter(myPlaneFilter);
-    if (theOperation->isEditOperation()) {
-      // If it is editing of sketch then it means that plane is already defined
-      std::shared_ptr<GeomAPI_Pln> aPln = PartSet_Tools::sketchPlane(myCurrentSketch);
-      myPlaneFilter->setPlane(aPln->impl<gp_Pln>());
-    }
+    mySketchMgr->startSketch(theOperation);
   }
   if (myDocumentShapeFilter.IsNull())
-    myDocumentShapeFilter = new ModuleBase_ShapeDocumentFilter(myWorkshop);
+    myDocumentShapeFilter = new PartSet_GlobalFilter(myWorkshop);
   myWorkshop->viewer()->addSelectionFilter(myDocumentShapeFilter);
 }
 
-void PartSet_Module::onOperationStopped(ModuleBase_Operation* theOperation)
+void PartSet_Module::operationStopped(ModuleBase_Operation* theOperation)
 {
   if (theOperation->id().toStdString() == SketchPlugin_Sketch::ID()) {
-    DataPtr aData = myCurrentSketch->data();
-    if ((!aData) || (!aData->isValid())) {
-      // The sketch was aborted
-      myCurrentSketch = CompositeFeaturePtr();
-      return; 
-    }
-    // Hide all sketcher sub-Objects
-    XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
-    XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer();
-    for (int i = 0; i < myCurrentSketch->numberOfSubs(); i++) {
-      FeaturePtr aFeature = myCurrentSketch->subFeature(i);
-      std::list<ResultPtr> aResults = aFeature->results();
-      std::list<ResultPtr>::const_iterator aIt;
-      for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
-        aDisplayer->erase((*aIt), false);
-      }
-      aDisplayer->erase(aFeature, false);
-    }
-    // Display sketcher result
-    std::list<ResultPtr> aResults = myCurrentSketch->results();
-    std::list<ResultPtr>::const_iterator aIt;
-    for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) {
-      aDisplayer->display((*aIt), false);
-    }
-    aDisplayer->display(myCurrentSketch);
-    
-    myCurrentSketch = CompositeFeaturePtr();
-    myWorkshop->viewer()->removeSelectionFilter(myPlaneFilter);
+    mySketchMgr->stopSketch(theOperation);
   }
   myWorkshop->viewer()->removeSelectionFilter(myDocumentShapeFilter);
 }
 
-void PartSet_Module::onPlaneSelected(const std::shared_ptr<GeomAPI_Pln>& thePln)
+bool PartSet_Module::canDisplayObject(const ObjectPtr& theObject) const
 {
-  myPlaneFilter->setPlane(thePln->impl<gp_Pln>());
+  bool aCanDisplay = false;
+  CompositeFeaturePtr aSketchFeature = mySketchMgr->activeSketch();
+  if (aSketchFeature.get() != NULL) {
+    FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
+
+    // MPV: the second and third conditions to avoid crash on exit for application
+    if (aFeature.get() != NULL && aFeature->data().get() && aFeature->data()->isValid()) {
+      if (aFeature == aSketchFeature) {
+        aCanDisplay = false;
+      }
+      else if (aSketchFeature.get() && aSketchFeature->data().get() &&
+               aSketchFeature->data()->isValid()) {
+        for (int i = 0; i < aSketchFeature->numberOfSubs() && !aCanDisplay; i++) {
+          FeaturePtr aSubFeature = aSketchFeature->subFeature(i);
+          std::list<ResultPtr> aResults = aSubFeature->results();
+          std::list<ResultPtr>::const_iterator aIt;
+          for (aIt = aResults.begin(); aIt != aResults.end() && !aCanDisplay; ++aIt) {
+            if (theObject == (*aIt))
+              aCanDisplay = true;
+          }
+          if (aSubFeature == theObject)
+            aCanDisplay = true;
+        }
+      }
+    }
+  }
+  else {
+    aCanDisplay = ModuleBase_IModule::canDisplayObject(theObject);
+  }
+  return aCanDisplay;
 }
 
-
 void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation)
 {
   ModuleBase_IPropertyPanel* aPanel = theOperation->propertyPanel();
@@ -270,17 +254,18 @@ void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation)
           std::dynamic_pointer_cast<GeomDataAPI_Point2D>(aData->attribute(SketchPlugin_Line::END_ID()));
         if (aPoint) {
           aPnt2dWgt->setPoint(aPoint->x(), aPoint->y());
-          PartSet_Tools::setConstraints(myCurrentSketch, theOperation->feature(), 
+          PartSet_Tools::setConstraints(mySketchMgr->activeSketch(), theOperation->feature(), 
             aWgt->attributeID(), aPoint->x(), aPoint->y());
-          theOperation->propertyPanel()->activateNextWidget(aPnt2dWgt);
+          aPanel->activateNextWidget(aPnt2dWgt);
         }
       }
     }
   } else {
     // Start editing constraint
     if (theOperation->isEditOperation()) {
+      // TODO: #391 - to be removed
       std::string aId = theOperation->id().toStdString();
-      if (sketchOperationIdList().contains(QString(aId.c_str()))) {
+      if (PartSet_SketcherMgr::sketchOperationIdList().contains(QString(aId.c_str()))) {
         if ((aId == SketchPlugin_ConstraintRadius::ID()) ||
             (aId == SketchPlugin_ConstraintLength::ID()) || 
             (aId == SketchPlugin_ConstraintDistance::ID())) {
@@ -302,218 +287,34 @@ void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation)
 
 void PartSet_Module::onSelectionChanged()
 {
-  // Editing of constraints can be done on selection
-  ModuleBase_ISelection* aSelect = myWorkshop->selection();
-  QList<ModuleBase_ViewerPrs> aSelected = aSelect->getSelected();
-  if (aSelected.size() == 1) {
-    ModuleBase_ViewerPrs aPrs = aSelected.first();
-    ObjectPtr aObject = aPrs.object();
-    FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
-    if (aFeature) {
-      std::string aId = aFeature->getKind();
-      if ((aId == SketchPlugin_ConstraintRadius::ID()) ||
-          (aId == SketchPlugin_ConstraintLength::ID()) || 
-          (aId == SketchPlugin_ConstraintDistance::ID())) {
-        editFeature(aFeature);
-      }
-    }
-  }
-}
-
-void PartSet_Module::onMousePressed(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent) 
-{
-  if (!(theEvent->buttons() & Qt::LeftButton))
-    return;
-
   ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
-  // Use only for sketch operations
-  if (aOperation && myCurrentSketch) {
-    if (!PartSet_Tools::sketchPlane(myCurrentSketch))
-      return;
-
-    bool isSketcher = (aOperation->id().toStdString() == SketchPlugin_Sketch::ID());
-    bool isSketchOpe = sketchOperationIdList().contains(aOperation->id());
-
-    // Avoid non-sketch operations
-    if ((!isSketchOpe) && (!isSketcher))
-      return;
-
-    bool isEditing = aOperation->isEditOperation();
-
-    // Ignore creation sketch operation
-    if ((!isSketcher) && (!isEditing))
-      return;
+  if (!aOperation)
+    return;
 
-    if (theEvent->modifiers()) {
-      // If user performs multiselection
-      if (isSketchOpe && (!isSketcher))
-        if (!aOperation->commit())
-          aOperation->abort();
-      return;
-    }
-    // Remember highlighted objects for editing
+  bool isSketcherOp = false;
+  // An edit operation is enable only if the current opeation is the sketch operation
+  if (mySketchMgr->activeSketch()) {
+    if (PartSet_Tools::sketchPlane(mySketchMgr->activeSketch()))
+      isSketcherOp = (aOperation->id().toStdString() == SketchPlugin_Sketch::ID());
+  }
+  if (isSketcherOp) {
+    // Editing of constraints can be done on selection
     ModuleBase_ISelection* aSelect = myWorkshop->selection();
-    QList<ModuleBase_ViewerPrs> aHighlighted = aSelect->getHighlighted();
     QList<ModuleBase_ViewerPrs> aSelected = aSelect->getSelected();
-    myEditingFeatures.clear();
-    myEditingAttr.clear();
-    if ((aHighlighted.size() == 0) && (aSelected.size() == 0)) {
-      if (isSketchOpe && (!isSketcher))
-        // commit previous operation
-        if (!aOperation->commit())
-          aOperation->abort();
-      return;
-    }
-
-    QObjectPtrList aSelObjects = getSumList(aHighlighted, aSelected);
-    if ((aHighlighted.size() == 1) && (aSelected.size() == 0)) {
-      // Move by selected shape (vertex). Can be used only for single selection
-      foreach(ModuleBase_ViewerPrs aPrs, aHighlighted) {
-        FeaturePtr aFeature = ModelAPI_Feature::feature(aHighlighted.first().object());
-        if (aFeature) {
-          myEditingFeatures.append(aFeature);
-          TopoDS_Shape aShape = aPrs.shape();
-          if (!aShape.IsNull()) {
-            if (aShape.ShapeType() == TopAbs_VERTEX) {
-              AttributePtr aAttr = PartSet_Tools::findAttributeBy2dPoint(myEditingFeatures.first(), 
-                                                                         aShape, myCurrentSketch);
-              if (aAttr)
-                myEditingAttr.append(aAttr);
-            }
-          }
-        }
-      }
-    } else {
-      // Provide multi-selection. Can be used only for features
-      foreach (ObjectPtr aObj, aSelObjects) {
-        FeaturePtr aFeature = ModelAPI_Feature::feature(aObj);
-        if (aFeature && (!myEditingFeatures.contains(aFeature)))
-          myEditingFeatures.append(aFeature);
-      }
-
-    }
-    // If nothing highlighted - return
-    if (myEditingFeatures.size() == 0)
-      return;
-
-    if (isSketcher) {
-      myIsDragging = true;
-      get2dPoint(theWnd, theEvent, myCurX, myCurY);
-      myDragDone = false;
-      myWorkshop->viewer()->enableSelection(false);
-      launchEditing();
-
-    } else if (isSketchOpe && isEditing) {
-      // If selected another object
-      aOperation->abort();
-
-      myIsDragging = true;
-      get2dPoint(theWnd, theEvent, myCurX, myCurY);
-      myDragDone = false;
-      myWorkshop->viewer()->enableSelection(false);
-
-      // This is necessary in order to finalize previous operation
-      QApplication::processEvents();
-      launchEditing();
-    }
-  }
-}
-
-
-void PartSet_Module::get2dPoint(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent, 
-                                double& theX, double& theY)
-{
-  Handle(V3d_View) aView = theWnd->v3dView();
-  gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
-  PartSet_Tools::convertTo2D(aPoint, myCurrentSketch, aView, theX, theY);
-}
-
-
-void PartSet_Module::launchEditing()
-{
-  if (myEditingFeatures.size() > 0) {
-    FeaturePtr aFeature = myEditingFeatures.first();
-    std::shared_ptr<SketchPlugin_Feature> aSPFeature = 
-              std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
-    if (aSPFeature) {
-      editFeature(aSPFeature);
-    }
-  }
-}
-
-/// Returns new instance of operation object (used in createOperation for customization)
-ModuleBase_Operation* PartSet_Module::getNewOperation(const std::string& theFeatureId)
-{
-  if (theFeatureId == PartSet_OperationSketch::Type()) {
-    return new PartSet_OperationSketch(theFeatureId.c_str(), this);
-  }
-  return ModuleBase_IModule::getNewOperation(theFeatureId);
-}
-
-
-void PartSet_Module::onMouseReleased(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
-{
-  myWorkshop->viewer()->enableSelection(true);
-  if (myIsDragging) {
-    myIsDragging = false;
-    if (myDragDone) {
-      myWorkshop->currentOperation()->commit();
-      myEditingFeatures.clear();
-      myEditingAttr.clear();
-    }
-  }
-}
-
-
-void PartSet_Module::onMouseMoved(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
-{
-  if (myIsDragging) {
-    ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
-    if (aOperation->id().toStdString() == SketchPlugin_Sketch::ID())
-      return; // No edit operation activated
-
-    static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_MOVED);
-    Handle(V3d_View) aView = theWnd->v3dView();
-    gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
-    double aX, aY;
-    PartSet_Tools::convertTo2D(aPoint, myCurrentSketch, aView, aX, aY);
-    double dX =  aX - myCurX;
-    double dY =  aY - myCurY;
-
-    if ((aOperation->id().toStdString() == SketchPlugin_Line::ID()) &&
-        (myEditingAttr.size() == 1) && 
-        myEditingAttr.first()) {
-      // probably we have prehighlighted point
-      AttributePtr aAttr = myEditingAttr.first();
-      std::string aAttrId = aAttr->id();
-      ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
-      QList<ModuleBase_ModelWidget*> aWidgets = aPanel->modelWidgets();
-      // Find corresponded widget to provide dragging
-      foreach (ModuleBase_ModelWidget* aWgt, aWidgets) {
-        if (aWgt->attributeID() == aAttrId) {
-          PartSet_WidgetPoint2D* aWgt2d = dynamic_cast<PartSet_WidgetPoint2D*>(aWgt);
-          if (aWgt2d) {
-            aWgt2d->setPoint(aWgt2d->x() + dX, aWgt2d->y() + dY);
-            break;
-          }
-        }
-      }
-    } else {
-      foreach(FeaturePtr aFeature, myEditingFeatures) {
-        std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
-          std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
-        if (aSketchFeature) { 
-          aSketchFeature->move(dX, dY);
-          ModelAPI_EventCreator::get()->sendUpdated(aSketchFeature, anEvent);
+    if (aSelected.size() == 1) {
+      ModuleBase_ViewerPrs aPrs = aSelected.first();
+      ObjectPtr aObject = aPrs.object();
+      FeaturePtr aFeature = ModelAPI_Feature::feature(aObject);
+      if (aFeature) {
+        std::string aId = aFeature->getKind();
+        if ((aId == SketchPlugin_ConstraintRadius::ID()) ||
+            (aId == SketchPlugin_ConstraintLength::ID()) || 
+            (aId == SketchPlugin_ConstraintDistance::ID())) {
+          editFeature(aFeature);
         }
       }
-      Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_MOVED));
-      Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
     }
-    myDragDone = true;
-    myCurX = aX;
-    myCurY = aY;
-  }
+  } 
 }
 
 void PartSet_Module::onKeyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent)
@@ -528,6 +329,24 @@ void PartSet_Module::onEnterReleased()
   myRestartingMode = RM_EmptyFeatureUsed;
 }
 
+void PartSet_Module::onOperationActivatedByPreselection()
+{
+  ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
+  if (!aOperation)
+    return;
+
+  // Set final definitions if they are necessary
+  //propertyPanelDefined(aOperation);
+
+  /// Commit sketcher operations automatically
+  FeaturePtr aFeature = aOperation->feature();
+  std::shared_ptr<SketchPlugin_Feature> aSPFeature = 
+            std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
+  if (aSPFeature) {
+    aOperation->commit();
+  }
+}
+
 void PartSet_Module::onNoMoreWidgets()
 {
   ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
@@ -544,23 +363,7 @@ void PartSet_Module::onNoMoreWidgets()
   }
 }
 
-QStringList PartSet_Module::sketchOperationIdList() const
-{
-  QStringList aIds;
-  aIds << SketchPlugin_Line::ID().c_str();
-  aIds << SketchPlugin_Point::ID().c_str();
-  aIds << SketchPlugin_Arc::ID().c_str();
-  aIds << SketchPlugin_Circle::ID().c_str();
-  aIds << SketchPlugin_ConstraintLength::ID().c_str();
-  aIds << SketchPlugin_ConstraintDistance::ID().c_str();
-  aIds << SketchPlugin_ConstraintRigid::ID().c_str();
-  aIds << SketchPlugin_ConstraintRadius::ID().c_str();
-  aIds << SketchPlugin_ConstraintPerpendicular::ID().c_str();
-  aIds << SketchPlugin_ConstraintParallel::ID().c_str();
-  return aIds;
-}
-
-void PartSet_Module::onVertexSelected(ObjectPtr theObject, const TopoDS_Shape& theShape)
+void PartSet_Module::onVertexSelected()
 {
   ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
   if (aOperation->id().toStdString() == SketchPlugin_Line::ID()) {
@@ -583,17 +386,16 @@ QWidget* PartSet_Module::createWidgetByType(const std::string& theType, QWidget*
     PartSet_WidgetSketchLabel* aWgt = new PartSet_WidgetSketchLabel(theParent, theWidgetApi, theParentId);
     aWgt->setWorkshop(aWorkshop);
     connect(aWgt, SIGNAL(planeSelected(const std::shared_ptr<GeomAPI_Pln>&)), 
-      this, SLOT(onPlaneSelected(const std::shared_ptr<GeomAPI_Pln>&)));
+      mySketchMgr, SLOT(onPlaneSelected(const std::shared_ptr<GeomAPI_Pln>&)));
     theModelWidgets.append(aWgt);
     return aWgt->getControl();
 
   } else if (theType == "sketch-2dpoint_selector") {
     PartSet_WidgetPoint2D* aWgt = new PartSet_WidgetPoint2D(theParent, theWidgetApi, theParentId);
     aWgt->setWorkshop(aWorkshop);
-    aWgt->setSketch(myCurrentSketch);
+    aWgt->setSketch(mySketchMgr->activeSketch());
 
-    connect(aWgt, SIGNAL(vertexSelected(ObjectPtr, const TopoDS_Shape&)), 
-      this, SLOT(onVertexSelected(ObjectPtr, const TopoDS_Shape&)));
+    connect(aWgt, SIGNAL(vertexSelected()), this, SLOT(onVertexSelected()));
 
     theModelWidgets.append(aWgt);
     return aWgt->getControl();
@@ -601,7 +403,7 @@ QWidget* PartSet_Module::createWidgetByType(const std::string& theType, QWidget*
   } if (theType == "point2ddistance") {
     PartSet_WidgetPoint2dDistance* aWgt = new PartSet_WidgetPoint2dDistance(theParent, theWidgetApi, theParentId);
     aWgt->setWorkshop(aWorkshop);
-    aWgt->setSketch(myCurrentSketch);
+    aWgt->setSketch(mySketchMgr->activeSketch());
 
     theModelWidgets.append(aWgt);
     return aWgt->getControl();
@@ -609,7 +411,7 @@ QWidget* PartSet_Module::createWidgetByType(const std::string& theType, QWidget*
   } if (theType == "sketch_shape_selector") {
     PartSet_WidgetShapeSelector* aWgt = 
       new PartSet_WidgetShapeSelector(theParent, workshop(), theWidgetApi, theParentId);
-    aWgt->setSketcher(myCurrentSketch);
+    aWgt->setSketcher(mySketchMgr->activeSketch());
 
     theModelWidgets.append(aWgt);
     return aWgt->getControl();
@@ -617,11 +419,12 @@ QWidget* PartSet_Module::createWidgetByType(const std::string& theType, QWidget*
   } if (theType == "sketch_constraint_shape_selector") {
     PartSet_WidgetConstraintShapeSelector* aWgt = 
       new PartSet_WidgetConstraintShapeSelector(theParent, workshop(), theWidgetApi, theParentId);
-    aWgt->setSketcher(myCurrentSketch);
+    aWgt->setSketcher(mySketchMgr->activeSketch());
 
     theModelWidgets.append(aWgt);
     return aWgt->getControl();
 
-  }else
+  } else
     return 0;
 }
+