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

diff --git a/src/PartSet/PartSet_Module.cpp b/src/PartSet/PartSet_Module.cpp
index 9ced217aa..2b92c351a 100644
--- a/src/PartSet/PartSet_Module.cpp
+++ b/src/PartSet/PartSet_Module.cpp
@@ -1,54 +1,64 @@
+// 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_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>
+#include <TopoDS.hxx>
+#include <TopoDS_Shape.hxx>
+#include <BRep_Tool.hxx>
 
 #include <QObject>
 #include <QMouseEvent>
@@ -63,7 +73,6 @@
 #include <QDebug>
 #endif
 
-
 /*!Create and return new instance of XGUI_Module*/
 extern "C" PARTSET_EXPORT ModuleBase_IModule* createModule(ModuleBase_IWorkshop* theWshop)
 {
@@ -72,23 +81,28 @@ extern "C" PARTSET_EXPORT ModuleBase_IModule* createModule(ModuleBase_IWorkshop*
 
 PartSet_Module::PartSet_Module(ModuleBase_IWorkshop* theWshop)
   : ModuleBase_IModule(theWshop), 
-  myIsDragging(false), myRestartingMode(true), 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*)));
+  mySketchMgr = new PartSet_SketcherMgr(this);
 
-  connect(aViewer, SIGNAL(mouseRelease(ModuleBase_IViewWindow*, QMouseEvent*)),
-          this, SLOT(onMouseReleased(ModuleBase_IViewWindow*, QMouseEvent*)));
+  XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(theWshop);
+  XGUI_Workshop* aWorkshop = aConnector->workshop();
 
-  connect(aViewer, SIGNAL(mouseMove(ModuleBase_IViewWindow*, QMouseEvent*)),
-          this, SLOT(onMouseMoved(ModuleBase_IViewWindow*, QMouseEvent*)));
+  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*)));
 }
 
 PartSet_Module::~PartSet_Module()
 {
+  if (!myDocumentShapeFilter.IsNull())
+    myDocumentShapeFilter.Nullify();
 }
 
 void PartSet_Module::registerValidators()
@@ -101,107 +115,138 @@ 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 = 
             std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
-  if (aSPFeature && myRestartingMode) {
+  if (aSPFeature && (myRestartingMode == RM_LastFeatureUsed ||
+                     myRestartingMode == RM_EmptyFeatureUsed)) {
     myLastOperationId = theOperation->id();
-    myLastFeature = theOperation->feature();
+    myLastFeature = myRestartingMode == RM_LastFeatureUsed ? theOperation->feature() : FeaturePtr();
+    
     launchOperation(myLastOperationId);
-  } else {
-    breakOperationSequence();
   }
+  breakOperationSequence();
 }
 
 void PartSet_Module::breakOperationSequence()
 {
   myLastOperationId = "";
   myLastFeature = FeaturePtr();
-  myRestartingMode = false;
-
+  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)
 {
-  myRestartingMode = true;
   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);
+    mySketchMgr->startSketch(theOperation);
   }
+  if (myDocumentShapeFilter.IsNull())
+    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);
+    mySketchMgr->stopSketch(theOperation);
+  }
+  myWorkshop->viewer()->removeSelectionFilter(myDocumentShapeFilter);
+}
+
+bool PartSet_Module::canDisplayObject(const ObjectPtr& theObject) const
+{
+  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;
+        }
       }
-      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();
   }
+  else {
+    aCanDisplay = ModuleBase_IModule::canDisplayObject(theObject);
+  }
+  return aCanDisplay;
 }
 
