Backup of the strokes as object

src/board/UBBoardView.cpp

@@ -50,6 +50,7 @@
 #include "domain/UBGraphicsVideoItem.h"
 #include "domain/UBGraphicsAudioItem.h"
 #include "domain/UBGraphicsSvgItem.h"
+#include "domain/UBGraphicsStrokesGroup.h"
 
 #include "document/UBDocumentProxy.h"
 
@@ -563,7 +564,8 @@ UBBoardView::mouseMoveEvent (QMouseEvent *event)
                       || item->type() == UBGraphicsPixmapItem::Type
                       || item->type() == UBGraphicsVideoItem::Type
                       || item->type() == UBGraphicsAudioItem::Type
-                      || item->type() == UBGraphicsSvgItem::Type) {
+                      || item->type() == UBGraphicsSvgItem::Type
+                      || item->type() == UBGraphicsStrokesGroup::Type) {
 
                   if (!mJustSelectedItems.contains(item)) {
                       item->setSelected(true);

src/board/UBDrawingController.cpp

@@ -45,7 +45,7 @@ UBDrawingController::UBDrawingController(QObject * parent)
     , mActiveRuler(NULL)
     , mStylusTool((UBStylusTool::Enum)-1)
     , mLatestDrawingTool((UBStylusTool::Enum)-1)
-    //, mDrawingMode(eDrawingMode_Vector)
+    , mDrawingMode(DRAWING_MODE)
 
 {
     connect(UBSettings::settings(), SIGNAL(colorContextChanged()), this, SIGNAL(colorPaletteChanged()));
@@ -106,10 +106,16 @@ void UBDrawingController::setStylusTool(int tool)
         mStylusTool = (UBStylusTool::Enum)tool;
 
 
+        if(eDrawingMode_Vector == DRAWING_MODE){
+            mDrawingMode = eDrawingMode_Vector;
+        }
+
         if (mStylusTool == UBStylusTool::Pen)
             UBApplication::mainWindow->actionPen->setChecked(true);
-        else if (mStylusTool == UBStylusTool::Eraser)
+        else if (mStylusTool == UBStylusTool::Eraser){
             UBApplication::mainWindow->actionEraser->setChecked(true);
+            mDrawingMode = eDrawingMode_Artistic;
+        }
         else if (mStylusTool == UBStylusTool::Marker)
             UBApplication::mainWindow->actionMarker->setChecked(true);
         else if (mStylusTool == UBStylusTool::Selector)

src/board/UBDrawingController.h

@@ -27,6 +27,8 @@ typedef enum{
     eDrawingMode_Vector
 }eDrawingMode;
 
+#define DRAWING_MODE    eDrawingMode_Artistic
+
 class UBDrawingController : public QObject
 {
     Q_OBJECT;

src/domain/UBGraphicsPolygonItem.cpp

@@ -39,6 +39,7 @@ UBGraphicsPolygonItem::UBGraphicsPolygonItem (const QPolygonF & polygon, QGraphi
     , mOriginalWidth(-1)
     , mIsNominalLine(false)
     , mStroke(0)
+    , mpGroup(NULL)
 {
     // NOOP
     initialize();
@@ -77,6 +78,10 @@ UBGraphicsPolygonItem::~UBGraphicsPolygonItem()
     clearStroke();
 }
 
+void UBGraphicsPolygonItem::setStrokesGroup(UBGraphicsStrokesGroup *group)
+{
+    mpGroup = group;
+}
 
 void UBGraphicsPolygonItem::setStroke(UBGraphicsStroke* stroke)
 {
@@ -156,7 +161,7 @@ UBGraphicsPolygonItem* UBGraphicsPolygonItem::deepCopy(const QPolygonF& pol) con
     copy->mIsNominalLine = false;
 
     copy->setStroke(this->stroke());
-    copy->setGroup(this->group());
+    copy->setStrokesGroup(this->strokesGroup());
     copy->setBrush(this->brush());
     copy->setPen(this->pen());
     copy->mHasAlpha = this->mHasAlpha;

src/domain/UBGraphicsPolygonItem.h

@@ -19,6 +19,7 @@
 
 #include "core/UB.h"
 #include "UBItem.h"
+#include "UBGraphicsStrokesGroup.h"
 
 class UBItem;
 class UBGraphicsScene;
@@ -37,6 +38,8 @@ class UBGraphicsPolygonItem : public QGraphicsPolygonItem, public UBItem
 
         void initialize();
 
+        void setStrokesGroup(UBGraphicsStrokesGroup* group);
+        UBGraphicsStrokesGroup* strokesGroup() const{return mpGroup;}
         void setColor(const QColor& color);
 
         QColor color() const;
@@ -132,6 +135,7 @@ class UBGraphicsPolygonItem : public QGraphicsPolygonItem, public UBItem
         QColor mColorOnLightBackground;
 
         UBGraphicsStroke* mStroke;
+        UBGraphicsStrokesGroup* mpGroup;
 
 };
 

src/domain/UBGraphicsScene.cpp

@@ -567,7 +567,7 @@ bool UBGraphicsScene::inputDeviceRelease()
             }
         }else if (mCurrentStroke)
         {
-            if(eDrawingMode_Vector == dc->drawingMode()){
+            if(eDrawingMode_Vector == DRAWING_MODE){
                 UBGraphicsStrokesGroup* pStrokes = new UBGraphicsStrokesGroup();
 
                 // Remove the strokes that were just drawn here and replace them by a stroke item
@@ -575,6 +575,7 @@ bool UBGraphicsScene::inputDeviceRelease()
                     mPreviousPolygonItems.removeAll(poly);
                     removeItem(poly);
                     UBCoreGraphicsScene::removeItemFromDeletion(poly);
+                    poly->setStrokesGroup(pStrokes);
                     pStrokes->addToGroup(poly);
                 }
 
@@ -756,13 +757,37 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
     eraserPathVar.addPolygon(eraserPolygon);
     const QPainterPath eraserPath = eraserPathVar;
 
+    // Get all the items that are intersecting with the eraser path
     QList<QGraphicsItem*> collidItems = items(eraserBoundingRect, Qt::IntersectsItemBoundingRect);
 
+    if(eDrawingMode_Vector == UBDrawingController::drawingController()->drawingMode()){
+        // NOTE: I decided to reuse the 'artistic' eraser all the time in order to have a better eraser
+        //       For this reason, the following code is not used but we will keep it for now, in case of
+        //       futur requirements.
+        foreach(QGraphicsItem* poly, collidItems){
+            UBGraphicsStrokesGroup* pGroup = dynamic_cast<UBGraphicsStrokesGroup*>(poly);
+            if(NULL != pGroup){
+                // TODO:    Ungroup the item, put back the polygons on the scene, deal with the
+                //          eraser's bounding rect, remove the polygons that must be removed
+                //          then create new groups.
+
+                // Get all substrokes and verify if they are part of the eraserpath then deal with it
+                foreach(QGraphicsItem* item, poly->childItems()){
+                    UBGraphicsPolygonItem* polygon = dynamic_cast<UBGraphicsPolygonItem*>(item);
+                    if(NULL != polygon){
+                        if(eraserBoundingRect.intersects(polygon->boundingRect())){
+                            pGroup->removeFromGroup(polygon);
+                            removeItem(polygon);
+                        }
+                    }
+                }
+            }
+        }
+
+    }else{
         QSet<QGraphicsItem*> toBeAddedItems;
         QSet<QGraphicsItem*> toBeRemovedItems;
-
         int collidItemsSize = collidItems.size();
-
         toBeAddedItems.reserve(collidItemsSize);
         toBeRemovedItems.reserve(collidItemsSize);
 
@@ -771,22 +796,26 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
     #pragma omp parallel for
             for (int i = 0; i < collidItemsSize; i++)
             {
-            UBGraphicsPolygonItem *collidingPolygonItem
-                = qgraphicsitem_cast<UBGraphicsPolygonItem*> (collidItems.at(i));
+                UBGraphicsPolygonItem *collidingPolygonItem = dynamic_cast<UBGraphicsPolygonItem*>(collidItems.at(i));
 
-            if (collidingPolygonItem)
+                if (NULL != collidingPolygonItem)
                 {
+                    UBGraphicsStrokesGroup* pGroup = collidingPolygonItem->strokesGroup();
+
                     if(eraserInnerRect.contains(collidingPolygonItem->boundingRect()))
                     {
     #pragma omp critical
+                        // Put the entire polygon into the remove list
                         toBeRemovedItems << collidingPolygonItem;
                     }
                     else
                     {
+                        // Here we get the polygon of the colliding item
                         QPolygonF collidingPolygon = collidingPolygonItem->polygon();
                         QPainterPath collidingPath;
                         collidingPath.addPolygon(collidingPolygon);
 
+                        // Then we substract the eraser path to the polygon and we simplify it
                         QPainterPath croppedPath = collidingPath.subtracted(eraserPath);
                         QPainterPath croppedPathSimplified = croppedPath.simplified();
 
@@ -797,17 +826,25 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
                         else if (croppedPathSimplified.isEmpty())
                         {
     #pragma omp critical
+                            // Put the entire polygon into the remove list if the eraser removes all its visible content
                             toBeRemovedItems << collidingPolygonItem;
                         }
                         else
                         {
+                            // Then we convert the remaining path to a list of polygons that will be converted in
+                            // UBGraphicsPolygonItems and added to the scene
                             foreach(const QPolygonF &pol, croppedPathSimplified.toFillPolygons())
                             {
                                 UBGraphicsPolygonItem* croppedPolygonItem = collidingPolygonItem->deepCopy(pol);
     #pragma omp critical
+                                // Add this new polygon to the 'added' list
                                 toBeAddedItems << croppedPolygonItem;
+                                if(NULL != pGroup){
+                                    croppedPolygonItem->setStrokesGroup(pGroup);
+                                }
                             }
     #pragma omp critical
+                            // Remove the original polygonitem because it has been replaced by many smaller polygons
                             toBeRemovedItems << collidingPolygonItem;
                         }
                     }
@@ -862,9 +899,28 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
         addItems(toBeAddedItems);
         mAddedItems += toBeAddedItems;
 
+        if(eDrawingMode_Vector == DRAWING_MODE){
+            foreach(QGraphicsItem* item, toBeAddedItems){
+                UBGraphicsPolygonItem* poly = dynamic_cast<UBGraphicsPolygonItem*>(item);
+                if(NULL != poly && NULL != poly->strokesGroup()){
+                    poly->strokesGroup()->addToGroup(poly);
+                }
+            }
+        }
+
         removeItems(toBeRemovedItems);
         mRemovedItems += toBeRemovedItems;
 
+        if(eDrawingMode_Vector == DRAWING_MODE){
+            foreach(QGraphicsItem* item, toBeRemovedItems){
+                UBGraphicsPolygonItem* poly = dynamic_cast<UBGraphicsPolygonItem*>(item);
+                if(NULL != poly && NULL != poly->strokesGroup()){
+                    poly->strokesGroup()->removeFromGroup(poly);
+                }
+            }
+        }
+    }
+
     mPreviousPoint = pEndPoint;
 }
 

src/domain/UBGraphicsStrokesGroup.h

@@ -16,6 +16,11 @@ public:
     virtual UBItem* deepCopy() const;
     virtual void remove();
     virtual UBGraphicsItemDelegate* Delegate() const {return mDelegate;}
+    enum { Type = UBGraphicsItemType::StrokeItemType };
+    virtual int type() const
+    {
+        return Type;
+    }
 
 protected:
     virtual void mousePressEvent(QGraphicsSceneMouseEvent *event);

src/frameworks/UBGeometryUtils.cpp

@@ -198,6 +198,7 @@ QRectF UBGeometryUtils::lineToInnerRect(const QLineF& pLine, const qreal& pWidth
     qreal centerX = (pLine.x1() + pLine.x2()) / 2;
     qreal centerY = (pLine.y1() + pLine.y2()) / 2;
 
+    // Please put a fucking comment here
     qreal side = sqrt((pWidth * pWidth) / 2);
     qreal halfSide = side / 2;