mirror of
https://gitlab.com/smart-pattern/valentina.git
synced 2024-06-28 07:08:12 +02:00
719 lines
23 KiB
C++
719 lines
23 KiB
C++
/************************************************************************
|
|
**
|
|
** @file vgrainlineitem.cpp
|
|
** @author Bojan Kverh
|
|
** @date September 10, 2016
|
|
**
|
|
** @brief
|
|
** @copyright
|
|
** This source code is part of the Valentina project, a pattern making
|
|
** program, whose allow create and modeling patterns of clothing.
|
|
** Copyright (C) 2013-2015 Valentina project
|
|
** <https://gitlab.com/smart-pattern/valentina> All Rights Reserved.
|
|
**
|
|
** Valentina is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation, either version 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** Valentina 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 General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
|
|
**
|
|
*************************************************************************/
|
|
|
|
#include <QDebug>
|
|
#include <QGraphicsScene>
|
|
#include <QGraphicsSceneMouseEvent>
|
|
#include <QGraphicsView>
|
|
#include <QPainter>
|
|
#include <QStyleOptionGraphicsItem>
|
|
#include <QtMath>
|
|
#include <cmath>
|
|
|
|
#include "../vmisc/def.h"
|
|
#include "../vmisc/literals.h"
|
|
#include "../vmisc/theme/vscenestylesheet.h"
|
|
#include "../vmisc/vabstractapplication.h"
|
|
#include "global.h"
|
|
#include "vgrainlineitem.h"
|
|
#include "vpiecegrainline.h"
|
|
|
|
constexpr int rectWidth = 30;
|
|
constexpr int resizeRectSize = 10;
|
|
constexpr int rotateCircR = 7;
|
|
constexpr int activeZ = 10;
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::VGrainlineItem constructor
|
|
* @param pParent pointer to the parent item
|
|
*/
|
|
VGrainlineItem::VGrainlineItem(VColorRole role, QGraphicsItem *pParent)
|
|
: VPieceItem(pParent),
|
|
m_penWidth(VAbstractApplication::VApp()->Settings()->WidthMainLine()),
|
|
m_role(role)
|
|
{
|
|
setAcceptHoverEvents(true);
|
|
m_inactiveZ = 5;
|
|
Reset();
|
|
UpdateRectangle();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto VGrainlineItem::shape() const -> QPainterPath
|
|
{
|
|
if (m_eMode == mNormal)
|
|
{
|
|
return MainShape();
|
|
}
|
|
|
|
QPainterPath path;
|
|
path.addPolygon(m_polyBound);
|
|
return path;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::paint paints the item content
|
|
* @param pP pointer to the painter object
|
|
* @param pOption not used
|
|
* @param pWidget not used
|
|
*/
|
|
void VGrainlineItem::paint(QPainter *pP, const QStyleOptionGraphicsItem *pOption, QWidget *pWidget)
|
|
{
|
|
Q_UNUSED(pOption)
|
|
Q_UNUSED(pWidget)
|
|
pP->save();
|
|
QColor clr = m_color;
|
|
|
|
if (m_role != VColorRole::CustomColor)
|
|
{
|
|
clr = VSceneStylesheet::Color(m_role);
|
|
}
|
|
|
|
const qreal width = ScaleWidth(VAbstractApplication::VApp()->Settings()->WidthHairLine(), SceneScale(scene()));
|
|
pP->setPen(QPen(clr, width, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin));
|
|
pP->setRenderHints(QPainter::Antialiasing);
|
|
|
|
VPieceGrainline grainline(QPointF(), m_dLength, m_dRotation, m_eArrowType);
|
|
// main line
|
|
const QLineF mainLine = grainline.GetMainLine();
|
|
pP->drawLine(mainLine.p1(), mainLine.p2());
|
|
|
|
pP->setBrush(clr);
|
|
|
|
if (grainline.IsArrowUpEnabled())
|
|
{
|
|
pP->drawPolygon(grainline.ArrowUp());
|
|
}
|
|
|
|
if (grainline.IsArrowDownEnabled())
|
|
{
|
|
pP->drawPolygon(grainline.ArrowDown());
|
|
}
|
|
|
|
if (grainline.IsFourWays())
|
|
{
|
|
// secondary line
|
|
const QLineF secondaryLine = grainline.SecondaryLine();
|
|
pP->drawLine(secondaryLine.p1(), secondaryLine.p2());
|
|
|
|
if (grainline.IsArrowLeftEnabled())
|
|
{
|
|
pP->drawPolygon(grainline.ArrowLeft());
|
|
}
|
|
|
|
if (grainline.IsArrowRightEnabled())
|
|
{
|
|
pP->drawPolygon(grainline.ArrowRight());
|
|
}
|
|
}
|
|
|
|
if (m_eMode != mNormal)
|
|
{
|
|
pP->setPen(QPen(clr, 2, Qt::DashLine));
|
|
pP->setBrush(Qt::NoBrush);
|
|
// bounding polygon
|
|
pP->drawPolygon(m_polyBound);
|
|
pP->setPen(QPen(clr, 3));
|
|
|
|
if (m_eMode != mRotate)
|
|
{
|
|
pP->setBrush(clr);
|
|
UpdatePolyResize();
|
|
pP->drawPolygon(m_polyResize);
|
|
}
|
|
|
|
pP->setBrush(Qt::NoBrush);
|
|
if (m_eMode == mResize)
|
|
{
|
|
pP->setPen(clr);
|
|
pP->drawLine(m_polyBound.at(0), m_polyBound.at(2));
|
|
pP->drawLine(m_polyBound.at(1), m_polyBound.at(3));
|
|
}
|
|
|
|
if (m_eMode == mRotate)
|
|
{
|
|
QPointF ptC = (m_polyBound.at(0) + m_polyBound.at(2)) / 2;
|
|
qreal dRad = rotateCircR;
|
|
pP->setBrush(clr);
|
|
pP->drawEllipse(ptC, dRad, dRad);
|
|
|
|
pP->setBrush(Qt::NoBrush);
|
|
pP->save();
|
|
pP->translate(ptC);
|
|
pP->rotate(qRadiansToDegrees(-m_dRotation));
|
|
int iX = qRound(m_dLength / 2 - 0.5 * dRad);
|
|
int iY = grainline.IsFourWays() ? qRound((m_dLength / 2) - 0.8 * dRad) : qRound(rectWidth - 0.5 * dRad);
|
|
int iR = qRound(dRad * 3);
|
|
pP->drawArc(iX - iR, iY - iR, iR, iR, 0 * 16, -90 * 16);
|
|
pP->drawArc(-iX, iY - iR, iR, iR, 270 * 16, -90 * 16);
|
|
pP->drawArc(-iX, -iY, iR, iR, 180 * 16, -90 * 16);
|
|
pP->drawArc(iX - iR, -iY, iR, iR, 90 * 16, -90 * 16);
|
|
pP->restore();
|
|
}
|
|
}
|
|
pP->restore();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::UpdateGeometry updates the item with grainline parameters
|
|
* @param ptPos position of one grainline's end
|
|
* @param dRotation rotation of the grainline in [degrees]
|
|
* @param dLength length of the grainline in user's units
|
|
*/
|
|
void VGrainlineItem::UpdateGeometry(const QPointF &ptPos, qreal dRotation, qreal dLength, GrainlineArrowDirection eAT)
|
|
{
|
|
m_dRotation = qDegreesToRadians(dRotation);
|
|
m_dLength = dLength;
|
|
m_eArrowType = eAT;
|
|
|
|
VPieceGrainline grainline(ptPos, m_dLength, m_dRotation, m_eArrowType);
|
|
qreal dX;
|
|
qreal dY;
|
|
QPointF pt = ptPos;
|
|
if (not grainline.IsContained(parentItem()->boundingRect(), dX, dY))
|
|
{
|
|
pt.setX(pt.x() + dX);
|
|
pt.setY(pt.y() + dY);
|
|
}
|
|
setPos(pt);
|
|
|
|
UpdateRectangle();
|
|
Update();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto VGrainlineItem::Grainline() const -> VPieceGrainline
|
|
{
|
|
return {QLineF(m_ptStart, m_ptFinish), m_eArrowType};
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::mousePressEvent handles left button mouse press events
|
|
* @param pME pointer to QGraphicsSceneMouseEvent object
|
|
*/
|
|
void VGrainlineItem::mousePressEvent(QGraphicsSceneMouseEvent *pME)
|
|
{
|
|
if (pME->button() == Qt::LeftButton && pME->type() != QEvent::GraphicsSceneMouseDoubleClick &&
|
|
(flags() & QGraphicsItem::ItemIsMovable))
|
|
{
|
|
if (m_moveType == NotMovable)
|
|
{
|
|
pME->ignore();
|
|
return;
|
|
}
|
|
|
|
pME->accept();
|
|
|
|
m_ptStartPos = pos();
|
|
m_ptStartMove = pME->scenePos();
|
|
m_dStartLength = m_dLength;
|
|
m_dStartRotation = m_dRotation;
|
|
m_dAngle = GetAngle(mapToParent(pME->pos()));
|
|
m_ptRotCenter = m_ptCenter;
|
|
|
|
if ((m_moveType & AllModifications) == AllModifications)
|
|
{
|
|
AllUserModifications(pME->pos());
|
|
setZValue(activeZ);
|
|
Update();
|
|
}
|
|
else if (m_moveType & IsRotatable)
|
|
{
|
|
if (m_moveType & IsResizable)
|
|
{
|
|
AllUserModifications(pME->pos());
|
|
}
|
|
else if (m_moveType & IsMovable)
|
|
{
|
|
UserRotateAndMove();
|
|
}
|
|
else
|
|
{
|
|
m_eMode = mRotate;
|
|
SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
|
|
}
|
|
setZValue(activeZ);
|
|
Update();
|
|
}
|
|
else if (m_moveType & IsResizable)
|
|
{
|
|
if (m_moveType & IsRotatable)
|
|
{
|
|
AllUserModifications(pME->pos());
|
|
}
|
|
else if (m_moveType & IsMovable)
|
|
{
|
|
UserMoveAndResize(pME->pos());
|
|
}
|
|
setZValue(activeZ);
|
|
Update();
|
|
}
|
|
else if (m_moveType & IsMovable)
|
|
{
|
|
if (m_moveType & IsRotatable)
|
|
{
|
|
UserRotateAndMove();
|
|
}
|
|
else if (m_moveType & IsResizable)
|
|
{
|
|
UserMoveAndResize(pME->pos());
|
|
}
|
|
else
|
|
{
|
|
m_eMode = mMove;
|
|
SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
|
|
}
|
|
|
|
setZValue(activeZ);
|
|
Update();
|
|
}
|
|
else
|
|
{
|
|
pME->ignore();
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::mouseMoveEvent handles mouse move events, making sure that the item is moved properly
|
|
* @param pME pointer to QGraphicsSceneMouseEvent object
|
|
*/
|
|
void VGrainlineItem::mouseMoveEvent(QGraphicsSceneMouseEvent *pME)
|
|
{
|
|
QPointF ptDiff = pME->scenePos() - m_ptStartMove;
|
|
qreal dX;
|
|
qreal dY;
|
|
if (m_eMode == mMove && m_moveType & IsMovable)
|
|
{
|
|
QPointF pt = m_ptStartPos + ptDiff;
|
|
VPieceGrainline grainline(pt, m_dLength, m_dRotation, m_eArrowType);
|
|
if (not grainline.IsContained(parentItem()->boundingRect(), dX, dY))
|
|
{
|
|
pt.setX(pt.x() + dX);
|
|
pt.setY(pt.y() + dY);
|
|
}
|
|
setPos(pt);
|
|
Update();
|
|
}
|
|
else if (m_eMode == mResize && m_moveType & IsResizable)
|
|
{
|
|
qreal dLen = qSqrt(ptDiff.x() * ptDiff.x() + ptDiff.y() * ptDiff.y());
|
|
qreal dAng = qAtan2(-ptDiff.y(), ptDiff.x());
|
|
dLen = -dLen * qCos(dAng - m_dRotation);
|
|
qreal dPrevLen = m_dLength;
|
|
// try with new length
|
|
if (not(m_moveType & IsMovable))
|
|
{
|
|
dLen *= 2;
|
|
}
|
|
|
|
if (m_dStartLength + dLen < ToPixel(5, Unit::Mm))
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_dLength = m_dStartLength + dLen;
|
|
|
|
QPointF pos;
|
|
|
|
if (m_moveType & IsMovable)
|
|
{
|
|
QLineF grainline(this->pos().x(), this->pos().y(), this->pos().x() + dPrevLen, this->pos().y());
|
|
grainline.setAngle(qRadiansToDegrees(m_dRotation));
|
|
grainline = QLineF(grainline.p2(), grainline.p1());
|
|
grainline.setLength(m_dLength);
|
|
pos = grainline.p2();
|
|
}
|
|
else
|
|
{
|
|
QLineF grainline(m_ptCenter.x(), m_ptCenter.y(), m_ptCenter.x() + m_dLength / 2.0, m_ptCenter.y());
|
|
|
|
grainline.setAngle(qRadiansToDegrees(m_dRotation));
|
|
grainline = QLineF(grainline.p2(), grainline.p1());
|
|
grainline.setLength(m_dLength);
|
|
|
|
pos = grainline.p2();
|
|
}
|
|
|
|
qreal dX;
|
|
qreal dY;
|
|
VPieceGrainline grainline(pos, m_dLength, m_dRotation, m_eArrowType);
|
|
if (not grainline.IsContained(parentItem()->boundingRect(), dX, dY))
|
|
{
|
|
m_dLength = dPrevLen;
|
|
}
|
|
else
|
|
{
|
|
setPos(pos);
|
|
}
|
|
|
|
UpdateRectangle();
|
|
Update();
|
|
}
|
|
else if (m_eMode == mRotate && m_moveType & IsRotatable)
|
|
{
|
|
// prevent strange angle changes due to singularities
|
|
qreal dLen = qSqrt(ptDiff.x() * ptDiff.x() + ptDiff.y() * ptDiff.y());
|
|
if (dLen < 2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (fabs(m_dAngle) < 0.01)
|
|
{
|
|
m_dAngle = GetAngle(mapToParent(pME->pos()));
|
|
return;
|
|
}
|
|
|
|
qreal dAng = GetAngle(mapToParent(pME->pos())) - m_dAngle;
|
|
QPointF ptNewPos = Rotate(m_ptStartPos, m_ptRotCenter, dAng);
|
|
VPieceGrainline grainline(ptNewPos, m_dLength, m_dStartRotation + dAng, m_eArrowType);
|
|
if (grainline.IsContained(parentItem()->boundingRect(), dX, dY))
|
|
{
|
|
setPos(ptNewPos);
|
|
m_dRotation = m_dStartRotation + dAng;
|
|
UpdateRectangle();
|
|
Update();
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::mouseReleaseEvent handles mouse release events and emits the proper signal if the item was
|
|
* moved
|
|
* @param pME pointer to QGraphicsSceneMouseEvent object
|
|
*/
|
|
void VGrainlineItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *pME)
|
|
{
|
|
if (pME->button() != Qt::LeftButton)
|
|
{
|
|
VPieceItem::mouseReleaseEvent(pME);
|
|
return;
|
|
}
|
|
|
|
if ((m_eMode == mMove || m_eMode == mRotate || m_eMode == mResize) && (flags() & QGraphicsItem::ItemIsMovable))
|
|
{
|
|
SetItemOverrideCursor(this, cursorArrowOpenHand, 1, 1);
|
|
}
|
|
|
|
QPointF ptDiff = pME->scenePos() - m_ptStartMove;
|
|
qreal dLen = qSqrt(ptDiff.x() * ptDiff.x() + ptDiff.y() * ptDiff.y());
|
|
bool bShort = (dLen < 2);
|
|
|
|
if (m_eMode == mMove || m_eMode == mResize)
|
|
{
|
|
if (bShort)
|
|
{
|
|
if (m_bReleased && m_moveType & IsRotatable)
|
|
{
|
|
m_eMode = mRotate;
|
|
Update();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m_eMode == mMove && m_moveType & IsMovable)
|
|
{
|
|
emit SignalMoved(pos());
|
|
}
|
|
else if (m_moveType & IsResizable)
|
|
{
|
|
emit SignalResized(m_dLength);
|
|
}
|
|
Update();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bShort)
|
|
{
|
|
m_eMode = mMove;
|
|
}
|
|
else if (m_moveType & IsRotatable)
|
|
{
|
|
emit SignalRotated(m_dRotation, m_ptStart);
|
|
}
|
|
Update();
|
|
}
|
|
m_bReleased = true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void VGrainlineItem::hoverEnterEvent(QGraphicsSceneHoverEvent *pME)
|
|
{
|
|
if (flags() & QGraphicsItem::ItemIsMovable)
|
|
{
|
|
SetItemOverrideCursor(this, cursorArrowOpenHand, 1, 1);
|
|
m_penWidth = VAbstractApplication::VApp()->Settings()->WidthMainLine() + 1;
|
|
}
|
|
VPieceItem::hoverEnterEvent(pME);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void VGrainlineItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *pME)
|
|
{
|
|
if (flags() & QGraphicsItem::ItemIsMovable)
|
|
{
|
|
m_penWidth = VAbstractApplication::VApp()->Settings()->WidthMainLine();
|
|
}
|
|
VPieceItem::hoverLeaveEvent(pME);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::UpdateBox updates the item
|
|
*/
|
|
void VGrainlineItem::Update()
|
|
{
|
|
update(m_rectBoundingBox);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::UpdateRectangle updates the polygon for the box around active item
|
|
* and the bounding rectangle
|
|
*/
|
|
void VGrainlineItem::UpdateRectangle()
|
|
{
|
|
VPieceGrainline grainline(QPointF(), m_dLength, m_dRotation, m_eArrowType);
|
|
const QLineF mainLine = grainline.GetMainLine();
|
|
|
|
m_ptStart = mapToParent(mainLine.p1());
|
|
m_ptFinish = mapToParent(mainLine.p2());
|
|
m_ptCenter = (m_ptStart + m_ptFinish) / 2;
|
|
|
|
m_polyBound.clear();
|
|
|
|
if (grainline.IsFourWays())
|
|
{
|
|
m_polyBound << QPointF(mainLine.p1().x() + (m_dLength / 2) * cos(m_dRotation + M_PI / 2),
|
|
mainLine.p1().y() - (m_dLength / 2) * sin(m_dRotation + M_PI / 2));
|
|
m_polyBound << QPointF(mainLine.p1().x() + (m_dLength / 2) * cos(m_dRotation - M_PI / 2),
|
|
mainLine.p1().y() - (m_dLength / 2) * sin(m_dRotation - M_PI / 2));
|
|
m_polyBound << QPointF(mainLine.p2().x() + (m_dLength / 2) * cos(m_dRotation - M_PI / 2),
|
|
mainLine.p2().y() - (m_dLength / 2) * sin(m_dRotation - M_PI / 2));
|
|
m_polyBound << QPointF(mainLine.p2().x() + (m_dLength / 2) * cos(m_dRotation + M_PI / 2),
|
|
mainLine.p2().y() - (m_dLength / 2) * sin(m_dRotation + M_PI / 2));
|
|
|
|
const QLineF secondaryLine = grainline.SecondaryLine();
|
|
m_ptSecondaryStart = mapToParent(secondaryLine.p1());
|
|
m_ptSecondaryFinish = mapToParent(secondaryLine.p2());
|
|
}
|
|
else
|
|
{
|
|
m_polyBound << QPointF(mainLine.p1().x() + rectWidth * cos(m_dRotation + M_PI / 2),
|
|
mainLine.p1().y() - rectWidth * sin(m_dRotation + M_PI / 2));
|
|
m_polyBound << QPointF(mainLine.p1().x() + rectWidth * cos(m_dRotation - M_PI / 2),
|
|
mainLine.p1().y() - rectWidth * sin(m_dRotation - M_PI / 2));
|
|
m_polyBound << QPointF(mainLine.p2().x() + rectWidth * cos(m_dRotation - M_PI / 2),
|
|
mainLine.p2().y() - rectWidth * sin(m_dRotation - M_PI / 2));
|
|
m_polyBound << QPointF(mainLine.p2().x() + rectWidth * cos(m_dRotation + M_PI / 2),
|
|
mainLine.p2().y() - rectWidth * sin(m_dRotation + M_PI / 2));
|
|
}
|
|
m_rectBoundingBox = m_polyBound.boundingRect().adjusted(-2, -2, 2, 2);
|
|
setTransformOriginPoint(m_rectBoundingBox.center());
|
|
|
|
UpdatePolyResize();
|
|
prepareGeometryChange();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto VGrainlineItem::GetAngle(const QPointF &pt) const -> double
|
|
{
|
|
return -VPieceItem::GetAngle(pt);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::Rotate rotates point pt around ptCenter by angle dAng [rad]
|
|
* and returns the resulting point
|
|
* @param pt point to rotate
|
|
* @param ptCenter center of rotation
|
|
* @param dAng angle of rotation
|
|
* @return point, which is a result of rotating pt around ptCenter by angle dAng
|
|
*/
|
|
auto VGrainlineItem::Rotate(const QPointF &pt, const QPointF &ptCenter, qreal dAng) -> QPointF
|
|
{
|
|
QPointF ptRel = pt - ptCenter;
|
|
QPointF ptFinal;
|
|
ptFinal.setX(ptRel.x() * qCos(dAng) + ptRel.y() * qSin(dAng));
|
|
ptFinal.setY(-ptRel.x() * qSin(dAng) + ptRel.y() * qCos(dAng));
|
|
ptFinal += ptCenter;
|
|
return ptFinal;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
/**
|
|
* @brief VGrainlineItem::GetInsideCorner calculates a point inside the bounding polygon,
|
|
* dDist away of i-th point in each direction
|
|
* @param i index of corner
|
|
* @param dDist distance
|
|
* @return resulting point
|
|
*/
|
|
auto VGrainlineItem::GetInsideCorner(int i, qreal dDist) const -> QPointF
|
|
{
|
|
QPointF pt1 = m_polyBound.at((i + 1) % m_polyBound.count()) - m_polyBound.at(i);
|
|
QPointF pt2 = m_polyBound.at((i + m_polyBound.count() - 1) % m_polyBound.count()) - m_polyBound.at(i);
|
|
|
|
pt1 = dDist * pt1 / qSqrt(pt1.x() * pt1.x() + pt1.y() * pt1.y());
|
|
pt2 = dDist * pt2 / qSqrt(pt2.x() * pt2.x() + pt2.y() * pt2.y());
|
|
|
|
return m_polyBound.at(i) + pt1 + pt2;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
auto VGrainlineItem::MainShape() const -> QPainterPath
|
|
{
|
|
VPieceGrainline grainline(QPointF(), m_dLength, m_dRotation, m_eArrowType);
|
|
const QLineF mainLine = grainline.GetMainLine();
|
|
QPainterPath linePath;
|
|
linePath.moveTo(mainLine.p1());
|
|
linePath.lineTo(mainLine.p2());
|
|
linePath.closeSubpath();
|
|
|
|
QPainterPathStroker stroker;
|
|
stroker.setWidth(m_penWidth);
|
|
QPainterPath path;
|
|
path.addPath((stroker.createStroke(linePath) + linePath).simplified());
|
|
path.closeSubpath();
|
|
|
|
if (grainline.IsArrowUpEnabled())
|
|
{
|
|
QPainterPath polyPath;
|
|
polyPath.addPolygon(grainline.ArrowUp());
|
|
|
|
path.addPath((stroker.createStroke(polyPath) + polyPath).simplified());
|
|
path.closeSubpath();
|
|
}
|
|
|
|
if (grainline.IsArrowDownEnabled())
|
|
{
|
|
QPainterPath polyPath;
|
|
polyPath.addPolygon(grainline.ArrowDown());
|
|
|
|
path.addPath((stroker.createStroke(polyPath) + polyPath).simplified());
|
|
path.closeSubpath();
|
|
}
|
|
|
|
if (grainline.IsFourWays())
|
|
{
|
|
const QLineF secondaryLine = grainline.SecondaryLine();
|
|
QPainterPath secondaryLinePath;
|
|
secondaryLinePath.moveTo(secondaryLine.p1());
|
|
secondaryLinePath.lineTo(secondaryLine.p2());
|
|
secondaryLinePath.closeSubpath();
|
|
|
|
path.addPath((stroker.createStroke(secondaryLinePath) + secondaryLinePath).simplified());
|
|
path.closeSubpath();
|
|
|
|
if (grainline.IsArrowLeftEnabled())
|
|
{
|
|
QPainterPath polyPath;
|
|
polyPath.addPolygon(grainline.ArrowLeft());
|
|
|
|
path.addPath((stroker.createStroke(polyPath) + polyPath).simplified());
|
|
path.closeSubpath();
|
|
}
|
|
|
|
if (grainline.IsArrowRightEnabled())
|
|
{
|
|
QPainterPath polyPath;
|
|
polyPath.addPolygon(grainline.ArrowRight());
|
|
|
|
path.addPath((stroker.createStroke(polyPath) + polyPath).simplified());
|
|
path.closeSubpath();
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void VGrainlineItem::AllUserModifications(const QPointF &pos)
|
|
{
|
|
if (m_eMode != mRotate)
|
|
{
|
|
UserMoveAndResize(pos);
|
|
}
|
|
else
|
|
{
|
|
SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void VGrainlineItem::UserRotateAndMove()
|
|
{
|
|
if (m_eMode != mRotate)
|
|
{
|
|
m_eMode = mMove;
|
|
}
|
|
SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void VGrainlineItem::UserMoveAndResize(const QPointF &pos)
|
|
{
|
|
if (m_polyResize.containsPoint(pos, Qt::OddEvenFill))
|
|
{
|
|
m_eMode = mResize;
|
|
setCursor(Qt::SizeFDiagCursor);
|
|
}
|
|
else
|
|
{
|
|
m_eMode = mMove; // block later if need
|
|
SetItemOverrideCursor(this, cursorArrowCloseHand, 1, 1);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
void VGrainlineItem::UpdatePolyResize()
|
|
{
|
|
m_polyResize.clear();
|
|
QPointF ptA = m_polyBound.at(1);
|
|
m_polyResize << ptA;
|
|
const double dSize = resizeRectSize;
|
|
|
|
ptA.setX(ptA.x() - dSize * cos(m_dRotation - M_PI / 2));
|
|
ptA.setY(ptA.y() + dSize * sin(m_dRotation - M_PI / 2));
|
|
m_polyResize << ptA;
|
|
|
|
ptA.setX(ptA.x() + dSize * cos(m_dRotation));
|
|
ptA.setY(ptA.y() - dSize * sin(m_dRotation));
|
|
m_polyResize << ptA;
|
|
|
|
ptA.setX(ptA.x() - dSize * cos(m_dRotation + M_PI / 2));
|
|
ptA.setY(ptA.y() + dSize * sin(m_dRotation + M_PI / 2));
|
|
m_polyResize << ptA;
|
|
}
|