Triangle graphics tool

src/adaptors/UBSvgSubsetAdaptor.cpp

@@ -26,6 +26,7 @@
 #include "tools/UBGraphicsCompass.h"
 #include "tools/UBGraphicsProtractor.h"
 #include "tools/UBGraphicsCurtainItem.h"
+#include "tools/UBGraphicsTriangle.h"
 
 #include "document/UBDocumentProxy.h"
 
@@ -644,6 +645,16 @@ UBGraphicsScene* UBSvgSubsetAdaptor::UBSvgSubsetReader::loadScene()
                     scene->addItem(protractor);
                     scene->registerTool(protractor);
                 }
+            }
+			else if (mXmlReader.name() == "protractor")
+            {
+                UBGraphicsTriangle *triangle = triangleFromSvg();
+
+                if (triangle)
+                {
+                    scene->addItem(triangle);
+                    scene->registerTool(triangle);
+                }
             }
             else if (mXmlReader.name() == "foreignObject")
             {
@@ -2556,7 +2567,46 @@ UBGraphicsProtractor* UBSvgSubsetAdaptor::UBSvgSubsetReader::protractorFromSvg()
     return protractor;
 }
 
+UBGraphicsTriangle* UBSvgSubsetAdaptor::UBSvgSubsetReader::triangleFromSvg()
+{
+    UBGraphicsTriangle* triangle = new UBGraphicsTriangle();
+
+    triangle->setZValue(UBGraphicsScene::toolLayerStart + UBGraphicsScene::toolOffsetTriangle);
+    triangle->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Tool));
+
+    graphicsItemFromSvg(triangle);
+
+    //QStringRef angle = mXmlReader.attributes().value(mNamespaceUri, "angle");
+    //if (!angle.isNull())
+    //{
+    //    protractor->setAngle(angle.toString().toFloat());
+    //}
+
+    //QStringRef markerAngle = mXmlReader.attributes().value(mNamespaceUri, "marker-angle");
+    //if (!markerAngle.isNull())
+    //{
+    //    protractor->setMarkerAngle(markerAngle.toString().toFloat());
+    //}
+
+    QStringRef svgX = mXmlReader.attributes().value("x");
+    QStringRef svgY = mXmlReader.attributes().value("y");
+    QStringRef svgWidth = mXmlReader.attributes().value("width");
+    QStringRef svgHeight = mXmlReader.attributes().value("height");
+
+	UBGraphicsTriangle::UBGraphicsTriangleOrientation orientation = 
+		UBGraphicsTriangle::orientationFromStr((mXmlReader.attributes().value("orientation")));
 