-
-
 void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation)
 {
+  ModuleBase_IPropertyPanel* aPanel = theOperation->propertyPanel();
+  if ((theOperation->id().toStdString() == SketchPlugin_Sketch::ID()) && 
+    (theOperation->isEditOperation())) {
+    // we have to manually activate the sketch label in edit mode
+      aPanel->activateWidget(aPanel->modelWidgets().first());
+      return;
+  }
+
+  // Restart last operation type 
   if ((theOperation->id() == myLastOperationId) && myLastFeature) {
-    ModuleBase_ModelWidget* aWgt = theOperation->propertyPanel()->activeWidget();
+    ModuleBase_ModelWidget* aWgt = aPanel->activeWidget();
     if (theOperation->id().toStdString() == SketchPlugin_Line::ID()) {
+      // Initialise new line with first point equal to end of previous
       PartSet_WidgetPoint2D* aPnt2dWgt = dynamic_cast<PartSet_WidgetPoint2D*>(aWgt);
       if (aPnt2dWgt) {
         std::shared_ptr<ModelAPI_Data> aData = myLastFeature->data();
@@ -209,185 +254,116 @@ 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 (PartSet_SketcherMgr::sketchOperationIdList().contains(QString(aId.c_str()))) {
+        if ((aId == SketchPlugin_ConstraintRadius::ID()) ||
+            (aId == SketchPlugin_ConstraintLength::ID()) || 
+            (aId == SketchPlugin_ConstraintDistance::ID())) {
+          // Find and activate widget for management of point for dimension line position
+          QList<ModuleBase_ModelWidget*> aWidgets = aPanel->modelWidgets();
+          foreach (ModuleBase_ModelWidget* aWgt, aWidgets) {
+            PartSet_WidgetPoint2D* aPntWgt = dynamic_cast<PartSet_WidgetPoint2D*>(aWgt);
+            if (aPntWgt) {
+              aPanel->activateWidget(aPntWgt);
+              return;
+            }
+          }
+        } 
+      }
+    }
   }
 }
 
 
 void PartSet_Module::onSelectionChanged()
 {
-}
-
-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;
 
-    // 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> aObjects = aSelect->getHighlighted();
-     myEditingFeatures.clear();
-    if (aObjects.size() > 0) {
-      foreach(ModuleBase_ViewerPrs aPrs, aObjects) {
-        FeaturePtr aFeature = ModelAPI_Feature::feature(aObjects.first().object());
-        if (aFeature)
-          myEditingFeatures.append(aFeature);
+    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);
+        }
       }
-    } 
-    // If nothing highlighted - return
-    if (myEditingFeatures.size() == 0)
-      return;
-
-    if (isSketcher) {
-      CompositeFeaturePtr aSketch = 
-        std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(aOperation->feature());
-      if (!PartSet_Tools::sketchPlane(aSketch))
-        return;
-      
-      //myCurrentSketch = aOperation->feature();
-      myIsDragging = true;
-      get2dPoint(theWnd, theEvent, myCurX, myCurY);
-      myDragDone = false;
-      myWorkshop->viewer()->enableSelection(false);
-
-      launchEditing();
-
-    } else if (isSketchOpe && isEditing) {
-      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)
+void PartSet_Module::onKeyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent)
 {
-  Handle(V3d_View) aView = theWnd->v3dView();
-  gp_Pnt aPoint = PartSet_Tools::convertClickToPoint(theEvent->pos(), aView);
-  PartSet_Tools::convertTo2D(aPoint, myCurrentSketch, aView, theX, theY);
+  XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
+  XGUI_OperationMgr* anOpMgr = aConnector->workshop()->operationMgr();
+  anOpMgr->onKeyReleased(theEvent);
 }
 
-
-void PartSet_Module::launchEditing()
+void PartSet_Module::onEnterReleased()
 {
-  if (myEditingFeatures.size() == 1) {
-    FeaturePtr aFeature = myEditingFeatures.first();
-    std::shared_ptr<SketchPlugin_Feature> aSPFeature = 
-              std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
-    if (aSPFeature) {
-      editFeature(aSPFeature);
-    }
-  }
+  myRestartingMode = RM_EmptyFeatureUsed;
 }
 
