Implemented import UBZ strokes from CFF (means strokes who was exported from UBZ to CFF and imported back).

Compatible with groups.

src/adaptors/UBCFFSubsetAdaptor.cpp

@@ -16,6 +16,7 @@
 #include <QSvgGenerator>
 #include <QSvgRenderer>
 #include <QPixmap>
+#include <QMap>
 
 #include "core/UBPersistenceManager.h"
 
@@ -350,6 +351,13 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPolygon(const QDomElement &e
         }
     }
 
+    //bounding rect lef top corner coordinates
+    qreal x1 = polygon.boundingRect().topLeft().x();
+    qreal y1 = polygon.boundingRect().topLeft().y();
+    //bounding rect dimensions
+    qreal width = polygon.boundingRect().width();
+    qreal height = polygon.boundingRect().height();
+
     QString strokeColorText = element.attribute(aStroke);
     QString fillColorText = element.attribute(aFill);
     QString strokeWidthText = element.attribute(aStrokewidth);
@@ -366,21 +374,59 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPolygon(const QDomElement &e
     brush.setColor(fillColor);
     brush.setStyle(Qt::SolidPattern);
 
-    UBGraphicsPolygonItem *graphicsPolygon = new UBGraphicsPolygonItem(polygon);
-    graphicsPolygon->setBrush(brush);
  
-    QTransform transform;
+    QUuid itemUuid(element.attribute(aId).right(QUuid().toString().length()));
-    QString textTransform = element.attribute(aTransform);
+    QUuid itemGroupUuid(element.attribute(aId).left(QUuid().toString().length()-1));
+    if (!itemUuid.isNull() && (itemGroupUuid!=itemUuid)) // reimported from UBZ
+    {
+        UBGraphicsPolygonItem *graphicsPolygon = new UBGraphicsPolygonItem(polygon);
 
-    graphicsPolygon->resetTransform();
+        graphicsPolygon->setBrush(brush);
-    if (!textTransform.isNull()) {
-        transform = transformFromString(textTransform, graphicsPolygon);
-    }
-    mCurrentScene->addItem(graphicsPolygon);    
 
-    if (mGSectionContainer)
+        QTransform transform;
+        QString textTransform = element.attribute(aTransform);
+
+        graphicsPolygon->resetTransform();
+        if (!textTransform.isNull()) {
+            transform = transformFromString(textTransform, graphicsPolygon);
+        }
+        mCurrentScene->addItem(graphicsPolygon);
+
+        graphicsPolygon->setUuid(itemUuid);
+
+    }
+    else // single CFF
     {
-        addItemToGSection(graphicsPolygon);
+        QSvgGenerator *generator = createSvgGenerator(width + pen.width(), height + pen.width());
+        QPainter painter;
+
+        painter.begin(generator); //drawing to svg tmp file
+
+        painter.translate(pen.widthF() / 2 - x1, pen.widthF() / 2 - y1);
+        painter.setBrush(brush);
+        painter.setPen(pen);
+        painter.drawPolygon(polygon);
+
+        painter.end();
+
+        //add resulting svg file to scene
+        UBGraphicsSvgItem *svgItem = mCurrentScene->addSvg(QUrl::fromLocalFile(generator->fileName()));
+        QTransform transform;
+        QString textTransform = element.attribute(aTransform);
+
+        svgItem->resetTransform();
+        if (!textTransform.isNull()) {
+            transform = transformFromString(textTransform, svgItem);
+        }
+        repositionSvgItem(svgItem, width +strokeWidth, height + strokeWidth, x1 - strokeWidth/2 + transform.m31(), y1 + strokeWidth/2 + transform.m32(), transform);
+        hashSceneItem(element, svgItem);
+
+        if (mGSectionContainer)
+        {
+            addItemToGSection(svgItem);
+        }
+
+        delete generator;
     }
     return true;
 }
@@ -416,6 +462,10 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPolyline(const QDomElement &
         }
     }
 
+    //bounding rect lef top corner coordinates
+    qreal x1 = polygon.boundingRect().topLeft().x();
+    qreal y1 = polygon.boundingRect().topLeft().y();
+
     //bounding rect dimensions
     qreal width = polygon.boundingRect().width();
     qreal height = polygon.boundingRect().height();
