kindred/create
1
1
Fork 0
Code Issues 37 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Merge pull request #12474 from NomAnor/pd-pattern-tasks

Browse Source 
Refactoring and cleanup of PD Pattern task panels
This commit is contained in:
Chris Hennes
2024-02-28 15:10:37 -06:00
committed by GitHub
parent 97f9c4e467 dac2fb4d3d
commit a878b81495
19 changed files with 1376 additions and 1860 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Mod/PartDesign/Gui/CMakeLists.txt
View File

@@ -41,6 +41,7 @@ set(PartDesignGui_UIC_SRCS
TaskHoleParameters.ui
TaskRevolutionParameters.ui
TaskTransformedMessages.ui
TaskTransformedParameters.ui
TaskMirroredParameters.ui
TaskLinearPatternParameters.ui
TaskPolarPatternParameters.ui

375
src/Mod/PartDesign/Gui/TaskLinearPatternParameters.cpp
View File

@@ -24,9 +24,8 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QAction>
# include <QMessageBox>
# include <QTimer>
#include <QMessageBox>
#include <QTimer>
#endif
#include <App/Document.h>
@@ -53,108 +52,29 @@ 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)
{
// we need a separate container widget to add all controls to
proxy = new QWidget(this);
ui->setupUi(proxy);
QMetaObject::connectSlotsByName(this);
this->groupLayout()->addWidget(proxy);
ui->buttonOK->hide();
ui->checkBoxUpdateView->setEnabled(true);
selectionMode = none;
blockUpdate = false; // Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
setupUI();
}
TaskLinearPatternParameters::TaskLinearPatternParameters(TaskMultiTransformParameters *parentTask, QLayout *layout)
: TaskTransformedParameters(parentTask), ui(new Ui_TaskLinearPatternParameters)
TaskLinearPatternParameters::TaskLinearPatternParameters(TaskMultiTransformParameters* parentTask,
QWidget* parameterWidget)
: TaskTransformedParameters(parentTask)
, ui(new Ui_TaskLinearPatternParameters)
{
proxy = new QWidget(parentTask);
ui->setupUi(proxy);
connect(ui->buttonOK, &QToolButton::pressed,
parentTask, &TaskLinearPatternParameters::onSubTaskButtonOK);
setupParameterUI(parameterWidget);
}
void TaskLinearPatternParameters::setupParameterUI(QWidget* widget)
{
ui->setupUi(widget);
QMetaObject::connectSlotsByName(this);
layout->addWidget(proxy);
ui->buttonOK->setEnabled(true);
ui->buttonAddFeature->hide();
ui->buttonRemoveFeature->hide();
ui->listWidgetFeatures->hide();
ui->checkBoxUpdateView->hide();
selectionMode = none;
// Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
blockUpdate = false;
setupUI();
}
void TaskLinearPatternParameters::connectSignals()
{
connect(ui->buttonAddFeature, &QToolButton::toggled,
this, &TaskLinearPatternParameters::onButtonAddFeature);
connect(ui->buttonRemoveFeature, &QToolButton::toggled,
this, &TaskLinearPatternParameters::onButtonRemoveFeature);
// Create context menu
QAction* action = new QAction(tr("Remove"), this);
action->setShortcut(QKeySequence::Delete);
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
// display shortcut behind the context menu entry
action->setShortcutVisibleInContextMenu(true);
#endif
ui->listWidgetFeatures->addAction(action);
connect(action, &QAction::triggered, this, &TaskLinearPatternParameters::onFeatureDeleted);
ui->listWidgetFeatures->setContextMenuPolicy(Qt::ActionsContextMenu);
connect(ui->listWidgetFeatures->model(), &QAbstractListModel::rowsMoved,
this, &TaskLinearPatternParameters::indexesMoved);
updateViewTimer = new QTimer(this);
updateViewTimer->setSingleShot(true);
updateViewTimer->setInterval(getUpdateViewTimeout());
connect(updateViewTimer, &QTimer::timeout,
this, &TaskLinearPatternParameters::onUpdateViewTimer);
connect(ui->comboDirection, qOverload<int>(&QComboBox::activated),
this, &TaskLinearPatternParameters::onDirectionChanged);
connect(ui->checkReverse, &QCheckBox::toggled,
this, &TaskLinearPatternParameters::onCheckReverse);
connect(ui->comboMode, qOverload<int>(&QComboBox::activated),
this, &TaskLinearPatternParameters::onModeChanged);
connect(ui->spinLength, qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this, &TaskLinearPatternParameters::onLength);
connect(ui->spinOffset, qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this, &TaskLinearPatternParameters::onOffset);
connect(ui->spinOccurrences, &Gui::UIntSpinBox::unsignedChanged,
this, &TaskLinearPatternParameters::onOccurrences);
connect(ui->checkBoxUpdateView, &QCheckBox::toggled,
this, &TaskLinearPatternParameters::onUpdateView);
}
void TaskLinearPatternParameters::setupUI()
{
// Get the feature data
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
std::vector<App::DocumentObject*> originals = pcLinearPattern->Originals.getValues();
// Fill data into dialog elements
for (auto obj : originals) {
if (obj) {
QListWidgetItem* item = new QListWidgetItem();
item->setText(QString::fromUtf8(obj->Label.getValue()));
item->setData(Qt::UserRole, QString::fromLatin1(obj->getNameInDocument()));
ui->listWidgetFeatures->addItem(item);
}
}
// ---------------------
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
ui->spinLength->bind(pcLinearPattern->Length);
ui->spinOffset->bind(pcLinearPattern->Offset);
@@ -177,55 +97,95 @@ void TaskLinearPatternParameters::setupUI()
dirLinks.setCombo(*(ui->comboDirection));
App::DocumentObject* sketch = getSketchObject();
if (sketch && sketch->isDerivedFrom(Part::Part2DObject::getClassTypeId())) {
if (sketch && sketch->isDerivedFrom<Part::Part2DObject>()) {
this->fillAxisCombo(dirLinks, static_cast<Part::Part2DObject*>(sketch));
}
else {
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();
ViewProviderOrigin* vpOrigin;
vpOrigin = static_cast<ViewProviderOrigin*>(Gui::Application::Instance->getViewProvider(origin));
App::Origin* origin = body->getOrigin();
auto vpOrigin = static_cast<ViewProviderOrigin*>(
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());
}
}
adaptVisibilityToMode();
connectSignals();
updateViewTimer = new QTimer(this);
updateViewTimer->setSingleShot(true);
updateViewTimer->setInterval(getUpdateViewTimeout());
connect(updateViewTimer,
&QTimer::timeout,
this,
&TaskLinearPatternParameters::onUpdateViewTimer);
connect(ui->comboDirection,
qOverload<int>(&QComboBox::activated),
this,
&TaskLinearPatternParameters::onDirectionChanged);
connect(ui->checkReverse,
&QCheckBox::toggled,
this,
&TaskLinearPatternParameters::onCheckReverse);
connect(ui->comboMode,
qOverload<int>(&QComboBox::activated),
this,
&TaskLinearPatternParameters::onModeChanged);
connect(ui->spinLength,
qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this,
&TaskLinearPatternParameters::onLength);
connect(ui->spinOffset,
qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this,
&TaskLinearPatternParameters::onOffset);
connect(ui->spinOccurrences,
&Gui::UIntSpinBox::unsignedChanged,
this,
&TaskLinearPatternParameters::onOccurrences);
}
void TaskLinearPatternParameters::retranslateParameterUI(QWidget* widget)
{
ui->retranslateUi(widget);
}
void TaskLinearPatternParameters::updateUI()
{
if (blockUpdate)
if (blockUpdate) {
return;
}
blockUpdate = true;
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
PartDesign::LinearPatternMode mode = static_cast<PartDesign::LinearPatternMode>(pcLinearPattern->Mode.getValue());
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
auto mode = static_cast<PartDesign::LinearPatternMode>(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);
}
// Note: This block of code would trigger change signal handlers (e.g. onOccurrences())
// and another updateUI() if we didn't check for blockUpdate
ui->checkReverse->setChecked(reverse);
ui->comboMode->setCurrentIndex((long)mode);
ui->comboMode->setCurrentIndex(static_cast<int>(mode));
ui->spinLength->setValue(length);
ui->spinOffset->setValue(offset);
ui->spinOccurrences->setValue(occurrences);
@@ -255,74 +215,54 @@ void TaskLinearPatternParameters::kickUpdateViewTimer() const
updateViewTimer->start();
}
void TaskLinearPatternParameters::addObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
QString objectName = QString::fromLatin1(obj->getNameInDocument());
QListWidgetItem* item = new QListWidgetItem();
item->setText(label);
item->setData(Qt::UserRole, objectName);
ui->listWidgetFeatures->addItem(item);
}
void TaskLinearPatternParameters::removeObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
removeItemFromListWidget(ui->listWidgetFeatures, label);
}
void TaskLinearPatternParameters::onSelectionChanged(const Gui::SelectionChanges& msg)
{
if (selectionMode != none && msg.Type == Gui::SelectionChanges::AddSelection) {
if (selectionMode != SelectionMode::None && msg.Type == Gui::SelectionChanges::AddSelection) {
if (originalSelected(msg)) {
exitSelectionMode();
}
else if (selectionMode == reference) {
// TODO check if this works correctly (2015-09-01, Fat-Zer)
exitSelectionMode();
else if (selectionMode == SelectionMode::Reference) {
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
std::vector<std::string> directions;
App::DocumentObject* selObj = nullptr;
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
if (pcLinearPattern) {
getReferencedSelection(pcLinearPattern, msg, selObj, directions);
// Note: ReferenceSelection has already checked the selection for validity
if (selObj && (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();
updateUI();
}
getReferencedSelection(pcLinearPattern, msg, selObj, directions);
if (!selObj) {
return;
}
// Note: ReferenceSelection has already checked the selection for validity
if (selObj->isDerivedFrom<App::Line>() || selObj->isDerivedFrom<Part::Feature>()
|| selObj->isDerivedFrom<PartDesign::Line>()
|| selObj->isDerivedFrom<PartDesign::Plane>()) {
setupTransaction();
pcLinearPattern->Direction.setValue(selObj, directions);
recomputeFeature();
updateUI();
}
exitSelectionMode();
}
}
}
void TaskLinearPatternParameters::clearButtons()
void TaskLinearPatternParameters::onCheckReverse(const bool on)
{
ui->buttonAddFeature->setChecked(false);
ui->buttonRemoveFeature->setChecked(false);
}
void TaskLinearPatternParameters::onCheckReverse(const bool on) {
if (blockUpdate)
if (blockUpdate) {
return;
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
}
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(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<PartDesign::LinearPattern*>(getObject());
}
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
pcLinearPattern->Mode.setValue(mode);
adaptVisibilityToMode();
@@ -331,31 +271,37 @@ void TaskLinearPatternParameters::onModeChanged(const int mode) {
kickUpdateViewTimer();
}
void TaskLinearPatternParameters::onLength(const double l) {
if (blockUpdate)
void TaskLinearPatternParameters::onLength(const double length)
{
if (blockUpdate) {
return;
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
pcLinearPattern->Length.setValue(l);
}
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
pcLinearPattern->Length.setValue(length);
exitSelectionMode();
kickUpdateViewTimer();
}
void TaskLinearPatternParameters::onOffset(const double o) {
if (blockUpdate)
void TaskLinearPatternParameters::onOffset(const double offset)
{
if (blockUpdate) {
return;
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
pcLinearPattern->Offset.setValue(o);
}
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
pcLinearPattern->Offset.setValue(offset);
exitSelectionMode();
kickUpdateViewTimer();
}
void TaskLinearPatternParameters::onOccurrences(const uint n) {
if (blockUpdate)
void TaskLinearPatternParameters::onOccurrences(const uint number)
{
if (blockUpdate) {
return;
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
pcLinearPattern->Occurrences.setValue(n);
}
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
pcLinearPattern->Occurrences.setValue(number);
exitSelectionMode();
kickUpdateViewTimer();
@@ -363,23 +309,27 @@ void TaskLinearPatternParameters::onOccurrences(const uint n) {
void TaskLinearPatternParameters::onDirectionChanged(int /*num*/)
{
if (blockUpdate)
if (blockUpdate) {
return;
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
try{
}
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
try {
if (!dirLinks.getCurrentLink().getValue()) {
// enter reference selection mode
hideObject();
showBase();
selectionMode = reference;
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();
@@ -390,13 +340,13 @@ void TaskLinearPatternParameters::onUpdateView(bool on)
blockUpdate = !on;
if (on) {
// Do the same like in TaskDlgLinearPatternParameters::accept() but without doCommand
PartDesign::LinearPattern* pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
auto pcLinearPattern = static_cast<PartDesign::LinearPattern*>(getObject());
std::vector<std::string> directions;
App::DocumentObject* obj;
App::DocumentObject* obj = nullptr;
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());
@@ -406,25 +356,10 @@ void TaskLinearPatternParameters::onUpdateView(bool on)
}
}
void TaskLinearPatternParameters::onFeatureDeleted()
void TaskLinearPatternParameters::getDirection(App::DocumentObject*& obj,
std::vector<std::string>& sub) const
{
PartDesign::Transformed* pcTransformed = getObject();
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
int currentRow = ui->listWidgetFeatures->currentRow();
if (currentRow < 0) {
Base::Console().Error("PartDesign LinearPattern: No feature selected for removing.\n");
return; //no current row selected
}
originals.erase(originals.begin() + currentRow);
setupTransaction();
pcTransformed->Originals.setValues(originals);
ui->listWidgetFeatures->model()->removeRow(currentRow);
recomputeFeature();
}
void TaskLinearPatternParameters::getDirection(App::DocumentObject*& obj, std::vector<std::string>& sub) const
{
const App::PropertyLinkSub &lnk = dirLinks.getCurrentLink();
const App::PropertyLinkSub& lnk = dirLinks.getCurrentLink();
obj = lnk.getValue();
sub = lnk.getSubValues();
}
@@ -457,42 +392,31 @@ 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();
ViewProviderOrigin* vpOrigin;
vpOrigin = static_cast<ViewProviderOrigin*>(Gui::Application::Instance->getViewProvider(origin));
App::Origin* origin = body->getOrigin();
auto vpOrigin = static_cast<ViewProviderOrigin*>(
Gui::Application::Instance->getViewProvider(origin));
vpOrigin->resetTemporaryVisibility();
}
}
catch (const Base::Exception &ex) {
Base::Console().Error ("%s\n", ex.what () );
}
if (proxy)
delete proxy;
}
void TaskLinearPatternParameters::changeEvent(QEvent *e)
{
TaskBox::changeEvent(e);
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(proxy);
catch (const Base::Exception& ex) {
Base::Console().Error("%s\n", ex.what());
}
}
void TaskLinearPatternParameters::apply()
{
std::vector<std::string> directions;
App::DocumentObject* obj;
App::DocumentObject* obj = nullptr;
getDirection(obj, directions);
std::string direction = buildLinkSingleSubPythonStr(obj, directions);
auto tobj = TransformedView->getObject();
FCMD_OBJ_CMD(tobj,"Direction = " << direction);
FCMD_OBJ_CMD(tobj,"Reversed = " << getReverse());
auto tobj = getObject();
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();
@@ -503,7 +427,8 @@ void TaskLinearPatternParameters::apply()
// TaskDialog
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskDlgLinearPatternParameters::TaskDlgLinearPatternParameters(ViewProviderLinearPattern *LinearPatternView)
TaskDlgLinearPatternParameters::TaskDlgLinearPatternParameters(
ViewProviderLinearPattern* LinearPatternView)
: TaskDlgTransformedParameters(LinearPatternView)
{
parameter = new TaskLinearPatternParameters(LinearPatternView);

65
src/Mod/PartDesign/Gui/TaskLinearPatternParameters.h
View File

@@ -30,48 +30,57 @@
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, QLayout *layout);
TaskLinearPatternParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget);
~TaskLinearPatternParameters() override;
void apply() override;
protected:
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
private Q_SLOTS:
void onUpdateViewTimer();
void onDirectionChanged(int num);
void onCheckReverse(const bool on);
void onModeChanged(const int mode);
void onLength(const double l);
void onOffset(const double o);
void onOccurrences(const uint n);
void onUpdateView(bool) override;
void onFeatureDeleted() override;
void onCheckReverse(bool on);
void onModeChanged(int mode);
void onLength(double length);
void onOffset(double offset);
void onOccurrences(uint number);
void onUpdateView(bool /*unused*/) override;
private:
void setupParameterUI(QWidget* widget) override;
void retranslateParameterUI(QWidget* widget) override;
void connectSignals();
void updateUI();
void adaptVisibilityToMode();
void kickUpdateViewTimer() const;
protected:
void addObject(App::DocumentObject*) override;
void removeObject(App::DocumentObject*) override;
void changeEvent(QEvent *e) override;
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
void clearButtons() override;
void getDirection(App::DocumentObject*& obj, std::vector<std::string>& sub) const;
bool getReverse() const;
int getMode() const;
@@ -79,31 +88,23 @@ protected:
double getOffset() const;
unsigned getOccurrences() const;
private:
void connectSignals();
void setupUI();
void updateUI();
void adaptVisibilityToMode();
void kickUpdateViewTimer() const;
private:
std::unique_ptr<Ui_TaskLinearPatternParameters> ui;
QTimer* updateViewTimer;
QTimer* updateViewTimer = nullptr;
ComboLinks dirLinks;
};
/// simulation dialog for the TaskView
class TaskDlgLinearPatternParameters : public TaskDlgTransformedParameters
class TaskDlgLinearPatternParameters: public TaskDlgTransformedParameters
{
Q_OBJECT
public:
explicit TaskDlgLinearPatternParameters(ViewProviderLinearPattern *LinearPatternView);
~TaskDlgLinearPatternParameters() override = default;
explicit TaskDlgLinearPatternParameters(ViewProviderLinearPattern* LinearPatternView);
};
} //namespace PartDesignGui
} // namespace PartDesignGui
#endif // GUI_TASKVIEW_TASKAPPERANCE_H
#endif // GUI_TASKVIEW_TASKAPPERANCE_H

109
src/Mod/PartDesign/Gui/TaskLinearPatternParameters.ui
View File

@@ -7,47 +7,25 @@
<x>0</x>
<y>0</y>
<width>270</width>
<height>339</height>
<height>188</height>
</rect>
</property>
<property name="windowTitle">
<string notr="true">Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QPushButton" name="buttonAddFeature">
<property name="text">
<string>Add feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonRemoveFeature">
<property name="text">
<string>Remove feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QListWidget" name="listWidgetFeatures">
<property name="toolTip">
<string>List can be reordered by dragging</string>
</property>
<property name="dragDropMode">
<enum>QAbstractItemView::InternalMove</enum>
</property>
</widget>
</item>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
@@ -184,27 +162,6 @@
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<widget class="QPushButton" name="buttonOK">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="checkBoxUpdateView">
<property name="text">
<string>Update view</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<customwidgets>
@@ -221,49 +178,11 @@
</customwidget>
</customwidgets>
<tabstops>
<tabstop>buttonAddFeature</tabstop>
<tabstop>buttonRemoveFeature</tabstop>
<tabstop>listWidgetFeatures</tabstop>
<tabstop>comboDirection</tabstop>
<tabstop>checkReverse</tabstop>
<tabstop>spinLength</tabstop>
<tabstop>spinOccurrences</tabstop>
<tabstop>buttonOK</tabstop>
<tabstop>checkBoxUpdateView</tabstop>
</tabstops>
<resources/>
<connections>
<connection>
<sender>buttonAddFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonRemoveFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>70</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>198</x>
<y>21</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonRemoveFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonAddFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>198</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>70</x>
<y>21</y>
</hint>
</hints>
</connection>
</connections>
<connections/>
</ui>

261
src/Mod/PartDesign/Gui/TaskMirroredParameters.cpp
View File

@@ -24,8 +24,7 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QAction>
# include <QMessageBox>
#include <QMessageBox>
#endif
#include <App/Document.h>
@@ -49,163 +48,103 @@ 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)
{
// we need a separate container widget to add all controls to
proxy = new QWidget(this);
ui->setupUi(proxy);
QMetaObject::connectSlotsByName(this);
this->groupLayout()->addWidget(proxy);
ui->buttonOK->hide();
ui->checkBoxUpdateView->setEnabled(true);
selectionMode = none;
blockUpdate = false; // Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
setupUI();
}
TaskMirroredParameters::TaskMirroredParameters(TaskMultiTransformParameters *parentTask, QLayout *layout)
: TaskTransformedParameters(parentTask), ui(new Ui_TaskMirroredParameters)
TaskMirroredParameters::TaskMirroredParameters(TaskMultiTransformParameters* parentTask,
QWidget* parameterWidget)
: TaskTransformedParameters(parentTask)
, ui(new Ui_TaskMirroredParameters)
{
proxy = new QWidget(parentTask);
ui->setupUi(proxy);
connect(ui->buttonOK, &QToolButton::pressed,
parentTask, &TaskMirroredParameters::onSubTaskButtonOK);
QMetaObject::connectSlotsByName(this);
layout->addWidget(proxy);
ui->buttonOK->setEnabled(true);
ui->buttonAddFeature->hide();
ui->buttonRemoveFeature->hide();
ui->listWidgetFeatures->hide();
ui->checkBoxUpdateView->hide();
selectionMode = none;
blockUpdate = false; // Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
setupUI();
setupParameterUI(parameterWidget);
}
void TaskMirroredParameters::setupUI()
void TaskMirroredParameters::setupParameterUI(QWidget* widget)
{
connect(ui->buttonAddFeature, &QToolButton::toggled, this, &TaskMirroredParameters::onButtonAddFeature);
connect(ui->buttonRemoveFeature, &QToolButton::toggled, this, &TaskMirroredParameters::onButtonRemoveFeature);
ui->setupUi(widget);
QMetaObject::connectSlotsByName(this);
// Create context menu
QAction* action = new QAction(tr("Remove"), this);
action->setShortcut(QKeySequence::Delete);
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
// display shortcut behind the context menu entry
action->setShortcutVisibleInContextMenu(true);
#endif
ui->listWidgetFeatures->addAction(action);
connect(action, &QAction::triggered, this, &TaskMirroredParameters::onFeatureDeleted);
ui->listWidgetFeatures->setContextMenuPolicy(Qt::ActionsContextMenu);
connect(ui->listWidgetFeatures->model(), &QAbstractListModel::rowsMoved,
this, &TaskMirroredParameters::indexesMoved);
connect(ui->comboPlane, qOverload<int>(&QComboBox::activated),
this, &TaskMirroredParameters::onPlaneChanged);
connect(ui->checkBoxUpdateView, &QCheckBox::toggled,
this, &TaskMirroredParameters::onUpdateView);
// Get the feature data
PartDesign::Mirrored* pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
std::vector<App::DocumentObject*> originals = pcMirrored->Originals.getValues();
// Fill data into dialog elements
for (auto obj : originals) {
if (obj) {
QListWidgetItem* item = new QListWidgetItem();
item->setText(QString::fromUtf8(obj->Label.getValue()));
item->setData(Qt::UserRole, QString::fromLatin1(obj->getNameInDocument()));
ui->listWidgetFeatures->addItem(item);
}
}
// ---------------------
connect(ui->comboPlane,
qOverload<int>(&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<Part::Part2DObject*>(sketch));
if (sketch && sketch->isDerivedFrom<Part::Part2DObject>()) {
this->fillPlanesCombo(planeLinks, static_cast<Part::Part2DObject*>(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();
ViewProviderOrigin* vpOrigin;
vpOrigin = static_cast<ViewProviderOrigin*>(Gui::Application::Instance->getViewProvider(origin));
App::Origin* origin = body->getOrigin();
auto vpOrigin = static_cast<ViewProviderOrigin*>(
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());
}
}
updateUI();
}
void TaskMirroredParameters::retranslateParameterUI(QWidget* widget)
{
ui->retranslateUi(widget);
}
void TaskMirroredParameters::updateUI()
{
if (blockUpdate)
if (blockUpdate) {
return;
}
blockUpdate = true;
PartDesign::Mirrored* pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
auto pcMirrored = static_cast<PartDesign::Mirrored*>(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);
}
blockUpdate = false;
}
void TaskMirroredParameters::addObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
QString objectName = QString::fromLatin1(obj->getNameInDocument());
QListWidgetItem* item = new QListWidgetItem();
item->setText(label);
item->setData(Qt::UserRole, objectName);
ui->listWidgetFeatures->addItem(item);
}
void TaskMirroredParameters::removeObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
removeItemFromListWidget(ui->listWidgetFeatures, label);
}
void TaskMirroredParameters::onSelectionChanged(const Gui::SelectionChanges& msg)
{
if (selectionMode!=none && msg.Type == Gui::SelectionChanges::AddSelection) {
if (selectionMode != SelectionMode::None && msg.Type == Gui::SelectionChanges::AddSelection) {
if (originalSelected(msg)) {
exitSelectionMode();
} else {
std::vector<std::string> mirrorPlanes;
App::DocumentObject* selObj;
PartDesign::Mirrored* pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
getReferencedSelection(pcMirrored, msg, selObj, mirrorPlanes);
if (!selObj)
return;
}
else if (selectionMode == SelectionMode::Reference) {
auto pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
if ( selectionMode == reference || selObj->isDerivedFrom ( App::Plane::getClassTypeId () ) ) {
std::vector<std::string> mirrorPlanes;
App::DocumentObject* selObj = nullptr;
getReferencedSelection(pcMirrored, msg, selObj, mirrorPlanes);
if (!selObj) {
return;
}
if (selObj->isDerivedFrom<App::Plane>()) {
setupTransaction();
pcMirrored->MirrorPlane.setValue(selObj, mirrorPlanes);
recomputeFeature();
@@ -216,32 +155,29 @@ void TaskMirroredParameters::onSelectionChanged(const Gui::SelectionChanges& msg
}
}
void TaskMirroredParameters::clearButtons()
{
ui->buttonAddFeature->setChecked(false);
ui->buttonRemoveFeature->setChecked(false);
}
void TaskMirroredParameters::onPlaneChanged(int /*num*/)
{
if (blockUpdate)
if (blockUpdate) {
return;
}
setupTransaction();
PartDesign::Mirrored* pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
try{
auto pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
try {
if (!planeLinks.getCurrentLink().getValue()) {
// enter reference selection mode
hideObject();
showBase();
selectionMode = reference;
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();
@@ -253,68 +189,49 @@ void TaskMirroredParameters::onUpdateView(bool on)
if (on) {
setupTransaction();
// Do the same like in TaskDlgMirroredParameters::accept() but without doCommand
PartDesign::Mirrored* pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
auto pcMirrored = static_cast<PartDesign::Mirrored*>(getObject());
std::vector<std::string> mirrorPlanes;
App::DocumentObject* obj;
App::DocumentObject* obj = nullptr;
getMirrorPlane(obj, mirrorPlanes);
pcMirrored->MirrorPlane.setValue(obj,mirrorPlanes);
pcMirrored->MirrorPlane.setValue(obj, mirrorPlanes);
recomputeFeature();
}
}
void TaskMirroredParameters::onFeatureDeleted()
void TaskMirroredParameters::getMirrorPlane(App::DocumentObject*& obj,
std::vector<std::string>& sub) const
{
PartDesign::Transformed* pcTransformed = getObject();
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
int currentRow = ui->listWidgetFeatures->currentRow();
if (currentRow < 0) {
Base::Console().Error("PartDesign MirroredPattern: No feature selected for removing.\n");
return; //no current row selected
}
originals.erase(originals.begin() + currentRow);
setupTransaction();
pcTransformed->Originals.setValues(originals);
ui->listWidgetFeatures->model()->removeRow(currentRow);
recomputeFeature();
}
void TaskMirroredParameters::getMirrorPlane(App::DocumentObject*& obj, std::vector<std::string> &sub) const
{
const App::PropertyLinkSub &lnk = planeLinks.getCurrentLink();
const App::PropertyLinkSub& lnk = planeLinks.getCurrentLink();
obj = lnk.getValue();
sub = lnk.getSubValues();
}
void TaskMirroredParameters::apply()
{
std::vector<std::string> mirrorPlanes;
App::DocumentObject* obj = nullptr;
getMirrorPlane(obj, mirrorPlanes);
std::string mirrorPlane = buildLinkSingleSubPythonStr(obj, mirrorPlanes);
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();
ViewProviderOrigin* vpOrigin;
vpOrigin = static_cast<ViewProviderOrigin*>(Gui::Application::Instance->getViewProvider(origin));
PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject());
if (body) {
App::Origin* origin = body->getOrigin();
auto vpOrigin = static_cast<ViewProviderOrigin*>(
Gui::Application::Instance->getViewProvider(origin));
vpOrigin->resetTemporaryVisibility();
}
} catch (const Base::Exception &ex) {
Base::Console().Error ("%s\n", ex.what () );
}
if (proxy)
delete proxy;
}
void TaskMirroredParameters::changeEvent(QEvent *e)
{
TaskBox::changeEvent(e);
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(proxy);
catch (const Base::Exception& ex) {
Base::Console().Error("%s\n", ex.what());
}
}
@@ -323,26 +240,12 @@ void TaskMirroredParameters::changeEvent(QEvent *e)
// TaskDialog
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskDlgMirroredParameters::TaskDlgMirroredParameters(ViewProviderMirrored *MirroredView)
TaskDlgMirroredParameters::TaskDlgMirroredParameters(ViewProviderMirrored* MirroredView)
: TaskDlgTransformedParameters(MirroredView)
{
parameter = new TaskMirroredParameters(MirroredView);
Content.push_back(parameter);
}
//==== calls from the TaskView ===============================================================
bool TaskDlgMirroredParameters::accept()
{
TaskMirroredParameters* mirrorParameter = static_cast<TaskMirroredParameters*>(parameter);
std::vector<std::string> mirrorPlanes;
App::DocumentObject* obj;
mirrorParameter->getMirrorPlane(obj, mirrorPlanes);
std::string mirrorPlane = buildLinkSingleSubPythonStr(obj, mirrorPlanes);
FCMD_OBJ_CMD(vp->getObject(),"MirrorPlane = " << mirrorPlane);
return TaskDlgTransformedParameters::accept();
}
#include "moc_TaskMirroredParameters.cpp"

50
src/Mod/PartDesign/Gui/TaskMirroredParameters.h
View File

@@ -29,70 +29,64 @@
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, QLayout *layout);
TaskMirroredParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget);
~TaskMirroredParameters() override;
void getMirrorPlane(App::DocumentObject*& obj, std::vector<std::string>& sub) const;
void apply() override;
protected:
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
private Q_SLOTS:
void onPlaneChanged(int num);
void onUpdateView(bool) override;
void onFeatureDeleted() override;
protected:
void addObject(App::DocumentObject*) override;
void removeObject(App::DocumentObject*) override;
void changeEvent(QEvent *e) override;
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
void clearButtons() override;
void onUpdateView(bool /*unused*/) override;
private:
void setupUI();
void setupParameterUI(QWidget* widget) override;
void retranslateParameterUI(QWidget* widget) override;
void updateUI();
ComboLinks planeLinks;
void getMirrorPlane(App::DocumentObject*& obj, std::vector<std::string>& sub) const;
private:
ComboLinks planeLinks;
std::unique_ptr<Ui_TaskMirroredParameters> ui;
};
/// simulation dialog for the TaskView
class TaskDlgMirroredParameters : public TaskDlgTransformedParameters
class TaskDlgMirroredParameters: public TaskDlgTransformedParameters
{
Q_OBJECT
public:
explicit TaskDlgMirroredParameters(ViewProviderMirrored *MirroredView);
~TaskDlgMirroredParameters() override = default;
public:
/// is called by the framework if the dialog is accepted (Ok)
bool accept() override;
explicit TaskDlgMirroredParameters(ViewProviderMirrored* MirroredView);
};
} //namespace PartDesignGui
} // namespace PartDesignGui
#endif // GUI_TASKVIEW_TASKAPPERANCE_H
#endif // GUI_TASKVIEW_TASKAPPERANCE_H

109
src/Mod/PartDesign/Gui/TaskMirroredParameters.ui
View File

@@ -7,47 +7,25 @@
<x>0</x>
<y>0</y>
<width>253</width>
<height>260</height>
<height>55</height>
</rect>
</property>
<property name="windowTitle">
<string notr="true">Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QPushButton" name="buttonAddFeature">
<property name="text">
<string>Add feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonRemoveFeature">
<property name="text">
<string>Remove feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QListWidget" name="listWidgetFeatures">
<property name="toolTip">
<string>List can be reordered by dragging</string>
</property>
<property name="dragDropMode">
<enum>QAbstractItemView::InternalMove</enum>
</property>
</widget>
</item>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
@@ -62,70 +40,11 @@
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QPushButton" name="buttonOK">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="checkBoxUpdateView">
<property name="text">
<string>Update view</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<tabstops>
<tabstop>buttonAddFeature</tabstop>
<tabstop>buttonRemoveFeature</tabstop>
<tabstop>listWidgetFeatures</tabstop>
<tabstop>comboPlane</tabstop>
<tabstop>buttonOK</tabstop>
<tabstop>checkBoxUpdateView</tabstop>
</tabstops>
<resources/>
<connections>
<connection>
<sender>buttonAddFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonRemoveFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>66</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>186</x>
<y>21</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonRemoveFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonAddFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>186</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>66</x>
<y>21</y>
</hint>
</hints>
</connection>
</connections>
<connections/>
</ui>

464
src/Mod/PartDesign/Gui/TaskMultiTransformParameters.cpp
View File

@@ -24,7 +24,7 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QAction>
#include <QAction>
#endif
#include <App/Document.h>
@@ -54,80 +54,79 @@ 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)
, subTask(nullptr)
, subFeature(nullptr)
{
// we need a separate container widget to add all controls to
proxy = new QWidget(this);
ui->setupUi(proxy);
setupUI();
}
void TaskMultiTransformParameters::setupParameterUI(QWidget* widget)
{
ui->setupUi(widget);
QMetaObject::connectSlotsByName(this);
this->groupLayout()->addWidget(proxy);
connect(ui->buttonAddFeature, &QToolButton::toggled,
this, &TaskMultiTransformParameters::onButtonAddFeature);
connect(ui->buttonRemoveFeature, &QToolButton::toggled,
this, &TaskMultiTransformParameters::onButtonRemoveFeature);
// Create context menu
QAction* action = new QAction(tr("Remove"), this);
action->setShortcut(QKeySequence::Delete);
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
// display shortcut behind the context menu entry
action->setShortcutVisibleInContextMenu(true);
#endif
ui->listWidgetFeatures->addAction(action);
connect(action, &QAction::triggered,
this, &TaskMultiTransformParameters::onFeatureDeleted);
ui->listWidgetFeatures->setContextMenuPolicy(Qt::ActionsContextMenu);
connect(ui->listWidgetFeatures->model(), &QAbstractListModel::rowsMoved,
this, &TaskMultiTransformParameters::indexesMoved);
// Create a context menu for the listview of transformation features
action = new QAction(tr("Edit"), ui->listTransformFeatures);
action->connect(action, &QAction::triggered,
this, &TaskMultiTransformParameters::onTransformEdit);
auto action = new QAction(tr("Edit"), ui->listTransformFeatures);
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->checkBoxUpdateView, &QCheckBox::toggled,
this, &TaskMultiTransformParameters::onUpdateView);
connect(ui->listTransformFeatures, &QListWidget::activated,
this, &TaskMultiTransformParameters::onTransformActivated);
connect(ui->listTransformFeatures,
&QListWidget::activated,
this,
&TaskMultiTransformParameters::onTransformActivated);
connect(ui->buttonOK,
&QToolButton::pressed,
this,
&TaskMultiTransformParameters::onSubTaskButtonOK);
ui->buttonOK->hide();
// Get the transformFeatures data
PartDesign::MultiTransform* pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> transformFeatures = pcMultiTransform->Transformations.getValues();
auto pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> transformFeatures =
pcMultiTransform->Transformations.getValues();
// Fill data into dialog elements
ui->listTransformFeatures->setEnabled(true);
@@ -140,100 +139,65 @@ TaskMultiTransformParameters::TaskMultiTransformParameters(ViewProviderTransform
if (!transformFeatures.empty()) {
ui->listTransformFeatures->setCurrentRow(0, QItemSelectionModel::ClearAndSelect);
editHint = false;
} else {
}
else {
ui->listTransformFeatures->addItem(tr("Right-click to add"));
editHint = true;
}
// Get the Originals data
std::vector<App::DocumentObject*> originals = pcMultiTransform->Originals.getValues();
// Fill data into dialog elements
for (auto obj : originals) {
if (obj) {
QListWidgetItem* item = new QListWidgetItem();
item->setText(QString::fromUtf8(obj->Label.getValue()));
item->setData(Qt::UserRole, QString::fromLatin1(obj->getNameInDocument()));
ui->listWidgetFeatures->addItem(item);
}
}
// ---------------------
}
void TaskMultiTransformParameters::addObject(App::DocumentObject* obj)
void TaskMultiTransformParameters::retranslateParameterUI(QWidget* widget)
{
QString label = QString::fromUtf8(obj->Label.getValue());
QString objectName = QString::fromLatin1(obj->getNameInDocument());
QListWidgetItem* item = new QListWidgetItem();
item->setText(label);
item->setData(Qt::UserRole, objectName);
ui->listWidgetFeatures->addItem(item);
}
void TaskMultiTransformParameters::removeObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
removeItemFromListWidget(ui->listWidgetFeatures, label);
}
void TaskMultiTransformParameters::onSelectionChanged(const Gui::SelectionChanges& msg)
{
if (originalSelected(msg)) {
exitSelectionMode();
}
}
void TaskMultiTransformParameters::clearButtons()
{
ui->buttonAddFeature->setChecked(false);
ui->buttonRemoveFeature->setChecked(false);
}
void TaskMultiTransformParameters::onFeatureDeleted()
{
PartDesign::Transformed* pcTransformed = getObject();
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
int currentRow = ui->listWidgetFeatures->currentRow();
if (currentRow < 0){
Base::Console().Error("PartDesign Multitransform: No feature selected for removing.\n");
return; //no current row selected
}
originals.erase(originals.begin() + currentRow);
setupTransaction();
pcTransformed->Originals.setValues(originals);
ui->listWidgetFeatures->model()->removeRow(currentRow);
recomputeFeature();
ui->retranslateUi(widget);
}
void TaskMultiTransformParameters::slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj)
{
if (Obj.getObject() == this->subFeature)
if (Obj.getObject() == this->subFeature) {
this->subFeature = nullptr;
}
TaskTransformedParameters::slotDeletedObject(Obj);
}
void TaskMultiTransformParameters::closeSubTask()
{
if (subTask) {
ui->buttonOK->hide();
exitSelectionMode();
disconnect(ui->checkBoxUpdateView, nullptr, subTask, nullptr);
// The subfeature can already be deleted (e.g. cancel) so we have to check before
// calling apply
if (subFeature) {
subTask->apply();
}
// Remove all parameter ui widgets and layout
ui->subFeatureWidget->setUpdatesEnabled(false);
qDeleteAll(
ui->subFeatureWidget->findChildren<QWidget*>(QString(), Qt::FindDirectChildrenOnly));
qDeleteAll(
ui->subFeatureWidget->findChildren<QLayout*>(QString(), Qt::FindDirectChildrenOnly));
ui->subFeatureWidget->setUpdatesEnabled(true);
delete subTask;
subTask = nullptr;
subFeature = nullptr;
}
}
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<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> transformFeatures = pcMultiTransform->Transformations.getValues();
auto pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> 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());
@@ -241,8 +205,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);
@@ -251,29 +215,37 @@ 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<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> transformFeatures = pcMultiTransform->Transformations.getValues();
auto pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> transformFeatures =
pcMultiTransform->Transformations.getValues();
subFeature = static_cast<PartDesign::Transformed*>(transformFeatures[row]);
if (transformFeatures[row]->is<PartDesign::Mirrored>())
subTask = new TaskMirroredParameters(this, ui->verticalLayout);
else if (transformFeatures[row]->is<PartDesign::LinearPattern>())
subTask = new TaskLinearPatternParameters(this, ui->verticalLayout);
else if (transformFeatures[row]->is<PartDesign::PolarPattern>())
subTask = new TaskPolarPatternParameters(this, ui->verticalLayout);
else if (transformFeatures[row]->is<PartDesign::Scaled>())
subTask = new TaskScaledParameters(this, ui->verticalLayout);
else
return; // TODO: Show an error?
if (subFeature->is<PartDesign::Mirrored>()) {
subTask = new TaskMirroredParameters(this, ui->subFeatureWidget);
}
else if (subFeature->is<PartDesign::LinearPattern>()) {
subTask = new TaskLinearPatternParameters(this, ui->subFeatureWidget);
}
else if (subFeature->is<PartDesign::PolarPattern>()) {
subTask = new TaskPolarPatternParameters(this, ui->subFeatureWidget);
}
else if (subFeature->is<PartDesign::Scaled>()) {
subTask = new TaskScaledParameters(this, ui->subFeatureWidget);
}
else {
return; // TODO: Show an error?
}
ui->buttonOK->show();
subTask->setEnabledTransaction(isEnabledTransaction());
connect(ui->checkBoxUpdateView, &QCheckBox::toggled,
subTask, &TaskTransformedParameters::onUpdateView);
}
void TaskMultiTransformParameters::onTransformActivated(const QModelIndex& index)
@@ -285,30 +257,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','"<<newFeatName<<"')");
FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::Mirrored','" << newFeatName << "')");
auto Feat = pcActiveBody->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 = ("<<Gui::Command::getObjectCmd(sketch)<<",['V_Axis'])");
if (sketch) {
FCMD_OBJ_CMD(Feat,
"MirrorPlane = (" << Gui::Command::getObjectCmd(sketch) << ",['V_Axis'])");
}
else {
App::Origin* orig = pcActiveBody->getOrigin();
FCMD_OBJ_CMD(Feat, "MirrorPlane = ("<<Gui::Command::getObjectCmd(orig->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()
@@ -316,29 +296,35 @@ 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','"<<newFeatName<<"')");
FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::LinearPattern','" << newFeatName << "')");
auto Feat = pcActiveBody->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 = ("<<Gui::Command::getObjectCmd(sketch)<<",['H_Axis'])");
FCMD_OBJ_CMD(Feat, "Direction = (" << Gui::Command::getObjectCmd(sketch) << ",['H_Axis'])");
}
else {
// set Direction value before filling up the combo box to avoid creating an empty item
// inside updateUI()
PartDesign::Body* body = static_cast<PartDesign::Body*>(Part::BodyBase::findBodyOf(getObject()));
auto body = static_cast<PartDesign::Body*>(Part::BodyBase::findBodyOf(getObject()));
if (body) {
FCMD_OBJ_CMD(Feat, "Direction = ("<<Gui::Command::getObjectCmd(body->getOrigin()->getX())<<",[''])");
FCMD_OBJ_CMD(Feat,
"Direction = (" << Gui::Command::getObjectCmd(body->getOrigin()->getX())
<< ",[''])");
}
}
@@ -347,75 +333,89 @@ 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','"<<newFeatName<<"')");
FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::PolarPattern','" << newFeatName << "')");
auto Feat = pcActiveBody->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 = ("<<Gui::Command::getObjectCmd(sketch)<<",['N_Axis'])");
if (sketch) {
FCMD_OBJ_CMD(Feat, "Axis = (" << Gui::Command::getObjectCmd(sketch) << ",['N_Axis'])");
}
else {
App::Origin* orig = pcActiveBody->getOrigin();
FCMD_OBJ_CMD(Feat, "Axis = ("<<Gui::Command::getObjectCmd(orig->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','"<<newFeatName<<"')");
FCMD_OBJ_CMD(pcActiveBody, "newObject('PartDesign::Scaled','" << newFeatName << "')");
auto Feat = pcActiveBody->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<PartDesign::MultiTransform*>(TransformedView->getObject());
auto pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
if (editHint) {
// Remove hint, first feature is being added
ui->listTransformFeatures->model()->removeRow(0);
@@ -423,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<App::DocumentObject*> 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<App::DocumentObject*> 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);
@@ -458,22 +464,25 @@ void TaskMultiTransformParameters::moveTransformFeature(const int increment)
{
setupTransaction();
int row = ui->listTransformFeatures->currentIndex().row();
PartDesign::MultiTransform* pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> transformFeatures = pcMultiTransform->Transformations.getValues();
auto pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
std::vector<App::DocumentObject*> transformFeatures =
pcMultiTransform->Transformations.getValues();
if (transformFeatures.empty())
if (transformFeatures.empty()) {
return;
}
App::DocumentObject* feature = transformFeatures[row];
transformFeatures.erase(transformFeatures.begin() + row);
QListWidgetItem* item = new QListWidgetItem(*(ui->listTransformFeatures->item(row)));
auto item = new QListWidgetItem(*(ui->listTransformFeatures->item(row)));
ui->listTransformFeatures->model()->removeRow(row);
// After this operation, if we were to insert at index row again, things will remain unchanged
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
@@ -481,7 +490,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);
@@ -514,14 +524,20 @@ void TaskMultiTransformParameters::onUpdateView(bool on)
}
}
const std::vector<App::DocumentObject*> TaskMultiTransformParameters::getTransformFeatures() const
{
PartDesign::MultiTransform* pcMultiTransform = static_cast<PartDesign::MultiTransform*>(TransformedView->getObject());
return pcMultiTransform->Transformations.getValues();
}
void TaskMultiTransformParameters::apply()
{
auto pcMultiTransform = static_cast<PartDesign::MultiTransform*>(getObject());
std::vector<App::DocumentObject*> transformFeatures =
pcMultiTransform->Transformations.getValues();
std::stringstream str;
str << Gui::Command::getObjectCmd(TransformedView->getObject()) << ".Transformations = [";
for (auto it : transformFeatures) {
if (it) {
str << Gui::Command::getObjectCmd(it) << ",";
}
}
str << "]";
Gui::Command::runCommand(Gui::Command::Doc, str.str().c_str());
}
TaskMultiTransformParameters::~TaskMultiTransformParameters()
@@ -530,18 +546,8 @@ TaskMultiTransformParameters::~TaskMultiTransformParameters()
closeSubTask();
}
catch (const Py::Exception&) {
Base::PyException e; // extract the Python error text
e.ReportException();
}
if (proxy)
delete proxy;
}
void TaskMultiTransformParameters::changeEvent(QEvent *e)
{
TaskBox::changeEvent(e);
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(proxy);
Base::PyException exc; // extract the Python error text
exc.ReportException();
}
}
@@ -550,7 +556,8 @@ void TaskMultiTransformParameters::changeEvent(QEvent *e)
// TaskDialog
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskDlgMultiTransformParameters::TaskDlgMultiTransformParameters(ViewProviderMultiTransform *MultiTransformView)
TaskDlgMultiTransformParameters::TaskDlgMultiTransformParameters(
ViewProviderMultiTransform* MultiTransformView)
: TaskDlgTransformedParameters(MultiTransformView)
{
parameter = new TaskMultiTransformParameters(MultiTransformView);
@@ -558,46 +565,5 @@ TaskDlgMultiTransformParameters::TaskDlgMultiTransformParameters(ViewProviderMul
Content.push_back(parameter);
}
//==== calls from the TaskView ===============================================================
bool TaskDlgMultiTransformParameters::accept()
{
// Set up transformations
TaskMultiTransformParameters* mtParameter = static_cast<TaskMultiTransformParameters*>(parameter);
std::vector<App::DocumentObject*> transformFeatures = mtParameter->getTransformFeatures();
std::stringstream str;
str << Gui::Command::getObjectCmd(vp->getObject()) << ".Transformations = [";
for (auto it : transformFeatures) {
if (it) {
str << Gui::Command::getObjectCmd(it) << ",";
}
}
str << "]";
Gui::Command::runCommand(Gui::Command::Doc,str.str().c_str());
return TaskDlgFeatureParameters::accept ();
}
// FIXME: It seems all roll back is finely handled by abortCommand() in parent classes. On the other
// hand manual removal of objects may lead to segfault in dialog distructer of subtransformation
// due to TaskMultiTransformParameters::getSubFeature() returns already destroid object. So check
// that everything is fine and delete the method. (2015-07-31, Fat-Zer)
//bool TaskDlgMultiTransformParameters::reject()
//{
// // Get objects before view is invalidated
// // For the same reason we can't delegate showing the originals to TaskDlgTransformedParameters::reject()
// PartDesign::MultiTransform* pcMultiTransform = static_cast<PartDesign::MultiTransform*>(vp->getObject());
// std::vector<App::DocumentObject*> transformFeatures = pcMultiTransform->Transformations.getValues();
//
// // Delete the transformation features - must happen before abortCommand()!
// for (std::vector<App::DocumentObject*>::const_iterator it = transformFeatures.begin(); it != transformFeatures.end(); ++it)
// {
// if ((*it) != NULL)
// Gui::Command::doCommand(
// Gui::Command::Doc,"App.ActiveDocument.removeObject(\"%s\")", (*it)->getNameInDocument());
// }
//
// return TaskDlgTransformedParameters::reject();
//}
#include "moc_TaskMultiTransformParameters.cpp"

73
src/Mod/PartDesign/Gui/TaskMultiTransformParameters.h
View File

@@ -30,44 +30,45 @@
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;
const std::vector<App::DocumentObject*> getTransformFeatures() const;
/// Return the currently active subFeature
PartDesign::Transformed* getSubFeature() {
return subFeature;
}
void apply() override;
public Q_SLOTS:
/// User finished editing a subFeature
void onSubTaskButtonOK() override;
/// Return the currently active subFeature
PartDesign::Transformed* getSubFeature()
{
return subFeature;
}
private Q_SLOTS:
/// User finished editing a subFeature
void onSubTaskButtonOK();
void onTransformDelete();
void onTransformEdit();
void onTransformActivated(const QModelIndex& index);
@@ -79,49 +80,41 @@ private Q_SLOTS:
void onMoveDown();
// Note: There is no Cancel button because I couldn't work out how to save the state of
// a subFeature so as to revert the changes of an edit operation
void onUpdateView(bool) override;
void onFeatureDeleted() override;
void onUpdateView(bool /*unused*/) override;
private:
void setupParameterUI(QWidget* widget) override;
void retranslateParameterUI(QWidget* widget) override;
/** Notifies when the object is about to be removed. */
void slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj) override;
protected:
void addObject(App::DocumentObject*) override;
void removeObject(App::DocumentObject*) override;
void changeEvent(QEvent *e) override;
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
void clearButtons() override;
private:
void updateUI();
void closeSubTask();
void moveTransformFeature(const int increment);
void finishAdd(std::string &newFeatName);
void moveTransformFeature(int increment);
void finishAdd(std::string& newFeatName);
private:
std::unique_ptr<Ui_TaskMultiTransformParameters> ui;
/// The subTask and subFeature currently active in the UI
TaskTransformedParameters* subTask;
PartDesign::Transformed* subFeature;
bool editHint;
TaskTransformedParameters* subTask = nullptr;
PartDesign::Transformed* subFeature = nullptr;
bool editHint = false;
};
/// simulation dialog for the TaskView
class TaskDlgMultiTransformParameters : public TaskDlgTransformedParameters
class TaskDlgMultiTransformParameters: public TaskDlgTransformedParameters
{
Q_OBJECT
public:
explicit TaskDlgMultiTransformParameters(ViewProviderMultiTransform *MultiTransformView);
~TaskDlgMultiTransformParameters() override = default;
explicit TaskDlgMultiTransformParameters(ViewProviderMultiTransform* MultiTransformView);
public:
/// is called by the framework if the dialog is accepted (Ok)
bool accept() override;
/// 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

101
src/Mod/PartDesign/Gui/TaskMultiTransformParameters.ui
View File

@@ -6,48 +6,26 @@
<rect>
<x>0</x>
<y>0</y>
<width>256</width>
<height>266</height>
<width>229</width>
<height>174</height>
</rect>
</property>
<property name="windowTitle">
<string notr="true">Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QPushButton" name="buttonAddFeature">
<property name="text">
<string>Add feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonRemoveFeature">
<property name="text">
<string>Remove feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QListWidget" name="listWidgetFeatures">
<property name="toolTip">
<string>List can be reordered by dragging</string>
</property>
<property name="dragDropMode">
<enum>QAbstractItemView::InternalMove</enum>
</property>
</widget>
</item>
<layout class="QVBoxLayout" name="verticalLayout" stretch="0,0,0,0">
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<widget class="QLabel" name="label">
<property name="text">
@@ -66,57 +44,20 @@
</widget>
</item>
<item>
<widget class="QCheckBox" name="checkBoxUpdateView">
<widget class="QWidget" name="subFeatureWidget" native="true"/>
</item>
<item>
<widget class="QPushButton" name="buttonOK">
<property name="text">
<string>Update view</string>
</property>
<property name="checked">
<bool>true</bool>
<string>OK</string>
</property>
</widget>
</item>
</layout>
</widget>
<tabstops>
<tabstop>buttonAddFeature</tabstop>
<tabstop>buttonRemoveFeature</tabstop>
<tabstop>listWidgetFeatures</tabstop>
<tabstop>listTransformFeatures</tabstop>
<tabstop>checkBoxUpdateView</tabstop>
</tabstops>
<resources/>
<connections>
<connection>
<sender>buttonAddFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonRemoveFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>67</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>188</x>
<y>21</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonRemoveFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonAddFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>188</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>67</x>
<y>21</y>
</hint>
</hints>
</connection>
</connections>
<connections/>
</ui>

358
src/Mod/PartDesign/Gui/TaskPolarPatternParameters.cpp
View File

@@ -24,9 +24,8 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QMessageBox>
# include <QAction>
# include <QTimer>
#include <QMessageBox>
#include <QTimer>
#endif
#include <Base/UnitsApi.h>
@@ -60,107 +59,29 @@ 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)
{
// we need a separate container widget to add all controls to
proxy = new QWidget(this);
ui->setupUi(proxy);
QMetaObject::connectSlotsByName(this);
this->groupLayout()->addWidget(proxy);
ui->buttonOK->hide();
ui->checkBoxUpdateView->setEnabled(true);
selectionMode = none;
blockUpdate = false; // Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
setupUI();
}
TaskPolarPatternParameters::TaskPolarPatternParameters(TaskMultiTransformParameters *parentTask, QLayout *layout)
: TaskTransformedParameters(parentTask), ui(new Ui_TaskPolarPatternParameters)
TaskPolarPatternParameters::TaskPolarPatternParameters(TaskMultiTransformParameters* parentTask,
QWidget* parameterWidget)
: TaskTransformedParameters(parentTask)
, ui(new Ui_TaskPolarPatternParameters)
{
proxy = new QWidget(parentTask);
ui->setupUi(proxy);
connect(ui->buttonOK, &QToolButton::pressed,
parentTask, &TaskMultiTransformParameters::onSubTaskButtonOK);
setupParameterUI(parameterWidget);
}
void TaskPolarPatternParameters::setupParameterUI(QWidget* widget)
{
ui->setupUi(widget);
QMetaObject::connectSlotsByName(this);
layout->addWidget(proxy);
ui->buttonOK->setEnabled(true);
ui->buttonAddFeature->hide();
ui->buttonRemoveFeature->hide();
ui->listWidgetFeatures->hide();
ui->checkBoxUpdateView->hide();
selectionMode = none;
blockUpdate = false; // Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
setupUI();
}
void TaskPolarPatternParameters::connectSignals()
{
connect(ui->buttonAddFeature, &QToolButton::toggled,
this, &TaskPolarPatternParameters::onButtonAddFeature);
connect(ui->buttonRemoveFeature, &QToolButton::toggled,
this, &TaskPolarPatternParameters::onButtonRemoveFeature);
// Create context menu
QAction* action = new QAction(tr("Remove"), this);
action->setShortcut(QKeySequence::Delete);
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
// display shortcut behind the context menu entry
action->setShortcutVisibleInContextMenu(true);
#endif
ui->listWidgetFeatures->addAction(action);
connect(action, &QAction::triggered,
this, &TaskPolarPatternParameters::onFeatureDeleted);
ui->listWidgetFeatures->setContextMenuPolicy(Qt::ActionsContextMenu);
connect(ui->listWidgetFeatures->model(), &QAbstractListModel::rowsMoved,
this, &TaskPolarPatternParameters::indexesMoved);
updateViewTimer = new QTimer(this);
updateViewTimer->setSingleShot(true);
updateViewTimer->setInterval(getUpdateViewTimeout());
connect(updateViewTimer, &QTimer::timeout,
this, &TaskPolarPatternParameters::onUpdateViewTimer);
connect(ui->comboAxis, qOverload<int>(&QComboBox::activated),
this, &TaskPolarPatternParameters::onAxisChanged);
connect(ui->comboMode, qOverload<int>(&QComboBox::activated),
this, &TaskPolarPatternParameters::onModeChanged);
connect(ui->checkReverse, &QCheckBox::toggled,
this, &TaskPolarPatternParameters::onCheckReverse);
connect(ui->polarAngle, qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this, &TaskPolarPatternParameters::onAngle);
connect(ui->angleOffset, qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this, &TaskPolarPatternParameters::onOffset);
connect(ui->spinOccurrences, &Gui::UIntSpinBox::unsignedChanged,
this, &TaskPolarPatternParameters::onOccurrences);
connect(ui->checkBoxUpdateView, &QCheckBox::toggled,
this, &TaskPolarPatternParameters::onUpdateView);
}
void TaskPolarPatternParameters::setupUI()
{
// Get the feature data
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
std::vector<App::DocumentObject*> originals = pcPolarPattern->Originals.getValues();
// Fill data into dialog elements
for (auto obj : originals) {
if (obj) {
QListWidgetItem* item = new QListWidgetItem();
item->setText(QString::fromUtf8(obj->Label.getValue()));
item->setData(Qt::UserRole, QString::fromLatin1(obj->getNameInDocument()));
ui->listWidgetFeatures->addItem(item);
}
}
// ---------------------
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
ui->polarAngle->bind(pcPolarPattern->Angle);
ui->angleOffset->bind(pcPolarPattern->Offset);
@@ -177,56 +98,96 @@ void TaskPolarPatternParameters::setupUI()
this->axesLinks.setCombo(*(ui->comboAxis));
App::DocumentObject* sketch = getSketchObject();
if (sketch && sketch->isDerivedFrom(Part::Part2DObject::getClassTypeId())) {
if (sketch && sketch->isDerivedFrom<Part::Part2DObject>()) {
this->fillAxisCombo(axesLinks, static_cast<Part::Part2DObject*>(sketch));
}
else {
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();
ViewProviderOrigin* vpOrigin;
vpOrigin = static_cast<ViewProviderOrigin*>(Gui::Application::Instance->getViewProvider(origin));
App::Origin* origin = body->getOrigin();
auto vpOrigin = static_cast<ViewProviderOrigin*>(
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());
}
}
adaptVisibilityToMode();
updateUI();
connectSignals();
updateViewTimer = new QTimer(this);
updateViewTimer->setSingleShot(true);
updateViewTimer->setInterval(getUpdateViewTimeout());
connect(updateViewTimer,
&QTimer::timeout,
this,
&TaskPolarPatternParameters::onUpdateViewTimer);
connect(ui->comboAxis,
qOverload<int>(&QComboBox::activated),
this,
&TaskPolarPatternParameters::onAxisChanged);
connect(ui->comboMode,
qOverload<int>(&QComboBox::activated),
this,
&TaskPolarPatternParameters::onModeChanged);
connect(ui->checkReverse,
&QCheckBox::toggled,
this,
&TaskPolarPatternParameters::onCheckReverse);
connect(ui->polarAngle,
qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this,
&TaskPolarPatternParameters::onAngle);
connect(ui->angleOffset,
qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this,
&TaskPolarPatternParameters::onOffset);
connect(ui->spinOccurrences,
&Gui::UIntSpinBox::unsignedChanged,
this,
&TaskPolarPatternParameters::onOccurrences);
}
void TaskPolarPatternParameters::retranslateParameterUI(QWidget* widget)
{
ui->retranslateUi(widget);
}
void TaskPolarPatternParameters::updateUI()
{
if (blockUpdate)
if (blockUpdate) {
return;
}
blockUpdate = true;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
PartDesign::PolarPatternMode mode = static_cast<PartDesign::PolarPatternMode>(pcPolarPattern->Mode.getValue());
auto mode = static_cast<PartDesign::PolarPatternMode>(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);
}
// Note: This block of code would trigger change signal handlers (e.g. onOccurrences())
// and another updateUI() if we didn't check for blockUpdate
ui->checkReverse->setChecked(reverse);
ui->comboMode->setCurrentIndex((long)mode);
ui->comboMode->setCurrentIndex(static_cast<int>(mode));
ui->polarAngle->setValue(angle);
ui->angleOffset->setValue(offset);
ui->spinOccurrences->setValue(occurrences);
@@ -254,39 +215,24 @@ void TaskPolarPatternParameters::adaptVisibilityToMode()
ui->angleOffsetWrapper->setVisible(mode == PartDesign::PolarPatternMode::offset);
}
void TaskPolarPatternParameters::addObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
QString objectName = QString::fromLatin1(obj->getNameInDocument());
QListWidgetItem* item = new QListWidgetItem();
item->setText(label);
item->setData(Qt::UserRole, objectName);
ui->listWidgetFeatures->addItem(item);
}
void TaskPolarPatternParameters::removeObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
removeItemFromListWidget(ui->listWidgetFeatures, label);
}
void TaskPolarPatternParameters::onSelectionChanged(const Gui::SelectionChanges& msg)
{
if (selectionMode!=none && msg.Type == Gui::SelectionChanges::AddSelection) {
if (selectionMode != SelectionMode::None && msg.Type == Gui::SelectionChanges::AddSelection) {
if (originalSelected(msg)) {
exitSelectionMode();
}
else {
std::vector<std::string> axes;
App::DocumentObject* selObj;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
getReferencedSelection(pcPolarPattern, msg, selObj, axes);
if(!selObj)
return;
else if (selectionMode == SelectionMode::Reference) {
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
if (selectionMode == reference || selObj->isDerivedFrom ( App::Line::getClassTypeId () ) ) {
std::vector<std::string> axes;
App::DocumentObject* selObj = nullptr;
getReferencedSelection(pcPolarPattern, msg, selObj, axes);
if (!selObj) {
return;
}
if (selObj->isDerivedFrom<App::Line>() || selObj->isDerivedFrom<Part::Feature>()
|| selObj->isDerivedFrom<PartDesign::Line>()) {
setupTransaction();
pcPolarPattern->Axis.setValue(selObj, axes);
recomputeFeature();
@@ -297,26 +243,24 @@ void TaskPolarPatternParameters::onSelectionChanged(const Gui::SelectionChanges&
}
}
void TaskPolarPatternParameters::clearButtons()
void TaskPolarPatternParameters::onCheckReverse(const bool on)
{
ui->buttonAddFeature->setChecked(false);
ui->buttonRemoveFeature->setChecked(false);
}
void TaskPolarPatternParameters::onCheckReverse(const bool on) {
if (blockUpdate)
if (blockUpdate) {
return;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
}
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
pcPolarPattern->Reversed.setValue(on);
exitSelectionMode();
kickUpdateViewTimer();
}
void TaskPolarPatternParameters::onModeChanged(const int mode) {
if (blockUpdate)
void TaskPolarPatternParameters::onModeChanged(const int mode)
{
if (blockUpdate) {
return;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
}
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
pcPolarPattern->Mode.setValue(mode);
adaptVisibilityToMode();
@@ -325,30 +269,36 @@ void TaskPolarPatternParameters::onModeChanged(const int mode) {
kickUpdateViewTimer();
}
void TaskPolarPatternParameters::onAngle(const double a) {
if (blockUpdate)
void TaskPolarPatternParameters::onAngle(const double angle)
{
if (blockUpdate) {
return;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
pcPolarPattern->Angle.setValue(a);
}
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
pcPolarPattern->Angle.setValue(angle);
exitSelectionMode();
kickUpdateViewTimer();
}
void TaskPolarPatternParameters::onOffset(const double a) {
if (blockUpdate)
void TaskPolarPatternParameters::onOffset(const double offset)
{
if (blockUpdate) {
return;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
pcPolarPattern->Offset.setValue(a);
}
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
pcPolarPattern->Offset.setValue(offset);
exitSelectionMode();
kickUpdateViewTimer();
}
void TaskPolarPatternParameters::onOccurrences(const uint n) {
if (blockUpdate)
void TaskPolarPatternParameters::onOccurrences(const uint n)
{
if (blockUpdate) {
return;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
}
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
pcPolarPattern->Occurrences.setValue(n);
exitSelectionMode();
@@ -357,24 +307,27 @@ void TaskPolarPatternParameters::onOccurrences(const uint n) {
void TaskPolarPatternParameters::onAxisChanged(int /*num*/)
{
if (blockUpdate)
if (blockUpdate) {
return;
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
}
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
try{
try {
if (!axesLinks.getCurrentLink().getValue()) {
// enter reference selection mode
hideObject();
showBase();
selectionMode = reference;
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();
@@ -385,13 +338,13 @@ void TaskPolarPatternParameters::onUpdateView(bool on)
blockUpdate = !on;
if (on) {
// Do the same like in TaskDlgPolarPatternParameters::accept() but without doCommand
PartDesign::PolarPattern* pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
auto pcPolarPattern = static_cast<PartDesign::PolarPattern*>(getObject());
std::vector<std::string> axes;
App::DocumentObject* obj;
App::DocumentObject* obj = nullptr;
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());
@@ -400,25 +353,10 @@ void TaskPolarPatternParameters::onUpdateView(bool on)
}
}
void TaskPolarPatternParameters::onFeatureDeleted()
void TaskPolarPatternParameters::getAxis(App::DocumentObject*& obj,
std::vector<std::string>& sub) const
{
PartDesign::Transformed* pcTransformed = getObject();
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
int currentRow = ui->listWidgetFeatures->currentRow();
if (currentRow < 0) {
Base::Console().Error("PartDesign PolarPattern: No feature selected for removing.\n");
return; //no current row selected
}
originals.erase(originals.begin() + currentRow);
setupTransaction();
pcTransformed->Originals.setValues(originals);
ui->listWidgetFeatures->model()->removeRow(currentRow);
recomputeFeature();
}
void TaskPolarPatternParameters::getAxis(App::DocumentObject*& obj, std::vector<std::string>& sub) const
{
const App::PropertyLinkSub &lnk = axesLinks.getCurrentLink();
const App::PropertyLinkSub& lnk = axesLinks.getCurrentLink();
obj = lnk.getValue();
sub = lnk.getSubValues();
}
@@ -428,6 +366,11 @@ bool TaskPolarPatternParameters::getReverse() const
return ui->checkReverse->isChecked();
}
int TaskPolarPatternParameters::getMode() const
{
return ui->comboMode->currentIndex();
}
double TaskPolarPatternParameters::getAngle() const
{
return ui->polarAngle->value().getValue();
@@ -441,42 +384,34 @@ 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();
ViewProviderOrigin* vpOrigin;
vpOrigin = static_cast<ViewProviderOrigin*>(Gui::Application::Instance->getViewProvider(origin));
vpOrigin->resetTemporaryVisibility ();
PartDesign::Body* body = PartDesign::Body::findBodyOf(getObject());
if (body) {
App::Origin* origin = body->getOrigin();
auto vpOrigin = static_cast<ViewProviderOrigin*>(
Gui::Application::Instance->getViewProvider(origin));
vpOrigin->resetTemporaryVisibility();
}
} catch (const Base::Exception &ex) {
Base::Console().Error ("%s\n", ex.what () );
}
if (proxy)
delete proxy;
}
void TaskPolarPatternParameters::changeEvent(QEvent *e)
{
TaskBox::changeEvent(e);
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(proxy);
catch (const Base::Exception& ex) {
Base::Console().Error("%s\n", ex.what());
}
}
void TaskPolarPatternParameters::apply()
{
auto tobj = TransformedView->getObject();
std::vector<std::string> axes;
App::DocumentObject* obj;
App::DocumentObject* obj = nullptr;
getAxis(obj, axes);
std::string axis = buildLinkSingleSubPythonStr(obj, axes);
FCMD_OBJ_CMD(tobj,"Axis = " << axis.c_str());
FCMD_OBJ_CMD(tobj,"Reversed = " << getReverse());
auto tobj = getObject();
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();
}
@@ -485,7 +420,8 @@ void TaskPolarPatternParameters::apply()
// TaskDialog
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskDlgPolarPatternParameters::TaskDlgPolarPatternParameters(ViewProviderPolarPattern *PolarPatternView)
TaskDlgPolarPatternParameters::TaskDlgPolarPatternParameters(
ViewProviderPolarPattern* PolarPatternView)
: TaskDlgTransformedParameters(PolarPatternView)
{
parameter = new TaskPolarPatternParameters(PolarPatternView);

68
src/Mod/PartDesign/Gui/TaskPolarPatternParameters.h
View File

@@ -30,80 +30,82 @@
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, QLayout *layout);
TaskPolarPatternParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget);
~TaskPolarPatternParameters() override;
void apply() override;
protected:
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
private Q_SLOTS:
void onUpdateViewTimer();
void onAxisChanged(int num);
void onModeChanged(const int mode);
void onCheckReverse(const bool on);
void onAngle(const double a);
void onOffset(const double a);
void onOccurrences(const uint n);
void onUpdateView(bool) override;
void onFeatureDeleted() override;
protected:
void addObject(App::DocumentObject*) override;
void removeObject(App::DocumentObject*) override;
void changeEvent(QEvent *e) override;
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
void clearButtons() override;
void getAxis(App::DocumentObject*& obj, std::vector<std::string>& sub) const;
const std::string getStdAxis() const;
const std::string getAxis() const;
bool getReverse() const;
double getAngle() const;
unsigned getOccurrences() const;
void onModeChanged(int mode);
void onCheckReverse(bool on);
void onAngle(double angle);
void onOffset(double offset);
void onOccurrences(uint number);
void onUpdateView(bool /*unused*/) override;
private:
void setupParameterUI(QWidget* widget) override;
void retranslateParameterUI(QWidget* widget) override;
void connectSignals();
void setupUI();
void updateUI();
void kickUpdateViewTimer() const;
void adaptVisibilityToMode();
void getAxis(App::DocumentObject*& obj, std::vector<std::string>& sub) const;
const std::string getStdAxis() const;
const std::string getAxis() const;
bool getReverse() const;
int getMode() const;
double getAngle() const;
unsigned getOccurrences() const;
private:
std::unique_ptr<Ui_TaskPolarPatternParameters> ui;
QTimer* updateViewTimer;
QTimer* updateViewTimer = nullptr;
ComboLinks axesLinks;
};
/// simulation dialog for the TaskView
class TaskDlgPolarPatternParameters : public TaskDlgTransformedParameters
class TaskDlgPolarPatternParameters: public TaskDlgTransformedParameters
{
Q_OBJECT
public:
explicit TaskDlgPolarPatternParameters(ViewProviderPolarPattern *PolarPatternView);
~TaskDlgPolarPatternParameters() override = default;
explicit TaskDlgPolarPatternParameters(ViewProviderPolarPattern* PolarPatternView);
};
} //namespace PartDesignGui
} // namespace PartDesignGui
#endif // GUI_TASKVIEW_TASKAPPERANCE_H
#endif // GUI_TASKVIEW_TASKAPPERANCE_H

109
src/Mod/PartDesign/Gui/TaskPolarPatternParameters.ui
View File

@@ -7,47 +7,25 @@
<x>0</x>
<y>0</y>
<width>253</width>
<height>339</height>
<height>206</height>
</rect>
</property>
<property name="windowTitle">
<string notr="true">Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QPushButton" name="buttonAddFeature">
<property name="text">
<string>Add feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonRemoveFeature">
<property name="text">
<string>Remove feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QListWidget" name="listWidgetFeatures">
<property name="toolTip">
<string>List can be reordered by dragging</string>
</property>
<property name="dragDropMode">
<enum>QAbstractItemView::InternalMove</enum>
</property>
</widget>
</item>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
@@ -196,27 +174,6 @@
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<widget class="QPushButton" name="buttonOK">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="checkBoxUpdateView">
<property name="text">
<string>Update view</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<customwidgets>
@@ -233,49 +190,11 @@
</customwidget>
</customwidgets>
<tabstops>
<tabstop>buttonAddFeature</tabstop>
<tabstop>buttonRemoveFeature</tabstop>
<tabstop>listWidgetFeatures</tabstop>
<tabstop>comboAxis</tabstop>
<tabstop>checkReverse</tabstop>
<tabstop>polarAngle</tabstop>
<tabstop>spinOccurrences</tabstop>
<tabstop>buttonOK</tabstop>
<tabstop>checkBoxUpdateView</tabstop>
</tabstops>
<resources/>
<connections>
<connection>
<sender>buttonAddFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonRemoveFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>66</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>186</x>
<y>21</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonRemoveFeature</sender>
<signal>clicked(bool)</signal>
<receiver>buttonAddFeature</receiver>
<slot>setDisabled(bool)</slot>
<hints>
<hint type="sourcelabel">
<x>186</x>
<y>21</y>
</hint>
<hint type="destinationlabel">
<x>66</x>
<y>21</y>
</hint>
</hints>
</connection>
</connections>
<connections/>
</ui>

189
src/Mod/PartDesign/Gui/TaskScaledParameters.cpp
View File

@@ -24,10 +24,10 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QAction>
#endif
#include <App/DocumentObject.h>
#include <App/Document.h>
#include <Base/Console.h>
#include <Gui/Command.h>
#include <Gui/Selection.h>
@@ -44,100 +44,62 @@ 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)
{
// we need a separate container widget to add all controls to
proxy = new QWidget(this);
ui->setupUi(proxy);
QMetaObject::connectSlotsByName(this);
this->groupLayout()->addWidget(proxy);
ui->buttonOK->hide();
ui->checkBoxUpdateView->setEnabled(true);
blockUpdate = false; // Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
setupUI();
}
TaskScaledParameters::TaskScaledParameters(TaskMultiTransformParameters *parentTask, QLayout *layout)
: TaskTransformedParameters(parentTask), ui(new Ui_TaskScaledParameters)
TaskScaledParameters::TaskScaledParameters(TaskMultiTransformParameters* parentTask,
QWidget* parameterWidget)
: TaskTransformedParameters(parentTask)
, ui(new Ui_TaskScaledParameters)
{
proxy = new QWidget(parentTask);
ui->setupUi(proxy);
connect(ui->buttonOK, &QPushButton::pressed,
parentTask, &TaskScaledParameters::onSubTaskButtonOK);
QMetaObject::connectSlotsByName(this);
layout->addWidget(proxy);
ui->buttonOK->setEnabled(true);
ui->buttonAddFeature->hide();
ui->buttonRemoveFeature->hide();
ui->listWidgetFeatures->hide();
ui->checkBoxUpdateView->hide();
blockUpdate = false; // Hack, sometimes it is NOT false although set to false in Transformed::Transformed()!!
setupUI();
setupParameterUI(parameterWidget);
}
void TaskScaledParameters::setupUI()
void TaskScaledParameters::setupParameterUI(QWidget* widget)
{
connect(ui->buttonAddFeature, &QPushButton::toggled, this, &TaskScaledParameters::onButtonAddFeature);
connect(ui->buttonRemoveFeature, &QPushButton::toggled, this, &TaskScaledParameters::onButtonRemoveFeature);
ui->setupUi(widget);
QMetaObject::connectSlotsByName(this);
// Create context menu
QAction* action = new QAction(tr("Remove"), this);
action->setShortcut(QKeySequence::Delete);
#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
// display shortcut behind the context menu entry
action->setShortcutVisibleInContextMenu(true);
#endif
ui->listWidgetFeatures->addAction(action);
connect(action, &QAction::triggered, this, &TaskScaledParameters::onFeatureDeleted);
ui->listWidgetFeatures->setContextMenuPolicy(Qt::ActionsContextMenu);
connect(ui->spinFactor, qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this, &TaskScaledParameters::onFactor);
connect(ui->spinOccurrences, &Gui::UIntSpinBox::unsignedChanged,
this, &TaskScaledParameters::onOccurrences);
connect(ui->checkBoxUpdateView, &QCheckBox::toggled,
this, &TaskScaledParameters::onUpdateView);
connect(ui->spinFactor,
qOverload<double>(&Gui::QuantitySpinBox::valueChanged),
this,
&TaskScaledParameters::onFactor);
connect(ui->spinOccurrences,
&Gui::UIntSpinBox::unsignedChanged,
this,
&TaskScaledParameters::onOccurrences);
// Get the feature data
PartDesign::Scaled* pcScaled = static_cast<PartDesign::Scaled*>(getObject());
std::vector<App::DocumentObject*> originals = pcScaled->Originals.getValues();
// Fill data into dialog elements
for (auto obj : originals) {
if (obj) {
QListWidgetItem* item = new QListWidgetItem();
item->setText(QString::fromUtf8(obj->Label.getValue()));
item->setData(Qt::UserRole, QString::fromLatin1(obj->getNameInDocument()));
ui->listWidgetFeatures->addItem(item);
}
}
// ---------------------
auto pcScaled = static_cast<PartDesign::Scaled*>(getObject());
ui->spinFactor->bind(pcScaled->Factor);
ui->spinOccurrences->setMaximum(INT_MAX);
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();
}
void TaskScaledParameters::retranslateParameterUI(QWidget* widget)
{
ui->retranslateUi(widget);
}
void TaskScaledParameters::updateUI()
{
if (blockUpdate)
if (blockUpdate) {
return;
}
blockUpdate = true;
PartDesign::Scaled* pcScaled = static_cast<PartDesign::Scaled*>(getObject());
auto pcScaled = static_cast<PartDesign::Scaled*>(getObject());
double factor = pcScaled->Factor.getValue();
unsigned occurrences = pcScaled->Occurrences.getValue();
@@ -148,50 +110,23 @@ void TaskScaledParameters::updateUI()
blockUpdate = false;
}
void TaskScaledParameters::onSelectionChanged(const Gui::SelectionChanges& msg)
void TaskScaledParameters::onFactor(const double factor)
{
if (originalSelected(msg)) {
Gui::SelectionObject selObj(msg);
App::DocumentObject* obj = selObj.getObject();
Q_ASSERT(obj);
QString label = QString::fromUtf8(obj->Label.getValue());
QString objectName = QString::fromLatin1(msg.pObjectName);
if (selectionMode == addFeature) {
QListWidgetItem* item = new QListWidgetItem();
item->setText(label);
item->setData(Qt::UserRole, objectName);
ui->listWidgetFeatures->addItem(item);
}
else {
removeItemFromListWidget(ui->listWidgetFeatures, label);
}
exitSelectionMode();
}
}
void TaskScaledParameters::clearButtons()
{
ui->buttonAddFeature->setChecked(false);
ui->buttonRemoveFeature->setChecked(false);
}
void TaskScaledParameters::onFactor(const double f)
{
if (blockUpdate)
if (blockUpdate) {
return;
PartDesign::Scaled* pcScaled = static_cast<PartDesign::Scaled*>(getObject());
pcScaled->Factor.setValue(f);
}
auto pcScaled = static_cast<PartDesign::Scaled*>(getObject());
pcScaled->Factor.setValue(factor);
recomputeFeature();
}
void TaskScaledParameters::onOccurrences(const uint n)
void TaskScaledParameters::onOccurrences(const uint number)
{
if (blockUpdate)
if (blockUpdate) {
return;
PartDesign::Scaled* pcScaled = static_cast<PartDesign::Scaled*>(getObject());
pcScaled->Occurrences.setValue(n);
}
auto pcScaled = static_cast<PartDesign::Scaled*>(getObject());
pcScaled->Occurrences.setValue(number);
recomputeFeature();
}
@@ -200,28 +135,13 @@ void TaskScaledParameters::onUpdateView(bool on)
blockUpdate = !on;
if (on) {
// Do the same like in TaskDlgScaledParameters::accept() but without doCommand
PartDesign::Scaled* pcScaled = static_cast<PartDesign::Scaled*>(getObject());
auto pcScaled = static_cast<PartDesign::Scaled*>(getObject());
pcScaled->Factor.setValue(getFactor());
pcScaled->Occurrences.setValue(getOccurrences());
recomputeFeature();
}
}
void TaskScaledParameters::onFeatureDeleted()
{
PartDesign::Transformed* pcTransformed = getObject();
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
int currentRow = ui->listWidgetFeatures->currentRow();
if (currentRow < 0) {
Base::Console().Error("PartDesign ScaledPattern: No feature selected for removing.\n");
return; //no current row selected
}
originals.erase(originals.begin() + currentRow);
pcTransformed->Originals.setValues(originals);
ui->listWidgetFeatures->model()->removeRow(currentRow);
recomputeFeature();
}
double TaskScaledParameters::getFactor() const
{
return ui->spinFactor->value().getValue();
@@ -232,25 +152,9 @@ unsigned TaskScaledParameters::getOccurrences() const
return ui->spinOccurrences->value();
}
TaskScaledParameters::~TaskScaledParameters()
{
if (proxy)
delete proxy;
}
void TaskScaledParameters::changeEvent(QEvent *e)
{
TaskBox::changeEvent(e);
if (e->type() == QEvent::LanguageChange) {
ui->retranslateUi(proxy);
}
}
void TaskScaledParameters::apply()
{
std::string name = TransformedView->getObject()->getNameInDocument();
Gui::Command::doCommand(Gui::Command::Doc,"App.ActiveDocument.%s.Factor = %f",name.c_str(), getFactor());
FCMD_OBJ_CMD(getObject(), "Factor = " << getFactor());
ui->spinOccurrences->apply();
}
@@ -259,21 +163,12 @@ void TaskScaledParameters::apply()
// TaskDialog
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskDlgScaledParameters::TaskDlgScaledParameters(ViewProviderScaled *ScaledView)
TaskDlgScaledParameters::TaskDlgScaledParameters(ViewProviderScaled* ScaledView)
: TaskDlgTransformedParameters(ScaledView)
{
parameter = new TaskScaledParameters(ScaledView);
Content.push_back(parameter);
}
//==== calls from the TaskView ===============================================================
bool TaskDlgScaledParameters::accept()
{
parameter->apply();
return TaskDlgTransformedParameters::accept();
}
#include "moc_TaskScaledParameters.cpp"

49
src/Mod/PartDesign/Gui/TaskScaledParameters.h
View File

@@ -29,67 +29,62 @@
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, QLayout *layout);
~TaskScaledParameters() override;
TaskScaledParameters(TaskMultiTransformParameters* parentTask, QWidget* parameterWidget);
void apply() override;
private Q_SLOTS:
void onFactor(const double f);
void onOccurrences(const uint n);
void onUpdateView(bool) override;
void onFeatureDeleted() override;
void onFactor(double factor);
void onOccurrences(uint number);
void onUpdateView(bool /*unused*/) override;
protected:
void changeEvent(QEvent *e) override;
void onSelectionChanged(const Gui::SelectionChanges& msg) override;
void clearButtons() override;
double getFactor() const;
unsigned getOccurrences() const;
private:
void setupUI();
void setupParameterUI(QWidget* widget) override;
void retranslateParameterUI(QWidget* widget) override;
void updateUI();
double getFactor() const;
unsigned getOccurrences() const;
private:
std::unique_ptr<Ui_TaskScaledParameters> ui;
};
/// simulation dialog for the TaskView
class TaskDlgScaledParameters : public TaskDlgTransformedParameters
class TaskDlgScaledParameters: public TaskDlgTransformedParameters
{
Q_OBJECT
public:
explicit TaskDlgScaledParameters(ViewProviderScaled *ScaledView);
~TaskDlgScaledParameters() override = default;
public:
/// is called by the framework if the dialog is accepted (Ok)
bool accept() override;
explicit TaskDlgScaledParameters(ViewProviderScaled* ScaledView);
};
} //namespace PartDesignGui
} // namespace PartDesignGui
#endif // GUI_TASKVIEW_TASKAPPERANCE_H
#endif // GUI_TASKVIEW_TASKAPPERANCE_H

86
src/Mod/PartDesign/Gui/TaskScaledParameters.ui
View File

@@ -7,44 +7,25 @@
<x>0</x>
<y>0</y>
<width>253</width>
<height>270</height>
<height>85</height>
</rect>
</property>
<property name="windowTitle">
<string notr="true">Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QPushButton" name="buttonAddFeature">
<property name="text">
<string>Add feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonRemoveFeature">
<property name="text">
<string>Remove feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QListWidget" name="listWidgetFeatures">
<property name="dragDropMode">
<enum>QAbstractItemView::InternalMove</enum>
</property>
</widget>
</item>
<property name="leftMargin">
<number>0</number>
</property>
<property name="topMargin">
<number>0</number>
</property>
<property name="rightMargin">
<number>0</number>
</property>
<property name="bottomMargin">
<number>0</number>
</property>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
@@ -55,7 +36,7 @@
</widget>
</item>
<item>
<widget class="Gui::QuantitySpinBox" name="spinFactor"/>
<widget class="Gui::QuantitySpinBox" name="spinFactor" native="true"/>
</item>
</layout>
</item>
@@ -73,40 +54,6 @@
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QPushButton" name="buttonOK">
<property name="text">
<string>OK</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="checkBoxUpdateView">
<property name="text">
<string>Update view</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<customwidgets>
@@ -123,13 +70,8 @@
</customwidget>
</customwidgets>
<tabstops>
<tabstop>buttonAddFeature</tabstop>
<tabstop>buttonRemoveFeature</tabstop>
<tabstop>listWidgetFeatures</tabstop>
<tabstop>spinFactor</tabstop>
<tabstop>spinOccurrences</tabstop>
<tabstop>buttonOK</tabstop>
<tabstop>checkBoxUpdateView</tabstop>
</tabstops>
<resources/>
<connections/>

437
src/Mod/PartDesign/Gui/TaskTransformedParameters.cpp
View File

@@ -23,7 +23,8 @@
#include "PreCompiled.h"
#ifndef _PreComp_
# include <QListWidget>
#include <QAction>
#include <QListWidget>
#endif
#include <App/Application.h>
@@ -40,26 +41,27 @@
#include <Mod/PartDesign/App/FeatureAddSub.h>
#include <Mod/PartDesign/App/FeatureTransformed.h>
#include "ui_TaskTransformedParameters.h"
#include "TaskTransformedParameters.h"
#include "TaskMultiTransformParameters.h"
#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)
, proxy(nullptr)
TransformedView->menuName,
true,
parent)
, TransformedView(TransformedView)
, parentTask(nullptr)
, insideMultiTransform(false)
, blockUpdate(false)
, ui(new Ui_TaskTransformedParameters)
{
Gui::Document* doc = TransformedView->getDocument();
this->attachDocument(doc);
@@ -68,31 +70,104 @@ TaskTransformedParameters::TaskTransformedParameters(ViewProviderTransformed *Tr
App::GetApplication().getActiveTransaction(&transactionID);
}
TaskTransformedParameters::TaskTransformedParameters(TaskMultiTransformParameters *parentTask)
: TaskBox(QPixmap(), tr(""), true, parentTask),
proxy(nullptr),
TransformedView(nullptr),
parentTask(parentTask),
insideMultiTransform(true),
blockUpdate(false)
{
}
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();
delete proxy;
}
void TaskTransformedParameters::setupUI()
{
// we need a separate container widget to add all controls to
proxy = new QWidget(this);
ui->setupUi(proxy);
QMetaObject::connectSlotsByName(this);
connect(ui->buttonAddFeature,
&QToolButton::toggled,
this,
&TaskTransformedParameters::onButtonAddFeature);
connect(ui->buttonRemoveFeature,
&QToolButton::toggled,
this,
&TaskTransformedParameters::onButtonRemoveFeature);
// Create context menu
auto action = new QAction(tr("Remove"), this);
action->setShortcut(QKeySequence::Delete);
// display shortcut behind the context menu entry
action->setShortcutVisibleInContextMenu(true);
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->checkBoxUpdateView,
&QCheckBox::toggled,
this,
&TaskTransformedParameters::onUpdateView);
// Get the feature data
auto pcTransformed = static_cast<PartDesign::Transformed*>(getObject());
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
// Fill data into dialog elements
for (auto obj : originals) {
if (obj) {
auto item = new QListWidgetItem();
item->setText(QString::fromUtf8(obj->Label.getValue()));
item->setData(Qt::UserRole, QString::fromLatin1(obj->getNameInDocument()));
ui->listWidgetFeatures->addItem(item);
}
}
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;
}
}
bool TaskTransformedParameters::isViewUpdated() const
void TaskTransformedParameters::changeEvent(QEvent* event)
{
return (blockUpdate == false);
TaskBox::changeEvent(event);
if (event->type() == QEvent::LanguageChange && proxy) {
ui->retranslateUi(proxy);
retranslateParameterUI(ui->featureUI);
}
}
void TaskTransformedParameters::onSelectionChanged(const Gui::SelectionChanges& msg)
{
if (originalSelected(msg)) {
exitSelectionMode();
}
}
void TaskTransformedParameters::clearButtons()
{
if (insideMultiTransform) {
parentTask->clearButtons();
}
else {
ui->buttonAddFeature->setChecked(false);
ui->buttonRemoveFeature->setChecked(false);
}
}
int TaskTransformedParameters::getUpdateViewTimeout() const
@@ -100,40 +175,53 @@ int TaskTransformedParameters::getUpdateViewTimeout() const
return 500;
}
void TaskTransformedParameters::addObject(App::DocumentObject*)
void TaskTransformedParameters::addObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
QString objectName = QString::fromLatin1(obj->getNameInDocument());
auto item = new QListWidgetItem();
item->setText(label);
item->setData(Qt::UserRole, objectName);
ui->listWidgetFeatures->addItem(item);
}
void TaskTransformedParameters::removeObject(App::DocumentObject*)
void TaskTransformedParameters::removeObject(App::DocumentObject* obj)
{
QString label = QString::fromUtf8(obj->Label.getValue());
removeItemFromListWidget(ui->listWidgetFeatures, label);
}
bool TaskTransformedParameters::originalSelected(const Gui::SelectionChanges& msg)
{
if (msg.Type == Gui::SelectionChanges::AddSelection && (
(selectionMode == addFeature) || (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);
if (selectedObject->isDerivedFrom(PartDesign::FeatureAddSub::getClassTypeId())) {
App::DocumentObject* selectedObject =
pcTransformed->getDocument()->getObject(msg.pObjectName);
if (selectedObject->isDerivedFrom<PartDesign::FeatureAddSub>()) {
// Do the same like in TaskDlgTransformedParameters::accept() but without doCommand
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
std::vector<App::DocumentObject*>::iterator o = std::find(originals.begin(), originals.end(), selectedObject);
if (selectionMode == addFeature) {
if (o == originals.end()) {
auto or_iter = std::find(originals.begin(), originals.end(), selectedObject);
if (selectionMode == SelectionMode::AddFeature) {
if (or_iter == originals.end()) {
originals.push_back(selectedObject);
addObject(selectedObject);
}
else {
return false; // duplicate selection
return false; // duplicate selection
}
} else {
if (o != originals.end()) {
originals.erase(o);
}
else {
if (or_iter != originals.end()) {
originals.erase(or_iter);
removeObject(selectedObject);
}
else {
@@ -153,22 +241,25 @@ 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 != 0 && tid == transactionID) {
return;
}
// open a transaction if none is active
std::string n("Edit ");
n += obj->Label.getValue();
transactionID = App::GetApplication().setActiveTransaction(n.c_str());
std::string name("Edit ");
name += obj->Label.getValue();
transactionID = App::GetApplication().setActiveTransaction(name.c_str());
}
void TaskTransformedParameters::setEnabledTransaction(bool on)
@@ -186,27 +277,33 @@ void TaskTransformedParameters::onButtonAddFeature(bool checked)
if (checked) {
hideObject();
showBase();
selectionMode = addFeature;
selectionMode = SelectionMode::AddFeature;
Gui::Selection().clearSelection();
} else {
}
else {
exitSelectionMode();
}
ui->buttonRemoveFeature->setDisabled(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 obj : body->Group.getValues()) {
if (!obj->Visibility.getValue() || !obj->isDerivedFrom<PartDesign::Feature>()) {
continue;
if(inset.count(o))
}
if (inset.count(obj) > 0) {
break;
}
return;
}
FCMD_OBJ_SHOW(getBaseObject());
@@ -216,147 +313,169 @@ void TaskTransformedParameters::onButtonRemoveFeature(bool checked)
{
if (checked) {
checkVisibility();
selectionMode = removeFeature;
selectionMode = SelectionMode::RemoveFeature;
Gui::Selection().clearSelection();
} else {
}
else {
exitSelectionMode();
}
ui->buttonAddFeature->setDisabled(checked);
}
void TaskTransformedParameters::removeItemFromListWidget(QListWidget* widget, const QString& itemstr)
void TaskTransformedParameters::onFeatureDeleted()
{
PartDesign::Transformed* pcTransformed = getObject();
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
int currentRow = ui->listWidgetFeatures->currentRow();
if (currentRow < 0) {
Base::Console().Error("PartDesign Pattern: No feature selected for removing.\n");
return; // no current row selected
}
originals.erase(originals.begin() + currentRow);
setupTransaction();
pcTransformed->Originals.setValues(originals);
ui->listWidgetFeatures->model()->removeRow(currentRow);
recomputeFeature();
}
void TaskTransformedParameters::removeItemFromListWidget(QListWidget* widget,
const QString& itemstr)
{
QList<QListWidgetItem*> items = widget->findItems(itemstr, Qt::MatchExactly);
if (!items.empty()) {
for (auto item : items) {
QListWidgetItem* it = widget->takeItem(widget->row(item));
delete it;
delete widget->takeItem(widget->row(item));
}
}
}
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;
if (insideMultiTransform) {
rv = parentTask->TransformedView;
} else {
rv = TransformedView;
}
return rv;
PartDesignGui::ViewProviderTransformed* TaskTransformedParameters::getTopTransformedView() const
{
return insideMultiTransform ? parentTask->TransformedView : TransformedView;
}
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>());
return static_cast<PartDesign::Transformed*>(transform);
}
PartDesign::Transformed *TaskTransformedParameters::getObject() const {
if (insideMultiTransform)
PartDesign::Transformed* TaskTransformedParameters::getObject() const
{
if (insideMultiTransform) {
return parentTask->getSubFeature();
else if (TransformedView)
}
if (TransformedView) {
return static_cast<PartDesign::Transformed*>(TransformedView->getObject());
else
return nullptr;
}
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;
}
@@ -405,26 +524,30 @@ void TaskTransformedParameters::exitSelectionMode()
{
try {
clearButtons();
selectionMode = none;
selectionMode = SelectionMode::None;
Gui::Selection().rmvSelectionGate();
showObject();
} catch(Base::Exception &e) {
e.ReportException();
}
catch (Base::Exception& exc) {
exc.ReportException();
}
}
void TaskTransformedParameters::addReferenceSelectionGate(AllowSelectionFlags allow)
{
std::unique_ptr<Gui::SelectionFilterGate> gateRefPtr(new ReferenceSelection(getBaseObject(), allow));
std::unique_ptr<Gui::SelectionFilterGate> gateDepPtr(new NoDependentsSelection(getTopTransformedObject()));
std::unique_ptr<Gui::SelectionFilterGate> gateRefPtr(
new ReferenceSelection(getBaseObject(), allow));
std::unique_ptr<Gui::SelectionFilterGate> gateDepPtr(
new NoDependentsSelection(getTopTransformedObject()));
Gui::Selection().addSelectionGate(new CombineSelectionFilterGates(gateRefPtr, gateDepPtr));
}
void TaskTransformedParameters::indexesMoved()
{
QAbstractItemModel* model = qobject_cast<QAbstractItemModel*>(sender());
if (!model)
auto model = qobject_cast<QAbstractItemModel*>(sender());
if (!model) {
return;
}
PartDesign::Transformed* pcTransformed = getObject();
std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues();
@@ -447,8 +570,9 @@ void TaskTransformedParameters::indexesMoved()
// TaskDialog
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TaskDlgTransformedParameters::TaskDlgTransformedParameters(ViewProviderTransformed *TransformedView_)
: TaskDlgFeatureParameters(TransformedView_), parameter(nullptr)
TaskDlgTransformedParameters::TaskDlgTransformedParameters(
ViewProviderTransformed* TransformedView_)
: TaskDlgFeatureParameters(TransformedView_)
{
assert(vp);
message = new TaskTransformedMessages(getTransformedView());
@@ -461,84 +585,93 @@ TaskDlgTransformedParameters::TaskDlgTransformedParameters(ViewProviderTransform
bool TaskDlgTransformedParameters::accept()
{
parameter->exitSelectionMode();
parameter->apply();
// Continue (usually in virtual method accept())
return TaskDlgFeatureParameters::accept ();
return TaskDlgFeatureParameters::accept();
}
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)
: doc(nullptr)
ComboLinks::ComboLinks(QComboBox& combo)
: _combo(&combo)
{
this->_combo = &combo;
_combo->clear();
}
int ComboLinks::addLink(const App::PropertyLinkSub &lnk, QString itemText)
int ComboLinks::addLink(const App::PropertyLinkSub& lnk, QString const& 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 const& linkSubname,
QString const& 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<std::string>(1,linkSubname));
if (newitem.getValue() && !this->doc)
App::PropertyLinkSub& newitem = *(linksInList[linksInList.size() - 1]);
newitem.setValue(linkObj, std::vector<std::string>(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<int>(linksInList.size())-1)
if (index < 0 || index > static_cast<int>(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);

252
src/Mod/PartDesign/Gui/TaskTransformedParameters.h
View File

@@ -38,15 +38,20 @@
class QListWidget;
namespace Part {
class Ui_TaskTransformedParameters;
namespace Part
{
class Feature;
}
namespace PartDesign {
namespace PartDesign
{
class Transformed;
}
namespace PartDesignGui {
namespace PartDesignGui
{
class TaskMultiTransformParameters;
@@ -64,9 +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);
ComboLinks() {_combo = nullptr; doc = nullptr;}
void setCombo(QComboBox &combo) {assert(!_combo); this->_combo = &combo; _combo->clear();}
explicit ComboLinks(QComboBox& combo);
ComboLinks() = default;
void setCombo(QComboBox& combo)
{
assert(!_combo);
this->_combo = &combo;
_combo->clear();
}
/**
* @brief addLink adds an item to the combo. Doesn't check for duplicates.
@@ -74,8 +85,8 @@ public:
* @param itemText
* @return
*/
int addLink(const App::PropertyLinkSub &lnk, QString itemText);
int addLink(App::DocumentObject* linkObj, std::string linkSubname, QString itemText);
int addLink(const App::PropertyLinkSub& lnk, QString const& itemText);
int addLink(App::DocumentObject* linkObj, std::string const& linkSubname, QString const& itemText);
void clear();
App::PropertyLinkSub& getLink(int index) const;
@@ -96,14 +107,23 @@ 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;
App::Document* doc;
QComboBox* _combo = nullptr;
App::Document* doc = nullptr;
std::vector<App::PropertyLinkSub*> linksInList;
};
@@ -115,33 +135,22 @@ 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;
/// Returns the originals property of associated top feeature object
const std::vector<App::DocumentObject*> & getOriginals() const;
/// Get the TransformedFeature object associated with this task
// Either through the ViewProvider or the currently active subFeature of the parentTask
App::DocumentObject *getBaseObject() const;
/// 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;
void exitSelectionMode();
/// Apply changes for python console
virtual void apply() = 0;
virtual void onUpdateView(bool) = 0;
/*!
* \brief setEnabledTransaction
@@ -149,114 +158,157 @@ public:
* instance that does it already, e.g. TaskDlgMultiTransformParameters.
* By default, transactions are enabled.
*/
void setEnabledTransaction(bool);
void setEnabledTransaction(bool /*unused*/);
/// Exit the selection mode of the associated task panel
void exitSelectionMode();
protected:
/** Setup the standalone UI.
* Call this in the derived destructor with ViewProvider.
*/
void setupUI();
/**
* Returns the base transformation
* 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;
/// 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.
*/
bool originalSelected(const Gui::SelectionChanges& msg);
/// Recompute either this feature or the parent MultiTransform feature
void recomputeFeature();
/// Hide the top transformed object (see getTopTransformedObject())
void hideObject();
/// Show the top transformed object (see getTopTransformedObject())
void showObject();
/// Hide the base transformation object (see getObject())
void hideBase();
/// Show the base transformation object (see getObject())
void showBase();
void addReferenceSelectionGate(AllowSelectionFlags);
int getUpdateViewTimeout() const;
/** Notifies when the object is about to be removed. */
void slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj) override;
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);
/// Fill combobox with the planes from the sketch and the own bodys origin planes
void fillPlanesCombo(ComboLinks& combolinks, Part::Part2DObject* sketch);
bool isEnabledTransaction() const;
void setupTransaction();
int getTransactionID() const {
return transactionID;
}
private Q_SLOTS:
virtual void onUpdateView(bool /*unused*/) = 0;
void onButtonAddFeature(bool checked);
void onButtonRemoveFeature(bool checked);
void onFeatureDeleted();
void indexesMoved();
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.
*/
virtual void setupParameterUI(QWidget* widget) = 0;
/// Change translation of the parameter UI
virtual void retranslateParameterUI(QWidget* widget) = 0;
void addObject(App::DocumentObject*);
void removeObject(App::DocumentObject*);
void clearButtons();
void checkVisibility();
/// 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;
protected:
/**
* 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;
protected Q_SLOTS:
/// Connect the subTask OK button to the MultiTransform task
virtual void onSubTaskButtonOK() {}
void onButtonAddFeature(const bool checked);
void onButtonRemoveFeature(const bool checked);
virtual void onFeatureDeleted() = 0;
void indexesMoved();
void changeEvent(QEvent* event) override;
protected:
/**
* Returns the base transformation
* For stand alone features it will be objects associated with the view provider
* For features inside multitransform it will be the parent's multitransform object
*/
PartDesign::Transformed *getObject () const;
bool originalSelected(const Gui::SelectionChanges& msg);
/// Recompute either this feature or the parent feature (MultiTransform mode)
void recomputeFeature();
void hideObject();
void showObject();
void hideBase();
void showBase();
void addReferenceSelectionGate(AllowSelectionFlags);
bool isViewUpdated() const;
int getUpdateViewTimeout() const;
void checkVisibility();
protected:
virtual void addObject(App::DocumentObject*);
virtual void removeObject(App::DocumentObject*);
/** Notifies when the object is about to be removed. */
void slotDeletedObject(const Gui::ViewProviderDocumentObject& Obj) override;
void changeEvent(QEvent *e) override = 0;
void onSelectionChanged(const Gui::SelectionChanges& msg) override = 0;
virtual void clearButtons()=0;
static void removeItemFromListWidget(QListWidget* widget, const QString& itemstr);
void fillAxisCombo(ComboLinks &combolinks, Part::Part2DObject *sketch);
void fillPlanesCombo(ComboLinks &combolinks, Part::Part2DObject *sketch);
protected:
QWidget* proxy;
ViewProviderTransformed *TransformedView;
enum class SelectionMode
{
None,
AddFeature,
RemoveFeature,
Reference
};
ViewProviderTransformed* TransformedView = nullptr;
SelectionMode selectionMode = SelectionMode::None;
/// Lock updateUI(), applying changes to the underlying feature and calling recomputeFeature()
bool blockUpdate = false;
private:
int transactionID = 0;
bool enableTransaction = true;
enum selectionModes { none, addFeature, removeFeature, reference };
selectionModes selectionMode = none;
/// The MultiTransform parent task of this task
TaskMultiTransformParameters* parentTask;
TaskMultiTransformParameters* parentTask = nullptr;
/// Flag indicating whether this object is a container for MultiTransform
bool insideMultiTransform;
/// Lock updateUI(), applying changes to the underlying feature and calling recomputeFeature()
bool blockUpdate;
bool insideMultiTransform = false;
/// Widget holding the transform task UI
QWidget* proxy = nullptr;
std::unique_ptr<Ui_TaskTransformedParameters> ui;
};
/// simulation dialog for the TaskView
class TaskDlgTransformedParameters : public PartDesignGui::TaskDlgFeatureParameters
class TaskDlgTransformedParameters: public PartDesignGui::TaskDlgFeatureParameters
{
Q_OBJECT
public:
explicit TaskDlgTransformedParameters(ViewProviderTransformed *TransformedView);
~TaskDlgTransformedParameters() override = default;
explicit TaskDlgTransformedParameters(ViewProviderTransformed* TransformedView);
ViewProviderTransformed* getTransformedView() const
{ return static_cast<ViewProviderTransformed*>(vp); }
{
return static_cast<ViewProviderTransformed*>(vp);
}
public:
/// is called by the framework if the dialog is accepted (Ok)
bool accept() override;
/// is called by the framework if the dialog is rejected (Cancel)
bool reject() override;
protected:
TaskTransformedParameters *parameter;
TaskTransformedMessages *message;
TaskTransformedParameters* parameter = nullptr;
TaskTransformedMessages* message = nullptr;
};
} //namespace PartDesignGui
} // namespace PartDesignGui
#endif // GUI_TASKVIEW_TASKAPPERANCE_H
#endif // GUI_TASKVIEW_TASKAPPERANCE_H

80
src/Mod/PartDesign/Gui/TaskTransformedParameters.ui Normal file
View File

@@ -0,0 +1,80 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>PartDesignGui::TaskTransformedParameters</class>
<widget class="QWidget" name="PartDesignGui::TaskTransformedParameters">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>262</width>
<height>207</height>
</rect>
</property>
<property name="windowTitle">
<string notr="true">Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QPushButton" name="buttonAddFeature">
<property name="text">
<string>Add feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonRemoveFeature">
<property name="text">
<string>Remove feature</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QListWidget" name="listWidgetFeatures">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>120</height>
</size>
</property>
<property name="toolTip">
<string>List can be reordered by dragging</string>
</property>
<property name="dragDropMode">
<enum>QAbstractItemView::InternalMove</enum>
</property>
</widget>
</item>
<item>
<widget class="QWidget" name="featureUI" native="true"/>
</item>
<item>
<widget class="QCheckBox" name="checkBoxUpdateView">
<property name="text">
<string>Update view</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<tabstops>
<tabstop>buttonAddFeature</tabstop>
<tabstop>buttonRemoveFeature</tabstop>
<tabstop>listWidgetFeatures</tabstop>
<tabstop>checkBoxUpdateView</tabstop>
</tabstops>
<resources/>
<connections/>
</ui>