X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Module.cpp;h=48e605f5540c63294a3fbde59b0f7db6311f25b5;hb=7ae872f97b92ea2f2b4789d05883f19db44c08ac;hp=64674f19d028bb725ba9cf1c8cc3d5356a927c09;hpb=7b4a6a2a335d41a647e0f6a6becb7c23df042be1;p=modules%2Fshaper.git diff --git a/src/PartSet/PartSet_Module.cpp b/src/PartSet/PartSet_Module.cpp index 64674f19d..48e605f55 100755 --- a/src/PartSet/PartSet_Module.cpp +++ b/src/PartSet/PartSet_Module.cpp @@ -4,18 +4,23 @@ #include "PartSet_WidgetSketchLabel.h" #include "PartSet_Validators.h" #include "PartSet_Tools.h" +#include "PartSet_PreviewPlanes.h" #include "PartSet_WidgetPoint2d.h" #include "PartSet_WidgetPoint2dDistance.h" +#include "PartSet_WidgetPoint2DFlyout.h" #include "PartSet_WidgetShapeSelector.h" -#include "PartSet_WidgetPoint2dAngle.h" #include "PartSet_WidgetMultiSelector.h" +#include "PartSet_WidgetMultiSelectorComposite.h" #include "PartSet_WidgetEditor.h" #include "PartSet_WidgetFileSelector.h" #include "PartSet_WidgetSketchCreator.h" #include "PartSet_SketcherMgr.h" +#include "PartSet_SketcherReetntrantMgr.h" #include "PartSet_MenuMgr.h" #include "PartSet_CustomPrs.h" #include "PartSet_IconFactory.h" +#include "PartSet_WidgetChoice.h" +#include "PartSet_OverconstraintListener.h" #include "PartSet_Filters.h" #include "PartSet_FilterInfinite.h" @@ -34,22 +39,14 @@ #include #include #include - -#include -#include -#include -#include -#include -#include -#include - +#include +#include #include #include #include #include #include -#include #include #include @@ -68,13 +65,10 @@ #include #include #include +#include #include #include -#include -#include -#include -#include #include #include #include @@ -104,6 +98,7 @@ #include #include #include +#include #include #include @@ -121,24 +116,17 @@ extern "C" PARTSET_EXPORT ModuleBase_IModule* createModule(ModuleBase_IWorkshop* } PartSet_Module::PartSet_Module(ModuleBase_IWorkshop* theWshop) - : ModuleBase_IModule(theWshop), - myRestartingMode(RM_None), myVisualLayerId(0), myHasConstraintShown(true) +: ModuleBase_IModule(theWshop), + myVisualLayerId(0) { new PartSet_IconFactory(); mySketchMgr = new PartSet_SketcherMgr(this); -#ifdef ModuleDataModel - myDataModel = new PartSet_DocumentDataModel(this); -#endif + mySketchReentrantMgr = new PartSet_SketcherReetntrantMgr(theWshop); XGUI_ModuleConnector* aConnector = dynamic_cast(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*))); @@ -146,15 +134,30 @@ PartSet_Module::PartSet_Module(ModuleBase_IWorkshop* theWshop) SLOT(onViewTransformed(int))); connect(aViewer, SIGNAL(viewCreated(ModuleBase_IViewWindow*)), SLOT(onViewCreated(ModuleBase_IViewWindow*))); - myMenuMgr = new PartSet_MenuMgr(this); myCustomPrs = new PartSet_CustomPrs(theWshop); + myOverconstraintListener = new PartSet_OverconstraintListener(theWshop); + Events_Loop* aLoop = Events_Loop::loop(); aLoop->registerListener(this, Events_Loop::eventByName(EVENT_DOCUMENT_CHANGED)); mySelectionFilters.Append(new PartSet_GlobalFilter(myWorkshop)); mySelectionFilters.Append(new PartSet_FilterInfinite(myWorkshop)); + + myHasConstraintShown[PartSet_Tools::Geometrical] = true; + myHasConstraintShown[PartSet_Tools::Dimensional] = true; + myHasConstraintShown[PartSet_Tools::Expressions] = false; + + Config_PropManager::registerProp("Visualization", "operation_parameter_color", + "Reference shape wireframe color in operation", Config_Prop::Color, + PartSet_CustomPrs::OPERATION_PARAMETER_COLOR()); + Config_PropManager::registerProp("Visualization", "operation_result_color", + "Result shape wireframe color in operation", Config_Prop::Color, + PartSet_CustomPrs::OPERATION_RESULT_COLOR()); + Config_PropManager::registerProp("Visualization", "operation_highlight_color", + "Multi selector item color in operation", Config_Prop::Color, + PartSet_CustomPrs::OPERATION_HIGHLIGHT_COLOR()); } PartSet_Module::~PartSet_Module() @@ -166,6 +169,7 @@ PartSet_Module::~PartSet_Module() aFilter.Nullify(); } delete myCustomPrs; + delete myOverconstraintListener; } void PartSet_Module::activateSelectionFilters() @@ -188,6 +192,16 @@ void PartSet_Module::deactivateSelectionFilters() } } +void PartSet_Module::storeSelection() +{ + sketchMgr()->storeSelection(); +} + +void PartSet_Module::restoreSelection() +{ + sketchMgr()->restoreSelection(); +} + void PartSet_Module::registerValidators() { //Registering of validators @@ -204,28 +218,11 @@ void PartSet_Module::registerValidators() aFactory->registerValidator("PartSet_TangentSelection", new PartSet_TangentSelection); aFactory->registerValidator("PartSet_FilletSelection", new PartSet_FilletSelection); aFactory->registerValidator("PartSet_AngleSelection", new PartSet_AngleSelection); + aFactory->registerValidator("PartSet_EqualSelection", new PartSet_EqualSelection); + aFactory->registerValidator("PartSet_CollinearSelection", new PartSet_CollinearSelection); + aFactory->registerValidator("PartSet_MiddlePointSelection", new PartSet_MiddlePointSelection); aFactory->registerValidator("PartSet_DifferentObjects", new PartSet_DifferentObjectsValidator); aFactory->registerValidator("PartSet_CoincidentAttr", new PartSet_CoincidentAttr); - - aFactory->registerValidator("GeomValidators_DifferentShapes", new GeomValidators_DifferentShapes); - aFactory->registerValidator("GeomValidators_ShapeType", new GeomValidators_ShapeType); - aFactory->registerValidator("GeomValidators_Face", new GeomValidators_Face); - aFactory->registerValidator("GeomValidators_Finite", new GeomValidators_Finite); - - aFactory->registerValidator("GeomValidators_ConstructionComposite", - new GeomValidators_ConstructionComposite); - - aFactory->registerValidator("GeomValidators_ZeroOffset", - new GeomValidators_ZeroOffset); - - aFactory->registerValidator("GeomValidators_BooleanArguments", - new GeomValidators_BooleanArguments); - - aFactory->registerValidator("PartSet_SketchEntityValidator", - new PartSet_SketchEntityValidator); - - aFactory->registerValidator("GeomValidators_Different", - new GeomValidators_Different); } void PartSet_Module::registerFilters() @@ -241,52 +238,125 @@ void PartSet_Module::registerProperties() PLANE_SIZE); Config_PropManager::registerProp("Sketch planes", "planes_thickness", "Thickness", Config_Prop::Integer, SKETCH_WIDTH); + Config_PropManager::registerProp("Sketch planes", "rotate_to_plane", "Rotate to plane when selected", + Config_Prop::Boolean, "false"); } -void PartSet_Module::onOperationCommitted(ModuleBase_Operation* theOperation) +void PartSet_Module::connectToPropertyPanel(ModuleBase_ModelWidget* theWidget, const bool isToConnect) +{ + mySketchMgr->connectToPropertyPanel(theWidget, isToConnect); +} + +void PartSet_Module::operationCommitted(ModuleBase_Operation* theOperation) { if (PartSet_SketcherMgr::isNestedSketchOperation(theOperation)) { mySketchMgr->commitNestedSketch(theOperation); } - ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); - if (!aFOperation || aFOperation->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 - XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); - XGUI_Workshop* aWorkshop = aConnector->workshop(); - aWorkshop->selector()->clearSelection(); - /// Restart sketcher operations automatically - FeaturePtr aFeature = aFOperation->feature(); - std::shared_ptr aSPFeature = - std::dynamic_pointer_cast(aFeature); - if (aSPFeature && (myRestartingMode == RM_LastFeatureUsed || - myRestartingMode == RM_EmptyFeatureUsed)) { - myLastOperationId = aFOperation->id(); - myLastFeature = myRestartingMode == RM_LastFeatureUsed ? aFOperation->feature() : FeaturePtr(); - if (!sketchMgr()->sketchSolverError()) - launchOperation(myLastOperationId); + if (!mySketchReentrantMgr->operationCommitted(theOperation)) { + + ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); + if (aFOperation && !aFOperation->isEditOperation()) { + // 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 + getWorkshop()->selector()->clearSelection(); + } } - breakOperationSequence(); } -void PartSet_Module::breakOperationSequence() +void PartSet_Module::operationAborted(ModuleBase_Operation* theOperation) { - myLastOperationId = ""; - myLastFeature = FeaturePtr(); - myRestartingMode = RM_None; + /// Restart sketcher operations automatically + mySketchReentrantMgr->operationAborted(theOperation); } -void PartSet_Module::onOperationAborted(ModuleBase_Operation* theOperation) +void PartSet_Module::operationStarted(ModuleBase_Operation* theOperation) { - breakOperationSequence(); + ModuleBase_IWorkshop* anIWorkshop = workshop(); + if (!theOperation->getDescription()->hasXmlRepresentation()) { //!< No need for property panel + anIWorkshop->updateCommandStatus(); + } + else { + ModuleBase_OperationFeature* aFOperation = dynamic_cast + (theOperation); + if (aFOperation) { + XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(anIWorkshop); + XGUI_PropertyPanel* aPropertyPanel = aWorkshop->propertyPanel(); + ModuleBase_ModelWidget* aFilledWidget = 0; + bool aPostonedWidgetActivation = false; + FeaturePtr aFeature = aFOperation->feature(); + + std::string aGreedAttributeId = ModuleBase_Tools::findGreedAttribute(anIWorkshop, aFeature); + // if there is a greed attribute, automatic commit by preselection for this feature is prohibited + aWorkshop->setPropertyPanel(aFOperation); + + // filling the operation values by the current selection + // if the operation can be committed after the controls filling, the method perform should + // be stopped. Otherwise unnecessary presentations can be shown(e.g. operation prs in sketch) + bool isOperationCommitted = false; + if (!aFOperation->isEditOperation()) { + aFilledWidget = aFOperation->activateByPreselection(aGreedAttributeId); + if (currentOperation() != aFOperation) + isOperationCommitted = true; + else { + if (aGreedAttributeId.empty()) { + // a signal should be emitted before the next widget activation + // because, the activation of the next widget will give a focus to the widget. As a result + // the value of the widget is initialized. And commit may happens until the value is entered. + if (aFilledWidget) { + if (mySketchReentrantMgr->canBeCommittedByPreselection()) + isOperationCommitted = mySketchMgr->operationActivatedByPreselection(); + // activate the next obligatory widget + if (!isOperationCommitted) + aPropertyPanel->activateNextWidget(aFilledWidget); + } + } + else { // there is a greed widget + const QList& aWidgets = aPropertyPanel->modelWidgets(); + std::string aFirstAttributeId = aWidgets.front()->attributeID(); + // activate next widget after greeded if it is the first widget in the panel + // else the first panel widget is already activated by operation start + if (aFirstAttributeId == aGreedAttributeId) + aPostonedWidgetActivation = true; + } + } + } if (!isOperationCommitted) { + anIWorkshop->updateCommandStatus(); + aWorkshop->connectToPropertyPanel(true); + operationStartedInternal(aFOperation); + + // the objects of the current operation should be deactivated + QObjectPtrList anObjects; + anObjects.append(aFeature); + std::list aResults = aFeature->results(); + std::list::const_iterator aIt; + for (aIt = aResults.begin(); aIt != aResults.end(); ++aIt) { + anObjects.append(*aIt); + } + QObjectPtrList::const_iterator anIt = anObjects.begin(), aLast = anObjects.end(); + for (; anIt != aLast; anIt++) + aWorkshop->deactivateActiveObject(*anIt, false); + if (anObjects.size() > 0) { + XGUI_Displayer* aDisplayer = aWorkshop->displayer(); + aDisplayer->updateViewer(); + } + } + if (aPostonedWidgetActivation) { + // if the widget is an empty in the chain of activated widgets, the current operation + // is restarted. It should be performed after functionality of the operation starting + aPropertyPanel->activateNextWidget(aFilledWidget); + } + } + } } -void PartSet_Module::onOperationStarted(ModuleBase_Operation* theOperation) +void PartSet_Module::operationStartedInternal(ModuleBase_Operation* theOperation) { + /// Restart sketcher operations automatically + mySketchReentrantMgr->operationStarted(theOperation); + if (PartSet_SketcherMgr::isSketchOperation(theOperation)) { mySketchMgr->startSketch(theOperation); } @@ -295,36 +365,46 @@ void PartSet_Module::onOperationStarted(ModuleBase_Operation* theOperation) } ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); - if (aFOperation) - myCustomPrs->activate(aFOperation->feature(), true); + if (aFOperation) { + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeArguments, true); + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeResults, true); + } } -void PartSet_Module::onOperationResumed(ModuleBase_Operation* theOperation) +void PartSet_Module::operationResumed(ModuleBase_Operation* theOperation) { - ModuleBase_IModule::onOperationResumed(theOperation); + ModuleBase_IModule::operationResumed(theOperation); ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); - if (aFOperation) - myCustomPrs->activate(aFOperation->feature(), true); + if (aFOperation) { + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeArguments, true); + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeResults, true); + } } -void PartSet_Module::onOperationStopped(ModuleBase_Operation* theOperation) +void PartSet_Module::operationStopped(ModuleBase_Operation* theOperation) { - bool isModified = myCustomPrs->deactivate(false); + bool isModifiedArgs = myCustomPrs->deactivate(ModuleBase_IModule::CustomizeArguments, false); + bool isModifiedResults = myCustomPrs->deactivate(ModuleBase_IModule::CustomizeResults, false); + bool isModified = isModifiedArgs || isModifiedResults; - if (PartSet_SketcherMgr::isSketchOperation(theOperation)) { - mySketchMgr->stopSketch(theOperation); - } - else if (PartSet_SketcherMgr::isNestedSketchOperation(theOperation)) { + if (PartSet_SketcherMgr::isNestedSketchOperation(theOperation)) { mySketchMgr->stopNestedSketch(theOperation); } + //VSV: Viewer is updated on feature update and redisplay if (isModified) { XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer(); aDisplayer->updateViewer(); } - mySketchMgr->onShowConstraintsToggle(myHasConstraintShown); + + QMap::const_iterator anIt = myHasConstraintShown.begin(), + aLast = myHasConstraintShown.end(); + for (; anIt != aLast; anIt++) { + myHasConstraintShown[anIt.key()]; + mySketchMgr->updateBySketchParameters(anIt.key(), anIt.value()); + } } ModuleBase_Operation* PartSet_Module::currentOperation() const @@ -361,10 +441,10 @@ bool PartSet_Module::canRedo() const bool PartSet_Module::canApplyAction(const ObjectPtr& theObject, const QString& theActionId) const { bool aValid = true; - if (theActionId == "DELETE_CMD" || theActionId == "MOVE_CMD") { + if (theActionId == "MOVE_CMD") { FeaturePtr aFeature = ModelAPI_Feature::feature(theObject); if (aFeature) { - // part features are removed in the PartSet module only. + // part features can not be moved in the history. if (aFeature->getKind() == PartSetPlugin_Part::ID()) aValid = false; } @@ -372,11 +452,6 @@ bool PartSet_Module::canApplyAction(const ObjectPtr& theObject, const QString& t return aValid; } -bool PartSet_Module::canCommitOperation() const -{ - return mySketchMgr->canCommitOperation(); -} - bool PartSet_Module::canEraseObject(const ObjectPtr& theObject) const { // the sketch manager put the restriction to the objects erase @@ -389,6 +464,11 @@ bool PartSet_Module::canDisplayObject(const ObjectPtr& theObject) const return mySketchMgr->canDisplayObject(theObject); } +void PartSet_Module::processHiddenObject(const std::list& theObjects) +{ + mySketchMgr->processHiddenObject(theObjects); +} + bool PartSet_Module::canActivateSelection(const ObjectPtr& theObject) const { bool aCanActivate = ModuleBase_IModule::canActivateSelection(theObject); @@ -418,24 +498,23 @@ void PartSet_Module::updateViewerMenu(const QMap& theStdActio QString PartSet_Module::getFeatureError(const FeaturePtr& theFeature) { QString anError = ModuleBase_IModule::getFeatureError(theFeature); - if (anError.isEmpty()) anError = sketchMgr()->getFeatureError(theFeature); - if (anError.isEmpty()) { - XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); - XGUI_OperationMgr* anOpMgr = aConnector->workshop()->operationMgr(); - - if (anOpMgr->isValidationLocked()) { - ModuleBase_OperationFeature* aFOperation = dynamic_cast - (anOpMgr->currentOperation()); - if (!aFOperation || theFeature == aFOperation->feature()) - anError = "Validation is locked by the current operation"; - } - } return anError; } +void PartSet_Module::grantedOperationIds(ModuleBase_Operation* theOperation, + QStringList& theIds) const +{ + myMenuMgr->grantedOperationIds(theOperation, theIds); + + if (PartSet_SketcherMgr::isSketchOperation(theOperation)) { + XGUI_Workshop* aWorkshop = getWorkshop(); + theIds.append(aWorkshop->contextMenuMgr()->action("DELETE_CMD")->text()); + } +} + void PartSet_Module::activeSelectionModes(QIntList& theModes) { theModes.clear(); @@ -457,8 +536,7 @@ void PartSet_Module::clearViewer() { myCustomPrs->clearPrs(); - XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); - XGUI_Workshop* aWorkshop = aConnector->workshop(); + XGUI_Workshop* aWorkshop = getWorkshop(); XGUI_Displayer* aDisplayer = aWorkshop->displayer(); aDisplayer->deactivateSelectionFilters(); } @@ -470,34 +548,54 @@ void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation) 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()); - return; - } + // we have to manually activate the sketch label in edit mode + if (PartSet_SketcherMgr::isSketchOperation(aFOperation) && (aFOperation->isEditOperation())) + aPanel->activateWidget(aPanel->modelWidgets().first()); +} - // Restart last operation type - if ((aFOperation->id() == myLastOperationId) && myLastFeature) { - ModuleBase_ModelWidget* aWgt = aPanel->activeWidget(); - if (aFOperation->id().toStdString() == SketchPlugin_Line::ID()) { - // Initialise new line with first point equal to end of previous - PartSet_WidgetPoint2D* aPnt2dWgt = dynamic_cast(aWgt); - if (aPnt2dWgt) { - std::shared_ptr aData = myLastFeature->data(); - std::shared_ptr aPoint = - std::dynamic_pointer_cast(aData->attribute(SketchPlugin_Line::END_ID())); - if (aPoint) { - aPnt2dWgt->setPoint(aPoint->x(), aPoint->y()); - PartSet_Tools::setConstraints(mySketchMgr->activeSketch(), aFOperation->feature(), - aWgt->attributeID(), aPoint->x(), aPoint->y()); - aPanel->activateNextWidget(aPnt2dWgt); +bool PartSet_Module::createWidgets(ModuleBase_Operation* theOperation, + QList& theWidgets) const +{ + bool aProcessed = false; + + ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); + XGUI_Workshop* aWorkshop = getWorkshop(); + XGUI_PropertyPanel* aPropertyPanel = aWorkshop->propertyPanel(); + if (mySketchMgr->activeSketch().get() && aFOperation && aPropertyPanel) { + ModuleBase_ISelection* aSelection = workshop()->selection(); + // click on a point in sketch leads here with the point is highlighted, not yet selected + QList aPreselection = aSelection->getHighlighted(); + if (aPreselection.size() == 1) { + ModuleBase_ViewerPrs aSelectedPrs = aPreselection[0]; + ObjectPtr anObject = aSelectedPrs.object(); + + FeaturePtr aFeature = ModelAPI_Feature::feature(anObject); + FeaturePtr anOpFeature = aFOperation->feature(); + GeomShapePtr aShape = aSelectedPrs.shape(); + // click on the digit of dimension constrain comes here with an empty shape, so we need the check + if (aFeature == anOpFeature && aShape.get() && !aShape->isNull()) { + const TopoDS_Shape& aTDShape = aShape->impl(); + AttributePtr anAttribute = PartSet_Tools::findAttributeBy2dPoint(anObject, aTDShape, + mySketchMgr->activeSketch()); + if (anAttribute.get()) { + QString aXmlRepr = aFOperation->getDescription()->xmlRepresentation(); + ModuleBase_WidgetFactory aFactory(aXmlRepr.toStdString(), workshop()); + + const std::string anAttributeId = anAttribute->id(); + aFactory.createWidget(aPropertyPanel->contentWidget(), anAttributeId); + + theWidgets = aFactory.getModelWidgets(); + // it is possible that the point does not present in XML definition, + // in this case, we assume that it is not processed by this module + // e.g. "Intersection point" feature + aProcessed = !theWidgets.isEmpty(); } } } } + return aProcessed; } - void PartSet_Module::onSelectionChanged() { ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); @@ -535,121 +633,90 @@ void PartSet_Module::onKeyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* the { XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); XGUI_OperationMgr* anOpMgr = aConnector->workshop()->operationMgr(); - anOpMgr->onKeyReleased(theEvent); -} - -void PartSet_Module::onEnterReleased() -{ - myRestartingMode = RM_EmptyFeatureUsed; -} - -void PartSet_Module::onOperationActivatedByPreselection() -{ - ModuleBase_Operation* anOperation = myWorkshop->currentOperation(); - if(anOperation && PartSet_SketcherMgr::isNestedSketchOperation(anOperation)) { - // Set final definitions if they are necessary - //propertyPanelDefined(aOperation); - - /// Commit sketcher operations automatically - anOperation->commit(); - } -} - -void PartSet_Module::onNoMoreWidgets() -{ - ModuleBase_Operation* anOperation = myWorkshop->currentOperation(); - if (anOperation) { - if (PartSet_SketcherMgr::isNestedSketchOperation(anOperation)) { - if (myRestartingMode != RM_Forbided) - myRestartingMode = RM_LastFeatureUsed; - XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); - XGUI_Workshop* aWorkshop = aConnector->workshop(); - XGUI_OperationMgr* anOpMgr = aWorkshop->operationMgr(); - // do nothing if the feature can not be applyed - if (anOpMgr->isApplyEnabled()) - anOperation->commit(); - } - } -} - -void PartSet_Module::onVertexSelected() -{ - ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); - if (aOperation->id().toStdString() == SketchPlugin_Line::ID()) { - /// If last line finished on vertex the lines creation sequence has to be break - ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); - ModuleBase_ModelWidget* anActiveWidget = aPanel->activeWidget(); - const QList& aWidgets = aPanel->modelWidgets(); - QList::const_iterator anIt = aWidgets.begin(), aLast = aWidgets.end(); - bool aFoundWidget = false; - bool aFoundObligatory = false; - for (; anIt != aLast && !aFoundObligatory; anIt++) { - if (!aFoundWidget) - aFoundWidget = *anIt == anActiveWidget; - else - aFoundObligatory = (*anIt)->isObligatory(); - } - if (!aFoundObligatory) - myRestartingMode = RM_Forbided; - } + anOpMgr->onKeyReleased(theWnd->viewPort(), theEvent); } -ModuleBase_ModelWidget* PartSet_Module::createWidgetByType(const std::string& theType, QWidget* theParent, - Config_WidgetAPI* theWidgetApi, std::string theParentId) +ModuleBase_ModelWidget* PartSet_Module::createWidgetByType(const std::string& theType, + QWidget* theParent, + Config_WidgetAPI* theWidgetApi) { ModuleBase_IWorkshop* aWorkshop = workshop(); - XGUI_ModuleConnector* aConnector = dynamic_cast(aWorkshop); - XGUI_Workshop* aXUIWorkshop = aConnector->workshop(); + XGUI_Workshop* aXUIWorkshop = getWorkshop(); ModuleBase_ModelWidget* aWgt = NULL; if (theType == "sketch-start-label") { PartSet_WidgetSketchLabel* aLabelWgt = new PartSet_WidgetSketchLabel(theParent, aWorkshop, - theWidgetApi, theParentId, mySketchMgr->isConstraintsShown()); + theWidgetApi, myHasConstraintShown); connect(aLabelWgt, SIGNAL(planeSelected(const std::shared_ptr&)), mySketchMgr, SLOT(onPlaneSelected(const std::shared_ptr&))); - connect(aLabelWgt, SIGNAL(showConstraintToggled(bool)), - mySketchMgr, SLOT(onShowConstraintsToggle(bool))); + connect(aLabelWgt, SIGNAL(showConstraintToggled(int, bool)), + mySketchMgr, SLOT(onShowConstraintsToggle(int, bool))); aWgt = aLabelWgt; } else if (theType == "sketch-2dpoint_selector") { PartSet_WidgetPoint2D* aPointWgt = new PartSet_WidgetPoint2D(theParent, aWorkshop, - theWidgetApi, theParentId); + theWidgetApi); + aPointWgt->setSketch(mySketchMgr->activeSketch()); + connect(aPointWgt, SIGNAL(vertexSelected()), sketchReentranceMgr(), SLOT(onVertexSelected())); + aWgt = aPointWgt; + }else if (theType == "sketch-2dpoint_flyout_selector") { + PartSet_WidgetPoint2DFlyout* aPointWgt = new PartSet_WidgetPoint2DFlyout(theParent, aWorkshop, + theWidgetApi); aPointWgt->setSketch(mySketchMgr->activeSketch()); - connect(aPointWgt, SIGNAL(vertexSelected()), this, SLOT(onVertexSelected())); + connect(aPointWgt, SIGNAL(vertexSelected()), sketchReentranceMgr(), SLOT(onVertexSelected())); aWgt = aPointWgt; } else if (theType == "point2ddistance") { PartSet_WidgetPoint2dDistance* aDistanceWgt = new PartSet_WidgetPoint2dDistance(theParent, - aWorkshop, theWidgetApi, theParentId); + aWorkshop, theWidgetApi); aDistanceWgt->setSketch(mySketchMgr->activeSketch()); aWgt = aDistanceWgt; - } else if(theType == "point2dangle") { - PartSet_WidgetPoint2dAngle* anAngleWgt = new PartSet_WidgetPoint2dAngle(theParent, - aWorkshop, theWidgetApi, theParentId); - anAngleWgt->setSketch(mySketchMgr->activeSketch()); - aWgt = anAngleWgt; } else if (theType == "sketch_shape_selector") { PartSet_WidgetShapeSelector* aShapeSelectorWgt = - new PartSet_WidgetShapeSelector(theParent, aWorkshop, theWidgetApi, theParentId); + new PartSet_WidgetShapeSelector(theParent, aWorkshop, theWidgetApi); aShapeSelectorWgt->setSketcher(mySketchMgr->activeSketch()); aWgt = aShapeSelectorWgt; } else if (theType == "sketch_multi_selector") { PartSet_WidgetMultiSelector* aShapeSelectorWgt = - new PartSet_WidgetMultiSelector(theParent, aWorkshop, theWidgetApi, theParentId); + new PartSet_WidgetMultiSelector(theParent, aWorkshop, theWidgetApi); aShapeSelectorWgt->setSketcher(mySketchMgr->activeSketch()); aWgt = aShapeSelectorWgt; - } else if (theType == WDG_DOUBLEVALUE_EDITOR) { - aWgt = new PartSet_WidgetEditor(theParent, aWorkshop, theWidgetApi, theParentId); + } else if (theType == "composite_multi_selector") { + PartSet_WidgetMultiSelectorComposite* aShapeSelectorWgt = + new PartSet_WidgetMultiSelectorComposite(theParent, aWorkshop, theWidgetApi); + aWgt = aShapeSelectorWgt; + } + else if (theType == WDG_DOUBLEVALUE_EDITOR) { + aWgt = new PartSet_WidgetEditor(theParent, aWorkshop, theWidgetApi); } else if (theType == "export_file_selector") { - aWgt = new PartSet_WidgetFileSelector(theParent, aWorkshop, theWidgetApi, theParentId); + aWgt = new PartSet_WidgetFileSelector(theParent, aWorkshop, theWidgetApi); } else if (theType == "sketch_launcher") { - aWgt = new PartSet_WidgetSketchCreator(theParent, this, theWidgetApi, theParentId); + aWgt = new PartSet_WidgetSketchCreator(theParent, this, theWidgetApi); + } else if (theType == "module_choice") { + aWgt = new PartSet_WidgetChoice(theParent, theWidgetApi); + connect(aWgt, SIGNAL(itemSelected(ModuleBase_ModelWidget*, int)), + this, SLOT(onChoiceChanged(ModuleBase_ModelWidget*, int))); } return aWgt; } +ModuleBase_ModelWidget* PartSet_Module::activeWidget() const +{ + ModuleBase_ModelWidget* anActiveWidget = 0; + + anActiveWidget = mySketchReentrantMgr->internalActiveWidget(); + if (!anActiveWidget) { + ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); + if (aOperation) { + ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); + anActiveWidget = aPanel->activeWidget(); + } + } + return anActiveWidget; +} bool PartSet_Module::deleteObjects() { - XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); - XGUI_Workshop* aWorkshop = aConnector->workshop(); + bool isProcessed = false; + + XGUI_Workshop* aWorkshop = getWorkshop(); XGUI_OperationMgr* anOpMgr = aWorkshop->operationMgr(); //SessionPtr aMgr = ModelAPI_Session::get(); @@ -658,6 +725,7 @@ bool PartSet_Module::deleteObjects() bool isSketchOp = PartSet_SketcherMgr::isSketchOperation(anOperation), isNestedOp = PartSet_SketcherMgr::isNestedSketchOperation(anOperation); if (isSketchOp || isNestedOp) { + isProcessed = true; // 2. find selected presentations // selected objects should be collected before the current operation abort because // the abort leads to selection lost on constraint objects. It can be corrected after #386 issue @@ -694,7 +762,7 @@ bool PartSet_Module::deleteObjects() // 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(anOpAction->id(), isSketchOp/*granted*/)) + if (!anOpMgr->canStartOperation(anOpAction->id())) return true; // the objects are processed but can not be deleted anOpMgr->startOperation(anOpAction); @@ -706,41 +774,7 @@ bool PartSet_Module::deleteObjects() // 5. stop operation anOpMgr->commitOperation(); } - else { - bool isPartRemoved = false; - // Delete part with help of PartSet plugin - // TODO: the deleted objects has to be processed by multiselection - QObjectPtrList aObjects = myWorkshop->selection()->selectedObjects(); - if (aObjects.size() == 1) { - ObjectPtr aObj = aObjects.first(); - FeaturePtr aFeature = std::dynamic_pointer_cast(aObj); - if (aFeature.get() && (aFeature->getKind() == PartSetPlugin_Part::ID())) { - // Remove feature should be created in the document of the part results - ResultPtr aPartResult = aFeature->firstResult(); - if (aPartResult.get()) { - std::shared_ptr aPart = - std::dynamic_pointer_cast(aPartResult); - DocumentPtr aPartDoc = aPart->partDoc(); - if (aPartDoc.get()) { - ModuleBase_OperationAction* anOpAction = new ModuleBase_OperationAction - (PartSetPlugin_Remove::ID().c_str(), this); - if (!anOpMgr->canStartOperation(anOpAction->id())) - return true; // the objects are processed but can not be deleted - - anOpMgr->startOperation(anOpAction); - - FeaturePtr aFeature = aPartDoc->addFeature(PartSetPlugin_Remove::ID()); - aFeature->execute(); - - anOpMgr->commitOperation(); - isPartRemoved = true; - } - } - } - } - return isPartRemoved; - } - return true; + return isProcessed; } void PartSet_Module::onFeatureTriggered() @@ -764,16 +798,34 @@ void PartSet_Module::onFeatureTriggered() ModuleBase_IModule::onFeatureTriggered(); } +void PartSet_Module::editFeature(FeaturePtr theFeature) +{ + storeConstraintsState(theFeature->getKind()); + ModuleBase_IModule::editFeature(theFeature); +} + void PartSet_Module::launchOperation(const QString& theCmdId) { - if (PartSet_SketcherMgr::constraintsIdList().contains(theCmdId)) { - // Show constraints if a constraint was anOperation - myHasConstraintShown = mySketchMgr->isConstraintsShown(); - mySketchMgr->onShowConstraintsToggle(true); - } + storeConstraintsState(theCmdId.toStdString()); ModuleBase_IModule::launchOperation(theCmdId); } +void PartSet_Module::storeConstraintsState(const std::string& theFeatureKind) +{ + if (myWorkshop->currentOperation() && + myWorkshop->currentOperation()->id().toStdString() == SketchPlugin_Sketch::ID()) { + const QMap& aShownStates = + mySketchMgr->showConstraintStates(); + myHasConstraintShown = aShownStates; + } + if (PartSet_SketcherMgr::constraintsIdList().contains(theFeatureKind.c_str())) { + // Show constraints if a constraint was anOperation + mySketchMgr->updateBySketchParameters(PartSet_Tools::Geometrical, true); + mySketchMgr->updateBySketchParameters(PartSet_Tools::Dimensional, true); + mySketchMgr->updateBySketchParameters(PartSet_Tools::Expressions, + myHasConstraintShown[PartSet_Tools::Expressions]); + } +} void PartSet_Module::onObjectDisplayed(ObjectPtr theObject, AISObjectPtr theAIS) { @@ -813,8 +865,7 @@ void PartSet_Module::onViewTransformed(int theTrsfType) //Handle(V3d_View) aView = aViewer->activeView(); - XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); - XGUI_Workshop* aWorkshop = aConnector->workshop(); + XGUI_Workshop* aWorkshop = getWorkshop(); XGUI_Displayer* aDisplayer = aWorkshop->displayer(); Handle(V3d_Viewer) aV3dViewer = aContext->CurrentViewer(); Handle(V3d_View) aView; @@ -831,7 +882,7 @@ void PartSet_Module::onViewTransformed(int theTrsfType) } if (aView.IsNull()) return; - double aLen = aView->Convert(20); + double aLen = aView->Convert(SketcherPrs_Tools::getDefaultArrowSize()); double aPrevLen = SketcherPrs_Tools::getArrowSize(); SketcherPrs_Tools::setArrowSize(aLen); @@ -855,11 +906,73 @@ void PartSet_Module::onViewTransformed(int theTrsfType) aDisplayer->updateViewer(); } -bool PartSet_Module::customizeObject(ObjectPtr theObject, const bool theUpdateViewer) +void PartSet_Module::activateCustomPrs(const FeaturePtr& theFeature, const ModuleBase_CustomizeFlag& theFlag, + const bool theUpdateViewer) +{ + myCustomPrs->activate(theFeature, theFlag, theUpdateViewer); +} + +void PartSet_Module::deactivateCustomPrs(const ModuleBase_CustomizeFlag& theFlag, + const bool theUpdateViewer) +{ + myCustomPrs->deactivate(theFlag, theUpdateViewer); +} + +bool PartSet_Module::customisePresentation(ResultPtr theResult, AISObjectPtr thePrs, + std::shared_ptr theCustomPrs) +{ + bool aCustomized = false; + + if (theResult.get()) + return aCustomized; + + XGUI_Workshop* aWorkshop = getWorkshop(); + XGUI_Displayer* aDisplayer = aWorkshop->displayer(); + ObjectPtr anObject = aDisplayer->getObject(thePrs); + if (anObject.get()) { + bool isConflicting = myOverconstraintListener->isConflictingObject(anObject); + // customize sketch symbol presentation + if (thePrs.get()) { + Handle(AIS_InteractiveObject) anAISIO = thePrs->impl(); + if (!anAISIO.IsNull()) { + if (!Handle(SketcherPrs_SymbolPrs)::DownCast(anAISIO).IsNull()) { + Handle(SketcherPrs_SymbolPrs) aPrs = Handle(SketcherPrs_SymbolPrs)::DownCast(anAISIO); + if (!aPrs.IsNull()) { + std::vector aColor; + myOverconstraintListener->getConflictingColor(aColor); + aPrs->SetConflictingConstraint(isConflicting, aColor); + aCustomized = true; + } + } + } + } + // customize sketch dimension constraint presentation + if (!aCustomized) { + std::vector aColor; + if (isConflicting) { + myOverconstraintListener->getConflictingColor(aColor); + } + if (aColor.empty()) + XGUI_CustomPrs::getDefaultColor(anObject, true, aColor); + if (!aColor.empty()) { + thePrs->setColor(aColor[0], aColor[1], aColor[2]); + aCustomized = true; + } + } + + // customize dimentional constrains + sketchMgr()->customizePresentation(anObject); + } + + return aCustomized; +} + +bool PartSet_Module::customizeObject(ObjectPtr theObject, const ModuleBase_CustomizeFlag& theFlag, + const bool theUpdateViewer) { bool isRedisplayed = false; - if (myCustomPrs->isActive()) - isRedisplayed = myCustomPrs->redisplay(theObject, theUpdateViewer); + if (myCustomPrs->isActive(theFlag)) + isRedisplayed = myCustomPrs->redisplay(theObject, theFlag, theUpdateViewer); return isRedisplayed; } @@ -868,22 +981,35 @@ void PartSet_Module::customizeObjectBrowser(QWidget* theObjectBrowser) { XGUI_ObjectsBrowser* aOB = dynamic_cast(theObjectBrowser); if (aOB) { - //QLineEdit* aLabel = aOB->activeDocLabel(); + QLabel* aLabel = aOB->activeDocLabel(); + aLabel->installEventFilter(myMenuMgr); + connect(aLabel, SIGNAL(customContextMenuRequested(const QPoint&)), + SLOT(onActiveDocPopup(const QPoint&))); //QPalette aPalet = aLabel->palette(); //aPalet.setColor(QPalette::Text, QColor(0, 72, 140)); //aLabel->setPalette(aPalet); aOB->treeView()->setExpandsOnDoubleClick(false); connect(aOB->treeView(), SIGNAL(doubleClicked(const QModelIndex&)), SLOT(onTreeViewDoubleClick(const QModelIndex&))); -#ifdef ModuleDataModel - connect(aOB, SIGNAL(headerMouseDblClicked(const QModelIndex&)), - SLOT(onTreeViewDoubleClick(const QModelIndex&))); - connect(aOB->treeView(), SIGNAL(doubleClicked(const QModelIndex&)), - myDataModel, SLOT(onMouseDoubleClick(const QModelIndex&))); -#endif } } +void PartSet_Module::onActiveDocPopup(const QPoint& thePnt) +{ + SessionPtr aMgr = ModelAPI_Session::get(); + QAction* aActivatePartAction = myMenuMgr->action("ACTIVATE_PARTSET_CMD"); + + XGUI_Workshop* aWorkshop = getWorkshop(); + QLabel* aHeader = aWorkshop->objectBrowser()->activeDocLabel(); + + aActivatePartAction->setEnabled((aMgr->activeDocument() != aMgr->moduleDocument())); + + QMenu aMenu; + aMenu.addAction(aActivatePartAction); + aMenu.exec(aHeader->mapToGlobal(thePnt)); +} + + ObjectPtr PartSet_Module::findPresentedObject(const AISObjectPtr& theAIS) const { ObjectPtr anObject; @@ -891,15 +1017,17 @@ ObjectPtr PartSet_Module::findPresentedObject(const AISObjectPtr& theAIS) const if (aOperation) { /// If last line finished on vertex the lines creation sequence has to be break ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); - ModuleBase_ModelWidget* anActiveWidget = aPanel->activeWidget(); - // if there is an active widget, find the presented object in it - if (!anActiveWidget) - anActiveWidget = aPanel->preselectionWidget(); + if (aPanel) { + ModuleBase_ModelWidget* anActiveWidget = aPanel->activeWidget(); + // if there is an active widget, find the presented object in it + if (!anActiveWidget) + anActiveWidget = aPanel->preselectionWidget(); - ModuleBase_WidgetValidated* aWidgetValidated = dynamic_cast - (anActiveWidget); - if (aWidgetValidated) - anObject = aWidgetValidated->findPresentedObject(theAIS); + ModuleBase_WidgetValidated* aWidgetValidated = dynamic_cast + (anActiveWidget); + if (aWidgetValidated) + anObject = aWidgetValidated->findPresentedObject(theAIS); + } } return anObject; } @@ -910,7 +1038,8 @@ void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const int aSelected = aObjects.size(); SessionPtr aMgr = ModelAPI_Session::get(); QAction* aActivatePartAction = myMenuMgr->action("ACTIVATE_PART_CMD"); - QAction* aActivatePartSetAction = myMenuMgr->action("ACTIVATE_PARTSET_CMD"); + + ModuleBase_Operation* aCurrentOp = myWorkshop->currentOperation(); if (aSelected == 1) { bool hasResult = false; bool hasFeature = false; @@ -921,13 +1050,13 @@ void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const ObjectPtr aObject = aObjects.first(); if (aObject) { ResultPartPtr aPart = std::dynamic_pointer_cast(aObject); - FeaturePtr aPartFeature = std::dynamic_pointer_cast(aObject); + FeaturePtr aFeature = std::dynamic_pointer_cast(aObject); bool isPart = aPart.get() || - (aPartFeature.get() && (aPartFeature->getKind() == PartSetPlugin_Part::ID())); + (aFeature.get() && (aFeature->getKind() == PartSetPlugin_Part::ID())); if (isPart) { DocumentPtr aPartDoc; if (!aPart.get()) { - aPart = std::dynamic_pointer_cast(aPartFeature->firstResult()); + aPart = std::dynamic_pointer_cast(aFeature->firstResult()); } if (aPart.get()) // this may be null is Part feature is disabled aPartDoc = aPart->partDoc(); @@ -936,28 +1065,24 @@ void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const aActivatePartAction->setEnabled((aMgr->activeDocument() != aPartDoc)); } else if (aObject->document() == aMgr->activeDocument()) { - if (hasParameter || hasFeature) + if (hasParameter || hasFeature) { + myMenuMgr->action("EDIT_CMD")->setEnabled(true); theMenu->addAction(myMenuMgr->action("EDIT_CMD")); + if (aCurrentOp && aFeature.get()) { + if (aCurrentOp->id().toStdString() == aFeature->getKind()) + myMenuMgr->action("EDIT_CMD")->setEnabled(false); + } + } } ResultBodyPtr aResult = std::dynamic_pointer_cast(aObject); if( aResult.get() ) theMenu->addAction(myMenuMgr->action("SELECT_PARENT_CMD")); - } else { // If feature is 0 the it means that selected root object (document) - theMenu->addAction(aActivatePartSetAction); - aActivatePartSetAction->setEnabled((aMgr->activeDocument() != aMgr->moduleDocument())); } - } else if (aSelected == 0) { - // if there is no selection then it means that upper label is selected - QModelIndexList aIndexes = myWorkshop->selection()->selectedIndexes(); - if (aIndexes.size() == 0) // it means that selection happens in top label outside of tree view - theMenu->addAction(aActivatePartSetAction); - aActivatePartSetAction->setEnabled((aMgr->activeDocument() != aMgr->moduleDocument())); } - bool aNotDeactivate = (myWorkshop->currentOperation() == 0); + bool aNotDeactivate = (aCurrentOp == 0); if (!aNotDeactivate) { aActivatePartAction->setEnabled(false); - aActivatePartSetAction->setEnabled(false); } } @@ -974,56 +1099,34 @@ void PartSet_Module::processEvent(const std::shared_ptr& theMess if (myWorkshop->currentOperation() && (!aAllowActivationList.contains(myWorkshop->currentOperation()->id()))) return; - XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); - XGUI_Workshop* aWorkshop = aConnector->workshop(); + XGUI_Workshop* aWorkshop = getWorkshop(); XGUI_DataTree* aTreeView = aWorkshop->objectBrowser()->treeView(); - QLineEdit* aLabel = aWorkshop->objectBrowser()->activeDocLabel(); + QLabel* aLabel = aWorkshop->objectBrowser()->activeDocLabel(); QPalette aPalet = aLabel->palette(); SessionPtr aMgr = ModelAPI_Session::get(); DocumentPtr aActiveDoc = aMgr->activeDocument(); -#ifdef ModuleDataModel - QModelIndex aOldIndex = myDataModel->activePartTree(); - DocumentPtr aDoc = aMgr->moduleDocument(); - if (aActiveDoc == aDoc) { - if (aOldIndex.isValid()) - aTreeView->setExpanded(aOldIndex, false); - myDataModel->deactivatePart(); - aPalet.setColor(QPalette::Text, QColor(0, 72, 140)); - } else { - std::string aGrpName = ModelAPI_ResultPart::group(); - for (int i = 0; i < aDoc->size(aGrpName); i++) { - ResultPartPtr aPart = std::dynamic_pointer_cast(aDoc->object(aGrpName, i)); - if (aPart->partDoc() == aActiveDoc) { - QModelIndex aIndex = myDataModel->partIndex(aPart); - if (myDataModel->activatePart(aIndex)) { - if (aOldIndex.isValid()) - aTreeView->setExpanded(aOldIndex, false); - aTreeView->setExpanded(myDataModel->activePartTree(), true); - aPalet.setColor(QPalette::Text, Qt::black); - } - break; - } - } - } -#else - // Problem with MPV: At first time on creation it doesn't work because Part feature - // creation event will be sent after if (aActivePartIndex.isValid()) aTreeView->setExpanded(aActivePartIndex, false); XGUI_DataModel* aDataModel = aWorkshop->objectBrowser()->dataModel(); aActivePartIndex = aDataModel->documentRootIndex(aActiveDoc); if (aActivePartIndex.isValid()) aTreeView->setExpanded(aActivePartIndex, true); -#endif + aLabel->setPalette(aPalet); aWorkshop->updateCommandStatus(); // Update displayed objects in order to update active color XGUI_Displayer* aDisplayer = aWorkshop->displayer(); QObjectPtrList aObjects = aDisplayer->displayedObjects(); - foreach(ObjectPtr aObj, aObjects) - aDisplayer->redisplay(aObj, false); + bool aHidden; + foreach(ObjectPtr aObj, aObjects) { + //TODO: replace by redisplay event. + aHidden = !aObj->data() || !aObj->data()->isValid() || + aObj->isDisabled() || (!aObj->isDisplayed()); + if (!aHidden) + aDisplayer->redisplay(aObj, false); + } aDisplayer->updateViewer(); } } @@ -1039,17 +1142,13 @@ void PartSet_Module::onTreeViewDoubleClick(const QModelIndex& theIndex) } if (theIndex.column() != 0) // Use only first column return; -#ifdef ModuleDataModel - ObjectPtr aObj = myDataModel->object(theIndex); -#else - XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); - XGUI_Workshop* aWorkshop = aConnector->workshop(); + + XGUI_Workshop* aWorkshop = getWorkshop(); XGUI_DataModel* aDataModel = aWorkshop->objectBrowser()->dataModel(); // De not use non editable Indexes if ((aDataModel->flags(theIndex) & Qt::ItemIsSelectable) == 0) return; ObjectPtr aObj = aDataModel->object(theIndex); -#endif ResultPartPtr aPart = std::dynamic_pointer_cast(aObj); if (!aPart.get()) { // Probably this is Feature @@ -1097,13 +1196,95 @@ void PartSet_Module::onViewCreated(ModuleBase_IViewWindow*) // the filters of this widget should be activated in the created view ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); if (aOperation) { - ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); - ModuleBase_ModelWidget* anActiveWidget = aPanel->activeWidget(); + ModuleBase_ModelWidget* anActiveWidget = activeWidget(); if (anActiveWidget) { - ModuleBase_WidgetValidated* aWidgetValidated = dynamic_cast - (anActiveWidget); - if (aWidgetValidated) - aWidgetValidated->activateFilters(true); + ModuleBase_WidgetSelector* aWSelector = dynamic_cast(anActiveWidget); + if (aWSelector) + aWSelector->activateSelectionAndFilters(true); + } + } +} + +//****************************************************** +void PartSet_Module::widgetStateChanged(int thePreviousState) +{ + mySketchMgr->widgetStateChanged(thePreviousState); +} + +bool PartSet_Module::processEnter(const std::string& thePreviousAttributeID) +{ + return mySketchReentrantMgr->processEnter(thePreviousAttributeID); +} + +//****************************************************** +void PartSet_Module::beforeOperationStarted(ModuleBase_Operation* theOperation) +{ +} + +//****************************************************** +void PartSet_Module::beforeOperationStopped(ModuleBase_Operation* theOperation) +{ + if (PartSet_SketcherMgr::isSketchOperation(theOperation)) { + mySketchMgr->stopSketch(theOperation); + } +} + +//****************************************************** +GeomShapePtr PartSet_Module::findShape(const AttributePtr& theAttribute) +{ + GeomShapePtr aGeomShape; + + ModuleBase_Operation* anOperation = myWorkshop->currentOperation(); + if (anOperation && PartSet_SketcherMgr::isNestedSketchOperation(anOperation)) { + aGeomShape = PartSet_Tools::findShapeBy2DPoint(theAttribute, myWorkshop); + } + return aGeomShape; +} + +//****************************************************** +AttributePtr PartSet_Module::findAttribute(const ObjectPtr& theObject, + const GeomShapePtr& theGeomShape) +{ + AttributePtr anAttribute; + GeomShapePtr aGeomShape = theGeomShape; + if (!aGeomShape.get()) { + // processing shape of result, e.g. sketch circle center is selected, this is a result + // the geom shape is empty, the shape of result should be used + ResultPtr aResult = std::dynamic_pointer_cast(theObject); + if (aResult.get()) { + aGeomShape = aResult->shape(); } } + + if (aGeomShape.get()) { + TopoDS_Shape aTDSShape = aGeomShape->impl(); + return PartSet_Tools::findAttributeBy2dPoint(theObject, aTDSShape, + mySketchMgr->activeSketch()); + } + return anAttribute; +} + +//****************************************************** +void PartSet_Module::onChoiceChanged(ModuleBase_ModelWidget* theWidget, + int theIndex) +{ + PartSet_WidgetChoice* aChoiceWidget = dynamic_cast(theWidget); + if (!aChoiceWidget) + return; + + QString aChoiceTitle = aChoiceWidget->getPropertyPanelTitle(theIndex); + if (!aChoiceTitle.isEmpty()) { + ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); + if (!aOperation) + return; + ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); + aPanel->setWindowTitle(aChoiceTitle); + } +} + +//****************************************************** +XGUI_Workshop* PartSet_Module::getWorkshop() const +{ + XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); + return aConnector->workshop(); }