+    if (!svgX.isNull() && !svgY.isNull() && !svgWidth.isNull() && !svgHeight.isNull())
+    {
+        triangle->setRect(svgX.toString().toFloat(), svgY.toString().toFloat()
+                            , svgWidth.toString().toFloat(), svgHeight.toString().toFloat(),
+							orientation);
+    }
+
+    triangle->setVisible(true);
+
+    return triangle;
+}
 
 void UBSvgSubsetAdaptor::convertPDFObjectsToImages(UBDocumentProxy* proxy)
 {

src/adaptors/UBSvgSubsetAdaptor.h

@@ -31,6 +31,7 @@ class UBGraphicsScene;
 class UBDocumentProxy;
 class UBGraphicsStroke;
 class UBPersistenceManager;
+class UBGraphicsTriangle;
 
 class UBSvgSubsetAdaptor
 {
@@ -118,6 +119,8 @@ class UBSvgSubsetAdaptor
 
                 UBGraphicsProtractor* protractorFromSvg();
 
+				UBGraphicsTriangle* triangleFromSvg();
+
                 void graphicsItemFromSvg(QGraphicsItem* gItem);
 
                 QXmlStreamReader mXmlReader;

src/core/main.cpp

@@ -54,9 +54,14 @@ void ub_message_output(QtMsgType type, const char *msg) {
 
 int main(int argc, char *argv[]) 
 {
+
+// Uncomment next section to have memory leaks information 
+// tracing in VC++ debug mode under Windows
+/*
 #if defined(_MSC_VER) && defined(_DEBUG)
     _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
 #endif
+*/
 
 	Q_INIT_RESOURCE(sankore);
 

src/domain/UBGraphicsScene.cpp

@@ -56,6 +56,7 @@ qreal UBGraphicsScene::toolLayerStart = 10000000.0;
 
 qreal UBGraphicsScene::toolOffsetRuler = 100;
 qreal UBGraphicsScene::toolOffsetProtractor = 100;
+qreal UBGraphicsScene::toolOffsetTriangle = 100;
 qreal UBGraphicsScene::toolOffsetCompass = 100;
 qreal UBGraphicsScene::toolOffsetEraser = 200;
 
@@ -125,7 +126,6 @@ UBGraphicsScene::UBGraphicsScene(UBDocumentProxy* parent)
 
 UBGraphicsScene::~UBGraphicsScene()
 {
-	int a = 13;
     // NOOP
 }
 
@@ -1411,9 +1411,9 @@ void UBGraphicsScene::addProtractor(QPointF center)
 
 void UBGraphicsScene::addTriangle(QPointF center)
 {
-    // Protractor
-/*
-    UBGraphicsTriangle* protractor = new UBGraphicsTriangle(); // mem : owned and destroyed by the scene
+    // Triangle
+
+    UBGraphicsTriangle* triangle = new UBGraphicsTriangle(); // mem : owned and destroyed by the scene
     mTools << triangle;
 
     triangle->setZValue(toolLayerStart + toolOffsetProtractor);
@@ -1425,7 +1425,7 @@ void UBGraphicsScene::addTriangle(QPointF center)
     triangle->moveBy(center.x() - itemSceneCenter.x(), center.y() - itemSceneCenter.y());
 
     triangle->setVisible(true);
-    setModified(true);*/
+    setModified(true);
 }
 
 

src/domain/UBGraphicsScene.h

@@ -235,6 +235,7 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
         static qreal toolOffsetProtractor;
         static qreal toolOffsetCompass;
         static qreal toolOffsetCurtain;
+		static qreal toolOffsetTriangle;
 
         QSet<QGraphicsItem*> tools(){ return mTools;}
 

src/frameworks/UBCoreGraphicsScene.cpp

@@ -12,7 +12,6 @@
 UBCoreGraphicsScene::UBCoreGraphicsScene(QObject * parent)
     : QGraphicsScene ( parent  )
 {
-	int a = 13;
     //NOOP
 }
 

src/tools/UBAbstractDrawRuler.cpp

 
 #include "UBAbstractDrawRuler.h"
+#include <QtSvg>
+#include "core/UB.h"
+#include "gui/UBResources.h"
+#include "domain/UBGraphicsScene.h"
+#include "board/UBDrawingController.h"
+#include "core/UBApplication.h"
+#include "board/UBBoardController.h"
 
 #include "core/memcheck.h"
 
+
+const QColor UBAbstractDrawRuler::sLightBackgroundMiddleFillColor = QColor(0x72, 0x72, 0x72, sFillTransparency);
+const QColor UBAbstractDrawRuler::sLightBackgroundEdgeFillColor = QColor(0xc3, 0xc3, 0xc3, sFillTransparency);
+const QColor UBAbstractDrawRuler::sLightBackgroundDrawColor = QColor(0x33, 0x33, 0x33, sDrawTransparency);
+const QColor UBAbstractDrawRuler::sDarkBackgroundMiddleFillColor = QColor(0xb5, 0xb5, 0xb5, sFillTransparency);
+const QColor UBAbstractDrawRuler::sDarkBackgroundEdgeFillColor = QColor(0xdd, 0xdd, 0xdd, sFillTransparency);
+const QColor UBAbstractDrawRuler::sDarkBackgroundDrawColor = QColor(0xff, 0xff, 0xff, sDrawTransparency);
+
 UBAbstractDrawRuler::UBAbstractDrawRuler()
+	: mResizing(false)
+    , mRotating(false)
+    , mShowButtons(false)
+    , mAntiScaleRatio(1.0)
 {}
 
+void UBAbstractDrawRuler::create(QGraphicsItem& item)
+{
+	item.setFlag(QGraphicsItem::ItemIsMovable, true);
+    item.setFlag(QGraphicsItem::ItemIsSelectable, true);
+    item.setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
+
+    item.setAcceptsHoverEvents(true);
+
+    mCloseSvgItem = new QGraphicsSvgItem(":/images/closeTool.svg", &item);
+    mCloseSvgItem->setVisible(false);
+    mCloseSvgItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Control));
+
+    mRotateSvgItem = new QGraphicsSvgItem(":/images/rotateTool.svg", &item);
+    mRotateSvgItem->setVisible(false);
+    mRotateSvgItem->setData(UBGraphicsItemData::ItemLayerType, QVariant(UBItemLayerType::Control));
+
+	updateResizeCursor(item);
+}
+
 
 UBAbstractDrawRuler::~UBAbstractDrawRuler()
+{
+}
+
+void UBAbstractDrawRuler::updateResizeCursor(QGraphicsItem &item)
+{
+    QPixmap pix(":/images/cursors/resize.png");
+    QTransform itemTransform = item.sceneTransform();
+    QRectF itemRect = item.boundingRect();
+    QPointF topLeft = itemTransform.map(itemRect.topLeft());
+    QPointF topRight = itemTransform.map(itemRect.topRight());
+    QLineF topLine(topLeft, topRight);
+    qreal angle = topLine.angle();
+    QTransform tr;
+    tr.rotate(- angle);
+    QCursor resizeCursor  = QCursor(pix.transformed(tr, Qt::SmoothTransformation), pix.width() / 2,  pix.height() / 2);
+    mResizeCursor = resizeCursor;
+}
+
+
+QCursor UBAbstractDrawRuler::moveCursor() const
+{
+    return Qt::SizeAllCursor;
+}
+
+QCursor UBAbstractDrawRuler::resizeCursor() const
+{
+    return mResizeCursor;
+}
+
+QCursor UBAbstractDrawRuler::rotateCursor() const
+{
+    return UBResources::resources()->rotateCursor;
+}
+
+QCursor UBAbstractDrawRuler::closeCursor() const
+{
+    return Qt::ArrowCursor;
+}
+
+QCursor UBAbstractDrawRuler::drawRulerLineCursor() const
+{
+	return UBResources::resources()->drawLineRulerCursor;
+}
+
+QColor UBAbstractDrawRuler::drawColor() const
+{
+    return scene()->isDarkBackground() ? sDarkBackgroundDrawColor : sLightBackgroundDrawColor;
+}
+
+QColor UBAbstractDrawRuler::middleFillColor() const
+{
+    return scene()->isDarkBackground() ? sDarkBackgroundMiddleFillColor : sLightBackgroundMiddleFillColor;
+}
+
+QColor UBAbstractDrawRuler::edgeFillColor() const
+{
+    return scene()->isDarkBackground() ? sDarkBackgroundEdgeFillColor : sLightBackgroundEdgeFillColor;
+}
+
+QFont UBAbstractDrawRuler::font() const
+{
+    QFont font("Arial");
+    font.setPixelSize(16);
+    return font;
+}
+
+void UBAbstractDrawRuler::StartLine(const QPointF& position, qreal width)
+{}
+void UBAbstractDrawRuler::DrawLine(const QPointF& position, qreal width)
+{}
+void UBAbstractDrawRuler::EndLine()
 {}
+
+
+void UBAbstractDrawRuler::paint()
+{
+    mAntiScaleRatio = 1 / (UBApplication::boardController->systemScaleFactor() * UBApplication::boardController->currentZoom());
+    QTransform antiScaleTransform;
+    antiScaleTransform.scale(mAntiScaleRatio, mAntiScaleRatio);
+
+    mCloseSvgItem->setTransform(antiScaleTransform);
+    mCloseSvgItem->setPos(closeButtonRect().topLeft());
+
+    mRotateSvgItem->setTransform(antiScaleTransform);
+    mRotateSvgItem->setPos(rotateButtonRect().topLeft());
+
+}
+
+

src/tools/UBAbstractDrawRuler.h

@@ -3,18 +3,72 @@
 
 #include <QtGui>
 class UBGraphicsScene;
+class QGraphicsSvgItem;
 
 class UBAbstractDrawRuler : public QObject
 {
-    Q_OBJECT;
+	Q_OBJECT
 
     public:
 		UBAbstractDrawRuler();
 		~UBAbstractDrawRuler();
 
-		virtual void StartLine(const QPointF& position, qreal width) = 0;
-		virtual void DrawLine(const QPointF& position, qreal width) = 0;
-		virtual void EndLine() = 0;
+		void create(QGraphicsItem& item);
+
+		virtual void StartLine(const QPointF& position, qreal width);
+		virtual void DrawLine(const QPointF& position, qreal width);
+		virtual void EndLine();
+	protected:
+
+		void paint();
+
+		virtual UBGraphicsScene* scene() const = 0;
+
+		virtual void rotateAroundTopLeftOrigin(qreal angle) = 0;
+
+		virtual QPointF	topLeftOrigin() const = 0;
+        virtual QRectF	resizeButtonRect() const = 0;
+        virtual QRectF	closeButtonRect() const = 0;
+        virtual QRectF	rotateButtonRect() const = 0;
+
+		void updateResizeCursor(QGraphicsItem &item);
+
+		bool mResizing;
+        bool mRotating;
+        bool mShowButtons;
+        QGraphicsSvgItem* mCloseSvgItem;
+        QGraphicsSvgItem* mRotateSvgItem;
+        QCursor mResizeCursor;
+        qreal mAntiScaleRatio;
+
+		QPointF startDrawPosition;
+
+		QCursor	moveCursor() const;
+        QCursor	resizeCursor() const;
+        QCursor	rotateCursor() const;
+        QCursor	closeCursor() const;
+		QCursor	drawRulerLineCursor() const;
+
+		QColor	drawColor() const;
+        QColor	middleFillColor() const;
+        QColor  edgeFillColor() const;
+        QFont   font() const;
+
+		static const QColor	sLightBackgroundEdgeFillColor;
+        static const QColor sLightBackgroundMiddleFillColor;
+        static const QColor	sLightBackgroundDrawColor;
+        static const QColor	sDarkBackgroundEdgeFillColor;
+        static const QColor	sDarkBackgroundMiddleFillColor;
+        static const QColor	sDarkBackgroundDrawColor;
+
+		static const int	sLeftEdgeMargin = 10;
+        static const int	sMinLength = 150;
+        static const int	sDegreeToQtAngleUnit = 16;
+        static const int	sRotationRadius = 15;
+        static const int	sPixelsPerMillimeter = 5;
+        static const int	sFillTransparency = 127;
+        static const int	sDrawTransparency = 192;
+        static const int	sRoundingRadius = sLeftEdgeMargin / 2;
 
 };
 

src/tools/UBGraphicsProtractor.h

@@ -13,12 +13,12 @@
 #include <QtSvg>
 
 #include "core/UB.h"
-
+#include "tools/UBAbstractDrawRuler.h"
 #include "domain/UBItem.h"
 
 class UBGraphicsScene;
 
-class UBGraphicsProtractor : public QObject, public QGraphicsEllipseItem, public UBItem
+class UBGraphicsProtractor : public UBAbstractDrawRuler, public QGraphicsEllipseItem, public UBItem
 {
 
     Q_OBJECT;
@@ -66,16 +66,15 @@ class UBGraphicsProtractor : public QObject, public QGraphicsEllipseItem, public
                 Tool      toolFromPos (QPointF pos);
         qreal       antiScale () const;
         UBGraphicsScene*            scene() const;
-        QColor                  drawColor() const;
         QBrush                  fillBrush() const;
 
         QSizeF buttonSizeReference () const{return QSizeF(radius() / 10, mCloseSvgItem->boundingRect().height() * radius()/(10 * mCloseSvgItem->boundingRect().width()));}
         QSizeF markerSizeReference () const{return QSizeF(radius() / 10, mMarkerSvgItem->boundingRect().height() * radius()/(10 * mMarkerSvgItem->boundingRect().width()));}
-        QRectF	 resetButtonBounds () const;
-        QRectF	 closeButtonBounds () const;
-        QRectF	resizeButtonBounds () const;
-        QRectF	rotateButtonBounds () const{return QRectF(buttonSizeReference().width() * 5.5, -buttonSizeReference().width() * 5, buttonSizeReference().width(), buttonSizeReference().width());}
-        QRectF	markerButtonBounds () const{return QRectF(radius() + 3, -markerSizeReference().height() / 2 , markerSizeReference().width(), markerSizeReference().height());}
+        QRectF	resetButtonRect () const;
+        QRectF	closeButtonRect () const;
+        QRectF	resizeButtonRect () const;
+        QRectF	rotateButtonRect () const{return QRectF(buttonSizeReference().width() * 5.5, -buttonSizeReference().width() * 5, buttonSizeReference().width(), buttonSizeReference().width());}
+        QRectF	markerButtonRect () const{return QRectF(radius() + 3, -markerSizeReference().height() / 2 , markerSizeReference().width(), markerSizeReference().height());}
                 inline qreal               radius () const{return rect().height() / 2 - 20;}
 
         // Members
@@ -87,21 +86,14 @@ class UBGraphicsProtractor : public QObject, public QGraphicsEllipseItem, public
         qreal   mStartAngle;
         qreal   mScaleFactor;
 
-        QGraphicsSvgItem* mCloseSvgItem;
         QGraphicsSvgItem* mResetSvgItem;
         QGraphicsSvgItem* mResizeSvgItem;
-        QGraphicsSvgItem* mRotateSvgItem;
         QGraphicsSvgItem* mMarkerSvgItem;
 
-        static const int                 sFillTransparency;
-        static const int                 sDrawTransparency;
-        static const QRectF                   sDefaultRect;
-        static const QColor                     sFillColor;
-        static const QColor               sFillColorCenter;
-        static const QColor                     sDrawColor;
-        static const QColor       sDarkBackgroundFillColor;
-        static const QColor sDarkBackgroundFillColorCenter;
-        static const QColor       sDarkBackgroundDrawColor;
+		static const QRectF sDefaultRect;
+
+		virtual void rotateAroundTopLeftOrigin(qreal angle);
+		virtual QPointF	topLeftOrigin() const;
 };
 
 #endif /* UBGRAPHICSPROTRACTOR_H_ */

src/tools/UBGraphicsRuler.h

@@ -44,70 +44,37 @@ class UBGraphicsRuler : public UBAbstractDrawRuler, public QGraphicsRectItem, pu
         void hidden();
 
     protected:
+		
         virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *styleOption, QWidget *widget);
         virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value);
 
         // Events
