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

Merge pull request #13219 from Ondsel-Development/TD_Insert

Browse Source 
TechDraw: Unify Insert View tools (View, ProjGroup, Sheet, Arch, svg, image)
This commit is contained in:
WandererFan
2024-04-24 08:24:26 -04:00
committed by GitHub
parent a2243cec5e ddd35aeefa
commit 05206afa1b
22 changed files with 1864 additions and 1163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
src/Mod/TechDraw/App/DrawProjGroup.cpp
View File

@@ -542,9 +542,8 @@ int DrawProjGroup::purgeProjections()
{
while (!Views.getValues().empty()) {
std::vector<DocumentObject*> views = Views.getValues();
DrawProjGroupItem* dpgi;
DocumentObject* dObj = views.back();
dpgi = dynamic_cast<DrawProjGroupItem*>(dObj);
auto* dpgi = dynamic_cast<DrawProjGroupItem*>(dObj);
if (dpgi) {
std::string itemName = dpgi->Type.getValueAsString();
removeProjection(itemName.c_str());
@@ -583,74 +582,7 @@ std::pair<Base::Vector3d, Base::Vector3d> DrawProjGroup::getDirsFromFront(std::s
throw Base::RuntimeError("Project Group missing Anchor projection item");
}
Base::Vector3d org(0.0, 0.0, 0.0);
gp_Ax2 anchorCS = anch->getProjectionCS(org);
gp_Pnt gOrg(0.0, 0.0, 0.0);
gp_Dir gDir = anchorCS.Direction();
gp_Dir gXDir = anchorCS.XDirection();
gp_Dir gYDir = anchorCS.YDirection();
gp_Ax1 gUpAxis(gOrg, gYDir);
gp_Ax2 newCS;
gp_Dir gNewDir;
gp_Dir gNewXDir;
double angle = M_PI / 2.0;//90*
if (viewType == "Right") {
newCS = anchorCS.Rotated(gUpAxis, angle);
projDir = dir2vec(newCS.Direction());
rotVec = dir2vec(newCS.XDirection());
}
else if (viewType == "Left") {
newCS = anchorCS.Rotated(gUpAxis, -angle);
projDir = dir2vec(newCS.Direction());
rotVec = dir2vec(newCS.XDirection());
}
else if (viewType == "Top") {
projDir = dir2vec(gYDir);
rotVec = dir2vec(gXDir);
}
else if (viewType == "Bottom") {
projDir = dir2vec(gYDir.Reversed());
rotVec = dir2vec(gXDir);
}
else if (viewType == "Rear") {
projDir = dir2vec(gDir.Reversed());
rotVec = dir2vec(gXDir.Reversed());
}
else if (viewType == "FrontTopLeft") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) - gp_Vec(gXDir) + gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) + gp_Vec(gDir));
rotVec = dir2vec(newXDir);
}
else if (viewType == "FrontTopRight") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) + gp_Vec(gXDir) + gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) - gp_Vec(gDir));
rotVec = dir2vec(newXDir);
}
else if (viewType == "FrontBottomLeft") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) - gp_Vec(gXDir) - gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) + gp_Vec(gDir));
rotVec = dir2vec(newXDir);
}
else if (viewType == "FrontBottomRight") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) + gp_Vec(gXDir) - gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) - gp_Vec(gDir));
rotVec = dir2vec(newXDir);
} else {
// not one of the standard view directions, so complain and use the values for "Front"
Base::Console().Error("DrawProjGroup - %s unknown projection: %s\n", getNameInDocument(),
viewType.c_str());
Base::Vector3d dirAnch = anch->Direction.getValue();
Base::Vector3d rotAnch = anch->getXDirection();
return std::make_pair(dirAnch, rotAnch);
}
return std::make_pair(projDir, rotVec);
return anch->getDirsFromFront(viewType);
}
Base::Vector3d DrawProjGroup::dir2vec(gp_Dir d)
@@ -1144,8 +1076,7 @@ TechDraw::DrawProjGroupItem* DrawProjGroup::getAnchor()
{
App::DocumentObject* docObj = Anchor.getValue();
if (docObj) {
DrawProjGroupItem* result = static_cast<DrawProjGroupItem*>(docObj);
return result;
return static_cast<DrawProjGroupItem*>(docObj);
}
return nullptr;
}
@@ -1153,7 +1084,7 @@ TechDraw::DrawProjGroupItem* DrawProjGroup::getAnchor()
void DrawProjGroup::setAnchorDirection(const Base::Vector3d dir)
{
App::DocumentObject* docObj = Anchor.getValue();
DrawProjGroupItem* item = static_cast<DrawProjGroupItem*>(docObj);
auto* item = static_cast<DrawProjGroupItem*>(docObj);
item->Direction.setValue(dir);
}
@@ -1163,7 +1094,7 @@ Base::Vector3d DrawProjGroup::getAnchorDirection()
if (!docObj) {
return Base::Vector3d();
}
DrawProjGroupItem* item = static_cast<DrawProjGroupItem*>(docObj);
auto* item = static_cast<DrawProjGroupItem*>(docObj);
return item->Direction.getValue();
}
@@ -1286,6 +1217,11 @@ void DrawProjGroup::spin(const std::string& spindirection)
if (spindirection == "CCW")
angle = -M_PI / 2.0;// Top -> Left -> Bottom -> Right -> Top
spin(angle);
}
void DrawProjGroup::spin(double angle)
{
DrawProjGroupItem* anchor = getAnchor();
Base::Vector3d org(0.0, 0.0, 0.0);
Base::Vector3d curRot = anchor->getXDirection();
@@ -1301,8 +1237,7 @@ std::vector<DrawProjGroupItem*> DrawProjGroup::getViewsAsDPGI()
std::vector<DrawProjGroupItem*> result;
auto views = Views.getValues();
for (auto& v : views) {
DrawProjGroupItem* item = static_cast<DrawProjGroupItem*>(v);
result.push_back(item);
result.push_back(static_cast<DrawProjGroupItem*>(v));
}
return result;
}
@@ -1318,7 +1253,7 @@ void DrawProjGroup::dumpISO(const char* title)
for (auto& docObj : Views.getValues()) {
Base::Vector3d dir;
Base::Vector3d axis;
DrawProjGroupItem* v = static_cast<DrawProjGroupItem*>(docObj);
auto* v = static_cast<DrawProjGroupItem*>(docObj);
std::string t = v->Type.getValueAsString();
dir = v->Direction.getValue();
axis = v->getXDirection();

1
src/Mod/TechDraw/App/DrawProjGroup.h
View File

@@ -129,6 +129,7 @@ public:
void rotate(const std::string &rotationdirection);
void spin(const std::string &spindirection);
void spin(double angle);
void dumpISO(const char * title);
std::vector<DrawProjGroupItem*> getViewsAsDPGI();

134
src/Mod/TechDraw/App/DrawProjGroupItem.cpp
View File

@@ -55,7 +55,7 @@ const char *DrawProjGroupItem::TypeEnums[] = {
PROPERTY_SOURCE(TechDraw::DrawProjGroupItem, TechDraw::DrawViewPart)
DrawProjGroupItem::DrawProjGroupItem(void)
DrawProjGroupItem::DrawProjGroupItem()
{
Type.setEnums(TypeEnums);
ADD_PROPERTY(Type, ((long)0));
@@ -65,30 +65,25 @@ DrawProjGroupItem::DrawProjGroupItem(void)
//projection group controls these
// Direction.setStatus(App::Property::ReadOnly, true);
RotationVector.setStatus(App::Property::ReadOnly, true); //Use XDirection
ScaleType.setValue("Custom");
Scale.setStatus(App::Property::Hidden, true);
ScaleType.setStatus(App::Property::Hidden, true);
}
short DrawProjGroupItem::mustExecute() const
{
//there is nothing unique about dpgi vs dvp
return TechDraw::DrawViewPart::mustExecute();
if (getPGroup()) {
ScaleType.setValue("Custom");
Scale.setStatus(App::Property::Hidden, true);
ScaleType.setStatus(App::Property::Hidden, true);
}
}
void DrawProjGroupItem::onChanged(const App::Property *prop)
{
if ((prop == &X) ||
(prop == &Y)) {
DrawProjGroup* parent = getPGroup();
if (parent) {
parent->touch(false);
if ((prop == &X) || (prop == &Y)) {
DrawProjGroup* pGroup = getPGroup();
if (pGroup) {
pGroup->touch(false);
}
}
TechDraw::DrawViewPart::onChanged(prop);
}
bool DrawProjGroupItem::isLocked(void) const
bool DrawProjGroupItem::isLocked() const
{
if (isAnchor()) { //Anchor view is always locked to DPG
return true;
@@ -96,23 +91,22 @@ bool DrawProjGroupItem::isLocked(void) const
return DrawView::isLocked();
}
bool DrawProjGroupItem::showLock(void) const
bool DrawProjGroupItem::showLock() const
{
DrawProjGroup* parent = getPGroup();
bool parentLock = false;
if (parent) {
parentLock = parent->LockPosition.getValue();
}
if (isAnchor() && //don't show lock for Front if DPG is not locked
!parentLock) {
//don't show lock for Front if DPG is not locked
if (isAnchor() && !parentLock) {
return false;
}
return DrawView::showLock();
}
App::DocumentObjectExecReturn *DrawProjGroupItem::execute(void)
App::DocumentObjectExecReturn *DrawProjGroupItem::execute()
{
// Base::Console().Message("DPGI::execute() - %s / %s\n", getNameInDocument(), Label.getValue());
if (!keepUpdated()) {
@@ -132,40 +126,46 @@ App::DocumentObjectExecReturn *DrawProjGroupItem::execute(void)
//unblock
}
if (DrawUtil::checkParallel(Direction.getValue(),
getXDirection())) {
if (DrawUtil::checkParallel(Direction.getValue(), getXDirection())) {
return new App::DocumentObjectExecReturn("DPGI: Direction and XDirection are parallel");
}
return DrawViewPart::execute();
}
void DrawProjGroupItem::postHlrTasks(void)
void DrawProjGroupItem::postHlrTasks()
{
// Base::Console().Message("DPGI::postHlrTasks() - %s\n", getNameInDocument());
DrawViewPart::postHlrTasks();
//DPGI has no geometry until HLR has finished, and the DPG can not properly
//AutoDistibute until all its items have geometry.
autoPosition();
DrawProjGroup* pGroup = getPGroup();
if (pGroup) {
//DPGI has no geometry until HLR has finished, and the DPG can not properly
//AutoDistibute until all its items have geometry.
autoPosition();
getPGroup()->reportReady(); //tell the parent DPG we are ready
pGroup->reportReady(); //tell the parent DPG we are ready
}
}
void DrawProjGroupItem::autoPosition()
{
DrawProjGroup* pGroup = getPGroup();
if (!pGroup) {
return;
}
// Base::Console().Message("DPGI::autoPosition(%s)\n", Label.getValue());
if (LockPosition.getValue()) {
return;
}
Base::Vector3d newPos;
if (getPGroup() && getPGroup()->AutoDistribute.getValue()) {
newPos = getPGroup()->getXYPosition(Type.getValueAsString());
if (pGroup && pGroup->AutoDistribute.getValue()) {
newPos = pGroup->getXYPosition(Type.getValueAsString());
X.setValue(newPos.x);
Y.setValue(newPos.y);
requestPaint();
purgeTouched(); //prevents "still touched after recompute" message
getPGroup()->purgeTouched(); //changing dpgi x, y marks parent dpg as touched
pGroup->purgeTouched(); //changing dpgi x, y marks parent dpg as touched
}
}
@@ -184,49 +184,12 @@ DrawProjGroup* DrawProjGroupItem::getPGroup() const
return dynamic_cast<DrawProjGroup *>(getCollection());
}
bool DrawProjGroupItem::isAnchor(void) const
bool DrawProjGroupItem::isAnchor() const
{
if (getPGroup() && (getPGroup()->getAnchor() == this) ) {
return true;
}
return false;
return getPGroup() && (getPGroup()->getAnchor() == this);
}
/// get a coord system aligned with Direction and Rotation Vector
gp_Ax2 DrawProjGroupItem::getViewAxis(const Base::Vector3d& pt,
const Base::Vector3d& axis,
const bool flip) const
{
Base::Console().Message("DPGI::getViewAxis - deprecated. use getProjectionCS\n");
(void) flip;
gp_Ax2 viewAxis;
Base::Vector3d projDir = Direction.getValue();
Base::Vector3d rotVec = getXDirection();
// mirror projDir through XZ plane
Base::Vector3d yNorm(0.0, 1.0, 0.0);
projDir = projDir - (yNorm * 2.0) * (projDir.Dot(yNorm));
rotVec = rotVec - (yNorm * 2.0) * (rotVec.Dot(yNorm));
if (DrawUtil::checkParallel(projDir, rotVec)) {
Base::Console().Warning("DPGI::getVA - %s - Direction and XDirection parallel. using defaults\n",
getNameInDocument());
}
try {
viewAxis = gp_Ax2(gp_Pnt(pt.x, pt.y, pt.z),
gp_Dir(projDir.x, projDir.y, projDir.z),
gp_Dir(rotVec.x, rotVec.y, rotVec.z));
}
catch (Standard_Failure& e4) {
Base::Console().Message("PROBLEM - DPGI (%s) failed to create viewAxis: %s **\n",
getNameInDocument(), e4.GetMessageString());
return ShapeUtils::getViewAxis(pt, axis, false);
}
return viewAxis;
}
Base::Vector3d DrawProjGroupItem::getXDirection(void) const
Base::Vector3d DrawProjGroupItem::getXDirection() const
{
// Base::Console().Message("DPGI::getXDirection() - %s\n", Label.getValue());
Base::Vector3d result(1.0, 0.0, 0.0); //default X
@@ -237,19 +200,23 @@ Base::Vector3d DrawProjGroupItem::getXDirection(void) const
prop = getPropertyByName("RotationVector");
if (prop) {
result = RotationVector.getValue(); //use RotationVector if we have it
} else {
}
else {
result = DrawViewPart::getXDirection(); //over complex.
}
} else {
}
else {
result = DrawViewPart::getXDirection();
}
} else { //not sure this branch can actually happen
}
else { //not sure this branch can actually happen
Base::Console().Message("DPGI::getXDirection - unexpected branch taken!\n");
prop = getPropertyByName("RotationVector");
if (prop) {
result = RotationVector.getValue();
} else {
}
else {
Base::Console().Message("DPGI::getXDirection - missing RotationVector and XDirection\n");
}
}
@@ -309,7 +276,7 @@ double DrawProjGroupItem::getRotateAngle()
return angle;
}
double DrawProjGroupItem::getScale(void) const
double DrawProjGroupItem::getScale() const
{
auto pgroup = getPGroup();
if (pgroup) {
@@ -319,7 +286,7 @@ double DrawProjGroupItem::getScale(void) const
}
return result;
}
return 1.0;
return Scale.getValue();
}
int DrawProjGroupItem::getScaleType() const
@@ -339,13 +306,12 @@ void DrawProjGroupItem::unsetupObject()
return;
}
if (!getPGroup()->hasProjection(Type.getValueAsString()) ) {
if (!getPGroup()->hasProjection(Type.getValueAsString())) {
DrawViewPart::unsetupObject();
return;
}
if ( getPGroup()->getAnchor() == this &&
!getPGroup()->isUnsetting() ) {
if (getPGroup()->getAnchor() == this && !getPGroup()->isUnsetting()) {
Base::Console().Warning("Warning - DPG (%s/%s) may be corrupt - Anchor deleted\n",
getPGroup()->getNameInDocument(), getPGroup()->Label.getValue());
getPGroup()->Anchor.setValue(nullptr); //this catches situation where DPGI is deleted w/o DPG::removeProjection
@@ -361,7 +327,7 @@ int DrawProjGroupItem::countParentPages() const
if (dpg) {
return dpg->countParentPages();
}
return 0;
return DrawView::countParentPages();
}
DrawPage* DrawProjGroupItem::findParentPage() const
@@ -370,7 +336,7 @@ DrawPage* DrawProjGroupItem::findParentPage() const
if (dpg) {
return dpg->findParentPage();
}
return nullptr;
return DrawView::findParentPage();
}
std::vector<DrawPage*> DrawProjGroupItem::findAllParentPages() const
@@ -379,10 +345,10 @@ std::vector<DrawPage*> DrawProjGroupItem::findAllParentPages() const
if (dpg) {
return dpg->findAllParentPages();
}
return std::vector<DrawPage*>();
return DrawView::findAllParentPages();
}
PyObject *DrawProjGroupItem::getPyObject(void)
PyObject *DrawProjGroupItem::getPyObject()
{
if (PythonObject.is(Py::_None())) {
// ref counter is set to 1

5
src/Mod/TechDraw/App/DrawProjGroupItem.h
View File

@@ -60,7 +60,6 @@ public:
App::PropertyEnumeration Type;
App::PropertyVector RotationVector; //this is superseded by dvp xdirection
short mustExecute() const override;
void onDocumentRestored() override;
void unsetupObject() override;
@@ -81,10 +80,6 @@ public:
//return PyObject as DrawProjGroupItemPy
PyObject *getPyObject() override;
gp_Ax2 getViewAxis(const Base::Vector3d& pt,
const Base::Vector3d& direction,
const bool flip=true) const override;
double getScale() const override;
int getScaleType() const override;
void autoPosition();

123
src/Mod/TechDraw/App/DrawViewPart.cpp
View File

@@ -1263,6 +1263,129 @@ Base::Vector3d DrawViewPart::getXDirection() const
return result;
}
void DrawViewPart::rotate(const std::string& rotationdirection)
{
std::pair<Base::Vector3d, Base::Vector3d> newDirs;
if (rotationdirection == "Right")
newDirs = getDirsFromFront("Left");// Front -> Right -> Rear -> Left -> Front
else if (rotationdirection == "Left")
newDirs = getDirsFromFront("Right");// Front -> Left -> Rear -> Right -> Front
else if (rotationdirection == "Up")
newDirs = getDirsFromFront("Bottom");// Front -> Top -> Rear -> Bottom -> Front
else if (rotationdirection == "Down")
newDirs = getDirsFromFront("Top");// Front -> Bottom -> Rear -> Top -> Front
Direction.setValue(newDirs.first);
XDirection.setValue(newDirs.second);
recompute();
}
void DrawViewPart::spin(const std::string& spindirection)
{
double angle;
if (spindirection == "CW")
angle = M_PI / 2.0;// Top -> Right -> Bottom -> Left -> Top
if (spindirection == "CCW")
angle = -M_PI / 2.0;// Top -> Left -> Bottom -> Right -> Top
spin(angle);
}
void DrawViewPart::spin(double angle)
{
Base::Vector3d org(0.0, 0.0, 0.0);
Base::Vector3d curRot = getXDirection();
Base::Vector3d curDir = Direction.getValue();
Base::Vector3d newRot = DrawUtil::vecRotate(curRot, angle, curDir, org);
XDirection.setValue(newRot);
recompute();
}
std::pair<Base::Vector3d, Base::Vector3d> DrawViewPart::getDirsFromFront(std::string viewType)
{
// Base::Console().Message("DVP::getDirsFromFront(%s)\n", viewType.c_str());
std::pair<Base::Vector3d, Base::Vector3d> result;
Base::Vector3d projDir, rotVec;
Base::Vector3d org(0.0, 0.0, 0.0);
gp_Ax2 anchorCS = getProjectionCS(org);
gp_Pnt gOrg(0.0, 0.0, 0.0);
gp_Dir gDir = anchorCS.Direction();
gp_Dir gXDir = anchorCS.XDirection();
gp_Dir gYDir = anchorCS.YDirection();
gp_Ax1 gUpAxis(gOrg, gYDir);
gp_Ax2 newCS;
gp_Dir gNewDir;
gp_Dir gNewXDir;
double angle = M_PI / 2.0;//90*
if (viewType == "Right") {
newCS = anchorCS.Rotated(gUpAxis, angle);
projDir = dir2vec(newCS.Direction());
rotVec = dir2vec(newCS.XDirection());
}
else if (viewType == "Left") {
newCS = anchorCS.Rotated(gUpAxis, -angle);
projDir = dir2vec(newCS.Direction());
rotVec = dir2vec(newCS.XDirection());
}
else if (viewType == "Top") {
projDir = dir2vec(gYDir);
rotVec = dir2vec(gXDir);
}
else if (viewType == "Bottom") {
projDir = dir2vec(gYDir.Reversed());
rotVec = dir2vec(gXDir);
}
else if (viewType == "Rear") {
projDir = dir2vec(gDir.Reversed());
rotVec = dir2vec(gXDir.Reversed());
}
else if (viewType == "FrontTopLeft") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) - gp_Vec(gXDir) + gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) + gp_Vec(gDir));
rotVec = dir2vec(newXDir);
}
else if (viewType == "FrontTopRight") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) + gp_Vec(gXDir) + gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) - gp_Vec(gDir));
rotVec = dir2vec(newXDir);
}
else if (viewType == "FrontBottomLeft") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) - gp_Vec(gXDir) - gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) + gp_Vec(gDir));
rotVec = dir2vec(newXDir);
}
else if (viewType == "FrontBottomRight") {
gp_Dir newDir = gp_Dir(gp_Vec(gDir) + gp_Vec(gXDir) - gp_Vec(gYDir));
projDir = dir2vec(newDir);
gp_Dir newXDir = gp_Dir(gp_Vec(gXDir) - gp_Vec(gDir));
rotVec = dir2vec(newXDir);
}
else {
// not one of the standard view directions, so complain and use the values for "Front"
Base::Console().Error("DrawViewPart - %s unknown projection: %s\n", getNameInDocument(),
viewType.c_str());
Base::Vector3d dirAnch = Direction.getValue();
Base::Vector3d rotAnch = getXDirection();
return std::make_pair(dirAnch, rotAnch);
}
return std::make_pair(projDir, rotVec);
}
Base::Vector3d DrawViewPart::dir2vec(gp_Dir d)
{
return Base::Vector3d(d.X(), d.Y(), d.Z());
}
Base::Vector3d DrawViewPart::getLegacyX(const Base::Vector3d& pt, const Base::Vector3d& axis,
const bool flip) const
{

6
src/Mod/TechDraw/App/DrawViewPart.h
View File

@@ -172,6 +172,12 @@ public:
virtual Base::Vector3d getLegacyX(const Base::Vector3d& pt, const Base::Vector3d& axis,
const bool flip = true) const;
void rotate(const std::string& rotationdirection);
void spin(const std::string& spindirection);
void spin(double val);
std::pair<Base::Vector3d, Base::Vector3d> getDirsFromFront(std::string viewType);
Base::Vector3d dir2vec(gp_Dir d);
gp_Ax2 localVectorToCS(const Base::Vector3d localUnit) const;
Base::Vector3d localVectorToDirection(const Base::Vector3d localUnit) const;

241
src/Mod/TechDraw/Gui/Command.cpp
View File

@@ -24,6 +24,8 @@
#include <QApplication>
#include <QFileInfo>
#include <QMessageBox>
#include <QCheckBox>
#include <QPushButton>
#include <vector>
#endif
@@ -294,7 +296,9 @@ CmdTechDrawView::CmdTechDrawView() : Command("TechDraw_View")
sAppModule = "TechDraw";
sGroup = QT_TR_NOOP("TechDraw");
sMenuText = QT_TR_NOOP("Insert View");
sToolTipText = QT_TR_NOOP("Insert a View");
sToolTipText = QT_TR_NOOP("Insert a View in current page.\n"
"Selected objects, spreadsheets or Arch WB section planes will be added.\n"
"Without a selection, a file browser lets you select a SVG or image file.");
sWhatsThis = "TechDraw_View";
sStatusTip = sToolTipText;
sPixmap = "actions/TechDraw_View";
@@ -303,23 +307,70 @@ CmdTechDrawView::CmdTechDrawView() : Command("TechDraw_View")
void CmdTechDrawView::activated(int iMsg)
{
Q_UNUSED(iMsg);
bool viewCreated = false;
TechDraw::DrawPage* page = DrawGuiUtil::findPage(this);
if (!page) {
return;
}
std::string PageName = page->getNameInDocument();
// switch to the page if it's not current active window
auto* vpp = dynamic_cast<ViewProviderPage*>
(Gui::Application::Instance->getViewProvider(page));
if (vpp) {
vpp->switchToMdiViewPage();
}
//set projection direction from selected Face
//use first object with a face selected
std::vector<App::DocumentObject*> shapes;
std::vector<App::DocumentObject*> xShapes;
std::vector<App::DocumentObject*> shapes, xShapes;
App::DocumentObject* partObj = nullptr;
std::string faceName;
Gui::ResolveMode resolve = Gui::ResolveMode::OldStyleElement;//mystery
bool single = false; //mystery
auto selection = getSelection().getSelectionEx(nullptr, App::DocumentObject::getClassTypeId(),
resolve, single);
auto selection = getSelection().getSelectionEx(nullptr, App::DocumentObject::getClassTypeId());
for (auto& sel : selection) {
bool is_linked = false;
auto obj = sel.getObject();
if (obj->isDerivedFrom(TechDraw::DrawPage::getClassTypeId())) {
if (obj->isDerivedFrom<TechDraw::DrawPage>() || obj->isDerivedFrom<TechDraw::DrawView>()) {
continue;
}
if (obj->isDerivedFrom<Spreadsheet::Sheet>()) {
std::string SpreadName = obj->getNameInDocument();
openCommand(QT_TRANSLATE_NOOP("Command", "Create spreadsheet view"));
std::string FeatName = getUniqueObjectName("Sheet");
doCommand(Doc, "App.activeDocument().addObject('TechDraw::DrawViewSpreadsheet', '%s')",
FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.translateLabel('DrawViewSpreadsheet', 'Sheet', '%s')",
FeatName.c_str(), FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.Source = App.activeDocument().%s", FeatName.c_str(),
SpreadName.c_str());
doCommand(Doc, "App.activeDocument().%s.addView(App.activeDocument().%s)", PageName.c_str(),
FeatName.c_str());
updateActive();
commitCommand();
viewCreated = true;
continue;
}
else if (DrawGuiUtil::isArchSection(obj)) {
std::string FeatName = getUniqueObjectName("ArchView");
std::string SourceName = obj->getNameInDocument();
openCommand(QT_TRANSLATE_NOOP("Command", "Create ArchView"));
doCommand(Doc, "App.activeDocument().addObject('TechDraw::DrawViewArch', '%s')",
FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.translateLabel('DrawViewArch', 'ArchView', '%s')",
FeatName.c_str(), FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.Source = App.activeDocument().%s", FeatName.c_str(),
SourceName.c_str());
doCommand(Doc, "App.activeDocument().%s.addView(App.activeDocument().%s)", PageName.c_str(),
FeatName.c_str());
updateActive();
commitCommand();
viewCreated = true;
continue;
}
if (obj->isDerivedFrom(App::LinkElement::getClassTypeId())
|| obj->isDerivedFrom(App::LinkGroup::getClassTypeId())
|| obj->isDerivedFrom(App::Link::getClassTypeId())) {
@@ -364,64 +415,99 @@ void CmdTechDrawView::activated(int iMsg)
}
}
ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Mod/TechDraw");
if (shapes.empty() && xShapes.empty()) {
QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Wrong selection"),
QObject::tr("No Shapes, Groups or Links in this selection"));
if (!viewCreated) {
// If nothing was selected, then we offer to insert SVG or Images files.
bool dontShowAgain = hGrp->GetBool("DontShowInsertFileMessage", false);
if (!dontShowAgain) {
QMessageBox msgBox;
msgBox.setText(msgBox.tr("If you want to insert a view from existing objects, please select them before invoking this tool. Without a selection, a file browser will open, to insert a SVG or image file."));
QCheckBox dontShowCheckBox(msgBox.tr("Do not show this message again"), &msgBox);
msgBox.setCheckBox(&dontShowCheckBox);
QPushButton* okButton = msgBox.addButton(QMessageBox::Ok);
msgBox.exec();
if (msgBox.clickedButton() == okButton && dontShowCheckBox.isChecked()) {
// Save the preference to not show the message again
hGrp->SetBool("DontShowInsertFileMessage", true);
}
}
QString filename = Gui::FileDialog::getOpenFileName(Gui::getMainWindow(),
QObject::tr("Select a SVG or Image file to open"), QString(),
QString::fromLatin1("%1 (*.svg *.svgz *.jpg *.jpeg *.png *.bmp);;%2 (*.*)")
.arg(QObject::tr("SVG or Image files"), QObject::tr("All Files")));
if (!filename.isEmpty()) {
if (filename.endsWith(QString::fromLatin1(".svg"), Qt::CaseInsensitive)
|| filename.endsWith(QString::fromLatin1(".svgz"), Qt::CaseInsensitive)) {
std::string FeatName = getUniqueObjectName("Symbol");
filename = Base::Tools::escapeEncodeFilename(filename);
openCommand(QT_TRANSLATE_NOOP("Command", "Create Symbol"));
doCommand(Doc, "f = open(\"%s\", 'r')", (const char*)filename.toUtf8());
doCommand(Doc, "svg = f.read()");
doCommand(Doc, "f.close()");
doCommand(Doc, "App.activeDocument().addObject('TechDraw::DrawViewSymbol', '%s')",
FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.translateLabel('DrawViewSymbol', 'Symbol', '%s')",
FeatName.c_str(), FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.Symbol = svg", FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.addView(App.activeDocument().%s)", PageName.c_str(),
FeatName.c_str());
}
else {
std::string FeatName = getUniqueObjectName("Image");
filename = Base::Tools::escapeEncodeFilename(filename);
openCommand(QT_TRANSLATE_NOOP("Command", "Create Image"));
doCommand(Doc, "App.activeDocument().addObject('TechDraw::DrawViewImage', '%s')", FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.translateLabel('DrawViewImage', 'Image', '%s')",
FeatName.c_str(), FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.ImageFile = '%s'", FeatName.c_str(), filename.toUtf8().constData());
doCommand(Doc, "App.activeDocument().%s.addView(App.activeDocument().%s)", PageName.c_str(), FeatName.c_str());
updateActive();
commitCommand();
}
updateActive();
commitCommand();
}
}
return;
}
TechDraw::DrawPage* page = DrawGuiUtil::findPage(this);
if (!page) {
return;
}
std::string PageName = page->getNameInDocument();
Base::Vector3d projDir;
Gui::WaitCursor wc;
openCommand(QT_TRANSLATE_NOOP("Command", "Create view"));
std::string FeatName = getUniqueObjectName("View");
doCommand(Doc, "App.activeDocument().addObject('TechDraw::DrawViewPart', '%s')",
FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.translateLabel('DrawViewPart', 'View', '%s')",
FeatName.c_str(), FeatName.c_str());
doCommand(Doc, "App.activeDocument().addObject('TechDraw::DrawProjGroupItem', '%s')",
FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.translateLabel('DrawProjGroupItem', 'View', '%s')",
FeatName.c_str(), FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.addView(App.activeDocument().%s)", PageName.c_str(),
FeatName.c_str());
FeatName.c_str());
App::DocumentObject* docObj = getDocument()->getObject(FeatName.c_str());
TechDraw::DrawViewPart* dvp = dynamic_cast<TechDraw::DrawViewPart*>(docObj);
auto* dvp = dynamic_cast<TechDraw::DrawViewPart*>(docObj);
if (!dvp) {
throw Base::TypeError("CmdTechDrawView DVP not found\n");
}
dvp->Source.setValues(shapes);
dvp->XSource.setValues(xShapes);
if (!faceName.empty()) {
std::pair<Base::Vector3d, Base::Vector3d> dirs =
DrawGuiUtil::getProjDirFromFace(partObj, faceName);
projDir = dirs.first;
getDocument()->setStatus(App::Document::Status::SkipRecompute, true);
doCommand(Doc, "App.activeDocument().%s.Direction = FreeCAD.Vector(%.12f, %.12f, %.12f)",
FeatName.c_str(), projDir.x, projDir.y, projDir.z);
//do something clever with dirs.second;
// dvp->setXDir(dirs.second);
doCommand(Doc, "App.activeDocument().%s.XDirection = FreeCAD.Vector(%.12f, %.12f, %.12f)",
FeatName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
doCommand(Doc, "App.activeDocument().%s.recompute()", FeatName.c_str());
getDocument()->setStatus(App::Document::Status::SkipRecompute, false);
}
else {
std::pair<Base::Vector3d, Base::Vector3d> dirs = DrawGuiUtil::get3DDirAndRot();
projDir = dirs.first;
getDocument()->setStatus(App::Document::Status::SkipRecompute, true);
doCommand(Doc, "App.activeDocument().%s.Direction = FreeCAD.Vector(%.12f, %.12f, %.12f)",
FeatName.c_str(), projDir.x, projDir.y, projDir.z);
doCommand(Doc, "App.activeDocument().%s.XDirection = FreeCAD.Vector(%.12f, %.12f, %.12f)",
FeatName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
// dvp->setXDir(dirs.second);
getDocument()->setStatus(App::Document::Status::SkipRecompute, false);
doCommand(Doc, "App.activeDocument().%s.recompute()", FeatName.c_str());
}
getDocument()->setStatus(App::Document::Status::SkipRecompute, true);
doCommand(Doc, "App.activeDocument().%s.Direction = FreeCAD.Vector(0.0, -1.0, 0.0)",
FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.RotationVector = FreeCAD.Vector(1.0, 0.0, 0.0)",
FeatName.c_str());
doCommand(Doc, "App.activeDocument().%s.XDirection = FreeCAD.Vector(1.0, 0.0, 0.0)",
FeatName.c_str());
getDocument()->setStatus(App::Document::Status::SkipRecompute, false);
doCommand(Doc, "App.activeDocument().%s.recompute()", FeatName.c_str());
commitCommand();
// create the rest of the desired views
Gui::Control().showDialog(new TaskDlgProjGroup(dvp, true));
}
bool CmdTechDrawView::isActive() { return DrawGuiUtil::needPage(this); }
@@ -1014,37 +1100,21 @@ void CmdTechDrawProjectionGroup::activated(int iMsg)
multiView->XSource.setValues(xShapes);
doCommand(Doc, "App.activeDocument().%s.addProjection('Front')", multiViewName.c_str());
if (!faceName.empty()) {
std::pair<Base::Vector3d, Base::Vector3d> dirs =
DrawGuiUtil::getProjDirFromFace(partObj, faceName);
getDocument()->setStatus(App::Document::Status::SkipRecompute, true);
doCommand(Doc,
"App.activeDocument().%s.Anchor.Direction = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.first.x, dirs.first.y, dirs.first.z);
doCommand(
Doc,
"App.activeDocument().%s.Anchor.RotationVector = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
doCommand(Doc,
"App.activeDocument().%s.Anchor.XDirection = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
getDocument()->setStatus(App::Document::Status::SkipRecompute, false);
}
else {
std::pair<Base::Vector3d, Base::Vector3d> dirs = DrawGuiUtil::get3DDirAndRot();
getDocument()->setStatus(App::Document::Status::SkipRecompute, true);
doCommand(Doc,
"App.activeDocument().%s.Anchor.Direction = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.first.x, dirs.first.y, dirs.first.z);
doCommand(
Doc,
"App.activeDocument().%s.Anchor.RotationVector = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
doCommand(Doc,
"App.activeDocument().%s.Anchor.XDirection = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
getDocument()->setStatus(App::Document::Status::SkipRecompute, false);
}
std::pair<Base::Vector3d, Base::Vector3d> dirs = !faceName.empty() ?
DrawGuiUtil::getProjDirFromFace(partObj, faceName)
: DrawGuiUtil::get3DDirAndRot();
getDocument()->setStatus(App::Document::Status::SkipRecompute, true);
doCommand(Doc,
"App.activeDocument().%s.Anchor.Direction = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.first.x, dirs.first.y, dirs.first.z);
doCommand(Doc,
"App.activeDocument().%s.Anchor.RotationVector = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
doCommand(Doc,
"App.activeDocument().%s.Anchor.XDirection = FreeCAD.Vector(%.12f, %.12f, %.12f)",
multiViewName.c_str(), dirs.second.x, dirs.second.y, dirs.second.z);
getDocument()->setStatus(App::Document::Status::SkipRecompute, false);
doCommand(Doc, "App.activeDocument().%s.Anchor.recompute()", multiViewName.c_str());
commitCommand();
@@ -1493,15 +1563,14 @@ void CmdTechDrawDraftView::activated(int iMsg)
std::string PageName = page->getNameInDocument();
std::pair<Base::Vector3d, Base::Vector3d> dirs = DrawGuiUtil::get3DDirAndRot();
for (std::vector<App::DocumentObject*>::iterator it = objects.begin(); it != objects.end();
++it) {
if ((*it)->isDerivedFrom(TechDraw::DrawPage::getClassTypeId()) ||
(*it)->isDerivedFrom(TechDraw::DrawView::getClassTypeId())) {
for (auto* obj : objects) {
if (obj->isDerivedFrom(TechDraw::DrawPage::getClassTypeId()) ||
obj->isDerivedFrom(TechDraw::DrawView::getClassTypeId())) {
// skip over TechDraw objects as they are not valid subjects for a DraftView
continue;
}
std::string FeatName = getUniqueObjectName("DraftView");
std::string SourceName = (*it)->getNameInDocument();
std::string SourceName = obj->getNameInDocument();
openCommand(QT_TRANSLATE_NOOP("Command", "Create DraftView"));
doCommand(Doc, "App.activeDocument().addObject('TechDraw::DrawViewDraft', '%s')",
FeatName.c_str());

19
src/Mod/TechDraw/Gui/QGIProjGroup.cpp
View File

@@ -65,7 +65,7 @@ bool QGIProjGroup::sceneEventFilter(QGraphicsItem* watched, QEvent *event)
QGIView *qAnchor = getAnchorQItem();
if(qAnchor && watched == qAnchor) {
QGraphicsSceneMouseEvent *mEvent = dynamic_cast<QGraphicsSceneMouseEvent*>(event);
auto *mEvent = dynamic_cast<QGraphicsSceneMouseEvent*>(event);
switch(event->type()) {
case QEvent::GraphicsSceneMousePress:
@@ -99,23 +99,27 @@ QVariant QGIProjGroup::itemChange(GraphicsItemChange change, const QVariant &val
if(gView) {
TechDraw::DrawView *fView = gView->getViewObject();
if(fView->isDerivedFrom<TechDraw::DrawProjGroupItem>()) {
TechDraw::DrawProjGroupItem *projItemPtr = static_cast<TechDraw::DrawProjGroupItem *>(fView);
auto *projItemPtr = static_cast<TechDraw::DrawProjGroupItem *>(fView);
QString type = QString::fromLatin1(projItemPtr->Type.getValueAsString());
if (type == QString::fromLatin1("Front")) {
gView->alignTo(m_origin, QString::fromLatin1("None"));
installSceneEventFilter(gView);
} else if ( type == QString::fromLatin1("Top") ||
}
else if ( type == QString::fromLatin1("Top") ||
type == QString::fromLatin1("Bottom")) {
gView->alignTo(m_origin, QString::fromLatin1("Vertical"));
} else if ( type == QString::fromLatin1("Left") ||
}
else if ( type == QString::fromLatin1("Left") ||
type == QString::fromLatin1("Right") ||
type == QString::fromLatin1("Rear") ) {
gView->alignTo(m_origin, QString::fromLatin1("Horizontal"));
} else if ( type == QString::fromLatin1("FrontTopRight") ||
}
else if ( type == QString::fromLatin1("FrontTopRight") ||
type == QString::fromLatin1("FrontBottomLeft") ) {
gView->alignTo(m_origin, QString::fromLatin1("45slash"));
} else if ( type == QString::fromLatin1("FrontTopLeft") ||
}
else if ( type == QString::fromLatin1("FrontTopLeft") ||
type == QString::fromLatin1("FrontBottomRight") ) {
gView->alignTo(m_origin, QString::fromLatin1("45backslash"));
}
@@ -158,7 +162,8 @@ void QGIProjGroup::mouseReleaseEvent(QGraphicsSceneMouseEvent * event)
event->ignore();
qAnchor->mouseReleaseEvent(event);
}
} else if(scene() && qAnchor) {
}
else if(scene() && qAnchor) {
// End of Drag
getViewObject()->setPosition(Rez::appX(x()), Rez::appX(getY()));
}

1
src/Mod/TechDraw/Gui/Resources/TechDraw.qrc
View File

@@ -87,6 +87,7 @@
<file>icons/TechDraw_3PtAngleDimension.svg</file>
<file>icons/TechDraw_AngleDimension.svg</file>
<file>icons/TechDraw_Balloon.svg</file>
<file>icons/TechDraw_CameraOrientation.svg</file>
<file>icons/TechDraw_DiameterDimension.svg</file>
<file>icons/TechDraw_Dimension.svg</file>
<file>icons/TechDraw_DimensionRepair.svg</file>

195
src/Mod/TechDraw/Gui/Resources/icons/TechDraw_CameraOrientation.svg Normal file
View File

@@ -0,0 +1,195 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
width="64"
height="64"
viewBox="0 0 64 64"
version="1.1"
id="svg142"
style="fill:none;stroke:#000000;stroke-width:2;stroke-linecap:round;stroke-linejoin:round"
sodipodi:docname="TechDraw_CameraOrientation.svg"
inkscape:version="1.1-beta1 (77e7b44db3, 2021-03-28)"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns="http://www.w3.org/2000/svg"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:dc="http://purl.org/dc/elements/1.1/">
<sodipodi:namedview
id="namedview19"
pagecolor="#505050"
bordercolor="#eeeeee"
borderopacity="1"
objecttolerance="10.0"
gridtolerance="10.0"
guidetolerance="10.0"
inkscape:pageshadow="0"
inkscape:pageopacity="0"
inkscape:pagecheckerboard="0"
showgrid="false"
inkscape:zoom="11.765625"
inkscape:cx="32"
inkscape:cy="32"
inkscape:window-width="3840"
inkscape:window-height="1571"
inkscape:window-x="-9"
inkscape:window-y="-9"
inkscape:window-maximized="1"
inkscape:current-layer="svg142" />
<metadata
id="metadata148">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
</cc:Work>
</rdf:RDF>
</metadata>
<defs
id="defs146">
<linearGradient
id="linearGradient1328">
<stop
id="stop1324"
offset="0"
style="stop-color:#ffffff;stop-opacity:1" />
<stop
id="stop1326"
offset="1"
style="stop-color:#16d0d2;stop-opacity:0;" />
</linearGradient>
<linearGradient
id="linearGradient1310">
<stop
style="stop-color:#06989a;stop-opacity:1"
offset="0"
id="stop1306" />
<stop
style="stop-color:#34e0e2;stop-opacity:1"
offset="1"
id="stop1308" />
</linearGradient>
<linearGradient
xlink:href="#linearGradient1310"
id="linearGradient1312"
x1="57.636765"
y1="50.225197"
x2="5.834971"
y2="19.189537"
gradientUnits="userSpaceOnUse" />
<radialGradient
xlink:href="#linearGradient1328"
id="radialGradient1322"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(0.71743104,0.00748738,-0.00738849,0.70797021,9.3050603,6.5739852)"
cx="32"
cy="35.575535"
fx="32"
fy="35.575535"
r="16" />
<linearGradient
gradientTransform="matrix(1.0625,0,0,1.1065089,-87.687497,0.78106561)"
gradientUnits="userSpaceOnUse"
y2="30"
x2="99"
y1="45.629101"
x1="102.22456"
id="linearGradient4001"
xlink:href="#linearGradient3995" />
<linearGradient
id="linearGradient3995">
<stop
id="stop3997"
offset="0"
style="stop-color:#16d0d2;stop-opacity:1" />
<stop
id="stop3999"
offset="1"
style="stop-color:#34e0e2;stop-opacity:1" />
</linearGradient>
<linearGradient
gradientTransform="matrix(1.0625,0,0,1.1065089,-87.687497,0.78106561)"
gradientUnits="userSpaceOnUse"
y2="30"
x2="115"
y1="43"
x1="121"
id="linearGradient4027"
xlink:href="#linearGradient4029" />
<linearGradient
id="linearGradient4029">
<stop
style="stop-color:#06989a;stop-opacity:1"
offset="0"
id="stop4031" />
<stop
style="stop-color:#16d0d2;stop-opacity:1"
offset="1"
id="stop4033" />
</linearGradient>
</defs>
<circle
style="opacity:1;vector-effect:none;fill:none;fill-opacity:1;stroke:#06989a;stroke-width:2.61091852;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
id="path907"
cx="-14.782197"
cy="31.832508"
rx="11.694541"
ry="12.694541" />
<g
id="g1166"
transform="matrix(0.59922184,0,0,0.59922184,26.083865,-4.6624405)">
<path
id="path138"
d="m 60.689917,49.407377 a 5.2163485,4.9735365 0 0 1 -5.216349,4.973537 H 8.5264316 A 5.2163485,4.9735365 0 0 1 3.310083,49.407377 V 22.052926 A 5.2163485,4.9735365 0 0 1 8.5264316,17.079389 H 18.959129 l 5.216348,-7.4603035 h 15.649046 l 5.216348,7.4603035 h 10.432697 a 5.2163485,4.9735365 0 0 1 5.216349,4.973537 z"
style="fill:url(#linearGradient1312);fill-opacity:1;stroke:#000000;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none" />
<g
transform="translate(0,4)"
id="g1160">
<circle
cx="32"
cy="32"
id="circle140"
style="fill:url(#radialGradient1322);fill-opacity:1;stroke:#000000;stroke-width:3;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
r="14" />
<ellipse
style="opacity:1;vector-effect:none;fill:none;fill-opacity:1;stroke:#06989a;stroke-width:1.78571;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1"
id="path351"
cx="32"
cy="32"
rx="11.607143"
ry="11.607142" />
</g>
</g>
<g
transform="translate(-6.7915007,7.2164799)"
id="g421">
<path
style="fill:url(#linearGradient4001);fill-opacity:1;stroke:#042a2a;stroke-width:2;stroke-linecap:round;stroke-linejoin:round;stroke-opacity:1"
d="M 9,49.769231 V 28.846153 l 18.307692,5.230771 V 55 Z"
id="path3185" />
<path
style="fill:#34e0e2;stroke:#042a2a;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-opacity:1"
d="M 9,28.846153 24.692308,21 43.000001,26.230769 27.307692,34.076924 Z"
id="path3973" />
<path
style="fill:url(#linearGradient4027);fill-opacity:1;stroke:#042a2a;stroke-width:2;stroke-linecap:butt;stroke-linejoin:round;stroke-opacity:1"
d="M 27.307692,34.076924 V 55 L 43.000001,47.153847 V 26.230769 Z"
id="path3975" />
<path
style="fill:none;stroke:#34e0e2;stroke-width:2;stroke-linecap:round;stroke-linejoin:miter;stroke-opacity:1"
d="M 10.999999,48.247271 V 31.536724 l 14.224332,4.001147 0.0875,16.81772 z"
id="path3185-7" />
<path
style="fill:none;stroke:#16d0d2;stroke-width:2;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
d="M 29.290031,35.305198 29.27232,51.999998 41,46.247429 40.960479,29.607759 Z"
id="path3975-4" />
</g>
<path
style="fill:none;stroke:#e12929;stroke-width:2;stroke-linecap:round;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:4, 4;stroke-dashoffset:0;stroke-opacity:1"
d="M 44.961487,16.828685 24.903055,36.802124"
id="path908"
sodipodi:nodetypes="cc" />
</svg>
Side by Side

After

Width:  |  Height:  |  Size: 6.9 KiB

355
src/Mod/TechDraw/Gui/Resources/icons/actions/TechDraw_View.svg
View File

File diff suppressed because one or more lines are too long
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 18 KiB

After

Width:  |  Height:  |  Size: 11 KiB

599
src/Mod/TechDraw/Gui/TaskProjGroup.cpp
View File

@@ -25,8 +25,21 @@
#ifndef _PreComp_
# include <cmath>
# include <QMessageBox>
# include <QGroupBox>
# include <QVBoxLayout>
# include <QHBoxLayout>
# include <QLabel>
# include <QPushButton>
# include <QDialog>
# include <QScreen>
#endif // #ifndef _PreComp_
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <QDialog>
#include <App/Document.h>
#include <Base/Console.h>
#include <Base/Tools.h>
#include <Gui/Application.h>
@@ -34,39 +47,56 @@
#include <Gui/Command.h>
#include <Gui/Document.h>
#include <Gui/WaitCursor.h>
#include <Gui/QuantitySpinBox.h>
#include <Mod/TechDraw/App/DrawPage.h>
#include <Mod/TechDraw/App/DrawProjGroupItem.h>
#include <Mod/TechDraw/App/DrawView.h>
#include <Mod/TechDraw/App/DrawViewPart.h>
#include <Mod/TechDraw/App/DrawProjGroup.h>
#include <Mod/TechDraw/App/DrawProjGroupItem.h>
#include <Mod/TechDraw/App/DrawUtil.h>
#include "DrawGuiUtil.h"
#include "TaskProjGroup.h"
#include "ui_TaskProjGroup.h"
#include "MDIViewPage.h"
#include "ViewProviderPage.h"
#include "ViewProviderProjGroup.h"
#include "ViewProviderDrawingView.h"
#include "ViewProviderProjGroupItem.h"
using namespace Gui;
using namespace TechDraw;
using namespace TechDrawGui;
TaskProjGroup::TaskProjGroup(TechDraw::DrawProjGroup* featView, bool mode) :
TaskProjGroup::TaskProjGroup(TechDraw::DrawView* featView, bool mode) :
ui(new Ui_TaskProjGroup),
multiView(featView),
m_createMode(mode)
view(featView),
multiView(nullptr),
m_createMode(mode),
blockCheckboxes(false)
{
ui->setupUi(this);
blockUpdate = true;
multiView = dynamic_cast<TechDraw::DrawProjGroup*>(view);
updateUi();
ui->projection->setCurrentIndex(multiView->ProjectionType.getValue());
if (multiView) {
ui->projection->setCurrentIndex(multiView->ProjectionType.getValue());
ui->cbAutoDistribute->setChecked(multiView->AutoDistribute.getValue());
// disable if no AutoDistribute
ui->sbXSpacing->setEnabled(multiView->AutoDistribute.getValue());
ui->sbYSpacing->setEnabled(multiView->AutoDistribute.getValue());
ui->sbXSpacing->setValue(multiView->spacingX.getValue());
ui->sbYSpacing->setValue(multiView->spacingY.getValue());
}
setFractionalScale(multiView->getScale());
ui->cmbScaleType->setCurrentIndex(multiView->ScaleType.getValue());
setFractionalScale(view->getScale());
ui->cmbScaleType->setCurrentIndex(view->ScaleType.getValue());
//Allow or prevent scale changing initially
if (multiView->ScaleType.isValue("Custom")) {
if (view->ScaleType.isValue("Custom")) {
ui->sbScaleNum->setEnabled(true);
ui->sbScaleDen->setEnabled(true);
}
@@ -75,12 +105,6 @@ TaskProjGroup::TaskProjGroup(TechDraw::DrawProjGroup* featView, bool mode) :
ui->sbScaleDen->setEnabled(false);
}
ui->cbAutoDistribute->setChecked(multiView->AutoDistribute.getValue());
// disable if no AutoDistribute
ui->sbXSpacing->setEnabled(multiView->AutoDistribute.getValue());
ui->sbYSpacing->setEnabled(multiView->AutoDistribute.getValue());
ui->sbXSpacing->setValue(multiView->spacingX.getValue());
ui->sbYSpacing->setValue(multiView->spacingY.getValue());
// Initially toggle view checkboxes if needed
setupViewCheckboxes(true);
@@ -95,6 +119,10 @@ TaskProjGroup::TaskProjGroup(TechDraw::DrawProjGroup* featView, bool mode) :
connect(ui->butDownRotate, &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
connect(ui->butLeftRotate, &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
connect(ui->butCCWRotate, &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
connect(ui->butFront, &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
connect(ui->butCam, &QPushButton::clicked, this, &TaskProjGroup::rotateButtonClicked);
connect(ui->lePrimary, &QPushButton::clicked, this, &TaskProjGroup::customDirectionClicked);
// //Reset button
// connect(ui->butReset, SIGNAL(clicked()), this, SLOT(onResetClicked()));
@@ -120,36 +148,69 @@ TaskProjGroup::TaskProjGroup(TechDraw::DrawProjGroup* featView, bool mode) :
ui->sbXSpacing->setUnit(Base::Unit::Length);
ui->sbYSpacing->setUnit(Base::Unit::Length);
m_page = multiView->findParentPage();
m_page = view->findParentPage();
Gui::Document* activeGui = Gui::Application::Instance->getDocument(m_page->getDocument());
Gui::ViewProvider* vp = activeGui->getViewProvider(m_page);
ViewProviderPage* dvp = static_cast<ViewProviderPage*>(vp);
auto* dvp = static_cast<ViewProviderPage*>(vp);
m_mdi = dvp->getMDIViewPage();
setUiPrimary();
saveGroupState();
}
void TaskProjGroup::updateUi()
{
if (multiView) {
setWindowTitle(QObject::tr("Projection Group"));
ui->projection->show();
ui->cbAutoDistribute->show();
ui->sbXSpacing->show();
ui->sbYSpacing->show();
ui->label_7->show();
ui->label_10->show();
ui->label_11->show();
}
else {
setWindowTitle(QObject::tr("Part View"));
ui->projection->hide();
ui->cbAutoDistribute->hide();
ui->sbXSpacing->hide();
ui->sbYSpacing->hide();
ui->label_7->hide();
ui->label_10->hide();
ui->label_11->hide();
// if the view is not a proj group item, then we disable secondary projs.
auto* dpgi = dynamic_cast<TechDraw::DrawProjGroupItem*>(view);
if (!dpgi) {
ui->secondaryProjGroupbox->hide();
}
}
}
void TaskProjGroup::saveGroupState()
{
// Base::Console().Message("TPG::saveGroupState()\n");
if (!multiView)
if (!view)
return;
m_saveSource = multiView->Source.getValues();
m_saveProjType = multiView->ProjectionType.getValueAsString();
m_saveScaleType = multiView->ScaleType.getValueAsString();
m_saveScale = multiView->Scale.getValue();
m_saveAutoDistribute = multiView->AutoDistribute.getValue();
m_saveSpacingX = multiView->spacingX.getValue();
m_saveSpacingY = multiView->spacingY.getValue();
DrawProjGroupItem* anchor = multiView->getAnchor();
m_saveDirection = anchor->Direction.getValue();
m_saveScaleType = view->ScaleType.getValueAsString();
m_saveScale = view->Scale.getValue();
for( const auto it : multiView->Views.getValues() ) {
auto view( dynamic_cast<DrawProjGroupItem *>(it) );
if (view) {
m_saveViewNames.emplace_back(view->Type.getValueAsString());
if (multiView) {
m_saveSource = multiView->Source.getValues();
m_saveProjType = multiView->ProjectionType.getValueAsString();
m_saveAutoDistribute = multiView->AutoDistribute.getValue();
m_saveSpacingX = multiView->spacingX.getValue();
m_saveSpacingY = multiView->spacingY.getValue();
DrawProjGroupItem* anchor = multiView->getAnchor();
m_saveDirection = anchor->Direction.getValue();
for( const auto it : multiView->Views.getValues() ) {
auto view( dynamic_cast<DrawProjGroupItem *>(it) );
if (view) {
m_saveViewNames.emplace_back(view->Type.getValueAsString());
}
}
}
}
@@ -158,19 +219,22 @@ void TaskProjGroup::saveGroupState()
void TaskProjGroup::restoreGroupState()
{
Base::Console().Message("TPG::restoreGroupState()\n");
if (!multiView)
if (!view)
return;
multiView->ProjectionType.setValue(m_saveProjType.c_str());
multiView->ScaleType.setValue(m_saveScaleType.c_str());
multiView->Scale.setValue(m_saveScale);
multiView->AutoDistribute.setValue(m_saveAutoDistribute);
multiView->spacingX.setValue(m_saveSpacingX);
multiView->spacingY.setValue(m_saveSpacingY);
multiView->purgeProjections();
for(auto & sv : m_saveViewNames) {
if (sv != "Front") {
multiView->addProjection(sv.c_str());
view->ScaleType.setValue(m_saveScaleType.c_str());
view->Scale.setValue(m_saveScale);
if (multiView) {
multiView->ProjectionType.setValue(m_saveProjType.c_str());
multiView->AutoDistribute.setValue(m_saveAutoDistribute);
multiView->spacingX.setValue(m_saveSpacingX);
multiView->spacingY.setValue(m_saveSpacingY);
multiView->purgeProjections();
for(auto & sv : m_saveViewNames) {
if (sv != "Front") {
multiView->addProjection(sv.c_str());
}
}
}
}
@@ -180,42 +244,225 @@ void TaskProjGroup::viewToggled(bool toggle)
Gui::WaitCursor wc;
bool changed = false;
// Obtain name of checkbox
QString viewName = sender()->objectName();
int index = viewName.mid(7).toInt();
int index = sender()->objectName().mid(7).toInt();
const char *viewNameCStr = viewChkIndexToCStr(index);
if ( toggle && !multiView->hasProjection( viewNameCStr ) ) {
if (!blockCheckboxes) {
if (multiView) {
// Check if only front is left. If so switch to normal view.
if (multiView->Views.getValues().size() == 2 && !toggle) {
turnProjGroupToView();
wc.restoreCursor();
return;
}
}
else {
// If toggle then we remove the view object and create a proj group instead.
turnViewToProjGroup();
}
}
if (toggle && !multiView->hasProjection(viewNameCStr)) {
Gui::Command::doCommand(Gui::Command::Doc,
"App.activeDocument().%s.addProjection('%s')",
multiView->getNameInDocument(), viewNameCStr);
changed = true;
} else if ( !toggle && multiView->hasProjection( viewNameCStr ) ) {
}
else if (!toggle && multiView->hasProjection(viewNameCStr)) {
if (multiView->canDelete(viewNameCStr)) {
multiView->removeProjection( viewNameCStr );
changed = true;
}
}
if (changed) {
if (multiView->ScaleType.isValue("Automatic")) {
double scale = multiView->getScale();
if (view->ScaleType.isValue("Automatic")) {
double scale = view->getScale();
setFractionalScale(scale);
}
multiView->recomputeFeature();
view->recomputeFeature();
}
wc.restoreCursor();
}
void TaskProjGroup::turnViewToProjGroup()
{
App::Document* doc = view->getDocument();
std::string multiViewName = doc->getUniqueObjectName("ProjGroup");
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().addObject('TechDraw::DrawProjGroup', '%s')", multiViewName.c_str());
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.addView(App.activeDocument().%s)", view->findParentPage()->getNameInDocument(), multiViewName.c_str());
auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
m_page->removeView(viewPart);
multiView = static_cast<TechDraw::DrawProjGroup*>(doc->getObject(multiViewName.c_str()));
multiView->Source.setValues(viewPart->Source.getValues());
multiView->XSource.setValues(viewPart->XSource.getValues());
multiView->X.setValue(viewPart->X.getValue());
multiView->Y.setValue(viewPart->Y.getValue());
multiView->Scale.setValue(viewPart->Scale.getValue());
multiView->ScaleType.setValue(viewPart->ScaleType.getValue());
viewPart->X.setValue(0.0);
viewPart->Y.setValue(0.0);
viewPart->ScaleType.setValue("Custom");
viewPart->Scale.setStatus(App::Property::Hidden, true);
viewPart->ScaleType.setStatus(App::Property::Hidden, true);
viewPart->Label.setValue("Front");
multiView->addView(viewPart);
multiView->Anchor.setValue(view);
multiView->Anchor.purgeTouched();
viewPart->LockPosition.setValue(true);
viewPart->LockPosition.setStatus(App::Property::ReadOnly, true); //Front should stay locked.
viewPart->LockPosition.purgeTouched();
multiView->requestPaint();//make sure the group object is on the Gui page
view = multiView;
updateUi();
}
void TaskProjGroup::turnProjGroupToView()
{
TechDraw::DrawViewPart* viewPart = multiView->getAnchor();
viewPart->Scale.setValue(multiView->Scale.getValue());
viewPart->ScaleType.setValue(multiView->ScaleType.getValue());
viewPart->Scale.setStatus(App::Property::Hidden, true);
viewPart->ScaleType.setStatus(App::Property::Hidden, true);
viewPart->Scale.purgeTouched();
viewPart->ScaleType.purgeTouched();
viewPart->Label.setValue("View");
viewPart->LockPosition.setValue(false);
viewPart->LockPosition.setStatus(App::Property::ReadOnly, false);
viewPart->LockPosition.purgeTouched();
viewPart->X.setValue(multiView->X.getValue());
viewPart->Y.setValue(multiView->Y.getValue());
m_page->addView(viewPart);
// remove viewPart from views before deleting the group.
multiView->removeView(viewPart);
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().removeObject('%s')", multiView->getNameInDocument());
Gui::Document* activeGui = Gui::Application::Instance->getDocument(m_page->getDocument());
auto* vp = static_cast<ViewProviderProjGroupItem*>(activeGui->getViewProvider(viewPart));
if (vp) {
vp->updateIcon();
}
viewPart->recomputeFeature();
view = viewPart;
multiView = nullptr;
updateUi();
}
void TaskProjGroup::customDirectionClicked()
{
auto* dirEditDlg = new DirectionEditDialog();
if (multiView) {
dirEditDlg->setDirection(multiView->getAnchor()->Direction.getValue());
dirEditDlg->setAngle(0.0);
}
else {
auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
dirEditDlg->setDirection(viewPart->Direction.getValue());
dirEditDlg->setAngle(0.0);
}
if (dirEditDlg->exec() == QDialog::Accepted) {
if (multiView) {
multiView->getAnchor()->Direction.setValue(dirEditDlg->getDirection());
multiView->spin(Base::toRadians(dirEditDlg->getAngle()));
}
else {
auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
viewPart->Direction.setValue(dirEditDlg->getDirection());
viewPart->spin(Base::toRadians(dirEditDlg->getAngle()));
}
setUiPrimary();
}
delete dirEditDlg;
}
void TaskProjGroup::rotateButtonClicked()
{
if ( multiView && ui ) {
if ( view && ui ) {
const QObject *clicked = sender();
//change Front View Dir by 90
if ( clicked == ui->butTopRotate ) multiView->rotate("Up");
else if (clicked == ui->butDownRotate) multiView->rotate("Down");
else if (clicked == ui->butRightRotate) multiView->rotate("Right");
else if (clicked == ui->butLeftRotate) multiView->rotate("Left");
else if (clicked == ui->butCWRotate ) multiView->spin("CW");
else if (clicked == ui->butCCWRotate) multiView->spin("CCW");
auto handleCameraButton = [&]() {
std::string faceName;
App::DocumentObject* obj = nullptr;
auto selection = Gui::Command::getSelection().getSelectionEx();
for (auto& sel : selection) {
for (auto& sub : sel.getSubNames()) {
if (TechDraw::DrawUtil::getGeomTypeFromName(sub) == "Face") {
obj = sel.getObject();
faceName = sub;
break;
}
}
if (!faceName.empty()) {
break;
}
}
std::pair<Base::Vector3d, Base::Vector3d> dirs = !faceName.empty() ?
DrawGuiUtil::getProjDirFromFace(obj, faceName)
: DrawGuiUtil::get3DDirAndRot();
return dirs;
};
if (multiView) {
//change Front View Dir by 90
if (clicked == ui->butTopRotate) multiView->rotate("Up");
else if (clicked == ui->butDownRotate) multiView->rotate("Down");
else if (clicked == ui->butRightRotate) multiView->rotate("Right");
else if (clicked == ui->butLeftRotate) multiView->rotate("Left");
else if (clicked == ui->butCWRotate) multiView->spin("CW");
else if (clicked == ui->butCCWRotate) multiView->spin("CCW");
else if (clicked == ui->butFront) {
multiView->getAnchor()->Direction.setValue(Base::Vector3d(0.0, -1.0, 0.0));
multiView->getAnchor()->RotationVector.setValue(Base::Vector3d(1.0, 0.0, 0.0));
multiView->getAnchor()->XDirection.setValue(Base::Vector3d(1.0, 0.0, 0.0));
multiView->updateSecondaryDirs();
}
else if (clicked == ui->butCam) {
std::pair<Base::Vector3d, Base::Vector3d> dirs = handleCameraButton();
multiView->getAnchor()->Direction.setValue(dirs.first);
multiView->getAnchor()->RotationVector.setValue(dirs.second);
multiView->getAnchor()->XDirection.setValue(dirs.second);
multiView->updateSecondaryDirs();
}
}
else {
auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
if (clicked == ui->butTopRotate) viewPart->rotate("Up");
else if (clicked == ui->butDownRotate) viewPart->rotate("Down");
else if (clicked == ui->butRightRotate) viewPart->rotate("Right");
else if (clicked == ui->butLeftRotate) viewPart->rotate("Left");
else if (clicked == ui->butCWRotate) viewPart->spin("CW");
else if (clicked == ui->butCCWRotate) viewPart->spin("CCW");
else if (clicked == ui->butFront) {
viewPart->Direction.setValue(Base::Vector3d(0.0,-1.0,0.0));
viewPart->XDirection.setValue(Base::Vector3d(1.0, 0.0, 0.0));
viewPart->recomputeFeature();
}
else if (clicked == ui->butCam) {
std::pair<Base::Vector3d, Base::Vector3d> dirs = handleCameraButton();
viewPart->Direction.setValue(dirs.first);
viewPart->XDirection.setValue(dirs.second);
viewPart->recomputeFeature();
}
}
setUiPrimary();
}
@@ -224,19 +471,22 @@ void TaskProjGroup::rotateButtonClicked()
//void TaskProjGroup::projectionTypeChanged(int index)
void TaskProjGroup::projectionTypeChanged(QString qText)
{
if(blockUpdate) {
if(blockUpdate || !multiView) {
return;
}
if (qText == QString::fromUtf8("Page")) {
multiView->ProjectionType.setValue("Default");
} else {
}
else {
std::string text = qText.toStdString();
multiView->ProjectionType.setValue(text.c_str());
}
// Update checkboxes so checked state matches the drawing
blockCheckboxes = true;
setupViewCheckboxes();
blockCheckboxes = false;
// set the tooltips of the checkboxes
ui->chkView0->setToolTip(getToolTipForBox(0));
@@ -250,7 +500,7 @@ void TaskProjGroup::projectionTypeChanged(QString qText)
ui->chkView8->setToolTip(getToolTipForBox(8));
ui->chkView9->setToolTip(getToolTipForBox(9));
multiView->recomputeFeature();
view->recomputeFeature();
}
void TaskProjGroup::scaleTypeChanged(int index)
@@ -264,33 +514,35 @@ void TaskProjGroup::scaleTypeChanged(int index)
if (index == 0) {
// Document Scale Type
multiView->ScaleType.setValue("Page");
} else if (index == 1) {
view->ScaleType.setValue("Page");
}
else if (index == 1) {
// Automatic Scale Type
//block recompute
multiView->ScaleType.setValue("Automatic");
double autoScale = multiView->autoScale();
multiView->Scale.setValue(autoScale);
view->ScaleType.setValue("Automatic");
double autoScale = view->autoScale();
view->Scale.setValue(autoScale);
//unblock recompute
} else if (index == 2) {
}
else if (index == 2) {
// Custom Scale Type
//block recompute
multiView->ScaleType.setValue("Custom");
view->ScaleType.setValue("Custom");
ui->sbScaleNum->setEnabled(true);
ui->sbScaleDen->setEnabled(true);
int a = ui->sbScaleNum->value();
int b = ui->sbScaleDen->value();
double scale = (double) a / (double) b;
multiView->Scale.setValue(scale);
view->Scale.setValue(scale);
//unblock recompute
}
}
void TaskProjGroup::AutoDistributeClicked(bool clicked)
{
if (blockUpdate) {
if (blockUpdate || !multiView) {
return;
}
multiView->AutoDistribute.setValue(clicked);
@@ -299,7 +551,7 @@ void TaskProjGroup::AutoDistributeClicked(bool clicked)
void TaskProjGroup::spacingChanged()
{
if (blockUpdate) {
if (blockUpdate || !multiView) {
return;
}
multiView->spacingX.setValue(ui->sbXSpacing->value().getValue());
@@ -311,10 +563,10 @@ void TaskProjGroup::updateTask()
{
// Update the scale type
blockUpdate = true;
ui->cmbScaleType->setCurrentIndex(multiView->ScaleType.getValue());
ui->cmbScaleType->setCurrentIndex(view->ScaleType.getValue());
// Update the scale value
setFractionalScale(multiView->getScale());
setFractionalScale(view->getScale());
blockUpdate = false;
}
@@ -336,7 +588,7 @@ void TaskProjGroup::scaleManuallyChanged(int unused)
Q_UNUSED(unused);
if(blockUpdate)
return;
if (!multiView->ScaleType.isValue("Custom")) { //ignore if not custom!
if (!view->ScaleType.isValue("Custom")) { //ignore if not custom!
return;
}
@@ -345,9 +597,9 @@ void TaskProjGroup::scaleManuallyChanged(int unused)
double scale = (double) a / (double) b;
Gui::Command::doCommand(Gui::Command::Doc, "App.activeDocument().%s.Scale = %f", multiView->getNameInDocument()
Gui::Command::doCommand(Gui::Command::Doc, "App.activeDocument().%s.Scale = %f", view->getNameInDocument()
, scale);
multiView->recomputeFeature();
view->recomputeFeature();
}
void TaskProjGroup::changeEvent(QEvent *event)
@@ -366,9 +618,8 @@ const char * TaskProjGroup::viewChkIndexToCStr(int index)
// First Angle: FBRight B FBL
// Right F L Rear
// FTRight T FTL
assert (multiView);
bool thirdAngle = multiView->usedProjectionType().isValue("Third Angle");
bool thirdAngle = multiView ? multiView->usedProjectionType().isValue("Third Angle") : false;
switch(index) {
case 0: return (thirdAngle ? "FrontTopLeft" : "FrontBottomRight");
case 1: return (thirdAngle ? "Top" : "Bottom");
@@ -386,7 +637,7 @@ const char * TaskProjGroup::viewChkIndexToCStr(int index)
QString TaskProjGroup::getToolTipForBox(int boxNumber)
{
bool thirdAngle = multiView->usedProjectionType().isValue("Third Angle");
bool thirdAngle = multiView ? multiView->usedProjectionType().isValue("Third Angle") : false;
switch(boxNumber) {
case 0: {return (thirdAngle ? tr("FrontTopLeft") : tr("FrontBottomRight")); break;}
case 1: {return (thirdAngle ? tr("Top") : tr("Bottom")); break;}
@@ -404,7 +655,7 @@ QString TaskProjGroup::getToolTipForBox(int boxNumber)
void TaskProjGroup::setupViewCheckboxes(bool addConnections)
{
if (!multiView)
if (!view)
return;
// There must be a better way to construct this list...
@@ -419,29 +670,45 @@ void TaskProjGroup::setupViewCheckboxes(bool addConnections)
ui->chkView8,
ui->chkView9 };
for (int i = 0; i < 10; ++i) {
QCheckBox *box = viewCheckboxes[i];
box->setToolTip(getToolTipForBox(i));
const char *viewStr = viewChkIndexToCStr(i);
if (!multiView) {
box->setCheckState(viewStr == "Front" ? Qt::Checked : Qt::Unchecked);
}
if (addConnections) {
connect(box, &QCheckBox::toggled, this, &TaskProjGroup::viewToggled);
}
const char *viewStr = viewChkIndexToCStr(i);
if (viewStr && multiView->hasProjection(viewStr)) {
box->setCheckState(Qt::Checked);
if (!multiView->canDelete(viewStr)) {
box->setEnabled(false);
if (multiView) {
if (viewStr && multiView->hasProjection(viewStr)) {
box->setCheckState(Qt::Checked);
if (!multiView->canDelete(viewStr)) {
box->setEnabled(false);
}
}
else {
box->setCheckState(Qt::Unchecked);
}
} else {
box->setCheckState(Qt::Unchecked);
}
box->setToolTip(getToolTipForBox(i));
}
}
void TaskProjGroup::setUiPrimary()
{
Base::Vector3d frontDir = multiView->getAnchorDirection();
Base::Vector3d frontDir;
if (multiView) {
frontDir = multiView->getAnchorDirection();
}
else {
auto* viewPart = static_cast<TechDraw::DrawViewPart*>(view);
if (viewPart) {
frontDir = viewPart->Direction.getValue();
}
}
ui->lePrimary->setText(formatVector(frontDir));
}
@@ -467,8 +734,10 @@ void TaskProjGroup::saveButtons(QPushButton* btnOK,
bool TaskProjGroup::apply()
{
// Base::Console().Message("TPG::apply()\n");
multiView->recomputeChildren();
multiView->recomputeFeature();
if (multiView) {
multiView->recomputeChildren();
}
view->recomputeFeature();
return true;
}
@@ -476,12 +745,14 @@ bool TaskProjGroup::apply()
bool TaskProjGroup::accept()
{
// Base::Console().Message("TPG::accept()\n");
Gui::Document* doc = Gui::Application::Instance->getDocument(multiView->getDocument());
Gui::Document* doc = Gui::Application::Instance->getDocument(view->getDocument());
if (!doc)
return false;
multiView->recomputeChildren();
multiView->recomputeFeature();
if (multiView) {
multiView->recomputeChildren();
}
view->recomputeFeature();
Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
@@ -490,28 +761,31 @@ bool TaskProjGroup::accept()
bool TaskProjGroup::reject()
{
Gui::Document* doc = Gui::Application::Instance->getDocument(multiView->getDocument());
Gui::Document* doc = Gui::Application::Instance->getDocument(view->getDocument());
if (!doc)
return false;
if (getCreateMode()) {
//remove the object completely from the document
std::string multiViewName = multiView->getNameInDocument();
std::string PageName = multiView->findParentPage()->getNameInDocument();
const char* viewName = view->getNameInDocument();
const char* PageName = view->findParentPage()->getNameInDocument();
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.purgeProjections()",
multiViewName.c_str());
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.removeView(App.activeDocument().%s)",
PageName.c_str(), multiViewName.c_str());
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().removeObject('%s')", multiViewName.c_str());
if (multiView) {
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.purgeProjections()",
viewName);
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().%s.removeView(App.activeDocument().%s)",
PageName, viewName);
}
Gui::Command::doCommand(Gui::Command::Gui, "App.activeDocument().removeObject('%s')", viewName);
Gui::Command::doCommand(Gui::Command::Gui, "Gui.ActiveDocument.resetEdit()");
} else {
}
else {
//set the DPG and its views back to entry state.
if (Gui::Command::hasPendingCommand()) {
Gui::Command::abortCommand();
// std::vector<std::string> undos = Gui::Application::Instance->activeDocument()->getUndoVector();
// Gui::Application::Instance->activeDocument()->undo(1);
// multiView->rebuildViewList();
// view->rebuildViewList();
// apply();
}
}
@@ -521,12 +795,12 @@ bool TaskProjGroup::reject()
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//TODO: Do we really need to hang on to the TaskDlgProjGroup in this class? IR
TaskDlgProjGroup::TaskDlgProjGroup(TechDraw::DrawProjGroup* featView, bool mode)
TaskDlgProjGroup::TaskDlgProjGroup(TechDraw::DrawView* featView, bool mode)
: TaskDialog()
, viewProvider(nullptr)
, multiView(featView)
, view(featView)
{
//viewProvider = dynamic_cast<const ViewProviderProjGroup *>(featView);
//viewProvider = dynamic_cast<const ViewProviderDrawingView *>(featView);
widget = new TaskProjGroup(featView, mode);
taskbox = new Gui::TaskView::TaskBox(Gui::BitmapFactory().pixmap("actions/TechDraw_ProjectionGroup"),
widget->windowTitle(), true, nullptr);
@@ -559,8 +833,13 @@ void TaskDlgProjGroup::modifyStandardButtons(QDialogButtonBox* box)
//==== calls from the TaskView ===============================================================
void TaskDlgProjGroup::open()
{
if (!widget->getCreateMode()) { //this is an edit session, start a transaction
App::GetApplication().setActiveTransaction("Edit Projection Group", true);
if (!widget->getCreateMode()) { //this is an edit session, start a transaction
if (dynamic_cast<TechDraw::DrawProjGroup*>(view)) {
App::GetApplication().setActiveTransaction("Edit Projection Group", true);
}
else {
App::GetApplication().setActiveTransaction("Edit Part View", true);
}
}
}
@@ -586,4 +865,106 @@ bool TaskDlgProjGroup::reject()
}
DirectionEditDialog::DirectionEditDialog(QWidget* parent) : QDialog(parent) {
setWindowFlags(Qt::Popup); // Make the dialog non-intrusive
createUI();
}
void DirectionEditDialog::setDirection(const Base::Vector3d& pos) {
xSpinBox->setValue(pos.x);
ySpinBox->setValue(pos.y);
zSpinBox->setValue(pos.z);
}
Base::Vector3d DirectionEditDialog::getDirection() const {
return Base::Vector3d(xSpinBox->value().getValue(), ySpinBox->value().getValue(), zSpinBox->value().getValue());
}
void DirectionEditDialog::setAngle(double val) {
angleSpinBox->setValue(val);
}
double DirectionEditDialog::getAngle() const {
return angleSpinBox->value().getValue();
}
void DirectionEditDialog::showEvent(QShowEvent* event) {
QDialog::showEvent(event);
// Calculate the position to ensure the dialog appears within the screen boundaries
QPoint cursorPos = QCursor::pos();
QSize screenSize = QApplication::primaryScreen()->size(); // Get the size of the primary screen
int x = cursorPos.x();
int y = cursorPos.y();
int dialogWidth = this->width();
int dialogHeight = this->height();
// Check if the dialog goes beyond the right edge of the screen
if (x + dialogWidth > screenSize.width()) {
x = screenSize.width() - dialogWidth;
}
// Check if the dialog goes beyond the bottom edge of the screen
if (y + dialogHeight > screenSize.height()) {
y = screenSize.height() - dialogHeight;
}
// Move the dialog to the calculated position
this->move(x, y);
}
void DirectionEditDialog::createUI() {
auto* directionGroup = new QGroupBox(tr("Direction"));
auto* directionLayout = new QVBoxLayout; // Use QVBoxLayout for vertical alignment
// Create layout and widgets for X
auto* xLayout = new QHBoxLayout;
auto* xLabel = new QLabel(tr("X: "));
xSpinBox = new Gui::QuantitySpinBox;
xSpinBox->setUnit(Base::Unit::Length);
xLayout->addWidget(xLabel);
xLayout->addWidget(xSpinBox);
// Create layout and widgets for Y
auto* yLayout = new QHBoxLayout;
auto* yLabel = new QLabel(tr("Y: "));
ySpinBox = new Gui::QuantitySpinBox;
ySpinBox->setUnit(Base::Unit::Length);
yLayout->addWidget(yLabel);
yLayout->addWidget(ySpinBox);
// Create layout and widgets for Z
auto* zLayout = new QHBoxLayout;
auto* zLabel = new QLabel(tr("Z: "));
zSpinBox = new Gui::QuantitySpinBox;
zSpinBox->setUnit(Base::Unit::Length);
zLayout->addWidget(zLabel);
zLayout->addWidget(zSpinBox);
// Add the layouts to the direction group
directionLayout->addLayout(xLayout);
directionLayout->addLayout(yLayout);
directionLayout->addLayout(zLayout);
directionGroup->setLayout(directionLayout);
angleSpinBox = new Gui::QuantitySpinBox;
angleSpinBox->setUnit(Base::Unit::Angle);
auto* buttonsLayout = new QHBoxLayout;
auto* okButton = new QPushButton(tr("OK"));
auto* cancelButton = new QPushButton(tr("Cancel"));
buttonsLayout->addWidget(okButton);
buttonsLayout->addWidget(cancelButton);
auto* mainLayout = new QVBoxLayout;
mainLayout->addWidget(directionGroup);
mainLayout->addWidget(new QLabel(tr("Rotate by")));
mainLayout->addWidget(angleSpinBox);
mainLayout->addLayout(buttonsLayout);
setLayout(mainLayout);
connect(okButton, &QPushButton::clicked, this, &QDialog::accept);
connect(cancelButton, &QPushButton::clicked, this, &QDialog::reject);
}
#include <Mod/TechDraw/Gui/moc_TaskProjGroup.cpp>

51
src/Mod/TechDraw/Gui/TaskProjGroup.h
View File

@@ -31,8 +31,12 @@
#include <Gui/TaskView/TaskView.h>
#include <Mod/TechDraw/TechDrawGlobal.h>
namespace Gui {
class QuantitySpinBox;
}
namespace TechDraw {
class DrawView;
class DrawProjGroup;
class DrawPage;
}
@@ -41,14 +45,14 @@ namespace TechDrawGui
{
class MDIViewPage;
class Ui_TaskProjGroup;
class ViewProviderProjGroup;
class ViewProviderDrawingView;
class TaskProjGroup : public QWidget
{
Q_OBJECT
public:
TaskProjGroup(TechDraw::DrawProjGroup* featView, bool mode);
TaskProjGroup(TechDraw::DrawView* featView, bool mode);
~TaskProjGroup() override = default;
virtual bool accept();
@@ -77,6 +81,10 @@ protected:
void setUiPrimary();
void saveGroupState();
void restoreGroupState();
void updateUi();
void turnViewToProjGroup();
void turnProjGroupToView();
QString formatVector(Base::Vector3d vec);
@@ -86,6 +94,8 @@ protected Q_SLOTS:
/// Requests appropriate rotation of our DrawProjGroup
void rotateButtonClicked();
void customDirectionClicked();
void projectionTypeChanged(QString qText);
void scaleTypeChanged(int index);
void AutoDistributeClicked(bool clicked);
@@ -98,10 +108,12 @@ private:
MDIViewPage* m_mdi;
std::unique_ptr<Ui_TaskProjGroup> ui;
TechDraw::DrawView* view;
TechDraw::DrawProjGroup* multiView;
bool m_createMode;
bool blockUpdate;
bool blockCheckboxes;
/// Translate a view checkbox index into represented view string, depending on projection type
const char * viewChkIndexToCStr(int index);
QString getToolTipForBox(int boxNumber);
@@ -126,11 +138,11 @@ class TaskDlgProjGroup : public Gui::TaskView::TaskDialog
Q_OBJECT
public:
TaskDlgProjGroup(TechDraw::DrawProjGroup* featView, bool mode);
TaskDlgProjGroup(TechDraw::DrawView* featView, bool mode);
~TaskDlgProjGroup() override;
const ViewProviderProjGroup * getViewProvider() const { return viewProvider; }
TechDraw::DrawProjGroup * getMultiView() const { return multiView; }
const ViewProviderDrawingView* getViewProvider() const { return viewProvider; }
TechDraw::DrawView* getView() const { return view; }
QDialogButtonBox::StandardButtons getStandardButtons() const override
{ return QDialogButtonBox::Ok | QDialogButtonBox::Apply | QDialogButtonBox::Cancel; }
@@ -152,14 +164,39 @@ public:
void update();
protected:
const ViewProviderProjGroup *viewProvider;
TechDraw::DrawProjGroup *multiView;
const ViewProviderDrawingView *viewProvider;
TechDraw::DrawView* view;
private:
TaskProjGroup * widget;
Gui::TaskView::TaskBox* taskbox;
};
class DirectionEditDialog : public QDialog {
Q_OBJECT
public:
explicit DirectionEditDialog(QWidget* parent = nullptr);
void setDirection(const Base::Vector3d& pos);
Base::Vector3d getDirection() const;
void setAngle(double val);
double getAngle() const;
protected:
void showEvent(QShowEvent* event) override;
private:
Gui::QuantitySpinBox* xSpinBox;
Gui::QuantitySpinBox* ySpinBox;
Gui::QuantitySpinBox* zSpinBox;
Gui::QuantitySpinBox* angleSpinBox;
void createUI();
};
} //namespace TechDrawGui
#endif // #ifndef GUI_TASKVIEW_TASKVIEWGROUP_H

1130
src/Mod/TechDraw/Gui/TaskProjGroup.ui
View File

File diff suppressed because it is too large Load Diff

7
src/Mod/TechDraw/Gui/ViewProviderPage.cpp
View File

@@ -275,7 +275,7 @@ bool ViewProviderPage::doubleClicked(void)
show();
if (m_mdiView) {
Gui::getMainWindow()->setActiveWindow(m_mdiView);
switchToMdiViewPage();
}
return true;
}
@@ -339,6 +339,11 @@ void ViewProviderPage::createMDIViewPage()
m_mdiView->setWindowTitle(tabTitle + QString::fromLatin1("[*]"));
m_mdiView->setWindowIcon(Gui::BitmapFactory().pixmap("TechDraw_TreePage"));
Gui::getMainWindow()->addWindow(m_mdiView);
switchToMdiViewPage();
}
void ViewProviderPage::switchToMdiViewPage()
{
Gui::getMainWindow()->setActiveWindow(m_mdiView);
m_graphicsView->setFocus();
}

1
src/Mod/TechDraw/Gui/ViewProviderPage.h
View File

@@ -107,6 +107,7 @@ public:
MDIViewPage* getMDIViewPage() const;
bool showMDIViewPage();
void removeMDIView();
void switchToMdiViewPage();
Gui::MDIView* getMDIView() const override;

7
src/Mod/TechDraw/Gui/ViewProviderPageExtension.cpp
View File

@@ -124,8 +124,11 @@ void ViewProviderPageExtension::extensionDropObject(App::DocumentObject* obj)
void ViewProviderPageExtension::dropObject(App::DocumentObject* obj)
{
if (obj->isDerivedFrom<TechDraw::DrawProjGroupItem>()) {
//DPGI can not be dropped onto the Page as it belongs to DPG, not Page
return;
//DPGI can not be dropped onto the Page if it belongs to DPG
auto* dpgi = static_cast<TechDraw::DrawProjGroupItem*>(obj);
if (dpgi->getPGroup()) {
return;
}
}
if (obj->isDerivedFrom<App::Link>()) {
auto* link = static_cast<App::Link*>(obj);

35
src/Mod/TechDraw/Gui/ViewProviderProjGroupItem.cpp
View File

@@ -54,17 +54,25 @@ ViewProviderProjGroupItem::~ViewProviderProjGroupItem()
void ViewProviderProjGroupItem::updateData(const App::Property* prop)
{
Gui::ViewProviderDocumentObject::updateData(prop);
//TODO: Once we know that ProjType is valid, sPixMap = "Proj" + projType
updateIcon();
}
void ViewProviderProjGroupItem::updateIcon()
{
TechDraw::DrawProjGroupItem* proj = getObject();
if(!proj) {
if (!proj) {
return;
}
// Set the icon pixmap depending on the orientation
std::string projType = proj->Type.getValueAsString();
//TODO: Once we know that ProjType is valid, sPixMap = "Proj" + projType
if(strcmp(projType.c_str(), "Front") == 0) {
if (!getObject()->getPGroup()) {
sPixmap = "TechDraw_TreeView";
} else if(strcmp(projType.c_str(), "Front") == 0) {
sPixmap = "TechDraw_ProjFront";
} else if(strcmp(projType.c_str(), "Rear") == 0) {
sPixmap = "TechDraw_ProjRear";
@@ -99,8 +107,9 @@ void ViewProviderProjGroupItem::setupContextMenu(QMenu* menu, QObject* receiver,
bool ViewProviderProjGroupItem::setEdit(int ModNum)
{
Q_UNUSED(ModNum);
doubleClicked();
if (!getObject()->getPGroup()) {
return ViewProviderViewPart::setEdit(ModNum);
}
return true;
}
@@ -112,6 +121,7 @@ void ViewProviderProjGroupItem::unsetEdit(int ModNum)
bool ViewProviderProjGroupItem::doubleClicked()
{
setEdit(ViewProvider::Default);
return true;
}
@@ -125,19 +135,16 @@ bool ViewProviderProjGroupItem::onDelete(const std::vector<std::string> &)
bool isAnchor = false;
// get the item and group
TechDraw::DrawProjGroupItem* dpgi = static_cast<TechDraw::DrawProjGroupItem*>(getViewObject());
TechDraw::DrawProjGroupItem* dpgi = getObject();
TechDraw::DrawProjGroup* dpg = dpgi->getPGroup();
// get the projection
TechDraw::DrawProjGroupItem* proj = getObject();
// check if it is the anchor projection
if (dpg && (dpg->hasProjection(proj->Type.getValueAsString()))
&& (dpg->getAnchor() == dpgi))
if (dpg && (dpg->getAnchor() == dpgi))
isAnchor = true;
// get child views
auto viewSection = getObject()->getSectionRefs();
auto viewDetail = getObject()->getDetailRefs();
auto viewLeader = getObject()->getLeaders();
auto viewSection = dpgi->getSectionRefs();
auto viewDetail = dpgi->getDetailRefs();
auto viewLeader = dpgi->getLeaders();
if (isAnchor)
{

1
src/Mod/TechDraw/Gui/ViewProviderProjGroupItem.h
View File

@@ -48,6 +48,7 @@ public:
bool doubleClicked() override;
void setupContextMenu(QMenu*, QObject*, const char*) override;
void updateData(const App::Property*) override;
void updateIcon();
TechDraw::DrawProjGroupItem* getViewObject() const override;
TechDraw::DrawProjGroupItem* getObject() const;

7
src/Mod/TechDraw/Gui/ViewProviderViewClip.cpp
View File

@@ -123,8 +123,11 @@ void ViewProviderViewClip::dragObject(App::DocumentObject* docObj)
void ViewProviderViewClip::dropObject(App::DocumentObject* docObj)
{
if (docObj->isDerivedFrom(TechDraw::DrawProjGroupItem::getClassTypeId())) {
//DPGI can not be dropped onto the Page as it belongs to DPG, not Page
return;
//DPGI can not be dropped onto the Page if it belongs to DPG
auto* dpgi = static_cast<TechDraw::DrawProjGroupItem*>(docObj);
if (dpgi->getPGroup()) {
return;
}
}
if (!docObj->isDerivedFrom(TechDraw::DrawView::getClassTypeId())) {
return;

11
src/Mod/TechDraw/Gui/ViewProviderViewPart.cpp
View File

@@ -56,6 +56,7 @@
#include "PreferencesGui.h"
#include "QGIView.h"
#include "TaskDetail.h"
#include "TaskProjGroup.h"
#include "ViewProviderViewPart.h"
#include "ViewProviderPage.h"
#include "QGIViewDimension.h"
@@ -264,6 +265,10 @@ bool ViewProviderViewPart::setEdit(int ModNum)
if (Gui::Control().activeDialog()) { //TaskPanel already open!
return false;
}
// clear the selection (convenience)
Gui::Selection().clearSelection();
TechDraw::DrawViewPart* dvp = getViewObject();
TechDraw::DrawViewDetail* dvd = dynamic_cast<TechDraw::DrawViewDetail*>(dvp);
if (dvd) {
@@ -271,13 +276,15 @@ bool ViewProviderViewPart::setEdit(int ModNum)
Base::Console().Error("DrawViewDetail - %s - has no BaseView!\n", dvd->getNameInDocument());
return false;
}
// clear the selection (convenience)
Gui::Selection().clearSelection();
Gui::Control().showDialog(new TaskDlgDetail(dvd));
Gui::Selection().clearSelection();
Gui::Selection().addSelection(dvd->getDocument()->getName(),
dvd->getNameInDocument());
}
else {
auto* view = dynamic_cast<TechDraw::DrawView*>(getObject());
Gui::Control().showDialog(new TaskDlgProjGroup(view, false));
}
return true;
}

9
src/Mod/TechDraw/Gui/Workbench.cpp
View File

@@ -294,12 +294,9 @@ Gui::ToolBarItem* Workbench::setupToolBars() const
*views << "TechDraw_View";
*views << "TechDraw_BrokenView";
*views << "TechDraw_ActiveView";
*views << "TechDraw_ProjectionGroup";
*views << "TechDraw_SectionGroup";
*views << "TechDraw_DetailView";
*views << "TechDraw_DraftView";
*views << "TechDraw_ArchView";
*views << "TechDraw_SpreadsheetView";
*views << "TechDraw_ClipGroup";
*views << "TechDraw_ProjectShape";
@@ -364,8 +361,6 @@ Gui::ToolBarItem* Workbench::setupToolBars() const
decor->setCommand("TechDraw Decoration");
*decor << "TechDraw_Hatch";
*decor << "TechDraw_GeometricHatch";
*decor << "TechDraw_Symbol";
*decor << "TechDraw_Image";
*decor << "TechDraw_ToggleFrame";
Gui::ToolBarItem* anno = new Gui::ToolBarItem(root);
@@ -401,11 +396,9 @@ Gui::ToolBarItem* Workbench::setupCommandBars() const
views->setCommand("Views");
*views << "TechDraw_View";
*views << "TechDraw_ActiveView";
*views << "TechDraw_ProjectionGroup";
*views << "TechDraw_SectionGroup";
*views << "TechDraw_DetailView";
*views << "TechDraw_DraftView";
*views << "TechDraw_SpreadsheetView";
*views << "TechDraw_ClipGroup";
*views << "TechDraw_ProjectShape";
@@ -470,8 +463,6 @@ Gui::ToolBarItem* Workbench::setupCommandBars() const
decor->setCommand("TechDraw Decoration");
*decor << "TechDraw_Hatch";
*decor << "TechDraw_GeometricHatch";
*decor << "TechDraw_Symbol";
*decor << "TechDraw_Image";
*decor << "TechDraw_ToggleFrame";
Gui::ToolBarItem* anno = new Gui::ToolBarItem(root);