Resolved an issue with the eraser o the strokes as object story

src/adaptors/UBSvgSubsetAdaptor.cpp

@@ -544,6 +544,7 @@ UBGraphicsScene* UBSvgSubsetAdaptor::UBSvgSubsetReader::loadScene()
                         if(strokesGroup){
                             polygonItem->setTransform(strokesGroup->transform());
                             strokesGroup->addToGroup(polygonItem);
+                            polygonItem->setStrokesGroup(strokesGroup);
                         }
                     }else{
                         scene->addItem(polygonItem);
@@ -1005,8 +1006,6 @@ void UBSvgSubsetAdaptor::UBSvgSubsetWriter::writeSvgElement()
 
 bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
 {
-
-
     if (mScene->isModified())
     {
         static int i = 0;
@@ -1029,6 +1028,7 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
 
         writeSvgElement();
 
+        // Get the items from the scene
         QList<QGraphicsItem*> items = mScene->items();
 
         qSort(items.begin(), items.end(), itemZIndexComp);
@@ -1041,10 +1041,32 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
         {
             QGraphicsItem *item = items.takeFirst();
 
-            UBGraphicsPolygonItem *polygonItem = qgraphicsitem_cast<UBGraphicsPolygonItem*> (item);
+            // Is the item a strokes group?
+            UBGraphicsStrokesGroup* strokesGroupItem = qgraphicsitem_cast<UBGraphicsStrokesGroup*>(item);
+            if(strokesGroupItem && strokesGroupItem->isVisible()){
+            	mXmlWriter.writeStartElement("g");
+            	QMatrix matrix = item->sceneMatrix();
+				if (!matrix.isIdentity()){
+					mXmlWriter.writeAttribute("transform", toSvgTransform(matrix));
+				}
+
+				// Add the polygons
+				foreach(QGraphicsItem* item, strokesGroupItem->childItems()){
+					UBGraphicsPolygonItem* poly = qgraphicsitem_cast<UBGraphicsPolygonItem*>(item);
+					if(NULL != poly){
+						polygonItemToSvgPolygon(poly, true);
+						items.removeOne(poly);
+					}
+				}
+
+            	mXmlWriter.writeEndElement(); //g
+            }
 
+            // Is the item a polygon?
+            UBGraphicsPolygonItem *polygonItem = qgraphicsitem_cast<UBGraphicsPolygonItem*> (item);
             if (polygonItem && polygonItem->isVisible())
             {
+
                 UBGraphicsStroke* currentStroke = polygonItem->stroke();
 
                 if (openStroke && (currentStroke != openStroke))
@@ -1116,84 +1138,86 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
                 openStroke = 0;
             }
 
+            // Is the item a picture?
             UBGraphicsPixmapItem *pixmapItem = qgraphicsitem_cast<UBGraphicsPixmapItem*> (item);
-
             if (pixmapItem && pixmapItem->isVisible())
             {
                 pixmapItemToLinkedImage(pixmapItem);
                 continue;
             }
 
+            // Is the item a shape?
             UBGraphicsSvgItem *svgItem = qgraphicsitem_cast<UBGraphicsSvgItem*> (item);
-
             if (svgItem && svgItem->isVisible())
             {
                 svgItemToLinkedSvg(svgItem);
                 continue;
             }
 
+            // Is the Item a video?
             UBGraphicsVideoItem *videoItem = qgraphicsitem_cast<UBGraphicsVideoItem*> (item);
-
             if (videoItem && videoItem->isVisible())
             {
                 videoItemToLinkedVideo(videoItem);
                 continue;
             }
 
+            // Is the item an audio?
             UBGraphicsAudioItem* audioItem = qgraphicsitem_cast<UBGraphicsAudioItem*> (item);
             if (audioItem && audioItem->isVisible()) {
                 audioItemToLinkedAudio(audioItem);
                 continue;
             }
 
+            // Is the item an app?
             UBGraphicsAppleWidgetItem *appleWidgetItem = qgraphicsitem_cast<UBGraphicsAppleWidgetItem*> (item);
-
             if (appleWidgetItem && appleWidgetItem->isVisible())
             {
                 graphicsAppleWidgetToSvg(appleWidgetItem);
                 continue;
             }
 
+            // Is the item a W3C?
             UBGraphicsW3CWidgetItem *w3cWidgetItem = qgraphicsitem_cast<UBGraphicsW3CWidgetItem*> (item);
-
             if (w3cWidgetItem && w3cWidgetItem->isVisible())
             {
                 graphicsW3CWidgetToSvg(w3cWidgetItem);
                 continue;
             }
 
+            // Is the item a PDF?
             UBGraphicsPDFItem *pdfItem = qgraphicsitem_cast<UBGraphicsPDFItem*> (item);
-
             if (pdfItem && pdfItem->isVisible())
             {
                 pdfItemToLinkedPDF(pdfItem);
                 continue;
             }
 
+            // Is the item a text?
             UBGraphicsTextItem *textItem = qgraphicsitem_cast<UBGraphicsTextItem*> (item);
-
             if (textItem && textItem->isVisible())
             {
                 textItemToSvg(textItem);
                 continue;
             }
 
+            // Is the item a curtain?
             UBGraphicsCurtainItem *curtainItem = qgraphicsitem_cast<UBGraphicsCurtainItem*> (item);
-
             if (curtainItem && curtainItem->isVisible())
             {
                 curtainItemToSvg(curtainItem);
                 continue;
             }
 
+            // Is the item a ruler?
             UBGraphicsRuler *ruler = qgraphicsitem_cast<UBGraphicsRuler*> (item);
-
             if (ruler && ruler->isVisible())
             {
                 rulerToSvg(ruler);
                 continue;
             }
 
+            // Is the item a cache?
             UBGraphicsCache* cache = qgraphicsitem_cast<UBGraphicsCache*>(item);
             if(cache && cache->isVisible())
             {
@@ -1201,32 +1225,32 @@ bool UBSvgSubsetAdaptor::UBSvgSubsetWriter::persistScene(int pageIndex)
                 continue;
             }
 
+            // Is the item a compass
             UBGraphicsCompass *compass = qgraphicsitem_cast<UBGraphicsCompass*> (item);
-
             if (compass && compass->isVisible())
             {
                 compassToSvg(compass);
                 continue;
             }
 
+            // Is the item a protractor?
             UBGraphicsProtractor *protractor = qgraphicsitem_cast<UBGraphicsProtractor*> (item);
-
             if (protractor && protractor->isVisible())
             {
                 protractorToSvg(protractor);
                 continue;
             }
 
+            // Is the item a triangle?
             UBGraphicsTriangle *triangle = qgraphicsitem_cast<UBGraphicsTriangle*> (item);
-
             if (triangle && triangle->isVisible())
             {
                 triangleToSvg(triangle);
                 continue;
             }
 
+            // Is the item a group?
             UBGraphicsGroupContainerItem *groupItem = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(item);
-
             if (groupItem && groupItem->isVisible())
             {
                 qDebug() << "came across the group during the parsing";

src/core/UBPersistenceManager.cpp

@@ -582,7 +582,6 @@ UBGraphicsScene* UBPersistenceManager::loadDocumentScene(UBDocumentProxy* proxy,
     if (mSceneCache.contains(proxy, sceneIndex))
         return mSceneCache.value(proxy, sceneIndex);
     else {
-        qDebug() << "scene" << sceneIndex << "retrieved from file ...";
         UBGraphicsScene* scene = UBSvgSubsetAdaptor::loadScene(proxy, sceneIndex);
 
         if (scene)

src/domain/UBGraphicsScene.cpp

@@ -834,18 +834,17 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
 
         if (mShouldUseOMP)
         {
-    #pragma omp parallel for
+    //#pragma omp parallel for
             for (int i = 0; i < collidItemsSize; i++)
             {
                 UBGraphicsPolygonItem *collidingPolygonItem = qgraphicsitem_cast<UBGraphicsPolygonItem*>(collidItems.at(i));
-
-                if (NULL != collidingPolygonItem)
+                if(NULL != collidingPolygonItem)
                 {
                     UBGraphicsStrokesGroup* pGroup = collidingPolygonItem->strokesGroup();
 
                     if(eraserInnerRect.contains(collidingPolygonItem->boundingRect()))
                     {
-    #pragma omp critical
+    //#pragma omp critical
                         // Put the entire polygon into the remove list
                         toBeRemovedItems << collidingPolygonItem;
                     }
@@ -882,7 +881,7 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
                         }
                         else */if (croppedPathSimplified.isEmpty())
                         {
-    #pragma omp critical
+    //#pragma omp critical
                             // Put the entire polygon into the remove list if the eraser removes all its visible content
                             toBeRemovedItems << collidingPolygonItem;
                         }
@@ -893,14 +892,15 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
                             foreach(const QPolygonF &pol, croppedPathSimplified.toFillPolygons())
                             {
                                 UBGraphicsPolygonItem* croppedPolygonItem = collidingPolygonItem->deepCopy(pol);
-    #pragma omp critical
+    //#pragma omp critical
                                 if(NULL != pGroup){
                                     croppedPolygonItem->setStrokesGroup(pGroup);
+                                    //pGroup->addToGroup(croppedPolygonItem);
                                 }
                                 // Add this new polygon to the 'added' list
                                 toBeAddedItems << croppedPolygonItem;
                             }
-    #pragma omp critical
+    //#pragma omp critical
                             // Remove the original polygonitem because it has been replaced by many smaller polygons
                             toBeRemovedItems << collidingPolygonItem;
                         }
@@ -961,8 +961,9 @@ void UBGraphicsScene::eraseLineTo(const QPointF &pEndPoint, const qreal &pWidth)
             foreach(QGraphicsItem* item, toBeRemovedItems){
                 UBGraphicsPolygonItem* poly = dynamic_cast<UBGraphicsPolygonItem*>(item);
                 if(NULL != poly){
-                    if(NULL != poly->strokesGroup()){
-                        poly->strokesGroup()->removeFromGroup(poly);
+                	UBGraphicsStrokesGroup* group = poly->strokesGroup();
+                    if(NULL != group){
+                        group->removeFromGroup(poly);
                         removeItem(poly);
                     }else{
                         qDebug() << "No group present";