-        virtual void   mousePressEvent(QGraphicsSceneMouseEvent *event);
+        virtual void	mousePressEvent(QGraphicsSceneMouseEvent *event);
         virtual void    mouseMoveEvent(QGraphicsSceneMouseEvent *event);
-        virtual void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
-        virtual void   hoverEnterEvent(QGraphicsSceneHoverEvent *event);
-        virtual void   hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
-        virtual void    hoverMoveEvent(QGraphicsSceneHoverEvent *event);
+        virtual void	mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+        virtual void	hoverEnterEvent(QGraphicsSceneHoverEvent *event);
+        virtual void	hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
+		virtual void    hoverMoveEvent(QGraphicsSceneHoverEvent *event);
 
     private:
         // Helpers
-        void               fillBackground(QPainter *painter);
-        void             paintGraduations(QPainter *painter);
-        void          paintRotationCenter(QPainter *painter);
-        void    rotateAroundTopLeftOrigin(qreal angle);
-        void           updateResizeCursor();
-
-        QPointF             topLeftOrigin() const;
-        QCursor                moveCursor() const;
-        QCursor              resizeCursor() const;
-        QCursor              rotateCursor() const;
-        QCursor               closeCursor() const;
-		QCursor				drawRulerLineCursor() const;
-        QRectF           resizeButtonRect() const;
-        QRectF            closeButtonRect() const;
-        QRectF           rotateButtonRect() const;
-        UBGraphicsScene*            scene() const;
-        QColor                  drawColor() const;
-        QColor            middleFillColor() const;
-        QColor              edgeFillColor() const;
-        QFont                        font() const;
+        void    fillBackground(QPainter *painter);
+        void    paintGraduations(QPainter *painter);
+        void    paintRotationCenter(QPainter *painter);
+        virtual void    rotateAroundTopLeftOrigin(qreal angle);
 
