diff --git a/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.cpp b/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.cpp index d4c19630af..a35b5ff75d 100644 --- a/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.cpp +++ b/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.cpp @@ -24,8 +24,8 @@ #include "PreCompiled.h" #ifndef _PreComp_ -# include -# include +#include +#include #endif #include @@ -52,26 +52,30 @@ using namespace Gui; /* TRANSLATOR PartDesignGui::TaskLinearPatternParameters */ -TaskLinearPatternParameters::TaskLinearPatternParameters(ViewProviderTransformed *TransformedView,QWidget *parent) +TaskLinearPatternParameters::TaskLinearPatternParameters(ViewProviderTransformed* TransformedView, + QWidget* parent) : TaskTransformedParameters(TransformedView, parent) , ui(new Ui_TaskLinearPatternParameters) { setupUI(); } -TaskLinearPatternParameters::TaskLinearPatternParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget) - : TaskTransformedParameters(parentTask), ui(new Ui_TaskLinearPatternParameters) +TaskLinearPatternParameters::TaskLinearPatternParameters(TaskMultiTransformParameters* parentTask, + QWidget* parameterWidget) + : TaskTransformedParameters(parentTask) + , ui(new Ui_TaskLinearPatternParameters) { setupParameterUI(parameterWidget); } -void TaskLinearPatternParameters::setupParameterUI(QWidget *widget) +void TaskLinearPatternParameters::setupParameterUI(QWidget* widget) { ui->setupUi(widget); QMetaObject::connectSlotsByName(this); // Get the feature data - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); ui->spinLength->bind(pcLinearPattern->Length); ui->spinOffset->bind(pcLinearPattern->Offset); @@ -101,16 +105,18 @@ void TaskLinearPatternParameters::setupParameterUI(QWidget *widget) this->fillAxisCombo(dirLinks, nullptr); } - //show the parts coordinate system axis for selection - PartDesign::Body * body = PartDesign::Body::findBodyOf(getObject()); - if(body) { + // show the parts coordinate system axis for selection + PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject()); + if (body) { try { - App::Origin *origin = body->getOrigin(); + App::Origin* origin = body->getOrigin(); ViewProviderOrigin* vpOrigin; - vpOrigin = static_cast(Gui::Application::Instance->getViewProvider(origin)); + vpOrigin = static_cast( + Gui::Application::Instance->getViewProvider(origin)); vpOrigin->setTemporaryVisibility(true, false); - } catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what () ); + } + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } @@ -119,21 +125,35 @@ void TaskLinearPatternParameters::setupParameterUI(QWidget *widget) updateViewTimer = new QTimer(this); updateViewTimer->setSingleShot(true); updateViewTimer->setInterval(getUpdateViewTimeout()); - connect(updateViewTimer, &QTimer::timeout, - this, &TaskLinearPatternParameters::onUpdateViewTimer); + connect(updateViewTimer, + &QTimer::timeout, + this, + &TaskLinearPatternParameters::onUpdateViewTimer); - connect(ui->comboDirection, qOverload(&QComboBox::activated), - this, &TaskLinearPatternParameters::onDirectionChanged); - connect(ui->checkReverse, &QCheckBox::toggled, - this, &TaskLinearPatternParameters::onCheckReverse); - connect(ui->comboMode, qOverload(&QComboBox::activated), - this, &TaskLinearPatternParameters::onModeChanged); - connect(ui->spinLength, qOverload(&Gui::QuantitySpinBox::valueChanged), - this, &TaskLinearPatternParameters::onLength); - connect(ui->spinOffset, qOverload(&Gui::QuantitySpinBox::valueChanged), - this, &TaskLinearPatternParameters::onOffset); - connect(ui->spinOccurrences, &Gui::UIntSpinBox::unsignedChanged, - this, &TaskLinearPatternParameters::onOccurrences); + connect(ui->comboDirection, + qOverload(&QComboBox::activated), + this, + &TaskLinearPatternParameters::onDirectionChanged); + connect(ui->checkReverse, + &QCheckBox::toggled, + this, + &TaskLinearPatternParameters::onCheckReverse); + connect(ui->comboMode, + qOverload(&QComboBox::activated), + this, + &TaskLinearPatternParameters::onModeChanged); + connect(ui->spinLength, + qOverload(&Gui::QuantitySpinBox::valueChanged), + this, + &TaskLinearPatternParameters::onLength); + connect(ui->spinOffset, + qOverload(&Gui::QuantitySpinBox::valueChanged), + this, + &TaskLinearPatternParameters::onOffset); + connect(ui->spinOccurrences, + &Gui::UIntSpinBox::unsignedChanged, + this, + &TaskLinearPatternParameters::onOccurrences); } void TaskLinearPatternParameters::retranslateParameterUI(QWidget* widget) @@ -143,22 +163,26 @@ void TaskLinearPatternParameters::retranslateParameterUI(QWidget* widget) void TaskLinearPatternParameters::updateUI() { - if (blockUpdate) + if (blockUpdate) { return; + } blockUpdate = true; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); - PartDesign::LinearPatternMode mode = static_cast(pcLinearPattern->Mode.getValue()); + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); + PartDesign::LinearPatternMode mode = + static_cast(pcLinearPattern->Mode.getValue()); bool reverse = pcLinearPattern->Reversed.getValue(); double length = pcLinearPattern->Length.getValue(); double offset = pcLinearPattern->Offset.getValue(); unsigned occurrences = pcLinearPattern->Occurrences.getValue(); - if (dirLinks.setCurrentLink(pcLinearPattern->Direction) == -1){ - //failed to set current, because the link isn't in the list yet - dirLinks.addLink(pcLinearPattern->Direction, getRefStr(pcLinearPattern->Direction.getValue(), - pcLinearPattern->Direction.getSubValues())); + if (dirLinks.setCurrentLink(pcLinearPattern->Direction) == -1) { + // failed to set current, because the link isn't in the list yet + dirLinks.addLink(pcLinearPattern->Direction, + getRefStr(pcLinearPattern->Direction.getValue(), + pcLinearPattern->Direction.getSubValues())); dirLinks.setCurrentLink(pcLinearPattern->Direction); } @@ -206,16 +230,18 @@ void TaskLinearPatternParameters::onSelectionChanged(const Gui::SelectionChanges exitSelectionMode(); std::vector directions; App::DocumentObject* selObj = nullptr; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); if (pcLinearPattern) { getReferencedSelection(pcLinearPattern, msg, selObj, directions); // Note: ReferenceSelection has already checked the selection for validity - if (selObj && (selectionMode == SelectionMode::Reference || - selObj->isDerivedFrom(App::Line::getClassTypeId()) || - selObj->isDerivedFrom(Part::Feature::getClassTypeId()) || - selObj->isDerivedFrom(PartDesign::Line::getClassTypeId()) || - selObj->isDerivedFrom(PartDesign::Plane::getClassTypeId()))) { + if (selObj + && (selectionMode == SelectionMode::Reference + || selObj->isDerivedFrom(App::Line::getClassTypeId()) + || selObj->isDerivedFrom(Part::Feature::getClassTypeId()) + || selObj->isDerivedFrom(PartDesign::Line::getClassTypeId()) + || selObj->isDerivedFrom(PartDesign::Plane::getClassTypeId()))) { setupTransaction(); pcLinearPattern->Direction.setValue(selObj, directions); recomputeFeature(); @@ -226,20 +252,26 @@ void TaskLinearPatternParameters::onSelectionChanged(const Gui::SelectionChanges } } -void TaskLinearPatternParameters::onCheckReverse(const bool on) { - if (blockUpdate) +void TaskLinearPatternParameters::onCheckReverse(const bool on) +{ + if (blockUpdate) { return; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + } + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); pcLinearPattern->Reversed.setValue(on); exitSelectionMode(); kickUpdateViewTimer(); } -void TaskLinearPatternParameters::onModeChanged(const int mode) { - if (blockUpdate) +void TaskLinearPatternParameters::onModeChanged(const int mode) +{ + if (blockUpdate) { return; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + } + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); pcLinearPattern->Mode.setValue(mode); adaptVisibilityToMode(); @@ -248,30 +280,39 @@ void TaskLinearPatternParameters::onModeChanged(const int mode) { kickUpdateViewTimer(); } -void TaskLinearPatternParameters::onLength(const double l) { - if (blockUpdate) +void TaskLinearPatternParameters::onLength(const double l) +{ + if (blockUpdate) { return; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + } + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); pcLinearPattern->Length.setValue(l); exitSelectionMode(); kickUpdateViewTimer(); } -void TaskLinearPatternParameters::onOffset(const double o) { - if (blockUpdate) +void TaskLinearPatternParameters::onOffset(const double o) +{ + if (blockUpdate) { return; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + } + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); pcLinearPattern->Offset.setValue(o); exitSelectionMode(); kickUpdateViewTimer(); } -void TaskLinearPatternParameters::onOccurrences(const uint n) { - if (blockUpdate) +void TaskLinearPatternParameters::onOccurrences(const uint n) +{ + if (blockUpdate) { return; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + } + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); pcLinearPattern->Occurrences.setValue(n); exitSelectionMode(); @@ -280,23 +321,28 @@ void TaskLinearPatternParameters::onOccurrences(const uint n) { void TaskLinearPatternParameters::onDirectionChanged(int /*num*/) { - if (blockUpdate) + if (blockUpdate) { return; - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); - try{ + } + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); + try { if (!dirLinks.getCurrentLink().getValue()) { // enter reference selection mode hideObject(); showBase(); selectionMode = SelectionMode::Reference; Gui::Selection().clearSelection(); - addReferenceSelectionGate(AllowSelection::EDGE | AllowSelection::FACE | AllowSelection::PLANAR); - } else { + addReferenceSelectionGate(AllowSelection::EDGE | AllowSelection::FACE + | AllowSelection::PLANAR); + } + else { exitSelectionMode(); pcLinearPattern->Direction.Paste(dirLinks.getCurrentLink()); } - } catch (Base::Exception &e) { - QMessageBox::warning(nullptr,tr("Error"),QApplication::translate("Exception", e.what())); + } + catch (Base::Exception& e) { + QMessageBox::warning(nullptr, tr("Error"), QApplication::translate("Exception", e.what())); } kickUpdateViewTimer(); @@ -307,13 +353,14 @@ void TaskLinearPatternParameters::onUpdateView(bool on) blockUpdate = !on; if (on) { // Do the same like in TaskDlgLinearPatternParameters::accept() but without doCommand - PartDesign::LinearPattern* pcLinearPattern = static_cast(getObject()); + PartDesign::LinearPattern* pcLinearPattern = + static_cast(getObject()); std::vector directions; App::DocumentObject* obj; setupTransaction(); getDirection(obj, directions); - pcLinearPattern->Direction.setValue(obj,directions); + pcLinearPattern->Direction.setValue(obj, directions); pcLinearPattern->Reversed.setValue(getReverse()); pcLinearPattern->Length.setValue(getLength()); pcLinearPattern->Offset.setValue(getOffset()); @@ -323,9 +370,10 @@ void TaskLinearPatternParameters::onUpdateView(bool on) } } -void TaskLinearPatternParameters::getDirection(App::DocumentObject*& obj, std::vector& sub) const +void TaskLinearPatternParameters::getDirection(App::DocumentObject*& obj, + std::vector& sub) const { - const App::PropertyLinkSub &lnk = dirLinks.getCurrentLink(); + const App::PropertyLinkSub& lnk = dirLinks.getCurrentLink(); obj = lnk.getValue(); sub = lnk.getSubValues(); } @@ -358,17 +406,18 @@ unsigned TaskLinearPatternParameters::getOccurrences() const TaskLinearPatternParameters::~TaskLinearPatternParameters() { try { - //hide the parts coordinate system axis for selection - PartDesign::Body * body = PartDesign::Body::findBodyOf(getObject()); + // hide the parts coordinate system axis for selection + PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject()); if (body) { - App::Origin *origin = body->getOrigin(); + App::Origin* origin = body->getOrigin(); ViewProviderOrigin* vpOrigin; - vpOrigin = static_cast(Gui::Application::Instance->getViewProvider(origin)); + vpOrigin = static_cast( + Gui::Application::Instance->getViewProvider(origin)); vpOrigin->resetTemporaryVisibility(); } } - catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what () ); + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } @@ -380,9 +429,9 @@ void TaskLinearPatternParameters::doApply() std::string direction = buildLinkSingleSubPythonStr(obj, directions); auto tobj = getObject(); - FCMD_OBJ_CMD(tobj,"Direction = " << direction); - FCMD_OBJ_CMD(tobj,"Reversed = " << getReverse()); - FCMD_OBJ_CMD(tobj,"Mode = " << getMode()); + FCMD_OBJ_CMD(tobj, "Direction = " << direction); + FCMD_OBJ_CMD(tobj, "Reversed = " << getReverse()); + FCMD_OBJ_CMD(tobj, "Mode = " << getMode()); ui->spinLength->apply(); ui->spinOffset->apply(); ui->spinOccurrences->apply(); @@ -393,7 +442,8 @@ void TaskLinearPatternParameters::doApply() // TaskDialog //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -TaskDlgLinearPatternParameters::TaskDlgLinearPatternParameters(ViewProviderLinearPattern *LinearPatternView) +TaskDlgLinearPatternParameters::TaskDlgLinearPatternParameters( + ViewProviderLinearPattern* LinearPatternView) : TaskDlgTransformedParameters(LinearPatternView) { parameter = new TaskLinearPatternParameters(LinearPatternView); diff --git a/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.h b/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.h index 410a2f0e52..3a2645dc13 100644 --- a/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.h +++ b/src/Mod/PartDesign/Gui/TaskLinearPatternParameters.h @@ -30,27 +30,31 @@ class QTimer; class Ui_TaskLinearPatternParameters; -namespace App { +namespace App +{ class Property; } -namespace Gui { +namespace Gui +{ class ViewProvider; } -namespace PartDesignGui { +namespace PartDesignGui +{ class TaskMultiTransformParameters; -class TaskLinearPatternParameters : public TaskTransformedParameters +class TaskLinearPatternParameters: public TaskTransformedParameters { Q_OBJECT public: /// Constructor for task with ViewProvider - explicit TaskLinearPatternParameters(ViewProviderTransformed *TransformedView, QWidget *parent = nullptr); + explicit TaskLinearPatternParameters(ViewProviderTransformed* TransformedView, + QWidget* parent = nullptr); /// Constructor for task with parent task (MultiTransform mode) - TaskLinearPatternParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget); + TaskLinearPatternParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget); ~TaskLinearPatternParameters() override; protected: @@ -92,14 +96,14 @@ private: /// simulation dialog for the TaskView -class TaskDlgLinearPatternParameters : public TaskDlgTransformedParameters +class TaskDlgLinearPatternParameters: public TaskDlgTransformedParameters { Q_OBJECT public: - explicit TaskDlgLinearPatternParameters(ViewProviderLinearPattern *LinearPatternView); + explicit TaskDlgLinearPatternParameters(ViewProviderLinearPattern* LinearPatternView); }; -} //namespace PartDesignGui +} // namespace PartDesignGui -#endif // GUI_TASKVIEW_TASKAPPERANCE_H +#endif // GUI_TASKVIEW_TASKAPPERANCE_H diff --git a/src/Mod/PartDesign/Gui/TaskMirroredParameters.cpp b/src/Mod/PartDesign/Gui/TaskMirroredParameters.cpp index db694beb3a..6cbd6eba04 100644 --- a/src/Mod/PartDesign/Gui/TaskMirroredParameters.cpp +++ b/src/Mod/PartDesign/Gui/TaskMirroredParameters.cpp @@ -24,7 +24,7 @@ #include "PreCompiled.h" #ifndef _PreComp_ -# include +#include #endif #include @@ -48,48 +48,55 @@ using namespace Gui; /* TRANSLATOR PartDesignGui::TaskMirroredParameters */ -TaskMirroredParameters::TaskMirroredParameters(ViewProviderTransformed *TransformedView, QWidget *parent) +TaskMirroredParameters::TaskMirroredParameters(ViewProviderTransformed* TransformedView, + QWidget* parent) : TaskTransformedParameters(TransformedView, parent) , ui(new Ui_TaskMirroredParameters) { setupUI(); } -TaskMirroredParameters::TaskMirroredParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget) - : TaskTransformedParameters(parentTask), ui(new Ui_TaskMirroredParameters) +TaskMirroredParameters::TaskMirroredParameters(TaskMultiTransformParameters* parentTask, + QWidget* parameterWidget) + : TaskTransformedParameters(parentTask) + , ui(new Ui_TaskMirroredParameters) { setupParameterUI(parameterWidget); } -void TaskMirroredParameters::setupParameterUI(QWidget *widget) +void TaskMirroredParameters::setupParameterUI(QWidget* widget) { ui->setupUi(widget); QMetaObject::connectSlotsByName(this); - connect(ui->comboPlane, qOverload(&QComboBox::activated), - this, &TaskMirroredParameters::onPlaneChanged); + connect(ui->comboPlane, + qOverload(&QComboBox::activated), + this, + &TaskMirroredParameters::onPlaneChanged); this->planeLinks.setCombo(*(ui->comboPlane)); ui->comboPlane->setEnabled(true); App::DocumentObject* sketch = getSketchObject(); if (sketch && sketch->isDerivedFrom(Part::Part2DObject::getClassTypeId())) { - this->fillPlanesCombo(planeLinks,static_cast(sketch)); + this->fillPlanesCombo(planeLinks, static_cast(sketch)); } else { this->fillPlanesCombo(planeLinks, nullptr); } - //show the parts coordinate system planes for selection - PartDesign::Body * body = PartDesign::Body::findBodyOf ( getObject() ); - if(body) { + // show the parts coordinate system planes for selection + PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject()); + if (body) { try { - App::Origin *origin = body->getOrigin(); + App::Origin* origin = body->getOrigin(); ViewProviderOrigin* vpOrigin; - vpOrigin = static_cast(Gui::Application::Instance->getViewProvider(origin)); + vpOrigin = static_cast( + Gui::Application::Instance->getViewProvider(origin)); vpOrigin->setTemporaryVisibility(false, true); - } catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what () ); + } + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } @@ -103,15 +110,18 @@ void TaskMirroredParameters::retranslateParameterUI(QWidget* widget) void TaskMirroredParameters::updateUI() { - if (blockUpdate) + if (blockUpdate) { return; + } blockUpdate = true; PartDesign::Mirrored* pcMirrored = static_cast(getObject()); - if (planeLinks.setCurrentLink(pcMirrored->MirrorPlane) == -1){ - //failed to set current, because the link isn't in the list yet - planeLinks.addLink(pcMirrored->MirrorPlane, getRefStr(pcMirrored->MirrorPlane.getValue(),pcMirrored->MirrorPlane.getSubValues())); + if (planeLinks.setCurrentLink(pcMirrored->MirrorPlane) == -1) { + // failed to set current, because the link isn't in the list yet + planeLinks.addLink( + pcMirrored->MirrorPlane, + getRefStr(pcMirrored->MirrorPlane.getValue(), pcMirrored->MirrorPlane.getSubValues())); planeLinks.setCurrentLink(pcMirrored->MirrorPlane); } @@ -124,15 +134,18 @@ void TaskMirroredParameters::onSelectionChanged(const Gui::SelectionChanges& msg if (originalSelected(msg)) { exitSelectionMode(); - } else { + } + else { std::vector mirrorPlanes; App::DocumentObject* selObj; PartDesign::Mirrored* pcMirrored = static_cast(getObject()); getReferencedSelection(pcMirrored, msg, selObj, mirrorPlanes); - if (!selObj) - return; + if (!selObj) { + return; + } - if ( selectionMode == SelectionMode::Reference || selObj->isDerivedFrom ( App::Plane::getClassTypeId () ) ) { + if (selectionMode == SelectionMode::Reference + || selObj->isDerivedFrom(App::Plane::getClassTypeId())) { setupTransaction(); pcMirrored->MirrorPlane.setValue(selObj, mirrorPlanes); recomputeFeature(); @@ -145,11 +158,12 @@ void TaskMirroredParameters::onSelectionChanged(const Gui::SelectionChanges& msg void TaskMirroredParameters::onPlaneChanged(int /*num*/) { - if (blockUpdate) + if (blockUpdate) { return; + } setupTransaction(); PartDesign::Mirrored* pcMirrored = static_cast(getObject()); - try{ + try { if (!planeLinks.getCurrentLink().getValue()) { // enter reference selection mode hideObject(); @@ -157,12 +171,14 @@ void TaskMirroredParameters::onPlaneChanged(int /*num*/) selectionMode = SelectionMode::Reference; Gui::Selection().clearSelection(); addReferenceSelectionGate(AllowSelection::FACE | AllowSelection::PLANAR); - } else { + } + else { exitSelectionMode(); pcMirrored->MirrorPlane.Paste(planeLinks.getCurrentLink()); } - } catch (Base::Exception &e) { - QMessageBox::warning(nullptr,tr("Error"),QApplication::translate("Exception", e.what())); + } + catch (Base::Exception& e) { + QMessageBox::warning(nullptr, tr("Error"), QApplication::translate("Exception", e.what())); } recomputeFeature(); @@ -179,15 +195,16 @@ void TaskMirroredParameters::onUpdateView(bool on) App::DocumentObject* obj; getMirrorPlane(obj, mirrorPlanes); - pcMirrored->MirrorPlane.setValue(obj,mirrorPlanes); + pcMirrored->MirrorPlane.setValue(obj, mirrorPlanes); recomputeFeature(); } } -void TaskMirroredParameters::getMirrorPlane(App::DocumentObject*& obj, std::vector &sub) const +void TaskMirroredParameters::getMirrorPlane(App::DocumentObject*& obj, + std::vector& sub) const { - const App::PropertyLinkSub &lnk = planeLinks.getCurrentLink(); + const App::PropertyLinkSub& lnk = planeLinks.getCurrentLink(); obj = lnk.getValue(); sub = lnk.getSubValues(); } @@ -199,22 +216,24 @@ void TaskMirroredParameters::doApply() getMirrorPlane(obj, mirrorPlanes); std::string mirrorPlane = buildLinkSingleSubPythonStr(obj, mirrorPlanes); - FCMD_OBJ_CMD(getObject(),"MirrorPlane = " << mirrorPlane); + FCMD_OBJ_CMD(getObject(), "MirrorPlane = " << mirrorPlane); } TaskMirroredParameters::~TaskMirroredParameters() { - //hide the parts coordinate system axis for selection + // hide the parts coordinate system axis for selection try { - PartDesign::Body * body = PartDesign::Body::findBodyOf ( getObject() ); - if ( body ) { - App::Origin *origin = body->getOrigin(); + PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject()); + if (body) { + App::Origin* origin = body->getOrigin(); ViewProviderOrigin* vpOrigin; - vpOrigin = static_cast(Gui::Application::Instance->getViewProvider(origin)); + vpOrigin = static_cast( + Gui::Application::Instance->getViewProvider(origin)); vpOrigin->resetTemporaryVisibility(); } - } catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what () ); + } + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } @@ -223,7 +242,7 @@ TaskMirroredParameters::~TaskMirroredParameters() // TaskDialog //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -TaskDlgMirroredParameters::TaskDlgMirroredParameters(ViewProviderMirrored *MirroredView) +TaskDlgMirroredParameters::TaskDlgMirroredParameters(ViewProviderMirrored* MirroredView) : TaskDlgTransformedParameters(MirroredView) { parameter = new TaskMirroredParameters(MirroredView); diff --git a/src/Mod/PartDesign/Gui/TaskMirroredParameters.h b/src/Mod/PartDesign/Gui/TaskMirroredParameters.h index 641fc590df..9da2d05671 100644 --- a/src/Mod/PartDesign/Gui/TaskMirroredParameters.h +++ b/src/Mod/PartDesign/Gui/TaskMirroredParameters.h @@ -29,27 +29,31 @@ class Ui_TaskMirroredParameters; -namespace App { +namespace App +{ class Property; } -namespace Gui { +namespace Gui +{ class ViewProvider; } -namespace PartDesignGui { +namespace PartDesignGui +{ class TaskMultiTransformParameters; -class TaskMirroredParameters : public TaskTransformedParameters +class TaskMirroredParameters: public TaskTransformedParameters { Q_OBJECT public: /// Constructor for task with ViewProvider - explicit TaskMirroredParameters(ViewProviderTransformed *TransformedView, QWidget *parent = nullptr); + explicit TaskMirroredParameters(ViewProviderTransformed* TransformedView, + QWidget* parent = nullptr); /// Constructor for task with parent task (MultiTransform mode) - TaskMirroredParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget); + TaskMirroredParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget); ~TaskMirroredParameters() override; @@ -74,14 +78,14 @@ private: /// simulation dialog for the TaskView -class TaskDlgMirroredParameters : public TaskDlgTransformedParameters +class TaskDlgMirroredParameters: public TaskDlgTransformedParameters { Q_OBJECT public: - explicit TaskDlgMirroredParameters(ViewProviderMirrored *MirroredView); + explicit TaskDlgMirroredParameters(ViewProviderMirrored* MirroredView); }; -} //namespace PartDesignGui +} // namespace PartDesignGui -#endif // GUI_TASKVIEW_TASKAPPERANCE_H +#endif // GUI_TASKVIEW_TASKAPPERANCE_H diff --git a/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.cpp b/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.cpp index e903839601..65fde209b3 100644 --- a/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.cpp +++ b/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.cpp @@ -24,7 +24,7 @@ #include "PreCompiled.h" #ifndef _PreComp_ -# include +#include #endif #include @@ -54,63 +54,80 @@ using namespace Gui; /* TRANSLATOR PartDesignGui::TaskMultiTransformParameters */ -TaskMultiTransformParameters::TaskMultiTransformParameters(ViewProviderTransformed *TransformedView,QWidget *parent) +TaskMultiTransformParameters::TaskMultiTransformParameters(ViewProviderTransformed* TransformedView, + QWidget* parent) : TaskTransformedParameters(TransformedView, parent) , ui(new Ui_TaskMultiTransformParameters) { setupUI(); } -void TaskMultiTransformParameters::setupParameterUI(QWidget *widget) +void TaskMultiTransformParameters::setupParameterUI(QWidget* widget) { ui->setupUi(widget); QMetaObject::connectSlotsByName(this); // Create a context menu for the listview of transformation features QAction* action = new QAction(tr("Edit"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onTransformEdit); + action->connect(action, + &QAction::triggered, + this, + &TaskMultiTransformParameters::onTransformEdit); ui->listTransformFeatures->addAction(action); action = new QAction(tr("Delete"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onTransformDelete); + action->connect(action, + &QAction::triggered, + this, + &TaskMultiTransformParameters::onTransformDelete); ui->listTransformFeatures->addAction(action); action = new QAction(tr("Add mirrored transformation"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onTransformAddMirrored); + action->connect(action, + &QAction::triggered, + this, + &TaskMultiTransformParameters::onTransformAddMirrored); ui->listTransformFeatures->addAction(action); action = new QAction(tr("Add linear pattern"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onTransformAddLinearPattern); + action->connect(action, + &QAction::triggered, + this, + &TaskMultiTransformParameters::onTransformAddLinearPattern); ui->listTransformFeatures->addAction(action); action = new QAction(tr("Add polar pattern"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onTransformAddPolarPattern); + action->connect(action, + &QAction::triggered, + this, + &TaskMultiTransformParameters::onTransformAddPolarPattern); ui->listTransformFeatures->addAction(action); action = new QAction(tr("Add scaled transformation"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onTransformAddScaled); + action->connect(action, + &QAction::triggered, + this, + &TaskMultiTransformParameters::onTransformAddScaled); ui->listTransformFeatures->addAction(action); action = new QAction(tr("Move up"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onMoveUp); + action->connect(action, &QAction::triggered, this, &TaskMultiTransformParameters::onMoveUp); ui->listTransformFeatures->addAction(action); action = new QAction(tr("Move down"), ui->listTransformFeatures); - action->connect(action, &QAction::triggered, - this, &TaskMultiTransformParameters::onMoveDown); + action->connect(action, &QAction::triggered, this, &TaskMultiTransformParameters::onMoveDown); ui->listTransformFeatures->addAction(action); ui->listTransformFeatures->setContextMenuPolicy(Qt::ActionsContextMenu); - connect(ui->listTransformFeatures, &QListWidget::activated, - this, &TaskMultiTransformParameters::onTransformActivated); + connect(ui->listTransformFeatures, + &QListWidget::activated, + this, + &TaskMultiTransformParameters::onTransformActivated); - connect(ui->buttonOK, &QToolButton::pressed, - this, &TaskMultiTransformParameters::onSubTaskButtonOK); + connect(ui->buttonOK, + &QToolButton::pressed, + this, + &TaskMultiTransformParameters::onSubTaskButtonOK); ui->buttonOK->hide(); // Get the transformFeatures data - PartDesign::MultiTransform* pcMultiTransform = static_cast(TransformedView->getObject()); - std::vector transformFeatures = pcMultiTransform->Transformations.getValues(); + PartDesign::MultiTransform* pcMultiTransform = + static_cast(TransformedView->getObject()); + std::vector transformFeatures = + pcMultiTransform->Transformations.getValues(); // Fill data into dialog elements ui->listTransformFeatures->setEnabled(true); @@ -123,7 +140,8 @@ void TaskMultiTransformParameters::setupParameterUI(QWidget *widget) if (!transformFeatures.empty()) { ui->listTransformFeatures->setCurrentRow(0, QItemSelectionModel::ClearAndSelect); editHint = false; - } else { + } + else { ui->listTransformFeatures->addItem(tr("Right-click to add")); editHint = true; } @@ -136,8 +154,9 @@ void TaskMultiTransformParameters::retranslateParameterUI(QWidget* widget) void TaskMultiTransformParameters::slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj) { - if (Obj.getObject() == this->subFeature) + if (Obj.getObject() == this->subFeature) { this->subFeature = nullptr; + } TaskTransformedParameters::slotDeletedObject(Obj); } @@ -150,8 +169,10 @@ void TaskMultiTransformParameters::closeSubTask() // Remove all parameter ui widgets and layout ui->subFeatureWidget->setUpdatesEnabled(false); - qDeleteAll(ui->subFeatureWidget->findChildren(QString(), Qt::FindDirectChildrenOnly)); - qDeleteAll(ui->subFeatureWidget->findChildren(QString(), Qt::FindDirectChildrenOnly)); + qDeleteAll( + ui->subFeatureWidget->findChildren(QString(), Qt::FindDirectChildrenOnly)); + qDeleteAll( + ui->subFeatureWidget->findChildren(QString(), Qt::FindDirectChildrenOnly)); ui->subFeatureWidget->setUpdatesEnabled(true); delete subTask; @@ -161,15 +182,19 @@ void TaskMultiTransformParameters::closeSubTask() void TaskMultiTransformParameters::onTransformDelete() { - if (editHint) - return; // Can't delete the hint... + if (editHint) { + return; // Can't delete the hint... + } int row = ui->listTransformFeatures->currentIndex().row(); - PartDesign::MultiTransform* pcMultiTransform = static_cast(TransformedView->getObject()); - std::vector transformFeatures = pcMultiTransform->Transformations.getValues(); + PartDesign::MultiTransform* pcMultiTransform = + static_cast(TransformedView->getObject()); + std::vector transformFeatures = + pcMultiTransform->Transformations.getValues(); App::DocumentObject* feature = transformFeatures[row]; - if (feature == this->subFeature) + if (feature == this->subFeature) { this->subFeature = nullptr; + } setupTransaction(); pcMultiTransform->getDocument()->removeObject(feature->getNameInDocument()); @@ -177,8 +202,8 @@ void TaskMultiTransformParameters::onTransformDelete() transformFeatures.erase(transformFeatures.begin() + row); pcMultiTransform->Transformations.setValues(transformFeatures); - // Note: When the last transformation is deleted, recomputeFeature does nothing, because Transformed::execute() - // says: "No transformations defined, exit silently" + // Note: When the last transformation is deleted, recomputeFeature does nothing, because + // Transformed::execute() says: "No transformations defined, exit silently" recomputeFeature(); ui->listTransformFeatures->model()->removeRow(row); @@ -187,25 +212,34 @@ void TaskMultiTransformParameters::onTransformDelete() void TaskMultiTransformParameters::onTransformEdit() { - if (editHint) - return; // Can't edit the hint... - closeSubTask(); // For example if user is editing one subTask and then double-clicks on another without OK'ing first + if (editHint) { + return; // Can't edit the hint... + } + closeSubTask(); // For example if user is editing one subTask and then double-clicks on another + // without OK'ing first ui->listTransformFeatures->currentItem()->setSelected(true); int row = ui->listTransformFeatures->currentIndex().row(); - PartDesign::MultiTransform* pcMultiTransform = static_cast(TransformedView->getObject()); - std::vector transformFeatures = pcMultiTransform->Transformations.getValues(); + PartDesign::MultiTransform* pcMultiTransform = + static_cast(TransformedView->getObject()); + std::vector transformFeatures = + pcMultiTransform->Transformations.getValues(); subFeature = static_cast(transformFeatures[row]); - if (subFeature->is()) + if (subFeature->is()) { subTask = new TaskMirroredParameters(this, ui->subFeatureWidget); - else if (subFeature->is()) + } + else if (subFeature->is()) { subTask = new TaskLinearPatternParameters(this, ui->subFeatureWidget); - else if (subFeature->is()) + } + else if (subFeature->is()) { subTask = new TaskPolarPatternParameters(this, ui->subFeatureWidget); - else if (subFeature->is()) + } + else if (subFeature->is()) { subTask = new TaskScaledParameters(this, ui->subFeatureWidget); - else - return; // TODO: Show an error? + } + else { + return; // TODO: Show an error? + } ui->buttonOK->show(); @@ -221,30 +255,38 @@ void TaskMultiTransformParameters::onTransformActivated(const QModelIndex& index void TaskMultiTransformParameters::onTransformAddMirrored() { closeSubTask(); - std::string newFeatName = TransformedView->getObject()->getDocument()->getUniqueObjectName("Mirrored"); + std::string newFeatName = + TransformedView->getObject()->getDocument()->getUniqueObjectName("Mirrored"); auto pcActiveBody = PartDesignGui::getBody(false); - if (!pcActiveBody) + if (!pcActiveBody) { return; + } - if (isEnabledTransaction()) + if (isEnabledTransaction()) { Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Mirrored")); + } - FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::Mirrored','"<getDocument()->getObject(newFeatName.c_str()); - if (!Feat) + if (!Feat) { return; - //Gui::Command::updateActive(); + } + // Gui::Command::updateActive(); App::DocumentObject* sketch = getSketchObject(); - if (sketch) - FCMD_OBJ_CMD(Feat, "MirrorPlane = ("<getOrigin(); - FCMD_OBJ_CMD(Feat, "MirrorPlane = ("<getXY())<<",[''])"); + FCMD_OBJ_CMD(Feat, + "MirrorPlane = (" << Gui::Command::getObjectCmd(orig->getXY()) << ",[''])"); } finishAdd(newFeatName); // show the new view when no error - if (!Feat->isError()) + if (!Feat->isError()) { TransformedView->getObject()->Visibility.setValue(true); + } } void TaskMultiTransformParameters::onTransformAddLinearPattern() @@ -252,29 +294,36 @@ void TaskMultiTransformParameters::onTransformAddLinearPattern() // See CmdPartDesignLinearPattern // closeSubTask(); - std::string newFeatName = TransformedView->getObject()->getDocument()->getUniqueObjectName("LinearPattern"); + std::string newFeatName = + TransformedView->getObject()->getDocument()->getUniqueObjectName("LinearPattern"); auto pcActiveBody = PartDesignGui::getBody(false); - if (!pcActiveBody) + if (!pcActiveBody) { return; + } - if (isEnabledTransaction()) + if (isEnabledTransaction()) { Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Make LinearPattern")); + } - FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::LinearPattern','"<getDocument()->getObject(newFeatName.c_str()); - if (!Feat) + if (!Feat) { return; - //Gui::Command::updateActive(); + } + // Gui::Command::updateActive(); App::DocumentObject* sketch = getSketchObject(); if (sketch) { - FCMD_OBJ_CMD(Feat, "Direction = ("<(Part::BodyBase::findBodyOf(getObject())); + PartDesign::Body* body = + static_cast(Part::BodyBase::findBodyOf(getObject())); if (body) { - FCMD_OBJ_CMD(Feat, "Direction = ("<getOrigin()->getX())<<",[''])"); + FCMD_OBJ_CMD(Feat, + "Direction = (" << Gui::Command::getObjectCmd(body->getOrigin()->getX()) + << ",[''])"); } } @@ -283,75 +332,90 @@ void TaskMultiTransformParameters::onTransformAddLinearPattern() finishAdd(newFeatName); // show the new view when no error - if (!Feat->isError()) + if (!Feat->isError()) { TransformedView->getObject()->Visibility.setValue(true); + } } void TaskMultiTransformParameters::onTransformAddPolarPattern() { closeSubTask(); - std::string newFeatName = TransformedView->getObject()->getDocument()->getUniqueObjectName("PolarPattern"); + std::string newFeatName = + TransformedView->getObject()->getDocument()->getUniqueObjectName("PolarPattern"); auto pcActiveBody = PartDesignGui::getBody(false); - if (!pcActiveBody) + if (!pcActiveBody) { return; + } - if (isEnabledTransaction()) + if (isEnabledTransaction()) { Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "PolarPattern")); + } - FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::PolarPattern','"<getDocument()->getObject(newFeatName.c_str()); - if (!Feat) + if (!Feat) { return; - //Gui::Command::updateActive(); + } + // Gui::Command::updateActive(); App::DocumentObject* sketch = getSketchObject(); - if (sketch) - FCMD_OBJ_CMD(Feat, "Axis = ("<getOrigin(); - FCMD_OBJ_CMD(Feat, "Axis = ("<getX())<<",[''])"); + FCMD_OBJ_CMD(Feat, "Axis = (" << Gui::Command::getObjectCmd(orig->getX()) << ",[''])"); } FCMD_OBJ_CMD(Feat, "Angle = 360"); FCMD_OBJ_CMD(Feat, "Occurrences = 2"); finishAdd(newFeatName); // show the new view when no error - if (!Feat->isError()) + if (!Feat->isError()) { TransformedView->getObject()->Visibility.setValue(true); + } } void TaskMultiTransformParameters::onTransformAddScaled() { closeSubTask(); - std::string newFeatName = TransformedView->getObject()->getDocument()->getUniqueObjectName("Scaled"); + std::string newFeatName = + TransformedView->getObject()->getDocument()->getUniqueObjectName("Scaled"); auto pcActiveBody = PartDesignGui::getBody(false); - if (!pcActiveBody) + if (!pcActiveBody) { return; + } - if (isEnabledTransaction()) + if (isEnabledTransaction()) { Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Scaled")); + } - FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::Scaled','"<getDocument()->getObject(newFeatName.c_str()); - if (!Feat) + if (!Feat) { return; - //Gui::Command::updateActive(); + } + // Gui::Command::updateActive(); FCMD_OBJ_CMD(Feat, "Factor = 2"); FCMD_OBJ_CMD(Feat, "Occurrences = 2"); finishAdd(newFeatName); // show the new view when no error - if (!Feat->isError()) + if (!Feat->isError()) { TransformedView->getObject()->Visibility.setValue(true); + } } -void TaskMultiTransformParameters::finishAdd(std::string &newFeatName) +void TaskMultiTransformParameters::finishAdd(std::string& newFeatName) { - //Gui::Command::updateActive(); - //Gui::Command::copyVisual(newFeatName.c_str(), "ShapeColor", getOriginals().front()->getNameInDocument().c_str()); - //Gui::Command::copyVisual(newFeatName.c_str(), "DisplayMode", getOriginals().front()->getNameInDocument().c_str()); + // Gui::Command::updateActive(); + // Gui::Command::copyVisual(newFeatName.c_str(), "ShapeColor", + // getOriginals().front()->getNameInDocument().c_str()); + // Gui::Command::copyVisual(newFeatName.c_str(), "DisplayMode", + // getOriginals().front()->getNameInDocument().c_str()); setupTransaction(); - PartDesign::MultiTransform* pcMultiTransform = static_cast(TransformedView->getObject()); + PartDesign::MultiTransform* pcMultiTransform = + static_cast(TransformedView->getObject()); if (editHint) { // Remove hint, first feature is being added ui->listTransformFeatures->model()->removeRow(0); @@ -359,24 +423,30 @@ void TaskMultiTransformParameters::finishAdd(std::string &newFeatName) int row = ui->listTransformFeatures->currentIndex().row(); if (row < 0) { // Happens when first row (first transformation) is created - // Hide all the originals now (hiding them in Command.cpp presents the user with an empty screen!) + // Hide all the originals now (hiding them in Command.cpp presents the user with an empty + // screen!) hideBase(); } // Insert new transformation after the selected row - // This means that in order to insert at the beginning, the user has to use "Move Up" in the menu - App::DocumentObject* newFeature = pcMultiTransform->getDocument()->getObject(newFeatName.c_str()); - std::vector transformFeatures = pcMultiTransform->Transformations.getValues(); + // This means that in order to insert at the beginning, the user has to use "Move Up" in the + // menu + App::DocumentObject* newFeature = + pcMultiTransform->getDocument()->getObject(newFeatName.c_str()); + std::vector transformFeatures = + pcMultiTransform->Transformations.getValues(); if (row == ui->listTransformFeatures->model()->rowCount() - 1) { // Note: Inserts always happen before the specified iterator so in order to append at the // end we need to use push_back() and append() transformFeatures.push_back(newFeature); ui->listTransformFeatures->addItem(QString::fromLatin1(newFeature->Label.getValue())); - ui->listTransformFeatures->setCurrentRow(row+1, QItemSelectionModel::ClearAndSelect); - } else { + ui->listTransformFeatures->setCurrentRow(row + 1, QItemSelectionModel::ClearAndSelect); + } + else { // Note: The feature tree always seems to append to the end, no matter what we say here transformFeatures.insert(transformFeatures.begin() + row + 1, newFeature); - ui->listTransformFeatures->insertItem(row + 1, QString::fromLatin1(newFeature->Label.getValue())); + ui->listTransformFeatures->insertItem(row + 1, + QString::fromLatin1(newFeature->Label.getValue())); ui->listTransformFeatures->setCurrentRow(row + 1, QItemSelectionModel::ClearAndSelect); } pcMultiTransform->Transformations.setValues(transformFeatures); @@ -394,11 +464,14 @@ void TaskMultiTransformParameters::moveTransformFeature(const int increment) { setupTransaction(); int row = ui->listTransformFeatures->currentIndex().row(); - PartDesign::MultiTransform* pcMultiTransform = static_cast(TransformedView->getObject()); - std::vector transformFeatures = pcMultiTransform->Transformations.getValues(); + PartDesign::MultiTransform* pcMultiTransform = + static_cast(TransformedView->getObject()); + std::vector transformFeatures = + pcMultiTransform->Transformations.getValues(); - if (transformFeatures.empty()) + if (transformFeatures.empty()) { return; + } App::DocumentObject* feature = transformFeatures[row]; transformFeatures.erase(transformFeatures.begin() + row); @@ -408,8 +481,9 @@ void TaskMultiTransformParameters::moveTransformFeature(const int increment) row += increment; - if (row < 0) + if (row < 0) { row = 0; + } if (row >= ui->listTransformFeatures->model()->rowCount()) { // Note: Inserts always happen before the specified iterator so in order to append at the @@ -417,7 +491,8 @@ void TaskMultiTransformParameters::moveTransformFeature(const int increment) transformFeatures.push_back(feature); ui->listTransformFeatures->addItem(item); ui->listTransformFeatures->setCurrentRow(row, QItemSelectionModel::ClearAndSelect); - } else { + } + else { transformFeatures.insert(transformFeatures.begin() + row, feature); ui->listTransformFeatures->insertItem(row, item); ui->listTransformFeatures->setCurrentRow(row, QItemSelectionModel::ClearAndSelect); @@ -452,8 +527,10 @@ void TaskMultiTransformParameters::onUpdateView(bool on) void TaskMultiTransformParameters::doApply() { - PartDesign::MultiTransform* pcMultiTransform = static_cast(getObject()); - std::vector transformFeatures = pcMultiTransform->Transformations.getValues(); + PartDesign::MultiTransform* pcMultiTransform = + static_cast(getObject()); + std::vector transformFeatures = + pcMultiTransform->Transformations.getValues(); std::stringstream str; str << Gui::Command::getObjectCmd(TransformedView->getObject()) << ".Transformations = ["; for (auto it : transformFeatures) { @@ -462,7 +539,7 @@ void TaskMultiTransformParameters::doApply() } } str << "]"; - Gui::Command::runCommand(Gui::Command::Doc,str.str().c_str()); + Gui::Command::runCommand(Gui::Command::Doc, str.str().c_str()); } TaskMultiTransformParameters::~TaskMultiTransformParameters() @@ -471,7 +548,7 @@ TaskMultiTransformParameters::~TaskMultiTransformParameters() closeSubTask(); } catch (const Py::Exception&) { - Base::PyException e; // extract the Python error text + Base::PyException e; // extract the Python error text e.ReportException(); } } @@ -481,7 +558,8 @@ TaskMultiTransformParameters::~TaskMultiTransformParameters() // TaskDialog //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -TaskDlgMultiTransformParameters::TaskDlgMultiTransformParameters(ViewProviderMultiTransform *MultiTransformView) +TaskDlgMultiTransformParameters::TaskDlgMultiTransformParameters( + ViewProviderMultiTransform* MultiTransformView) : TaskDlgTransformedParameters(MultiTransformView) { parameter = new TaskMultiTransformParameters(MultiTransformView); diff --git a/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.h b/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.h index feb3730dcb..30a84f4bea 100644 --- a/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.h +++ b/src/Mod/PartDesign/Gui/TaskMultiTransformParameters.h @@ -30,32 +30,37 @@ class Ui_TaskMultiTransformParameters; class QModelIndex; -namespace PartDesign { +namespace PartDesign +{ class Transformed; } -namespace App { +namespace App +{ class Property; } -namespace Gui { +namespace Gui +{ class ViewProvider; } -namespace PartDesignGui { +namespace PartDesignGui +{ - -class TaskMultiTransformParameters : public TaskTransformedParameters +class TaskMultiTransformParameters: public TaskTransformedParameters { Q_OBJECT public: - explicit TaskMultiTransformParameters(ViewProviderTransformed *TransformedView,QWidget *parent = nullptr); + explicit TaskMultiTransformParameters(ViewProviderTransformed* TransformedView, + QWidget* parent = nullptr); ~TaskMultiTransformParameters() override; /// Return the currently active subFeature - PartDesign::Transformed* getSubFeature() { + PartDesign::Transformed* getSubFeature() + { return subFeature; } @@ -86,7 +91,7 @@ private: void updateUI(); void closeSubTask(); void moveTransformFeature(const int increment); - void finishAdd(std::string &newFeatName); + void finishAdd(std::string& newFeatName); private: std::unique_ptr ui; @@ -98,17 +103,17 @@ private: /// simulation dialog for the TaskView -class TaskDlgMultiTransformParameters : public TaskDlgTransformedParameters +class TaskDlgMultiTransformParameters: public TaskDlgTransformedParameters { Q_OBJECT public: - explicit TaskDlgMultiTransformParameters(ViewProviderMultiTransform *MultiTransformView); + explicit TaskDlgMultiTransformParameters(ViewProviderMultiTransform* MultiTransformView); /// is called by the framework if the dialog is rejected (Cancel) // virtual bool reject(); }; -} //namespace PartDesignGui +} // namespace PartDesignGui -#endif // GUI_TASKVIEW_TASKAPPERANCE_H +#endif // GUI_TASKVIEW_TASKAPPERANCE_H diff --git a/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.cpp b/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.cpp index db282a28f4..0afe933dd9 100644 --- a/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.cpp +++ b/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.cpp @@ -24,8 +24,8 @@ #include "PreCompiled.h" #ifndef _PreComp_ -# include -# include +#include +#include #endif #include @@ -59,20 +59,23 @@ using namespace Gui; /* TRANSLATOR PartDesignGui::TaskPolarPatternParameters */ -TaskPolarPatternParameters::TaskPolarPatternParameters(ViewProviderTransformed *TransformedView,QWidget *parent) +TaskPolarPatternParameters::TaskPolarPatternParameters(ViewProviderTransformed* TransformedView, + QWidget* parent) : TaskTransformedParameters(TransformedView, parent) , ui(new Ui_TaskPolarPatternParameters) { setupUI(); } -TaskPolarPatternParameters::TaskPolarPatternParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget) - : TaskTransformedParameters(parentTask), ui(new Ui_TaskPolarPatternParameters) +TaskPolarPatternParameters::TaskPolarPatternParameters(TaskMultiTransformParameters* parentTask, + QWidget* parameterWidget) + : TaskTransformedParameters(parentTask) + , ui(new Ui_TaskPolarPatternParameters) { setupParameterUI(parameterWidget); } -void TaskPolarPatternParameters::setupParameterUI(QWidget *widget) +void TaskPolarPatternParameters::setupParameterUI(QWidget* widget) { ui->setupUi(widget); QMetaObject::connectSlotsByName(this); @@ -102,17 +105,19 @@ void TaskPolarPatternParameters::setupParameterUI(QWidget *widget) this->fillAxisCombo(axesLinks, nullptr); } - //show the parts coordinate system axis for selection - PartDesign::Body * body = PartDesign::Body::findBodyOf ( getObject() ); + // show the parts coordinate system axis for selection + PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject()); - if(body) { + if (body) { try { - App::Origin *origin = body->getOrigin(); + App::Origin* origin = body->getOrigin(); ViewProviderOrigin* vpOrigin; - vpOrigin = static_cast(Gui::Application::Instance->getViewProvider(origin)); + vpOrigin = static_cast( + Gui::Application::Instance->getViewProvider(origin)); vpOrigin->setTemporaryVisibility(true, false); - } catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what () ); + } + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } @@ -122,20 +127,34 @@ void TaskPolarPatternParameters::setupParameterUI(QWidget *widget) updateViewTimer = new QTimer(this); updateViewTimer->setSingleShot(true); updateViewTimer->setInterval(getUpdateViewTimeout()); - connect(updateViewTimer, &QTimer::timeout, - this, &TaskPolarPatternParameters::onUpdateViewTimer); - connect(ui->comboAxis, qOverload(&QComboBox::activated), - this, &TaskPolarPatternParameters::onAxisChanged); - connect(ui->comboMode, qOverload(&QComboBox::activated), - this, &TaskPolarPatternParameters::onModeChanged); - connect(ui->checkReverse, &QCheckBox::toggled, - this, &TaskPolarPatternParameters::onCheckReverse); - connect(ui->polarAngle, qOverload(&Gui::QuantitySpinBox::valueChanged), - this, &TaskPolarPatternParameters::onAngle); - connect(ui->angleOffset, qOverload(&Gui::QuantitySpinBox::valueChanged), - this, &TaskPolarPatternParameters::onOffset); - connect(ui->spinOccurrences, &Gui::UIntSpinBox::unsignedChanged, - this, &TaskPolarPatternParameters::onOccurrences); + connect(updateViewTimer, + &QTimer::timeout, + this, + &TaskPolarPatternParameters::onUpdateViewTimer); + connect(ui->comboAxis, + qOverload(&QComboBox::activated), + this, + &TaskPolarPatternParameters::onAxisChanged); + connect(ui->comboMode, + qOverload(&QComboBox::activated), + this, + &TaskPolarPatternParameters::onModeChanged); + connect(ui->checkReverse, + &QCheckBox::toggled, + this, + &TaskPolarPatternParameters::onCheckReverse); + connect(ui->polarAngle, + qOverload(&Gui::QuantitySpinBox::valueChanged), + this, + &TaskPolarPatternParameters::onAngle); + connect(ui->angleOffset, + qOverload(&Gui::QuantitySpinBox::valueChanged), + this, + &TaskPolarPatternParameters::onOffset); + connect(ui->spinOccurrences, + &Gui::UIntSpinBox::unsignedChanged, + this, + &TaskPolarPatternParameters::onOccurrences); } void TaskPolarPatternParameters::retranslateParameterUI(QWidget* widget) @@ -145,21 +164,25 @@ void TaskPolarPatternParameters::retranslateParameterUI(QWidget* widget) void TaskPolarPatternParameters::updateUI() { - if (blockUpdate) + if (blockUpdate) { return; + } blockUpdate = true; PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); - PartDesign::PolarPatternMode mode = static_cast(pcPolarPattern->Mode.getValue()); + PartDesign::PolarPatternMode mode = + static_cast(pcPolarPattern->Mode.getValue()); bool reverse = pcPolarPattern->Reversed.getValue(); double angle = pcPolarPattern->Angle.getValue(); double offset = pcPolarPattern->Offset.getValue(); unsigned occurrences = pcPolarPattern->Occurrences.getValue(); if (axesLinks.setCurrentLink(pcPolarPattern->Axis) == -1) { - //failed to set current, because the link isn't in the list yet - axesLinks.addLink(pcPolarPattern->Axis, getRefStr(pcPolarPattern->Axis.getValue(),pcPolarPattern->Axis.getSubValues())); + // failed to set current, because the link isn't in the list yet + axesLinks.addLink( + pcPolarPattern->Axis, + getRefStr(pcPolarPattern->Axis.getValue(), pcPolarPattern->Axis.getSubValues())); axesLinks.setCurrentLink(pcPolarPattern->Axis); } @@ -204,12 +227,15 @@ void TaskPolarPatternParameters::onSelectionChanged(const Gui::SelectionChanges& else { std::vector axes; App::DocumentObject* selObj; - PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); + PartDesign::PolarPattern* pcPolarPattern = + static_cast(getObject()); getReferencedSelection(pcPolarPattern, msg, selObj, axes); - if(!selObj) - return; + if (!selObj) { + return; + } - if (selectionMode == SelectionMode::Reference || selObj->isDerivedFrom ( App::Line::getClassTypeId () ) ) { + if (selectionMode == SelectionMode::Reference + || selObj->isDerivedFrom(App::Line::getClassTypeId())) { setupTransaction(); pcPolarPattern->Axis.setValue(selObj, axes); recomputeFeature(); @@ -220,9 +246,11 @@ void TaskPolarPatternParameters::onSelectionChanged(const Gui::SelectionChanges& } } -void TaskPolarPatternParameters::onCheckReverse(const bool on) { - if (blockUpdate) +void TaskPolarPatternParameters::onCheckReverse(const bool on) +{ + if (blockUpdate) { return; + } PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); pcPolarPattern->Reversed.setValue(on); @@ -230,9 +258,11 @@ void TaskPolarPatternParameters::onCheckReverse(const bool on) { kickUpdateViewTimer(); } -void TaskPolarPatternParameters::onModeChanged(const int mode) { - if (blockUpdate) +void TaskPolarPatternParameters::onModeChanged(const int mode) +{ + if (blockUpdate) { return; + } PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); pcPolarPattern->Mode.setValue(mode); @@ -242,9 +272,11 @@ void TaskPolarPatternParameters::onModeChanged(const int mode) { kickUpdateViewTimer(); } -void TaskPolarPatternParameters::onAngle(const double a) { - if (blockUpdate) +void TaskPolarPatternParameters::onAngle(const double a) +{ + if (blockUpdate) { return; + } PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); pcPolarPattern->Angle.setValue(a); @@ -252,9 +284,11 @@ void TaskPolarPatternParameters::onAngle(const double a) { kickUpdateViewTimer(); } -void TaskPolarPatternParameters::onOffset(const double a) { - if (blockUpdate) +void TaskPolarPatternParameters::onOffset(const double a) +{ + if (blockUpdate) { return; + } PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); pcPolarPattern->Offset.setValue(a); @@ -262,9 +296,11 @@ void TaskPolarPatternParameters::onOffset(const double a) { kickUpdateViewTimer(); } -void TaskPolarPatternParameters::onOccurrences(const uint n) { - if (blockUpdate) +void TaskPolarPatternParameters::onOccurrences(const uint n) +{ + if (blockUpdate) { return; + } PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); pcPolarPattern->Occurrences.setValue(n); @@ -274,11 +310,12 @@ void TaskPolarPatternParameters::onOccurrences(const uint n) { void TaskPolarPatternParameters::onAxisChanged(int /*num*/) { - if (blockUpdate) + if (blockUpdate) { return; + } PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); - try{ + try { if (!axesLinks.getCurrentLink().getValue()) { // enter reference selection mode hideObject(); @@ -286,12 +323,14 @@ void TaskPolarPatternParameters::onAxisChanged(int /*num*/) selectionMode = SelectionMode::Reference; Gui::Selection().clearSelection(); addReferenceSelectionGate(AllowSelection::EDGE | AllowSelection::CIRCLE); - } else { + } + else { exitSelectionMode(); pcPolarPattern->Axis.Paste(axesLinks.getCurrentLink()); } - } catch (Base::Exception &e) { - QMessageBox::warning(nullptr,tr("Error"),QApplication::translate("Exception", e.what())); + } + catch (Base::Exception& e) { + QMessageBox::warning(nullptr, tr("Error"), QApplication::translate("Exception", e.what())); } kickUpdateViewTimer(); @@ -302,13 +341,14 @@ void TaskPolarPatternParameters::onUpdateView(bool on) blockUpdate = !on; if (on) { // Do the same like in TaskDlgPolarPatternParameters::accept() but without doCommand - PartDesign::PolarPattern* pcPolarPattern = static_cast(getObject()); + PartDesign::PolarPattern* pcPolarPattern = + static_cast(getObject()); std::vector axes; App::DocumentObject* obj; setupTransaction(); getAxis(obj, axes); - pcPolarPattern->Axis.setValue(obj,axes); + pcPolarPattern->Axis.setValue(obj, axes); pcPolarPattern->Reversed.setValue(getReverse()); pcPolarPattern->Angle.setValue(getAngle()); pcPolarPattern->Occurrences.setValue(getOccurrences()); @@ -317,9 +357,10 @@ void TaskPolarPatternParameters::onUpdateView(bool on) } } -void TaskPolarPatternParameters::getAxis(App::DocumentObject*& obj, std::vector& sub) const +void TaskPolarPatternParameters::getAxis(App::DocumentObject*& obj, + std::vector& sub) const { - const App::PropertyLinkSub &lnk = axesLinks.getCurrentLink(); + const App::PropertyLinkSub& lnk = axesLinks.getCurrentLink(); obj = lnk.getValue(); sub = lnk.getSubValues(); } @@ -347,17 +388,19 @@ unsigned TaskPolarPatternParameters::getOccurrences() const TaskPolarPatternParameters::~TaskPolarPatternParameters() { - //hide the parts coordinate system axis for selection + // hide the parts coordinate system axis for selection try { - PartDesign::Body * body = PartDesign::Body::findBodyOf ( getObject() ); - if ( body ) { - App::Origin *origin = body->getOrigin(); + PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject()); + if (body) { + App::Origin* origin = body->getOrigin(); ViewProviderOrigin* vpOrigin; - vpOrigin = static_cast(Gui::Application::Instance->getViewProvider(origin)); - vpOrigin->resetTemporaryVisibility (); + vpOrigin = static_cast( + Gui::Application::Instance->getViewProvider(origin)); + vpOrigin->resetTemporaryVisibility(); } - } catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what () ); + } + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } @@ -369,9 +412,9 @@ void TaskPolarPatternParameters::doApply() std::string axis = buildLinkSingleSubPythonStr(obj, axes); auto tobj = getObject(); - FCMD_OBJ_CMD(tobj,"Axis = " << axis.c_str()); - FCMD_OBJ_CMD(tobj,"Reversed = " << getReverse()); - FCMD_OBJ_CMD(tobj,"Mode = " << getMode()); + FCMD_OBJ_CMD(tobj, "Axis = " << axis.c_str()); + FCMD_OBJ_CMD(tobj, "Reversed = " << getReverse()); + FCMD_OBJ_CMD(tobj, "Mode = " << getMode()); ui->polarAngle->apply(); ui->angleOffset->apply(); ui->spinOccurrences->apply(); @@ -382,7 +425,8 @@ void TaskPolarPatternParameters::doApply() // TaskDialog //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -TaskDlgPolarPatternParameters::TaskDlgPolarPatternParameters(ViewProviderPolarPattern *PolarPatternView) +TaskDlgPolarPatternParameters::TaskDlgPolarPatternParameters( + ViewProviderPolarPattern* PolarPatternView) : TaskDlgTransformedParameters(PolarPatternView) { parameter = new TaskPolarPatternParameters(PolarPatternView); diff --git a/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.h b/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.h index f0fcfc8f53..c33cc7b0fc 100644 --- a/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.h +++ b/src/Mod/PartDesign/Gui/TaskPolarPatternParameters.h @@ -30,27 +30,31 @@ class QTimer; class Ui_TaskPolarPatternParameters; -namespace App { +namespace App +{ class Property; } -namespace Gui { +namespace Gui +{ class ViewProvider; } -namespace PartDesignGui { +namespace PartDesignGui +{ class TaskMultiTransformParameters; -class TaskPolarPatternParameters : public TaskTransformedParameters +class TaskPolarPatternParameters: public TaskTransformedParameters { Q_OBJECT public: /// Constructor for task with ViewProvider - explicit TaskPolarPatternParameters(ViewProviderTransformed *TransformedView, QWidget *parent = nullptr); + explicit TaskPolarPatternParameters(ViewProviderTransformed* TransformedView, + QWidget* parent = nullptr); /// Constructor for task with parent task (MultiTransform mode) - TaskPolarPatternParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget); + TaskPolarPatternParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget); ~TaskPolarPatternParameters() override; protected: @@ -93,14 +97,14 @@ private: /// simulation dialog for the TaskView -class TaskDlgPolarPatternParameters : public TaskDlgTransformedParameters +class TaskDlgPolarPatternParameters: public TaskDlgTransformedParameters { Q_OBJECT public: - explicit TaskDlgPolarPatternParameters(ViewProviderPolarPattern *PolarPatternView); + explicit TaskDlgPolarPatternParameters(ViewProviderPolarPattern* PolarPatternView); }; -} //namespace PartDesignGui +} // namespace PartDesignGui -#endif // GUI_TASKVIEW_TASKAPPERANCE_H +#endif // GUI_TASKVIEW_TASKAPPERANCE_H diff --git a/src/Mod/PartDesign/Gui/TaskScaledParameters.cpp b/src/Mod/PartDesign/Gui/TaskScaledParameters.cpp index 76fd21239e..54873b3e4d 100644 --- a/src/Mod/PartDesign/Gui/TaskScaledParameters.cpp +++ b/src/Mod/PartDesign/Gui/TaskScaledParameters.cpp @@ -44,28 +44,35 @@ using namespace Gui; /* TRANSLATOR PartDesignGui::TaskScaledParameters */ -TaskScaledParameters::TaskScaledParameters(ViewProviderTransformed *TransformedView,QWidget *parent) +TaskScaledParameters::TaskScaledParameters(ViewProviderTransformed* TransformedView, + QWidget* parent) : TaskTransformedParameters(TransformedView, parent) , ui(new Ui_TaskScaledParameters) { setupUI(); } -TaskScaledParameters::TaskScaledParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget) - : TaskTransformedParameters(parentTask), ui(new Ui_TaskScaledParameters) +TaskScaledParameters::TaskScaledParameters(TaskMultiTransformParameters* parentTask, + QWidget* parameterWidget) + : TaskTransformedParameters(parentTask) + , ui(new Ui_TaskScaledParameters) { setupParameterUI(parameterWidget); } -void TaskScaledParameters::setupParameterUI(QWidget *widget) +void TaskScaledParameters::setupParameterUI(QWidget* widget) { ui->setupUi(widget); QMetaObject::connectSlotsByName(this); - connect(ui->spinFactor, qOverload(&Gui::QuantitySpinBox::valueChanged), - this, &TaskScaledParameters::onFactor); - connect(ui->spinOccurrences, &Gui::UIntSpinBox::unsignedChanged, - this, &TaskScaledParameters::onOccurrences); + connect(ui->spinFactor, + qOverload(&Gui::QuantitySpinBox::valueChanged), + this, + &TaskScaledParameters::onFactor); + connect(ui->spinOccurrences, + &Gui::UIntSpinBox::unsignedChanged, + this, + &TaskScaledParameters::onOccurrences); // Get the feature data PartDesign::Scaled* pcScaled = static_cast(getObject()); @@ -75,7 +82,7 @@ void TaskScaledParameters::setupParameterUI(QWidget *widget) ui->spinOccurrences->bind(pcScaled->Occurrences); ui->spinFactor->setEnabled(true); ui->spinOccurrences->setEnabled(true); - //ui->spinFactor->setDecimals(Base::UnitsApi::getDecimals()); + // ui->spinFactor->setDecimals(Base::UnitsApi::getDecimals()); updateUI(); } @@ -87,8 +94,9 @@ void TaskScaledParameters::retranslateParameterUI(QWidget* widget) void TaskScaledParameters::updateUI() { - if (blockUpdate) + if (blockUpdate) { return; + } blockUpdate = true; PartDesign::Scaled* pcScaled = static_cast(getObject()); @@ -104,8 +112,9 @@ void TaskScaledParameters::updateUI() void TaskScaledParameters::onFactor(const double f) { - if (blockUpdate) + if (blockUpdate) { return; + } PartDesign::Scaled* pcScaled = static_cast(getObject()); pcScaled->Factor.setValue(f); recomputeFeature(); @@ -113,8 +122,9 @@ void TaskScaledParameters::onFactor(const double f) void TaskScaledParameters::onOccurrences(const uint n) { - if (blockUpdate) + if (blockUpdate) { return; + } PartDesign::Scaled* pcScaled = static_cast(getObject()); pcScaled->Occurrences.setValue(n); recomputeFeature(); @@ -144,7 +154,7 @@ unsigned TaskScaledParameters::getOccurrences() const void TaskScaledParameters::doApply() { - FCMD_OBJ_CMD(getObject(),"Factor = " << getFactor()); + FCMD_OBJ_CMD(getObject(), "Factor = " << getFactor()); ui->spinOccurrences->apply(); } @@ -153,7 +163,7 @@ void TaskScaledParameters::doApply() // TaskDialog //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -TaskDlgScaledParameters::TaskDlgScaledParameters(ViewProviderScaled *ScaledView) +TaskDlgScaledParameters::TaskDlgScaledParameters(ViewProviderScaled* ScaledView) : TaskDlgTransformedParameters(ScaledView) { parameter = new TaskScaledParameters(ScaledView); diff --git a/src/Mod/PartDesign/Gui/TaskScaledParameters.h b/src/Mod/PartDesign/Gui/TaskScaledParameters.h index 1ab7c6ff6f..60a1a6d829 100644 --- a/src/Mod/PartDesign/Gui/TaskScaledParameters.h +++ b/src/Mod/PartDesign/Gui/TaskScaledParameters.h @@ -29,27 +29,31 @@ class Ui_TaskScaledParameters; -namespace App { +namespace App +{ class Property; } -namespace Gui { +namespace Gui +{ class ViewProvider; } -namespace PartDesignGui { +namespace PartDesignGui +{ class TaskMultiTransformParameters; -class TaskScaledParameters : public TaskTransformedParameters +class TaskScaledParameters: public TaskTransformedParameters { Q_OBJECT public: /// Constructor for task with ViewProvider - explicit TaskScaledParameters(ViewProviderTransformed *TransformedView, QWidget *parent = nullptr); + explicit TaskScaledParameters(ViewProviderTransformed* TransformedView, + QWidget* parent = nullptr); /// Constructor for task with parent task (MultiTransform mode) - TaskScaledParameters(TaskMultiTransformParameters *parentTask, QWidget* parameterWidget); + TaskScaledParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget); private Q_SLOTS: void onFactor(const double f); @@ -71,14 +75,14 @@ private: /// simulation dialog for the TaskView -class TaskDlgScaledParameters : public TaskDlgTransformedParameters +class TaskDlgScaledParameters: public TaskDlgTransformedParameters { Q_OBJECT public: - explicit TaskDlgScaledParameters(ViewProviderScaled *ScaledView); + explicit TaskDlgScaledParameters(ViewProviderScaled* ScaledView); }; -} //namespace PartDesignGui +} // namespace PartDesignGui -#endif // GUI_TASKVIEW_TASKAPPERANCE_H +#endif // GUI_TASKVIEW_TASKAPPERANCE_H diff --git a/src/Mod/PartDesign/Gui/TaskTransformedParameters.cpp b/src/Mod/PartDesign/Gui/TaskTransformedParameters.cpp index c296a1d4a2..25fd674181 100644 --- a/src/Mod/PartDesign/Gui/TaskTransformedParameters.cpp +++ b/src/Mod/PartDesign/Gui/TaskTransformedParameters.cpp @@ -23,8 +23,8 @@ #include "PreCompiled.h" #ifndef _PreComp_ -# include -# include +#include +#include #endif #include @@ -47,16 +47,19 @@ #include "ReferenceSelection.h" -FC_LOG_LEVEL_INIT("PartDesign",true,true) +FC_LOG_LEVEL_INIT("PartDesign", true, true) using namespace PartDesignGui; using namespace Gui; /* TRANSLATOR PartDesignGui::TaskTransformedParameters */ -TaskTransformedParameters::TaskTransformedParameters(ViewProviderTransformed *TransformedView, QWidget *parent) +TaskTransformedParameters::TaskTransformedParameters(ViewProviderTransformed* TransformedView, + QWidget* parent) : TaskBox(Gui::BitmapFactory().pixmap(TransformedView->featureIcon().c_str()), - TransformedView->menuName, true, parent) + TransformedView->menuName, + true, + parent) , TransformedView(TransformedView) , ui(new Ui_TaskTransformedParameters) { @@ -67,20 +70,20 @@ TaskTransformedParameters::TaskTransformedParameters(ViewProviderTransformed *Tr App::GetApplication().getActiveTransaction(&transactionID); } -TaskTransformedParameters::TaskTransformedParameters(TaskMultiTransformParameters *parentTask) - : TaskBox(QPixmap(), tr(""), true, parentTask), - parentTask(parentTask), - insideMultiTransform(true) -{ -} +TaskTransformedParameters::TaskTransformedParameters(TaskMultiTransformParameters* parentTask) + : TaskBox(QPixmap(), tr(""), true, parentTask) + , parentTask(parentTask) + , insideMultiTransform(true) +{} TaskTransformedParameters::~TaskTransformedParameters() { // make sure to remove selection gate in all cases Gui::Selection().rmvSelectionGate(); - if (proxy) + if (proxy) { delete proxy; + } } void TaskTransformedParameters::setupUI() @@ -90,8 +93,14 @@ void TaskTransformedParameters::setupUI() ui->setupUi(proxy); QMetaObject::connectSlotsByName(this); - connect(ui->buttonAddFeature, &QToolButton::toggled, this, &TaskTransformedParameters::onButtonAddFeature); - connect(ui->buttonRemoveFeature, &QToolButton::toggled, this, &TaskTransformedParameters::onButtonRemoveFeature); + connect(ui->buttonAddFeature, + &QToolButton::toggled, + this, + &TaskTransformedParameters::onButtonAddFeature); + connect(ui->buttonRemoveFeature, + &QToolButton::toggled, + this, + &TaskTransformedParameters::onButtonRemoveFeature); // Create context menu QAction* action = new QAction(tr("Remove"), this); @@ -103,11 +112,15 @@ void TaskTransformedParameters::setupUI() ui->listWidgetFeatures->addAction(action); connect(action, &QAction::triggered, this, &TaskTransformedParameters::onFeatureDeleted); ui->listWidgetFeatures->setContextMenuPolicy(Qt::ActionsContextMenu); - connect(ui->listWidgetFeatures->model(), &QAbstractListModel::rowsMoved, - this, &TaskTransformedParameters::indexesMoved); + connect(ui->listWidgetFeatures->model(), + &QAbstractListModel::rowsMoved, + this, + &TaskTransformedParameters::indexesMoved); - connect(ui->checkBoxUpdateView, &QCheckBox::toggled, - this, &TaskTransformedParameters::onUpdateView); + connect(ui->checkBoxUpdateView, + &QCheckBox::toggled, + this, + &TaskTransformedParameters::onUpdateView); // Get the feature data PartDesign::Transformed* pcTransformed = static_cast(getObject()); @@ -123,17 +136,18 @@ void TaskTransformedParameters::setupUI() } } - setupParameterUI(ui->featureUI); // create parameter UI widgets + setupParameterUI(ui->featureUI); // create parameter UI widgets this->groupLayout()->addWidget(proxy); } void TaskTransformedParameters::slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj) { - if (TransformedView == &Obj) + if (TransformedView == &Obj) { TransformedView = nullptr; + } } -void TaskTransformedParameters::changeEvent(QEvent *e) +void TaskTransformedParameters::changeEvent(QEvent* e) { TaskBox::changeEvent(e); if (e->type() == QEvent::LanguageChange && proxy) { @@ -153,7 +167,8 @@ void TaskTransformedParameters::clearButtons() { if (insideMultiTransform) { parentTask->clearButtons(); - } else { + } + else { ui->buttonAddFeature->setChecked(false); ui->buttonRemoveFeature->setChecked(false); } @@ -183,28 +198,33 @@ void TaskTransformedParameters::removeObject(App::DocumentObject* obj) bool TaskTransformedParameters::originalSelected(const Gui::SelectionChanges& msg) { - if (msg.Type == Gui::SelectionChanges::AddSelection && ( - (selectionMode == SelectionMode::AddFeature) || (selectionMode == SelectionMode::RemoveFeature))) { + if (msg.Type == Gui::SelectionChanges::AddSelection + && ((selectionMode == SelectionMode::AddFeature) + || (selectionMode == SelectionMode::RemoveFeature))) { - if (strcmp(msg.pDocName, getObject()->getDocument()->getName()) != 0) + if (strcmp(msg.pDocName, getObject()->getDocument()->getName()) != 0) { return false; + } PartDesign::Transformed* pcTransformed = getObject(); - App::DocumentObject* selectedObject = pcTransformed->getDocument()->getObject(msg.pObjectName); + App::DocumentObject* selectedObject = + pcTransformed->getDocument()->getObject(msg.pObjectName); if (selectedObject->isDerivedFrom(PartDesign::FeatureAddSub::getClassTypeId())) { // Do the same like in TaskDlgTransformedParameters::accept() but without doCommand std::vector originals = pcTransformed->Originals.getValues(); - std::vector::iterator o = std::find(originals.begin(), originals.end(), selectedObject); + std::vector::iterator o = + std::find(originals.begin(), originals.end(), selectedObject); if (selectionMode == SelectionMode::AddFeature) { if (o == originals.end()) { originals.push_back(selectedObject); addObject(selectedObject); } else { - return false; // duplicate selection + return false; // duplicate selection } - } else { + } + else { if (o != originals.end()) { originals.erase(o); removeObject(selectedObject); @@ -226,17 +246,20 @@ bool TaskTransformedParameters::originalSelected(const Gui::SelectionChanges& ms void TaskTransformedParameters::setupTransaction() { - if (!isEnabledTransaction()) + if (!isEnabledTransaction()) { return; + } auto obj = getObject(); - if (!obj) + if (!obj) { return; + } int tid = 0; App::GetApplication().getActiveTransaction(&tid); - if (tid && tid == transactionID) + if (tid && tid == transactionID) { return; + } // open a transaction if none is active std::string n("Edit "); @@ -261,7 +284,8 @@ void TaskTransformedParameters::onButtonAddFeature(bool checked) showBase(); selectionMode = SelectionMode::AddFeature; Gui::Selection().clearSelection(); - } else { + } + else { exitSelectionMode(); } @@ -269,19 +293,22 @@ void TaskTransformedParameters::onButtonAddFeature(bool checked) } // Make sure only some feature before the given one is visible -void TaskTransformedParameters::checkVisibility() { +void TaskTransformedParameters::checkVisibility() +{ auto feat = getObject(); auto body = feat->getFeatureBody(); - if(!body) + if (!body) { return; + } auto inset = feat->getInListEx(true); inset.emplace(feat); - for(auto o : body->Group.getValues()) { - if(!o->Visibility.getValue() - || !o->isDerivedFrom(PartDesign::Feature::getClassTypeId())) + for (auto o : body->Group.getValues()) { + if (!o->Visibility.getValue() || !o->isDerivedFrom(PartDesign::Feature::getClassTypeId())) { continue; - if(inset.count(o)) + } + if (inset.count(o)) { break; + } return; } FCMD_OBJ_SHOW(getBaseObject()); @@ -293,7 +320,8 @@ void TaskTransformedParameters::onButtonRemoveFeature(bool checked) checkVisibility(); selectionMode = SelectionMode::RemoveFeature; Gui::Selection().clearSelection(); - } else { + } + else { exitSelectionMode(); } @@ -307,7 +335,7 @@ void TaskTransformedParameters::onFeatureDeleted() int currentRow = ui->listWidgetFeatures->currentRow(); if (currentRow < 0) { Base::Console().Error("PartDesign Pattern: No feature selected for removing.\n"); - return; //no current row selected + return; // no current row selected } originals.erase(originals.begin() + currentRow); setupTransaction(); @@ -316,7 +344,8 @@ void TaskTransformedParameters::onFeatureDeleted() recomputeFeature(); } -void TaskTransformedParameters::removeItemFromListWidget(QListWidget* widget, const QString& itemstr) +void TaskTransformedParameters::removeItemFromListWidget(QListWidget* widget, + const QString& itemstr) { QList items = widget->findItems(itemstr, Qt::MatchExactly); if (!items.empty()) { @@ -327,129 +356,142 @@ void TaskTransformedParameters::removeItemFromListWidget(QListWidget* widget, co } } -void TaskTransformedParameters::fillAxisCombo(ComboLinks &combolinks, - Part::Part2DObject* sketch) +void TaskTransformedParameters::fillAxisCombo(ComboLinks& combolinks, Part::Part2DObject* sketch) { combolinks.clear(); - //add sketch axes - if (sketch){ - combolinks.addLink(sketch, "N_Axis",tr("Normal sketch axis")); - combolinks.addLink(sketch,"V_Axis",tr("Vertical sketch axis")); - combolinks.addLink(sketch,"H_Axis",tr("Horizontal sketch axis")); - for (int i=0; i < sketch->getAxisCount(); i++) { - QString itemText = tr("Construction line %1").arg(i+1); + // add sketch axes + if (sketch) { + combolinks.addLink(sketch, "N_Axis", tr("Normal sketch axis")); + combolinks.addLink(sketch, "V_Axis", tr("Vertical sketch axis")); + combolinks.addLink(sketch, "H_Axis", tr("Horizontal sketch axis")); + for (int i = 0; i < sketch->getAxisCount(); i++) { + QString itemText = tr("Construction line %1").arg(i + 1); std::stringstream sub; sub << "Axis" << i; - combolinks.addLink(sketch,sub.str(),itemText); + combolinks.addLink(sketch, sub.str(), itemText); } } - //add part axes + // add part axes App::DocumentObject* obj = getObject(); - PartDesign::Body * body = PartDesign::Body::findBodyOf ( obj ); + PartDesign::Body* body = PartDesign::Body::findBodyOf(obj); if (body) { try { App::Origin* orig = body->getOrigin(); - combolinks.addLink(orig->getX(),"",tr("Base X axis")); - combolinks.addLink(orig->getY(),"",tr("Base Y axis")); - combolinks.addLink(orig->getZ(),"",tr("Base Z axis")); - } catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what() ); + combolinks.addLink(orig->getX(), "", tr("Base X axis")); + combolinks.addLink(orig->getY(), "", tr("Base Y axis")); + combolinks.addLink(orig->getZ(), "", tr("Base Z axis")); + } + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } - //add "Select reference" - combolinks.addLink(nullptr,std::string(),tr("Select reference...")); + // add "Select reference" + combolinks.addLink(nullptr, std::string(), tr("Select reference...")); } -void TaskTransformedParameters::fillPlanesCombo(ComboLinks &combolinks, - Part::Part2DObject* sketch) +void TaskTransformedParameters::fillPlanesCombo(ComboLinks& combolinks, Part::Part2DObject* sketch) { combolinks.clear(); - //add sketch axes - if (sketch){ - combolinks.addLink(sketch,"V_Axis",QObject::tr("Vertical sketch axis")); - combolinks.addLink(sketch,"H_Axis",QObject::tr("Horizontal sketch axis")); - for (int i=0; i < sketch->getAxisCount(); i++) { - QString itemText = tr("Construction line %1").arg(i+1); + // add sketch axes + if (sketch) { + combolinks.addLink(sketch, "V_Axis", QObject::tr("Vertical sketch axis")); + combolinks.addLink(sketch, "H_Axis", QObject::tr("Horizontal sketch axis")); + for (int i = 0; i < sketch->getAxisCount(); i++) { + QString itemText = tr("Construction line %1").arg(i + 1); std::stringstream sub; sub << "Axis" << i; - combolinks.addLink(sketch,sub.str(),itemText); + combolinks.addLink(sketch, sub.str(), itemText); } } - //add part baseplanes + // add part baseplanes App::DocumentObject* obj = getObject(); - PartDesign::Body * body = PartDesign::Body::findBodyOf ( obj ); + PartDesign::Body* body = PartDesign::Body::findBodyOf(obj); if (body) { try { App::Origin* orig = body->getOrigin(); - combolinks.addLink(orig->getXY(),"",tr("Base XY plane")); - combolinks.addLink(orig->getYZ(),"",tr("Base YZ plane")); - combolinks.addLink(orig->getXZ(),"",tr("Base XZ plane")); - } catch (const Base::Exception &ex) { - Base::Console().Error ("%s\n", ex.what() ); + combolinks.addLink(orig->getXY(), "", tr("Base XY plane")); + combolinks.addLink(orig->getYZ(), "", tr("Base YZ plane")); + combolinks.addLink(orig->getXZ(), "", tr("Base XZ plane")); + } + catch (const Base::Exception& ex) { + Base::Console().Error("%s\n", ex.what()); } } - //add "Select reference" - combolinks.addLink(nullptr,std::string(),tr("Select reference...")); + // add "Select reference" + combolinks.addLink(nullptr, std::string(), tr("Select reference...")); } -void TaskTransformedParameters::recomputeFeature() { +void TaskTransformedParameters::recomputeFeature() +{ getTopTransformedView()->recomputeFeature(); } -PartDesignGui::ViewProviderTransformed *TaskTransformedParameters::getTopTransformedView() const { - PartDesignGui::ViewProviderTransformed *rv; +PartDesignGui::ViewProviderTransformed* TaskTransformedParameters::getTopTransformedView() const +{ + PartDesignGui::ViewProviderTransformed* rv; if (insideMultiTransform) { rv = parentTask->TransformedView; - } else { + } + else { rv = TransformedView; } return rv; } -PartDesign::Transformed *TaskTransformedParameters::getTopTransformedObject() const { +PartDesign::Transformed* TaskTransformedParameters::getTopTransformedObject() const +{ ViewProviderTransformed* vp = getTopTransformedView(); - if (!vp) + if (!vp) { return nullptr; + } - App::DocumentObject *transform = vp->getObject(); - assert (transform->isDerivedFrom(PartDesign::Transformed::getClassTypeId())); + App::DocumentObject* transform = vp->getObject(); + assert(transform->isDerivedFrom(PartDesign::Transformed::getClassTypeId())); return static_cast(transform); } -PartDesign::Transformed *TaskTransformedParameters::getObject() const { - if (insideMultiTransform) +PartDesign::Transformed* TaskTransformedParameters::getObject() const +{ + if (insideMultiTransform) { return parentTask->getSubFeature(); - else if (TransformedView) + } + else if (TransformedView) { return static_cast(TransformedView->getObject()); - else + } + else { return nullptr; + } } -App::DocumentObject *TaskTransformedParameters::getBaseObject() const { - PartDesign::Feature* feature = getTopTransformedObject (); - if (!feature) +App::DocumentObject* TaskTransformedParameters::getBaseObject() const +{ + PartDesign::Feature* feature = getTopTransformedObject(); + if (!feature) { return nullptr; + } // NOTE: getBaseObject() throws if there is no base; shouldn't happen here. - App::DocumentObject *base = feature->getBaseObject(true); - if(!base) { + App::DocumentObject* base = feature->getBaseObject(true); + if (!base) { auto body = feature->getFeatureBody(); - if(body) + if (body) { base = body->getPrevSolidFeature(feature); + } } return base; } -App::DocumentObject* TaskTransformedParameters::getSketchObject() const { +App::DocumentObject* TaskTransformedParameters::getSketchObject() const +{ PartDesign::Transformed* feature = getTopTransformedObject(); return feature ? feature->getSketchObject() : nullptr; } @@ -501,23 +543,27 @@ void TaskTransformedParameters::exitSelectionMode() selectionMode = SelectionMode::None; Gui::Selection().rmvSelectionGate(); showObject(); - } catch(Base::Exception &e) { + } + catch (Base::Exception& e) { e.ReportException(); } } void TaskTransformedParameters::addReferenceSelectionGate(AllowSelectionFlags allow) { - std::unique_ptr gateRefPtr(new ReferenceSelection(getBaseObject(), allow)); - std::unique_ptr gateDepPtr(new NoDependentsSelection(getTopTransformedObject())); + std::unique_ptr gateRefPtr( + new ReferenceSelection(getBaseObject(), allow)); + std::unique_ptr gateDepPtr( + new NoDependentsSelection(getTopTransformedObject())); Gui::Selection().addSelectionGate(new CombineSelectionFilterGates(gateRefPtr, gateDepPtr)); } void TaskTransformedParameters::indexesMoved() { QAbstractItemModel* model = qobject_cast(sender()); - if (!model) + if (!model) { return; + } PartDesign::Transformed* pcTransformed = getObject(); std::vector originals = pcTransformed->Originals.getValues(); @@ -540,7 +586,8 @@ void TaskTransformedParameters::indexesMoved() // TaskDialog //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -TaskDlgTransformedParameters::TaskDlgTransformedParameters(ViewProviderTransformed *TransformedView_) +TaskDlgTransformedParameters::TaskDlgTransformedParameters( + ViewProviderTransformed* TransformedView_) : TaskDlgFeatureParameters(TransformedView_) { assert(vp); @@ -556,7 +603,7 @@ bool TaskDlgTransformedParameters::accept() parameter->exitSelectionMode(); parameter->apply(); - return TaskDlgFeatureParameters::accept (); + return TaskDlgFeatureParameters::accept(); } bool TaskDlgTransformedParameters::reject() @@ -564,74 +611,81 @@ bool TaskDlgTransformedParameters::reject() // ensure that we are not in selection mode parameter->exitSelectionMode(); - return TaskDlgFeatureParameters::reject (); + return TaskDlgFeatureParameters::reject(); } #include "moc_TaskTransformedParameters.cpp" -ComboLinks::ComboLinks(QComboBox &combo) +ComboLinks::ComboLinks(QComboBox& combo) : _combo(&combo) { _combo->clear(); } -int ComboLinks::addLink(const App::PropertyLinkSub &lnk, QString itemText) +int ComboLinks::addLink(const App::PropertyLinkSub& lnk, QString itemText) { - if(!_combo) + if (!_combo) { return 0; + } _combo->addItem(itemText); this->linksInList.push_back(new App::PropertyLinkSub()); - App::PropertyLinkSub &newitem = *(linksInList[linksInList.size()-1]); + App::PropertyLinkSub& newitem = *(linksInList[linksInList.size() - 1]); newitem.Paste(lnk); - if (newitem.getValue() && !this->doc) + if (newitem.getValue() && !this->doc) { this->doc = newitem.getValue()->getDocument(); - return linksInList.size()-1; + } + return linksInList.size() - 1; } -int ComboLinks::addLink(App::DocumentObject *linkObj, std::string linkSubname, QString itemText) +int ComboLinks::addLink(App::DocumentObject* linkObj, std::string linkSubname, QString itemText) { - if(!_combo) + if (!_combo) { return 0; + } _combo->addItem(itemText); this->linksInList.push_back(new App::PropertyLinkSub()); - App::PropertyLinkSub &newitem = *(linksInList[linksInList.size()-1]); - newitem.setValue(linkObj,std::vector(1,linkSubname)); - if (newitem.getValue() && !this->doc) + App::PropertyLinkSub& newitem = *(linksInList[linksInList.size() - 1]); + newitem.setValue(linkObj, std::vector(1, linkSubname)); + if (newitem.getValue() && !this->doc) { this->doc = newitem.getValue()->getDocument(); - return linksInList.size()-1; + } + return linksInList.size() - 1; } void ComboLinks::clear() { - for(size_t i = 0 ; i < this->linksInList.size() ; i++){ + for (size_t i = 0; i < this->linksInList.size(); i++) { delete linksInList[i]; } - if(this->_combo) + if (this->_combo) { _combo->clear(); + } } -App::PropertyLinkSub &ComboLinks::getLink(int index) const +App::PropertyLinkSub& ComboLinks::getLink(int index) const { - if (index < 0 || index > static_cast(linksInList.size())-1) + if (index < 0 || index > static_cast(linksInList.size()) - 1) { throw Base::IndexError("ComboLinks::getLink:Index out of range"); - if (linksInList[index]->getValue() && doc && !(doc->isIn(linksInList[index]->getValue()))) + } + if (linksInList[index]->getValue() && doc && !(doc->isIn(linksInList[index]->getValue()))) { throw Base::ValueError("Linked object is not in the document; it may have been deleted"); + } return *(linksInList[index]); } -App::PropertyLinkSub &ComboLinks::getCurrentLink() const +App::PropertyLinkSub& ComboLinks::getCurrentLink() const { assert(_combo); return getLink(_combo->currentIndex()); } -int ComboLinks::setCurrentLink(const App::PropertyLinkSub &lnk) +int ComboLinks::setCurrentLink(const App::PropertyLinkSub& lnk) { - for(size_t i = 0 ; i < linksInList.size() ; i++) { - App::PropertyLinkSub &it = *(linksInList[i]); - if(lnk.getValue() == it.getValue() && lnk.getSubValues() == it.getSubValues()){ + for (size_t i = 0; i < linksInList.size(); i++) { + App::PropertyLinkSub& it = *(linksInList[i]); + if (lnk.getValue() == it.getValue() && lnk.getSubValues() == it.getSubValues()) { bool wasBlocked = _combo->signalsBlocked(); _combo->blockSignals(true); _combo->setCurrentIndex(i); diff --git a/src/Mod/PartDesign/Gui/TaskTransformedParameters.h b/src/Mod/PartDesign/Gui/TaskTransformedParameters.h index 4ddc5dd79f..ddb58779f9 100644 --- a/src/Mod/PartDesign/Gui/TaskTransformedParameters.h +++ b/src/Mod/PartDesign/Gui/TaskTransformedParameters.h @@ -40,15 +40,18 @@ class QListWidget; class Ui_TaskTransformedParameters; -namespace Part { +namespace Part +{ class Feature; } -namespace PartDesign { +namespace PartDesign +{ class Transformed; } -namespace PartDesignGui { +namespace PartDesignGui +{ class TaskMultiTransformParameters; @@ -66,10 +69,15 @@ public: * remove items from the combo directly, otherwise internal tracking list * will go out of sync, and crashes may result. */ - explicit ComboLinks(QComboBox &combo); + explicit ComboLinks(QComboBox& combo); ComboLinks() = default; - void setCombo(QComboBox &combo) {assert(!_combo); this->_combo = &combo; _combo->clear();} + void setCombo(QComboBox& combo) + { + assert(!_combo); + this->_combo = &combo; + _combo->clear(); + } /** * @brief addLink adds an item to the combo. Doesn't check for duplicates. @@ -77,7 +85,7 @@ public: * @param itemText * @return */ - int addLink(const App::PropertyLinkSub &lnk, QString itemText); + int addLink(const App::PropertyLinkSub& lnk, QString itemText); int addLink(App::DocumentObject* linkObj, std::string linkSubname, QString itemText); void clear(); App::PropertyLinkSub& getLink(int index) const; @@ -99,11 +107,20 @@ public: * @param lnk * @return the index of an item that was selected, -1 if link is not in the list yet. */ - int setCurrentLink(const App::PropertyLinkSub &lnk); + int setCurrentLink(const App::PropertyLinkSub& lnk); - QComboBox& combo() const {assert(_combo); return *_combo;} + QComboBox& combo() const + { + assert(_combo); + return *_combo; + } + + ~ComboLinks() + { + _combo = nullptr; + clear(); + } - ~ComboLinks() {_combo = nullptr; clear();} private: QComboBox* _combo = nullptr; App::Document* doc = nullptr; @@ -118,17 +135,18 @@ private: Because in the second case there is no ViewProvider, some special methods are required to access the underlying FeatureTransformed object in two different ways. **/ -class TaskTransformedParameters : public Gui::TaskView::TaskBox, - public Gui::SelectionObserver, - public Gui::DocumentObserver +class TaskTransformedParameters: public Gui::TaskView::TaskBox, + public Gui::SelectionObserver, + public Gui::DocumentObserver { Q_OBJECT public: /// Constructor for task with ViewProvider - explicit TaskTransformedParameters(ViewProviderTransformed *TransformedView, QWidget *parent = nullptr); + explicit TaskTransformedParameters(ViewProviderTransformed* TransformedView, + QWidget* parent = nullptr); /// Constructor for task with parent task (MultiTransform mode) - explicit TaskTransformedParameters(TaskMultiTransformParameters *parentTask); + explicit TaskTransformedParameters(TaskMultiTransformParameters* parentTask); ~TaskTransformedParameters() override; /// Apply changes for python console @@ -150,8 +168,8 @@ public: protected: /** Setup the standalone UI. - * Call this in the derived destructor with ViewProvider. - */ + * Call this in the derived destructor with ViewProvider. + */ void setupUI(); /** @@ -159,14 +177,15 @@ protected: * For stand alone features it will be object associated with the view provider * For features inside MultiTransform it will be the parent MultiTransform's sub feature object */ - PartDesign::Transformed *getObject() const; + PartDesign::Transformed* getObject() const; - /// Get the sketch object of the first original either of the object associated with this feature or with the parent feature (MultiTransform mode) + /// Get the sketch object of the first original either of the object associated with this + /// feature or with the parent feature (MultiTransform mode) App::DocumentObject* getSketchObject() const; /** Handle adding/removing of selected features - * Returns true if a selected feature was added/removed. - */ + * Returns true if a selected feature was added/removed. + */ bool originalSelected(const Gui::SelectionChanges& msg); /// Recompute either this feature or the parent MultiTransform feature @@ -191,9 +210,9 @@ protected: void onSelectionChanged(const Gui::SelectionChanges& msg) override; /// Fill combobox with the axis from the sketch and the own bodys origin axis - void fillAxisCombo(ComboLinks &combolinks, Part::Part2DObject *sketch); + void fillAxisCombo(ComboLinks& combolinks, Part::Part2DObject* sketch); /// Fill combobox with the planes from the sketch and the own bodys origin planes - void fillPlanesCombo(ComboLinks &combolinks, Part::Part2DObject *sketch); + void fillPlanesCombo(ComboLinks& combolinks, Part::Part2DObject* sketch); bool isEnabledTransaction() const; void setupTransaction(); @@ -208,9 +227,9 @@ private Q_SLOTS: private: /** Setup the parameter UI. - * This is called to create the parameter UI in the specified widget. - * Call this in the derived constructor with MultiTransform parent. - */ + * This is called to create the parameter UI in the specified widget. + * Call this in the derived constructor with MultiTransform parent. + */ virtual void setupParameterUI(QWidget* widget) = 0; /// Change translation of the parameter UI @@ -226,35 +245,36 @@ private: /// Return the base object of the base transformed object (see getTopTransformedObject()) // Either through the ViewProvider or the currently active subFeature of the parentTask - App::DocumentObject *getBaseObject() const; + App::DocumentObject* getBaseObject() const; /** * Returns the base transformation view provider * For stand alone features it will be view provider associated with this object * For features inside multitransform it will be the view provider of the multitransform object */ - PartDesignGui::ViewProviderTransformed *getTopTransformedView () const; + PartDesignGui::ViewProviderTransformed* getTopTransformedView() const; /** * Returns the base transformed object * For stand alone features it will be objects associated with this object * For features inside multitransform it will be the base multitransform object */ - PartDesign::Transformed *getTopTransformedObject () const; + PartDesign::Transformed* getTopTransformedObject() const; - void changeEvent(QEvent *e) override; + void changeEvent(QEvent* e) override; static void removeItemFromListWidget(QListWidget* widget, const QString& itemstr); protected: - enum class SelectionMode { + enum class SelectionMode + { None, AddFeature, RemoveFeature, Reference }; - ViewProviderTransformed *TransformedView = nullptr; + ViewProviderTransformed* TransformedView = nullptr; SelectionMode selectionMode = SelectionMode::None; /// Lock updateUI(), applying changes to the underlying feature and calling recomputeFeature() @@ -273,15 +293,17 @@ private: }; /// simulation dialog for the TaskView -class TaskDlgTransformedParameters : public PartDesignGui::TaskDlgFeatureParameters +class TaskDlgTransformedParameters: public PartDesignGui::TaskDlgFeatureParameters { Q_OBJECT public: - explicit TaskDlgTransformedParameters(ViewProviderTransformed *TransformedView); + explicit TaskDlgTransformedParameters(ViewProviderTransformed* TransformedView); ViewProviderTransformed* getTransformedView() const - { return static_cast(vp); } + { + return static_cast(vp); + } /// is called by the framework if the dialog is accepted (Ok) bool accept() override; @@ -289,10 +311,10 @@ public: bool reject() override; protected: - TaskTransformedParameters *parameter = nullptr; - TaskTransformedMessages *message = nullptr; + TaskTransformedParameters* parameter = nullptr; + TaskTransformedMessages* message = nullptr; }; -} //namespace PartDesignGui +} // namespace PartDesignGui -#endif // GUI_TASKVIEW_TASKAPPERANCE_H +#endif // GUI_TASKVIEW_TASKAPPERANCE_H