-/// Returns new instance of operation object (used in createOperation for customization)
-ModuleBase_Operation* PartSet_Module::getNewOperation(const std::string& theFeatureId)
+void PartSet_Module::onOperationActivatedByPreselection()
 {
-  if (theFeatureId == PartSet_OperationSketch::Type()) {
-    return new PartSet_OperationSketch(theFeatureId.c_str(), this);
-  }
-  return ModuleBase_IModule::getNewOperation(theFeatureId);
-}
+  ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
+  if (!aOperation)
+    return;
 
+  // Set final definitions if they are necessary
+  //propertyPanelDefined(aOperation);
 
-void PartSet_Module::onMouseReleased(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
-{
-  if (myIsDragging) {
-    myIsDragging = false;
-    myWorkshop->viewer()->enableSelection(true);
-    if (myDragDone)
-      myWorkshop->currentOperation()->commit();
+  /// 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::onMouseMoved(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent)
+void PartSet_Module::onNoMoreWidgets()
 {
-  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;
-
-    std::shared_ptr<SketchPlugin_Feature> aSketchFeature =
-      std::dynamic_pointer_cast<SketchPlugin_Feature>(aOperation->feature());
-    if (aSketchFeature) { 
-      aSketchFeature->move(dX, dY);
-      ModelAPI_EventCreator::get()->sendUpdated(aSketchFeature, anEvent);
-      Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
-    }/* else { // Alternative case for moving
-      ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
-      QList<ModuleBase_ModelWidget*> aWidgets = aPanel->modelWidgets();
-      foreach(ModuleBase_ModelWidget* aWgt, aWidgets) {
-        PartSet_WidgetPoint2D* aWgt2d = dynamic_cast<PartSet_WidgetPoint2D*>(aWgt);
-        if (aWgt2d) {
-          aWgt2d->setPoint(aWgt2d->x() + dX, aWgt2d->y() + dY);
-        }
-      }
-    }*/
-    myDragDone = true;
-    myCurX = aX;
-    myCurY = aY;
+  ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
+  if (aOperation) {
+    /// Restart sketcher operations automatically
+    FeaturePtr aFeature = aOperation->feature();
+    std::shared_ptr<SketchPlugin_Feature> aSPFeature = 
+              std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
+    if (aSPFeature) {
+      if (myRestartingMode != RM_Forbided)
+        myRestartingMode = RM_LastFeatureUsed;
+      aOperation->commit();
+    }
   }
 }
 
-
-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()) {
@@ -395,7 +371,7 @@ void PartSet_Module::onVertexSelected(ObjectPtr theObject, const TopoDS_Shape& t
     ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
     const QList<ModuleBase_ModelWidget*>& aWidgets = aPanel->modelWidgets();
     if (aWidgets.last() == aPanel->activeWidget()) {
-      breakOperationSequence();
+      myRestartingMode = RM_Forbided;
     }
   }
 }
@@ -409,16 +385,17 @@ QWidget* PartSet_Module::createWidgetByType(const std::string& theType, QWidget*
   if (theType == "sketch-start-label") {
     PartSet_WidgetSketchLabel* aWgt = new PartSet_WidgetSketchLabel(theParent, theWidgetApi, theParentId);
     aWgt->setWorkshop(aWorkshop);
+    connect(aWgt, SIGNAL(planeSelected(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();
@@ -426,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();
@@ -434,11 +411,20 @@ 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();
 
-  }else
+  } if (theType == "sketch_constraint_shape_selector") {
+    PartSet_WidgetConstraintShapeSelector* aWgt = 
+      new PartSet_WidgetConstraintShapeSelector(theParent, workshop(), theWidgetApi, theParentId);
+    aWgt->setSketcher(mySketchMgr->activeSketch());
+
+    theModelWidgets.append(aWgt);
+    return aWgt->getControl();
+
+  } else
     return 0;
 }
+