diff --git a/src/App/Link.cpp b/src/App/Link.cpp index 8f4eb62303..64dcdf19b0 100644 --- a/src/App/Link.cpp +++ b/src/App/Link.cpp @@ -905,7 +905,6 @@ void LinkBaseExtension::monitorOnChangeCopyObjects( if (getLinkCopyOnChangeValue() == CopyOnChangeDisabled) return; for(auto obj : objs) { - obj->setStatus(App::ObjectStatus::TouchOnColorChange, true); copyOnChangeSrcConns.push_back(obj->signalChanged.connect( [this](const DocumentObject &, const Property &) { if (auto prop = this->getLinkCopyOnChangeTouchedProperty()) { diff --git a/src/Gui/TaskElementColors.cpp b/src/Gui/TaskElementColors.cpp index 40a9007556..e36b6c03fe 100644 --- a/src/Gui/TaskElementColors.cpp +++ b/src/Gui/TaskElementColors.cpp @@ -40,10 +40,9 @@ #include "Document.h" #include "FileDialog.h" #include "Selection.h" -#include "SelectionObject.h" +#include "ViewParams.h" #include "ViewProviderLink.h" - FC_LOG_LEVEL_INIT("Gui", true, true) using namespace Gui; @@ -59,7 +58,6 @@ public: Document *vpDoc; std::map elements; std::vector items; - std::string hiddenSub; Connection connectDelDoc; Connection connectDelObj; QPixmap px; @@ -196,31 +194,108 @@ public: } void accept() { - if(touched && ui->recompute->isChecked()) { - auto obj = vp->getObject(); - obj->touch(); - obj->getDocument()->recompute(obj->getInListRecursive()); + if(touched) { touched = false; + if(ui->recompute->isChecked()) { + auto obj = vp->getObject(); + auto objs = obj->getInListRecursive(); + objs.push_back(obj); + for (auto o : objs) + o->enforceRecompute(); + obj->getDocument()->recompute(objs); + } else { + for (auto obj : App::Document::getDependencyList( + {vp->getObject()}, App::Document::DepSort)) + { + auto vp = Application::Instance->getViewProvider(obj); + if (vp) + vp->updateColors(); + } + } } App::GetApplication().closeActiveTransaction(); } void removeAll() { - if(elements.size()) { - hiddenSub.clear(); - ui->elementList->clear(); - elements.clear(); - apply(); + if(elements.empty()) + return; + + auto itFace = elements.find("Face"); + auto itEdge = elements.find("Edge"); + auto itVertex = elements.find("Vertex"); + bool revert = false; + for (auto & v : elements) { + if (itFace != elements.end() && v.first != "Face" && boost::starts_with(v.first, "Face")) { + revert = true; + v.second->setData(Qt::UserRole, itFace->second->data(Qt::UserRole)); + } + if (itEdge != elements.end() && v.first != "Edge" && boost::starts_with(v.first, "Edge")) { + revert = true; + v.second->setData(Qt::UserRole, itEdge->second->data(Qt::UserRole)); + } + if (itVertex != elements.end() && v.first != "Vertex" && boost::starts_with(v.first, "Vertex")) { + revert = true; + v.second->setData(Qt::UserRole, itVertex->second->data(Qt::UserRole)); + } } + if (revert) + apply(); + ui->elementList->clear(); + elements.clear(); + apply(); } void removeItems() { + std::vector faces; + std::vector edges; + std::vector vertexes; + std::vector subs; for(auto item : ui->elementList->selectedItems()) { - std::string sub = qPrintable(item->data(Qt::UserRole+1).value()); - if(sub == hiddenSub) - hiddenSub.clear(); - elements.erase(sub); - delete item; + subs.push_back(qPrintable(item->data(Qt::UserRole+1).value())); + if (subs.back() != "Face" && boost::starts_with(subs.back(), "Face")) + faces.push_back(item); + else if (subs.back() != "Edge" && boost::starts_with(subs.back(), "Edge")) + edges.push_back(item); + else if (subs.back() != "Vertex" && boost::starts_with(subs.back(), "Vertex")) + vertexes.push_back(item); + } + + // In order to better support backward compatibility, Part view provider + // still allow user to set color through DiffuseColor. So when doing + // color mapping, it will not touch any element color that are not + // explicitly set through ColoredElements property. Therefore, when the + // user removes colored elements here, we must explicitly revert only + // those element too. Same for the removeAll() above. + if (faces.size()) { + auto it = elements.find("Face"); + if (it != elements.end()) { + for (auto item : faces) + item->setData(Qt::UserRole, it->second->data(Qt::UserRole)); + } + } + if (edges.size()) { + auto it = elements.find("Edge"); + if (it != elements.end()) { + for (auto item : edges) + item->setData(Qt::UserRole, it->second->data(Qt::UserRole)); + } + } + if (vertexes.size()) { + auto it = elements.find("Vertex"); + if (it != elements.end()) { + for (auto item : vertexes) + item->setData(Qt::UserRole, it->second->data(Qt::UserRole)); + } + } + apply(); + + // now remove the items + for (auto & sub : subs) { + auto it = elements.find(sub); + if (it != elements.end()) { + delete it->second; + elements.erase(it); + } } apply(); } @@ -287,8 +362,6 @@ public: } for(auto item : ui->elementList->selectedItems()) { std::string name(qPrintable(item->data(Qt::UserRole+1).value())); - if(ViewProvider::hasHiddenMarker(name.c_str())) - continue; auto &v = sels[name]; if(!v) Selection().addSelection(editDoc.c_str(), @@ -317,12 +390,8 @@ ElementColors::ElementColors(ViewProviderDocumentObject* vp, bool noHide) if(noHide) d->ui->hideSelection->setVisible(false); - ParameterGrp::handle hPart = App::GetApplication().GetParameterGroupByPath - ("User parameter:BaseApp/Preferences/View"); - d->ui->recompute->setChecked(hPart->GetBool("ColorRecompute",true)); - d->ui->onTop->setChecked(hPart->GetBool("ColorOnTop",true)); - if(d->ui->onTop->isChecked()) - d->vpParent->OnTopWhenSelected.setValue(3); + d->ui->recompute->setChecked(ViewParams::instance()->getColorRecompute()); + d->ui->onTop->setChecked(ViewParams::instance()->getColorOnTop()); Selection().addSelectionGate(d, ResolveMode::NoResolve); @@ -342,15 +411,11 @@ ElementColors::~ElementColors() } void ElementColors::on_recompute_clicked(bool checked) { - ParameterGrp::handle hPart = App::GetApplication().GetParameterGroupByPath - ("User parameter:BaseApp/Preferences/View"); - hPart->SetBool("ColorRecompute",checked); + ViewParams::instance()->setColorRecompute(checked); } void ElementColors::on_onTop_clicked(bool checked) { - ParameterGrp::handle hPart = App::GetApplication().GetParameterGroupByPath - ("User parameter:BaseApp/Preferences/View"); - hPart->SetBool("ColorOnTop",checked); + ViewParams::instance()->setColorOnTop(checked); d->vpParent->OnTopWhenSelected.setValue(checked?3:d->onTopMode); } @@ -414,8 +479,12 @@ void ElementColors::on_addSelection_clicked() break; } for(auto &sub : subs) { - if(boost::starts_with(sub,d->editSub)) - d->addItem(-1,sub.c_str()+d->editSub.size(),true); + if(!boost::starts_with(sub,d->editSub)) + continue; + std::string s(sub.c_str()+d->editSub.size()); + if(s.empty() || s.back() == '.') + s += "Face"; + d->addItem(-1,s.c_str(),true); } break; } @@ -468,23 +537,13 @@ void ElementColors::changeEvent(QEvent *e) void ElementColors::leaveEvent(QEvent *e) { QWidget::leaveEvent(e); Selection().rmvPreselect(); - if(d->hiddenSub.size()) { - d->vp->partialRender({d->hiddenSub},false); - d->hiddenSub.clear(); - } } void ElementColors::on_elementList_itemEntered(QListWidgetItem *item) { std::string name(qPrintable(item->data(Qt::UserRole+1).value())); - if(d->hiddenSub.size()) { - d->vp->partialRender({d->hiddenSub},false); - d->hiddenSub.clear(); - } - if(ViewProvider::hasHiddenMarker(name.c_str())) { - d->hiddenSub = name; - d->vp->partialRender({name},true); - name.resize(name.size()-ViewProvider::hiddenMarker().size()); - } + const char *hidden = ViewProvider::hasHiddenMarker(name.c_str()); + if(hidden) + name.resize(name.size()-std::strlen(hidden)); Selection().setPreselect(d->editDoc.c_str(), d->editObj.c_str(), (d->editSub+name).c_str(),0,0,0, d->ui->onTop->isChecked() ? Gui::SelectionChanges::MsgSource::TreeView diff --git a/src/Gui/ViewParams.h b/src/Gui/ViewParams.h index ff55628400..020403ea71 100644 --- a/src/Gui/ViewParams.h +++ b/src/Gui/ViewParams.h @@ -62,6 +62,8 @@ public: FC_VIEW_PARAM(EnablePropertyViewForInactiveDocument,bool,Bool,true) \ FC_VIEW_PARAM(ShowSelectionBoundingBox,bool,Bool,false) \ FC_VIEW_PARAM(PropertyViewTimer, unsigned long, Unsigned, 100) \ + FC_VIEW_PARAM(ColorOnTop, bool, Bool, true) \ + FC_VIEW_PARAM(ColorRecompute, bool, Bool, true) \ #undef FC_VIEW_PARAM #define FC_VIEW_PARAM(_name,_ctype,_type,_def) \ diff --git a/src/Gui/ViewProvider.h b/src/Gui/ViewProvider.h index ed7682e52e..fa66ce145d 100644 --- a/src/Gui/ViewProvider.h +++ b/src/Gui/ViewProvider.h @@ -411,6 +411,10 @@ public: virtual void setElementColors(const std::map &colors) { (void)colors; } + virtual void updateColors(App::Document *sourceDoc=0, bool forceColorMap=false) { + (void)sourceDoc; + (void)forceColorMap; + } static const std::string &hiddenMarker(); static const char *hasHiddenMarker(const char *subname); //@} diff --git a/src/Gui/ViewProviderDocumentObject.h b/src/Gui/ViewProviderDocumentObject.h index 1bc3e7ad22..fe942da333 100644 --- a/src/Gui/ViewProviderDocumentObject.h +++ b/src/Gui/ViewProviderDocumentObject.h @@ -160,6 +160,8 @@ public: /** Start the edit mode with ViewProvider::Default */ void startDefaultEditMode(); + virtual void checkColorUpdate() {} + protected: /*! Get the active mdi view of the document this view provider is part of. @note The returned mdi view doesn't need to be a 3d view but can be e.g. diff --git a/src/Gui/ViewProviderGeometryObject.cpp b/src/Gui/ViewProviderGeometryObject.cpp index 4e277a43a9..9ebd1c4cfe 100644 --- a/src/Gui/ViewProviderGeometryObject.cpp +++ b/src/Gui/ViewProviderGeometryObject.cpp @@ -114,14 +114,16 @@ ViewProviderGeometryObject::~ViewProviderGeometryObject() void ViewProviderGeometryObject::onChanged(const App::Property* prop) { - // Actually, the properties 'ShapeColor' and 'Transparency' are part of the property 'ShapeMaterial'. - // Both redundant properties are kept due to more convenience for the user. But we must keep the values - // consistent of all these properties. + Gui::ColorUpdater colorUpdater; + if (prop == &Selectable) { bool Sel = Selectable.getValue(); setSelectable(Sel); } else if (prop == &ShapeColor) { + // Actually, the properties 'ShapeColor' and 'Transparency' are part of the property 'ShapeMaterial'. + // Both redundant properties are kept due to more convenience for the user. But we must keep the values + // consistent of all these properties. const App::Color& c = ShapeColor.getValue(); pcShapeMaterial->diffuseColor.setValue(c.r,c.g,c.b); if (c != ShapeMaterial.getValue().diffuseColor) @@ -137,21 +139,20 @@ void ViewProviderGeometryObject::onChanged(const App::Property* prop) } } else if (prop == &ShapeMaterial) { - if (getObject() && getObject()->testStatus(App::ObjectStatus::TouchOnColorChange)) - getObject()->touch(true); const App::Material& Mat = ShapeMaterial.getValue(); long value = (long)(100*Mat.transparency); if (value != Transparency.getValue()) Transparency.setValue(value); const App::Color& color = Mat.diffuseColor; - if (color != ShapeColor.getValue()) - ShapeColor.setValue(Mat.diffuseColor); pcShapeMaterial->ambientColor.setValue(Mat.ambientColor.r,Mat.ambientColor.g,Mat.ambientColor.b); pcShapeMaterial->diffuseColor.setValue(Mat.diffuseColor.r,Mat.diffuseColor.g,Mat.diffuseColor.b); pcShapeMaterial->specularColor.setValue(Mat.specularColor.r,Mat.specularColor.g,Mat.specularColor.b); pcShapeMaterial->emissiveColor.setValue(Mat.emissiveColor.r,Mat.emissiveColor.g,Mat.emissiveColor.b); pcShapeMaterial->shininess.setValue(Mat.shininess); pcShapeMaterial->transparency.setValue(Mat.transparency); + if (color != ShapeColor.getValue()) + ShapeColor.setValue(Mat.diffuseColor); + Gui::ColorUpdater::addObject(getObject()); } else if (prop == &BoundingBox) { showBoundingBox(BoundingBox.getValue()); diff --git a/src/Mod/Part/Gui/CMakeLists.txt b/src/Mod/Part/Gui/CMakeLists.txt index 43d8b3d1ff..bc75913c48 100644 --- a/src/Mod/Part/Gui/CMakeLists.txt +++ b/src/Mod/Part/Gui/CMakeLists.txt @@ -17,6 +17,8 @@ include_directories( ) link_directories(${OCC_LIBRARY_DIR}) +generate_from_xml(ViewProviderPartExtPy) + set(PartGui_LIBS Part FreeCADGui @@ -64,7 +66,7 @@ set(PartGui_UIC_SRCS DlgProjectionOnSurface.ui SectionCutting.ui ShapeFromMesh.ui - TaskFaceColors.ui + # TaskFaceColors.ui TaskShapeBuilder.ui TaskLoft.ui TaskOffset.ui @@ -215,9 +217,9 @@ SET(PartGui_SRCS SectionCutting.ui ShapeFromMesh.cpp ShapeFromMesh.h - TaskFaceColors.cpp - TaskFaceColors.h - TaskFaceColors.ui + # TaskFaceColors.cpp + # TaskFaceColors.h + # TaskFaceColors.ui TaskShapeBuilder.cpp TaskShapeBuilder.h TaskShapeBuilder.ui @@ -238,6 +240,10 @@ SET(PartGui_SRCS TaskCheckGeometry.h TaskAttacher.h TaskAttacher.cpp + ViewProviderPartExtPy.xml + ViewProviderPartExtPyImp.cpp + PartParams.h + PartParams.cpp ) if(FREECAD_USE_PCH) diff --git a/src/Mod/Part/Gui/PartParams.cpp b/src/Mod/Part/Gui/PartParams.cpp new file mode 100644 index 0000000000..ca9436f644 --- /dev/null +++ b/src/Mod/Part/Gui/PartParams.cpp @@ -0,0 +1,1040 @@ +/**************************************************************************** + * Copyright (c) 2022 Zheng Lei (realthunder) * + * * + * This file is part of the FreeCAD CAx development system. * + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License as published by the Free Software Foundation; either * + * version 2 of the License, or (at your option) any later version. * + * * + * This library is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU Library General Public License for more details. * + * * + * You should have received a copy of the GNU Library General Public * + * License along with this library; see the file COPYING.LIB. If not, * + * write to the Free Software Foundation, Inc., 59 Temple Place, * + * Suite 330, Boston, MA 02111-1307, USA * + * * + ****************************************************************************/ + +#include "PreCompiled.h" +#include +#include +#include +#include +#include +#include "ViewProvider.h" + +namespace { +QTimer &getTimer() { + static QTimer *timer; + if (!timer) { + timer = new QTimer(); + timer->setSingleShot(true); + QObject::connect(timer, &QTimer::timeout, [](){ + // search for Part view providers and apply the new settings + for (auto doc : App::GetApplication().getDocuments()) { + auto gdoc = Gui::Application::Instance->getDocument(doc); + for (auto vp : gdoc->getViewProvidersOfType( + PartGui::ViewProviderPart::getClassTypeId())) + static_cast(vp)->reload(); + } + }); + } + return *timer; +} +} // anonymous namespace + +/*[[[cog +import PartGuiParams +PartGuiParams.define() +]]]*/ + +// Auto generated code (Tools/params_utils.py:166) +#include +#include +#include +#include "PartParams.h" +using namespace PartGui; + +// Auto generated code (Tools/params_utils.py:175) +namespace { +class PartParamsP: public ParameterGrp::ObserverType { +public: + ParameterGrp::handle handle; + std::unordered_map funcs; + + bool NormalsFromUVNodes; + bool TwoSideRendering; + double MinimumDeviation; + double MeshDeviation; + double MeshAngularDeflection; + double MinimumAngularDeflection; + bool OverrideTessellation; + bool MapFaceColor; + bool MapLineColor; + bool MapPointColor; + bool MapTransparency; + bool AutoGridScale; + unsigned long PreviewAddColor; + unsigned long PreviewSubColor; + unsigned long PreviewDressColor; + unsigned long PreviewIntersectColor; + bool PreviewOnEdit; + bool PreviewWithTransparency; + bool EditOnTop; + long EditRecomputeWait; + bool AdjustCameraForNewFeature; + unsigned long DefaultDatumColor; + bool RespectSystemDPI; + long SelectionPickThreshold; + long SelectionPickThreshold2; + bool SelectionPickRTree; + + // Auto generated code (Tools/params_utils.py:203) + PartParamsP() { + handle = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Mod/Part"); + handle->Attach(this); + + NormalsFromUVNodes = handle->GetBool("NormalsFromUVNodes", true); + funcs["NormalsFromUVNodes"] = &PartParamsP::updateNormalsFromUVNodes; + TwoSideRendering = handle->GetBool("TwoSideRendering", true); + funcs["TwoSideRendering"] = &PartParamsP::updateTwoSideRendering; + MinimumDeviation = handle->GetFloat("MinimumDeviation", 0.05); + funcs["MinimumDeviation"] = &PartParamsP::updateMinimumDeviation; + MeshDeviation = handle->GetFloat("MeshDeviation", 0.2); + funcs["MeshDeviation"] = &PartParamsP::updateMeshDeviation; + MeshAngularDeflection = handle->GetFloat("MeshAngularDeflection", 28.65); + funcs["MeshAngularDeflection"] = &PartParamsP::updateMeshAngularDeflection; + MinimumAngularDeflection = handle->GetFloat("MinimumAngularDeflection", 5.0); + funcs["MinimumAngularDeflection"] = &PartParamsP::updateMinimumAngularDeflection; + OverrideTessellation = handle->GetBool("OverrideTessellation", false); + funcs["OverrideTessellation"] = &PartParamsP::updateOverrideTessellation; + MapFaceColor = handle->GetBool("MapFaceColor", true); + funcs["MapFaceColor"] = &PartParamsP::updateMapFaceColor; + MapLineColor = handle->GetBool("MapLineColor", false); + funcs["MapLineColor"] = &PartParamsP::updateMapLineColor; + MapPointColor = handle->GetBool("MapPointColor", false); + funcs["MapPointColor"] = &PartParamsP::updateMapPointColor; + MapTransparency = handle->GetBool("MapTransparency", false); + funcs["MapTransparency"] = &PartParamsP::updateMapTransparency; + AutoGridScale = handle->GetBool("AutoGridScale", false); + funcs["AutoGridScale"] = &PartParamsP::updateAutoGridScale; + PreviewAddColor = handle->GetUnsigned("PreviewAddColor", 0x64FFFF30); + funcs["PreviewAddColor"] = &PartParamsP::updatePreviewAddColor; + PreviewSubColor = handle->GetUnsigned("PreviewSubColor", 0xFF646430); + funcs["PreviewSubColor"] = &PartParamsP::updatePreviewSubColor; + PreviewDressColor = handle->GetUnsigned("PreviewDressColor", 0xFF64FF30); + funcs["PreviewDressColor"] = &PartParamsP::updatePreviewDressColor; + PreviewIntersectColor = handle->GetUnsigned("PreviewIntersectColor", 0x6464FF30); + funcs["PreviewIntersectColor"] = &PartParamsP::updatePreviewIntersectColor; + PreviewOnEdit = handle->GetBool("PreviewOnEdit", true); + funcs["PreviewOnEdit"] = &PartParamsP::updatePreviewOnEdit; + PreviewWithTransparency = handle->GetBool("PreviewWithTransparency", true); + funcs["PreviewWithTransparency"] = &PartParamsP::updatePreviewWithTransparency; + EditOnTop = handle->GetBool("EditOnTop", false); + funcs["EditOnTop"] = &PartParamsP::updateEditOnTop; + EditRecomputeWait = handle->GetInt("EditRecomputeWait", 300); + funcs["EditRecomputeWait"] = &PartParamsP::updateEditRecomputeWait; + AdjustCameraForNewFeature = handle->GetBool("AdjustCameraForNewFeature", true); + funcs["AdjustCameraForNewFeature"] = &PartParamsP::updateAdjustCameraForNewFeature; + DefaultDatumColor = handle->GetUnsigned("DefaultDatumColor", 0xFFD70099); + funcs["DefaultDatumColor"] = &PartParamsP::updateDefaultDatumColor; + RespectSystemDPI = handle->GetBool("RespectSystemDPI", false); + funcs["RespectSystemDPI"] = &PartParamsP::updateRespectSystemDPI; + SelectionPickThreshold = handle->GetInt("SelectionPickThreshold", 1000); + funcs["SelectionPickThreshold"] = &PartParamsP::updateSelectionPickThreshold; + SelectionPickThreshold2 = handle->GetInt("SelectionPickThreshold2", 500); + funcs["SelectionPickThreshold2"] = &PartParamsP::updateSelectionPickThreshold2; + SelectionPickRTree = handle->GetBool("SelectionPickRTree", false); + funcs["SelectionPickRTree"] = &PartParamsP::updateSelectionPickRTree; + } + + // Auto generated code (Tools/params_utils.py:217) + ~PartParamsP() { + } + + // Auto generated code (Tools/params_utils.py:222) + void OnChange(Base::Subject &, const char* sReason) { + if(!sReason) + return; + auto it = funcs.find(sReason); + if(it == funcs.end()) + return; + it->second(this); + + } + + + // Auto generated code (Tools/params_utils.py:238) + static void updateNormalsFromUVNodes(PartParamsP *self) { + self->NormalsFromUVNodes = self->handle->GetBool("NormalsFromUVNodes", true); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateTwoSideRendering(PartParamsP *self) { + self->TwoSideRendering = self->handle->GetBool("TwoSideRendering", true); + } + // Auto generated code (Tools/params_utils.py:244) + static void updateMinimumDeviation(PartParamsP *self) { + auto v = self->handle->GetFloat("MinimumDeviation", 0.05); + if (self->MinimumDeviation != v) { + self->MinimumDeviation = v; + PartParams::onMinimumDeviationChanged(); + } + } + // Auto generated code (Tools/params_utils.py:244) + static void updateMeshDeviation(PartParamsP *self) { + auto v = self->handle->GetFloat("MeshDeviation", 0.2); + if (self->MeshDeviation != v) { + self->MeshDeviation = v; + PartParams::onMeshDeviationChanged(); + } + } + // Auto generated code (Tools/params_utils.py:244) + static void updateMeshAngularDeflection(PartParamsP *self) { + auto v = self->handle->GetFloat("MeshAngularDeflection", 28.65); + if (self->MeshAngularDeflection != v) { + self->MeshAngularDeflection = v; + PartParams::onMeshAngularDeflectionChanged(); + } + } + // Auto generated code (Tools/params_utils.py:244) + static void updateMinimumAngularDeflection(PartParamsP *self) { + auto v = self->handle->GetFloat("MinimumAngularDeflection", 5.0); + if (self->MinimumAngularDeflection != v) { + self->MinimumAngularDeflection = v; + PartParams::onMinimumAngularDeflectionChanged(); + } + } + // Auto generated code (Tools/params_utils.py:244) + static void updateOverrideTessellation(PartParamsP *self) { + auto v = self->handle->GetBool("OverrideTessellation", false); + if (self->OverrideTessellation != v) { + self->OverrideTessellation = v; + PartParams::onOverrideTessellationChanged(); + } + } + // Auto generated code (Tools/params_utils.py:238) + static void updateMapFaceColor(PartParamsP *self) { + self->MapFaceColor = self->handle->GetBool("MapFaceColor", true); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateMapLineColor(PartParamsP *self) { + self->MapLineColor = self->handle->GetBool("MapLineColor", false); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateMapPointColor(PartParamsP *self) { + self->MapPointColor = self->handle->GetBool("MapPointColor", false); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateMapTransparency(PartParamsP *self) { + self->MapTransparency = self->handle->GetBool("MapTransparency", false); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateAutoGridScale(PartParamsP *self) { + self->AutoGridScale = self->handle->GetBool("AutoGridScale", false); + } + // Auto generated code (Tools/params_utils.py:238) + static void updatePreviewAddColor(PartParamsP *self) { + self->PreviewAddColor = self->handle->GetUnsigned("PreviewAddColor", 0x64FFFF30); + } + // Auto generated code (Tools/params_utils.py:238) + static void updatePreviewSubColor(PartParamsP *self) { + self->PreviewSubColor = self->handle->GetUnsigned("PreviewSubColor", 0xFF646430); + } + // Auto generated code (Tools/params_utils.py:238) + static void updatePreviewDressColor(PartParamsP *self) { + self->PreviewDressColor = self->handle->GetUnsigned("PreviewDressColor", 0xFF64FF30); + } + // Auto generated code (Tools/params_utils.py:238) + static void updatePreviewIntersectColor(PartParamsP *self) { + self->PreviewIntersectColor = self->handle->GetUnsigned("PreviewIntersectColor", 0x6464FF30); + } + // Auto generated code (Tools/params_utils.py:238) + static void updatePreviewOnEdit(PartParamsP *self) { + self->PreviewOnEdit = self->handle->GetBool("PreviewOnEdit", true); + } + // Auto generated code (Tools/params_utils.py:238) + static void updatePreviewWithTransparency(PartParamsP *self) { + self->PreviewWithTransparency = self->handle->GetBool("PreviewWithTransparency", true); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateEditOnTop(PartParamsP *self) { + self->EditOnTop = self->handle->GetBool("EditOnTop", false); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateEditRecomputeWait(PartParamsP *self) { + self->EditRecomputeWait = self->handle->GetInt("EditRecomputeWait", 300); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateAdjustCameraForNewFeature(PartParamsP *self) { + self->AdjustCameraForNewFeature = self->handle->GetBool("AdjustCameraForNewFeature", true); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateDefaultDatumColor(PartParamsP *self) { + self->DefaultDatumColor = self->handle->GetUnsigned("DefaultDatumColor", 0xFFD70099); + } + // Auto generated code (Tools/params_utils.py:244) + static void updateRespectSystemDPI(PartParamsP *self) { + auto v = self->handle->GetBool("RespectSystemDPI", false); + if (self->RespectSystemDPI != v) { + self->RespectSystemDPI = v; + PartParams::onRespectSystemDPIChanged(); + } + } + // Auto generated code (Tools/params_utils.py:238) + static void updateSelectionPickThreshold(PartParamsP *self) { + self->SelectionPickThreshold = self->handle->GetInt("SelectionPickThreshold", 1000); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateSelectionPickThreshold2(PartParamsP *self) { + self->SelectionPickThreshold2 = self->handle->GetInt("SelectionPickThreshold2", 500); + } + // Auto generated code (Tools/params_utils.py:238) + static void updateSelectionPickRTree(PartParamsP *self) { + self->SelectionPickRTree = self->handle->GetBool("SelectionPickRTree", false); + } +}; + +// Auto generated code (Tools/params_utils.py:256) +PartParamsP *instance() { + static PartParamsP *inst = new PartParamsP; + return inst; +} + +} // Anonymous namespace + +// Auto generated code (Tools/params_utils.py:265) +ParameterGrp::handle PartParams::getHandle() { + return instance()->handle; +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docNormalsFromUVNodes() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getNormalsFromUVNodes() { + return instance()->NormalsFromUVNodes; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultNormalsFromUVNodes() { + const static bool def = true; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setNormalsFromUVNodes(const bool &v) { + instance()->handle->SetBool("NormalsFromUVNodes",v); + instance()->NormalsFromUVNodes = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeNormalsFromUVNodes() { + instance()->handle->RemoveBool("NormalsFromUVNodes"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docTwoSideRendering() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getTwoSideRendering() { + return instance()->TwoSideRendering; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultTwoSideRendering() { + const static bool def = true; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setTwoSideRendering(const bool &v) { + instance()->handle->SetBool("TwoSideRendering",v); + instance()->TwoSideRendering = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeTwoSideRendering() { + instance()->handle->RemoveBool("TwoSideRendering"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMinimumDeviation() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const double & PartParams::getMinimumDeviation() { + return instance()->MinimumDeviation; +} + +// Auto generated code (Tools/params_utils.py:300) +const double & PartParams::defaultMinimumDeviation() { + const static double def = 0.05; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMinimumDeviation(const double &v) { + instance()->handle->SetFloat("MinimumDeviation",v); + instance()->MinimumDeviation = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMinimumDeviation() { + instance()->handle->RemoveFloat("MinimumDeviation"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMeshDeviation() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const double & PartParams::getMeshDeviation() { + return instance()->MeshDeviation; +} + +// Auto generated code (Tools/params_utils.py:300) +const double & PartParams::defaultMeshDeviation() { + const static double def = 0.2; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMeshDeviation(const double &v) { + instance()->handle->SetFloat("MeshDeviation",v); + instance()->MeshDeviation = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMeshDeviation() { + instance()->handle->RemoveFloat("MeshDeviation"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMeshAngularDeflection() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const double & PartParams::getMeshAngularDeflection() { + return instance()->MeshAngularDeflection; +} + +// Auto generated code (Tools/params_utils.py:300) +const double & PartParams::defaultMeshAngularDeflection() { + const static double def = 28.65; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMeshAngularDeflection(const double &v) { + instance()->handle->SetFloat("MeshAngularDeflection",v); + instance()->MeshAngularDeflection = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMeshAngularDeflection() { + instance()->handle->RemoveFloat("MeshAngularDeflection"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMinimumAngularDeflection() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const double & PartParams::getMinimumAngularDeflection() { + return instance()->MinimumAngularDeflection; +} + +// Auto generated code (Tools/params_utils.py:300) +const double & PartParams::defaultMinimumAngularDeflection() { + const static double def = 5.0; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMinimumAngularDeflection(const double &v) { + instance()->handle->SetFloat("MinimumAngularDeflection",v); + instance()->MinimumAngularDeflection = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMinimumAngularDeflection() { + instance()->handle->RemoveFloat("MinimumAngularDeflection"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docOverrideTessellation() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getOverrideTessellation() { + return instance()->OverrideTessellation; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultOverrideTessellation() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setOverrideTessellation(const bool &v) { + instance()->handle->SetBool("OverrideTessellation",v); + instance()->OverrideTessellation = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeOverrideTessellation() { + instance()->handle->RemoveBool("OverrideTessellation"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMapFaceColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getMapFaceColor() { + return instance()->MapFaceColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultMapFaceColor() { + const static bool def = true; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMapFaceColor(const bool &v) { + instance()->handle->SetBool("MapFaceColor",v); + instance()->MapFaceColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMapFaceColor() { + instance()->handle->RemoveBool("MapFaceColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMapLineColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getMapLineColor() { + return instance()->MapLineColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultMapLineColor() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMapLineColor(const bool &v) { + instance()->handle->SetBool("MapLineColor",v); + instance()->MapLineColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMapLineColor() { + instance()->handle->RemoveBool("MapLineColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMapPointColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getMapPointColor() { + return instance()->MapPointColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultMapPointColor() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMapPointColor(const bool &v) { + instance()->handle->SetBool("MapPointColor",v); + instance()->MapPointColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMapPointColor() { + instance()->handle->RemoveBool("MapPointColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docMapTransparency() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getMapTransparency() { + return instance()->MapTransparency; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultMapTransparency() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setMapTransparency(const bool &v) { + instance()->handle->SetBool("MapTransparency",v); + instance()->MapTransparency = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeMapTransparency() { + instance()->handle->RemoveBool("MapTransparency"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docAutoGridScale() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getAutoGridScale() { + return instance()->AutoGridScale; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultAutoGridScale() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setAutoGridScale(const bool &v) { + instance()->handle->SetBool("AutoGridScale",v); + instance()->AutoGridScale = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeAutoGridScale() { + instance()->handle->RemoveBool("AutoGridScale"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docPreviewAddColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const unsigned long & PartParams::getPreviewAddColor() { + return instance()->PreviewAddColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const unsigned long & PartParams::defaultPreviewAddColor() { + const static unsigned long def = 0x64FFFF30; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setPreviewAddColor(const unsigned long &v) { + instance()->handle->SetUnsigned("PreviewAddColor",v); + instance()->PreviewAddColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removePreviewAddColor() { + instance()->handle->RemoveUnsigned("PreviewAddColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docPreviewSubColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const unsigned long & PartParams::getPreviewSubColor() { + return instance()->PreviewSubColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const unsigned long & PartParams::defaultPreviewSubColor() { + const static unsigned long def = 0xFF646430; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setPreviewSubColor(const unsigned long &v) { + instance()->handle->SetUnsigned("PreviewSubColor",v); + instance()->PreviewSubColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removePreviewSubColor() { + instance()->handle->RemoveUnsigned("PreviewSubColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docPreviewDressColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const unsigned long & PartParams::getPreviewDressColor() { + return instance()->PreviewDressColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const unsigned long & PartParams::defaultPreviewDressColor() { + const static unsigned long def = 0xFF64FF30; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setPreviewDressColor(const unsigned long &v) { + instance()->handle->SetUnsigned("PreviewDressColor",v); + instance()->PreviewDressColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removePreviewDressColor() { + instance()->handle->RemoveUnsigned("PreviewDressColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docPreviewIntersectColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const unsigned long & PartParams::getPreviewIntersectColor() { + return instance()->PreviewIntersectColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const unsigned long & PartParams::defaultPreviewIntersectColor() { + const static unsigned long def = 0x6464FF30; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setPreviewIntersectColor(const unsigned long &v) { + instance()->handle->SetUnsigned("PreviewIntersectColor",v); + instance()->PreviewIntersectColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removePreviewIntersectColor() { + instance()->handle->RemoveUnsigned("PreviewIntersectColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docPreviewOnEdit() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getPreviewOnEdit() { + return instance()->PreviewOnEdit; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultPreviewOnEdit() { + const static bool def = true; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setPreviewOnEdit(const bool &v) { + instance()->handle->SetBool("PreviewOnEdit",v); + instance()->PreviewOnEdit = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removePreviewOnEdit() { + instance()->handle->RemoveBool("PreviewOnEdit"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docPreviewWithTransparency() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getPreviewWithTransparency() { + return instance()->PreviewWithTransparency; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultPreviewWithTransparency() { + const static bool def = true; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setPreviewWithTransparency(const bool &v) { + instance()->handle->SetBool("PreviewWithTransparency",v); + instance()->PreviewWithTransparency = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removePreviewWithTransparency() { + instance()->handle->RemoveBool("PreviewWithTransparency"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docEditOnTop() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getEditOnTop() { + return instance()->EditOnTop; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultEditOnTop() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setEditOnTop(const bool &v) { + instance()->handle->SetBool("EditOnTop",v); + instance()->EditOnTop = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeEditOnTop() { + instance()->handle->RemoveBool("EditOnTop"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docEditRecomputeWait() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const long & PartParams::getEditRecomputeWait() { + return instance()->EditRecomputeWait; +} + +// Auto generated code (Tools/params_utils.py:300) +const long & PartParams::defaultEditRecomputeWait() { + const static long def = 300; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setEditRecomputeWait(const long &v) { + instance()->handle->SetInt("EditRecomputeWait",v); + instance()->EditRecomputeWait = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeEditRecomputeWait() { + instance()->handle->RemoveInt("EditRecomputeWait"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docAdjustCameraForNewFeature() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getAdjustCameraForNewFeature() { + return instance()->AdjustCameraForNewFeature; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultAdjustCameraForNewFeature() { + const static bool def = true; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setAdjustCameraForNewFeature(const bool &v) { + instance()->handle->SetBool("AdjustCameraForNewFeature",v); + instance()->AdjustCameraForNewFeature = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeAdjustCameraForNewFeature() { + instance()->handle->RemoveBool("AdjustCameraForNewFeature"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docDefaultDatumColor() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const unsigned long & PartParams::getDefaultDatumColor() { + return instance()->DefaultDatumColor; +} + +// Auto generated code (Tools/params_utils.py:300) +const unsigned long & PartParams::defaultDefaultDatumColor() { + const static unsigned long def = 0xFFD70099; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setDefaultDatumColor(const unsigned long &v) { + instance()->handle->SetUnsigned("DefaultDatumColor",v); + instance()->DefaultDatumColor = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeDefaultDatumColor() { + instance()->handle->RemoveUnsigned("DefaultDatumColor"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docRespectSystemDPI() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getRespectSystemDPI() { + return instance()->RespectSystemDPI; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultRespectSystemDPI() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setRespectSystemDPI(const bool &v) { + instance()->handle->SetBool("RespectSystemDPI",v); + instance()->RespectSystemDPI = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeRespectSystemDPI() { + instance()->handle->RemoveBool("RespectSystemDPI"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docSelectionPickThreshold() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const long & PartParams::getSelectionPickThreshold() { + return instance()->SelectionPickThreshold; +} + +// Auto generated code (Tools/params_utils.py:300) +const long & PartParams::defaultSelectionPickThreshold() { + const static long def = 1000; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setSelectionPickThreshold(const long &v) { + instance()->handle->SetInt("SelectionPickThreshold",v); + instance()->SelectionPickThreshold = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeSelectionPickThreshold() { + instance()->handle->RemoveInt("SelectionPickThreshold"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docSelectionPickThreshold2() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const long & PartParams::getSelectionPickThreshold2() { + return instance()->SelectionPickThreshold2; +} + +// Auto generated code (Tools/params_utils.py:300) +const long & PartParams::defaultSelectionPickThreshold2() { + const static long def = 500; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setSelectionPickThreshold2(const long &v) { + instance()->handle->SetInt("SelectionPickThreshold2",v); + instance()->SelectionPickThreshold2 = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeSelectionPickThreshold2() { + instance()->handle->RemoveInt("SelectionPickThreshold2"); +} + +// Auto generated code (Tools/params_utils.py:288) +const char *PartParams::docSelectionPickRTree() { + return ""; +} + +// Auto generated code (Tools/params_utils.py:294) +const bool & PartParams::getSelectionPickRTree() { + return instance()->SelectionPickRTree; +} + +// Auto generated code (Tools/params_utils.py:300) +const bool & PartParams::defaultSelectionPickRTree() { + const static bool def = false; + return def; +} + +// Auto generated code (Tools/params_utils.py:307) +void PartParams::setSelectionPickRTree(const bool &v) { + instance()->handle->SetBool("SelectionPickRTree",v); + instance()->SelectionPickRTree = v; +} + +// Auto generated code (Tools/params_utils.py:314) +void PartParams::removeSelectionPickRTree() { + instance()->handle->RemoveBool("SelectionPickRTree"); +} +//[[[end]]] + +void PartParams::onMeshDeviationChanged() { + getTimer().start(100); +} + +void PartParams::onMeshAngularDeflectionChanged() { + getTimer().start(100); +} + +void PartParams::onMinimumDeviationChanged() { + getTimer().start(100); +} + +void PartParams::onMinimumAngularDeflectionChanged() { + getTimer().start(100); +} + +void PartParams::onOverrideTessellationChanged() { + getTimer().start(100); +} + +void PartParams::onRespectSystemDPIChanged() { + getTimer().start(100); +} diff --git a/src/Mod/Part/Gui/PartParams.h b/src/Mod/Part/Gui/PartParams.h new file mode 100644 index 0000000000..ce95a20d78 --- /dev/null +++ b/src/Mod/Part/Gui/PartParams.h @@ -0,0 +1,341 @@ +/**************************************************************************** + * Copyright (c) 2022 Zheng Lei (realthunder) * + * * + * This file is part of the FreeCAD CAx development system. * + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License as published by the Free Software Foundation; either * + * version 2 of the License, or (at your option) any later version. * + * * + * This library is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU Library General Public License for more details. * + * * + * You should have received a copy of the GNU Library General Public * + * License along with this library; see the file COPYING.LIB. If not, * + * write to the Free Software Foundation, Inc., 59 Temple Place, * + * Suite 330, Boston, MA 02111-1307, USA * + * * + ****************************************************************************/ + +#ifndef PART_PARAMS_H +#define PART_PARAMS_H + +/*[[[cog +import PartGuiParams +PartGuiParams.declare() +]]]*/ + +// Auto generated code (Tools/params_utils.py:72) +#include + + +// Auto generated code (Tools/params_utils.py:78) +namespace PartGui { +/** Convenient class to obtain Part/PartDesign visual related parameters + + * The parameters are under group "User parameter:BaseApp/Preferences/Mod/Part" + * + * This class is auto generated by Mod/Part/Gui/PartParams.py. Modify that file + * instead of this one, if you want to add any parameter. You need + * to install Cog Python package for code generation: + * @code + * pip install cogapp + * @endcode + * + * Once modified, you can regenerate the header and the source file, + * @code + * python3 -m cogapp -r Mod/Part/Gui/PartParams.h Mod/Part/Gui/PartParams.cpp + * @endcode + * + * You can add a new parameter by adding lines in Mod/Part/Gui/PartParams.py. Available + * parameter types are 'Int, UInt, String, Bool, Float'. For example, to add + * a new Int type parameter, + * @code + * ParamInt(parameter_name, default_value, documentation, on_change=False) + * @endcode + * + * If there is special handling on parameter change, pass in on_change=True. + * And you need to provide a function implementation in Mod/Part/Gui/PartParams.cpp with + * the following signature. + * @code + * void PartParams:onChanged() + * @endcode + */ +class PartGuiExport PartParams { +public: + static ParameterGrp::handle getHandle(); + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter NormalsFromUVNodes + static const bool & getNormalsFromUVNodes(); + static const bool & defaultNormalsFromUVNodes(); + static void removeNormalsFromUVNodes(); + static void setNormalsFromUVNodes(const bool &v); + static const char *docNormalsFromUVNodes(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter TwoSideRendering + static const bool & getTwoSideRendering(); + static const bool & defaultTwoSideRendering(); + static void removeTwoSideRendering(); + static void setTwoSideRendering(const bool &v); + static const char *docTwoSideRendering(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MinimumDeviation + static const double & getMinimumDeviation(); + static const double & defaultMinimumDeviation(); + static void removeMinimumDeviation(); + static void setMinimumDeviation(const double &v); + static const char *docMinimumDeviation(); + static void onMinimumDeviationChanged(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MeshDeviation + static const double & getMeshDeviation(); + static const double & defaultMeshDeviation(); + static void removeMeshDeviation(); + static void setMeshDeviation(const double &v); + static const char *docMeshDeviation(); + static void onMeshDeviationChanged(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MeshAngularDeflection + static const double & getMeshAngularDeflection(); + static const double & defaultMeshAngularDeflection(); + static void removeMeshAngularDeflection(); + static void setMeshAngularDeflection(const double &v); + static const char *docMeshAngularDeflection(); + static void onMeshAngularDeflectionChanged(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MinimumAngularDeflection + static const double & getMinimumAngularDeflection(); + static const double & defaultMinimumAngularDeflection(); + static void removeMinimumAngularDeflection(); + static void setMinimumAngularDeflection(const double &v); + static const char *docMinimumAngularDeflection(); + static void onMinimumAngularDeflectionChanged(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter OverrideTessellation + static const bool & getOverrideTessellation(); + static const bool & defaultOverrideTessellation(); + static void removeOverrideTessellation(); + static void setOverrideTessellation(const bool &v); + static const char *docOverrideTessellation(); + static void onOverrideTessellationChanged(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MapFaceColor + static const bool & getMapFaceColor(); + static const bool & defaultMapFaceColor(); + static void removeMapFaceColor(); + static void setMapFaceColor(const bool &v); + static const char *docMapFaceColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MapLineColor + static const bool & getMapLineColor(); + static const bool & defaultMapLineColor(); + static void removeMapLineColor(); + static void setMapLineColor(const bool &v); + static const char *docMapLineColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MapPointColor + static const bool & getMapPointColor(); + static const bool & defaultMapPointColor(); + static void removeMapPointColor(); + static void setMapPointColor(const bool &v); + static const char *docMapPointColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter MapTransparency + static const bool & getMapTransparency(); + static const bool & defaultMapTransparency(); + static void removeMapTransparency(); + static void setMapTransparency(const bool &v); + static const char *docMapTransparency(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter AutoGridScale + static const bool & getAutoGridScale(); + static const bool & defaultAutoGridScale(); + static void removeAutoGridScale(); + static void setAutoGridScale(const bool &v); + static const char *docAutoGridScale(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter PreviewAddColor + static const unsigned long & getPreviewAddColor(); + static const unsigned long & defaultPreviewAddColor(); + static void removePreviewAddColor(); + static void setPreviewAddColor(const unsigned long &v); + static const char *docPreviewAddColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter PreviewSubColor + static const unsigned long & getPreviewSubColor(); + static const unsigned long & defaultPreviewSubColor(); + static void removePreviewSubColor(); + static void setPreviewSubColor(const unsigned long &v); + static const char *docPreviewSubColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter PreviewDressColor + static const unsigned long & getPreviewDressColor(); + static const unsigned long & defaultPreviewDressColor(); + static void removePreviewDressColor(); + static void setPreviewDressColor(const unsigned long &v); + static const char *docPreviewDressColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter PreviewIntersectColor + static const unsigned long & getPreviewIntersectColor(); + static const unsigned long & defaultPreviewIntersectColor(); + static void removePreviewIntersectColor(); + static void setPreviewIntersectColor(const unsigned long &v); + static const char *docPreviewIntersectColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter PreviewOnEdit + static const bool & getPreviewOnEdit(); + static const bool & defaultPreviewOnEdit(); + static void removePreviewOnEdit(); + static void setPreviewOnEdit(const bool &v); + static const char *docPreviewOnEdit(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter PreviewWithTransparency + static const bool & getPreviewWithTransparency(); + static const bool & defaultPreviewWithTransparency(); + static void removePreviewWithTransparency(); + static void setPreviewWithTransparency(const bool &v); + static const char *docPreviewWithTransparency(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter EditOnTop + static const bool & getEditOnTop(); + static const bool & defaultEditOnTop(); + static void removeEditOnTop(); + static void setEditOnTop(const bool &v); + static const char *docEditOnTop(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter EditRecomputeWait + static const long & getEditRecomputeWait(); + static const long & defaultEditRecomputeWait(); + static void removeEditRecomputeWait(); + static void setEditRecomputeWait(const long &v); + static const char *docEditRecomputeWait(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter AdjustCameraForNewFeature + static const bool & getAdjustCameraForNewFeature(); + static const bool & defaultAdjustCameraForNewFeature(); + static void removeAdjustCameraForNewFeature(); + static void setAdjustCameraForNewFeature(const bool &v); + static const char *docAdjustCameraForNewFeature(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter DefaultDatumColor + static const unsigned long & getDefaultDatumColor(); + static const unsigned long & defaultDefaultDatumColor(); + static void removeDefaultDatumColor(); + static void setDefaultDatumColor(const unsigned long &v); + static const char *docDefaultDatumColor(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter RespectSystemDPI + static const bool & getRespectSystemDPI(); + static const bool & defaultRespectSystemDPI(); + static void removeRespectSystemDPI(); + static void setRespectSystemDPI(const bool &v); + static const char *docRespectSystemDPI(); + static void onRespectSystemDPIChanged(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter SelectionPickThreshold + static const long & getSelectionPickThreshold(); + static const long & defaultSelectionPickThreshold(); + static void removeSelectionPickThreshold(); + static void setSelectionPickThreshold(const long &v); + static const char *docSelectionPickThreshold(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter SelectionPickThreshold2 + static const long & getSelectionPickThreshold2(); + static const long & defaultSelectionPickThreshold2(); + static void removeSelectionPickThreshold2(); + static void setSelectionPickThreshold2(const long &v); + static const char *docSelectionPickThreshold2(); + //@} + + // Auto generated code (Tools/params_utils.py:122) + //@{ + /// Accessor for parameter SelectionPickRTree + static const bool & getSelectionPickRTree(); + static const bool & defaultSelectionPickRTree(); + static void removeSelectionPickRTree(); + static void setSelectionPickRTree(const bool &v); + static const char *docSelectionPickRTree(); + //@} + +// Auto generated code (Tools/params_utils.py:150) +}; // class PartParams +} // namespace PartGui +//[[[end]]] +#endif // PART_PARAMS_H