Merge remote-tracking branch 'origin/aleksei_kanash_dev' into Ilia_dev

src/adaptors/UBCFFSubsetAdaptor.cpp

@@ -16,6 +16,7 @@
 #include <QSvgGenerator>
 #include <QSvgRenderer>
 #include <QPixmap>
+#include <QMap>
 
 #include "core/UBPersistenceManager.h"
 
@@ -373,37 +374,60 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPolygon(const QDomElement &e
     brush.setColor(fillColor);
     brush.setStyle(Qt::SolidPattern);
 
-    QSvgGenerator *generator = createSvgGenerator(width + pen.width(), height + pen.width());
+ 
-    QPainter painter;
+    QUuid itemUuid(element.attribute(aId).right(QUuid().toString().length()));
+    QUuid itemGroupUuid(element.attribute(aId).left(QUuid().toString().length()-1));
+    if (!itemUuid.isNull() && (itemGroupUuid!=itemUuid)) // reimported from UBZ
+    {
+        UBGraphicsPolygonItem *graphicsPolygon = new UBGraphicsPolygonItem(polygon);
 
-    painter.begin(generator); //drawing to svg tmp file
+        graphicsPolygon->setBrush(brush);
 
-    painter.translate(pen.widthF() / 2 - x1, pen.widthF() / 2 - y1);
+        QTransform transform;
-    painter.setBrush(brush);
+        QString textTransform = element.attribute(aTransform);
-    painter.setPen(pen);
-    painter.drawPolygon(polygon);
 
-    painter.end();
+        graphicsPolygon->resetTransform();
+        if (!textTransform.isNull()) {
+            transform = transformFromString(textTransform, graphicsPolygon);
+        }
+        mCurrentScene->addItem(graphicsPolygon);
 
-    //add resulting svg file to scene
+        graphicsPolygon->setUuid(itemUuid);
-    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);
+    else // single CFF
-    hashSceneItem(element, svgItem);
-
-    if (mGSectionContainer)
     {
-        addItemToGSection(svgItem);
+        QSvgGenerator *generator = createSvgGenerator(width + pen.width(), height + pen.width());
-    }
+        QPainter painter;
 
-    delete generator;
+        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;
 }
 bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPolyline(const QDomElement &element)
@@ -441,6 +465,7 @@ 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();
@@ -458,35 +483,64 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvgPolyline(const QDomElement &
     pen.setColor(strokeColor);
     pen.setWidth(strokeWidth);
 
-    QSvgGenerator *generator = createSvgGenerator(width + pen.width(), height + pen.width());
+    QBrush brush;
-    QPainter painter;
+    brush.setColor(strokeColor);
+    brush.setStyle(Qt::SolidPattern);
 
-    painter.begin(generator); //drawing to svg tmp file
+    QUuid itemUuid(element.attribute(aId).right(QUuid().toString().length()));
+    QUuid itemGroupUuid(element.attribute(aId).left(QUuid().toString().length()-1));
+    if (!itemUuid.isNull() && (itemGroupUuid!=itemUuid)) // reimported from UBZ
+    {
+        UBGraphicsPolygonItem *graphicsPolygon = new UBGraphicsPolygonItem(polygon);
 
-    painter.translate(pen.widthF()/2 - x1, pen.widthF()/2- y1);
+        UBGraphicsStroke *stroke = new UBGraphicsStroke();
-    painter.setPen(pen);
+        graphicsPolygon->setStroke(stroke);
-    painter.drawPolyline(polygon);
 
-    painter.end();
+        graphicsPolygon->setBrush(brush);
+        QTransform transform;
+        QString textTransform = element.attribute(aTransform);
 
-    //add resulting svg file to scene
+        graphicsPolygon->resetTransform();
-    UBGraphicsSvgItem *svgItem = mCurrentScene->addSvg(QUrl::fromLocalFile(generator->fileName()));
+        if (!textTransform.isNull()) {
-    QTransform transform;
+            transform = transformFromString(textTransform, graphicsPolygon);
-    QString textTransform = element.attribute(aTransform);
+        }
+        mCurrentScene->addItem(graphicsPolygon);
 
-    svgItem->resetTransform();
-    if (!textTransform.isNull()) {
-        transform = transformFromString(textTransform, svgItem);
     }
-    repositionSvgItem(svgItem, width +strokeWidth, height + strokeWidth, x1 + transform.m31() - strokeWidth/2, y1 + transform.m32() + strokeWidth/2, transform);
+    else // simple CFF
-    hashSceneItem(element, svgItem);
-
-    if (mGSectionContainer)
     {
-        addItemToGSection(svgItem);
+        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;
     }
 
-    delete generator;
 
     return true;
 }
@@ -980,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;
@@ -1027,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;
@@ -1036,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);
@@ -1052,15 +1106,86 @@ bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseSvg(const QDomElement &svgSecti
     return true;
 }
 
