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

Techdraw: Smart Dimension: Fixes and simplifies code

Browse Source
This commit is contained in:
PaddleStroke
2024-04-22 16:59:55 +02:00
parent 41650a78d4
commit cc393632e1
12 changed files with 306 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/Mod/TechDraw/App/DimensionFormatter.cpp
View File

@@ -91,9 +91,6 @@ std::string DimensionFormatter::formatValue(const qreal value,
QString qMultiValueStr;
QString qBasicUnit = Base::Tools::fromStdString(Base::UnitsApi::getBasicLengthUnit());
if (areaMeasure) {
qBasicUnit = qBasicUnit + QString::fromUtf8("²");
}
QString formattedValue;
if (isMultiValueSchema() && partial == 0) {
@@ -138,6 +135,10 @@ std::string DimensionFormatter::formatValue(const qreal value,
else {
double convertValue = Base::Quantity::parse(QString::fromLatin1("1") + qBasicUnit).getValue();
userVal = asQuantity.getValue() / convertValue;
if (areaMeasure) {
userVal = userVal / convertValue; // divide again as area is length²
qBasicUnit = qBasicUnit + QString::fromUtf8("²");
}
}
if (isTooSmall(userVal, formatSpecifier)) {

10
src/Mod/TechDraw/App/DimensionReferences.cpp
View File

@@ -265,15 +265,7 @@ Part::TopoShape ReferenceEntry::asTopoShapeEdge(const TopoDS_Edge &edge)
Part::TopoShape ReferenceEntry::asTopoShapeFace(const TopoDS_Face &face)
{
// Base::Console().Message("RE::asTopoShapeFace()\n");
TopoDS_Face unscaledFace = face;
if (!is3d()) {
// 2d reference - projected and scaled. scale might have changed, so we need to unscale
auto dvp = static_cast<TechDraw::DrawViewPart*>(getObject());
TopoDS_Shape unscaledShape = ShapeUtils::scaleShape(face, 1.0 / dvp->getScale());
unscaledFace = TopoDS::Face(unscaledShape);
}
return { unscaledFace };
return { face };
}
std::string ReferenceEntry::geomType() const

400
src/Mod/TechDraw/Gui/CommandCreateDims.cpp
View File

@@ -30,6 +30,7 @@
#include <QMessageBox>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QPoint>
#endif//#ifndef _PreComp_
#include <App/Document.h>
@@ -178,7 +179,7 @@ public:
: SelectionObserver(true)
, specialDimension(SpecialDimension::None)
, availableDimension(AvailableDimension::FIRST)
, previousPos(QPoint(0, 0))
, mousePos(QPoint(0, 0))
, selPoints({})
, selLine({})
, selCircleArc({})
@@ -218,6 +219,10 @@ public:
void activated() override
{
auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
if (mdi) {
mdi->setDimensionsSelectability(false);
}
Gui::Selection().setSelectionStyle(Gui::SelectionSingleton::SelectionStyle::GreedySelection);
Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Insert Dimension"));
handleInitialSelection();
@@ -225,6 +230,10 @@ public:
void deactivated() override
{
auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
if (mdi) {
mdi->setDimensionsSelectability(true);
}
Gui::Selection().setSelectionStyle(Gui::SelectionSingleton::SelectionStyle::NormalSelection);
Gui::Command::abortCommand();
}
@@ -247,7 +256,7 @@ public:
else if (availableDimension == AvailableDimension::FIFTH || availableDimension == AvailableDimension::RESET) {
availableDimension = AvailableDimension::FIRST;
}
makeAppropriateDimension(previousPos);
makeAppropriateDimension();
event->accept();
}
else if (event->key() == Qt::Key_Z && (QApplication::keyboardModifiers() & Qt::ControlModifier)) {
@@ -270,7 +279,7 @@ public:
void mouseMoveEvent(QMouseEvent* event) override
{
previousPos = event->pos();
mousePos = event->pos();
if (dims.empty()){
return;
@@ -280,13 +289,13 @@ public:
Base::Vector3d dirMaster, delta;
//Change distance dimension based on position of mouse.
if (specialDimension == SpecialDimension::LineOr2PointsDistance){
updateDistanceType(event->pos());
updateDistanceType();
}
else if (specialDimension == SpecialDimension::ExtendDistance){
updateExtentDistanceType(event->pos());
updateExtentDistanceType();
}
else if (specialDimension == SpecialDimension::ChainDistance || specialDimension == SpecialDimension::CoordDistance){
updateChainDistanceType(event->pos());
updateChainDistanceType();
textToMiddle = true;
pointPair pp = dims[0]->getLinearPoints();
dirMaster = pp.second() - pp.first();
@@ -301,7 +310,7 @@ public:
int i = 0;
for (auto* dim : dims) {
auto dimType = static_cast<DimensionType>(dim->Type.getValue());
moveDimension(event->pos(), dim, textToMiddle, dirMaster, delta, dimType, i);
moveDimension(mousePos, dim, textToMiddle, dirMaster, delta, dimType, i);
if (specialDimension == SpecialDimension::CoordDistance) {
i++;
@@ -321,7 +330,7 @@ public:
}
return qgivDimension->getDatumLabel();
}
void moveDimension(QPoint& pos, DrawViewDimension* dim, bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
void moveDimension(QPoint pos, DrawViewDimension* dim, bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
Base::Vector3d delta = Base::Vector3d(), DimensionType type = DimensionType::Distance, int i = 0)
{
if (!dim) { return; }
@@ -330,14 +339,14 @@ public:
label->setPos(getDimPositionToBe(pos, label->pos(), textToMiddle, dir, delta, type, i));
}
QPointF getDimPositionToBe(QPoint& pos, QPointF curPos = QPointF(), bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
QPointF getDimPositionToBe(QPoint pos, QPointF curPos = QPointF(), bool textToMiddle = false, Base::Vector3d dir = Base::Vector3d(),
Base::Vector3d delta = Base::Vector3d(), DimensionType type = DimensionType::Distance, int i = 0)
{
auto* vpp = dynamic_cast<ViewProviderDrawingView*>(Gui::Application::Instance->getViewProvider(partFeat));
if (!vpp) { return QPointF(); }
QPointF scenePos = viewPage->mapToScene(pos) - vpp->getQView()->pos();
QPointF scenePos = viewPage->mapToScene(pos) - vpp->getQView()->scenePos();
if (textToMiddle) {
// delta is for coord distances. i = 0 when it's a chain so delta is ignored.
@@ -383,86 +392,104 @@ public:
}
}
bool mousePressEvent(QMouseEvent* event) override
void setDimsSelectability(bool val)
{
if (event->button() == Qt::RightButton && !dims.empty()) {
Gui::Selection().clearSelection();
clearAndRestartCommand();
event->accept();
return true;
for (auto dim : dims) {
setDimSelectability(dim, val);
}
}
void setDimSelectability(DrawViewDimension* d, bool val)
{
QGIDatumLabel* label = getDimLabel(d);
if (label) {
label->setSelectability(val);
}
return TechDrawHandler::mousePressEvent(event);
}
bool mouseReleaseEvent(QMouseEvent* event) override
void mouseReleaseEvent(QMouseEvent* event) override
{
// Base::Console().Warning("mouseReleaseEvent TH\n");
bool finalize = true;
if (removedRef.hasGeometry()) {
finalize = false;
//Base::Console().Warning("RmvSelection \n");
// Remove the reference from the vector
ReferenceVector& selVector = getSelectionVector(removedRef);
selVector.erase(std::remove(selVector.begin(), selVector.end(), removedRef), selVector.end());
if (!selectionEmpty()) {
availableDimension = AvailableDimension::FIRST;
makeAppropriateDimension(event->pos());
}
else {
if (event->button() == Qt::RightButton) {
if (!dims.empty()) {
Gui::Selection().clearSelection();
clearAndRestartCommand();
}
removedRef = ReferenceEntry();
}
if (addedRef.hasGeometry()) {
finalize = false;
//Base::Console().Warning("AddSelection\n");
//add the geometry to its type vector. Temporarily if not selAllowed
if (addedRef.getSubName() == "") {
// Behavior deactivated for now because I found it annoying.
// To reactivate replace addedRef.hasGeometry() by addedRef.getObject() above.
// This means user selected the view itself.
if (selectionEmpty()) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", event->pos());
}
event->accept();
}
else {
ReferenceVector& selVector = getSelectionVector(addedRef);
selVector.push_back(addedRef);
TechDrawHandler::mouseReleaseEvent(event);
}
return;
}
else if (event->button() == Qt::LeftButton) {
mousePos = event->pos();
availableDimension = AvailableDimension::FIRST;
bool selAllowed = makeAppropriateDimension(event->pos());
bool finalize = true;
if (!selAllowed) {
// remove from selection
blockRemoveSel = true;
if (removedRef.hasGeometry()) {
finalize = false;
//Base::Console().Warning("RmvSelection \n");
// Remove the reference from the vector
ReferenceVector& selVector = getSelectionVector(removedRef);
selVector.erase(std::remove(selVector.begin(), selVector.end(), removedRef), selVector.end());
Gui::Selection().rmvSelection(addedRef.getObject()->getDocument()->getName(), addedRef.getObject()->getNameInDocument(), addedRef.getSubName().c_str());
blockRemoveSel = false;
if (!selectionEmpty()) {
availableDimension = AvailableDimension::FIRST;
makeAppropriateDimension();
}
else {
clearAndRestartCommand();
}
removedRef = ReferenceEntry();
}
if (selVector == selFaces) {
// if sel face and not allowed, then a dimension is being created
// and user clicked on a face to drop it.
// Better would be to disable face selectability when needed.
finalize = true;
if (addedRef.hasGeometry()) {
finalize = false;
//Base::Console().Warning("AddSelection\n");
//add the geometry to its type vector. Temporarily if not selAllowed
if (addedRef.getSubName() == "") {
// Behavior deactivated for now because I found it annoying.
// To reactivate replace addedRef.hasGeometry() by addedRef.getObject() above.
// This means user selected the view itself.
if (selectionEmpty()) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX");
}
}
else {
ReferenceVector& selVector = getSelectionVector(addedRef);
selVector.push_back(addedRef);
availableDimension = AvailableDimension::FIRST;
bool selAllowed = makeAppropriateDimension();
if (!selAllowed) {
// remove from selection
blockRemoveSel = true;
Gui::Selection().rmvSelection(addedRef.getObject()->getDocument()->getName(),
addedRef.getObject()->getNameInDocument(), addedRef.getSubName().c_str());
blockRemoveSel = false;
if (selVector == selFaces) {
// if sel face and not allowed, then a dimension is being created
// and user clicked on a face to drop it.
// Better would be to disable face selectability when needed.
finalize = true;
}
}
}
addedRef = ReferenceEntry();
}
addedRef = ReferenceEntry();
}
// Finalize if click on empty space.
if (finalize && !dims.empty()) {
finalizeCommand();
// Finalize if click on empty space.
if (finalize && !dims.empty()) {
finalizeCommand();
}
}
return true;
}
void onSelectionChanged(const Gui::SelectionChanges& msg)
void onSelectionChanged(const Gui::SelectionChanges& msg) override
{
//Base::Console().Warning("onSelectionChanged %d - --%s--\n", (int)msg.Type, msg.pSubName);
@@ -539,7 +566,7 @@ protected:
SpecialDimension specialDimension;
AvailableDimension availableDimension;
QPoint previousPos;
QPoint mousePos;
ReferenceVector selPoints;
ReferenceVector selLine;
@@ -578,7 +605,7 @@ protected:
}
// See if the selection is valid
bool selAllowed = makeAppropriateDimension(QPoint());
bool selAllowed = makeAppropriateDimension();
if (!selAllowed) {
clearRefVectors();
@@ -704,316 +731,322 @@ protected:
return result;
}
bool makeAppropriateDimension(QPoint& pos) {
bool makeAppropriateDimension() {
bool selAllowed = false;
//Base::Console().Warning("makeAppropriateDimension %d %d %d %d %d %d\n", selPoints.size(), selLine.size(), selCircleArc.size(), selEllipseArc.size(), selSplineAndCo.size(), selFaces.size());
GeomSelectionSizes selection(selPoints.size(), selLine.size(), selCircleArc.size(), selEllipseArc.size(), selSplineAndCo.size(), selFaces.size());
if (selection.hasFaces()) {
if (selection.has1Face()) { makeCts_Faces(selAllowed, pos); }
if (selection.has1Face()) { makeCts_Faces(selAllowed); }
else { return false; } // nothing else with face works
}
else if (selection.hasPoints()) {
if (selection.has1Point()) { selAllowed = true; }
else if (selection.has2Points()) { makeCts_2Point(selAllowed, pos); }
else if (selection.has3Points()) { makeCts_3Point(selAllowed, pos); }
else if (selection.has4MorePoints()) { makeCts_4MorePoints(selAllowed, pos); }
else if (selection.has1Point1Line()) { makeCts_1Point1Line(selAllowed, pos); }
else if (selection.has1Point1Circle()) { makeCts_1Point1Circle(selAllowed, pos); }
else if (selection.has1Point1Ellipse()) { makeCts_1Point1Ellipse(selAllowed, pos); }
else if (selection.has2Points()) { makeCts_2Point(selAllowed); }
else if (selection.has3Points()) { makeCts_3Point(selAllowed); }
else if (selection.has4MorePoints()) { makeCts_4MorePoints(selAllowed); }
else if (selection.has1Point1Line()) { makeCts_1Point1Line(selAllowed); }
else if (selection.has1Point1Circle()) { makeCts_1Point1Circle(selAllowed); }
else if (selection.has1Point1Ellipse()) { makeCts_1Point1Ellipse(selAllowed); }
}
else if (selection.hasLines()) {
if (selection.has1Line()) { makeCts_1Line(selAllowed, pos); }
else if (selection.has2Lines()) { makeCts_2Line(selAllowed, pos); }
else if (selection.has1Line1Circle()) { makeCts_1Line1Circle(selAllowed, pos); }
else if (selection.has1Line1Ellipse()) { makeCts_1Line1Ellipse(selAllowed, pos); }
if (selection.has1Line()) { makeCts_1Line(selAllowed); }
else if (selection.has2Lines()) { makeCts_2Line(selAllowed); }
else if (selection.has1Line1Circle()) { makeCts_1Line1Circle(selAllowed); }
else if (selection.has1Line1Ellipse()) { makeCts_1Line1Ellipse(selAllowed); }
}
else if (selection.hasCirclesOrArcs()) {
if (selection.has1Circle()) { makeCts_1Circle(selAllowed, pos); }
else if (selection.has2Circles()) { makeCts_2Circle(selAllowed, pos); }
if (selection.has1Circle()) { makeCts_1Circle(selAllowed); }
else if (selection.has2Circles()) { makeCts_2Circle(selAllowed); }
}
else if (selection.hasEllipseAndCo()) {
if (selection.has1Ellipse()) { makeCts_1Ellipse(selAllowed, pos); }
if (selection.has2Ellipses()) { makeCts_2Ellipses(selAllowed, pos); }
if (selection.has1Ellipse()) { makeCts_1Ellipse(selAllowed); }
if (selection.has2Ellipses()) { makeCts_2Ellipses(selAllowed); }
}
else if (selection.hasSplineAndCo()) {
if (selection.has1Spline()) { makeCts_1Spline(selAllowed, pos); }
if (selection.has1SplineAndMore()) { makeCts_1SplineAndMore(selAllowed, pos); }
if (selection.has1Spline()) { makeCts_1Spline(selAllowed); }
if (selection.has1SplineAndMore()) { makeCts_1SplineAndMore(selAllowed); }
}
// Make created constraints unselectable.
if (selAllowed) {
setDimsSelectability(false);
}
return selAllowed;
}
void makeCts_Faces(bool& selAllowed, QPoint& pos)
void makeCts_Faces(bool& selAllowed)
{
//area
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Area dimension"));
createAreaDimension(selFaces[0], pos);
createAreaDimension(selFaces[0]);
selAllowed = true;
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_2Point(bool& selAllowed, QPoint& pos)
void makeCts_2Point(bool& selAllowed)
{
//distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Distance dimension"));
createDistanceDimension("Distance", selPoints[0], selPoints[1], pos);
createDistanceDimension("Distance", { selPoints[0], selPoints[1] });
specialDimension = SpecialDimension::LineOr2PointsDistance;
selAllowed = true;
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_3Point(bool& selAllowed, QPoint& pos)
void makeCts_3Point(bool& selAllowed)
{
// chain distances, angle
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal chain dimensions"));
createChainDimension("DistanceX", pos);
createChainDimension("DistanceX");
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal coordinate dimensions"));
createCoordDimension("DistanceX", pos);
createCoordDimension("DistanceX");
}
if (availableDimension == AvailableDimension::THIRD) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add 3-points angle dimension"));
create3pAngleDimension(selPoints[0], selPoints[1], selPoints[2], pos);
create3pAngleDimension({ selPoints[0], selPoints[1], selPoints[2] });
}
else if (availableDimension == AvailableDimension::FOURTH) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add 3-points angle dimension"));
create3pAngleDimension(selPoints[1], selPoints[2], selPoints[0], pos);
create3pAngleDimension({ selPoints[1], selPoints[2], selPoints[0] });
}
else if (availableDimension == AvailableDimension::FIFTH) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add 3-points angle dimension"));
create3pAngleDimension(selPoints[2], selPoints[0], selPoints[1], pos);
create3pAngleDimension({ selPoints[2], selPoints[0], selPoints[1] });
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_4MorePoints(bool& selAllowed, QPoint& pos)
void makeCts_4MorePoints(bool& selAllowed)
{
// chain distances
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal chain dimension"));
createChainDimension("DistanceX", pos);
createChainDimension("DistanceX");
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal coordinate dimensions"));
createCoordDimension("DistanceX", pos);
createCoordDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Point1Line(bool& selAllowed, QPoint& pos)
void makeCts_1Point1Line(bool& selAllowed)
{
//distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add point to line Distance dimension"));
createDistanceDimension("Distance", selPoints[0], selLine[0], pos);
createDistanceDimension("Distance", { selPoints[0], selLine[0] });
selAllowed = true;
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Point1Circle(bool& selAllowed, QPoint& pos)
void makeCts_1Point1Circle(bool& selAllowed)
{
//Distance, extent distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add length dimension"));
createDistanceDimension("Distance", selPoints[0], selCircleArc[0], pos);
createDistanceDimension("Distance", { selPoints[0], selCircleArc[0] });
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Point1Ellipse(bool& selAllowed, QPoint& pos)
void makeCts_1Point1Ellipse(bool& selAllowed)
{
//Distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add length dimension"));
createDistanceDimension("Distance", selPoints[0], selEllipseArc[0], pos);
createDistanceDimension("Distance", { selPoints[0], selEllipseArc[0] });
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Line(bool& selAllowed, QPoint& pos)
void makeCts_1Line(bool& selAllowed)
{
//distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add length dimension"));
createDistanceDimension("Distance", selLine[0], ReferenceEntry(), pos);
createDistanceDimension("Distance", { selLine[0] });
specialDimension = SpecialDimension::LineOr2PointsDistance;
selAllowed = true;
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_2Line(bool& selAllowed, QPoint& pos)
void makeCts_2Line(bool& selAllowed)
{
//angle (if parallel: Distance (see in createAngleDimension)).
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Angle dimension"));
createAngleDimension(selLine[0], selLine[1], pos);
createAngleDimension(selLine[0], selLine[1]);
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Line1Circle(bool& selAllowed, QPoint& pos)
void makeCts_1Line1Circle(bool& selAllowed)
{
//distance, extent distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add circle to line Distance dimension"));
createDistanceDimension("Distance", selCircleArc[0], selLine[0], pos);
createDistanceDimension("Distance", { selCircleArc[0], selLine[0] });
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Line1Ellipse(bool& selAllowed, QPoint& pos)
void makeCts_1Line1Ellipse(bool& selAllowed)
{
//distance, extent distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add ellipse to line Distance dimension"));
createDistanceDimension("Distance", selEllipseArc[0], selLine[0], pos);
createDistanceDimension("Distance", { selEllipseArc[0], selLine[0] });
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Circle(bool& selAllowed, QPoint& pos)
void makeCts_1Circle(bool& selAllowed)
{
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
createRadiusDiameterDimension(selCircleArc[0], pos, true);
createRadiusDiameterDimension(selCircleArc[0], true);
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
createRadiusDiameterDimension(selCircleArc[0], pos, false);
createRadiusDiameterDimension(selCircleArc[0], false);
if (selCircleArc[0].geomEdgeType() != TechDraw::ARCOFCIRCLE) {
availableDimension = AvailableDimension::RESET;
}
}
if (availableDimension == AvailableDimension::THIRD) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Arc Length dimension"));
createArcLengthDimension(selCircleArc[0], pos);
createArcLengthDimension(selCircleArc[0]);
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_2Circle(bool& selAllowed, QPoint& pos)
void makeCts_2Circle(bool& selAllowed)
{
//Distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add circle to circle Distance dimension"));
createDistanceDimension("Distance", selCircleArc[0], selCircleArc[1], pos);
createDistanceDimension("Distance", { selCircleArc[0], selCircleArc[1] });
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Ellipse(bool& selAllowed, QPoint& pos)
void makeCts_1Ellipse(bool& selAllowed)
{
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
createRadiusDiameterDimension(selEllipseArc[0], pos, true);
createRadiusDiameterDimension(selEllipseArc[0], true);
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Radius dimension"));
createRadiusDiameterDimension(selEllipseArc[0], pos, false);
createRadiusDiameterDimension(selEllipseArc[0], false);
if (selEllipseArc[0].geomEdgeType() != TechDraw::ARCOFELLIPSE) {
availableDimension = AvailableDimension::RESET;
}
}
if (availableDimension == AvailableDimension::THIRD) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Arc Length dimension"));
createArcLengthDimension(selEllipseArc[0], pos);
createArcLengthDimension(selEllipseArc[0]);
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_2Ellipses(bool& selAllowed, QPoint& pos)
void makeCts_2Ellipses(bool& selAllowed)
{
//Distance
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add ellipse to ellipse Distance dimension"));
createDistanceDimension("Distance", selEllipseArc[0], selEllipseArc[1], pos);
createDistanceDimension("Distance", { selEllipseArc[0], selEllipseArc[1] });
selAllowed = true;
}
if (availableDimension == AvailableDimension::SECOND) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1Spline(bool& selAllowed, QPoint& pos)
void makeCts_1Spline(bool& selAllowed)
{
//Edge length
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add edge length dimension"));
createArcLengthDimension(selSplineAndCo[0], pos);
createArcLengthDimension(selSplineAndCo[0]);
selAllowed = true;
availableDimension = AvailableDimension::RESET;
}
}
void makeCts_1SplineAndMore(bool& selAllowed, QPoint& pos)
void makeCts_1SplineAndMore(bool& selAllowed)
{
//Extend
if (availableDimension == AvailableDimension::FIRST) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
selAllowed = true;
availableDimension = AvailableDimension::RESET;
}
}
void createAreaDimension(ReferenceEntry ref, QPoint& pos)
void createAreaDimension(ReferenceEntry ref)
{
DrawViewDimension* dim = dimMaker(partFeat, "Area", { ref }, {});
dims.push_back(dim);
moveDimension(pos, dim);
moveDimension(mousePos, dim);
}
void createRadiusDiameterDimension(ReferenceEntry ref, QPoint& pos, bool firstCstr) {
void createRadiusDiameterDimension(ReferenceEntry ref, bool firstCstr) {
bool isCircleGeom = true;
int GeoId(TechDraw::DrawUtil::getIndexFromName(ref.getSubName()));
TechDraw::BaseGeomPtr geom = partFeat->getGeomByIndex(GeoId);
isCircleGeom = geom->getGeomType() == TechDraw::CIRCLE || TechDraw::ELLIPSE;
isCircleGeom = (geom->getGeomType() == TechDraw::CIRCLE) || (geom->getGeomType() == TechDraw::ELLIPSE);
// Use same preference as in sketcher?
ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/Mod/TechDraw/dimensioning");
@@ -1032,61 +1065,57 @@ protected:
}
dims.push_back(dim);
moveDimension(pos, dim);
moveDimension(mousePos, dim);
}
void createAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2, QPoint& pos) {
void createAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2) {
if (TechDraw::isValidMultiEdge({ ref1, ref2 }) != isAngle) {
//isValidMultiEdge check if lines are parallel.
restartCommand(QT_TRANSLATE_NOOP("Command", "Add Distance dimension"));
createDistanceDimension("Distance", ref1, ref2, pos);
createDistanceDimension("Distance", { ref1, ref2 });
return;
}
DrawViewDimension* dim = dimMaker(partFeat, "Angle", {ref1, ref2}, {});
dims.push_back(dim);
moveDimension(pos, dim);
moveDimension(mousePos, dim);
}
void create3pAngleDimension(ReferenceEntry ref1, ReferenceEntry ref2, ReferenceEntry ref3, QPoint& pos)
void create3pAngleDimension(ReferenceVector refs)
{
DrawViewDimension* dim = dimMaker(partFeat, "Angle3Pt", {ref1, ref2, ref3}, {});
DrawViewDimension* dim = dimMaker(partFeat, "Angle3Pt", refs, {});
dims.push_back(dim);
moveDimension(pos, dim);
moveDimension(mousePos, dim);
}
void createArcLengthDimension(ReferenceEntry ref, QPoint& pos)
void createArcLengthDimension(ReferenceEntry ref)
{
DrawViewDimension* dim = makeArcLengthDimension(ref);
dims.push_back(dim);
moveDimension(pos, dim);
moveDimension(mousePos, dim);
}
void createDistanceDimension(std::string type, ReferenceEntry ref1, ReferenceEntry ref2, QPoint& pos) {
ReferenceVector refs = { ref1 };
if (ref2.hasGeometry()) { // if valid
refs.push_back(ref2);
}
void createDistanceDimension(std::string type, ReferenceVector refs)
{
DrawViewDimension* dim = dimMaker(partFeat, type, refs, {});
dims.push_back(dim);
moveDimension(pos, dim);
moveDimension(mousePos, dim);
}
void createExtentDistanceDimension(std::string type, QPoint& pos) {
void createExtentDistanceDimension(std::string type) {
specialDimension = SpecialDimension::ExtendDistance;
DrawViewDimension* dim = DrawDimHelper::makeExtentDim(partFeat, type, allRefs());
dims.push_back(dim);
moveDimension(pos, dim);
moveDimension(mousePos, dim);
}
void updateDistanceType(QPoint& pos)
void updateDistanceType()
{
if (dims.empty()) {
return;
@@ -1098,7 +1127,7 @@ protected:
Base::Vector3d pnt1 = Rez::guiX(pp.first());
Base::Vector3d pnt2 = Rez::guiX(pp.second());
QPointF fpos = getDimPositionToBe(pos);
QPointF fpos = getDimPositionToBe(mousePos);
double minX, minY, maxX, maxY;
minX = min(pnt1.x, pnt2.x);
@@ -1127,14 +1156,15 @@ protected:
specialDimension = SpecialDimension::LineOr2PointsDistance;
if (selLine.size() == 1) {
createDistanceDimension(newType, selLine[0], ReferenceEntry(), pos);
createDistanceDimension(newType, { selLine[0] });
}
else {
createDistanceDimension(newType, selPoints[0], selPoints[1], pos);
createDistanceDimension(newType, { selPoints[0], selPoints[1] });
}
setDimsSelectability(false);
}
void updateExtentDistanceType(QPoint& pos)
void updateExtentDistanceType()
{
if (dims.empty()) {
return;
@@ -1146,7 +1176,7 @@ protected:
Base::Vector3d pnt1 = Rez::guiX(pp.first());
Base::Vector3d pnt2 = Rez::guiX(pp.second());
QPointF fpos = getDimPositionToBe(pos);
QPointF fpos = getDimPositionToBe(mousePos);
double minX, minY, maxX, maxY;
minX = min(pnt1.x, pnt2.x);
@@ -1157,16 +1187,21 @@ protected:
if (fpos.x() > minX && fpos.x() < maxX
&& (fpos.y() < minY || fpos.y() > maxY) && type != DimensionType::DistanceX) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add DistanceX extent dimension"));
createExtentDistanceDimension("DistanceX", pos);
createExtentDistanceDimension("DistanceX");
}
else if (fpos.y() > minY && fpos.y() < maxY
&& (fpos.x() < minX || fpos.x() > maxX) && type != DimensionType::DistanceY) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add DistanceY extent dimension"));
createExtentDistanceDimension("DistanceY", pos);
createExtentDistanceDimension("DistanceY");
}
else {
return;
}
setDimsSelectability(false);
}
void updateChainDistanceType(QPoint& pos)
void updateChainDistanceType()
{
if (dims.empty()) {
return;
@@ -1187,7 +1222,7 @@ protected:
maxY = max(maxY, max(pnt1.y, pnt2.y));
}
QPointF fpos = getDimPositionToBe(pos);
QPointF fpos = getDimPositionToBe(mousePos);
auto type = static_cast<DimensionType>(dims[0]->Type.getValue());
@@ -1195,37 +1230,42 @@ protected:
&& (fpos.y() < minY || fpos.y() > maxY) && type != DimensionType::DistanceX) {
if (specialDimension == SpecialDimension::ChainDistance) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal chain dimensions"));
createChainDimension("DistanceX", pos);
createChainDimension("DistanceX");
}
else {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add horizontal coord dimensions"));
createCoordDimension("DistanceX", pos);
createCoordDimension("DistanceX");
}
}
else if (fpos.y() > minY && fpos.y() < maxY
&& (fpos.x() < minX || fpos.x() > maxX) && type != DimensionType::DistanceY) {
if (specialDimension == SpecialDimension::ChainDistance) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add vertical chain dimensions"));
createChainDimension("DistanceY", pos);
createChainDimension("DistanceY");
}
else {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add vertical coord dimensions"));
createCoordDimension("DistanceY", pos);
createCoordDimension("DistanceY");
}
}
else if (((fpos.y() < minY || fpos.y() > maxY) && (fpos.x() < minX || fpos.x() > maxX)) && type != DimensionType::Distance) {
if (specialDimension == SpecialDimension::ChainDistance) {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add oblique chain dimensions"));
createChainDimension("Distance", pos);
createChainDimension("Distance");
}
else {
restartCommand(QT_TRANSLATE_NOOP("Command", "Add oblique coord dimensions"));
createCoordDimension("Distance", pos);
createCoordDimension("Distance");
}
}
else {
return;
}
setDimsSelectability(false);
}
void createChainDimension(std::string type, QPoint& pos)
void createChainDimension(std::string type)
{
specialDimension = SpecialDimension::ChainDistance;
if (type == "Distance") {
@@ -1241,7 +1281,7 @@ protected:
}
}
void createCoordDimension(std::string type, QPoint& pos)
void createCoordDimension(std::string type)
{
specialDimension = SpecialDimension::CoordDistance;
if (type == "Distance") {
@@ -1269,7 +1309,7 @@ protected:
Gui::Command::abortCommand();
Gui::Command::openCommand(QT_TRANSLATE_NOOP("Command", "Dimension"));
specialDimension = SpecialDimension::None;
previousPos = QPoint(0,0);
mousePos = QPoint(0,0);
clearRefVectors();
partFeat = nullptr;
dims.clear();

3
src/Mod/TechDraw/Gui/CommandExtensionDims.cpp
View File

@@ -2377,7 +2377,7 @@ DrawViewDimension* TechDrawGui::makeArcLengthDimension(const ReferenceEntry& ref
}
GProp_GProps edgeProps;
BRepGProp::LinearProperties(edge->getOCCEdge(), edgeProps);
double length = edgeProps.Mass();
double length = edgeProps.Mass() / dvp->getScale();
Base::Vector3d startPt = edge->getStartPoint();
Base::Vector3d endPt = edge->getEndPoint();
@@ -2385,7 +2385,6 @@ DrawViewDimension* TechDrawGui::makeArcLengthDimension(const ReferenceEntry& ref
endPt.y = -endPt.y;
std::stringstream startName, endName, formatSpec;
double scale = dvp->getScale();
Base::Vector3d cvPoint = CosmeticVertex::makeCanonicalPoint(dvp, startPt);
std::string startVertTag = dvp->addCosmeticVertex(cvPoint);
int startVertNumber = dvp->add1CVToGV(startVertTag);

3
src/Mod/TechDraw/Gui/CommandExtensionDims.h
View File

@@ -23,9 +23,12 @@
#ifndef TECHDRAWGUI_CommandExtensionDims_H
#define TECHDRAWGUI_CommandExtensionDims_H
#include <Mod/TechDraw/TechDrawGlobal.h>
namespace TechDraw
{
class ReferenceEntry;
class DrawViewDimension;
}
namespace TechDrawGui {

30
src/Mod/TechDraw/Gui/MDIViewPage.cpp
View File

@@ -110,6 +110,7 @@ MDIViewPage::MDIViewPage(ViewProviderPage* pageVp, Gui::Document* doc, QWidget*
connect(m_printAllAction, &QAction::triggered, this, qOverload<>(&MDIViewPage::printAllPages));
isSelectionBlocked = false;
isContextualMenuEnabled = true;
QString tabText = QString::fromUtf8(pageVp->getDrawPage()->getNameInDocument());
tabText += QString::fromUtf8("[*]");
@@ -461,14 +462,16 @@ PyObject* MDIViewPage::getPyObject()
void MDIViewPage::contextMenuEvent(QContextMenuEvent* event)
{
// Base::Console().Message("MDIVP::contextMenuEvent() - reason: %d\n", event->reason());
QMenu menu;
menu.addAction(m_toggleFrameAction);
menu.addAction(m_toggleKeepUpdatedAction);
menu.addAction(m_exportSVGAction);
menu.addAction(m_exportDXFAction);
menu.addAction(m_exportPDFAction);
menu.addAction(m_printAllAction);
menu.exec(event->globalPos());
if (isContextualMenuEnabled) {
QMenu menu;
menu.addAction(m_toggleFrameAction);
menu.addAction(m_toggleKeepUpdatedAction);
menu.addAction(m_exportSVGAction);
menu.addAction(m_exportDXFAction);
menu.addAction(m_exportPDFAction);
menu.addAction(m_printAllAction);
menu.exec(event->globalPos());
}
}
void MDIViewPage::toggleFrame() { m_vpPage->toggleFrameState(); }
@@ -1065,6 +1068,17 @@ void MDIViewPage::showStatusMsg(const char* string1, const char* string2, const
}
}
void MDIViewPage::setDimensionsSelectability(bool val)
{
for (auto scene : m_scene->items()) {
auto* dl = dynamic_cast<QGIDatumLabel*>(scene);
if (dl) {
dl->setSelectability(val);
}
}
}
// ----------------------------------------------------------------------------
void MDIViewPagePy::init_type()

4
src/Mod/TechDraw/Gui/MDIViewPage.h
View File

@@ -109,6 +109,9 @@ public:
void setScene(QGSPage* scene, QGVPage* view);
void fixSceneDependencies();
void setDimensionsSelectability(bool val);
void enableContextualMenu(bool val) { isContextualMenuEnabled = val; }
public Q_SLOTS:
void viewAll() override;
void saveSVG();
@@ -147,6 +150,7 @@ private:
std::string m_objectName;
std::string m_documentName;
bool isSelectionBlocked;
bool isContextualMenuEnabled;
QPointer<QGSPage> m_scene;
QString m_currentPath;

29
src/Mod/TechDraw/Gui/QGIViewDimension.cpp
View File

@@ -93,8 +93,7 @@ QGIDatumLabel::QGIDatumLabel() : m_dragState(NoDrag)
setCacheMode(QGraphicsItem::NoCache);
setFlag(ItemSendsGeometryChanges, true);
setFlag(ItemIsMovable, true);
setFlag(ItemIsSelectable, true);
setAcceptHoverEvents(true);
setSelectability(true);
setFiltersChildEvents(true);
m_dimText = new QGCustomText();
@@ -445,6 +444,13 @@ void QGIDatumLabel::setColor(QColor color)
m_unitText->setColor(m_colNormal);
}
void QGIDatumLabel::setSelectability(bool val)
{
setFlag(ItemIsSelectable, val);
setAcceptHoverEvents(val);
setAcceptedMouseButtons(val ? Qt::AllButtons : Qt::NoButton);
}
//**************************************************************
QGIViewDimension::QGIViewDimension() : dvDimension(nullptr), hasHover(false), m_lineWidth(0.0)
{
@@ -1258,7 +1264,7 @@ void QGIViewDimension::resetArrows() const
}
void QGIViewDimension::drawArrows(int count, const Base::Vector2d positions[], double angles[],
bool flipped) const
bool flipped, bool forcePoint) const
{
const int arrowCount = 2;
QGIArrow* arrows[arrowCount] = {aHead1, aHead2};
@@ -1278,7 +1284,8 @@ void QGIViewDimension::drawArrows(int count, const Base::Vector2d positions[], d
continue;
}
arrow->setStyle(QGIArrow::getPrefArrowStyle());
// some dimensions must use point ends (area). The point style is 3.
arrow->setStyle(forcePoint ? 3 : QGIArrow::getPrefArrowStyle());
auto vp = static_cast<ViewProviderDimension*>(getViewProvider(getViewObject()));
auto arrowSize = vp->Arrowsize.getValue();
arrow->setSize(arrowSize);
@@ -1406,7 +1413,7 @@ void QGIViewDimension::drawDimensionLine(QPainterPath& painterPath,
const Base::Vector2d& targetPoint, double lineAngle,
double startPosition, double jointPosition,
const Base::BoundBox2d& labelRectangle, int arrowCount,
int standardStyle, bool flipArrows) const
int standardStyle, bool flipArrows, bool forcePointStyle) const
{
// Keep the convention start position <= 0
jointPosition *= normalizeStartPosition(startPosition, lineAngle);
@@ -1426,7 +1433,7 @@ void QGIViewDimension::drawDimensionLine(QPainterPath& painterPath,
arrowAngles[0] = lineAngle;
arrowAngles[1] = lineAngle + M_PI;
drawArrows(arrowCount, arrowPositions, arrowAngles, flipArrows);
drawArrows(arrowCount, arrowPositions, arrowAngles, flipArrows, forcePointStyle);
}
void QGIViewDimension::drawDimensionArc(QPainterPath& painterPath, const Base::Vector2d& arcCenter,
@@ -2097,6 +2104,7 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
Base::Vector2d labelCenter(labelRectangle.GetCenter());
double labelAngle = 0.0;
bool forcePointStyle = true;
if (standardStyle == ViewProviderDimension::STD_STYLE_ISO_REFERENCING
|| standardStyle == ViewProviderDimension::STD_STYLE_ASME_REFERENCING) {
@@ -2112,11 +2120,10 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
jointDirection = getAsmeRefJointPoint(labelRectangle, left) - centerPoint;
}
double lineAngles = jointDirection.Angle();
double lineAngle = jointDirection.Angle();
double jointPositions = jointDirection.Length();
drawDimensionLine(areaPath, centerPoint, lineAngles, 0.0,
jointPositions, labelRectangle, 1, standardStyle, flipArrow);
drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, jointPositions, labelRectangle, 1, standardStyle, flipArrow, forcePointStyle);
Base::Vector2d outsetPoint(standardStyle == ViewProviderDimension::STD_STYLE_ISO_REFERENCING
? getIsoRefOutsetPoint(labelRectangle, left)
@@ -2135,7 +2142,7 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
lineAngle = lineAngle - M_PI;
double labelPosition = -cos(devAngle) * ((labelCenter - centerPoint).Length());
drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow);
drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow, forcePointStyle);
}
else if (standardStyle == ViewProviderDimension::STD_STYLE_ASME_INLINED) {
// Text must remain horizontal, but it may split the leader line
@@ -2143,7 +2150,7 @@ void QGIViewDimension::drawAreaExecutive(const Base::Vector2d& centerPoint, doub
double lineAngle = labelDirection.Angle();
double labelPosition = labelDirection.Length();
drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow);
drawDimensionLine(areaPath, centerPoint, lineAngle, 0.0, labelPosition, labelRectangle, 1, standardStyle, flipArrow, forcePointStyle);
}
else {
Base::Console().Error(

5
src/Mod/TechDraw/Gui/QGIViewDimension.h
View File

@@ -87,6 +87,7 @@ public:
void setPrettyPre();
void setPrettyNormal();
void setColor(QColor color);
void setSelectability(bool val);
QGCustomText* getDimText() { return m_dimText; }
void setDimText(QGCustomText* newText) { m_dimText = newText; }
@@ -232,7 +233,7 @@ protected:
void draw() override;
void resetArrows() const;
void drawArrows(int count, const Base::Vector2d positions[], double angles[], bool flipped) const;
void drawArrows(int count, const Base::Vector2d positions[], double angles[], bool flipped, bool forcePoint = false) const;
void drawSingleLine(QPainterPath &painterPath, const Base::Vector2d &lineOrigin, double lineAngle,
double startPosition, double endPosition) const;
@@ -245,7 +246,7 @@ protected:
void drawDimensionLine(QPainterPath &painterPath, const Base::Vector2d &targetPoint, double lineAngle,
double startPosition, double jointPosition, const Base::BoundBox2d &labelRectangle,
int arrowCount, int standardStyle, bool flipArrows) const;
int arrowCount, int standardStyle, bool flipArrows, bool forcePointStyle = false) const;
void drawDimensionArc(QPainterPath &painterPath, const Base::Vector2d &arcCenter, double arcRadius,
double endAngle, double startRotation, double jointAngle,
const Base::BoundBox2d &labelRectangle, int arrowCount,

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

@@ -104,6 +104,7 @@ public:
void activateHandler(TechDrawHandler* newHandler);
void deactivateHandler();
bool isHandlerActive() { return toolHandler != nullptr; }
bool isBalloonPlacing() const { return balloonPlacing; }
void setBalloonPlacing(bool isPlacing) { balloonPlacing = isPlacing; }

28
src/Mod/TechDraw/Gui/TechDrawHandler.cpp
View File

@@ -26,6 +26,9 @@
#include <QGuiApplication>
#include <QPainter>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QTimer>
#include <Inventor/events/SoKeyboardEvent.h>
#endif // #ifndef _PreComp_
@@ -55,6 +58,12 @@ TechDrawHandler::~TechDrawHandler()
void TechDrawHandler::activate(QGVPage* vp)
{
auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
if (!mdi) {
return;
}
mdi->enableContextualMenu(false);
viewPage = vp;
if (!Gui::ToolHandler::activate()) {
@@ -62,6 +71,22 @@ void TechDrawHandler::activate(QGVPage* vp)
}
}
void TechDrawHandler::deactivate()
{
Gui::ToolHandler::deactivate();
// The context menu event of MDIViewPage comes after the tool is deactivated.
// So to prevent the menu from appearing when the tool is cleared by right mouse click
// we set a small timer.
QTimer::singleShot(100, [this]() { // 100 milliseconds delay
auto* mdi = dynamic_cast<MDIViewPage*>(Gui::getMainWindow()->activeWindow());
if (!mdi) {
return;
}
mdi->enableContextualMenu(true);
});
}
void TechDrawHandler::keyReleaseEvent(QKeyEvent* event)
{
// the default behaviour is to quit - specific handler categories may
@@ -72,7 +97,7 @@ void TechDrawHandler::keyReleaseEvent(QKeyEvent* event)
}
}
bool TechDrawHandler::mousePressEvent(QMouseEvent* event)
void TechDrawHandler::mouseReleaseEvent(QMouseEvent* event)
{
// the default behaviour is to quit - specific handler categories may
// override this behaviour, for example to implement a continuous mode
@@ -80,7 +105,6 @@ bool TechDrawHandler::mousePressEvent(QMouseEvent* event)
quit();
event->accept();
}
return true;
}
void TechDrawHandler::quit()

5
src/Mod/TechDraw/Gui/TechDrawHandler.h
View File

@@ -39,12 +39,13 @@ public:
virtual ~TechDrawHandler();
void activate(QGVPage* vPage);
void deactivate() override;
void quit() override;
virtual void mouseMoveEvent(QMouseEvent* event) = 0;
virtual bool mousePressEvent(QMouseEvent* event);
virtual bool mouseReleaseEvent(QMouseEvent* event) = 0;
virtual void mousePressEvent(QMouseEvent* event) { Q_UNUSED(event) };
virtual void mouseReleaseEvent(QMouseEvent* event);
virtual void keyPressEvent(QKeyEvent* event) = 0;
virtual void keyReleaseEvent(QKeyEvent* event);