#include "PartSet_WidgetPoint2DFlyout.h"
#include "PartSet_WidgetShapeSelector.h"
#include "PartSet_WidgetMultiSelector.h"
+#include "PartSet_WidgetSubShapeSelector.h"
#include "PartSet_WidgetEditor.h"
#include "PartSet_WidgetFileSelector.h"
#include "PartSet_WidgetSketchCreator.h"
#include <ModelAPI_ResultBody.h>
#include <ModelAPI_AttributeString.h>
#include <ModelAPI_AttributeSelectionList.h>
+#include <ModelAPI_Tools.h>
#include <GeomDataAPI_Point2D.h>
#include <GeomDataAPI_Point.h>
#include <XGUI_ErrorMgr.h>
#include <XGUI_CustomPrs.h>
#include <XGUI_SelectionMgr.h>
+#include <XGUI_ActionsMgr.h>
#include <SketchPlugin_Feature.h>
#include <SketchPlugin_Sketch.h>
#include <SketchPlugin_ConstraintRadius.h>
#include <SketcherPrs_SymbolPrs.h>
+#include <SketcherPrs_Coincident.h>
#include <SketcherPrs_Tools.h>
#include <Events_Loop.h>
PartSet_Module::PartSet_Module(ModuleBase_IWorkshop* theWshop)
: ModuleBase_IModule(theWshop),
- myVisualLayerId(0)
+ myVisualLayerId(0),
+ myIsOperationIsLaunched(false)
{
new PartSet_IconFactory();
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;
+ setDefaultConstraintShown();
Config_PropManager::registerProp("Visualization", "operation_parameter_color",
"Reference shape wireframe color in operation", Config_Prop::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(SKETCH_TAB_NAME, "disable_input_fields", "Disable input fields",
+ // Config_Prop::Boolean, "true");
}
PartSet_Module::~PartSet_Module()
void PartSet_Module::registerProperties()
{
- Config_PropManager::registerProp("Sketch planes", "planes_size", "Size", Config_Prop::Double,
+ Config_PropManager::registerProp(SKETCH_TAB_NAME, "planes_size", "Size", Config_Prop::Double,
PLANE_SIZE);
- Config_PropManager::registerProp("Sketch planes", "planes_thickness", "Thickness",
+ Config_PropManager::registerProp(SKETCH_TAB_NAME, "planes_thickness", "Thickness",
Config_Prop::Integer, SKETCH_WIDTH);
- Config_PropManager::registerProp("Sketch planes", "rotate_to_plane", "Rotate to plane when selected",
+ Config_PropManager::registerProp(SKETCH_TAB_NAME, "rotate_to_plane", "Rotate to plane when selected",
Config_Prop::Boolean, "false");
}
void PartSet_Module::operationCommitted(ModuleBase_Operation* theOperation)
{
- if (PartSet_SketcherMgr::isNestedSketchOperation(theOperation)) {
+ if (sketchMgr()->isNestedSketchOperation(theOperation)) {
mySketchMgr->commitNestedSketch(theOperation);
}
void PartSet_Module::operationStarted(ModuleBase_Operation* theOperation)
{
- ModuleBase_IWorkshop* anIWorkshop = workshop();
- if (!theOperation->getDescription()->hasXmlRepresentation()) { //!< No need for property panel
- anIWorkshop->updateCommandStatus();
- }
- else {
- ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
- (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);
+ ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>
+ (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
- 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);
- }
+ 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<ModuleBase_ModelWidget*>& 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<ResultPtr> aResults = aFeature->results();
- std::list<ResultPtr>::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();
+ else { // there is a greed widget
+ const QList<ModuleBase_ModelWidget*>& 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 (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);
+ } if (!isOperationCommitted) {
+ workshop()->updateCommandStatus();
+ aWorkshop->connectToPropertyPanel(true);
+ updateSketcherOnStart(aFOperation);
+ updatePresentationsOnStart(aFOperation);
+
+ // the objects of the current operation should be deactivated
+ QObjectPtrList anObjects;
+ anObjects.append(aFeature);
+ std::list<ResultPtr> aResults;
+ ModelAPI_Tools::allResults(aFeature, aResults);
+ std::list<ResultPtr>::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::operationStartedInternal(ModuleBase_Operation* theOperation)
+void PartSet_Module::updateSketcherOnStart(ModuleBase_Operation* theOperation)
{
- /// Restart sketcher operations automatically
- mySketchReentrantMgr->operationStarted(theOperation);
-
if (PartSet_SketcherMgr::isSketchOperation(theOperation)) {
mySketchMgr->startSketch(theOperation);
}
- else if (PartSet_SketcherMgr::isNestedSketchOperation(theOperation)) {
+ else if (sketchMgr()->isNestedSketchOperation(theOperation)) {
mySketchMgr->startNestedSketch(theOperation);
}
+}
+void PartSet_Module::updatePresentationsOnStart(ModuleBase_Operation* theOperation)
+{
ModuleBase_OperationFeature* aFOperation = dynamic_cast<ModuleBase_OperationFeature*>(theOperation);
if (aFOperation) {
myCustomPrs->activate(aFOperation->feature(), ModuleBase_IModule::CustomizeArguments, true);
bool isModifiedResults = myCustomPrs->deactivate(ModuleBase_IModule::CustomizeResults, false);
bool isModified = isModifiedArgs || isModifiedResults;
- 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) {
QMap<PartSet_Tools::ConstraintVisibleState, bool>::const_iterator anIt = myHasConstraintShown.begin(),
aLast = myHasConstraintShown.end();
for (; anIt != aLast; anIt++) {
- myHasConstraintShown[anIt.key()];
mySketchMgr->updateBySketchParameters(anIt.key(), anIt.value());
}
}
if (theActionId == "MOVE_CMD") {
FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
if (aFeature) {
+ ResultPtr aResult = ModuleBase_Tools::firstResult(aFeature);
// part features can not be moved in the history.
- if (aFeature->getKind() == PartSetPlugin_Part::ID())
+ if (aResult.get() && aResult->groupName() == ModelAPI_ResultPart::group())
aValid = false;
}
}
return mySketchMgr->canDisplayObject(theObject);
}
-void PartSet_Module::processHiddenObject(const std::list<ObjectPtr>& theObjects)
+/*void PartSet_Module::processHiddenObject(const std::list<ObjectPtr>& theObjects)
{
mySketchMgr->processHiddenObject(theObjects);
-}
+}*/
bool PartSet_Module::canActivateSelection(const ObjectPtr& theObject) const
{
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
myMenuMgr->updateViewerMenu(theStdActions);
}
+bool PartSet_Module::isActionEnableStateFixed(const int theActionId) const
+{
+ bool isEnabledFixed = false;
+ if (theActionId == XGUI_ActionsMgr::AcceptAll &&
+ mySketchReentrantMgr->isInternalEditStarted())
+ isEnabledFixed = true;
+ return isEnabledFixed;
+}
+
QString PartSet_Module::getFeatureError(const FeaturePtr& theFeature)
{
QString anError = ModuleBase_IModule::getFeatureError(theFeature);
PartSet_SketcherMgr::sketchSelectionModes(theModes);
}
+void PartSet_Module::customSubShapesSelectionModes(QIntList& theTypes)
+{
+ if (theTypes.contains(TopAbs_FACE))
+ theTypes.append(SketcherPrs_Tools::Sel_Sketch_Face);
+ if (theTypes.contains(TopAbs_WIRE))
+ theTypes.append(SketcherPrs_Tools::Sel_Sketch_Wire);
+}
+
bool PartSet_Module::isMouseOverWindow()
{
return mySketchMgr->isMouseOverWindow();
}
+bool PartSet_Module::isSketchNeutralPointActivated() const
+{
+ bool isNeutralPoint = true;
+ if (sketchReentranceMgr()->isInternalEditStarted())
+ isNeutralPoint = false;
+ if (myIsOperationIsLaunched)
+ isNeutralPoint = false;
+
+ return isNeutralPoint;
+}
+
void PartSet_Module::closeDocument()
{
clearViewer();
aShapeSelectorWgt->setSketcher(mySketchMgr->activeSketch());
aWgt = aShapeSelectorWgt;
}
+ else if (theType == "sketch_sub_shape_selector") {
+ PartSet_WidgetSubShapeSelector* aSubShapeSelectorWgt =
+ new PartSet_WidgetSubShapeSelector(theParent, aWorkshop, theWidgetApi);
+ aSubShapeSelectorWgt->setSketcher(mySketchMgr->activeSketch());
+ aWgt = aSubShapeSelectorWgt;
+ }
else if (theType == WDG_DOUBLEVALUE_EDITOR) {
aWgt = new PartSet_WidgetEditor(theParent, aWorkshop, theWidgetApi);
} else if (theType == "export_file_selector") {
ModuleBase_Operation* aOperation = myWorkshop->currentOperation();
if (aOperation) {
ModuleBase_IPropertyPanel* aPanel = aOperation->propertyPanel();
- anActiveWidget = aPanel->activeWidget();
+ anActiveWidget = aPanel ? aPanel->activeWidget() : 0;
}
}
return anActiveWidget;
// 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
void PartSet_Module::onFeatureTriggered()
{
- QAction* aCmd = dynamic_cast<QAction*>(sender());
+ // is commented for imp: Unpressing the button of the current action must behave like
+ // a validation if the entity can be created (instead of Cancel, as currently)
+ /*QAction* aCmd = dynamic_cast<QAction*>(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);
+ bool isNestedOp = myModule->sketchMgr()->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
launchOperation(aCmd->data().toString());
}
}
- }
+ }*/
ModuleBase_IModule::onFeatureTriggered();
}
void PartSet_Module::launchOperation(const QString& theCmdId)
{
+ myIsOperationIsLaunched = true;
storeConstraintsState(theCmdId.toStdString());
+ updateConstraintsState(theCmdId.toStdString());
+
ModuleBase_IModule::launchOperation(theCmdId);
+
+ myIsOperationIsLaunched = false;
}
void PartSet_Module::storeConstraintsState(const std::string& theFeatureKind)
mySketchMgr->showConstraintStates();
myHasConstraintShown = aShownStates;
}
- if (PartSet_SketcherMgr::constraintsIdList().contains(theFeatureKind.c_str())) {
+}
+
+void PartSet_Module::updateConstraintsState(const std::string& theFeatureKind)
+{
+ if (PartSet_SketcherMgr::constraintsIdList().contains(theFeatureKind.c_str()) ||
+ PartSet_SketcherMgr::replicationsIdList().contains(theFeatureKind.c_str())) {
// Show constraints if a constraint was anOperation
mySketchMgr->updateBySketchParameters(PartSet_Tools::Geometrical, true);
mySketchMgr->updateBySketchParameters(PartSet_Tools::Dimensional, true);
aDisplayer->updateViewer();
}
+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)
{
{
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()) {
+ if (!anObject)
+ return aCustomized;
+
+ if (!theResult.get()) {
bool isConflicting = myOverconstraintListener->isConflictingObject(anObject);
// customize sketch symbol presentation
if (thePrs.get()) {
aPrs->SetConflictingConstraint(isConflicting, aColor);
aCustomized = true;
}
+ } else if (!Handle(SketcherPrs_Coincident)::DownCast(anAISIO).IsNull()) {
+ Handle(SketcherPrs_Coincident) aPrs = Handle(SketcherPrs_Coincident)::DownCast(anAISIO);
+ if (!aPrs.IsNull()) {
+ std::vector<int> aColor;
+ myOverconstraintListener->getConflictingColor(aColor);
+ aPrs->SetConflictingConstraint(isConflicting, aColor);
+ aCustomized = true;
+ }
}
}
}
if (aColor.empty())
XGUI_CustomPrs::getDefaultColor(anObject, true, aColor);
if (!aColor.empty()) {
- thePrs->setColor(aColor[0], aColor[1], aColor[2]);
- aCustomized = true;
+ aCustomized = thePrs->setColor(aColor[0], aColor[1], aColor[2]);
}
}
-
- // customize dimentional constrains
- sketchMgr()->customizePresentation(anObject);
}
+ // customize dimentional constrains
+ sketchMgr()->customizePresentation(anObject);
return aCustomized;
}
return mySketchReentrantMgr->processEnter(thePreviousAttributeID);
}
-//******************************************************
-void PartSet_Module::beforeOperationStarted(ModuleBase_Operation* theOperation)
-{
-}
-
//******************************************************
void PartSet_Module::beforeOperationStopped(ModuleBase_Operation* theOperation)
{
GeomShapePtr aGeomShape;
ModuleBase_Operation* anOperation = myWorkshop->currentOperation();
- if (anOperation && PartSet_SketcherMgr::isNestedSketchOperation(anOperation)) {
+ if (anOperation && sketchMgr()->isNestedSketchOperation(anOperation)) {
aGeomShape = PartSet_Tools::findShapeBy2DPoint(theAttribute, myWorkshop);
}
return aGeomShape;
XGUI_ModuleConnector* aConnector = dynamic_cast<XGUI_ModuleConnector*>(workshop());
return aConnector->workshop();
}
+
+//******************************************************
+void PartSet_Module::setDefaultConstraintShown()
+{
+ myHasConstraintShown[PartSet_Tools::Geometrical] = true;
+ myHasConstraintShown[PartSet_Tools::Dimensional] = true;
+ myHasConstraintShown[PartSet_Tools::Expressions] = false;
+}