-		int drawLineDirection;
+		QGraphicsSvgItem* mResizeSvgItem;
 
-        // Members
-        bool mResizing;
-        bool mRotating;
-        bool mShowButtons;
-        QGraphicsSvgItem* mCloseSvgItem;
-        QGraphicsSvgItem* mRotateSvgItem;
-        QGraphicsSvgItem* mResizeSvgItem;
-        QCursor mResizeCursor;
-        qreal mAntiScaleRatio;
+        virtual QPointF             topLeftOrigin() const;
+        virtual QRectF           resizeButtonRect() const;
+        virtual QRectF            closeButtonRect() const;
+        virtual QRectF           rotateButtonRect() const;
+        virtual UBGraphicsScene*            scene() const;
 
-		QPointF startDrawPosition;
+		int drawLineDirection;
 
         // Constants
         static const QRect               sDefaultRect;
-        static const int              sLeftEdgeMargin = 10;
-        static const int                   sMinLength = 150;
-        static const int         sDegreeToQtAngleUnit = 16;
-        static const int              sRotationRadius = 15;
-        static const int         sPixelsPerMillimeter = 5;
-        static const int            sFillTransparency = 127;
-        static const int            sDrawTransparency = 192;
-        static const int              sRoundingRadius = sLeftEdgeMargin / 2;
-        static const QColor   sLightBackgroundEdgeFillColor;
-        static const QColor sLightBackgroundMiddleFillColor;
-        static const QColor       sLightBackgroundDrawColor;
-        static const QColor    sDarkBackgroundEdgeFillColor;
-        static const QColor  sDarkBackgroundMiddleFillColor;
-        static const QColor        sDarkBackgroundDrawColor;
 };
 
 #endif /* UBGRAPHICSRULER_H_ */

