diff --git a/resources/forms/mainWindow.ui b/resources/forms/mainWindow.ui index f777c7c1..fe527d3a 100644 --- a/resources/forms/mainWindow.ui +++ b/resources/forms/mainWindow.ui @@ -1750,6 +1750,25 @@ Dotted Style + + + true + + + + :/images/stylusPalette/line.svg + :/images/stylusPalette/lineOn.svg:/images/stylusPalette/line.svg + + + Vector + + + Draw Vectors + + + Ctrl+J + + diff --git a/src/api/UBWidgetUniboardAPI.cpp b/src/api/UBWidgetUniboardAPI.cpp index 14c04019..91daebc5 100644 --- a/src/api/UBWidgetUniboardAPI.cpp +++ b/src/api/UBWidgetUniboardAPI.cpp @@ -145,6 +145,10 @@ void UBWidgetUniboardAPI::setTool(const QString& toolString) { UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Line); } + else if (lower == "vector") + { + UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Vector); + } } diff --git a/src/board/UBBoardController.cpp b/src/board/UBBoardController.cpp index 21b2b861..139dde62 100644 --- a/src/board/UBBoardController.cpp +++ b/src/board/UBBoardController.cpp @@ -2005,6 +2005,7 @@ void UBBoardController::setColorIndex(int pColorIndex) if (UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Marker && UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Line && + UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Vector && UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Text && UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Selector) { @@ -2013,6 +2014,7 @@ void UBBoardController::setColorIndex(int pColorIndex) if (UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Pen || UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Line || + UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Vector || UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Text || UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Selector) { @@ -2246,6 +2248,13 @@ void UBBoardController::stylusToolChanged(int tool) mPropertyPaletteWidgets[eraserWidth]->setVisible(false); mPropertyPaletteWidgets[lineStyle]->setVisible(true); } else + if (eTool == UBStylusTool::Vector) + { + mPropertyPaletteWidgets[color]->setVisible(true); + mPropertyPaletteWidgets[lineWidth]->setVisible(true); + mPropertyPaletteWidgets[eraserWidth]->setVisible(false); + mPropertyPaletteWidgets[lineStyle]->setVisible(false); + } else { mPropertyPaletteWidgets[color]->setVisible(false); mPropertyPaletteWidgets[lineWidth]->setVisible(false); diff --git a/src/board/UBBoardView.cpp b/src/board/UBBoardView.cpp index 734d7929..42c8b11e 100644 --- a/src/board/UBBoardView.cpp +++ b/src/board/UBBoardView.cpp @@ -368,7 +368,7 @@ void UBBoardView::tabletEvent (QTabletEvent * event) QPointF scenePos = viewportTransform ().inverted ().map (tabletPos); qreal pressure = 1.0; - if (((currentTool == UBStylusTool::Pen || currentTool == UBStylusTool::Line) && mPenPressureSensitive) || + if (((currentTool == UBStylusTool::Pen || currentTool == UBStylusTool::Line || currentTool == UBStylusTool::Vector) && mPenPressureSensitive) || (currentTool == UBStylusTool::Marker && mMarkerPressureSensitive)) pressure = event->pressure (); else{ @@ -1823,6 +1823,9 @@ void UBBoardView::setToolCursor (int tool) case UBStylusTool::Line: controlViewport->setCursor (UBResources::resources ()->penCursor); break; + case UBStylusTool::Vector: + controlViewport->setCursor (UBResources::resources ()->penCursor); + break; case UBStylusTool::Text: controlViewport->setCursor (UBResources::resources ()->textCursor); break; diff --git a/src/board/UBDrawingController.cpp b/src/board/UBDrawingController.cpp index da105aa4..d75e2895 100644 --- a/src/board/UBDrawingController.cpp +++ b/src/board/UBDrawingController.cpp @@ -75,6 +75,7 @@ UBDrawingController::UBDrawingController(QObject * parent) connect(UBApplication::mainWindow->actionZoomOut, SIGNAL(triggered(bool)), this, SLOT(zoomOutToolSelected(bool))); connect(UBApplication::mainWindow->actionPointer, SIGNAL(triggered(bool)), this, SLOT(pointerToolSelected(bool))); connect(UBApplication::mainWindow->actionLine, SIGNAL(triggered(bool)), this, SLOT(lineToolSelected(bool))); + connect(UBApplication::mainWindow->actionVector, SIGNAL(triggered(bool)), this, SLOT(vectorToolSelected(bool))); connect(UBApplication::mainWindow->actionText, SIGNAL(triggered(bool)), this, SLOT(textToolSelected(bool))); connect(UBApplication::mainWindow->actionCapture, SIGNAL(triggered(bool)), this, SLOT(captureToolSelected(bool))); } @@ -104,12 +105,12 @@ void UBDrawingController::setStylusTool(int tool) { UBApplication::boardController->activeScene()->deselectAllItems(); if (mStylusTool == UBStylusTool::Pen || mStylusTool == UBStylusTool::Marker - || mStylusTool == UBStylusTool::Line) + || mStylusTool == UBStylusTool::Line || mStylusTool == UBStylusTool::Vector) { mLatestDrawingTool = mStylusTool; } - if (tool == UBStylusTool::Pen || tool == UBStylusTool::Line) + if (tool == UBStylusTool::Pen || tool == UBStylusTool::Line || tool == UBStylusTool::Vector) { emit lineWidthIndexChanged(UBSettings::settings()->penWidthIndex()); emit colorIndexChanged(UBSettings::settings()->penColorIndex()); @@ -144,6 +145,8 @@ void UBDrawingController::setStylusTool(int tool) UBApplication::mainWindow->actionPointer->setChecked(true); else if (mStylusTool == UBStylusTool::Line) UBApplication::mainWindow->actionLine->setChecked(true); + else if (mStylusTool == UBStylusTool::Vector) + UBApplication::mainWindow->actionVector->setChecked(true); else if (mStylusTool == UBStylusTool::Text) UBApplication::mainWindow->actionText->setChecked(true); else if (mStylusTool == UBStylusTool::Capture) @@ -160,13 +163,14 @@ bool UBDrawingController::isDrawingTool() { return (stylusTool() == UBStylusTool::Pen) || (stylusTool() == UBStylusTool::Marker) + || (stylusTool() == UBStylusTool::Vector) || (stylusTool() == UBStylusTool::Line); } int UBDrawingController::currentToolWidthIndex() { - if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line) + if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line || stylusTool() == UBStylusTool::Vector) return UBSettings::settings()->penWidthIndex(); else if (stylusTool() == UBStylusTool::Marker) return UBSettings::settings()->markerWidthIndex(); @@ -177,7 +181,7 @@ int UBDrawingController::currentToolWidthIndex() qreal UBDrawingController::currentToolWidth() { - if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line) + if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line || stylusTool() == UBStylusTool::Vector) return UBSettings::settings()->currentPenWidth(); else if (stylusTool() == UBStylusTool::Marker) return UBSettings::settings()->currentMarkerWidth(); @@ -198,6 +202,7 @@ void UBDrawingController::setLineWidthIndex(int index) UBSettings::settings()->setPenWidthIndex(index); if(stylusTool() != UBStylusTool::Line + && stylusTool() != UBStylusTool::Vector && stylusTool() != UBStylusTool::Selector) { setStylusTool(UBStylusTool::Pen); @@ -210,7 +215,7 @@ void UBDrawingController::setLineWidthIndex(int index) int UBDrawingController::currentToolColorIndex() { - if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line) + if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line || stylusTool() == UBStylusTool::Vector) { return UBSettings::settings()->penColorIndex(); } @@ -233,7 +238,7 @@ QColor UBDrawingController::currentToolColor() QColor UBDrawingController::toolColor(bool onDarkBackground) { - if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line) + if (stylusTool() == UBStylusTool::Pen || stylusTool() == UBStylusTool::Line || stylusTool() == UBStylusTool::Vector) { return UBSettings::settings()->penColor(onDarkBackground); } @@ -412,6 +417,11 @@ void UBDrawingController::lineToolSelected(bool checked) setStylusTool(UBStylusTool::Line); } +void UBDrawingController::vectorToolSelected(bool checked) +{ + if (checked) + setStylusTool(UBStylusTool::Vector); +} void UBDrawingController::textToolSelected(bool checked) { diff --git a/src/board/UBDrawingController.h b/src/board/UBDrawingController.h index 4ed3b981..1cdff717 100644 --- a/src/board/UBDrawingController.h +++ b/src/board/UBDrawingController.h @@ -110,6 +110,7 @@ class UBDrawingController : public QObject void zoomOutToolSelected(bool checked); void pointerToolSelected(bool checked); void lineToolSelected(bool checked); + void vectorToolSelected(bool checked); void textToolSelected(bool checked); void captureToolSelected(bool checked); }; diff --git a/src/core/UB.h b/src/core/UB.h index c9bfa5cb..cd568c35 100644 --- a/src/core/UB.h +++ b/src/core/UB.h @@ -72,6 +72,7 @@ struct UBStylusTool Pointer, Line, Text, + Vector, Capture }; }; @@ -184,6 +185,7 @@ struct UBGraphicsItemType UserTypesCount, //65557 AxesItemType, //65558 LineItemType, //65559 + VectorItemType, //65560 SelectionFrameType // this line must be the last line in this enum because it is types counter. }; }; diff --git a/src/domain/UBGraphicsScene.cpp b/src/domain/UBGraphicsScene.cpp index 7ff28467..38741d6f 100644 --- a/src/domain/UBGraphicsScene.cpp +++ b/src/domain/UBGraphicsScene.cpp @@ -71,6 +71,7 @@ #include "UBGraphicsSvgItem.h" #include "UBGraphicsPolygonItem.h" #include "UBGraphicsLineItem.h" +#include "UBGraphicsVectorItem.h" #include "UBGraphicsMediaItem.h" #include "UBGraphicsWidgetItem.h" #include "UBGraphicsPDFItem.h" @@ -540,7 +541,7 @@ bool UBGraphicsScene::inputDeviceMove(const QPointF& scenePos, const qreal& pres width /= UBApplication::boardController->systemScaleFactor(); width /= UBApplication::boardController->currentZoom(); - if (currentTool == UBStylusTool::Line || dc->activeRuler()) + if (currentTool == UBStylusTool::Line || dc->activeRuler()|| currentTool == UBStylusTool::Vector) { QLineF radius(mPreviousPoint, position); qreal angle = radius.angle(); @@ -564,6 +565,9 @@ bool UBGraphicsScene::inputDeviceMove(const QPointF& scenePos, const qreal& pres else if (currentTool == UBStylusTool::Line) { drawLineTo(position, width, true); } + else if (currentTool == UBStylusTool::Vector) { + drawLineTo(position, width, true); + } else { bool interpolate = false; @@ -658,6 +662,16 @@ bool UBGraphicsScene::inputDeviceRelease(int tool) UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, NULL, mpLastLine); UBApplication::undoStack->push(uc); + mAddedItems.clear(); + } + } else + if(currentTool == UBStylusTool::Vector) + { + if (mUndoRedoStackEnabled) + { //should be deleted after scene own undo stack implemented + UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, NULL, mpLastVector); + UBApplication::undoStack->push(uc); + mAddedItems.clear(); } } else{ @@ -914,6 +928,7 @@ void UBGraphicsScene::moveTo(const QPointF &pPoint) } void UBGraphicsScene::drawLineTo(const QPointF &pEndPoint, const qreal &pWidth, bool bLineStyle) { + if(UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Vector) bLineStyle = true; drawLineTo(pEndPoint, pWidth, pWidth, bLineStyle); } @@ -937,6 +952,12 @@ void UBGraphicsScene::drawLineTo(const QPointF &pEndPoint, const qreal &startWid mAddedItems.clear(); } + if(UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Vector) + { + UBGraphicsVectorItem *vectorItem = new UBGraphicsVectorItem(QLineF(mPreviousPoint, pEndPoint), initialWidth, endWidth); + initVectorItem(vectorItem); + addVectorItemToCurrentStroke(vectorItem); + } else if (UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Line) { UBGraphicsPolygonItem *polygonItem = lineToPolygonItem(QLineF(mPreviousPoint, pEndPoint), initialWidth, endWidth); @@ -1015,6 +1036,20 @@ void UBGraphicsScene::addLineItemToCurrentStroke(UBGraphicsLineItem* lineItem) } +void UBGraphicsScene::addVectorItemToCurrentStroke(UBGraphicsVectorItem* vectorItem) +{ + vectorItem->setFlag(QGraphicsItem::ItemIsMovable, true); + vectorItem->setFlag(QGraphicsItem::ItemIsSelectable, true); + vectorItem->SetDelegate(); + + mpLastVector = vectorItem; + mAddedItems.insert(vectorItem); + + // Here we add the item to the scene + addItem(vectorItem); + +} + void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth) { const QLineF line(mPreviousPoint, pEndPoint); @@ -1036,11 +1071,14 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth) QList intersectedLineItems; + QList intersectedVectorItems; + #pragma omp parallel for for(int i=0; i(collidItems[i]); UBGraphicsLineItem *li = qgraphicsitem_cast(collidItems[i]); + UBGraphicsVectorItem *vi = qgraphicsitem_cast(collidItems[i]); if(pi != NULL) { QPainterPath itemPainterPath; @@ -1081,7 +1119,24 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth) intersectedLineItems << li; } } + }else if (vi != NULL) + { + QPainterPath itemPainterPath; + QList linePoints = vi->linePoints(); + for (int i=0; i < linePoints.count(); ++i) + { + itemPainterPath.addEllipse(linePoints[i], 1, 1); + } + if (eraserPath.contains(itemPainterPath) || eraserPath.intersects(itemPainterPath)) + { + #pragma omp critical + { + // Compete remove item + intersectedVectorItems << vi; + } + } } + } for(int i=0; isetTransform(t); + } + } + + if (!intersectedItems.empty() || !intersectedLineItems.empty()||!intersectedVectorItems.empty()) setModified(true); } @@ -1352,6 +1421,28 @@ void UBGraphicsScene::initLineItem(UBGraphicsLineItem* lineItem) lineItem->setPen(linePen); } +void UBGraphicsScene::initVectorItem(UBGraphicsVectorItem* vectorItem) +{ + QColor colorOnDarkBG; + QColor colorOnLightBG; + + colorOnDarkBG = UBApplication::boardController->penColorOnDarkBackground(); + colorOnLightBG = UBApplication::boardController->penColorOnLightBackground(); + + if (mDarkBackground) + { + vectorItem->setColor(colorOnDarkBG); + } + else + { + vectorItem->setColor(colorOnLightBG); + } + vectorItem->setColorOnDarkBackground(colorOnDarkBG); + vectorItem->setColorOnLightBackground(colorOnLightBG); + + vectorItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Graphic)); +} + UBGraphicsPolygonItem* UBGraphicsScene::arcToPolygonItem(const QLineF& pStartRadius, qreal pSpanAngle, qreal pWidth) { QPolygonF polygon = UBGeometryUtils::arcToPolygon(pStartRadius, pSpanAngle, pWidth); @@ -1572,7 +1663,8 @@ void UBGraphicsScene::clearContent(clearCase pCase) ? qgraphicsitem_cast(item->parentItem()) : 0; UBGraphicsItemDelegate *curDelegate = UBGraphicsItem::Delegate(item); - if (!curDelegate && item->type() != UBGraphicsLineItem::Type) { + if (!curDelegate && item->type() != UBGraphicsLineItem::Type + && item->type() != UBGraphicsVectorItem::Type) { continue; } @@ -1581,6 +1673,10 @@ void UBGraphicsScene::clearContent(clearCase pCase) bool shouldDelete = false; if(item->type()==UBGraphicsLineItem::Type) + { + removedItems << item; + this->removeItem(item); + } else if(item->type()==UBGraphicsVectorItem::Type) { removedItems << item; this->removeItem(item); diff --git a/src/domain/UBGraphicsScene.h b/src/domain/UBGraphicsScene.h index 54483e75..ab6274e0 100644 --- a/src/domain/UBGraphicsScene.h +++ b/src/domain/UBGraphicsScene.h @@ -42,6 +42,7 @@ class UBGraphicsProxyWidget; class UBGraphicsSvgItem; class UBGraphicsPolygonItem; class UBGraphicsLineItem; +class UBGraphicsVectorItem; class UBGraphicsMediaItem; class UBGraphicsWidgetItem; class UBGraphicsW3CWidgetItem; @@ -402,9 +403,11 @@ public slots: UBGraphicsPolygonItem* curveToPolygonItem(const QList &points, qreal startWidth, qreal endWidth); void addPolygonItemToCurrentStroke(UBGraphicsPolygonItem* polygonItem); void addLineItemToCurrentStroke(UBGraphicsLineItem* lineItem); + void addVectorItemToCurrentStroke(UBGraphicsVectorItem* vectorItem); void initPolygonItem(UBGraphicsPolygonItem*); void initLineItem(UBGraphicsLineItem*); + void initVectorItem(UBGraphicsVectorItem*); void drawEraser(const QPointF& pEndPoint, bool pressed = true); @@ -498,6 +501,7 @@ public slots: UBGraphicsPolygonItem* mpLastPolygon; UBGraphicsPolygonItem* mTempPolygon; UBGraphicsLineItem* mpLastLine; + UBGraphicsVectorItem* mpLastVector; bool mDrawWithCompass; UBGraphicsPolygonItem *mCurrentPolygon; diff --git a/src/domain/UBGraphicsVectorItem.cpp b/src/domain/UBGraphicsVectorItem.cpp new file mode 100644 index 00000000..22d5a5bb --- /dev/null +++ b/src/domain/UBGraphicsVectorItem.cpp @@ -0,0 +1,206 @@ +#include "UBGraphicsVectorItem.h" + +#include "frameworks/UBGeometryUtils.h" +#include "UBGraphicsScene.h" +#include "core/memcheck.h" +#include + +UBGraphicsVectorItem::UBGraphicsVectorItem (QGraphicsItem * parent) + : QGraphicsLineItem(parent) + , mHasAlpha(false) + , mOriginalWidth(-1) + , mIsNominalLine(false) +{ + // NOOP + initialize(); +} + +UBGraphicsVectorItem::UBGraphicsVectorItem (const QLineF & line, QGraphicsItem * parent) + : QGraphicsLineItem(line, parent) + , mOriginalWidth(-1) + , mIsNominalLine(false) +{ + // NOOP + initialize(); +} + + +UBGraphicsVectorItem::UBGraphicsVectorItem (const QLineF& pLine, qreal pWidth) + : QGraphicsLineItem(pLine) + , mOriginalLine(pLine) + , mOriginalWidth(pWidth) + , mIsNominalLine(true) +{ + // NOOP + initialize(); +} + +UBGraphicsVectorItem::UBGraphicsVectorItem (const QLineF& pLine, qreal pStartWidth, qreal pEndWidth) + : QGraphicsLineItem(pLine) + , mOriginalLine(pLine) + , mOriginalWidth(pEndWidth) + , mIsNominalLine(true) +{ + // NOOP + initialize(); +} + + +void UBGraphicsVectorItem::initialize() +{ + //setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::DrawingItem)); //Necessary to set if we want z value to be assigned correctly + setDelegate(new UBGraphicsItemDelegate(this, 0, GF_COMMON + | GF_RESPECT_RATIO + | GF_REVOLVABLE + | GF_FLIPPABLE_ALL_AXIS)); + setUuid(QUuid::createUuid()); + setData(UBGraphicsItemData::itemLayerType, QVariant(itemLayerType::ObjectItem)); //Necessary to set if we want z value to be assigned correctly + setFlag(QGraphicsItem::ItemSendsGeometryChanges, true); + setFlag(QGraphicsItem::ItemIsSelectable, true); + setFlag(QGraphicsItem::ItemIsMovable, true); + setSublines(); +} + +void UBGraphicsVectorItem::setSublines() +{ + QLineF thisLine = QLineF(this->line().p2().x(), this->line().p2().y(),this->line().p2().x()+this->line().length()/10, this->line().p2().y()); + thisLine.setAngle(this->line().angle() - 135); + sublines.push_back(new QGraphicsLineItem(thisLine)); + + thisLine = QLineF(this->line().p2().x(), this->line().p2().y(),this->line().p2().x()+this->line().length()/10, this->line().p2().y()); + thisLine.setAngle(this->line().angle() + 135); + sublines.push_back(new QGraphicsLineItem(thisLine)); +} + +void UBGraphicsVectorItem::setUuid(const QUuid &pUuid) +{ + UBItem::setUuid(pUuid); + setData(UBGraphicsItemData::ItemUuid, QVariant(pUuid)); //store item uuid inside the QGraphicsItem to fast operations with Items on the scene +} + +UBGraphicsVectorItem::~UBGraphicsVectorItem() +{ + for (int i = 0; i < sublines.size(); ++i) + delete sublines[i]; + sublines.clear(); +} + +void UBGraphicsVectorItem::setColor(const QColor& pColor) +{ + QPen pen = QPen(pColor); + pen.setStyle(style()); + pen.setCapStyle(Qt::PenCapStyle::RoundCap); + pen.setWidth(mOriginalWidth); + QGraphicsLineItem::setPen(pen); + for (int i = 0; i < sublines.size(); ++i) + sublines[i]->setPen(pen); + mHasAlpha = (pColor.alphaF() < 1.0); +} + + +QColor UBGraphicsVectorItem::color() const +{ + return QGraphicsLineItem::pen().color(); +} + +void UBGraphicsVectorItem::setStyle(const Qt::PenStyle& style) +{ + QPen pen = QPen(color()); + pen.setStyle(style); + pen.setCapStyle(Qt::PenCapStyle::RoundCap); + pen.setWidth(mOriginalWidth); + QGraphicsLineItem::setPen(pen); + for (int i = 0; i < sublines.size(); ++i) + sublines[i]->setPen(pen); +} + +Qt::PenStyle UBGraphicsVectorItem::style() const +{ + return QGraphicsLineItem::pen().style(); +} + +QList UBGraphicsVectorItem::linePoints() +{ + QList points = QList(); + qreal incr = 1/line().length(); + if (incr<0) incr*=-1; + if (incr>0) + { + for (qreal t = 0; t <= 1; t+=incr) + { + points.push_back(line().pointAt(t)); + } + } + return points; +} + +UBItem* UBGraphicsVectorItem::deepCopy() const +{ + UBGraphicsVectorItem* copy = new UBGraphicsVectorItem(line()); + copyItemParameters(copy); + return copy; +} + + +void UBGraphicsVectorItem::copyItemParameters(UBItem *copy) const +{ + UBGraphicsVectorItem *cp = dynamic_cast(copy); + if (cp) + { + cp->mOriginalLine = this->mOriginalLine; + cp->mOriginalWidth = this->mOriginalWidth; + cp->mIsNominalLine = this->mIsNominalLine; + + cp->setTransform(transform()); + cp->setPos(pos()); + cp->setPen(this->pen()); + cp->mHasAlpha = this->mHasAlpha; + + cp->setColorOnDarkBackground(this->colorOnDarkBackground()); + cp->setColorOnLightBackground(this->colorOnLightBackground()); + + cp->setFlag(QGraphicsItem::ItemIsMovable, true); + cp->setFlag(QGraphicsItem::ItemIsSelectable, true); + cp->setZValue(this->zValue()); + cp->setData(UBGraphicsItemData::ItemLayerType, this->data(UBGraphicsItemData::ItemLayerType)); + cp->setData(UBGraphicsItemData::ItemLocked, this->data(UBGraphicsItemData::ItemLocked)); + } +} + +void UBGraphicsVectorItem::paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) +{ + QStyleOptionGraphicsItem styleOption = QStyleOptionGraphicsItem(*option); + if(mHasAlpha && scene() && scene()->isLightBackground()) + painter->setCompositionMode(QPainter::CompositionMode_SourceOver); + + painter->setRenderHints(QPainter::Antialiasing); + + QGraphicsLineItem::paint(painter, option, widget); + for (int i = 0; i paint(painter, option, widget); + } + Delegate()->postpaint(painter, &styleOption, widget); +} + +UBGraphicsScene* UBGraphicsVectorItem::scene() +{ + return qobject_cast(QGraphicsLineItem::scene()); +} + +void UBGraphicsVectorItem::SetDelegate() +{ + Delegate()->createControls(); +} + +QVariant UBGraphicsVectorItem::itemChange(GraphicsItemChange change, const QVariant &value) +{ + QVariant newValue = Delegate()->itemChange(change, value); + UBGraphicsItem *item = dynamic_cast(this); + if (item) + { + item->Delegate()->positionHandles(); + } + + return QGraphicsItem::itemChange(change, newValue); +} diff --git a/src/domain/UBGraphicsVectorItem.h b/src/domain/UBGraphicsVectorItem.h new file mode 100644 index 00000000..7227065b --- /dev/null +++ b/src/domain/UBGraphicsVectorItem.h @@ -0,0 +1,107 @@ +#ifndef UBGRAPHICSVECTORITEM_H +#define UBGRAPHICSVECTORITEM_H + +#include +#include "core/UB.h" +#include "UBItem.h" + +class UBItem; +class UBGraphicsScene; + +class UBGraphicsVectorItem: public QGraphicsLineItem, public UBItem, public UBGraphicsItem +{ + +public: + UBGraphicsVectorItem(); +public: + + UBGraphicsVectorItem(QGraphicsItem * parent = 0 ); + UBGraphicsVectorItem(const QLineF& line, qreal pWidth); + UBGraphicsVectorItem(const QLineF& pLine, qreal pStartWidth, qreal pEndWidth); + UBGraphicsVectorItem(const QLineF & line, QGraphicsItem * parent = 0); + + ~UBGraphicsVectorItem(); + + void initialize(); + + void setUuid(const QUuid &pUuid); + + void setColor(const QColor& color); + void setStyle(const Qt::PenStyle& style); + + QColor color() const; + Qt::PenStyle style() const; + + virtual UBGraphicsScene* scene(); + + enum { Type = UBGraphicsItemType::VectorItemType }; + + virtual int type() const + { + return Type; + } + + void setLine(const QLineF pLine) + { + mIsNominalLine = false; + QGraphicsLineItem::setLine(pLine); + } + + virtual UBItem* deepCopy() const; + + virtual void copyItemParameters(UBItem *copy) const; + + QLineF originalLine() { return mOriginalLine;} + qreal originalWidth() { return mOriginalWidth;} + bool isNominalLine() {return mIsNominalLine;} + + void setNominalLine(bool isNominalLine) { mIsNominalLine = isNominalLine; } + + QList linePoints(); + + QColor colorOnDarkBackground() const + { + return mColorOnDarkBackground; + } + + void setColorOnDarkBackground(QColor pColorOnDarkBackground) + { + mColorOnDarkBackground = pColorOnDarkBackground; + } + + QColor colorOnLightBackground() const + { + return mColorOnLightBackground; + } + + void setColorOnLightBackground(QColor pColorOnLightBackground) + { + mColorOnLightBackground = pColorOnLightBackground; + } + + void SetDelegate(); + + QList SubLines() + { + return sublines; + } + + protected: + void paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget); + virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value); + void setSublines(); + + private: + + bool mHasAlpha; + + QLineF mOriginalLine; + qreal mOriginalWidth; + bool mIsNominalLine; + + QColor mColorOnDarkBackground; + QColor mColorOnLightBackground; + QList sublines; +}; + +#endif // UBGRAPHICSVECTORITEM_H diff --git a/src/domain/domain.pri b/src/domain/domain.pri index 91206704..ec4e08ee 100644 --- a/src/domain/domain.pri +++ b/src/domain/domain.pri @@ -1,4 +1,5 @@ HEADERS += src/domain/UBGraphicsScene.h \ + $$PWD/UBGraphicsVectorItem.h \ src/domain/UBGraphicsItemUndoCommand.h \ src/domain/UBGraphicsTextItemUndoCommand.h \ src/domain/UBGraphicsItemTransformUndoCommand.h \ @@ -29,6 +30,7 @@ HEADERS += src/domain/UBGraphicsScene.h \ src/domain/UBGraphicsItemZLevelUndoCommand.h SOURCES += src/domain/UBGraphicsScene.cpp \ + $$PWD/UBGraphicsVectorItem.cpp \ src/domain/UBGraphicsItemUndoCommand.cpp \ src/domain/UBGraphicsTextItemUndoCommand.cpp \ src/domain/UBGraphicsItemTransformUndoCommand.cpp \ diff --git a/src/gui/UBStylusPalette.cpp b/src/gui/UBStylusPalette.cpp index 11190b92..cb039782 100644 --- a/src/gui/UBStylusPalette.cpp +++ b/src/gui/UBStylusPalette.cpp @@ -61,6 +61,7 @@ UBStylusPalette::UBStylusPalette(QWidget *parent, Qt::Orientation orient) actions << UBApplication::mainWindow->actionPointer; actions << UBApplication::mainWindow->actionLine; + actions << UBApplication::mainWindow->actionVector; actions << UBApplication::mainWindow->actionText; actions << UBApplication::mainWindow->actionCapture; diff --git a/src/gui/UBToolbarButtonGroup.cpp b/src/gui/UBToolbarButtonGroup.cpp index 30f697e5..686c8519 100644 --- a/src/gui/UBToolbarButtonGroup.cpp +++ b/src/gui/UBToolbarButtonGroup.cpp @@ -209,7 +209,8 @@ void UBToolbarButtonGroup::colorPaletteChanged() QList colors; - if (UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Pen + if (UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Pen + || UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Vector || UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Line) { colors = UBSettings::settings()->penColors(isDarkBackground);