MOS
/
OpenBoard
5
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fixed, improved, cleaned and commented aristo tool.

Browse Source
preferencesAboutTextFull
Guillaume Burel 12 years ago
parent a74b7ca134
commit 519c39c843
2 changed files with 357 additions and 312 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 391
      src/tools/UBGraphicsAristo.cpp
  2. 150
      src/tools/UBGraphicsAristo.h

391
src/tools/UBGraphicsAristo.cpp
Unescape View File

@ -13,37 +13,42 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <QGraphicsPolygonItem> #include "UBGraphicsAristo.h"
#include <QPolygonF>
#include "tools/UBGraphicsAristo.h"
#include "core/UBApplication.h"
#include "board/UBBoardController.h" #include "board/UBBoardController.h"
#include "board/UBDrawingController.h" #include "board/UBDrawingController.h"
#include "core/UBApplication.h"
#include "domain/UBGraphicsScene.h" #include "domain/UBGraphicsScene.h"
#include <QColor>
#include <QFont>
#include <QFontMetricsF>
#include <QGraphicsItem>
#include <QLineF>
#include <QPolygonF>
#include <QRadialGradient>
#include <QString>
#include "core/memcheck.h" #include "core/memcheck.h"
const QRect UBGraphicsAristo::sDefaultRect = QRect(0, 0, 800, 400); const QRectF UBGraphicsAristo::sDefaultRect = QRectF(0, 0, 800, 500);
const UBGraphicsAristo::UBGraphicsAristoOrientation UBGraphicsAristo::sDefaultOrientation = UBGraphicsAristo::Bottom; const UBGraphicsAristo::Orientation UBGraphicsAristo::sDefaultOrientation = UBGraphicsAristo::Bottom;
UBGraphicsAristo::UBGraphicsAristo() UBGraphicsAristo::UBGraphicsAristo()
: UBAbstractDrawRuler() : UBAbstractDrawRuler()
, QGraphicsPolygonItem() , QGraphicsPathItem()
, angle(0) , mMarking(false)
, mResizing(false) , mResizing(false)
, mRotating(false) , mRotating(false)
, mMarking(false) , mOrientation(Undefined)
, mSpan(180) , mAngle(0)
, mStartAngle(0)
, mCurrentAngle(0) , mCurrentAngle(0)
, mStartAngle(0)
, mSpan(180)
, mHFlipSvgItem(0)
, mMarkerSvgItem(0)
, mResizeSvgItem(0)
, mRotateSvgItem(0)
{ {
setRect(sDefaultRect, sDefaultOrientation);
create(*this);
mHFlipSvgItem = new QGraphicsSvgItem(":/images/vflipTool.svg", this); mHFlipSvgItem = new QGraphicsSvgItem(":/images/vflipTool.svg", this);
mHFlipSvgItem->setVisible(false); mHFlipSvgItem->setVisible(false);
mHFlipSvgItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Control)); mHFlipSvgItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Control));
@ -59,163 +64,163 @@ UBGraphicsAristo::UBGraphicsAristo()
mMarkerSvgItem = new QGraphicsSvgItem(":/images/angleMarker.svg", this); mMarkerSvgItem = new QGraphicsSvgItem(":/images/angleMarker.svg", this);
mMarkerSvgItem->setVisible(false); mMarkerSvgItem->setVisible(false);
mMarkerSvgItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool)); mMarkerSvgItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
} mMarkerSvgItem->setVisible(true);
UBGraphicsAristo::~UBGraphicsAristo()
{
}
UBItem* UBGraphicsAristo::deepCopy(void) const
{
UBGraphicsAristo* copy = new UBGraphicsAristo();
copyItemParameters(copy);
return copy;
}
void UBGraphicsAristo::copyItemParameters(UBItem *copy) const create(*this);
{ setBoundingRect(sDefaultRect);
UBGraphicsAristo* cp = dynamic_cast<UBGraphicsAristo*>(copy); setOrientation(sDefaultOrientation);
if (cp)
{
/* TODO: copy all members */
cp->setPos(this->pos());
cp->setPolygon(this->polygon());
cp->setTransform(this->transform());
}
} }
void UBGraphicsAristo::setRect(qreal x, qreal y, qreal w, qreal h, UBGraphicsAristoOrientation orientation) UBGraphicsAristo::~UBGraphicsAristo()
{ {
QPolygonF polygon; /* NOOP */
polygon << QPointF(x, y) << QPoint(x, y + h) << QPoint(x+w, y + h);
setPolygon(polygon);
setOrientation(orientation);
} }
void UBGraphicsAristo::setOrientation(UBGraphicsAristoOrientation orientation) /*
* setOrientation() modify the tool orientation.
* makeGeometryChange() is called so points are recomputed, control items are positionnated and shape is determined according to this modification.
*/
void UBGraphicsAristo::setOrientation(Orientation orientation)
{ {
mOrientation = orientation; mOrientation = orientation;
calculatePoints(rect()); makeGeometryChange();
QPolygonF polygon;
polygon << A << B << C;
setPolygon(polygon);
}
UBGraphicsScene* UBGraphicsAristo::scene() const
{
return static_cast<UBGraphicsScene*>(QGraphicsPolygonItem::scene());
} }
/* calculatePoints() is used to calculate polygon's apexes coordinates. /* calculatePoints() is used to calculate polygon's apexes coordinates.
* This function handles orientation changes too. * This function handles orientation changes too.
*/ */
void UBGraphicsAristo::calculatePoints(const QRectF& r) void UBGraphicsAristo::calculatePoints()
{
switch(mOrientation)
{ {
switch (mOrientation) {
case Bottom: case Bottom:
A.setX(r.left()); A.setY(r.top()); C.setX(boundingRect().center().x());
B.setX(r.right()); B.setY(r.top()); C.setY(boundingRect().bottom());
C.setX(r.center().x()); C.setY(A.y() + r.width() / 2);
A.setX(boundingRect().left());
A.setY(boundingRect().bottom() - boundingRect().width() / 2);
B.setX(boundingRect().right());
B.setY(boundingRect().bottom() - boundingRect().width() / 2);
break; break;
case Top: case Top:
A.setX(r.left()); A.setY(r.bottom()); C.setX(boundingRect().center().x());
B.setX(r.right()); B.setY(r.bottom()); C.setY(boundingRect().top());
C.setX(r.center().x()); C.setY(A.y() - r.width() / 2);
A.setX(boundingRect().left());
A.setY(boundingRect().top() + boundingRect().width() / 2);
B.setX(boundingRect().right());
B.setY(boundingRect().top() + boundingRect().width() / 2);
break;
default:
break; break;
} }
} }
void UBGraphicsAristo::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *) /*
* setItemsPos() places control items according to A, B and C positions.
* Call this function after A, B or C position modification, mostly after calling calculatePoints().
* These positions has to be set when calling setPath() to allow hover events on items which are not into the main polygon.
*/
void UBGraphicsAristo::setItemsPos()
{ {
QPolygonF polygon;
painter->setBrush(fillBrush());
painter->setPen(drawColor());
polygon << A << B << C;
painter->drawPolygon(polygon);
polygon.clear();
paintGraduations(painter);
mCloseSvgItem->setPos(closeButtonRect().topLeft() + rotationCenter()); mCloseSvgItem->setPos(closeButtonRect().topLeft() + rotationCenter());
mHFlipSvgItem->setPos(hFlipRect().topLeft() + rotationCenter()); mHFlipSvgItem->setPos(hFlipRect().topLeft() + rotationCenter());
mRotateSvgItem->setPos(rotateRect().topLeft() + rotationCenter()); mRotateSvgItem->setPos(rotateRect().topLeft() + rotationCenter());
mResizeSvgItem->setPos(resizeButtonRect().topLeft() + rotationCenter()); mResizeSvgItem->setPos(resizeButtonRect().topLeft() + rotationCenter());
mMarkerSvgItem->setPos(markerButtonRect().topLeft() + rotationCenter());
}
/*
* determinePath() modify the shape according to apexes coordinates and control item positions.
* This is useful when orientation is modified.
* Returns the painter path corresponding to object parameters.
*/
QPainterPath UBGraphicsAristo::determinePath()
{
QPainterPath path;
paintMarker(painter); QPolygonF polygon;
mMarkerSvgItem->setVisible(true); polygon << A << B << C;
path.addPolygon(polygon);
path.addPath(mResizeSvgItem->shape().translated(mResizeSvgItem->pos()));
path.addPath(mMarkerSvgItem->shape().translated(mMarkerSvgItem->pos()));
return path;
} }
QPainterPath UBGraphicsAristo::shape() const /*
* setBoundingRect() is a helper to set the given rectangle as the new shape to limit apexes coordinates.
* This is useful when instanciating or resizing the object.
* makeGeometryChange() is called so points are recomputed, control items are positionnated and shape is determined according to this modification.
* Setting bounds' width less than 300 is not allowed.
*/
void UBGraphicsAristo::setBoundingRect(QRectF boundingRect)
{ {
QPainterPath tShape; if (boundingRect.width() < 300)
QPolygonF tPolygon; return;
tPolygon << A << B << C;
tShape.addPolygon(tPolygon);
tPolygon.clear();
return tShape; QPainterPath path;
path.addRect(boundingRect);
setPath(path);
if (mOrientation != Undefined)
makeGeometryChange();
} }
/* paintMarker() adjust marker button according to the current angle, draw the line allowing user to set precisely the angle, and draw the current angle's value. */ void UBGraphicsAristo::makeGeometryChange()
void UBGraphicsAristo::paintMarker(QPainter *painter)
{ {
/* adjusting marker button */ calculatePoints();
mMarkerSvgItem->setPos(markerButtonRect().topLeft() + rotationCenter()); setItemsPos();
mMarkerSvgItem->resetTransform(); setPath(determinePath());
mMarkerSvgItem->translate(-markerButtonRect().left(), -markerButtonRect().top()); }
mMarkerSvgItem->rotate(mCurrentAngle);
mMarkerSvgItem->translate(markerButtonRect().left(), markerButtonRect().top());
qreal co = cos((mCurrentAngle) * PI/180); UBItem* UBGraphicsAristo::deepCopy(void) const
qreal si = sin((mCurrentAngle) * PI/180); {
UBGraphicsAristo* copy = new UBGraphicsAristo();
copyItemParameters(copy);
return copy;
}
/* Setting point composing the line (from point C) which intersects the line we want to draw. */ void UBGraphicsAristo::copyItemParameters(UBItem *copy) const
QPointF referencePoint; {
if (mOrientation == Bottom) { UBGraphicsAristo* cp = dynamic_cast<UBGraphicsAristo*>(copy);
if ((int)mCurrentAngle % 360 < 90) if (cp)
referencePoint = B; {
else /* TODO: copy all members */
referencePoint = A; cp->setPos(this->pos());
cp->setPath(this->path());
cp->setTransform(this->transform());
} }
else if (mOrientation == Top) {
if ((int)mCurrentAngle % 360 < 270 && (int)mCurrentAngle % 360 > 0)
referencePoint = A;
else
referencePoint = B;
} }
/* getting intersection point to draw the wanted line */
QLineF intersectedLine(rotationCenter(), QPointF(rotationCenter().x()+co, rotationCenter().y()+si));
QPointF intersectionPoint;
if (intersectedLine.intersect(QLineF(referencePoint, C), &intersectionPoint))
painter->drawLine(QLineF(intersectionPoint, rotationCenter()));
/* drawing angle value */
qreal rightAngle = mOrientation == Bottom ? mCurrentAngle : 360 - mCurrentAngle;
QString angleText = QString("%1°").arg(rightAngle, 0, 'f', 1); void UBGraphicsAristo::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
QPolygonF polygon;
QFont font1 = painter->font(); painter->setBrush(fillBrush());
#ifdef Q_WS_MAC painter->setPen(drawColor());
font1.setPointSizeF(font1.pointSizeF() - 3);
#endif
QFontMetricsF fm1(font1);
if (mOrientation == Bottom) polygon << A << B << C;
painter->drawText(rotationCenter().x() - fm1.width(angleText)/2 - radius()/8, rotationCenter().y() + radius()/8 - fm1.height()/2, fm1.width(angleText), fm1.height(), Qt::AlignCenter, angleText); painter->drawPolygon(polygon);
else polygon.clear();
painter->drawText(rotationCenter().x() - fm1.width(angleText)/2 - radius()/8, rotationCenter().y() - radius()/8 - fm1.height()/2, fm1.width(angleText), fm1.height(), Qt::AlignCenter, angleText);
paintGraduations(painter);
paintMarker(painter);
}
QBrush UBGraphicsAristo::fillBrush() const
{
QColor fillColor = edgeFillColor();// scene()->isDarkBackground() ? sDarkBackgroundFillColor : sFillColor;
QColor fillColorCenter = middleFillColor();//scene()->isDarkBackground() ? sDarkBackgroundFillColorCenter : sFillColorCenter;
QColor transparentWhite = Qt::white;
transparentWhite.setAlpha(scene()->isDarkBackground() ? sDrawTransparency : sFillTransparency);
QRadialGradient radialGradient(boundingRect().center(), radius(), boundingRect().center());
radialGradient.setColorAt(0, fillColorCenter);
radialGradient.setColorAt(1, fillColor);
return radialGradient;
} }
/* paintGraduations() paints graduations on the ruler side (length graduations) and the two other sides (angle graduation) */ /* paintGraduations() paints graduations on the ruler side (length graduations) and the two other sides (angle graduation) */
@ -239,7 +244,7 @@ void UBGraphicsAristo::paintRulerGraduations(QPainter *painter)
QFontMetricsF fontMetrics(painter->font()); QFontMetricsF fontMetrics(painter->font());
/* Browsing milliters in half width of ruler side */ /* Browsing milliters in half width of ruler side */
for (int millimeters = 0; millimeters < (rect().width() / 2 - sLeftEdgeMargin - sRoundingRadius) / sPixelsPerMillimeter; millimeters++) for (int millimeters = 0; millimeters < (boundingRect().width() / 2 - sLeftEdgeMargin - sRoundingRadius) / sPixelsPerMillimeter; millimeters++)
{ {
/* defining graduationHeight ; values are different to draw bigger lines if millimiter considered is a centimeter or a half centimeter */ /* defining graduationHeight ; values are different to draw bigger lines if millimiter considered is a centimeter or a half centimeter */
int graduationHeight = (0 == millimeters % millimetersPerCentimeter) ? int graduationHeight = (0 == millimeters % millimetersPerCentimeter) ?
@ -262,13 +267,13 @@ void UBGraphicsAristo::paintRulerGraduations(QPainter *painter)
QString text = QString("%1").arg((int)(millimeters / millimetersPerCentimeter)); QString text = QString("%1").arg((int)(millimeters / millimetersPerCentimeter));
/* staying inside polygon */ /* staying inside polygon */
if (rotationCenter().x() + sPixelsPerMillimeter * millimeters + fontMetrics.width(text) / 2 < rect().right()) if (rotationCenter().x() + sPixelsPerMillimeter * millimeters + fontMetrics.width(text) / 2 < boundingRect().right())
{ {
qreal textWidth = fontMetrics.width(text); qreal textWidth = fontMetrics.width(text);
qreal textHeight = fontMetrics.tightBoundingRect(text).height() + 5; qreal textHeight = fontMetrics.tightBoundingRect(text).height() + 5;
/* text y-coordinate is different according to tool's orientation */ /* text y-coordinate is different according to tool's orientation */
qreal textY = mOrientation == Bottom ? rect().top() + 5 + centimeterGraduationHeight : rect().bottom() - 5 - centimeterGraduationHeight + graduationHeight; qreal textY = mOrientation == Bottom ? A.y() + 5 + centimeterGraduationHeight : A.y() - 5 - centimeterGraduationHeight + graduationHeight;
/* if text's rect is not out of polygon's bounds, drawing value below or above graduation */ /* if text's rect is not out of polygon's bounds, drawing value below or above graduation */
QPointF intersectionPoint; QPointF intersectionPoint;
@ -390,32 +395,73 @@ void UBGraphicsAristo::paintProtractorGraduations(QPainter* painter)
painter->restore(); painter->restore();
} }
QBrush UBGraphicsAristo::fillBrush() const /* paintMarker() adjust marker button according to the current angle, draw the line allowing user to set precisely the angle, and draw the current angle's value. */
void UBGraphicsAristo::paintMarker(QPainter *painter)
{ {
QColor fillColor = edgeFillColor();// scene()->isDarkBackground() ? sDarkBackgroundFillColor : sFillColor; /* adjusting marker button */
QColor fillColorCenter = middleFillColor();//scene()->isDarkBackground() ? sDarkBackgroundFillColorCenter : sFillColorCenter; mMarkerSvgItem->resetTransform();
QColor transparentWhite = Qt::white; mMarkerSvgItem->translate(-markerButtonRect().left(), -markerButtonRect().top());
transparentWhite.setAlpha(scene()->isDarkBackground() ? sDrawTransparency : sFillTransparency); mMarkerSvgItem->rotate(mCurrentAngle);
QRadialGradient radialGradient(rect().center(), radius(), rect().center()); mMarkerSvgItem->translate(markerButtonRect().left(), markerButtonRect().top());
radialGradient.setColorAt(0, fillColorCenter);
radialGradient.setColorAt(1, fillColor);
return radialGradient; qreal co = cos((mCurrentAngle) * PI/180);
qreal si = sin((mCurrentAngle) * PI/180);
/* Setting point composing the line (from point C) which intersects the line we want to draw. */
QPointF referencePoint;
if (mOrientation == Bottom) {
if ((int)mCurrentAngle % 360 < 90)
referencePoint = B;
else
referencePoint = A;
} }
else if (mOrientation == Top) {
if ((int)mCurrentAngle % 360 < 270 && (int)mCurrentAngle % 360 > 0)
referencePoint = A;
else
referencePoint = B;
}
/* getting intersection point to draw the wanted line */
QLineF intersectedLine(rotationCenter(), QPointF(rotationCenter().x()+co, rotationCenter().y()+si));
QPointF intersectionPoint;
if (intersectedLine.intersect(QLineF(referencePoint, C), &intersectionPoint))
painter->drawLine(QLineF(intersectionPoint, rotationCenter()));
/* drawing angle value */
qreal rightAngle = mOrientation == Bottom ? mCurrentAngle : 360 - mCurrentAngle;
QString angleText = QString("%1°").arg(rightAngle, 0, 'f', 1);
QFont font1 = painter->font();
#ifdef Q_WS_MAC
font1.setPointSizeF(font1.pointSizeF() - 3);
#endif
QFontMetricsF fm1(font1);
if (mOrientation == Bottom)
painter->drawText(rotationCenter().x() - fm1.width(angleText)/2 - radius()/8, rotationCenter().y() + radius()/8 - fm1.height()/2, fm1.width(angleText), fm1.height(), Qt::AlignCenter, angleText);
else
painter->drawText(rotationCenter().x() - fm1.width(angleText)/2 - radius()/8, rotationCenter().y() - radius()/8 - fm1.height()/2, fm1.width(angleText), fm1.height(), Qt::AlignCenter, angleText);
}
void UBGraphicsAristo::rotateAroundCenter(qreal angle) void UBGraphicsAristo::rotateAroundCenter(qreal angle)
{ {
qreal oldAngle = this->angle; qreal oldAngle = mAngle;
this->angle = angle; mAngle = angle;
QTransform transform; QTransform transform;
rotateAroundCenter(transform, rotationCenter()); rotateAroundCenter(transform, rotationCenter());
setTransform(transform, true); setTransform(transform, true);
this->angle = oldAngle + angle; // We have to store absolute value for FLIP case mAngle = oldAngle + angle; // We have to store absolute value for FLIP case
} }
void UBGraphicsAristo::rotateAroundCenter(QTransform& transform, QPointF center) void UBGraphicsAristo::rotateAroundCenter(QTransform& transform, QPointF center)
{ {
transform.translate(center.x(), center.y()); transform.translate(center.x(), center.y());
transform.rotate(angle); transform.rotate(mAngle);
transform.translate(- center.x(), - center.y()); transform.translate(- center.x(), - center.y());
} }
@ -441,11 +487,6 @@ QRectF UBGraphicsAristo::closeButtonRect() const
return QRectF(- mCloseSvgItem->boundingRect().width() / 2, y, mCloseSvgItem->boundingRect().width(), mCloseSvgItem->boundingRect().height()); return QRectF(- mCloseSvgItem->boundingRect().width() / 2, y, mCloseSvgItem->boundingRect().width(), mCloseSvgItem->boundingRect().height());
} }
QRectF UBGraphicsAristo::resizeButtonRect() const
{
return QRectF((B - rotationCenter()).x() - 100 - mResizeSvgItem->boundingRect().width()/2, - mResizeSvgItem->boundingRect().height()/2, mResizeSvgItem->boundingRect().width(), mResizeSvgItem->boundingRect().height());
}
QRectF UBGraphicsAristo::hFlipRect() const QRectF UBGraphicsAristo::hFlipRect() const
{ {
qreal y = radius() / 4; qreal y = radius() / 4;
@ -455,6 +496,16 @@ QRectF UBGraphicsAristo::hFlipRect() const
return QRectF(- mHFlipSvgItem->boundingRect().width() / 2, y, mHFlipSvgItem->boundingRect().width(), mHFlipSvgItem->boundingRect().height()); return QRectF(- mHFlipSvgItem->boundingRect().width() / 2, y, mHFlipSvgItem->boundingRect().width(), mHFlipSvgItem->boundingRect().height());
} }
QRectF UBGraphicsAristo::markerButtonRect() const
{
return QRectF (radius()/2 - mMarkerSvgItem->boundingRect().width(), - mMarkerSvgItem->boundingRect().height()/2, mMarkerSvgItem->boundingRect().width(), mMarkerSvgItem->boundingRect().height());
}
QRectF UBGraphicsAristo::resizeButtonRect() const
{
return QRectF((B - rotationCenter()).x() - 100 - mResizeSvgItem->boundingRect().width()/2, - mResizeSvgItem->boundingRect().height()/2, mResizeSvgItem->boundingRect().width(), mResizeSvgItem->boundingRect().height());
}
QRectF UBGraphicsAristo::rotateRect() const QRectF UBGraphicsAristo::rotateRect() const
{ {
qreal y = radius() / 4 + hFlipRect().height() + 3; qreal y = radius() / 4 + hFlipRect().height() + 3;
@ -464,26 +515,22 @@ QRectF UBGraphicsAristo::rotateRect() const
} }
QRectF UBGraphicsAristo::markerButtonRect() const
{
return QRectF (radius()/2 - mMarkerSvgItem->boundingRect().width(), - mMarkerSvgItem->boundingRect().height()/2, mMarkerSvgItem->boundingRect().width(), mMarkerSvgItem->boundingRect().height());
}
QCursor UBGraphicsAristo::flipCursor() const QCursor UBGraphicsAristo::flipCursor() const
{ {
return Qt::ArrowCursor; return Qt::ArrowCursor;
} }
QCursor UBGraphicsAristo::resizeCursor() const QCursor UBGraphicsAristo::markerCursor() const
{ {
return Qt::ArrowCursor; return Qt::ArrowCursor;
} }
QCursor UBGraphicsAristo::markerCursor() const QCursor UBGraphicsAristo::resizeCursor() const
{ {
return Qt::ArrowCursor; return Qt::ArrowCursor;
} }
void UBGraphicsAristo::mousePressEvent(QGraphicsSceneMouseEvent *event) void UBGraphicsAristo::mousePressEvent(QGraphicsSceneMouseEvent *event)
{ {
switch (toolFromPos(event->pos())) { switch (toolFromPos(event->pos())) {
@ -530,7 +577,7 @@ void UBGraphicsAristo::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
} }
else if (mResizing) { else if (mResizing) {
QPointF delta = event->pos() - event->lastPos(); QPointF delta = event->pos() - event->lastPos();
setRect(QRectF(rect().topLeft(), QSizeF(rect().width() + delta.x(), rect().height() + delta.x() / 2)), mOrientation); setBoundingRect(QRectF(boundingRect().topLeft(), QSizeF(boundingRect().width() + delta.x(), boundingRect().height() + delta.x())));
} }
else if(mMarking) { else if(mMarking) {
qreal angle = currentLine.angleTo(lastLine); qreal angle = currentLine.angleTo(lastLine);
@ -584,6 +631,8 @@ void UBGraphicsAristo::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
case Top: case Top:
setOrientation(Bottom); setOrientation(Bottom);
break; break;
default:
break;
} }
default: default:
QGraphicsItem::mouseReleaseEvent(event); QGraphicsItem::mouseReleaseEvent(event);
@ -700,7 +749,7 @@ UBGraphicsAristo::Tool UBGraphicsAristo::toolFromPos(QPointF pos)
{ {
pos = pos - rotationCenter(); pos = pos - rotationCenter();
qreal rotationAngle = mOrientation == Bottom ? - mCurrentAngle : 360 * (int)(mCurrentAngle / 360 + 1) - mCurrentAngle; qreal rotationAngle = mOrientation == Bottom ? - mCurrentAngle : Top ? 360 * (int)(mCurrentAngle / 360 + 1) - mCurrentAngle : 0;
QTransform t; QTransform t;
t.rotate(rotationAngle); t.rotate(rotationAngle);
@ -722,6 +771,7 @@ UBGraphicsAristo::Tool UBGraphicsAristo::toolFromPos(QPointF pos)
return None; return None;
} }
void UBGraphicsAristo::StartLine(const QPointF &scenePos, qreal width) void UBGraphicsAristo::StartLine(const QPointF &scenePos, qreal width)
{ {
QPointF itemPos = mapFromScene(scenePos); QPointF itemPos = mapFromScene(scenePos);
@ -730,10 +780,10 @@ void UBGraphicsAristo::StartLine(const QPointF &scenePos, qreal width)
y = rotationCenter().y(); y = rotationCenter().y();
if (itemPos.x() < rect().x() + sLeftEdgeMargin) if (itemPos.x() < boundingRect().x() + sLeftEdgeMargin)
itemPos.setX(rect().x() + sLeftEdgeMargin); itemPos.setX(boundingRect().x() + sLeftEdgeMargin);
if (itemPos.x() > rect().x() + rect().width() - sLeftEdgeMargin) if (itemPos.x() > boundingRect().x() + boundingRect().width() - sLeftEdgeMargin)
itemPos.setX(rect().x() + rect().width() - sLeftEdgeMargin); itemPos.setX(boundingRect().x() + boundingRect().width() - sLeftEdgeMargin);
itemPos.setY(y); itemPos.setY(y);
itemPos = mapToScene(itemPos); itemPos = mapToScene(itemPos);
@ -750,10 +800,10 @@ void UBGraphicsAristo::DrawLine(const QPointF &scenePos, qreal width)
y = rotationCenter().y(); y = rotationCenter().y();
if (itemPos.x() < rect().x() + sLeftEdgeMargin) if (itemPos.x() < boundingRect().x() + sLeftEdgeMargin)
itemPos.setX(rect().x() + sLeftEdgeMargin); itemPos.setX(boundingRect().x() + sLeftEdgeMargin);
if (itemPos.x() > rect().x() + rect().width() - sLeftEdgeMargin) if (itemPos.x() > boundingRect().x() + boundingRect().width() - sLeftEdgeMargin)
itemPos.setX(rect().x() + rect().width() - sLeftEdgeMargin); itemPos.setX(boundingRect().x() + boundingRect().width() - sLeftEdgeMargin);
itemPos.setY(y); itemPos.setY(y);
itemPos = mapToScene(itemPos); itemPos = mapToScene(itemPos);
@ -765,4 +815,11 @@ void UBGraphicsAristo::DrawLine(const QPointF &scenePos, qreal width)
void UBGraphicsAristo::EndLine() void UBGraphicsAristo::EndLine()
{ {
/* NOOP */
}
UBGraphicsScene* UBGraphicsAristo::scene() const
{
return static_cast<UBGraphicsScene*>(QGraphicsPathItem::scene());
} }

150
src/tools/UBGraphicsAristo.h
Unescape View File

@ -16,19 +16,25 @@
#ifndef UBGRAPHICSARISTO_H_ #ifndef UBGRAPHICSARISTO_H_
#define UBGRAPHICSARISTO_H_ #define UBGRAPHICSARISTO_H_
#include <QtGui>
#include <QtSvg>
#include <QGraphicsPolygonItem>
#include "core/UB.h" #include "core/UB.h"
#include "domain/UBItem.h" #include "domain/UBItem.h"
#include "tools/UBAbstractDrawRuler.h" #include "tools/UBAbstractDrawRuler.h"
#include <QBrush>
class UBGraphicsScene; #include <QCursor>
class UBItem; #include <QGraphicsPathItem>
#include <QGraphicsSceneHoverEvent>
class UBGraphicsAristo : public UBAbstractDrawRuler, public QGraphicsPolygonItem, public UBItem #include <QGraphicsSceneMouseEvent>
#include <QGraphicsSvgItem>
#include <QPainter>
#include <QPainterPath>
#include <QPointF>
#include <QRectF>
#include <QStyleOptionGraphicsItem>
#include <QTransform>
#include <QWidget>
class UBGraphicsAristo : public UBAbstractDrawRuler, public QGraphicsPathItem, public UBItem
{ {
Q_OBJECT Q_OBJECT
@ -36,61 +42,45 @@ class UBGraphicsAristo : public UBAbstractDrawRuler, public QGraphicsPolygonItem
UBGraphicsAristo(); UBGraphicsAristo();
virtual ~UBGraphicsAristo(); virtual ~UBGraphicsAristo();
enum { Type = UBGraphicsItemType::AristoItemType }; enum {
enum Tool {None, Move, Resize, Rotate, Close, MoveMarker, HorizontalFlip}; Type = UBGraphicsItemType::AristoItemType
};
virtual int type() const enum Tool {
None,
Move,
Resize,
Rotate,
Close,
MoveMarker,
HorizontalFlip
};
enum Orientation
{ {
return Type; Bottom = 0,
} Top,
Undefined
};
void setOrientation(Orientation orientation);
void setBoundingRect(QRectF boundingRect);
virtual UBItem* deepCopy(void) const; virtual UBItem* deepCopy() const;
virtual void copyItemParameters(UBItem *copy) const; virtual void copyItemParameters(UBItem *copy) const;
virtual void StartLine(const QPointF& scenePos, qreal width); virtual void StartLine(const QPointF& scenePos, qreal width);
virtual void DrawLine(const QPointF& position, qreal width); virtual void DrawLine(const QPointF& position, qreal width);
virtual void EndLine(); virtual void EndLine();
enum UBGraphicsAristoOrientation virtual int type() const
{
Bottom = 0,
Top
};
static UBGraphicsAristoOrientation orientationFromStr(QStringRef& str)
{
if (str == "Bottom") return Bottom;
if (str == "Top") return Top;
return sDefaultOrientation;
}
static QString orientationToStr(UBGraphicsAristoOrientation orientation)
{
QString result;
if (orientation == 0) result = "Bottom";
else if (orientation == 1) result = "Top";
return result;
}
void setRect(const QRectF &rect, UBGraphicsAristoOrientation orientation)
{ {
setRect(rect.x(), rect.y(), rect.width(), rect.height(), orientation); return Type;
} }
void setRect(qreal x, qreal y, qreal w, qreal h, UBGraphicsAristoOrientation orientation);
void setOrientation(UBGraphicsAristoOrientation orientation);
UBGraphicsAristoOrientation getOrientation() const {return mOrientation;}
QRectF rect() const {return boundingRect();}
UBGraphicsScene* scene() const; UBGraphicsScene* scene() const;
protected: protected:
virtual void paint (QPainter *painter, const QStyleOptionGraphicsItem *styleOption, QWidget *widget); virtual void paint (QPainter *painter, const QStyleOptionGraphicsItem *styleOption, QWidget *widget);
virtual QPainterPath shape() const;
virtual void rotateAroundCenter(qreal angle); virtual void rotateAroundCenter(qreal angle);
virtual void resize(qreal factor); virtual void resize(qreal factor);
@ -98,14 +88,14 @@ class UBGraphicsAristo : public UBAbstractDrawRuler, public QGraphicsPolygonItem
virtual QPointF rotationCenter() const; virtual QPointF rotationCenter() const;
virtual QRectF closeButtonRect() const; virtual QRectF closeButtonRect() const;
QRectF resizeButtonRect () const;
QRectF hFlipRect() const; QRectF hFlipRect() const;
QRectF rotateRect() const;
QRectF markerButtonRect() const; QRectF markerButtonRect() const;
QRectF resizeButtonRect () const;
QRectF rotateRect() const;
QCursor flipCursor() const; QCursor flipCursor() const;
QCursor resizeCursor() const;
QCursor markerCursor() const; QCursor markerCursor() const;
QCursor resizeCursor() const;
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event); virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event); virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
@ -115,51 +105,49 @@ class UBGraphicsAristo : public UBAbstractDrawRuler, public QGraphicsPolygonItem
virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event); virtual void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
private: private:
UBGraphicsAristo::Tool toolFromPos(QPointF pos); Tool toolFromPos(QPointF pos);
QTransform calculateRotationTransform();
qreal angle;
QTransform calculateRotationTransform();
void rotateAroundCenter(QTransform& transform, QPointF center); void rotateAroundCenter(QTransform& transform, QPointF center);
bool mResizing; void calculatePoints();
bool mRotating; QPainterPath determinePath();
bool mMarking; void setItemsPos();
QRect lastRect; void makeGeometryChange();
qreal mSpan;
// Coordinates are transformed....
QPoint lastPos;
QGraphicsSvgItem* mHFlipSvgItem;
QGraphicsSvgItem* mRotateSvgItem;
QGraphicsSvgItem* mResizeSvgItem;
QGraphicsSvgItem* mMarkerSvgItem;
qreal mStartAngle;
qreal mCurrentAngle;
static const QRect sDefaultRect;
static const UBGraphicsAristoOrientation sDefaultOrientation;
QBrush fillBrush() const;
void paintGraduations(QPainter *painter); void paintGraduations(QPainter *painter);
void paintRulerGraduations(QPainter *painter);
void paintProtractorGraduations(QPainter* painter);
void paintMarker(QPainter *painter); void paintMarker(QPainter *painter);
void paintProtractorGraduations(QPainter* painter);
void paintRulerGraduations(QPainter *painter);
inline qreal radius () const inline qreal radius () const
{ {
return sqrt(((B.x() - A.x())*(B.x() - A.x()))+((B.y() - A.y())*(B.y() - A.y()))) * 9 / 16 - 20; return sqrt(((B.x() - A.x())*(B.x() - A.x()))+((B.y() - A.y())*(B.y() - A.y()))) * 9 / 16 - 20;
} }
QBrush fillBrush() const;
UBGraphicsAristoOrientation mOrientation; bool mMarking;
bool mResizing;
bool mRotating;
void calculatePoints(const QRectF& rect); Orientation mOrientation;
qreal mAngle;
qreal mCurrentAngle;
qreal mStartAngle;
qreal mSpan;
QGraphicsSvgItem* mHFlipSvgItem;
QGraphicsSvgItem* mMarkerSvgItem;
QGraphicsSvgItem* mResizeSvgItem;
QGraphicsSvgItem* mRotateSvgItem;
QPointF A, B, C; QPointF A, B, C;
static const int d = 70; // width of triangle border
static const int sArrowLength = 30;
static const int sMinWidth = 380;
static const int sMinHeight = 200;
static const int sArcAngleMargin = 5; static const int sArcAngleMargin = 5;
static const Orientation sDefaultOrientation;
static const QRectF sDefaultRect;
}; };
#endif /* UBGRAPHICSARISTO_H_ */ #endif /* UBGRAPHICSARISTO_H_ */

Write Preview
Loading…
Cancel
Save