src/tools/UBGraphicsTriangle.cpp

 
+#include <QGraphicsPolygonItem>
+#include <QPolygonF>
+
 #include "tools/UBGraphicsTriangle.h"
+#include "core/UBApplication.h"
+#include "board/UBBoardController.h"
+#include "board/UBDrawingController.h"
+#include "domain/UBGraphicsScene.h"
+
 #include "core/memcheck.h"
 
+const QRect UBGraphicsTriangle::sDefaultRect =  QRect(0, 0, 800, 400);
+const UBGraphicsTriangle::UBGraphicsTriangleOrientation UBGraphicsTriangle::sDefaultOrientation = 
+UBGraphicsTriangle::BottomLeft;
+
 UBGraphicsTriangle::UBGraphicsTriangle()
+	:QGraphicsPolygonItem()
 {
+	setRect(sDefaultRect, sDefaultOrientation);
+
+	create(*this);
+
+    //updateResizeCursor();
 }
 
 UBGraphicsTriangle::~UBGraphicsTriangle()
-{}
\ No newline at end of file
+{
+}
+
+UBItem* UBGraphicsTriangle::deepCopy(void) const
+{
+	UBGraphicsTriangle* copy = new UBGraphicsTriangle();
+
+    copy->setPos(this->pos());
+	copy->setPolygon(this->polygon());
+    copy->setZValue(this->zValue());
+    copy->setTransform(this->transform());
+
+    // TODO UB 4.7 ... complete all members ?
+
+    return copy;
+
+}
+
+void UBGraphicsTriangle::setRect(qreal x, qreal y, qreal w, qreal h, UBGraphicsTriangleOrientation orientation)
+{
+	mRect.setCoords(x, y, x+w, y+h);
+	mOrientation = orientation;
+
+	QPolygonF polygon;
+	polygon << QPointF(x, y) << QPoint(x, y + h) << QPoint(x+w, y + h) << QPoint(x, y);
+
+	QTransform t;
+
+	switch(orientation)
+	{
+	case BottomLeft:
+		t.setMatrix(1, 0, 0, 0, 1, 0, 0, 0, 1);
+		break;
+	case BottomRight:
+		t.setMatrix(-1, 0, 0, 0, 1, 0, x, 0, 1);
+		break;
+	case TopLeft:
+		t.setMatrix(1, 0, 0, 0, -1, 0, 0, y, 1);
+		break;
+	case TopRight:
+		t.setMatrix(-1, 0, 0, 0, -1, 0, x, y, 1);
+		break;
+	}
+
+
+	/*
+	switch(orientation)
+	{
+	case BottomLeft:
+		polygon << QPointF(x, y) << QPoint(x, y + h) << QPoint(x+w, y + h) << QPoint(x, y);
+		break;
+	case BottomRight:
+		polygon << QPointF(x, y + h) << QPoint(x + w, y + y) << QPoint(x + w, y) << QPoint(x, y + h);
+		break;
+	case TopLeft:
+		polygon << QPointF(x, y) << QPoint(x, y + h) << QPoint(x + w, y) << QPoint(x, y);
+		break;
+	case TopRight:
+		polygon << QPointF(x, y) << QPoint(x + w, y + h) << QPoint(x+w, y) << QPoint(x, y );
+		break;
+	}
+	*/
+	setPolygon(polygon);
+	setTransform(t);
+}
+
+UBGraphicsScene* UBGraphicsTriangle::scene() const
+{
+	return static_cast<UBGraphicsScene*>(QGraphicsPolygonItem::scene());
+}
+
+void UBGraphicsTriangle::paint(QPainter *painter, const QStyleOptionGraphicsItem *styleOption, QWidget *widget)
+{
+	QPointF A1(mRect.x(), mRect.y());
+	QPointF B1(mRect.x(), mRect.y() + mRect.height());
+	QPointF C1(mRect.x() + mRect.width(), mRect.y() + mRect.height());
+
+	qreal d = 70;
+	qreal C = sqrt(mRect.width() * mRect.width() + mRect.height() * mRect.height());
+	qreal L = (C * d + mRect.width() * d)/ mRect.height();
+	qreal K = (C * d + mRect.height() * d)/ mRect.width();
+
+	qreal W1 = mRect.height() * d / C;
+	qreal H1 = mRect.width() * d / C;
+
+	QPointF A2(mRect.x() + d, mRect.y() + K);
+	QPointF B2(mRect.x() + d, mRect.y() + mRect.height() - d);
+	QPointF C2(mRect.x() + mRect.width() - L, mRect.y() + mRect.height() - d);
+
+	QPoint CC(mRect.x() + mRect.width() - L + W1,
+		mRect.y() + mRect.height() - d - H1);
+
+	painter->setPen(Qt::NoPen);
+
+	QPolygonF polygon;
+
+	QLinearGradient gradient1(QPointF(A1.x(), 0), QPointF(A2.x(), 0));
+	gradient1.setColorAt(0, edgeFillColor());
+	gradient1.setColorAt(1, middleFillColor());
+	painter->setBrush(gradient1);
+	polygon << A1 << A2 << B2 << B1;
+	painter->drawPolygon(polygon);
+	polygon.clear();
+
+	QLinearGradient gradient2(QPointF(0, B1.y()), QPointF(0, B2.y()));
+	gradient2.setColorAt(0, edgeFillColor());
+	gradient2.setColorAt(1, middleFillColor());
+	painter->setBrush(gradient2);
+	polygon << B1 << B2 << C2 << C1;
+	painter->drawPolygon(polygon);
+	polygon.clear();
+
+	QLinearGradient gradient3(CC, C2);
+	gradient3.setColorAt(0, edgeFillColor());
+	gradient3.setColorAt(1, middleFillColor());
+	painter->setBrush(gradient3);
+	polygon << C1 << C2 << A2 << A1;
+	painter->drawPolygon(polygon);
+	polygon.clear();
+
+
+	painter->setBrush(Qt::NoBrush);
+	painter->setPen(drawColor());
+
+	polygon << A1 << B1 << C1;
+	painter->drawPolygon(polygon);
+	polygon.clear();
+
+	polygon << A2 << B2 << C2;
+	painter->drawPolygon(polygon);
+
+	paintGraduations(painter);
+}
+
+void UBGraphicsTriangle::paintGraduations(QPainter *painter)
+{
+    const int     centimeterGraduationHeight = 15;
+    const int halfCentimeterGraduationHeight = 10;
+    const int     millimeterGraduationHeight = 5;
+    const int       millimetersPerCentimeter = 10;
+    const int   millimetersPerHalfCentimeter = 5;
+
+    painter->save();
+    painter->setFont(font());
+    QFontMetricsF fontMetrics(painter->font());
+    for (int millimeters = 0; millimeters < (rect().width() - sLeftEdgeMargin - sRoundingRadius) / sPixelsPerMillimeter; millimeters++)
+    {
+        int graduationX = topLeftOrigin().x() + sPixelsPerMillimeter * millimeters;
+        int graduationHeight = (0 == millimeters % millimetersPerCentimeter) ?
+            centimeterGraduationHeight :
+            ((0 == millimeters % millimetersPerHalfCentimeter) ?
+                halfCentimeterGraduationHeight : millimeterGraduationHeight);
+
+		// Check that grad. line inside triangle
+		qreal lineY = rect().bottom() - rect().height()/rect().width()*(rect().width() - graduationX);
+		if (lineY >= topLeftOrigin().y() + rect().height() - graduationHeight)
+			break;
+        
+        painter->drawLine(QLine(graduationX, topLeftOrigin().y() + rect().height(), graduationX, topLeftOrigin().y() + rect().height() - graduationHeight));
+        if (0 == millimeters % millimetersPerCentimeter)
+        {
+            QString text = QString("%1").arg((int)(millimeters / millimetersPerCentimeter));
+			int textXRight = graduationX + fontMetrics.width(text) / 2;
+			qreal textWidth = fontMetrics.width(text);
+            qreal textHeight = fontMetrics.tightBoundingRect(text).height() + 5;
+			int textY = rect().bottom() - 5 - centimeterGraduationHeight - textHeight;
+
+			lineY = rect().bottom() - rect().height()/rect().width()*(rect().width() - textXRight);
+
+			if (textXRight < rect().right()
+				&& lineY < textY)
+            {
+                painter->drawText(
+                    QRectF(graduationX - textWidth / 2, 
+					textY, textWidth, textHeight),
+                    Qt::AlignVCenter, text);
+            }
+        }
+    }
+    painter->restore();
+}
+
+
+void UBGraphicsTriangle::rotateAroundTopLeftOrigin(qreal angle)
+{}
+
+QPointF	UBGraphicsTriangle::topLeftOrigin() const
+{
+	return QPointF(mRect.x() + sLeftEdgeMargin , mRect.y());
+}
+
+QRectF	UBGraphicsTriangle::resizeButtonRect() const
+{
+	return QRectF(0,0,0,0);
+}
+
+QRectF	UBGraphicsTriangle::closeButtonRect() const
+{
+	return QRectF(0,0,0,0);
+}
+
+QRectF	UBGraphicsTriangle::rotateButtonRect() const
+{
+	return QRectF(0,0,0,0);
+}

