Editor plugin: Kopírování a manipulace s elementy

Pdf4QtLibCore/sources/pdfpagecontenteditorprocessor.cpp

@@ -54,7 +54,7 @@ void PDFPageContentEditorProcessor::performInterceptInstruction(Operator current
     {
         if (currentOperator == Operator::TextBegin && !isTextProcessing())
         {
-            m_contentElementText.reset(new PDFEditedPageContentElementText(*getGraphicState()));
+            m_contentElementText.reset(new PDFEditedPageContentElementText(*getGraphicState(), getGraphicState()->getCurrentTransformationMatrix()));
         }
     }
     else
@@ -64,7 +64,6 @@ void PDFPageContentEditorProcessor::performInterceptInstruction(Operator current
             if (m_contentElementText && !m_contentElementText->isEmpty())
             {
                 m_contentElementText->setTextPath(std::move(m_textPath));
-                m_contentElementText->setBoundingBox(m_textBoundingRect);
                 m_content.addContentElement(std::move(m_contentElementText));
             }
             m_contentElementText.reset();
@@ -129,9 +128,8 @@ bool PDFPageContentEditorProcessor::performOriginalImagePainting(const PDFImage&
 {
     BaseClass::performOriginalImagePainting(image, stream);
 
-    QRectF boundingBox = getCurrentWorldMatrix().mapRect(QRectF(0.0, 0.0, 1.0, 1.0));
     PDFObject imageObject = PDFObject::createStream(std::make_shared<PDFStream>(*stream));
-    m_content.addContentImage(*getGraphicState(), std::move(imageObject), QImage(), boundingBox);
+    m_content.addContentImage(*getGraphicState(), std::move(imageObject), QImage());
 
     return false;
 }
@@ -430,12 +428,12 @@ QString PDFEditedPageContent::getOperandName(PDFPageContentProcessor::Operator o
 
 void PDFEditedPageContent::addContentPath(PDFPageContentProcessorState state, QPainterPath path, bool strokePath, bool fillPath)
 {
-    m_contentElements.emplace_back(new PDFEditedPageContentElementPath(std::move(state), std::move(path), strokePath, fillPath));
+    m_contentElements.emplace_back(new PDFEditedPageContentElementPath(std::move(state), std::move(path), strokePath, fillPath, state.getCurrentTransformationMatrix()));
 }
 
-void PDFEditedPageContent::addContentImage(PDFPageContentProcessorState state, PDFObject imageObject, QImage image, QRectF boundingBox)
+void PDFEditedPageContent::addContentImage(PDFPageContentProcessorState state, PDFObject imageObject, QImage image)
 {
-    m_contentElements.emplace_back(new PDFEditedPageContentElementImage(std::move(state), std::move(imageObject), std::move(image), boundingBox));
+    m_contentElements.emplace_back(new PDFEditedPageContentElementImage(std::move(state), std::move(imageObject), std::move(image), state.getCurrentTransformationMatrix()));
 }
 
 void PDFEditedPageContent::addContentElement(std::unique_ptr<PDFEditedPageContentElement> element)
@@ -453,8 +451,9 @@ PDFEditedPageContentElement* PDFEditedPageContent::getBackElement() const
     return m_contentElements.back().get();
 }
 
-PDFEditedPageContentElement::PDFEditedPageContentElement(PDFPageContentProcessorState state) :
+PDFEditedPageContentElement::PDFEditedPageContentElement(PDFPageContentProcessorState state, QTransform transform) :
-    m_state(std::move(state))
+    m_state(std::move(state)),
+    m_transform(transform)
 {
 
 }
@@ -469,8 +468,18 @@ void PDFEditedPageContentElement::setState(const PDFPageContentProcessorState& n
     m_state = newState;
 }
 
-PDFEditedPageContentElementPath::PDFEditedPageContentElementPath(PDFPageContentProcessorState state, QPainterPath path, bool strokePath, bool fillPath) :
+QTransform PDFEditedPageContentElement::getTransform() const
-    PDFEditedPageContentElement(std::move(state)),
+{
+    return m_transform;
+}
+
+void PDFEditedPageContentElement::setTransform(const QTransform& newTransform)
+{
+    m_transform = newTransform;
+}
+
+PDFEditedPageContentElementPath::PDFEditedPageContentElementPath(PDFPageContentProcessorState state, QPainterPath path, bool strokePath, bool fillPath, QTransform transform) :
+    PDFEditedPageContentElement(std::move(state), transform),
     m_path(std::move(path)),
     m_strokePath(strokePath),
     m_fillPath(fillPath)
@@ -485,7 +494,7 @@ PDFEditedPageContentElement::Type PDFEditedPageContentElementPath::getType() con
 
 PDFEditedPageContentElementPath* PDFEditedPageContentElementPath::clone() const
 {
-    return new PDFEditedPageContentElementPath(getState(), getPath(), getStrokePath(), getFillPath());
+    return new PDFEditedPageContentElementPath(getState(), getPath(), getStrokePath(), getFillPath(), getTransform());
 }
 
 QRectF PDFEditedPageContentElementPath::getBoundingBox() const
@@ -524,11 +533,10 @@ void PDFEditedPageContentElementPath::setFillPath(bool newFillPath)
     m_fillPath = newFillPath;
 }
 
-PDFEditedPageContentElementImage::PDFEditedPageContentElementImage(PDFPageContentProcessorState state, PDFObject imageObject, QImage image, QRectF boundingBox) :
+PDFEditedPageContentElementImage::PDFEditedPageContentElementImage(PDFPageContentProcessorState state, PDFObject imageObject, QImage image, QTransform transform) :
-    PDFEditedPageContentElement(std::move(state)),
+    PDFEditedPageContentElement(std::move(state), transform),
     m_imageObject(std::move(imageObject)),
-    m_image(std::move(image)),
+    m_image(std::move(image))
-    m_boundingBox(boundingBox)
 {
 
 }
@@ -540,12 +548,12 @@ PDFEditedPageContentElement::Type PDFEditedPageContentElementImage::getType() co
 
 PDFEditedPageContentElementImage* PDFEditedPageContentElementImage::clone() const
 {
-    return new PDFEditedPageContentElementImage(getState(), getImageObject(), getImage(), getBoundingBox());
+    return new PDFEditedPageContentElementImage(getState(), getImageObject(), getImage(), getTransform());
 }
 
 QRectF PDFEditedPageContentElementImage::getBoundingBox() const
 {
-    return m_boundingBox;
+    return getTransform().mapRect(QRectF(0, 0, 1, 1));
 }
 
 PDFObject PDFEditedPageContentElementImage::getImageObject() const
@@ -568,8 +576,8 @@ void PDFEditedPageContentElementImage::setImage(const QImage& newImage)
     m_image = newImage;
 }
 
-PDFEditedPageContentElementText::PDFEditedPageContentElementText(PDFPageContentProcessorState state) :
+PDFEditedPageContentElementText::PDFEditedPageContentElementText(PDFPageContentProcessorState state, QTransform transform) :
-    PDFEditedPageContentElement(state)
+    PDFEditedPageContentElement(state, transform)
 {
 
 }
@@ -577,10 +585,9 @@ PDFEditedPageContentElementText::PDFEditedPageContentElementText(PDFPageContentP
 PDFEditedPageContentElementText::PDFEditedPageContentElementText(PDFPageContentProcessorState state,
                                                                  std::vector<Item> items,
                                                                  QPainterPath textPath,
-                                                                 QRectF boundingBox) :
+                                                                 QTransform transform) :
-    PDFEditedPageContentElement(state),
+    PDFEditedPageContentElement(state, transform),
     m_items(std::move(items)),
-    m_boundingBox(boundingBox),
     m_textPath(std::move(textPath))
 {
 
@@ -593,7 +600,7 @@ PDFEditedPageContentElement::Type PDFEditedPageContentElementText::getType() con
 
 PDFEditedPageContentElementText* PDFEditedPageContentElementText::clone() const
 {
-    return new PDFEditedPageContentElementText(getState(), getItems(), getTextPath(), getBoundingBox());
+    return new PDFEditedPageContentElementText(getState(), getItems(), getTextPath(), getTransform());
 }
 
 void PDFEditedPageContentElementText::addItem(Item item)
@@ -613,12 +620,7 @@ void PDFEditedPageContentElementText::setItems(const std::vector<Item>& newItems
 
 QRectF PDFEditedPageContentElementText::getBoundingBox() const
 {
-    return m_boundingBox;
+    return getTransform().mapRect(m_textPath.boundingRect());
-}
-
-void PDFEditedPageContentElementText::setBoundingBox(const QRectF& newBoundingBox)
-{
-    m_boundingBox = newBoundingBox;
 }
 
 QPainterPath PDFEditedPageContentElementText::getTextPath() const

Pdf4QtLibCore/sources/pdfpagecontenteditorprocessor.h

@@ -33,7 +33,7 @@ class PDF4QTLIBCORESHARED_EXPORT PDFEditedPageContentElement
 {
 public:
     PDFEditedPageContentElement() = default;
-    PDFEditedPageContentElement(PDFPageContentProcessorState state);
+    PDFEditedPageContentElement(PDFPageContentProcessorState state, QTransform transform);
     virtual ~PDFEditedPageContentElement() = default;
 
     enum class Type
@@ -60,14 +60,22 @@ public:
 
     virtual QRectF getBoundingBox() const = 0;
 
+    QTransform getTransform() const;
+    void setTransform(const QTransform& newTransform);
+
 protected:
     PDFPageContentProcessorState m_state;
+    QTransform m_transform;
 };
 
 class PDF4QTLIBCORESHARED_EXPORT PDFEditedPageContentElementPath : public PDFEditedPageContentElement
 {
 public:
-    PDFEditedPageContentElementPath(PDFPageContentProcessorState state, QPainterPath path, bool strokePath, bool fillPath);
+    PDFEditedPageContentElementPath(PDFPageContentProcessorState state,
+                                    QPainterPath path,
+                                    bool strokePath,
+                                    bool fillPath,
+                                    QTransform transform);
     virtual ~PDFEditedPageContentElementPath() = default;
 
     virtual Type getType() const override;
@@ -94,7 +102,10 @@ private:
 class PDF4QTLIBCORESHARED_EXPORT PDFEditedPageContentElementImage : public PDFEditedPageContentElement
 {
 public:
-    PDFEditedPageContentElementImage(PDFPageContentProcessorState state, PDFObject imageObject, QImage image, QRectF boundingBox);
+    PDFEditedPageContentElementImage(PDFPageContentProcessorState state,
+                                     PDFObject imageObject,
+                                     QImage image,
+                                     QTransform transform);
     virtual ~PDFEditedPageContentElementImage() = default;
 
     virtual Type getType() const override;
@@ -112,7 +123,6 @@ public:
 private:
     PDFObject m_imageObject;
     QImage m_image;
-    QRectF m_boundingBox;
 };
 
 class PDF4QTLIBCORESHARED_EXPORT PDFEditedPageContentElementText : public PDFEditedPageContentElement
@@ -128,11 +138,11 @@ public:
         PDFPageContentProcessorState state;
     };
 
-    PDFEditedPageContentElementText(PDFPageContentProcessorState state);
+    PDFEditedPageContentElementText(PDFPageContentProcessorState state, QTransform transform);
     PDFEditedPageContentElementText(PDFPageContentProcessorState state,
                                     std::vector<Item> items,
                                     QPainterPath textPath,
-                                    QRectF boundingBox);
+                                    QTransform transform);
     virtual ~PDFEditedPageContentElementText() = default;
 
     virtual Type getType() const override;
@@ -147,8 +157,6 @@ public:
 
     bool isEmpty() const { return m_items.empty(); }
 
-    void setBoundingBox(const QRectF& newBoundingBox);
-
     QPainterPath getTextPath() const;
     void setTextPath(QPainterPath newTextPath);
 
@@ -156,7 +164,6 @@ public:
 
 private:
     std::vector<Item> m_items;
-    QRectF m_boundingBox;
     QPainterPath m_textPath;
 };
 
@@ -174,7 +181,7 @@ public:
     static QString getOperandName(PDFPageContentProcessor::Operator operatorValue, int operandIndex);
 
     void addContentPath(PDFPageContentProcessorState state, QPainterPath path, bool strokePath, bool fillPath);
-    void addContentImage(PDFPageContentProcessorState state, PDFObject imageObject, QImage image, QRectF boundingBox);
+    void addContentImage(PDFPageContentProcessorState state, PDFObject imageObject, QImage image);
     void addContentClipping(PDFPageContentProcessorState state, QPainterPath path);
     void addContentElement(std::unique_ptr<PDFEditedPageContentElement> element);
 

Pdf4QtLibWidgets/sources/pdfpagecontenteditorediteditemsettings.cpp

@@ -67,7 +67,7 @@ void PDFPageContentEditorEditedItemSettings::loadFromElement(PDFPageContentEleme
         ui->plainTextEdit->setPlainText(text);
     }
 
-    QTransform matrix = editedElement->getElement()->getState().getCurrentTransformationMatrix();
+    QTransform matrix = editedElement->getElement()->getTransform();
     PDFTransformationDecomposition decomposedTransformation = PDFPainterHelper::decomposeTransform(matrix);
 
     ui->rotationAngleEdit->setValue(qRadiansToDegrees(decomposedTransformation.rotationAngle));
@@ -87,6 +87,17 @@ void PDFPageContentEditorEditedItemSettings::saveToElement(PDFPageContentElement
         imageElement->setImage(m_image);
         imageElement->setImageObject(PDFObject());
     }
+
+    PDFTransformationDecomposition decomposedTransformation;
+    decomposedTransformation.rotationAngle = ui->rotationAngleEdit->value();
+    decomposedTransformation.shearFactor = ui->shearFactorEdit->value();
+    decomposedTransformation.scaleX = ui->scaleInXEdit->value();
+    decomposedTransformation.scaleY = ui->scaleInYEdit->value();
+    decomposedTransformation.translateX = ui->translateInXEdit->value();
+    decomposedTransformation.translateY = ui->translateInYEdit->value();
+
+    QTransform transform = PDFPainterHelper::composeTransform(decomposedTransformation);
+    editedElement->getElement()->setTransform(transform);
 }
 
 static int PDF_gcd(int a, int b)

