554 lines
16 KiB
C++
554 lines
16 KiB
C++
/***************************************************************************
|
|
* 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"
|
|
#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 "QGIWeldSymbol.h"
|
|
#include "PreferencesGui.h"
|
|
#include "QGCustomText.h"
|
|
#include "QGILeaderLine.h"
|
|
#include "QGIPrimPath.h"
|
|
#include "QGITile.h"
|
|
#include "QGIVertex.h"
|
|
|
|
#include "ViewProviderWeld.h"
|
|
#include "ZVALUE.h"
|
|
|
|
|
|
using namespace TechDraw;
|
|
using namespace TechDrawGui;
|
|
|
|
|
|
//**************************************************************
|
|
QGIWeldSymbol::QGIWeldSymbol() :
|
|
m_arrowFeat(nullptr),
|
|
m_otherFeat(nullptr),
|
|
m_tailText(nullptr),
|
|
m_fieldFlag(nullptr),
|
|
m_allAround(nullptr),
|
|
m_blockDraw(false)
|
|
{
|
|
setFiltersChildEvents(true); //qt5
|
|
setFlag(QGraphicsItem::ItemIsMovable, false);
|
|
|
|
setCacheMode(QGraphicsItem::NoCache);
|
|
setZValue(ZVALUE::DIMENSION);
|
|
|
|
m_tailText = new QGCustomText();
|
|
m_tailText->setPlainText(
|
|
QString::fromUtf8(" "));
|
|
addToGroup(m_tailText);
|
|
m_tailText->hide();
|
|
m_tailText->setPos(0.0, 0.0); //avoid bRect issues
|
|
|
|
m_allAround = new QGIVertex(-1);
|
|
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);
|
|
|
|
m_fieldFlag = new QGIPrimPath();
|
|
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)
|
|
{
|
|
// Base::Console().Message("QGIWS::itemChange(%d)\n", change);
|
|
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)
|
|
{
|
|
// Base::Console().Message("QGIWS::updateView()\n");
|
|
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()
|
|
{
|
|
// Base::Console().Message("QGIWS::draw()- %s\n", getFeature()->getNameInDocument());
|
|
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)
|
|
{
|
|
// Base::Console().Message("QGIWS::drawTile() - tileFeat: %X\n", tileFeat);
|
|
if (!tileFeat) {
|
|
Base::Console().Message("QGIWS::drawTile - tile is null\n");
|
|
return;
|
|
}
|
|
|
|
const auto sym = getFeature();
|
|
if (!sym)
|
|
return;
|
|
auto vp = dynamic_cast<ViewProviderWeld *>(getViewProvider(sym));
|
|
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();
|
|
// std::string symbolFile = tileFeat->SymbolFile.getValue();
|
|
int row = tileFeat->TileRow.getValue();
|
|
int col = tileFeat->TileColumn.getValue();
|
|
|
|
QGITile* 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->setSymbolFile(symbolFile);
|
|
tile->setZValue(ZVALUE::DIMENSION);
|
|
tile->setTileScale(featScale);
|
|
tile->setTailRight(getFeature()->isTailRightSide());
|
|
tile->setAltWeld(getFeature()->AlternatingWeld.getValue());
|
|
|
|
tile->draw();
|
|
}
|
|
|
|
void QGIWeldSymbol::drawAllAround()
|
|
{
|
|
// Base::Console().Message("QGIWS::drawAllAround()\n");
|
|
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(calculateFontPixelSize(getDimFontSize()));
|
|
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()
|
|
{
|
|
// Base::Console().Message("QGIWS::drawTailText()\n");
|
|
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;
|
|
} else {
|
|
m_tailText->show();
|
|
}
|
|
const auto sym = getFeature();
|
|
if (!sym)
|
|
return;
|
|
auto vp = dynamic_cast<ViewProviderWeld *>(getViewProvider(sym));
|
|
if (!vp) {
|
|
return;
|
|
}
|
|
QString qFontName = Base::Tools::fromStdString(vp->Font.getValue());
|
|
int fontSize = QGIView::exactFontSize(vp->Font.getValue(),
|
|
vp->FontSize.getValue());
|
|
|
|
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);
|
|
|
|
double textWidth = m_tailText->boundingRect().width();
|
|
double charWidth = textWidth / tText.size();
|
|
double hMargin = charWidth + prefArrowSize();
|
|
|
|
double textHeight = m_tailText->boundingRect().width();
|
|
double vFudge = textHeight * 0.1;
|
|
|
|
if (getFeature()->isTailRightSide()) {
|
|
m_tailText->justifyLeftAt(textPos.x() + hMargin, textPos.y() - vFudge, true);
|
|
} else {
|
|
m_tailText->justifyRightAt(textPos.x() - hMargin, textPos.y() - vFudge, true);
|
|
}
|
|
}
|
|
|
|
void QGIWeldSymbol::drawFieldFlag()
|
|
{
|
|
// Base::Console().Message("QGIWS::drawFieldFlag()\n");
|
|
QPointF fieldFlagPos = getKinkPoint();
|
|
m_fieldFlag->setPos(fieldFlagPos);
|
|
|
|
if (getFeature()->FieldWeld.getValue()) {
|
|
m_fieldFlag->show();
|
|
} else {
|
|
m_fieldFlag->hide();
|
|
return;
|
|
}
|
|
std::vector<QPointF> flagPoints = { QPointF(0.0, 0.0),
|
|
QPointF(0.0, -3.0),
|
|
QPointF(-2.0, -2.5),
|
|
QPointF(0.0, -2.0) };
|
|
//flag sb about 2x text?
|
|
// double scale = calculateFontPixelSize(getDimFontSize()) / 2.0;
|
|
double scale = PreferencesGui::dimFontSizePX() / 2.0;
|
|
QPainterPath path;
|
|
path.moveTo(flagPoints.at(0) * scale);
|
|
int i = 1;
|
|
int stop = flagPoints.size();
|
|
for ( ; i < stop; i++) {
|
|
path.lineTo(flagPoints.at(i) * 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*> tiles = getQGITiles();
|
|
for (auto t: tiles) {
|
|
QList<QGraphicsItem*> tChildren = t->childItems();
|
|
for (auto tc: tChildren) {
|
|
t->removeFromGroup(tc);
|
|
scene()->removeItem(tc);
|
|
//tc gets deleted when QGIWS gets deleted
|
|
}
|
|
removeFromGroup(t);
|
|
scene()->removeItem(t);
|
|
delete t;
|
|
}
|
|
}
|
|
|
|
std::vector<QGITile*> QGIWeldSymbol::getQGITiles() const
|
|
{
|
|
std::vector<QGITile*> result;
|
|
QList<QGraphicsItem*> children = childItems();
|
|
for (auto& c:children) {
|
|
QGITile* tile = dynamic_cast<QGITile*>(c);
|
|
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*> tiles = getQGITiles();
|
|
for (auto t: tiles) {
|
|
t->setColor(getNormalColor());
|
|
t->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*> tiles = getQGITiles();
|
|
for (auto t: tiles) {
|
|
t->setColor(getPreColor());
|
|
t->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*> tiles = getQGITiles();
|
|
for (auto t: tiles) {
|
|
t->setColor(getSelectColor());
|
|
t->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(org.x, org.y);
|
|
return result;
|
|
}
|
|
|
|
QPointF QGIWeldSymbol::getKinkPoint()
|
|
{
|
|
Base::Vector3d org = getLeader()->getKinkPoint();
|
|
QPointF result(org.x, org.y);
|
|
return result;
|
|
}
|
|
|
|
QPointF QGIWeldSymbol::getTailPoint()
|
|
{
|
|
Base::Vector3d org = getLeader()->getTailPoint();
|
|
QPointF result(org.x, org.y);
|
|
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());
|
|
}
|
|
|
|
//preference
|
|
QColor QGIWeldSymbol::prefNormalColor()
|
|
{
|
|
setNormalColor(PreferencesGui::leaderQColor());
|
|
return getNormalColor();
|
|
}
|
|
|
|
double QGIWeldSymbol::prefArrowSize()
|
|
{
|
|
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& t: qgTiles) {
|
|
QRectF childRect = mapFromItem(t, t->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>
|