605 lines
19 KiB
C++
605 lines
19 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 <BRep_Builder.hxx>
|
|
#include <TopoDS_Compound.hxx>
|
|
#include <TopoDS_Shape.hxx>
|
|
#include <TopoDS_Edge.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <BRepAdaptor_Curve.hxx>
|
|
#include <Precision.hxx>
|
|
|
|
#include <QGraphicsScene>
|
|
#include <QGraphicsSceneMouseEvent>
|
|
#include <QPainter>
|
|
#include <QPainterPath>
|
|
#include <QPaintDevice>
|
|
#include <QSvgGenerator>
|
|
#include <QVector2D>
|
|
#include <cmath>
|
|
#endif
|
|
|
|
#include <App/Application.h>
|
|
#include <App/Material.h>
|
|
#include <Base/Console.h>
|
|
#include <Base/Exception.h>
|
|
#include <Base/Parameter.h>
|
|
#include <Base/UnitsApi.h>
|
|
#include <Gui/Command.h>
|
|
|
|
#include <Mod/Part/App/PartFeature.h>
|
|
|
|
#include <Mod/TechDraw/App/DrawLeaderLine.h>
|
|
#include <Mod/TechDraw/App/DrawUtil.h>
|
|
#include <Mod/TechDraw/App/Geometry.h>
|
|
#include <Mod/TechDraw/App/LineGroup.h>
|
|
#include <Mod/TechDraw/App/ArrowPropEnum.h>
|
|
|
|
#include "Rez.h"
|
|
#include "ZVALUE.h"
|
|
#include "PreferencesGui.h"
|
|
#include "QGIArrow.h"
|
|
#include "ViewProviderLeader.h"
|
|
#include "QGIPrimPath.h"
|
|
#include "QGEPath.h"
|
|
|
|
#include "QGILeaderLine.h"
|
|
|
|
using namespace TechDrawGui;
|
|
using namespace TechDraw;
|
|
|
|
//**************************************************************
|
|
QGILeaderLine::QGILeaderLine() :
|
|
m_parentItem(nullptr),
|
|
m_lineWidth(1.0),
|
|
m_lineColor(Qt::black),
|
|
m_lineStyle(Qt::SolidLine),
|
|
m_editPathStyle(Qt::SolidLine),
|
|
m_hasHover(false),
|
|
m_saveX(0.0),
|
|
m_saveY(0.0),
|
|
m_blockDraw(false)
|
|
|
|
{
|
|
setHandlesChildEvents(false);
|
|
setAcceptHoverEvents(true);
|
|
setFlag(QGraphicsItem::ItemIsSelectable, true);
|
|
setFlag(QGraphicsItem::ItemIsMovable, false);
|
|
setFlag(QGraphicsItem::ItemSendsScenePositionChanges, false);
|
|
setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
|
|
|
|
setCacheMode(QGraphicsItem::NoCache);
|
|
|
|
m_line = new QGIPrimPath();
|
|
addToGroup(m_line);
|
|
m_line->setFlag(QGraphicsItem::ItemIsSelectable, false);
|
|
m_line->setAcceptHoverEvents(false);
|
|
m_line->setPos(0.0, 0.0);
|
|
|
|
m_editPath = new QGEPath(this);
|
|
addToGroup(m_editPath);
|
|
m_editPath->setPos(0.0, 0.0);
|
|
m_editPath->setFlag(QGraphicsItem::ItemIsSelectable, false);
|
|
m_editPath->setFlag(QGraphicsItem::ItemIsMovable, false);
|
|
setFlag(QGraphicsItem::ItemSendsScenePositionChanges, false);
|
|
m_editPath->setZValue(ZVALUE::DIMENSION);
|
|
m_editPath->hide();
|
|
|
|
m_arrow1 = new QGIArrow();
|
|
addToGroup(m_arrow1);
|
|
m_arrow1->setPos(0.0, 0.0);
|
|
m_arrow1->hide();
|
|
m_arrow2 = new QGIArrow();
|
|
addToGroup(m_arrow2);
|
|
m_arrow2->setPos(0.0, 0.0);
|
|
m_arrow2->hide();
|
|
|
|
setZValue(ZVALUE::DIMENSION);
|
|
|
|
QObject::connect(
|
|
m_editPath, SIGNAL(pointsUpdated(QPointF, std::vector<QPointF>)),
|
|
this , SLOT (onLineEditFinished(QPointF, std::vector<QPointF>))
|
|
);
|
|
}
|
|
|
|
void QGILeaderLine::setLeaderFeature(TechDraw::DrawLeaderLine* feat)
|
|
{
|
|
// Base::Console().Message("QGILL::setLeaderFeature()\n");
|
|
setViewFeature(static_cast<TechDraw::DrawView *>(feat));
|
|
|
|
float x = Rez::guiX(feat->X.getValue());
|
|
float y = Rez::guiX(-feat->Y.getValue());
|
|
setPos(x, y);
|
|
|
|
setNormalColorAll();
|
|
setPrettyNormal();
|
|
|
|
updateView();
|
|
}
|
|
|
|
QVariant QGILeaderLine::itemChange(GraphicsItemChange change, const QVariant &value)
|
|
{
|
|
// Base::Console().Message("QGILL::itemChange(%d)\n", change);
|
|
if (change == ItemSelectedHasChanged && scene()) {
|
|
if(isSelected()) {
|
|
setPrettySel();
|
|
} else {
|
|
setPrettyNormal();
|
|
}
|
|
draw();
|
|
} else if(change == ItemSceneChange && scene()) {
|
|
// nothing special!
|
|
}
|
|
return QGIView::itemChange(change, value);
|
|
}
|
|
|
|
//QGILL isn't draggable so skip QGIV::mousePress have event
|
|
void QGILeaderLine::mousePressEvent(QGraphicsSceneMouseEvent * event)
|
|
{
|
|
// Base::Console().Message("QGILL::mousePressEvent() - %s\n", getViewName());
|
|
QGraphicsItem::mousePressEvent(event);
|
|
}
|
|
|
|
//QGILL isn't draggable so skip QGIV::mouseRelease
|
|
void QGILeaderLine::mouseReleaseEvent(QGraphicsSceneMouseEvent * event)
|
|
{
|
|
// Base::Console().Message("QGILL::mouseReleaseEvent() - %s\n", getViewName());
|
|
QGraphicsItem::mouseReleaseEvent(event);
|
|
}
|
|
|
|
void QGILeaderLine::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
|
|
{
|
|
// Base::Console().Message("QGILL::hoverEnter() - selected; %d\n", isSelected());
|
|
m_hasHover = true;
|
|
if (!isSelected()) {
|
|
setPrettyPre();
|
|
}
|
|
QGIView::hoverEnterEvent(event);
|
|
}
|
|
|
|
void QGILeaderLine::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
|
|
{
|
|
// Base::Console().Message("QGILL::hoverLeave() - selected; %d\n", isSelected());
|
|
m_hasHover = false;
|
|
if(!isSelected()) {
|
|
setPrettyNormal();
|
|
}
|
|
QGIView::hoverLeaveEvent(event);
|
|
}
|
|
|
|
void QGILeaderLine::onSourceChange(TechDraw::DrawView* newParent)
|
|
{
|
|
// Base::Console().Message("QGILL::onSoureChange(%s)\n", newParent->getNameInDocument());
|
|
std::string parentName = newParent->getNameInDocument();
|
|
QGIView* qgiParent = getQGIVByName(parentName);
|
|
if (qgiParent) {
|
|
m_parentItem = qgiParent;
|
|
setParentItem(m_parentItem);
|
|
draw();
|
|
} else {
|
|
Base::Console().Warning("QGILL::onSourceChange - new parent %s has no QGIView\n", parentName.c_str());
|
|
}
|
|
}
|
|
|
|
void QGILeaderLine::setNormalColorAll()
|
|
{
|
|
// Base::Console().Message("QGILL::setNormalColorAll - normal color: %s\n", qPrintable(getNormalColor().name()));
|
|
m_line->setNormalColor(getNormalColor());
|
|
m_editPath->setNormalColor(getNormalColor());
|
|
m_arrow1->setNormalColor(getNormalColor());
|
|
m_arrow1->setFillColor(getNormalColor());
|
|
m_arrow2->setNormalColor(getNormalColor());
|
|
m_arrow2->setFillColor(getNormalColor());
|
|
}
|
|
|
|
void QGILeaderLine::setPrettyNormal() {
|
|
// Base::Console().Message("QGILL::setPrettyNormal()\n");
|
|
m_line->setPrettyNormal();
|
|
m_arrow1->setPrettyNormal();
|
|
m_arrow2->setPrettyNormal();
|
|
}
|
|
|
|
void QGILeaderLine::setPrettyPre() {
|
|
// Base::Console().Message("QGILL::setPrettyPre()\n");
|
|
m_line->setPrettyPre();
|
|
m_arrow1->setPrettyPre();
|
|
m_arrow2->setPrettyPre();
|
|
}
|
|
|
|
void QGILeaderLine::setPrettySel() {
|
|
// Base::Console().Message("QGILL::setPrettySel()\n");
|
|
m_line->setPrettySel();
|
|
m_arrow1->setPrettySel();
|
|
m_arrow2->setPrettySel();
|
|
}
|
|
|
|
|
|
void QGILeaderLine::closeEdit()
|
|
{
|
|
// Base::Console().Message("QGIL::closeEdit()\n");
|
|
if (m_editPath) {
|
|
m_editPath->onEndEdit(); //tell QEPath that edit session ended
|
|
}
|
|
}
|
|
|
|
//signaled from QEPath
|
|
void QGILeaderLine::onLineEditFinished(QPointF tipDisplace, std::vector<QPointF> points)
|
|
{
|
|
// Base::Console().Message("QGILL::onLineEditFinished(%s, %d)\n",
|
|
// TechDraw::DrawUtil::formatVector(tipDisplace).c_str(),
|
|
// points.size());
|
|
m_blockDraw = true;
|
|
auto featLeader = getFeature();
|
|
if (!featLeader)
|
|
return;
|
|
double baseScale = featLeader->getBaseScale();
|
|
|
|
if ( !(TechDraw::DrawUtil::fpCompare(tipDisplace.x(), 0.0) &&
|
|
TechDraw::DrawUtil::fpCompare(tipDisplace.y(), 0.0)) ) {
|
|
//tip was moved. need to change AttachPoint
|
|
QPointF oldAttach = getAttachFromFeature();
|
|
QPointF newAttach = oldAttach + (tipDisplace / baseScale);
|
|
featLeader->setPosition(Rez::appX(newAttach.x()),
|
|
Rez::appX(- newAttach.y()),
|
|
true);
|
|
}
|
|
|
|
std::vector<Base::Vector3d> waypoints;
|
|
for (auto& p: points) {
|
|
QPointF moved = p - tipDisplace;
|
|
Base::Vector3d v(moved.x(), moved.y(), 0.0);
|
|
waypoints.push_back(v);
|
|
}
|
|
waypoints.at(0) = Base::Vector3d(0.0, 0.0, 0.0);
|
|
|
|
featLeader->WayPoints.setValues(waypoints);
|
|
if (featLeader->AutoHorizontal.getValue()) {
|
|
featLeader->adjustLastSegment();
|
|
}
|
|
|
|
Q_EMIT editComplete(); //tell task editing is complete
|
|
|
|
m_blockDraw = false;
|
|
m_editPath->hide();
|
|
draw();
|
|
}
|
|
|
|
void QGILeaderLine::startPathEdit()
|
|
{
|
|
saveState();
|
|
auto featLeader( dynamic_cast<TechDraw::DrawLeaderLine*>(getViewObject()) );
|
|
if (!featLeader)
|
|
return;
|
|
|
|
double scale = featLeader->getScale();
|
|
m_editPath->setScale(scale);
|
|
m_editPath->inEdit(true);
|
|
m_editPath->show();
|
|
m_editPath->startPathEdit(getWayPointsFromFeature());
|
|
}
|
|
|
|
void QGILeaderLine::saveState()
|
|
{
|
|
// Base::Console().Message("QGILL::saveState()\n");
|
|
auto featLeader = getFeature();
|
|
if (featLeader) {
|
|
m_savePoints = featLeader->WayPoints.getValues();
|
|
m_saveX = featLeader->X.getValue();
|
|
m_saveY = featLeader->Y.getValue();
|
|
}
|
|
}
|
|
|
|
void QGILeaderLine::restoreState()
|
|
{
|
|
// Base::Console().Message("QGILL::restoreState()\n");
|
|
auto featLeader = getFeature();
|
|
if (featLeader) {
|
|
featLeader->WayPoints.setValues(m_savePoints);
|
|
featLeader->X.setValue(m_saveX);
|
|
featLeader->Y.setValue(m_saveY);
|
|
featLeader->recomputeFeature();
|
|
}
|
|
}
|
|
|
|
//******************************************************************************
|
|
|
|
void QGILeaderLine::updateView(bool update)
|
|
{
|
|
// Base::Console().Message("QGIL::updateView() %s\n", getViewObject()->getNameInDocument());
|
|
Q_UNUSED(update);
|
|
auto featLeader( dynamic_cast<TechDraw::DrawLeaderLine*>(getViewObject()) );
|
|
if (!featLeader) {
|
|
Base::Console().Warning("QGILL::updateView - no feature!\n");
|
|
return;
|
|
}
|
|
|
|
auto vp = static_cast<ViewProviderLeader*>(getViewProvider(getViewObject()));
|
|
if (!vp)
|
|
return;
|
|
draw();
|
|
}
|
|
|
|
void QGILeaderLine::draw()
|
|
{
|
|
// Base::Console().Message("QGILL::draw()- %s\n", getViewObject()->getNameInDocument());
|
|
if (m_blockDraw)
|
|
return;
|
|
if (!isVisible())
|
|
return;
|
|
TechDraw::DrawLeaderLine* featLeader = getFeature();
|
|
if (!featLeader)
|
|
return;
|
|
auto vp = static_cast<ViewProviderLeader*>(getViewProvider(getViewObject()));
|
|
if (!vp)
|
|
return;
|
|
|
|
double scale = 1.0;
|
|
TechDraw::DrawView* parent = featLeader->getBaseView();
|
|
if (parent)
|
|
scale = parent->getScale();
|
|
|
|
if (m_editPath->inEdit())
|
|
return;
|
|
|
|
//********
|
|
if (featLeader->isLocked())
|
|
setFlag(QGraphicsItem::ItemIsMovable, false);
|
|
else
|
|
setFlag(QGraphicsItem::ItemIsMovable, true);
|
|
m_lineStyle = (Qt::PenStyle) vp->LineStyle.getValue();
|
|
|
|
double baseScale = featLeader->getBaseScale();
|
|
double x = Rez::guiX(featLeader->X.getValue());
|
|
double y = - Rez::guiX(featLeader->Y.getValue());
|
|
QPointF aPoint(x, y);
|
|
aPoint *= baseScale;
|
|
setPos(aPoint);
|
|
|
|
m_line->setFillStyle(Qt::NoBrush);
|
|
m_line->setStyle(m_lineStyle);
|
|
m_line->setWidth(getLineWidth());
|
|
|
|
m_line->setPos(0, 0); //make m_line coords == leader coords
|
|
|
|
std::vector<QPointF> qPoints = getWayPointsFromFeature();
|
|
if (featLeader->Scalable.getValue()) {
|
|
for (auto& p : qPoints) {
|
|
p = p * scale;
|
|
}
|
|
}
|
|
|
|
setNormalColorAll();
|
|
m_line->setPath(makeLeaderPath(qPoints));
|
|
setArrows(qPoints);
|
|
|
|
if (isSelected()) {
|
|
setPrettySel();
|
|
} else if (m_hasHover) {
|
|
setPrettyPre();
|
|
} else {
|
|
setPrettyNormal();
|
|
}
|
|
update(boundingRect());
|
|
}
|
|
|
|
QPainterPath QGILeaderLine::makeLeaderPath(std::vector<QPointF> qPoints)
|
|
{
|
|
// Base::Console().Message("QGILeaderLine::makeLeaderPath()\n");
|
|
QPainterPath result;
|
|
DrawLeaderLine* featLeader = getFeature();
|
|
if (!featLeader) {
|
|
Base::Console().Message("QGILL::makeLeaderPath - featLeader is nullptr\n");
|
|
return result;
|
|
}
|
|
|
|
QPointF startAdjVec(0.0, 0.0);
|
|
double startAdjLength(0.0);
|
|
QPointF endAdjVec(0.0, 0.0);
|
|
double endAdjLength(0.0);
|
|
if (qPoints.size() > 1) {
|
|
//make path adjustment to hide leaderline ends behind arrowheads
|
|
if (featLeader->StartSymbol.getValue() != ArrowType::NONE) {
|
|
startAdjLength = QGIArrow::getOverlapAdjust(featLeader->StartSymbol.getValue(),
|
|
QGIArrow::getPrefArrowSize());
|
|
}
|
|
if (featLeader->EndSymbol.getValue() != ArrowType::NONE) {
|
|
endAdjLength = QGIArrow::getOverlapAdjust(featLeader->EndSymbol.getValue(),
|
|
QGIArrow::getPrefArrowSize());
|
|
}
|
|
|
|
//get adjustment directions
|
|
startAdjVec = qPoints.at(1) - qPoints.front();
|
|
endAdjVec = (*(qPoints.end() - 2))- qPoints.back();
|
|
|
|
//get adjustment vectors
|
|
QVector2D startTemp(startAdjVec);
|
|
QVector2D endTemp(endAdjVec);
|
|
startTemp.normalize();
|
|
endTemp.normalize();
|
|
startAdjVec = startTemp.toPointF() * startAdjLength;
|
|
endAdjVec = endTemp.toPointF() * endAdjLength;
|
|
|
|
qPoints.front() += startAdjVec;
|
|
qPoints.back() += endAdjVec;
|
|
result.moveTo(qPoints.front());
|
|
for (int i = 1; i < (int)qPoints.size(); i++) {
|
|
result.lineTo(qPoints.at(i));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
QPointF QGILeaderLine::getAttachFromFeature()
|
|
{
|
|
// Base::Console().Message("QGILL::getAttachFromFeature()\n");
|
|
QPointF result;
|
|
TechDraw::DrawLeaderLine* featLeader = getFeature();
|
|
if((!featLeader) ) {
|
|
Base::Console().Message("QGIL::getAttachFromLeader - no feature\n");
|
|
return result;
|
|
}
|
|
double x = Rez::guiX(featLeader->X.getValue());
|
|
double y = - Rez::guiX(featLeader->Y.getValue());
|
|
result = QPointF(x, y);
|
|
return result;
|
|
}
|
|
|
|
std::vector<QPointF> QGILeaderLine::getWayPointsFromFeature()
|
|
{
|
|
std::vector<QPointF> qPoints;
|
|
|
|
DrawLeaderLine* featLeader = getFeature();
|
|
if (!featLeader) {
|
|
Base::Console().Message("QGILL::getWayPointsFromFeature - featLeader is nullptr\n");
|
|
return qPoints;
|
|
}
|
|
|
|
std::vector<Base::Vector3d> vPoints = featLeader->WayPoints.getValues();
|
|
for (auto& d: vPoints) {
|
|
QPointF temp(d.x, d.y);
|
|
qPoints.push_back(temp);
|
|
}
|
|
if (qPoints.empty()) {
|
|
Base::Console().Warning("QGILeaderLine::getWayPointsFromFeature - no points\n");
|
|
}
|
|
return qPoints;
|
|
}
|
|
|
|
void QGILeaderLine::setArrows(std::vector<QPointF> pathPoints)
|
|
{
|
|
// Base::Console().Message("QGILL::setArrows()\n");
|
|
Base::Vector3d stdX(1.0, 0.0, 0.0);
|
|
TechDraw::DrawLeaderLine* featLeader = getFeature();
|
|
|
|
QPointF lastOffset = (pathPoints.back() - pathPoints.front());
|
|
|
|
if (featLeader->StartSymbol.getValue() != ArrowType::NONE) {
|
|
m_arrow1->setStyle(featLeader->StartSymbol.getValue());
|
|
m_arrow1->setWidth(getLineWidth());
|
|
// TODO: variable size arrow heads
|
|
m_arrow1->setSize(QGIArrow::getPrefArrowSize());
|
|
m_arrow1->setDirMode(true);
|
|
m_arrow1->setDirection(stdX);
|
|
if (pathPoints.size() > 1) {
|
|
auto it = pathPoints.begin();
|
|
QPointF s = (*it);
|
|
QPointF e = (*(it + 1));
|
|
QPointF qsVec = s - e;
|
|
Base::Vector3d sVec(qsVec.x(), qsVec.y(), 0.0);
|
|
m_arrow1->setDirection(sVec);
|
|
m_arrow1->setPos(0.0, 0.0);
|
|
}
|
|
m_arrow1->draw();
|
|
m_arrow1->show();
|
|
} else {
|
|
m_arrow1->hide();
|
|
}
|
|
|
|
if (featLeader->EndSymbol.getValue() != ArrowType::NONE) {
|
|
m_arrow2->setStyle(featLeader->EndSymbol.getValue());
|
|
m_arrow2->setWidth(getLineWidth());
|
|
m_arrow2->setDirMode(true);
|
|
m_arrow2->setDirection(-stdX);
|
|
if (pathPoints.size() > 1) {
|
|
auto itr = pathPoints.rbegin();
|
|
QPointF s = (*itr);
|
|
QPointF e = (*(itr + 1));
|
|
QPointF qeVec = s - e;
|
|
Base::Vector3d eVec(qeVec.x(), qeVec.y(), 0.0);
|
|
m_arrow2->setDirection(eVec);
|
|
m_arrow2->setPos(lastOffset);
|
|
}
|
|
m_arrow2->draw();
|
|
m_arrow2->show();
|
|
} else {
|
|
m_arrow2->hide();
|
|
}
|
|
}
|
|
|
|
void QGILeaderLine::drawBorder()
|
|
{
|
|
////Leaders have no border!
|
|
// QGIView::drawBorder(); //good for debugging
|
|
}
|
|
|
|
//******************************************************************************
|
|
|
|
|
|
void QGILeaderLine::abandonEdit()
|
|
{
|
|
// Base::Console().Message("QGIL::abandonEdit()\n");
|
|
m_editPath->clearMarkers();
|
|
m_editPath->hide();
|
|
restoreState();
|
|
}
|
|
|
|
double QGILeaderLine::getLineWidth()
|
|
{
|
|
auto vp = static_cast<ViewProviderLeader*>(getViewProvider(getViewObject()));
|
|
if (!vp)
|
|
return Rez::guiX(LineGroup::getDefaultWidth("Graphic"));
|
|
return Rez::guiX(vp->LineWidth.getValue());
|
|
}
|
|
|
|
TechDraw::DrawLeaderLine* QGILeaderLine::getFeature()
|
|
{
|
|
TechDraw::DrawLeaderLine* result =
|
|
static_cast<TechDraw::DrawLeaderLine*>(getViewObject());
|
|
return result;
|
|
}
|
|
|
|
double QGILeaderLine::getEdgeFuzz() const
|
|
{
|
|
return PreferencesGui::edgeFuzz();
|
|
}
|
|
|
|
QColor QGILeaderLine::prefNormalColor()
|
|
{
|
|
// Base::Console().Message("QGILL::getNormalColor()\n");
|
|
setNormalColor(PreferencesGui::leaderQColor());
|
|
|
|
auto vp = dynamic_cast<ViewProviderLeader*>(getViewProvider(getViewObject()));
|
|
if (vp) {
|
|
setNormalColor(vp->Color.getValue().asValue<QColor>());
|
|
}
|
|
return getNormalColor();
|
|
}
|
|
|
|
QRectF QGILeaderLine::boundingRect() const
|
|
{
|
|
return childrenBoundingRect();
|
|
}
|
|
|
|
void QGILeaderLine::paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) {
|
|
QStyleOptionGraphicsItem myOption(*option);
|
|
myOption.state &= ~QStyle::State_Selected;
|
|
|
|
// painter->setPen(Qt::blue);
|
|
// painter->drawRect(boundingRect()); //good for debugging
|
|
|
|
QGIView::paint (painter, &myOption, widget);
|
|
}
|
|
|
|
#include <Mod/TechDraw/Gui/moc_QGILeaderLine.cpp>
|