Pdf4QtLibWidgets/sources/pdfpagecontentelements.cpp

@@ -2549,7 +2549,10 @@ PDFPageContentElementEdited::~PDFPageContentElementEdited()
 
 PDFPageContentElementEdited* PDFPageContentElementEdited::clone() const
 {
-    return new PDFPageContentElementEdited(m_element.get());
+    PDFPageContentElementEdited* copy = new PDFPageContentElementEdited(m_element.get());
+    copy->setElementId(getElementId());
+    copy->setPageIndex(getPageIndex());
+    return copy;
 }
 
 void PDFPageContentElementEdited::drawPage(QPainter* painter,
@@ -2566,16 +2569,18 @@ void PDFPageContentElementEdited::drawPage(QPainter* painter,
     Q_UNUSED(layoutGetter);
     Q_UNUSED(errors);
 
-    QRectF rect = getBoundingBox();
+    QRectF clipRect = m_element->getBoundingBox();
     painter->setWorldTransform(QTransform(pagePointToDevicePointMatrix), true);
     painter->setPen(Qt::SolidLine);
     painter->setBrush(Qt::NoBrush);
     painter->setFont(QApplication::font());
     painter->setRenderHint(QPainter::Antialiasing);
-    painter->setClipRect(rect, Qt::IntersectClip);
+    painter->setClipRect(clipRect, Qt::IntersectClip);
+    painter->setTransform(m_element->getTransform(), true);
 
     if (const PDFEditedPageContentElementImage* imageElement = m_element->asImage())
     {
+        QRectF rect(0, 0, 1, 1);
         painter->translate(rect.bottomLeft());
         painter->scale(1.0, -1.0);
 
@@ -2591,7 +2596,6 @@ void PDFPageContentElementEdited::drawPage(QPainter* painter,
         const PDFPageContentProcessorState& state = m_element->getState();
         painter->setPen(pdf::PDFPainterHelper::createPenFromState(&state, state.getAlphaStroking()));
         painter->setBrush(pdf::PDFPainterHelper::createBrushFromState(&state, state.getAlphaFilling()));
-        painter->setTransform(pathElement->getState().getCurrentTransformationMatrix(), true);
         painter->drawPath(pathElement->getPath());
     }
 
@@ -2610,7 +2614,7 @@ uint PDFPageContentElementEdited::getManipulationMode(const QPointF& point, PDFR
 
     if (getBoundingBox().contains(point))
     {
-        return Select;
+        return Translate;
     }
 
     return None;
@@ -2618,8 +2622,23 @@ uint PDFPageContentElementEdited::getManipulationMode(const QPointF& point, PDFR
 
 void PDFPageContentElementEdited::performManipulation(uint mode, const QPointF& offset)
 {
-    Q_UNUSED(mode);
+    switch (mode)
-    Q_UNUSED(offset);
+    {
+    case None:
+        break;
+
+    case Translate:
+    {
+        QTransform transform = m_element->getTransform();
+        QTransform updatedTransform(transform.m11(), transform.m12(), transform.m21(), transform.m22(), transform.dx() + offset.x(), transform.dy() + offset.y());
+        m_element->setTransform(updatedTransform);
+        break;
+    }
+
+    default:
+        Q_ASSERT(false);
+        break;
+    }
 }
 
 QRectF PDFPageContentElementEdited::getBoundingBox() const

Pdf4QtLibWidgets/sources/pdfpagecontentelements.h

@@ -489,8 +489,8 @@ private:
 };
 
 class PDF4QTLIBWIDGETSSHARED_EXPORT PDFPageContentScene : public QObject,
-                                                   public IDocumentDrawInterface,
+                                                          public IDocumentDrawInterface,
-                                                   public IDrawWidgetInputInterface
+                                                          public IDrawWidgetInputInterface
 {
     Q_OBJECT