X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Module.cpp;h=70f6736b51f0c3c955c7b406c42ba577904ef242;hb=3c3a34a6515ac15f7cb8a77e2f307d3835b72b78;hp=9b380a839de031128e1b0311af90b67a7373f389;hpb=34afe547352180006fee9600173c4dc93dc1f6c3;p=modules%2Fshaper.git diff --git a/src/PartSet/PartSet_Module.cpp b/src/PartSet/PartSet_Module.cpp index 9b380a839..70f6736b5 100755 --- a/src/PartSet/PartSet_Module.cpp +++ b/src/PartSet/PartSet_Module.cpp @@ -1,24 +1,43 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D +// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or +// email : webmaster.salome@opencascade.com +// #include "PartSet_Module.h" #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_WidgetFeaturePointSelector.h" #include "PartSet_WidgetEditor.h" #include "PartSet_WidgetFileSelector.h" #include "PartSet_WidgetSketchCreator.h" #include "PartSet_SketcherMgr.h" -#include "PartSet_SketcherReetntrantMgr.h" +#include "PartSet_SketcherReentrantMgr.h" +#include "PartSet_ResultSketchPrs.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" @@ -32,11 +51,15 @@ #include #include #include +#include +#include #include #include -#include #include #include +#include +#include +#include #include #include @@ -45,45 +68,56 @@ #include #include #include +#include +#include +#include #include #include #include +#include +#include +#include +#include +#include +#include #include -#include -#include -#include +#include +#include #include -#include -#include #include +#include +#include #include -#include -#include +#include +#include -#include -#include #include #include #include #include #include #include +#include +#include +#include #include +#include #include #include #include #include +#include +#include #include #include #include #include #include -#include #include #include @@ -93,6 +127,7 @@ #include #include #include +#include #include #include @@ -109,22 +144,20 @@ extern "C" PARTSET_EXPORT ModuleBase_IModule* createModule(ModuleBase_IWorkshop* return new PartSet_Module(theWshop); } +//****************************************************** PartSet_Module::PartSet_Module(ModuleBase_IWorkshop* theWshop) : ModuleBase_IModule(theWshop), - myVisualLayerId(0), myHasConstraintShown(true) + myVisualLayerId(0), + myIsOperationIsLaunched(false) { new PartSet_IconFactory(); mySketchMgr = new PartSet_SketcherMgr(this); - mySketchReentrantMgr = new PartSet_SketcherReetntrantMgr(theWshop); + mySketchReentrantMgr = new PartSet_SketcherReentrantMgr(theWshop); XGUI_ModuleConnector* aConnector = dynamic_cast(theWshop); XGUI_Workshop* aWorkshop = aConnector->workshop(); - XGUI_OperationMgr* anOpMgr = aWorkshop->operationMgr(); - 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*))); @@ -132,48 +165,79 @@ 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)); + registerSelectionFilter(SF_GlobalFilter, new PartSet_GlobalFilter(myWorkshop)); + registerSelectionFilter(SF_FilterInfinite, new PartSet_FilterInfinite(myWorkshop)); + Handle(PartSet_ResultGroupNameFilter) aCRFilter = new PartSet_ResultGroupNameFilter(myWorkshop); + std::set aCRGroupNames; + aCRGroupNames.insert(ModelAPI_ResultConstruction::group()); + aCRFilter->setGroupNames(aCRGroupNames); + registerSelectionFilter(SF_ResultGroupNameFilter, aCRFilter); + + setDefaultConstraintShown(); + + 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()); + Config_PropManager::registerProp("Visualization", "operation_remove_feature_color", + "Color of removed feature in operation", Config_Prop::Color, + PartSet_CustomPrs::OPERATION_REMOVE_FEATURE_COLOR()); + Config_PropManager::registerProp("Visualization", "sketch_preview_plane", + "Color of sketch plane", Config_Prop::Color, + PartSet_CustomPrs::OPERATION_SKETCH_PLANE()); + + Config_PropManager::registerProp("Visualization", "hidden_face_transparency", + "Hidden faces transparency", + Config_Prop::Double, + "0.8"); } +//****************************************************** PartSet_Module::~PartSet_Module() { - SelectMgr_ListIteratorOfListOfFilter aIt(mySelectionFilters); - for (; aIt.More(); aIt.Next()) { - Handle(SelectMgr_Filter) aFilter = aIt.Value(); + std::map::const_iterator aFiltersIt = + mySelectionFilters.begin(); + for (; aFiltersIt != mySelectionFilters.end(); aFiltersIt++) { + Handle(SelectMgr_Filter) aFilter = aFiltersIt->second; if (!aFilter.IsNull()) aFilter.Nullify(); } delete myCustomPrs; + delete myOverconstraintListener; } -void PartSet_Module::activateSelectionFilters() +//****************************************************** +void PartSet_Module::storeSelection() { - SelectMgr_ListIteratorOfListOfFilter aIt(mySelectionFilters); - for (; aIt.More(); aIt.Next()) { - Handle(SelectMgr_Filter) aFilter = aIt.Value(); - if (!aFilter.IsNull()) - myWorkshop->viewer()->addSelectionFilter(aFilter); - } + // cash is used only to restore selection, so it should be filled in storeSelection and + // after applying immediatelly cleared in restoreSelection + myCurrentSelection.clear(); + sketchMgr()->storeSelection(PartSet_SketcherMgr::ST_SelectType, myCurrentSelection); } -void PartSet_Module::deactivateSelectionFilters() +//****************************************************** +void PartSet_Module::restoreSelection() { - SelectMgr_ListIteratorOfListOfFilter aIt(mySelectionFilters); - for (; aIt.More(); aIt.Next()) { - Handle(SelectMgr_Filter) aFilter = aIt.Value(); - if (!aFilter.IsNull()) - myWorkshop->viewer()->removeSelectionFilter(aFilter); - } + // cash is used only to restore selection, so it should be filled in storeSelection and + // after applying immediatelly cleared in restoreSelection + sketchMgr()->restoreSelection(myCurrentSelection); + myCurrentSelection.clear(); } +//****************************************************** void PartSet_Module::registerValidators() { //Registering of validators @@ -191,106 +255,209 @@ void PartSet_Module::registerValidators() 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_DifferentPoints", new PartSet_DifferentPointsValidator); aFactory->registerValidator("PartSet_CoincidentAttr", new PartSet_CoincidentAttr); - aFactory->registerValidator("PartSet_SketchEntityValidator", new PartSet_SketchEntityValidator); -} - -void PartSet_Module::registerFilters() -{ - //Registering of selection filters - XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); - ModuleBase_FilterFactory* aFactory = aConnector->selectionFilters(); -} - -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); - Config_PropManager::registerProp("Sketch planes", "rotate_to_plane", "Rotate to plane when selected", - Config_Prop::Boolean, "false"); + aFactory->registerValidator("PartSet_MultyTranslationSelection", + new PartSet_MultyTranslationSelection); + aFactory->registerValidator("PartSet_SplitSelection", new PartSet_SplitSelection); + aFactory->registerValidator("PartSet_ProjectionSelection", new PartSet_ProjectionSelection); } -void PartSet_Module::connectToPropertyPanel(ModuleBase_ModelWidget* theWidget, const bool isToConnect) +//****************************************************** +void PartSet_Module::connectToPropertyPanel(ModuleBase_ModelWidget* theWidget, + const bool isToConnect) { mySketchMgr->connectToPropertyPanel(theWidget, isToConnect); } -void PartSet_Module::operationCommitted(ModuleBase_Operation* theOperation) +//****************************************************** +void PartSet_Module::operationCommitted(ModuleBase_Operation* theOperation) { - if (PartSet_SketcherMgr::isNestedSketchOperation(theOperation)) { + if (sketchMgr()->isNestedSketchOperation(theOperation)) { mySketchMgr->commitNestedSketch(theOperation); } + /// deactivate of overconstraint listener should be performed after Sketch commit (#2176) + if (PartSet_SketcherMgr::isSketchOperation(theOperation)) + overconstraintListener()->setActive(false); /// Restart sketcher operations automatically if (!mySketchReentrantMgr->operationCommitted(theOperation)) { - ModuleBase_OperationFeature* aFOperation = dynamic_cast(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 - XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); - XGUI_Workshop* aWorkshop = aConnector->workshop(); - aWorkshop->selector()->clearSelection(); + getWorkshop()->selector()->clearSelection(); } } } +//****************************************************** void PartSet_Module::operationAborted(ModuleBase_Operation* theOperation) { /// Restart sketcher operations automatically mySketchReentrantMgr->operationAborted(theOperation); + /// deactivate of overconstraint listener should be performed after Sketch abort (#2176) + if (PartSet_SketcherMgr::isSketchOperation(theOperation)) + overconstraintListener()->setActive(false); } +//****************************************************** void PartSet_Module::operationStarted(ModuleBase_Operation* theOperation) { - /// Restart sketcher operations automatically - mySketchReentrantMgr->operationStarted(theOperation); + ModuleBase_OperationFeature* aFOperation = dynamic_cast + (theOperation); + if (aFOperation) { + XGUI_Workshop* aWorkshop = XGUI_Tools::workshop(workshop()); + XGUI_PropertyPanel* aPropertyPanel = aWorkshop->propertyPanel(); + + ModuleBase_ModelWidget* aFilledWidget = 0; + bool aPostonedWidgetActivation = false; + + FeaturePtr aFeature = aFOperation->feature(); + /// Restart sketcher operations automatically + /// it is important to call method of sketch reentrant manager before filling of PP + /// because it fills some created feature attributes, these new values should be used + /// to fill the property panel + mySketchReentrantMgr->operationStarted(theOperation); + + aWorkshop->fillPropertyPanel(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()) { + std::string aGreedAttributeId = ModuleBase_Tools::findGreedAttribute(workshop(), aFeature); + // if there is a greed attribute, automatic commit by preselection + // for this feature is prohibited + 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) { + aWorkshop->connectToPropertyPanel(true); + updateSketcherOnStart(aFOperation); + updatePresentationsOnStart(aFOperation); + + // the objects of the current operation should be deactivated + QObjectPtrList anObjects; + anObjects.append(aFeature); + std::list aResults; + ModelAPI_Tools::allResults(aFeature, aResults); + 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(); + } + /// state of command actions should be updated after displayed objects modification because + /// deactivation(for example) of objects may influence on selection in the viewer + /// State of command actions may depend on selection in the viewer(e.g. Sketch) + workshop()->updateCommandStatus(); + } + 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::updateSketcherOnStart(ModuleBase_Operation* theOperation) +{ if (PartSet_SketcherMgr::isSketchOperation(theOperation)) { mySketchMgr->startSketch(theOperation); } - else if (PartSet_SketcherMgr::isNestedSketchOperation(theOperation)) { + else if (sketchMgr()->isNestedSketchOperation(theOperation)) { mySketchMgr->startNestedSketch(theOperation); } +} - ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); - if (aFOperation) - myCustomPrs->activate(aFOperation->feature(), true); +//****************************************************** +void PartSet_Module::updatePresentationsOnStart(ModuleBase_Operation* theOperation) +{ + ModuleBase_OperationFeature* aFOperation = + dynamic_cast(theOperation); + if (aFOperation) { + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeArguments, true); + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeResults, true); + } } +//****************************************************** void PartSet_Module::operationResumed(ModuleBase_Operation* theOperation) { ModuleBase_IModule::operationResumed(theOperation); - ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); - if (aFOperation) - myCustomPrs->activate(aFOperation->feature(), true); + ModuleBase_OperationFeature* aFOperation = + dynamic_cast(theOperation); + if (aFOperation) { + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeArguments, true); + myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeResults, true); + } } +//****************************************************** 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 (sketchMgr()->isNestedSketchOperation(theOperation)) { mySketchMgr->stopNestedSketch(theOperation); } + else if (PartSet_SketcherMgr::isSketchOperation(theOperation)) + setDefaultConstraintShown(); //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); + if (isModified) { + XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); + XGUI_Displayer* aDisplayer = aConnector->workshop()->displayer(); + aDisplayer->updateViewer(); + } + + QMap::const_iterator + anIt = myHasConstraintShown.begin(), aLast = myHasConstraintShown.end(); + for (; anIt != aLast; anIt++) { + mySketchMgr->updateBySketchParameters(anIt.key(), anIt.value()); + } } +//****************************************************** ModuleBase_Operation* PartSet_Module::currentOperation() const { XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); @@ -298,6 +465,7 @@ ModuleBase_Operation* PartSet_Module::currentOperation() const return anOpMgr->currentOperation(); } +//****************************************************** bool PartSet_Module::canUndo() const { bool aCanUndo = false; @@ -310,6 +478,7 @@ bool PartSet_Module::canUndo() const return aCanUndo; } +//****************************************************** bool PartSet_Module::canRedo() const { bool aCanRedo = false; @@ -322,58 +491,94 @@ bool PartSet_Module::canRedo() const return aCanRedo; } +//****************************************************** 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. - if (aFeature->getKind() == PartSetPlugin_Part::ID()) + ResultPtr aResult = ModuleBase_Tools::firstResult(aFeature); + // part features can not be moved in the history. + if (aResult.get() && aResult->groupName() == ModelAPI_ResultPart::group()) aValid = false; } } return aValid; } +//****************************************************** bool PartSet_Module::canEraseObject(const ObjectPtr& theObject) const { // the sketch manager put the restriction to the objects erase return mySketchMgr->canEraseObject(theObject); } +//****************************************************** bool PartSet_Module::canDisplayObject(const ObjectPtr& theObject) const { // the sketch manager put the restriction to the objects display return mySketchMgr->canDisplayObject(theObject); } +//****************************************************** +bool PartSet_Module::canUsePreselection(const QString& thePreviousOperationKind, + const QString& theStartedOperationKind) +{ + if (ModuleBase_IModule::canUsePreselection(thePreviousOperationKind, theStartedOperationKind)) + return true; + + return mySketchMgr->isNestedSketchFeature(theStartedOperationKind); +} + +/*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); ModuleBase_Operation* anOperation = myWorkshop->currentOperation(); bool isSketchOp = PartSet_SketcherMgr::isSketchOperation(anOperation), - isNestedOp = PartSet_SketcherMgr::isNestedSketchOperation(anOperation); + isNestedOp = sketchMgr()->isNestedSketchOperation(anOperation); if (isSketchOp || isNestedOp) { // in active sketch operation it is possible to activate operation object in selection // in the edit operation, e.g. points of the line can be moved when the line is edited - ModuleBase_OperationFeature* aFOperation = dynamic_cast(anOperation); + ModuleBase_OperationFeature* aFOperation = + dynamic_cast(anOperation); aCanActivate = aCanActivate || (aFOperation && aFOperation->isEditOperation()); } return aCanActivate; } -bool PartSet_Module::addViewerMenu(QMenu* theMenu, const QMap& theStdActions) const +//****************************************************** +bool PartSet_Module::addViewerMenu(const QMap& theStdActions, + QWidget* theParent, + QMap& theMenuActions) const { - return myMenuMgr->addViewerMenu(theMenu, theStdActions); + return myMenuMgr->addViewerMenu(theStdActions, theParent, theMenuActions); } +//****************************************************** void PartSet_Module::updateViewerMenu(const QMap& theStdActions) { myMenuMgr->updateViewerMenu(theStdActions); } +//****************************************************** +bool PartSet_Module::isActionEnableStateFixed(const int theActionId) const +{ + bool isEnabledFixed = false; + if (theActionId == XGUI_ActionsMgr::AcceptAll && + mySketchReentrantMgr->isInternalEditActive()) + isEnabledFixed = true; + return isEnabledFixed; +} + +//****************************************************** QString PartSet_Module::getFeatureError(const FeaturePtr& theFeature) { QString anError = ModuleBase_IModule::getFeatureError(theFeature); @@ -383,49 +588,156 @@ QString PartSet_Module::getFeatureError(const FeaturePtr& theFeature) return anError; } +//****************************************************** void PartSet_Module::grantedOperationIds(ModuleBase_Operation* theOperation, QStringList& theIds) const { myMenuMgr->grantedOperationIds(theOperation, theIds); if (PartSet_SketcherMgr::isSketchOperation(theOperation)) { - XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); - XGUI_Workshop* aWorkshop = aConnector->workshop(); - + XGUI_Workshop* aWorkshop = getWorkshop(); theIds.append(aWorkshop->contextMenuMgr()->action("DELETE_CMD")->text()); } } +//****************************************************** void PartSet_Module::activeSelectionModes(QIntList& theModes) { - theModes.clear(); if (mySketchMgr->activeSketch().get()) - PartSet_SketcherMgr::sketchSelectionModes(theModes); + PartSet_SketcherMgr::sketchSelectionModes(mySketchMgr->activeSketch(), theModes); + else + theModes = XGUI_Tools::workshop(myWorkshop)->viewerSelectionModes(); +} + +//****************************************************** +void PartSet_Module::moduleSelectionModes(int theModesType, QIntList& theModes) +{ + customSubShapesSelectionModes(theModes); + //theModes.append(XGUI_Tools::workshop(myWorkshop)->viewerSelectionModes()); + //myWorkshop->module()->activeSelectionModes(theModes); +} + +//****************************************************** +void PartSet_Module::moduleSelectionFilters(const QIntList& theFilterTypes, + SelectMgr_ListOfFilter& theSelectionFilters) +{ + bool isSketchActive = mySketchMgr->activeSketch().get(); + + std::map::const_iterator aFiltersIt = + mySelectionFilters.begin(); + for (; aFiltersIt != mySelectionFilters.end(); aFiltersIt++) { + int aFilterType = aFiltersIt->first; + // do not add not participating filters in given parameters + if (!theFilterTypes.contains(aFilterType)) + continue; + + // using sketch filters only if sketch operation is active + if (!isSketchActive && + mySketchMgr->sketchSelectionFilter((XGUI_SelectionFilterType)aFilterType)) + continue; + + // using filtering of construction results only from faces panel + if (aFilterType == SF_ResultGroupNameFilter) + continue; + + theSelectionFilters.Append(aFiltersIt->second); + } +} + +//****************************************************** +QIntList PartSet_Module::selectionFilters() +{ + QIntList aTypes; + + std::map::const_iterator aFiltersIt = + mySelectionFilters.begin(); + for (; aFiltersIt != mySelectionFilters.end(); aFiltersIt++) + aTypes.append(aFiltersIt->first); + + return aTypes; +} + +//****************************************************** +void PartSet_Module::registerSelectionFilter(const XGUI_SelectionFilterType theFilterType, + const Handle(SelectMgr_Filter)& theFilter) +{ + mySelectionFilters[theFilterType] = theFilter; +} + +//****************************************************** +Handle(SelectMgr_Filter) PartSet_Module::selectionFilter(const int theType) +{ + XGUI_SelectionFilterType aType = (XGUI_SelectionFilterType)theType; + + if (mySelectionFilters.find(aType) != mySelectionFilters.end()) + return mySelectionFilters[aType]; + else + return Handle(SelectMgr_Filter)(); +} + +//****************************************************** +void PartSet_Module::customSubShapesSelectionModes(QIntList& theModes) +{ + if (theModes.contains(TopAbs_FACE)) + theModes.append(SketcherPrs_Tools::Sel_Sketch_Face); + if (theModes.contains(TopAbs_WIRE)) + theModes.append(SketcherPrs_Tools::Sel_Sketch_Wire); + + if (mySketchMgr->activeSketch().get()) + PartSet_SketcherMgr::sketchSelectionModes(mySketchMgr->activeSketch(), theModes); } +//****************************************************** +void PartSet_Module::getGeomSelection(const std::shared_ptr& theSelected, + ObjectPtr& theObject, AttributePtr& theAttribute) +{ + ObjectPtr anObject = theSelected->object(); + GeomShapePtr aShape = theSelected->shape(); + + theAttribute = findAttribute(anObject, aShape); + // TODO: try to create result if object is an external object + theObject = anObject; +} + +//****************************************************** bool PartSet_Module::isMouseOverWindow() { return mySketchMgr->isMouseOverWindow(); } +//****************************************************** +bool PartSet_Module::isSketchNeutralPointActivated() const +{ + bool isNeutralPoint = true; + if (sketchReentranceMgr()->isInternalEditActive()) + isNeutralPoint = false; + if (myIsOperationIsLaunched) + isNeutralPoint = false; + + return isNeutralPoint; +} + +//****************************************************** void PartSet_Module::closeDocument() { - clearViewer(); + myActivePartIndex = QModelIndex(); } +//****************************************************** 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(); + aDisplayer->deactivateSelectionFilters(false); } +//****************************************************** void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation) { - ModuleBase_OperationFeature* aFOperation = dynamic_cast(theOperation); + ModuleBase_OperationFeature* aFOperation = + dynamic_cast(theOperation); if (!aFOperation) return; @@ -435,7 +747,60 @@ void PartSet_Module::propertyPanelDefined(ModuleBase_Operation* theOperation) aPanel->activateWidget(aPanel->modelWidgets().first()); } +//****************************************************** +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_ViewerPrsPtr 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()) { + // if feature has only one result and shape of result is equal to selected shape + // this attribute is not processed. It is a case of Sketch Point. + if (aFeature->results().size() == 1) { + ResultPtr aResult = aFeature->results().front(); + if (aResult.get() && aResult->shape()->isEqual(aShape)) + return aProcessed; + } + 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(); @@ -451,106 +816,92 @@ void PartSet_Module::onSelectionChanged() if (isSketcherOp) { // Editing of constraints can be done on selection ModuleBase_ISelection* aSelect = myWorkshop->selection(); - QList aSelected = aSelect->getSelected(); + QList aSelected = aSelect->getSelected(); if (aSelected.size() == 1) { - ModuleBase_ViewerPrs aPrs = aSelected.first(); - ObjectPtr aObject = aPrs.object(); + ModuleBase_ViewerPrsPtr 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_ConstraintLength::ID()) || (aId == SketchPlugin_ConstraintDistance::ID()) || (aId == SketchPlugin_ConstraintAngle::ID())) { editFeature(aFeature); } } } - } + } } +//****************************************************** void PartSet_Module::onKeyRelease(ModuleBase_IViewWindow* theWnd, QKeyEvent* theEvent) { XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); XGUI_OperationMgr* anOpMgr = aConnector->workshop()->operationMgr(); - anOpMgr->onKeyReleased(theEvent); -} - -void PartSet_Module::onOperationActivatedByPreselection() -{ - if (!mySketchReentrantMgr->canBeCommittedByPreselection()) - return; - - 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(); - } + 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") { + }else if (theType == "sketch-2dpoint_flyout_selector") { PartSet_WidgetPoint2DFlyout* aPointWgt = new PartSet_WidgetPoint2DFlyout(theParent, aWorkshop, - theWidgetApi, theParentId); + theWidgetApi); aPointWgt->setSketch(mySketchMgr->activeSketch()); connect(aPointWgt, SIGNAL(vertexSelected()), sketchReentranceMgr(), SLOT(onVertexSelected())); aWgt = aPointWgt; - } else if (theType == "point2ddistance") { - PartSet_WidgetPoint2dDistance* aDistanceWgt = new PartSet_WidgetPoint2dDistance(theParent, - aWorkshop, theWidgetApi, theParentId); - 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 == "sketch_feature_point_selector") { + PartSet_WidgetFeaturePointSelector* aPointSelectorWgt = + new PartSet_WidgetFeaturePointSelector(theParent, aWorkshop, theWidgetApi); + aPointSelectorWgt->setSketcher(mySketchMgr->activeSketch()); + aWgt = aPointSelectorWgt; + } + 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, theParentId); - connect(aWgt, SIGNAL(itemSelected(int)), SLOT(onBooleanOperationChange(int))); + aWgt = new ModuleBase_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; @@ -560,24 +911,27 @@ ModuleBase_ModelWidget* PartSet_Module::activeWidget() const ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); if (aOperation) { ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); - anActiveWidget = aPanel->activeWidget(); + anActiveWidget = aPanel ? aPanel->activeWidget() : 0; } } 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(); // 1. check whether the delete should be processed in the module ModuleBase_Operation* anOperation = myWorkshop->currentOperation(); bool isSketchOp = PartSet_SketcherMgr::isSketchOperation(anOperation), - isNestedOp = PartSet_SketcherMgr::isNestedSketchOperation(anOperation); + isNestedOp = sketchMgr()->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 @@ -614,11 +968,19 @@ 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())) + bool isCommitted; + if (!anOpMgr->canStartOperation(anOpAction->id(), isCommitted)) return true; // the objects are processed but can not be deleted anOpMgr->startOperation(anOpAction); + // WORKAROUND, should be done to avoid viewer highlight update after deletetion of objects + // the problem is in AIS Dimensions recompute + // if a line and the dim are removed, line is the first + // it causes the AIS recompute, where the base line is null, + // the result is empty AIS in the viewer + XGUI_Tools::workshop(myWorkshop)->selector()->clearSelection(); + // 4. delete features // sketch feature should be skipped, only sub-features can be removed // when sketch operation is active @@ -626,91 +988,83 @@ 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 isProcessed; +} + +//****************************************************** +void PartSet_Module::editFeature(FeaturePtr theFeature) +{ + storeConstraintsState(theFeature->getKind()); + ModuleBase_IModule::editFeature(theFeature); +} + +//****************************************************** +bool PartSet_Module::canCommitOperation() const +{ return true; } -void PartSet_Module::onFeatureTriggered() -{ - QAction* aCmd = dynamic_cast(sender()); - if (aCmd->isCheckable() && aCmd->isChecked()) { - // 1. check whether the delete should be processed in the module - ModuleBase_Operation* anOperation = myWorkshop->currentOperation(); - bool isNestedOp = PartSet_SketcherMgr::isNestedCreateOperation(anOperation); - if (isNestedOp) { - // in case if in the viewer nothing is displayed, the create operation should not be - // comitted even if all values of the feature are initialized - if (!mySketchMgr->canDisplayCurrentCreatedFeature()) { - // the action information should be saved before the operation is aborted - // because this abort leads to update command status, which unchecks this action - anOperation->abort(); - launchOperation(aCmd->data().toString()); - } - } +//****************************************************** +void PartSet_Module::launchOperation(const QString& theCmdId, const bool& isStartAfterCommitOnly) +{ + myIsOperationIsLaunched = true; + storeConstraintsState(theCmdId.toStdString()); + updateConstraintsState(theCmdId.toStdString()); + + ModuleBase_IModule::launchOperation(theCmdId, isStartAfterCommitOnly); + + myIsOperationIsLaunched = false; +} + +//****************************************************** +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; } - ModuleBase_IModule::onFeatureTriggered(); } -void PartSet_Module::launchOperation(const QString& theCmdId) +//****************************************************** +void PartSet_Module::updateConstraintsState(const std::string& theFeatureKind) { - if (PartSet_SketcherMgr::constraintsIdList().contains(theCmdId)) { + if (PartSet_SketcherMgr::constraintsIdList().contains(theFeatureKind.c_str()) || + PartSet_SketcherMgr::replicationsIdList().contains(theFeatureKind.c_str())) { // Show constraints if a constraint was anOperation - myHasConstraintShown = mySketchMgr->isConstraintsShown(); - mySketchMgr->onShowConstraintsToggle(true); + mySketchMgr->updateBySketchParameters(PartSet_Tools::Geometrical, true); + mySketchMgr->updateBySketchParameters(PartSet_Tools::Dimensional, true); + mySketchMgr->updateBySketchParameters(PartSet_Tools::Expressions, + myHasConstraintShown[PartSet_Tools::Expressions]); } - ModuleBase_IModule::launchOperation(theCmdId); } - -void PartSet_Module::onObjectDisplayed(ObjectPtr theObject, AISObjectPtr theAIS) +//****************************************************** +void PartSet_Module::onObjectDisplayed(ObjectPtr theObject, AISObjectPtr theAIS) { Handle(AIS_InteractiveObject) anAIS = theAIS->impl(); if (!anAIS.IsNull()) { + bool aToUseZLayer = false; + FeaturePtr aFeature = ModelAPI_Feature::feature(theObject); + if (aFeature.get() && PartSet_Tools::findRefsToMeFeature(aFeature, + SketchPlugin_Projection::ID())) + aToUseZLayer = true; Handle(AIS_InteractiveContext) aCtx = anAIS->GetContext(); Handle(AIS_Dimension) aDim = Handle(AIS_Dimension)::DownCast(anAIS); if (!aDim.IsNull()) { - aCtx->SetZLayer(aDim, myVisualLayerId); + aToUseZLayer = true; } else { Handle(SketcherPrs_SymbolPrs) aCons = Handle(SketcherPrs_SymbolPrs)::DownCast(anAIS); if (!aCons.IsNull()) - aCtx->SetZLayer(aCons, myVisualLayerId); + aToUseZLayer = true; } + if (aToUseZLayer) + aCtx->SetZLayer(anAIS, myVisualLayerId); } } +//****************************************************** void PartSet_Module::onBeforeObjectErase(ObjectPtr theObject, AISObjectPtr theAIS) { // this is obsolete @@ -720,6 +1074,7 @@ void PartSet_Module::onBeforeObjectErase(ObjectPtr theObject, AISObjectPtr theAI // myCustomPrs->redisplay(theObject, false); } +//****************************************************** void PartSet_Module::onViewTransformed(int theTrsfType) { // Set length of arrows constant in pixel size @@ -733,14 +1088,13 @@ 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; double aScale = 0; - for (aV3dViewer->InitDefinedViews(); - aV3dViewer->MoreDefinedViews(); + for (aV3dViewer->InitDefinedViews(); + aV3dViewer->MoreDefinedViews(); aV3dViewer->NextDefinedViews()) { Handle(V3d_View) aV = aV3dViewer->DefinedView(); double aS = aV->Scale(); @@ -751,63 +1105,160 @@ void PartSet_Module::onViewTransformed(int theTrsfType) } if (aView.IsNull()) return; - double aLen = aView->Convert(20); - - double aPrevLen = SketcherPrs_Tools::getArrowSize(); - SketcherPrs_Tools::setArrowSize(aLen); - const double aPrevScale = aViewer->Scale(aViewer->activeView()); - const double aCurScale = aViewer->activeView()->Camera()->Scale(); - aViewer->SetScale(aViewer->activeView(), aCurScale); - SketcherPrs_Tools::setTextHeight (aCurScale / aPrevScale * SketcherPrs_Tools::getTextHeight()); - bool isModified = false; - QList aPrsList = aDisplayer->displayedPresentations(); - foreach (AISObjectPtr aAIS, aPrsList) { - Handle(AIS_InteractiveObject) aAisObj = aAIS->impl(); - - Handle(AIS_Dimension) aDim = Handle(AIS_Dimension)::DownCast(aAisObj); - if (!aDim.IsNull()) { - aDim->DimensionAspect()->ArrowAspect()->SetLength(aLen); - aContext->Redisplay(aDim, false); - isModified = true; + + ModuleBase_Operation* aCurrentOperation = myWorkshop->currentOperation(); + if (aCurrentOperation && + (PartSet_SketcherMgr::isSketchOperation(aCurrentOperation) || + sketchMgr()->isNestedSketchOperation(aCurrentOperation))) + { + double aLen = aView->Convert(SketcherPrs_Tools::getConfigArrowSize()); + + double aPrevLen = SketcherPrs_Tools::getArrowSize(); + SketcherPrs_Tools::setArrowSize(aLen); + const double aCurScale = aViewer->activeView()->Camera()->Scale(); + aViewer->SetScale(aViewer->activeView(), aCurScale); + bool isModified = false; + QList aPrsList = aDisplayer->displayedPresentations(); + foreach (AISObjectPtr aAIS, aPrsList) { + Handle(AIS_InteractiveObject) aAisObj = aAIS->impl(); + + Handle(AIS_Dimension) aDim = Handle(AIS_Dimension)::DownCast(aAisObj); + if (!aDim.IsNull()) { + aDim->DimensionAspect()->ArrowAspect()->SetLength(aLen); + aContext->Redisplay(aDim, false); + isModified = true; + } } + if (isModified) + aDisplayer->updateViewer(); } - if (isModified) - aDisplayer->updateViewer(); } -bool PartSet_Module::customizeObject(ObjectPtr theObject, const bool theUpdateViewer) +//****************************************************** +bool PartSet_Module::isCustomPrsActivated(const ModuleBase_CustomizeFlag& theFlag) const +{ + return myCustomPrs->isActive(theFlag); +} + +//****************************************************** +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; + + XGUI_Workshop* aWorkshop = getWorkshop(); + XGUI_Displayer* aDisplayer = aWorkshop->displayer(); + ObjectPtr anObject = aDisplayer->getObject(thePrs); + if (!anObject) + return aCustomized; + + if (!theResult.get()) { + std::vector aColor; + XGUI_CustomPrs::getDefaultColor(anObject, true, aColor); + if (!aColor.empty()) { + aCustomized = thePrs->setColor(aColor[0], aColor[1], aColor[2]); + } + } + // customize dimentional constrains + sketchMgr()->customizePresentation(anObject); + + return aCustomized; +} + +//****************************************************** +bool PartSet_Module::afterCustomisePresentation(std::shared_ptr theResult, + AISObjectPtr thePrs, + GeomCustomPrsPtr theCustomPrs) +{ + bool aCustomized = false; + + XGUI_Workshop* aWorkshop = getWorkshop(); + XGUI_Displayer* aDisplayer = aWorkshop->displayer(); + ObjectPtr anObject = aDisplayer->getObject(thePrs); + if (!anObject) + return aCustomized; + + std::vector aColor; + bool aUseCustomColor = true; + if (aUseCustomColor) + myOverconstraintListener->getCustomColor(anObject, aColor); + // customize sketch symbol presentation + 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()) { + aPrs->SetCustomColor(aColor); + aCustomized = true; + } + } else if (!Handle(SketcherPrs_Coincident)::DownCast(anAISIO).IsNull()) { + Handle(SketcherPrs_Coincident) aPrs = Handle(SketcherPrs_Coincident)::DownCast(anAISIO); + if (!aPrs.IsNull()) { + aPrs->SetCustomColor(aColor); + aCustomized = true; + } + } + } + // customize sketch dimension constraint presentation + if (!aCustomized) { + if (!aColor.empty()) { // otherwise presentation has the default color + aCustomized = thePrs->setColor(aColor[0], aColor[1], aColor[2]); + } + } + 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; } +//****************************************************** void PartSet_Module::customizeObjectBrowser(QWidget* theObjectBrowser) { XGUI_ObjectsBrowser* aOB = dynamic_cast(theObjectBrowser); if (aOB) { QLabel* aLabel = aOB->activeDocLabel(); aLabel->installEventFilter(myMenuMgr); - connect(aLabel, SIGNAL(customContextMenuRequested(const QPoint&)), + 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&)), + connect(aOB->treeView(), SIGNAL(doubleClicked(const QModelIndex&)), SLOT(onTreeViewDoubleClick(const QModelIndex&))); + + Events_Loop* aLoop = Events_Loop::loop(); + aLoop->registerListener(this, Events_Loop::eventByName(EVENT_OBJECT_CREATED)); } } +//****************************************************** void PartSet_Module::onActiveDocPopup(const QPoint& thePnt) { SessionPtr aMgr = ModelAPI_Session::get(); QAction* aActivatePartAction = myMenuMgr->action("ACTIVATE_PARTSET_CMD"); - XGUI_ModuleConnector* aConnector = dynamic_cast(myWorkshop); - XGUI_Workshop* aWorkshop = aConnector->workshop(); + XGUI_Workshop* aWorkshop = getWorkshop(); QLabel* aHeader = aWorkshop->objectBrowser()->activeDocLabel(); aActivatePartAction->setEnabled((aMgr->activeDocument() != aMgr->moduleDocument())); @@ -817,7 +1268,13 @@ void PartSet_Module::onActiveDocPopup(const QPoint& thePnt) aMenu.exec(aHeader->mapToGlobal(thePnt)); } +//****************************************************** +Handle(AIS_InteractiveObject) PartSet_Module::createPresentation(const ResultPtr& theResult) +{ + return mySketchMgr->createPresentation(theResult); +} +//****************************************************** ObjectPtr PartSet_Module::findPresentedObject(const AISObjectPtr& theAIS) const { ObjectPtr anObject; @@ -825,19 +1282,34 @@ 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(); - - ModuleBase_WidgetValidated* aWidgetValidated = dynamic_cast - (anActiveWidget); - if (aWidgetValidated) - anObject = aWidgetValidated->findPresentedObject(theAIS); + 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); + } } return anObject; } +//****************************************************** +bool PartSet_Module::canBeShaded(Handle(AIS_InteractiveObject) theAIS) const +{ + bool aCanBeShaged = true; + + Handle(PartSet_ResultSketchPrs) aPrs = Handle(PartSet_ResultSketchPrs)::DownCast(theAIS); + if (!aPrs.IsNull()) + aCanBeShaged = false; + + return aCanBeShaged; +} + +//****************************************************** void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const { QObjectPtrList aObjects = myWorkshop->selection()->selectedObjects(); @@ -845,19 +1317,22 @@ void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const SessionPtr aMgr = ModelAPI_Session::get(); QAction* aActivatePartAction = myMenuMgr->action("ACTIVATE_PART_CMD"); + bool hasResult = false; + bool hasFeature = false; + bool hasParameter = false; + bool hasCompositeOwner = false; + bool hasResultInHistory = false; + bool hasFolder = false; + ModuleBase_Tools::checkObjects(aObjects, hasResult, hasFeature, hasParameter, + hasCompositeOwner, hasResultInHistory, hasFolder); + ModuleBase_Operation* aCurrentOp = myWorkshop->currentOperation(); if (aSelected == 1) { - bool hasResult = false; - bool hasFeature = false; - bool hasParameter = false; - bool hasSubFeature = false; - ModuleBase_Tools::checkObjects(aObjects, hasResult, hasFeature, hasParameter, hasSubFeature); - ObjectPtr aObject = aObjects.first(); if (aObject) { ResultPartPtr aPart = std::dynamic_pointer_cast(aObject); FeaturePtr aFeature = std::dynamic_pointer_cast(aObject); - bool isPart = aPart.get() || + bool isPart = aPart.get() || (aFeature.get() && (aFeature->getKind() == PartSetPlugin_Part::ID())); if (isPart) { DocumentPtr aPartDoc; @@ -866,7 +1341,7 @@ void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const } if (aPart.get()) // this may be null is Part feature is disabled aPartDoc = aPart->partDoc(); - + theMenu->addAction(aActivatePartAction); aActivatePartAction->setEnabled((aMgr->activeDocument() != aPartDoc)); @@ -880,10 +1355,12 @@ void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const } } } - - ResultBodyPtr aResult = std::dynamic_pointer_cast(aObject); - if( aResult.get() ) - theMenu->addAction(myMenuMgr->action("SELECT_PARENT_CMD")); + } + } else { + if (hasFeature) { + myMenuMgr->action("EDIT_CMD")->setEnabled(aCurrentOp == 0); + theMenu->addAction(myMenuMgr->action("EDIT_CMD")); + theMenu->addSeparator(); } } bool aNotDeactivate = (aCurrentOp == 0); @@ -892,33 +1369,49 @@ void PartSet_Module::addObjectBrowserMenu(QMenu* theMenu) const } } +//****************************************************** +#define EXPAND_PARENT(OBJ) \ +QModelIndex aObjIndex = aDataModel->objectIndex(OBJ); \ +if (aObjIndex.isValid()) { \ + QModelIndex aParent = aObjIndex.parent(); \ + int aCount = aDataModel->rowCount(aParent); \ + if (aCount == 1) \ + aTreeView->setExpanded(aParent, true); \ +} + +//****************************************************** void PartSet_Module::processEvent(const std::shared_ptr& theMessage) { if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_DOCUMENT_CHANGED)) { // Do not change activation of parts if an operation active static QStringList aAllowActivationList; if (aAllowActivationList.isEmpty()) - aAllowActivationList << - QString(PartSetPlugin_Part::ID().c_str()) << + aAllowActivationList << + QString(PartSetPlugin_Part::ID().c_str()) << QString(PartSetPlugin_Duplicate::ID().c_str()) << QString(PartSetPlugin_Remove::ID().c_str()); - if (myWorkshop->currentOperation() && + 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(); QLabel* aLabel = aWorkshop->objectBrowser()->activeDocLabel(); QPalette aPalet = aLabel->palette(); SessionPtr aMgr = ModelAPI_Session::get(); DocumentPtr aActiveDoc = aMgr->activeDocument(); - if (aActivePartIndex.isValid()) - aTreeView->setExpanded(aActivePartIndex, false); + // workaround for #2431 (SISGSEGV when launching some unit tests from GUI) + //if (myActivePartIndex.isValid()) + // aTreeView->setExpanded(myActivePartIndex, false); + XGUI_DataModel* aDataModel = aWorkshop->objectBrowser()->dataModel(); - aActivePartIndex = aDataModel->documentRootIndex(aActiveDoc); - if (aActivePartIndex.isValid()) - aTreeView->setExpanded(aActivePartIndex, true); + myActivePartIndex = aDataModel->documentRootIndex(aActiveDoc, 0); + bool needUpdate = false; + if (myActivePartIndex.isValid()) { + needUpdate = aTreeView->isExpanded(myActivePartIndex); + if (!needUpdate) + aTreeView->setExpanded(myActivePartIndex, true); + } aLabel->setPalette(aPalet); aWorkshop->updateCommandStatus(); @@ -928,30 +1421,67 @@ void PartSet_Module::processEvent(const std::shared_ptr& theMess QObjectPtrList aObjects = aDisplayer->displayedObjects(); bool aHidden; foreach(ObjectPtr aObj, aObjects) { - //TODO: replace by redisplay event. - aHidden = !aObj->data() || !aObj->data()->isValid() || + aHidden = !aObj->data() || !aObj->data()->isValid() || aObj->isDisabled() || (!aObj->isDisplayed()); if (!aHidden) aDisplayer->redisplay(aObj, false); } aDisplayer->updateViewer(); + // Update tree items if they are expanded + if (needUpdate) { + aTreeView->viewport()->repaint(aTreeView->viewport()->rect()); + } + } else if (theMessage->eventID() == Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED)) { + std::shared_ptr aUpdMsg = + std::dynamic_pointer_cast(theMessage); + std::set aObjects = aUpdMsg->objects(); + + ObjectPtr aConstrObj; + ObjectPtr aResultObj; + std::set::const_iterator aIt; + DocumentPtr aRootDoc = ModelAPI_Session::get()->moduleDocument(); + for (aIt = aObjects.begin(); aIt != aObjects.end(); ++aIt) { + ObjectPtr aObject = (*aIt); + if ((!aResultObj.get()) && (aObject->groupName() == ModelAPI_ResultBody::group()) + && (aObject->document() != aRootDoc)) + aResultObj = aObject; + if ((!aConstrObj.get()) && (aObject->groupName() == ModelAPI_ResultConstruction::group()) + && (aObject->document() != aRootDoc)) + aConstrObj = aObject; + if (aResultObj.get() && aConstrObj.get()) + break; + } + + if (aResultObj.get() || aConstrObj.get()) { + XGUI_Workshop* aWorkshop = getWorkshop(); + XGUI_DataTree* aTreeView = aWorkshop->objectBrowser()->treeView(); + XGUI_DataModel* aDataModel = aWorkshop->objectBrowser()->dataModel(); + + if (aResultObj.get()) { + EXPAND_PARENT(aResultObj) + } + if (aConstrObj.get()) { + EXPAND_PARENT(aConstrObj) + } + } } } +//****************************************************** void PartSet_Module::onTreeViewDoubleClick(const QModelIndex& theIndex) { if (myWorkshop->currentOperation()) // Do not change activation of parts if an operation active return; SessionPtr aMgr = ModelAPI_Session::get(); if (!theIndex.isValid()) { - aMgr->setActiveDocument(aMgr->moduleDocument()); + // It seems that this code is obsolete + //aMgr->setActiveDocument(aMgr->moduleDocument()); return; } - if (theIndex.column() != 0) // Use only first column + if (theIndex.column() != 1) // Use only first column return; - 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) @@ -969,12 +1499,12 @@ void PartSet_Module::onTreeViewDoubleClick(const QModelIndex& theIndex) if (aPart->partDoc() == aMgr->activeDocument()) { myMenuMgr->activatePartSet(); } else { - aPart->activate(); + myMenuMgr->activatePart(aPart); } } } - +//****************************************************** void PartSet_Module::onViewCreated(ModuleBase_IViewWindow*) { // z layer is created for all started operations in order to visualize operation AIS presentation @@ -1002,15 +1532,8 @@ void PartSet_Module::onViewCreated(ModuleBase_IViewWindow*) } // if there is an active operation with validated widget, // the filters of this widget should be activated in the created view - ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); - if (aOperation) { - ModuleBase_ModelWidget* anActiveWidget = activeWidget(); - if (anActiveWidget) { - ModuleBase_WidgetSelector* aWSelector = dynamic_cast(anActiveWidget); - if (aWSelector) - aWSelector->activateSelectionAndFilters(true); - } - } + myWorkshop->selectionActivate()->updateSelectionFilters(); + myWorkshop->selectionActivate()->updateSelectionModes(); } //****************************************************** @@ -1019,28 +1542,97 @@ void PartSet_Module::widgetStateChanged(int thePreviousState) mySketchMgr->widgetStateChanged(thePreviousState); } +//****************************************************** bool PartSet_Module::processEnter(const std::string& thePreviousAttributeID) { return mySketchReentrantMgr->processEnter(thePreviousAttributeID); } +//****************************************************** +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 && sketchMgr()->isNestedSketchOperation(anOperation)) { + aGeomShape = PartSet_Tools::findShapeBy2DPoint(theAttribute, myWorkshop); + } + return aGeomShape; +} //****************************************************** -void PartSet_Module::onBooleanOperationChange(int theOperation) +AttributePtr PartSet_Module::findAttribute(const ObjectPtr& theObject, + const GeomShapePtr& theGeomShape) { - ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); - if (!aOperation) + 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; +} + +//****************************************************** +std::shared_ptr PartSet_Module::reentrantMessage() +{ + return sketchReentranceMgr()->reentrantMessage(); +} + +//****************************************************** +void PartSet_Module::setReentrantPreSelection(const std::shared_ptr& theMessage) +{ + sketchReentranceMgr()->setReentrantPreSelection(theMessage); +} + +//****************************************************** +void PartSet_Module::onChoiceChanged(ModuleBase_ModelWidget* theWidget, + int theIndex) +{ + ModuleBase_WidgetChoice* aChoiceWidget = dynamic_cast(theWidget); + if (!aChoiceWidget) return; - ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); - switch (theOperation) { - case 0: - aPanel->setWindowTitle(tr("Cut")); - break; - case 1: - aPanel->setWindowTitle(tr("Fuse")); - break; - case 2: - aPanel->setWindowTitle(tr("Common")); - break; + + QString aChoiceTitle = aChoiceWidget->getPropertyPanelTitle(theIndex); + if (!aChoiceTitle.isEmpty()) { + ModuleBase_Operation* aOperation = myWorkshop->currentOperation(); + if (!aOperation) + return; + ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel(); + if (aPanel) + aPanel->setWindowTitle(aChoiceTitle); } } + +//****************************************************** +XGUI_Workshop* PartSet_Module::getWorkshop() const +{ + XGUI_ModuleConnector* aConnector = dynamic_cast(workshop()); + return aConnector->workshop(); +} + +//****************************************************** +void PartSet_Module::setDefaultConstraintShown() +{ + myHasConstraintShown[PartSet_Tools::Geometrical] = true; + myHasConstraintShown[PartSet_Tools::Dimensional] = true; + myHasConstraintShown[PartSet_Tools::Expressions] = false; +}