Merge branch 'master' of github.com:Sankore/Sankore-3.1

preferencesAboutTextFull
Claudio Valerio 13 years ago
commit 97dc3d90bf
  1. 7
      src/board/UBBoardView.cpp
  2. 11
      src/board/UBDrawingController.cpp
  3. 8
      src/board/UBDrawingController.h
  4. 2
      src/core/UBApplicationController.cpp
  5. 9
      src/domain/UBGraphicsPolygonItem.cpp
  6. 1
      src/domain/UBGraphicsPolygonItem.h
  7. 134
      src/domain/UBGraphicsScene.cpp
  8. 1
      src/domain/UBGraphicsScene.h
  9. 7
      src/domain/UBGraphicsStroke.cpp
  10. 2
      src/domain/UBGraphicsStroke.h
  11. 86
      src/domain/UBGraphicsStrokesGroup.cpp
  12. 28
      src/domain/UBGraphicsStrokesGroup.h
  13. 6
      src/domain/domain.pri
  14. 6
      src/frameworks/UBCoreGraphicsScene.cpp
  15. 1
      src/frameworks/UBCoreGraphicsScene.h
  16. 13
      src/tools/UBGraphicsRuler.cpp

@ -316,7 +316,6 @@ void UBBoardView::tabletEvent (QTabletEvent * event)
} }
QPointF scenePos = viewportTransform ().inverted ().map (tabletPos); QPointF scenePos = viewportTransform ().inverted ().map (tabletPos);
qDebug() << "scene Pos " << scenePos;
qreal pressure = 1.0; qreal pressure = 1.0;
if (((currentTool == UBStylusTool::Pen || currentTool == UBStylusTool::Line) if (((currentTool == UBStylusTool::Pen || currentTool == UBStylusTool::Line)
@ -329,16 +328,12 @@ void UBBoardView::tabletEvent (QTabletEvent * event)
switch (event->type ()) { switch (event->type ()) {
case QEvent::TabletPress: { case QEvent::TabletPress: {
qDebug() << "TabletPress";
mTabletStylusIsPressed = true; mTabletStylusIsPressed = true;
scene()->inputDevicePress (scenePos, pressure); scene()->inputDevicePress (scenePos, pressure);
break; break;
} }
case QEvent::TabletMove: { case QEvent::TabletMove: {
qDebug() << "TabletMove";
if (mTabletStylusIsPressed) if (mTabletStylusIsPressed)
scene ()->inputDeviceMove (scenePos, pressure); scene ()->inputDeviceMove (scenePos, pressure);
@ -348,8 +343,6 @@ void UBBoardView::tabletEvent (QTabletEvent * event)
} }
case QEvent::TabletRelease: { case QEvent::TabletRelease: {
qDebug() << "TabletRelease";
UBStylusTool::Enum currentTool = (UBStylusTool::Enum)dc->stylusTool (); UBStylusTool::Enum currentTool = (UBStylusTool::Enum)dc->stylusTool ();
scene ()->setToolCursor (currentTool); scene ()->setToolCursor (currentTool);
setToolCursor (currentTool); setToolCursor (currentTool);

@ -45,6 +45,7 @@ UBDrawingController::UBDrawingController(QObject * parent)
, mActiveRuler(NULL) , mActiveRuler(NULL)
, mStylusTool((UBStylusTool::Enum)-1) , mStylusTool((UBStylusTool::Enum)-1)
, mLatestDrawingTool((UBStylusTool::Enum)-1) , mLatestDrawingTool((UBStylusTool::Enum)-1)
//, mDrawingMode(eDrawingMode_Vector)
{ {
connect(UBSettings::settings(), SIGNAL(colorContextChanged()), this, SIGNAL(colorPaletteChanged())); connect(UBSettings::settings(), SIGNAL(colorContextChanged()), this, SIGNAL(colorPaletteChanged()));
@ -387,3 +388,13 @@ void UBDrawingController::captureToolSelected(bool checked)
if (checked) if (checked)
setStylusTool(UBStylusTool::Capture); setStylusTool(UBStylusTool::Capture);
} }
void UBDrawingController::setDrawingMode(eDrawingMode mode)
{
mDrawingMode = mode;
}
eDrawingMode UBDrawingController::drawingMode()
{
return mDrawingMode;
}

@ -22,6 +22,11 @@
class UBAbstractDrawRuler; class UBAbstractDrawRuler;
typedef enum{
eDrawingMode_Artistic,
eDrawingMode_Vector
}eDrawingMode;
class UBDrawingController : public QObject class UBDrawingController : public QObject
{ {
Q_OBJECT; Q_OBJECT;
@ -49,6 +54,8 @@ class UBDrawingController : public QObject
void setPenColor(bool onDarkBackground, const QColor& color, int pIndex); void setPenColor(bool onDarkBackground, const QColor& color, int pIndex);
void setMarkerColor(bool onDarkBackground, const QColor& color, int pIndex); void setMarkerColor(bool onDarkBackground, const QColor& color, int pIndex);
void setMarkerAlpha(qreal alpha); void setMarkerAlpha(qreal alpha);
void setDrawingMode(eDrawingMode mode);
eDrawingMode drawingMode();
UBAbstractDrawRuler* mActiveRuler; UBAbstractDrawRuler* mActiveRuler;
@ -69,6 +76,7 @@ class UBDrawingController : public QObject
private: private:
UBStylusTool::Enum mStylusTool; UBStylusTool::Enum mStylusTool;
UBStylusTool::Enum mLatestDrawingTool; UBStylusTool::Enum mLatestDrawingTool;
eDrawingMode mDrawingMode;
static UBDrawingController* sDrawingController; static UBDrawingController* sDrawingController;

@ -463,6 +463,7 @@ void UBApplicationController::showDesktop(bool dontSwitchFrontProcess)
UBPlatformUtils::bringPreviousProcessToFront(); UBPlatformUtils::bringPreviousProcessToFront();
} }
UBDrawingController::drawingController()->setDrawingMode(eDrawingMode_Artistic);
UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Selector); UBDrawingController::drawingController()->setStylusTool(UBStylusTool::Selector);
} }
@ -606,6 +607,7 @@ void UBApplicationController::checkUpdateRequest()
void UBApplicationController::hideDesktop() void UBApplicationController::hideDesktop()
{ {
mDisplayManager->adjustScreens(-1); mDisplayManager->adjustScreens(-1);
UBDrawingController::drawingController()->setDrawingMode(eDrawingMode_Vector);
if (mMainMode == Board) if (mMainMode == Board)
{ {

@ -176,7 +176,6 @@ UBGraphicsPolygonItem* UBGraphicsPolygonItem::deepCopy(const QPolygonF& pol) con
void UBGraphicsPolygonItem::paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget) void UBGraphicsPolygonItem::paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget)
{ {
if(mHasAlpha && scene() && scene()->isLightBackground()) if(mHasAlpha && scene() && scene()->isLightBackground())
{ {
painter->setCompositionMode(QPainter::CompositionMode_Darken); painter->setCompositionMode(QPainter::CompositionMode_Darken);
@ -190,11 +189,3 @@ UBGraphicsScene* UBGraphicsPolygonItem::scene()
{ {
return qobject_cast<UBGraphicsScene*>(QGraphicsPolygonItem::scene()); return qobject_cast<UBGraphicsScene*>(QGraphicsPolygonItem::scene());
} }

@ -116,7 +116,6 @@ class UBGraphicsPolygonItem : public QGraphicsPolygonItem, public UBItem
protected: protected:
void paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget); void paint ( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget);
private: private:
void clearStroke(); void clearStroke();

@ -54,6 +54,7 @@
#include "UBGraphicsWidgetItem.h" #include "UBGraphicsWidgetItem.h"
#include "UBGraphicsPDFItem.h" #include "UBGraphicsPDFItem.h"
#include "UBGraphicsTextItem.h" #include "UBGraphicsTextItem.h"
#include "UBGraphicsStrokesGroup.h"
#include "UBAppleWidget.h" #include "UBAppleWidget.h"
#include "UBW3CWidget.h" #include "UBW3CWidget.h"
@ -269,8 +270,9 @@ UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
, magniferDisplayViewWidget(0) , magniferDisplayViewWidget(0)
, mZLayerController(new UBZLayerController(this)) , mZLayerController(new UBZLayerController(this))
, mIsDesktopMode(false) , mIsDesktopMode(false)
, mpLastPolygon(NULL)
{ {
UBCoreGraphicsScene::setObjectName("BoardScene");
#ifdef __ppc__ #ifdef __ppc__
mShouldUseOMP = false; mShouldUseOMP = false;
#elif defined(Q_WS_MAC) #elif defined(Q_WS_MAC)
@ -331,19 +333,29 @@ bool UBGraphicsScene::inputDevicePress(const QPointF& scenePos, const qreal& pre
if (UBDrawingController::drawingController()->isDrawingTool()) if (UBDrawingController::drawingController()->isDrawingTool())
{ {
// -----------------------------------------------------------------
// We fall here if we are using the Pen, the Marker or the Line tool
// -----------------------------------------------------------------
qreal width = 0; qreal width = 0;
// delete current stroke, if not assigned to any polygon // delete current stroke, if not assigned to any polygon
if (mCurrentStroke) if (mCurrentStroke && mCurrentStroke->polygons().empty()){
if (mCurrentStroke->polygons().empty()) delete mCurrentStroke;
delete mCurrentStroke; mCurrentStroke = NULL;
}
// ---------------------------------------------------------------
// Create a new Stroke. A Stroke is a collection of QGraphicsLines
// ---------------------------------------------------------------
mCurrentStroke = new UBGraphicsStroke(); mCurrentStroke = new UBGraphicsStroke();
if (currentTool != UBStylusTool::Line) if (currentTool != UBStylusTool::Line){
// Handle the pressure
width = UBDrawingController::drawingController()->currentToolWidth() * pressure; width = UBDrawingController::drawingController()->currentToolWidth() * pressure;
else }else{
width = UBDrawingController::drawingController()->currentToolWidth(); //ignore pressure for line tool // Ignore pressure for the line tool
width = UBDrawingController::drawingController()->currentToolWidth();
}
width /= UBApplication::boardController->systemScaleFactor(); width /= UBApplication::boardController->systemScaleFactor();
width /= UBApplication::boardController->currentZoom(); width /= UBApplication::boardController->currentZoom();
@ -352,15 +364,13 @@ bool UBGraphicsScene::inputDevicePress(const QPointF& scenePos, const qreal& pre
mRemovedItems.clear(); mRemovedItems.clear();
if (UBDrawingController::drawingController()->mActiveRuler) if (UBDrawingController::drawingController()->mActiveRuler)
{ {
UBDrawingController::drawingController()->mActiveRuler->StartLine( UBDrawingController::drawingController()->mActiveRuler->StartLine(scenePos, width);
scenePos, width);
} }
else else
{ {
moveTo(scenePos); moveTo(scenePos);
drawLineTo(scenePos, width, drawLineTo(scenePos, width, UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Line);
UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Line);
} }
accepted = true; accepted = true;
} }
@ -411,39 +421,48 @@ bool UBGraphicsScene::inputDeviceMove(const QPointF& scenePos, const qreal& pres
{ {
qreal width = 0; qreal width = 0;
if (currentTool != UBStylusTool::Line) if (currentTool != UBStylusTool::Line){
// Handle the pressure
width = dc->currentToolWidth() * pressure; width = dc->currentToolWidth() * pressure;
else }else{
width = dc->currentToolWidth();//ignore pressure for line tool // Ignore pressure for line tool
width = dc->currentToolWidth();
}
width /= UBApplication::boardController->systemScaleFactor(); width /= UBApplication::boardController->systemScaleFactor();
width /= UBApplication::boardController->currentZoom(); width /= UBApplication::boardController->currentZoom();
if (dc->mActiveRuler) if (currentTool == UBStylusTool::Line || dc->mActiveRuler)
{ {
dc->mActiveRuler->DrawLine(position, width); if(NULL != mpLastPolygon && NULL != mCurrentStroke && mAddedItems.size() > 0){
} UBCoreGraphicsScene::removeItemFromDeletion(mpLastPolygon);
else mAddedItems.remove(mpLastPolygon);
{ mCurrentStroke->remove(mpLastPolygon);
if (currentTool == UBStylusTool::Line) removeItem(mpLastPolygon);
{ mPreviousPolygonItems.removeAll(mpLastPolygon);
// TODO: Verify this beautiful implementation and check if }
// it is possible to optimize it
QLineF radius(mPreviousPoint, position); // ------------------------------------------------------------------------
qreal angle = radius.angle(); // Here we wanna make sure that the Line will 'grip' at i*45, i*90 degrees
angle = qRound(angle / 45) * 45; // ------------------------------------------------------------------------
qreal radiusLength = radius.length();
QPointF newPosition( QLineF radius(mPreviousPoint, position);
mPreviousPoint.x() + radiusLength * cos((angle * PI) / 180), qreal angle = radius.angle();
mPreviousPoint.y() - radiusLength * sin((angle * PI) / 180)); angle = qRound(angle / 45) * 45;
QLineF chord(position, newPosition); qreal radiusLength = radius.length();
if (chord.length() < qMin((int)16, (int)(radiusLength / 20))) QPointF newPosition(
position = newPosition; mPreviousPoint.x() + radiusLength * cos((angle * PI) / 180),
} mPreviousPoint.y() - radiusLength * sin((angle * PI) / 180));
QLineF chord(position, newPosition);
drawLineTo(position, width, if (chord.length() < qMin((int)16, (int)(radiusLength / 20)))
UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Line); position = newPosition;
} }
if(dc->mActiveRuler){
dc->mActiveRuler->DrawLine(position, width);
}else{
drawLineTo(position, width, UBDrawingController::drawingController()->stylusTool() == UBStylusTool::Line);
}
} }
else if (currentTool == UBStylusTool::Eraser) else if (currentTool == UBStylusTool::Eraser)
{ {
@ -492,9 +511,31 @@ bool UBGraphicsScene::inputDeviceRelease()
{ {
if (mCurrentStroke) if (mCurrentStroke)
{ {
if (mCurrentStroke->polygons().empty()) if(eDrawingMode_Vector == dc->drawingMode()){
UBGraphicsStrokesGroup* pStrokes = new UBGraphicsStrokesGroup();
// Remove the strokes that were just drawn here and replace them by a stroke item
foreach(UBGraphicsPolygonItem* poly, mCurrentStroke->polygons()){
mPreviousPolygonItems.removeAll(poly);
removeItem(poly);
UBCoreGraphicsScene::removeItemFromDeletion(poly);
pStrokes->addToGroup(poly);
}
// TODO LATER : Generate well pressure-interpolated polygons and create the line group with them
mAddedItems.clear();
// Add the groupItem in mAddedItem
mAddedItems << pStrokes;
addItem(pStrokes);
}
if (mCurrentStroke->polygons().empty()){
delete mCurrentStroke; delete mCurrentStroke;
mCurrentStroke = 0; mCurrentStroke = 0;
}
} }
} }
@ -606,6 +647,9 @@ void UBGraphicsScene::drawLineTo(const QPointF &pEndPoint, const qreal &pWidth,
if (!polygonItem->brush().isOpaque()) if (!polygonItem->brush().isOpaque())
{ {
// -------------------------------------------------------------------------------------
// Here we substract the polygons that are overlapping in order to keep the transparency
// -------------------------------------------------------------------------------------
for (int i = 0; i < mPreviousPolygonItems.size(); i++) for (int i = 0; i < mPreviousPolygonItems.size(); i++)
{ {
UBGraphicsPolygonItem* previous = mPreviousPolygonItems.value(i); UBGraphicsPolygonItem* previous = mPreviousPolygonItems.value(i);
@ -625,15 +669,17 @@ void UBGraphicsScene::drawLineTo(const QPointF &pEndPoint, const qreal &pWidth,
mAddedItems.clear(); mAddedItems.clear();
} }
mpLastPolygon = polygonItem;
mAddedItems.insert(polygonItem); mAddedItems.insert(polygonItem);
// Here we add the item to the scene
addItem(polygonItem);
if (mCurrentStroke) if (mCurrentStroke)
{ {
polygonItem->setStroke(mCurrentStroke); polygonItem->setStroke(mCurrentStroke);
} }
addItem(polygonItem);
mPreviousPolygonItems.append(polygonItem); mPreviousPolygonItems.append(polygonItem);
if (!bLineStyle) if (!bLineStyle)

@ -395,6 +395,7 @@ public slots:
UBMagnifier *magniferDisplayViewWidget; UBMagnifier *magniferDisplayViewWidget;
UBZLayerController *mZLayerController; UBZLayerController *mZLayerController;
UBGraphicsPolygonItem* mpLastPolygon;
}; };

@ -86,3 +86,10 @@ bool UBGraphicsStroke::hasAlpha() const
} }
} }
void UBGraphicsStroke::clear()
{
if(!mPolygons.empty()){
mPolygons.clear();
}
}

@ -41,6 +41,8 @@ class UBGraphicsStroke
bool hasAlpha() const; bool hasAlpha() const;
void clear();
protected: protected:
void addPolygon(UBGraphicsPolygonItem* pol); void addPolygon(UBGraphicsPolygonItem* pol);

@ -0,0 +1,86 @@
#include "UBGraphicsStrokesGroup.h"
UBGraphicsStrokesGroup::UBGraphicsStrokesGroup(QGraphicsItem *parent):QGraphicsItemGroup(parent)
{
mDelegate = new UBGraphicsItemDelegate(this, 0, true, true);
mDelegate->init();
mDelegate->setFlippable(true);
setData(UBGraphicsItemData::ItemLayerType, UBItemLayerType::Object);
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);
}
UBGraphicsStrokesGroup::~UBGraphicsStrokesGroup()
{
if(mDelegate){
delete mDelegate;
}
}
void UBGraphicsStrokesGroup::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
if (mDelegate->mousePressEvent(event))
{
//NOOP
}
else
{
// QGraphicsItemGroup::mousePressEvent(event);
}
}
void UBGraphicsStrokesGroup::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (mDelegate->mouseMoveEvent(event))
{
// NOOP;
}
else
{
QGraphicsItemGroup::mouseMoveEvent(event);
}
}
void UBGraphicsStrokesGroup::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
mDelegate->mouseReleaseEvent(event);
QGraphicsItemGroup::mouseReleaseEvent(event);
}
UBItem* UBGraphicsStrokesGroup::deepCopy() const
{
UBGraphicsStrokesGroup* copy = new UBGraphicsStrokesGroup();
copy->setPos(this->pos());
copy->setTransform(this->transform());
copy->setFlag(QGraphicsItem::ItemIsMovable, true);
copy->setFlag(QGraphicsItem::ItemIsSelectable, true);
copy->setData(UBGraphicsItemData::ItemLayerType, this->data(UBGraphicsItemData::ItemLayerType));
copy->setData(UBGraphicsItemData::ItemLocked, this->data(UBGraphicsItemData::ItemLocked));
return copy;
}
void UBGraphicsStrokesGroup::remove()
{
if (mDelegate)
mDelegate->remove(true);
}
void UBGraphicsStrokesGroup::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
// Never draw the rubber band, we draw our custom selection with the DelegateFrame
QStyleOptionGraphicsItem styleOption = QStyleOptionGraphicsItem(*option);
styleOption.state &= ~QStyle::State_Selected;
QGraphicsItemGroup::paint(painter, &styleOption, widget);
}
QVariant UBGraphicsStrokesGroup::itemChange(GraphicsItemChange change, const QVariant &value)
{
QVariant newValue = mDelegate->itemChange(change, value);
return QGraphicsItemGroup::itemChange(change, newValue);
}

@ -0,0 +1,28 @@
#ifndef UBGRAPHICSSTROKESGROUP_H
#define UBGRAPHICSSTROKESGROUP_H
#include <QGraphicsItemGroup>
#include <QGraphicsSceneMouseEvent>
#include "core/UB.h"
#include "UBItem.h"
class UBGraphicsStrokesGroup : public QObject, public QGraphicsItemGroup, public UBItem, public UBGraphicsItem
{
Q_OBJECT
public:
UBGraphicsStrokesGroup(QGraphicsItem* parent = 0);
~UBGraphicsStrokesGroup();
virtual UBItem* deepCopy() const;
virtual void remove();
virtual UBGraphicsItemDelegate* Delegate() const {return mDelegate;}
protected:
virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
};
#endif // UBGRAPHICSSTROKESGROUP_H

@ -23,7 +23,8 @@ HEADERS += src/domain/UBGraphicsScene.h \
src/domain/UBGraphicsAudioItem.h \ src/domain/UBGraphicsAudioItem.h \
src/domain/UBGraphicsAudioItemDelegate.h \ src/domain/UBGraphicsAudioItemDelegate.h \
src/domain/UBAbstractUndoCommand.h\ src/domain/UBAbstractUndoCommand.h\
src/domain/UBAngleWidget.h src/domain/UBAngleWidget.h \
src/domain/UBGraphicsStrokesGroup.h
HEADERS += src/domain/UBGraphicsItemDelegate.h \ HEADERS += src/domain/UBGraphicsItemDelegate.h \
src/domain/UBGraphicsVideoItemDelegate.h \ src/domain/UBGraphicsVideoItemDelegate.h \
@ -56,7 +57,8 @@ SOURCES += src/domain/UBGraphicsScene.cpp \
src/domain/UBGraphicsAudioItem.cpp \ src/domain/UBGraphicsAudioItem.cpp \
src/domain/UBGraphicsAudioItemDelegate.cpp \ src/domain/UBGraphicsAudioItemDelegate.cpp \
src/domain/UBAbstractUndoCommand.cpp \ src/domain/UBAbstractUndoCommand.cpp \
src/domain/UBAngleWidget.cpp src/domain/UBAngleWidget.cpp \
src/domain/UBGraphicsStrokesGroup.cpp
SOURCES += src/domain/UBGraphicsItemDelegate.cpp \ SOURCES += src/domain/UBGraphicsItemDelegate.cpp \
src/domain/UBGraphicsVideoItemDelegate.cpp \ src/domain/UBGraphicsVideoItemDelegate.cpp \

@ -87,3 +87,9 @@ bool UBCoreGraphicsScene::deleteItem(QGraphicsItem* item)
return false; return false;
} }
void UBCoreGraphicsScene::removeItemFromDeletion(QGraphicsItem *item)
{
if(NULL != item){
mItemsToDelete.remove(item);
}
}

@ -30,6 +30,7 @@ class UBCoreGraphicsScene : public QGraphicsScene
virtual bool deleteItem(QGraphicsItem* item); virtual bool deleteItem(QGraphicsItem* item);
void removeItemFromDeletion(QGraphicsItem* item);
private: private:
QSet<QGraphicsItem*> mItemsToDelete; QSet<QGraphicsItem*> mItemsToDelete;

@ -103,6 +103,7 @@ void UBGraphicsRuler::paint(QPainter *painter, const QStyleOptionGraphicsItem *s
painter->setPen(drawColor()); painter->setPen(drawColor());
painter->setRenderHint(QPainter::Antialiasing, true);
painter->drawRoundedRect(rect(), sRoundingRadius, sRoundingRadius); painter->drawRoundedRect(rect(), sRoundingRadius, sRoundingRadius);
fillBackground(painter); fillBackground(painter);
paintGraduations(painter); paintGraduations(painter);
@ -452,8 +453,8 @@ void UBGraphicsRuler::StartLine(const QPointF& scenePos, qreal width)
itemPos.setY(y); itemPos.setY(y);
itemPos = mapToScene(itemPos); itemPos = mapToScene(itemPos);
scene()->moveTo(itemPos); scene()->moveTo(itemPos);
scene()->drawLineTo(itemPos, width, true); scene()->drawLineTo(itemPos, width, true);
} }
void UBGraphicsRuler::DrawLine(const QPointF& scenePos, qreal width) void UBGraphicsRuler::DrawLine(const QPointF& scenePos, qreal width)
@ -478,9 +479,11 @@ void UBGraphicsRuler::DrawLine(const QPointF& scenePos, qreal width)
itemPos = mapToScene(itemPos); itemPos = mapToScene(itemPos);
// We have to use "pointed" line for marker tool // We have to use "pointed" line for marker tool
scene()->drawLineTo(itemPos, width, scene()->drawLineTo(itemPos, width, UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Marker);
UBDrawingController::drawingController()->stylusTool() != UBStylusTool::Marker);
} }
void UBGraphicsRuler::EndLine() void UBGraphicsRuler::EndLine()
{} {
// We never come to this place
scene()->inputDeviceRelease();
}

Loading…
Cancel
Save