PartSet_SketcherReetntrantMgr::PartSet_SketcherReetntrantMgr(ModuleBase_IWorkshop* theWorkshop)
: QObject(theWorkshop),
myWorkshop(theWorkshop),
- myIsInternalEditOperation(false),
- myLastOperationId(""),
- myPreviousAttributeID(""),
- myRestartingMode(RM_None)
+ myRestartingMode(RM_None),
+ myIsFlagsBlocked(false),
+ myIsInternalEditOperation(false)
{
}
{
}
-ModuleBase_ModelWidget* PartSet_SketcherReetntrantMgr::activeWidget() const
+ModuleBase_ModelWidget* PartSet_SketcherReetntrantMgr::internalActiveWidget() const
{
ModuleBase_ModelWidget* aWidget = 0;
if (!isActiveMgr())
if (!isActiveMgr())
return aProcessed;
- ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
- if (!aFOperation)
- return aProcessed;
+ aProcessed = myIsInternalEditOperation;
+ resetFlags();
- FeaturePtr aFeature = aFOperation->feature();
- std::shared_ptr<SketchPlugin_Feature> aSPFeature =
- std::dynamic_pointer_cast<SketchPlugin_Feature>(aFeature);
- if (aSPFeature && (myRestartingMode == RM_LastFeatureUsed ||
- myRestartingMode == RM_EmptyFeatureUsed)) {
- myLastOperationId = aFOperation->id().toStdString();
- myLastFeature = myRestartingMode == RM_LastFeatureUsed ? aFOperation->feature() : FeaturePtr();
- PartSet_Module* aModule = module();
- if (!aModule->sketchMgr()->sketchSolverError()) {
- if (!aFOperation->isEditOperation()) {
- FeaturePtr anOperationFeature = aFOperation->feature();
- if (anOperationFeature.get() != NULL) {
- aModule->editFeature(anOperationFeature);
- aProcessed = true;
-
- myIsInternalEditOperation = true;
- // activate selection filters of the first widget in the viewer
- onWidgetActivated();
-
- // activate the last active widget in the Property Panel
- if (!myPreviousAttributeID.empty()) {
- ModuleBase_Operation* anEditOperation = aModule->currentOperation();
- if (anEditOperation) {
- ModuleBase_IPropertyPanel* aPanel = aFOperation->propertyPanel();
- ModuleBase_ModelWidget* aPreviousAttributeWidget = 0;
- QList<ModuleBase_ModelWidget*> aWidgets = aPanel->modelWidgets();
- for (int i = 0, aNb = aWidgets.size(); i < aNb && !aPreviousAttributeWidget; i++) {
- if (aWidgets[i]->attributeID() == myPreviousAttributeID)
- aPreviousAttributeWidget = aWidgets[i];
- }
- // If the current widget is a selector, do nothing, it processes the mouse press
- if (aPreviousAttributeWidget && !aPreviousAttributeWidget->isViewerSelector())
- aPreviousAttributeWidget->focusTo();
- }
- }
- }
- }
- else {
- // the flag should be reset before start to do not react to the widget deactivate
- myIsInternalEditOperation = false;
- aModule->launchOperation(myLastOperationId.c_str());
- breakOperationSequence();
- aProcessed = true;
- }
- }
- }
+ return aProcessed;
+}
- if (!aProcessed)
- breakOperationSequence();
+void PartSet_SketcherReetntrantMgr::operationStarted(ModuleBase_Operation* theOperation)
+{
+ if (!isActiveMgr())
+ return;
- return aProcessed;
+ resetFlags();
}
void PartSet_SketcherReetntrantMgr::operationAborted(ModuleBase_Operation* theOperation)
if (!isActiveMgr())
return;
- if (myIsInternalEditOperation) {
- // abort the created feature, which is currently edited
- SessionPtr aMgr = ModelAPI_Session::get();
- if (aMgr->hasModuleDocument() && aMgr->canUndo()) {
- aMgr->undo();
- workshop()->operationMgr()->updateApplyOfOperations();
- workshop()->updateCommandStatus();
- }
- }
- myIsInternalEditOperation = false;
- breakOperationSequence();
+ resetFlags();
}
-bool PartSet_SketcherReetntrantMgr::processMouseMoved(ModuleBase_IViewWindow*/* theWnd*/,
- QMouseEvent*/* theEvent*/)
+bool PartSet_SketcherReetntrantMgr::processMouseMoved(ModuleBase_IViewWindow* /* theWnd*/,
+ QMouseEvent* /* theEvent*/)
{
bool aProcessed = false;
if (!isActiveMgr())
if (myIsInternalEditOperation) {
PartSet_WidgetPoint2D* aPoint2DWdg = dynamic_cast<PartSet_WidgetPoint2D*>(module()->activeWidget());
if (aPoint2DWdg && aPoint2DWdg->canBeActivatedByMove()) {
- ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
- anOperation->commit();
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+ (myWorkshop->currentOperation());
+ FeaturePtr aLastFeature = myRestartingMode == RM_LastFeatureUsed ? aFOperation->feature() : FeaturePtr();
+ restartOperation();
aProcessed = true;
+
+ if (aLastFeature) {
+ ModuleBase_IPropertyPanel* aPanel = myWorkshop->currentOperation()->propertyPanel();
+ PartSet_WidgetPoint2D* aPoint2DWdg = dynamic_cast<PartSet_WidgetPoint2D*>(aPanel->activeWidget());
+ if (aPoint2DWdg && aPoint2DWdg->canBeActivatedByMove()) {
+ QList<ModuleBase_ViewerPrs> aSelection;
+ aSelection.append(ModuleBase_ViewerPrs(aLastFeature, TopoDS_Shape(), NULL));
+ if (aPoint2DWdg->setSelection(aSelection, true))
+ aPanel->activateNextWidget(aPoint2DWdg);
+ }
+ }
}
}
return aProcessed;
}
-bool PartSet_SketcherReetntrantMgr::processMousePressed(ModuleBase_IViewWindow*/* theWnd*/,
- QMouseEvent*/* theEvent*/)
+bool PartSet_SketcherReetntrantMgr::processMousePressed(ModuleBase_IViewWindow* /* theWnd*/,
+ QMouseEvent* /* theEvent*/)
{
return isActiveMgr() && myIsInternalEditOperation;
}
ModuleBase_ModelWidget* anActiveWidget = anOperation->propertyPanel()->activeWidget();
if (!anActiveWidget || !anActiveWidget->isViewerSelector()) {
- anOperation->commit();
+ restartOperation();
aProcessed = true;
// fill the widget by the mouse event point
return aProcessed;
}
-void PartSet_SketcherReetntrantMgr::propertyPanelDefined(ModuleBase_Operation* theOperation)
+void PartSet_SketcherReetntrantMgr::onWidgetActivated()
{
if (!isActiveMgr())
return;
- ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
- if (!aFOperation)
+ if (!myIsInternalEditOperation)
return;
- ModuleBase_IPropertyPanel* aPanel = aFOperation->propertyPanel();
- if (PartSet_SketcherMgr::isSketchOperation(aFOperation) && (aFOperation->isEditOperation())) {
- // we have to manually activate the sketch label in edit mode
- aPanel->activateWidget(aPanel->modelWidgets().first());
- }
- else if ((aFOperation->id() == myLastOperationId.c_str()) && myLastFeature) {
- // Restart last operation type
- ModuleBase_ModelWidget* aWgt = aPanel->activeWidget();
- PartSet_WidgetPoint2D* aPoint2DWdg = dynamic_cast<PartSet_WidgetPoint2D*>(module()->activeWidget());
- if (aPoint2DWdg && aPoint2DWdg->canBeActivatedByMove()) {
- QList<ModuleBase_ViewerPrs> aSelection;
- aSelection.append(ModuleBase_ViewerPrs(myLastFeature, TopoDS_Shape(), NULL));
- if (aPoint2DWdg->setSelection(aSelection, true))
- aPanel->activateNextWidget(aPoint2DWdg);
- }
+ PartSet_Module* aModule = module();
+ ModuleBase_ModelWidget* aFirstWidget = aModule->activeWidget();
+ ModuleBase_IPropertyPanel* aPanel = aModule->currentOperation()->propertyPanel();
+ if (aFirstWidget != aPanel->activeWidget()) {
+ ModuleBase_WidgetSelector* aWSelector = dynamic_cast<ModuleBase_WidgetSelector*>(aFirstWidget);
+ if (aWSelector)
+ aWSelector->activateSelectionAndFilters(true);
}
}
{
if (!isActiveMgr())
return;
+ XGUI_OperationMgr* anOpMgr = workshop()->operationMgr();
+ if (!anOpMgr->isApplyEnabled())
+ return;
- ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
- if (anOperation) {
- if (PartSet_SketcherMgr::isNestedSketchOperation(anOperation)) {
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+ (myWorkshop->currentOperation());
+ if (aFOperation) {
+ if (PartSet_SketcherMgr::isNestedSketchOperation(aFOperation)) {
+ XGUI_OperationMgr* anOpMgr = workshop()->operationMgr();
if (myRestartingMode != RM_Forbided) {
myRestartingMode = RM_LastFeatureUsed;
- myPreviousAttributeID = thePreviousAttributeID;
+ startInternalEdit(thePreviousAttributeID);
}
- XGUI_Workshop* aWorkshop = workshop();
- XGUI_OperationMgr* anOpMgr = aWorkshop->operationMgr();
- // do nothing if the feature can not be applyed
- if (anOpMgr->isApplyEnabled())
- anOperation->commit();
+ else
+ aFOperation->commit();
}
}
}
}
}
-void PartSet_SketcherReetntrantMgr::enterReleased()
+void PartSet_SketcherReetntrantMgr::onEnterReleased()
{
if (!isActiveMgr())
return;
ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
(myWorkshop->currentOperation());
- if (/*!aFOperation->isEditOperation() || */myIsInternalEditOperation)
+ if (myIsInternalEditOperation)
myRestartingMode = RM_EmptyFeatureUsed;
}
return !isActiveMgr() || myRestartingMode == RM_None;
}
-void PartSet_SketcherReetntrantMgr::onWidgetActivated()
-{
- if (!isActiveMgr())
- return;
-
- if (!myIsInternalEditOperation)
- return;
-
- PartSet_Module* aModule = module();
- ModuleBase_ModelWidget* aFirstWidget = aModule->activeWidget();
- ModuleBase_IPropertyPanel* aPanel = aModule->currentOperation()->propertyPanel();
- if (aFirstWidget != aPanel->activeWidget()) {
- ModuleBase_WidgetSelector* aWSelector = dynamic_cast<ModuleBase_WidgetSelector*>(aFirstWidget);
- if (aWSelector)
- aWSelector->activateSelectionAndFilters(true);
- }
-}
-
bool PartSet_SketcherReetntrantMgr::isActiveMgr() const
{
PartSet_SketcherMgr* aSketcherMgr = module()->sketchMgr();
PartSet_SketcherMgr::isNestedSketchOperation(aCurrentOperation);
}
-void PartSet_SketcherReetntrantMgr::breakOperationSequence()
+void PartSet_SketcherReetntrantMgr::startInternalEdit(const std::string& thePreviousAttributeID)
{
- myLastOperationId = "";
- myLastFeature = FeaturePtr();
- myRestartingMode = RM_None;
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+ (myWorkshop->currentOperation());
+
+ aFOperation->setEditOperation();
+ FeaturePtr anOperationFeature = aFOperation->feature();
+ if (anOperationFeature.get() != NULL) {
+
+ myIsInternalEditOperation = true;
+ // activate selection filters of the first widget in the viewer
+ onWidgetActivated();
+
+ // activate the last active widget in the Property Panel
+ if (!thePreviousAttributeID.empty()) {
+ ModuleBase_Operation* anEditOperation = module()->currentOperation();
+ if (anEditOperation) {
+ ModuleBase_IPropertyPanel* aPanel = aFOperation->propertyPanel();
+ ModuleBase_ModelWidget* aPreviousAttributeWidget = 0;
+ QList<ModuleBase_ModelWidget*> aWidgets = aPanel->modelWidgets();
+ for (int i = 0, aNb = aWidgets.size(); i < aNb && !aPreviousAttributeWidget; i++) {
+ if (aWidgets[i]->attributeID() == thePreviousAttributeID)
+ aPreviousAttributeWidget = aWidgets[i];
+ }
+ // If the current widget is a selector, do nothing, it processes the mouse press
+ if (aPreviousAttributeWidget && !aPreviousAttributeWidget->isViewerSelector())
+ aPreviousAttributeWidget->focusTo();
+ }
+ }
+ }
+}
+
+void PartSet_SketcherReetntrantMgr::restartOperation()
+{
+ if (myIsInternalEditOperation) {
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(
+ myWorkshop->currentOperation());
+ if (aFOperation) {
+ myIsFlagsBlocked = true;
+ aFOperation->commit();
+ module()->launchOperation(aFOperation->id());
+ myIsFlagsBlocked = false;
+ resetFlags();
+ }
+ }
+}
+
+void PartSet_SketcherReetntrantMgr::resetFlags()
+{
+ if (!myIsFlagsBlocked) {
+ myIsInternalEditOperation = false;
+ myRestartingMode = RM_None;
+ }
}
XGUI_Workshop* PartSet_SketcherReetntrantMgr::workshop() const
/// \ingroup PartSet_SketcherReetntrantMgr
/// It provides reentrant create operations in sketch, that is when all inputs are valid,
/// automatic validation of the creation and switch the created entity to edit mode
-/// ('internal' edit operation),
-/// with the ability to simultaneously create the next entity of same type (re-entrance of the operation).
+/// ('internal' edit operation), with the ability to simultaneously create the next entity
+/// of same type (re-entrance of the operation).
/// OK valids the current edition and exits from the operation (no re-entrance).
/// Cancel removes (undo) the entity currently edited and exits from the operation (no re-entrance).
class PARTSET_EXPORT PartSet_SketcherReetntrantMgr : public QObject
virtual ~PartSet_SketcherReetntrantMgr();
public:
- /// If the internal edit operation is started, this is the first widget of the operation
- ModuleBase_ModelWidget* activeWidget() const;
-
- /// Restarts sketcher operation automatically. If the commited operation is created, it starts
- /// an 'internal' edit operation for the created feature. If an 'internal' operation is committed,
- /// a create operation for a new feature with the current feature kind is started.
- /// Some internal flags are taken into accout, such as whether the previous feature should be
- /// used for initialization of created one or whether the restart of operation is forbidden.
- /// \param theOperation a committed operation
- /// \return true if an operation restarted
+ /// Returns a first widget of the current opeation if the internal edit operation is active
+ /// or return null. If the current widget of the operation is a viewer selector, it returns null.
+ ModuleBase_ModelWidget* internalActiveWidget() const;
+
+ /// Resets the internal flags
+ /// \param theOperation a started operation
+ void operationStarted(ModuleBase_Operation* theOperation);
+
+ /// Resets the internal flags
+ /// \param theOperation a started operation
+ /// \return state whether the internal edit operation was active
bool operationCommitted(ModuleBase_Operation* theOperation);
- /// \param theOperation a committed operation
+ /// Resets the internal flags
+ /// \param theOperation a started operation
void operationAborted(ModuleBase_Operation* theOperation);
/// Return true if the manager processes the mouse move event
/// It happens if the current operation is an internal edit operation and the first
- /// control can be filled by the mouse move event. The operation is committed.
+ /// control can be filled by the mouse move event. The operation is restarted.
/// \return true if operation is committed.
bool processMouseMoved(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
/// Return true if the manager processes the mouse enter event
/// It happens if the current operation is an internal edit operation.
- /// The operation is committed.
+ /// The operation is restarted. If the first widget of the started operation is
+ /// the point 2d, it processes this mouse event
/// \return true if operation is committed.
bool processMouseReleased(ModuleBase_IViewWindow* theWnd, QMouseEvent* theEvent);
- /// Activates the operation widgets relatively the internal reentrant flags
- void propertyPanelDefined(ModuleBase_Operation* theOperation);
-
-
- /// Processing of vertex selected, if the feature is line, save flags to stop reentrant operation
- void vertexSelected();
-
- /// It is called by enter key released
- /// Set a specific type of restarting the current operation
- void enterReleased();
-
/// It is called by the current operation filling with the preselection.
/// Returns false if the reentrant mode of the operation is not empty.
bool canBeCommittedByPreselection();
private slots:
/// SLOT, that is called by a widget activating in the property panel
- /// If the 'internal' edit operation is started, it activates the first control selection
+ /// If the 'internal' edit operation is started, it activates the first widget selection
void onWidgetActivated();
/// SLOT, that is called by no more widget signal emitted by property panel
- /// Set a specific flag to restart the sketcher operation
+ /// Start an internal edit operation or, if the internal flag is forbided, commits
+ /// the current operation
+ /// \param thePreviousAttributeID an index of the previous active attribute
void onNoMoreWidgets(const std::string& thePreviousAttributeID);
- /// Processing of vertex selected
+ /// Processing of vertex selected. Set an internal reentrant flag to forbiddent state if
+ /// the current feature is a line and there are not obligate widgets anymore
void onVertexSelected();
+ /// SLOT, that is called by enter key released
+ /// Set a specific type of restarting the current operation to do not use the feature
+ /// for initialization of a new started operation.
+ void onEnterReleased();
+
private:
/// Returns true if the current operation is a sketch or a nested sketch operation
bool isActiveMgr() const;
+ /// Sets the focus to the last control of the property panel and activates selection
+ /// of the first widget to can select first value of the next create operation
+ /// \param thePreviousAttributeID an index of the previous attribute to set focus to this widget
+ void startInternalEdit(const std::string& thePreviousAttributeID);
+
+ /// Commits the current operation and launches a new with the commited operation feature index
+ void restartOperation();
+
/// Breaks sequense of automatically resterted operations
- void breakOperationSequence();
+ void resetFlags();
/// Returns the workshop
XGUI_Workshop* workshop() const;
private:
ModuleBase_IWorkshop* myWorkshop; /// the workshop
+ RestartingMode myRestartingMode; /// automatical restarting mode flag
+ bool myIsFlagsBlocked; /// true when reset of flags should not be perfromed
bool myIsInternalEditOperation; /// true when the 'internal' edit is started
-
- std::string myLastOperationId;
- FeaturePtr myLastFeature;
-
- std::string myPreviousAttributeID;
- RestartingMode myRestartingMode; /// Automatical restarting mode flag
};
#endif
