kindred/create
1
1
Fork 0
Code Issues 44 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
b57d0f37aa04df22d91ba54ceb6751d25413bd48
create/src/Mod/TechDraw/Gui/QGIWeldSymbol.cpp

626 lines
18 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2019 WandererFan <wandererfan@gmail.com> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#include "PreCompiled.h"
#include <qpainter.h>
#ifndef _PreComp_
# include <cmath>
# include <QGraphicsScene>
# include <QPainterPath>
#endif
#include <Base/Console.h>
#include <Base/Tools.h>
#include <Mod/TechDraw/App/DrawLeaderLine.h>
#include <Mod/TechDraw/App/DrawTile.h>
#include <Mod/TechDraw/App/DrawTileWeld.h>
#include <Mod/TechDraw/App/DrawWeldSymbol.h>
#include <Mod/TechDraw/App/DrawUtil.h>
#include "QGIWeldSymbol.h"
#include "PreferencesGui.h"
#include "QGCustomText.h"
#include "QGILeaderLine.h"
#include "QGIPrimPath.h"
#include "QGITile.h"
#include "QGIVertex.h"
#include "Rez.h"
#include "ViewProviderWeld.h"
#include "ZVALUE.h"
using namespace TechDraw;
using namespace TechDrawGui;
using DU = DrawUtil;
//**************************************************************
QGIWeldSymbol::QGIWeldSymbol() :
m_arrowFeat(nullptr),
m_otherFeat(nullptr),
m_tailText(new QGCustomText()),
m_fieldFlag(new QGIPrimPath()),
m_allAround(new QGIVertex(-1)),
m_blockDraw(false)
{
setFiltersChildEvents(true);
setFlag(QGraphicsItem::ItemIsMovable, false);
setCacheMode(QGraphicsItem::NoCache);
setZValue(ZVALUE::DIMENSION);
m_tailText->setPlainText(
QStringLiteral(" "));
addToGroup(m_tailText);
m_tailText->hide();
m_tailText->setPos(0.0, 0.0); //avoid bRect issues
addToGroup(m_allAround);
m_allAround->setPos(0.0, 0.0);
m_allAround->setAcceptHoverEvents(false);
m_allAround->setFlag(QGraphicsItem::ItemIsSelectable, false);
m_allAround->setFlag(QGraphicsItem::ItemIsMovable, false);
m_allAround->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, false);
m_allAround->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
m_allAround->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
addToGroup(m_fieldFlag);
m_fieldFlag->setPos(0.0, 0.0);
m_fieldFlag->setAcceptHoverEvents(false);
m_fieldFlag->setFlag(QGraphicsItem::ItemIsSelectable, false);
m_fieldFlag->setFlag(QGraphicsItem::ItemIsMovable, false);
m_fieldFlag->setFlag(QGraphicsItem::ItemSendsScenePositionChanges, false);
m_fieldFlag->setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
m_fieldFlag->setFlag(QGraphicsItem::ItemStacksBehindParent, true);
m_fieldFlag->setFill(prefNormalColor(), Qt::SolidPattern);
setNormalColor(prefNormalColor());
setCurrentColor(getNormalColor());
setSettingColor(getNormalColor());
setPrettyNormal();
}
QVariant QGIWeldSymbol::itemChange(GraphicsItemChange change, const QVariant &value)
{
if (change == ItemSelectedHasChanged && scene()) {
if(isSelected()) {
setPrettySel();
} else {
setPrettyNormal();
}
} else if(change == ItemSceneChange && scene()) {
// nothing special!
}
return QGIView::itemChange(change, value);
}
void QGIWeldSymbol::updateView(bool update)
{
Q_UNUSED(update);
TechDraw::DrawWeldSymbol *feature = getFeature();
if (!feature) {
Base::Console().warning("QGIWS::updateView - no feature!\n");
return;
}
if (feature->isRestoring() || !getLeader()) {
return;
}
draw();
}
void QGIWeldSymbol::draw()
{
if (!isVisible()) {
return;
}
getTileFeats();
removeQGITiles();
if (m_arrowFeat) {
drawTile(m_arrowFeat);
}
if (m_otherFeat) {
drawTile(m_otherFeat);
}
drawAllAround();
drawFieldFlag();
drawTailText();
}
void QGIWeldSymbol::drawTile(TechDraw::DrawTileWeld* tileFeat)
{
if (!tileFeat) {
Base::Console().message("QGIWS::drawTile - tile is null\n");
return;
}
const auto symbol = getFeature();
if (!symbol) {
return;
}
auto vp = dynamic_cast<ViewProviderWeld *>(getViewProvider(symbol));
if (!vp) {
return;
}
std::string fontName = vp->Font.getValue();
int fontSize = QGIView::exactFontSize(vp->Font.getValue(),
vp->TileFontSize.getValue());
double featScale = getLeader()->getScale();
std::string tileTextL = tileFeat->LeftText.getValue();
std::string tileTextR = tileFeat->RightText.getValue();
std::string tileTextC = tileFeat->CenterText.getValue();
int row = (int)tileFeat->TileRow.getValue();
int col = (int)tileFeat->TileColumn.getValue();
auto tile = new QGITile(tileFeat);
addToGroup(tile);
QPointF org = getTileOrigin();
tile->setTilePosition(org, row, col);
tile->setFont(fontName, fontSize);
tile->setColor(getCurrentColor());
tile->setTileTextLeft(tileTextL);
tile->setTileTextRight(tileTextR);
tile->setTileTextCenter(tileTextC);
tile->setZValue(ZVALUE::DIMENSION);
tile->setTileScale(featScale);
tile->setTailRight(getFeature()->isTailRightSide());
tile->setAltWeld(getFeature()->AlternatingWeld.getValue());
auto localAxes = getLocalAxes();
tile->setLocalAxes(localAxes.first, localAxes.second);
auto tilePos = tile->calcTilePosition(); // this is not the center! pos is left and up from center
auto rotationDeg = getLastSegAngle();
Base::Vector3d stdX{1, 0, 0};
auto xdir = localAxes.first;
auto dot = stdX.Dot(xdir);
constexpr double DegreesHalfCircle{180.0};
if (dot < 0) {
rotationDeg -= DegreesHalfCircle;
}
tile->setRotation(rotationDeg); // Qt angles are clockwise
tile->draw();
tile->setPos(tilePos);
}
void QGIWeldSymbol::drawAllAround()
{
QPointF allAroundPos = getKinkPoint();
m_allAround->setPos(allAroundPos);
if (getFeature()->AllAround.getValue()) {
m_allAround->show();
} else {
m_allAround->hide();
return;
}
m_allAround->setNormalColor(getCurrentColor());
m_allAround->setFill(Qt::NoBrush);
m_allAround->setRadius(PreferencesGui::dimFontSizePX());
auto qgiLead = dynamic_cast<QGILeaderLine *>(getQGIVByName(getLeader()->getNameInDocument()));
if (qgiLead) {
m_allAround->setWidth(qgiLead->getLineWidth());
}
m_allAround->setZValue(ZVALUE::DIMENSION);
}
void QGIWeldSymbol::drawTailText()
{
constexpr double DegreesHalfCircle{180.0};
constexpr double verticalBRectAdjustFactor{1.2}; // text bounding rect is bigger than font size and text is not
// vertically aligned with brect midline, so we artificially
// bump the text size so the middle aligns with the leader
QPointF textPos = getTailPoint();
m_tailText->setPos(textPos); //avoid messing up brect with empty item at 0, 0 !!!
std::string tText = getFeature()->TailText.getValue();
if (tText.empty()) {
m_tailText->hide();
return;
}
m_tailText->show();
const auto symbol = getFeature();
if (!symbol) {
return;
}
auto vp = dynamic_cast<ViewProviderWeld *>(getViewProvider(symbol));
if (!vp) {
return;
}
QString qFontName = QString::fromStdString(vp->Font.getValue());
int fontSize = QGIView::exactFontSize(vp->Font.getValue(),
vp->FontSize.getValue()); // this is different from the size used in the tiles
m_font.setFamily(qFontName);
m_font.setPixelSize(fontSize);
m_tailText->setFont(m_font);
m_tailText->setPlainText(
QString::fromUtf8(tText.c_str()));
m_tailText->setColor(getCurrentColor());
m_tailText->setZValue(ZVALUE::DIMENSION);
auto brWidth = m_tailText->boundingRect().width();
auto brHeight = m_tailText->boundingRect().height();
auto brCharWidth = brWidth / tText.length();
double hMargin = brCharWidth + prefArrowSize(); // leave a gap from the graphic
auto angleDeg = getLastSegAngle();
auto localAxes = getLocalAxes();
auto xdir = localAxes.first;
auto ydir = localAxes.second;
Base::Vector3d stdX{1, 0, 0};
auto xdirStartOffset = DU::toQPointF(xdir * brWidth) * -1; // start of text in xDir when leader points left
auto dot = stdX.Dot(xdir);
if (dot < 0) {
angleDeg -= DegreesHalfCircle;
xdirStartOffset = QPointF(0, 0);
ydir = -ydir;
}
auto xAdjust = DU::toQPointF(xdir * hMargin);
auto yAdjust = DU::toQPointF(ydir * (brHeight * verticalBRectAdjustFactor) / 2);
// QGCustomText doesn't know about rotation so we can't use the justify methods
QPointF justPoint = textPos - xAdjust + yAdjust; // original
justPoint += xdirStartOffset;
m_tailText->setPos(justPoint);
auto kink = getLeader()->getKinkPoint();
m_tailText->setTransformOriginPoint(DU::toQPointF(kink));
m_tailText->setRotation(angleDeg);
}
void QGIWeldSymbol::drawFieldFlag()
{
QPointF fieldFlagPos = getKinkPoint();
m_fieldFlag->setPos(fieldFlagPos);
if (getFeature()->FieldWeld.getValue()) {
m_fieldFlag->show();
} else {
m_fieldFlag->hide();
return;
}
auto localAxes = getLocalAxes();
auto xdir = localAxes.first;
auto ydir = localAxes.second;
// TODO: similar code used here and in QGITiled to handle leader points left. different actions, though.
// used here and QGITile.
Base::Vector3d stdX{1, 0, 0};
auto dot = stdX.Dot(xdir);
if (dot < 0) {
// our leader points left, so yDir should be +Y, but we need -Y up
ydir = -ydir;
}
// NOLINTBEGIN readability-magic-numbers
std::vector<QPointF> flagPoints = { QPointF(0.0, 0.0),
DU::toQPointF(ydir * 3.0),
DU::toQPointF(xdir * -2.0 + ydir * 2.5),
DU::toQPointF(ydir * 2.0) };
// NOLINTEND readability-magic-numbers
double scale = (float)PreferencesGui::dimFontSizePX() / 2;
QPainterPath path;
path.moveTo(flagPoints.at(0) * scale);
size_t iSeg = 1;
for ( ; iSeg < flagPoints.size(); iSeg++) {
path.lineTo(flagPoints.at(iSeg) * scale);
}
auto qgiLead = dynamic_cast<QGILeaderLine *>(getQGIVByName(getLeader()->getNameInDocument()));
if (qgiLead) {
m_fieldFlag->setWidth(qgiLead->getLineWidth());
}
m_fieldFlag->setZValue(ZVALUE::DIMENSION);
m_fieldFlag->setPath(path);
}
void QGIWeldSymbol::getTileFeats()
{
std::vector<TechDraw::DrawTileWeld*> tiles = getFeature()->getTiles();
m_arrowFeat = nullptr;
m_otherFeat = nullptr;
if (!tiles.empty()) {
TechDraw::DrawTileWeld* tempTile = tiles.at(0);
if (tempTile->TileRow.getValue() == 0) {
m_arrowFeat = tempTile;
} else {
m_otherFeat = tempTile;
}
}
if (tiles.size() > 1) {
TechDraw::DrawTileWeld* tempTile = tiles.at(1);
if (tempTile->TileRow.getValue() == 0) {
m_arrowFeat = tempTile;
} else {
m_otherFeat = tempTile;
}
}
}
void QGIWeldSymbol::removeQGITiles()
{
std::vector<QGITile*> tilesAll = getQGITiles();
for (auto tile: tilesAll) {
QList<QGraphicsItem*> tChildren = tile->childItems();
for (auto tc: tChildren) {
tile->removeFromGroup(tc);
scene()->removeItem(tc);
//tc gets deleted when QGIWS gets deleted
}
removeFromGroup(tile);
scene()->removeItem(tile);
delete tile;
}
}
std::vector<QGITile*> QGIWeldSymbol::getQGITiles() const
{
std::vector<QGITile*> result;
QList<QGraphicsItem*> children = childItems();
for (auto& child:children) {
auto tile = dynamic_cast<QGITile*>(child);
if (tile) {
result.push_back(tile);
}
}
return result;
}
void QGIWeldSymbol::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
{
Q_UNUSED(event);
if (isSelected()) {
setCurrentColor(getSelectColor());
setPrettySel();
} else {
setCurrentColor(getPreColor());
setPrettyPre();
}
QGIView::hoverEnterEvent(event);
}
void QGIWeldSymbol::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
{
Q_UNUSED(event);
if(isSelected()) {
setCurrentColor(getSelectColor());
setPrettySel();
} else {
setCurrentColor(getNormalColor());
setPrettyNormal();
}
QGIView::hoverLeaveEvent(event);
}
void QGIWeldSymbol::drawBorder()
{
////Weld Symbols have no border!
// QGIView::drawBorder(); //good for debugging
}
void QGIWeldSymbol::setPrettyNormal()
{
std::vector<QGITile*> tilesAll = getQGITiles();
for (auto tile: tilesAll) {
tile->setColor(getNormalColor());
tile->draw();
}
setCurrentColor(getNormalColor());
m_fieldFlag->setNormalColor(getNormalColor());
m_fieldFlag->setPrettyNormal();
m_allAround->setNormalColor(getNormalColor());
m_allAround->setPrettyNormal();
m_tailText->setColor(getNormalColor());
m_tailText->setPrettyNormal();
}
void QGIWeldSymbol::setPrettyPre()
{
std::vector<QGITile*> tilesAll = getQGITiles();
for (auto tile: tilesAll) {
tile->setColor(getPreColor());
tile->draw();
}
setCurrentColor(getPreColor());
m_fieldFlag->setNormalColor(getPreColor());
m_fieldFlag->setPrettyPre();
m_allAround->setNormalColor(getPreColor());
m_allAround->setPrettyPre();
m_tailText->setColor(getPreColor());
m_tailText->setPrettyPre();
}
void QGIWeldSymbol::setPrettySel()
{
std::vector<QGITile*> tilesAll = getQGITiles();
for (auto tile: tilesAll) {
tile->setColor(getSelectColor());
tile->draw();
}
setCurrentColor(getSelectColor());
m_fieldFlag->setNormalColor(getSelectColor());
m_fieldFlag->setPrettySel();
m_allAround->setNormalColor(getSelectColor());
m_allAround->setPrettySel();
m_tailText->setColor(getSelectColor());
m_tailText->setPrettySel();
}
QPointF QGIWeldSymbol::getTileOrigin()
{
Base::Vector3d org = getLeader()->getTileOrigin();
QPointF result = DU::toQPointF(Rez::guiX(org));
return result;
}
QPointF QGIWeldSymbol::getKinkPoint()
{
Base::Vector3d org = getLeader()->getKinkPoint();
QPointF result = DU::toQPointF(Rez::guiX(org));
return result;
}
QPointF QGIWeldSymbol::getTailPoint()
{
Base::Vector3d org = getLeader()->getTailPoint();
QPointF result = DU::toQPointF(Rez::guiX(org));
return result;
}
TechDraw::DrawWeldSymbol* QGIWeldSymbol::getFeature()
{
return dynamic_cast<TechDraw::DrawWeldSymbol *>(getViewObject());
}
TechDraw::DrawLeaderLine *QGIWeldSymbol::getLeader()
{
DrawWeldSymbol *feature = getFeature();
if (!feature) {
return nullptr;
}
return dynamic_cast<TechDraw::DrawLeaderLine *>(feature->Leader.getValue());
}
//! get the angle for the transformed last segment
double QGIWeldSymbol::getLastSegAngle()
{
auto lastSegDirection = getLeader()->lastSegmentDirection();
auto lastSegAngleRad = DU::angleWithX(lastSegDirection);
return Base::toDegrees(lastSegAngleRad);
}
std::pair<Base::Vector3d, Base::Vector3d> QGIWeldSymbol::getLocalAxes()
{
auto localX = getLeader()->lastSegmentDirection();
auto localY = DU::invertY(localX);
localY.RotateZ(std::numbers::pi/2);
localY.Normalize();
localY = DU::invertY(localY);
return {localX, localY};
}
//preference
QColor QGIWeldSymbol::prefNormalColor()
{
setNormalColor(PreferencesGui::leaderQColor());
return getNormalColor();
}
double QGIWeldSymbol::prefArrowSize() const
{
return PreferencesGui::dimArrowSize();
}
double QGIWeldSymbol::prefFontSize() const
{
return Preferences::labelFontSizeMM();
}
QRectF QGIWeldSymbol::boundingRect() const
{
return customBoundingRect();
}
QRectF QGIWeldSymbol::customBoundingRect() const
{
QRectF result;
if (m_tailText) {
QRectF childRect = mapFromItem(m_tailText, m_tailText->boundingRect()).boundingRect();
result = result.united(childRect);
}
if (m_fieldFlag) {
QRectF childRect = mapFromItem(m_fieldFlag, m_fieldFlag->boundingRect()).boundingRect();
result = result.united(childRect);
}
if (m_allAround) {
QRectF childRect = mapFromItem(m_allAround, m_allAround->boundingRect()).boundingRect();
result = result.united(childRect);
}
std::vector<QGITile*> qgTiles = getQGITiles();
for (auto& tile: qgTiles) {
QRectF childRect = mapFromItem(tile, tile->boundingRect()).boundingRect();
result = result.united(childRect);
}
return result;
}
QPainterPath QGIWeldSymbol::shape() const
{
return QGraphicsItemGroup::shape();
}
void QGIWeldSymbol::paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) {
QStyleOptionGraphicsItem myOption(*option);
myOption.state &= ~QStyle::State_Selected;
// painter->setPen(Qt::red);
// painter->drawRect(boundingRect()); //good for debugging
QGIView::paint (painter, &myOption, widget);
}
#include <Mod/TechDraw/Gui/moc_QGIWeldSymbol.cpp>
Reference in New Issue View Git Blame Copy Permalink