-bool UBCFFSubsetAdaptor::UBCFFSubsetReader::parseIwbGroup(QDomElement &parent)
+UBGraphicsGroupContainerItem *UBCFFSubsetAdaptor::UBCFFSubsetReader::parseIwbGroup(QDomElement &parent)
 {
     //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;
     }
 
-    return true;
+    UBGraphicsGroupContainerItem *group = new UBGraphicsGroupContainerItem();
+    QMultiMap<QString, UBGraphicsPolygonItem *> strokesGroupsContainer;    
+    QList<QGraphicsItem *> groupContainer;    
+    QString currentStrokeIdentifier;
+
+    QDomElement currentStrokeElement = parent.firstChildElement();    
+    while (!currentStrokeElement.isNull())
+    {
+        if (tGroup == currentStrokeElement.tagName())
+            group->addToGroup(parseIwbGroup(currentStrokeElement));
+        else
+        {
+            QString uuid = currentStrokeElement.attribute(aRef);
+            if (!uuid.isEmpty())
+            {
+                if (uuid.size() > QUuid().toString().length()) // create stroke group
+                {              
+                    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(QUuid(uuid)));
+            }
+        }
+        currentStrokeElement = currentStrokeElement.nextSiblingElement();
+    }
+
+
+
+    foreach (QString key, strokesGroupsContainer.keys())
+    {
+        UBGraphicsStrokesGroup* pStrokesGroup = new UBGraphicsStrokesGroup();
+        UBGraphicsStroke *currentStroke = new UBGraphicsStroke();
+        foreach(UBGraphicsPolygonItem* poly, strokesGroupsContainer.values(key))
+        {
+            if (poly)
+            {
+                mCurrentScene->removeItem(poly);
+                mCurrentScene->removeItemFromDeletion(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);
+    }
+
+    foreach(QGraphicsItem* item, groupContainer)
+        group->addToGroup(item);
+
+    if (group->childItems().count())
+    {
+        mCurrentScene->addItem(group);
+
+        if (!groupContainer.count())
+        {
+            group->destroy(false);
+        }
+    }
+
+    return group;
 }
 
 bool UBCFFSubsetAdaptor::UBCFFSubsetReader::strToBool(QString str)
@@ -1071,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;

src/adaptors/UBCFFSubsetAdaptor.h

@@ -102,7 +102,7 @@ private:
         inline bool parseSvgFlash(const QDomElement &element);
         inline bool parseSvgAudio(const QDomElement &element);
         inline bool parseSvgVideo(const QDomElement &element);
-        inline bool parseIwbGroup(QDomElement &parent);
+        inline UBGraphicsGroupContainerItem *parseIwbGroup(QDomElement &parent);
         inline bool parseIwbElement(QDomElement &element);
         inline void parseTSpan(const QDomElement &parent, QPainter &painter
                                , qreal &curX, qreal &curY, qreal &width, qreal &height, qreal &linespacing, QRectF &lastDrawnTextBoundingRect