@@ -436,20 +486,59 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPolyline(const QDomElement &
     QBrush brush;
     brush.setColor(strokeColor);
     brush.setStyle(Qt::SolidPattern);
-    UBGraphicsPolygonItem *graphicsPolygon = new UBGraphicsPolygonItem(polygon);
-    graphicsPolygon->setBrush(brush);
-    QTransform transform;
-    QString textTransform = element.attribute(aTransform);
 
-    graphicsPolygon->resetTransform();
+    QUuid itemUuid(element.attribute(aId).right(QUuid().toString().length()));
-    if (!textTransform.isNull()) {
+    QUuid itemGroupUuid(element.attribute(aId).left(QUuid().toString().length()-1));
-        transform = transformFromString(textTransform, graphicsPolygon);
+    if (!itemUuid.isNull() && (itemGroupUuid!=itemUuid)) // reimported from UBZ
-    }
+    {
-    mCurrentScene->addItem(graphicsPolygon);
+        UBGraphicsPolygonItem *graphicsPolygon = new UBGraphicsPolygonItem(polygon);
 
-    if (mGSectionContainer)
+        UBGraphicsStroke *stroke = new UBGraphicsStroke();
+        graphicsPolygon->setStroke(stroke);
+
+        graphicsPolygon->setBrush(brush);
+        QTransform transform;
+        QString textTransform = element.attribute(aTransform);
+
+        graphicsPolygon->resetTransform();
+        if (!textTransform.isNull()) {
+            transform = transformFromString(textTransform, graphicsPolygon);
+        }
+        mCurrentScene->addItem(graphicsPolygon);
+
+    }
+    else // simple CFF
     {
-        addItemToGSection(graphicsPolygon);
+        QSvgGenerator *generator = createSvgGenerator(width + pen.width(), height + pen.width());
+        QPainter painter;
+
+        painter.begin(generator); //drawing to svg tmp file
+
+        painter.translate(pen.widthF() / 2 - x1, pen.widthF() / 2 - y1);
+        painter.setBrush(brush);
+        painter.setPen(pen);
+        painter.drawPolygon(polygon);
+
+        painter.end();
+
+        //add resulting svg file to scene
+        UBGraphicsSvgItem *svgItem = mCurrentScene->addSvg(QUrl::fromLocalFile(generator->fileName()));
+        QTransform transform;
+        QString textTransform = element.attribute(aTransform);
+
+        svgItem->resetTransform();
+        if (!textTransform.isNull()) {
+            transform = transformFromString(textTransform, svgItem);
+        }
+        repositionSvgItem(svgItem, width +strokeWidth, height + strokeWidth, x1 - strokeWidth/2 + transform.m31(), y1 + strokeWidth/2 + transform.m32(), transform);
+        hashSceneItem(element, svgItem);
+
+        if (mGSectionContainer)
+        {
+            addItemToGSection(svgItem);
+        }
+
+        delete generator;
     }
 
 
@@ -945,8 +1034,8 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgElement(const QDomElement &p
 {
     QString tagName = parent.tagName();
     if (parent.namespaceURI() != svgNS) {
-        qDebug() << "Incorrect namespace, error at content file, line number" << parent.lineNumber();
+        qWarning() << "Incorrect namespace, error at content file, line number" << parent.lineNumber();
-        return false;
+        //return false;
     }
 
     if      (tagName == tG          &&  !parseGSection(parent))             return false;
@@ -992,8 +1081,8 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPageset(const QDomElement &p
 bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseIwbMeta(const QDomElement &element)
 {
     if (element.namespaceURI() != iwbNS) {
-        qDebug() << "incorrect meta namespace, incorrect document";
+        qWarning() << "incorrect meta namespace, incorrect document";
-        return false;
+        //return false;
     }
 
     return true;
@@ -1001,8 +1090,8 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseIwbMeta(const QDomElement &elem
 bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvg(const QDomElement &svgSection)
 {
     if (svgSection.namespaceURI() != svgNS) {
-        qDebug() << "incorrect svg namespace, incorrect document";
+        qWarning() << "incorrect svg namespace, incorrect document";
-        return false;
+       // return false;
     }
 
     parseSvgSectionAttr(svgSection);
@@ -1021,13 +1110,15 @@ UBGraphicsGroupContainerItem *UBCFFSubsetAdaptor::UBCFFSubsetReader::parseIwbGro
 {
     //TODO. Create groups from elements parsed by parseIwbElement() function
     if (parent.namespaceURI() != iwbNS) {
-        qDebug() << "incorrect iwb group namespace, incorrect document";
+        qWarning() << "incorrect iwb group namespace, incorrect document";
-        return false;
+      //  return false;
     }
 
     UBGraphicsGroupContainerItem *group = new UBGraphicsGroupContainerItem();
-    QList<UBGraphicsPolygonItem *> strokesContainer;    
+    QMultiMap<QString, UBGraphicsPolygonItem *> strokesGroupsContainer;    
     QList<QGraphicsItem *> groupContainer;    
+    QString currentStrokeIdentifier;
+
     QDomElement currentStrokeElement = parent.firstChildElement();    
     while (!currentStrokeElement.isNull())
     {
@@ -1038,40 +1129,62 @@ UBGraphicsGroupContainerItem *UBCFFSubsetAdaptor::UBCFFSubsetReader::parseIwbGro
             QString uuid = currentStrokeElement.attribute(aRef);
             if (!uuid.isEmpty())
             {
-                if (uuid.contains("stroke")) // create stroke group
+                if (uuid.size() > QUuid().toString().length()) // create stroke group
-                    strokesContainer.append(qgraphicsitem_cast<UBGraphicsPolygonItem *>(mCurrentScene->itemForUuid(uuid)));
+                {              
+                    currentStrokeIdentifier = uuid.left(QUuid().toString().length()-1);
+                    UBGraphicsPolygonItem *strokeByUuid = qgraphicsitem_cast<UBGraphicsPolygonItem *>(mCurrentScene->itemForUuid(QUuid(uuid.right(QUuid().toString().length()))));
+
+                    if (strokeByUuid)
+                        strokesGroupsContainer.insert(currentStrokeIdentifier, strokeByUuid);
+                }
                 else // single elements in group
-                    groupContainer.append(mCurrentScene->itemForUuid(uuid));
+                    groupContainer.append(mCurrentScene->itemForUuid(QUuid(uuid)));
             }
         }
         currentStrokeElement = currentStrokeElement.nextSiblingElement();
     }
-    UBGraphicsStrokesGroup* pStrokesGroup = new UBGraphicsStrokesGroup();
+
-    UBGraphicsStroke *currentStroke = new UBGraphicsStroke();
+
-    foreach(UBGraphicsPolygonItem* poly, strokesContainer)
+
+    foreach (QString key, strokesGroupsContainer.keys())
     {
-        if (poly)
+        UBGraphicsStrokesGroup* pStrokesGroup = new UBGraphicsStrokesGroup();
+        UBGraphicsStroke *currentStroke = new UBGraphicsStroke();
+        foreach(UBGraphicsPolygonItem* poly, strokesGroupsContainer.values(key))
         {
-            mCurrentScene->removeItem(poly);
+            if (poly)
-            mCurrentScene->removeItemFromDeletion(poly);
+            {
-            poly->setStrokesGroup(pStrokesGroup);
+                mCurrentScene->removeItem(poly);
-            poly->setStroke(currentStroke);
+                mCurrentScene->removeItemFromDeletion(poly);
-            pStrokesGroup->addToGroup(poly);
+                poly->setStrokesGroup(pStrokesGroup);
+                poly->setStroke(currentStroke);
+                pStrokesGroup->addToGroup(poly);
+            }
         }
+        if (currentStroke->polygons().empty())
+            delete currentStroke;
+        if (pStrokesGroup->childItems().count())
+            mCurrentScene->addItem(pStrokesGroup);
+        else
+            delete pStrokesGroup;
+
+        if (pStrokesGroup)
+            group->addToGroup(pStrokesGroup);
     }
-    if (currentStroke->polygons().empty())
+
-        delete currentStroke;
-    if (pStrokesGroup->childItems().count())
-        mCurrentScene->addItem(pStrokesGroup);
-    else
-        delete pStrokesGroup;
     foreach(QGraphicsItem* item, groupContainer)
         group->addToGroup(item);
-    if (pStrokesGroup)
+
-        group->addToGroup(pStrokesGroup);
     if (group->childItems().count())
+    {
         mCurrentScene->addItem(group);
 
+        if (!groupContainer.count())
+        {
+            group->destroy(false);
+        }
+    }
+
     return group;
 }
 
@@ -1083,8 +1196,8 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::strToBool(QString str)
 bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseIwbElement(QDomElement &element)
 {
     if (element.namespaceURI() != iwbNS) {
-        qDebug() << "incorrect iwb element namespace, incorrect document";
+        qWarning() << "incorrect iwb element namespace, incorrect document";
-        return false;
+      //  return false;
     }
 
     bool locked = false;