signals:
/// The operation is started
+ void beforeStarted();
void started();
/// The operation is aborted
+ void beforeAborted();
void aborted();
/// The operation is committed
+ void beforeCommitted();
void committed();
/// The operation is aborted or committed
Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
}
-void ModuleBase_OperationFeature::resumeOperation()
-{
- ModuleBase_Operation::resumeOperation();
- //if (!myIsEditing)
- setCurrentFeature(feature());
- //SessionPtr aMgr = ModelAPI_Session::get();
- //DocumentPtr aDoc = aMgr->activeDocument();
- //aDoc->setCurrentFeature(feature(), false);
-}
-
FeaturePtr ModuleBase_OperationFeature::createFeature(const bool theFlushMessage)
{
if (myParentFeature.get()) {
}
ModelAPI_Session::get()->startOperation(anId.toStdString());
+ emit beforeStarted();
startOperation();
if (!myIsEditing) {
return;
}
}
- /// Set current feature and remeber old current feature
- if (myIsEditing) {
- SessionPtr aMgr = ModelAPI_Session::get();
- DocumentPtr aDoc = aMgr->activeDocument();
- // the parameter of current feature should be false, we should use all feature, not only visible
- // in order to correctly save the previous feature of the nested operation, where the
- // features can be not visible in the tree. The problem case is Edit sketch entitity(line)
- // in the Sketch, created in ExtrusionCut operation. The entity disappears by commit.
- // When sketch entity operation started, the sketch should be cashed here as the current.
- // Otherwise(the flag is true), the ExtrusionCut is cashed, when commit happens, the sketch
- // is disabled, sketch entity is disabled as extrusion cut is created earliest then sketch.
- // As a result the sketch disappears from the viewer. However after commit it is displayed back.
- myPreviousCurrentFeature = aDoc->currentFeature(false);
- aDoc->setCurrentFeature(feature(), false);
- }
-
startOperation();
emit started();
void ModuleBase_OperationFeature::abort()
{
+ emit beforeAborted();
+
// the viewer update should be blocked in order to avoid the features blinking before they are
// hidden
std::shared_ptr<Events_Message> aMsg = std::shared_ptr<Events_Message>(
if (aPropertyPanel)
aPropertyPanel->cleanContent();
- SessionPtr aMgr = ModelAPI_Session::get();
- if (myIsEditing) {
- DocumentPtr aDoc = aMgr->activeDocument();
- bool aIsOp = aMgr->isOperation();
- if (!aIsOp)
- aMgr->startOperation();
- aDoc->setCurrentFeature(myPreviousCurrentFeature, false);//true);
- if (!aIsOp)
- aMgr->finishOperation();
- myPreviousCurrentFeature = FeaturePtr();
- }
abortOperation();
-
stopOperation();
+ SessionPtr aMgr = ModelAPI_Session::get();
aMgr->abortOperation();
emit stopped();
// the viewer update should be unblocked in order to avoid the features blinking before they are
SessionPtr aMgr = ModelAPI_Session::get();
/// Set current feature and remeber old current feature
- if (myIsEditing) {
- setCurrentFeature(myPreviousCurrentFeature);
- /*DocumentPtr aDoc = aMgr->activeDocument();
- bool aIsOp = aMgr->isOperation();
- if (!aIsOp)
- aMgr->startOperation();
- aDoc->setCurrentFeature(myPreviousCurrentFeature, true);
- if (!aIsOp)
- aMgr->finishOperation();*/
- myPreviousCurrentFeature = FeaturePtr();
- }
- else {
- /*CompositeFeaturePtr aCompositeFeature = ModelAPI_Tools::compositeOwner(feature());
- if (aCompositeFeature.get())
- setCurrentFeature(aCompositeFeature);//myPreviousCurrentFeature);
- //else
- // setCurrentFeature(feature());*/
- }
+ emit beforeCommitted();
commitOperation();
aMgr->finishOperation();
return false;
}
-void ModuleBase_OperationFeature::setCurrentFeature(const FeaturePtr& theFeature)
-{
- SessionPtr aMgr = ModelAPI_Session::get();
- DocumentPtr aDoc = aMgr->activeDocument();
- bool aIsOp = aMgr->isOperation();
- if (!aIsOp)
- aMgr->startOperation();
- aDoc->setCurrentFeature(theFeature, false);//true);
- if (!aIsOp)
- aMgr->finishOperation();
-}
-
void ModuleBase_OperationFeature::activateByPreselection()
{
if (myPreSelection.empty())
return myParentFeature;
}
+void ModuleBase_OperationFeature::setPreviousCurrentFeature(const FeaturePtr& theFeature)
+{
+ myPreviousCurrentFeature = theFeature;
+}
+
+FeaturePtr ModuleBase_OperationFeature::previousCurrentFeature()
+{
+ return myPreviousCurrentFeature;
+}
+
void ModuleBase_OperationFeature::initSelection(ModuleBase_ISelection* theSelection,
ModuleBase_IViewer* theViewer)
{
/// \return Currently installed property panel
//ModuleBase_IPropertyPanel* propertyPanel() const { return myPropertyPanel; }
- void setCurrentFeature(const FeaturePtr& theFeature);
-
/// Activates widgets by preselection if it is accepted. Emits signal if the activation is correct
virtual void activateByPreselection();
/// \return Installed parent feature (can be NULL)
CompositeFeaturePtr parentFeature() const;
+ /// Stores the previous to the operation current feature
+ /// \set theFeature a feature
+ void setPreviousCurrentFeature(const FeaturePtr& theFeature);
+
+ /// Returns the previous to the operation current feature
+ /// \return theFeature a feature
+ FeaturePtr previousCurrentFeature();
+
signals:
/// The operation is filled with existing preselection
void activatedByPreselection();
/// Hide feature/results if they were hided on start
virtual void stopOperation();
- /// Virtual method called after operation resume (see resume() method for more description)
- virtual void resumeOperation();
-
/// Creates an operation new feature
/// \param theFlushMessage the flag whether the create message should be flushed
/// \returns the created feature
currentOperation()->postpone();
myOperations.append(theOperation);
+ connect(theOperation, SIGNAL(beforeStarted()), SLOT(onBeforeOperationStarted()));
+ connect(theOperation, SIGNAL(beforeAborted()), SLOT(onBeforeOperationAborted()));
+ connect(theOperation, SIGNAL(beforeCommitted()), SLOT(onBeforeOperationCommitted()));
+
connect(theOperation, SIGNAL(started()), SLOT(onOperationStarted()));
connect(theOperation, SIGNAL(aborted()), SLOT(onOperationAborted()));
connect(theOperation, SIGNAL(committed()), SLOT(onOperationCommitted()));
+
connect(theOperation, SIGNAL(stopped()), SLOT(onOperationStopped()));
connect(theOperation, SIGNAL(resumed()), SLOT(onOperationResumed()));
ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
return isGranted;
}
+void XGUI_OperationMgr::setCurrentFeature(const FeaturePtr& theFeature)
+{
+ SessionPtr aMgr = ModelAPI_Session::get();
+ DocumentPtr aDoc = aMgr->activeDocument();
+ bool aIsOp = aMgr->isOperation();
+ if (!aIsOp)
+ aMgr->startOperation();
+ aDoc->setCurrentFeature(theFeature, false);
+ if (!aIsOp)
+ aMgr->finishOperation();
+}
+
bool XGUI_OperationMgr::canStartOperation(const QString& theId, const bool isAdditionallyGranted)
{
bool aCanStart = true;
}
}
+void XGUI_OperationMgr::onBeforeOperationStarted()
+{
+ ModuleBase_Operation* aCurrentOperation = dynamic_cast<ModuleBase_Operation*>(sender());
+ if (!aCurrentOperation)
+ return;
+
+ /// Set current feature and remeber old current feature
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(aCurrentOperation);
+ if (aFOperation) {
+ SessionPtr aMgr = ModelAPI_Session::get();
+ DocumentPtr aDoc = aMgr->activeDocument();
+ // the parameter of current feature should be false, we should use all feature, not only visible
+ // in order to correctly save the previous feature of the nested operation, where the
+ // features can be not visible in the tree. The problem case is Edit sketch entitity(line)
+ // in the Sketch, created in ExtrusionCut operation. The entity disappears by commit.
+ // When sketch entity operation started, the sketch should be cashed here as the current.
+ // Otherwise(the flag is true), the ExtrusionCut is cashed, when commit happens, the sketch
+ // is disabled, sketch entity is disabled as extrusion cut is created earliest then sketch.
+ // As a result the sketch disappears from the viewer. However after commit it is displayed back.
+ aFOperation->setPreviousCurrentFeature(aDoc->currentFeature(false));
+ if (aFOperation->isEditOperation()) // it should be performed by the feature edit only
+ // in create operation, the current feature is changed by addFeature()
+ aDoc->setCurrentFeature(aFOperation->feature(), false);
+ }
+}
+
void XGUI_OperationMgr::onOperationStarted()
{
ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
emit operationStarted(aSenderOperation);
}
+void XGUI_OperationMgr::onBeforeOperationAborted()
+{
+ onBeforeOperationCommitted();
+}
+
void XGUI_OperationMgr::onOperationAborted()
{
ModuleBase_Operation* aSenderOperation = dynamic_cast<ModuleBase_Operation*>(sender());
emit operationAborted(aSenderOperation);
}
+void XGUI_OperationMgr::onBeforeOperationCommitted()
+{
+ ModuleBase_Operation* aCurrentOperation = dynamic_cast<ModuleBase_Operation*>(sender());
+ if (!aCurrentOperation)
+ return;
+
+ /// Restore the previous current feature
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(aCurrentOperation);
+ if (aFOperation) {
+ if (aFOperation->isEditOperation()) {
+ /// Restore the previous current feature
+ setCurrentFeature(aFOperation->previousCurrentFeature());
+ }
+ else { // create operation
+ // the Top created feature should stays the current. In nested operations, like Line in the Sketch or
+ // Sketch in ExtrusionCut, a previous feature should be restored on commit. It is performed here
+ // in order to perform it in the current transaction without opening a new one.
+ if (myOperations.front() != aFOperation)
+ setCurrentFeature(aFOperation->previousCurrentFeature());
+ }
+ }
+}
+
void XGUI_OperationMgr::onOperationCommitted()
{
// apply state for all features from the stack of operations should be updated
#include "XGUI.h"
#include <ModuleBase_Operation.h>
+#include "ModelAPI_Feature.h"
#include <QList>
#include <QObject>
/// \return boolean result
bool isGrantedOperation(ModuleBase_Operation* theOperation);
+ /// Sets the feature as a current in the document
+ /// \param theFeature a feature
+ void setCurrentFeature(const FeaturePtr& theFeature);
+
public slots:
/// SLOT, that is called by the key in the property panel is clicked.
/// \param theEvent the mouse event
/// If there is a suspended operation, restart it.
void onOperationStopped();
- /// Slot called on operation start
+ /// Slot called before operation started. Stores the previous current feature, set the feature
+ /// of the operation as a current in the document. The previous current feature should be restored
+ /// by the operation abort/commit
+ void onBeforeOperationStarted();
+
+ /// Slot called after operation started
void onOperationStarted();
- /// Slot called on operation abort
+ /// Slot called before operation aborted. Restore the previous current operation
+ void onBeforeOperationAborted();
+
+ /// Slot called after operation aborted
void onOperationAborted();
- /// Slot called on operation commit
+ /// Slot called before operation committed. Restore the previous current operation
+ void onBeforeOperationCommitted();
+
+ /// Slot called after operation committed
void onOperationCommitted();
/// Slot called on operation resume
/// Current workshop
ModuleBase_IWorkshop* myWorkshop;
-
/// Lock/Unlock access to Ok button in property panel
bool myIsValidationLock;
/// Lock/Unlock access to Ok button in property panel