src/tools/UBGraphicsTriangle.h

@@ -15,17 +15,75 @@
 
 #include "core/UB.h"
 #include "domain/UBItem.h"
+#include "tools/UBAbstractDrawRuler.h"
 
 
 class UBGraphicsScene;
+class UBItem;
 
-class UBGraphicsTriangle : public QObject, public QGraphicsPolygonItem, public UBItem
+class UBGraphicsTriangle : public UBAbstractDrawRuler, public QGraphicsPolygonItem, public UBItem
 {
     Q_OBJECT;
 
     public:
         UBGraphicsTriangle();
         virtual ~UBGraphicsTriangle();
+
+		enum { Type = UBGraphicsItemType::TriangleItemType };
+
+        virtual int type() const
+        {
+            return Type;
+        }
+
+
+		virtual UBItem* deepCopy(void) const;
+
+		enum UBGraphicsTriangleOrientation
+		{
+				BottomLeft = 0,
+				BottomRight,
+				TopLeft,
+				TopRight
+		};
+
+		static UBGraphicsTriangleOrientation orientationFromStr(QStringRef& str)
+		{
+			if (str == "BottomLeft") return BottomLeft;
+			if (str == "BottomRight") return BottomRight;
+			if (str == "TopLeft") return TopLeft;
+			if (str == "TopRight") return TopRight;
+			return sDefaultOrientation;
+		}
+		void setRect(const QRectF &rect, UBGraphicsTriangleOrientation orientation)
+		{
+			setRect(rect.x(), rect.y(), rect.width(), rect.height(), orientation);
+		}
+		void setRect(qreal x, qreal y, qreal w, qreal h, UBGraphicsTriangleOrientation orientation);
+		QRectF rect() const {return mRect;}
+
+		UBGraphicsScene* scene() const;
+	protected:
+		virtual void paint (QPainter *painter, const QStyleOptionGraphicsItem *styleOption, QWidget *widget);
+
+		virtual void rotateAroundTopLeftOrigin(qreal angle);
+
+		virtual QPointF	topLeftOrigin() const;
+        virtual QRectF	resizeButtonRect() const;
+        virtual QRectF	closeButtonRect() const;
+        virtual QRectF	rotateButtonRect() const;
+
+
+	private:
+
+		static const QRect sDefaultRect;
+		static const UBGraphicsTriangleOrientation sDefaultOrientation;
+
+		void paintGraduations(QPainter *painter);
+
+
+		QRectF mRect;
+		UBGraphicsTriangleOrientation mOrientation;
 };
 
 #endif /* UBGRAPHICSTRIANGLE_H_ */