Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 759 insertions, 0 deletions

diff --git a/svx/qa/unit/svdraw.cxx b/svx/qa/unit/svdraw.cxx
new file mode 100644
index 0000000000..66f4528d88
--- /dev/null
+++ b/svx/qa/unit/svdraw.cxx
@@ -0,0 +1,759 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <test/unoapixml_test.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
+#include <com/sun/star/drawing/XDrawPage.hpp>
+#include <com/sun/star/text/XTextRange.hpp>
+#include <com/sun/star/drawing/FillStyle.hpp>
+#include <com/sun/star/drawing/LineStyle.hpp>
+#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
+#include <com/sun/star/drawing/HomogenMatrix3.hpp>
+
+#include <drawinglayer/tools/primitive2dxmldump.hxx>
+#include <rtl/ustring.hxx>
+#include <vcl/virdev.hxx>
+#include <svx/sdr/contact/displayinfo.hxx>
+#include <svx/sdr/contact/viewcontact.hxx>
+#include <svx/sdr/contact/viewobjectcontact.hxx>
+#include <svx/svdtrans.hxx>
+#include <svx/svdorect.hxx>
+#include <svx/unopage.hxx>
+#include <svx/svdview.hxx>
+#include <svx/xlineit0.hxx>
+#include <svx/xlnstwit.hxx>
+#include <comphelper/propertyvalue.hxx>
+#include <sfx2/viewsh.hxx>
+#include <svl/itempool.hxx>
+#include <svx/svdomedia.hxx>
+#include <vcl/filter/PDFiumLibrary.hxx>
+
+#include <sdr/contact/objectcontactofobjlistpainter.hxx>
+
+using namespace ::com::sun::star;
+
+namespace
+{
+/// Tests for svx/source/svdraw/ code.
+class SvdrawTest : public UnoApiXmlTest
+{
+public:
+    SvdrawTest()
+        : UnoApiXmlTest("svx/qa/unit/data/")
+    {
+    }
+
+protected:
+    SdrPage* getFirstDrawPageWithAssert();
+};
+
+SdrPage* SvdrawTest::getFirstDrawPageWithAssert()
+{
+    uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(mxComponent,
+                                                                   uno::UNO_QUERY_THROW);
+    CPPUNIT_ASSERT(xDrawPagesSupplier.is());
+    uno::Reference<drawing::XDrawPages> xDrawPages(xDrawPagesSupplier->getDrawPages());
+    uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPages->getByIndex(0), uno::UNO_QUERY_THROW);
+    CPPUNIT_ASSERT(xDrawPage.is());
+
+    auto pDrawPage = dynamic_cast<SvxDrawPage*>(xDrawPage.get());
+    CPPUNIT_ASSERT(pDrawPage);
+    return pDrawPage->GetSdrPage();
+}
+
+xmlDocUniquePtr lcl_dumpAndParseFirstObjectWithAssert(SdrPage* pSdrPage)
+{
+    ScopedVclPtrInstance<VirtualDevice> aVirtualDevice;
+    sdr::contact::ObjectContactOfObjListPainter aObjectContact(*aVirtualDevice,
+                                                               { pSdrPage->GetObj(0) }, nullptr);
+    const auto& rDrawPageVOContact
+        = pSdrPage->GetViewContact().GetViewObjectContact(aObjectContact);
+    sdr::contact::DisplayInfo aDisplayInfo;
+    drawinglayer::primitive2d::Primitive2DContainer xPrimitiveSequence;
+    rDrawPageVOContact.getPrimitive2DSequenceHierarchy(aDisplayInfo, xPrimitiveSequence);
+
+    drawinglayer::Primitive2dXmlDump aDumper;
+    xmlDocUniquePtr pXmlDoc = aDumper.dumpAndParse(xPrimitiveSequence);
+    CPPUNIT_ASSERT(pXmlDoc);
+    return pXmlDoc;
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testSemiTransparentText)
+{
+    // Create a new Draw document with a rectangle.
+    mxComponent = loadFromDesktop("private:factory/sdraw");
+    uno::Reference<lang::XMultiServiceFactory> xFactory(mxComponent, uno::UNO_QUERY);
+    uno::Reference<drawing::XShape> xShape(
+        xFactory->createInstance("com.sun.star.drawing.RectangleShape"), uno::UNO_QUERY);
+    xShape->setSize(awt::Size(10000, 10000));
+    xShape->setPosition(awt::Point(1000, 1000));
+
+    uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(mxComponent, uno::UNO_QUERY);
+    uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPagesSupplier->getDrawPages()->getByIndex(0),
+                                                 uno::UNO_QUERY);
+    xDrawPage->add(xShape);
+
+    // Add semi-transparent text on the rectangle.
+    uno::Reference<text::XTextRange> xShapeText(xShape, uno::UNO_QUERY);
+    xShapeText->getText()->setString("hello");
+
+    uno::Reference<beans::XPropertySet> xShapeProperties(xShape, uno::UNO_QUERY);
+    xShapeProperties->setPropertyValue("CharColor", uno::Any(COL_RED));
+    sal_Int16 nTransparence = 75;
+    xShapeProperties->setPropertyValue("CharTransparence", uno::Any(nTransparence));
+
+    // Generates drawinglayer primitives for the page.
+    auto pDrawPage = dynamic_cast<SvxDrawPage*>(xDrawPage.get());
+    CPPUNIT_ASSERT(pDrawPage);
+    SdrPage* pSdrPage = pDrawPage->GetSdrPage();
+    xmlDocUniquePtr pDocument = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+    // Make sure the text is semi-transparent.
+    // Without the accompanying fix in place, this test would have failed with:
+    // - Expected: 1
+    // - Actual  : 0
+    // - XPath '//unifiedtransparence' number of nodes is incorrect
+    // i.e. the text was just plain red, not semi-transparent.
+    sal_Int16 fTransparence
+        = getXPath(pDocument, "//unifiedtransparence"_ostr, "transparence"_ostr).toInt32();
+    CPPUNIT_ASSERT_EQUAL(nTransparence, fTransparence);
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testHandlePathObjScale)
+{
+    // Given a path object:
+    mxComponent = loadFromDesktop("private:factory/sdraw");
+    uno::Reference<lang::XMultiServiceFactory> xFactory(mxComponent, uno::UNO_QUERY);
+    uno::Reference<drawing::XShape> xShape(
+        xFactory->createInstance("com.sun.star.drawing.ClosedBezierShape"), uno::UNO_QUERY);
+
+    // When setting its scale by both using setSize() and scaling in a transform matrix:
+    // Set size and basic properties.
+    xShape->setPosition(awt::Point(2512, 6062));
+    xShape->setSize(awt::Size(112, 112));
+    uno::Reference<beans::XPropertySet> xShapeProps(xShape, uno::UNO_QUERY);
+    xShapeProps->setPropertyValue("FillStyle", uno::Any(drawing::FillStyle_SOLID));
+    xShapeProps->setPropertyValue("LineStyle", uno::Any(drawing::LineStyle_SOLID));
+    xShapeProps->setPropertyValue("FillColor", uno::Any(static_cast<sal_Int32>(0)));
+    // Add it to the draw page.
+    uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(mxComponent, uno::UNO_QUERY);
+    uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPagesSupplier->getDrawPages()->getByIndex(0),
+                                                 uno::UNO_QUERY);
+    xDrawPage->add(xShape);
+    // Set polygon coordinates.
+    drawing::PolyPolygonBezierCoords aPolyPolygonBezierCoords;
+    aPolyPolygonBezierCoords.Coordinates = {
+        {
+            awt::Point(2624, 6118),
+            awt::Point(2624, 6087),
+            awt::Point(2599, 6062),
+            awt::Point(2568, 6062),
+            awt::Point(2537, 6062),
+            awt::Point(2512, 6087),
+            awt::Point(2512, 6118),
+            awt::Point(2512, 6149),
+            awt::Point(2537, 6175),
+            awt::Point(2568, 6174),
+            awt::Point(2599, 6174),
+            awt::Point(2625, 6149),
+            awt::Point(2624, 6118),
+        },
+    };
+    aPolyPolygonBezierCoords.Flags = {
+        {
+            drawing::PolygonFlags_NORMAL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_NORMAL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_NORMAL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_NORMAL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_CONTROL,
+            drawing::PolygonFlags_NORMAL,
+        },
+    };
+    xShapeProps->setPropertyValue("PolyPolygonBezier", uno::Any(aPolyPolygonBezierCoords));
+    drawing::HomogenMatrix3 aMatrix;
+    aMatrix.Line1.Column1 = 56;
+    aMatrix.Line2.Column1 = -97;
+    aMatrix.Line3.Column1 = 0;
+    aMatrix.Line1.Column2 = 97;
+    aMatrix.Line2.Column2 = 56;
+    aMatrix.Line3.Column2 = 0;
+    aMatrix.Line1.Column3 = 3317;
+    aMatrix.Line2.Column3 = 5583;
+    aMatrix.Line3.Column3 = 1;
+    xShapeProps->setPropertyValue("Transformation", uno::Any(aMatrix));
+
+    // Then make sure the scaling is only applied once:
+    // Without the accompanying fix in place, this test would have failed with:
+    // - Expected: 113
+    // - Actual  : 12566
+    // i.e. the scaling was applied twice.
+    CPPUNIT_ASSERT_EQUAL(static_cast<sal_Int32>(113), xShape->getSize().Width);
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testTextEditEmptyGrabBag)
+{
+    // Given a document with a groupshape, which has 2 children.
+    mxComponent = loadFromDesktop("private:factory/sdraw");
+    uno::Reference<lang::XMultiServiceFactory> xFactory(mxComponent, uno::UNO_QUERY);
+    uno::Reference<drawing::XShape> xRect1(
+        xFactory->createInstance("com.sun.star.drawing.RectangleShape"), uno::UNO_QUERY);
+    xRect1->setPosition(awt::Point(1000, 1000));
+    xRect1->setSize(awt::Size(10000, 10000));
+    uno::Reference<drawing::XShape> xRect2(
+        xFactory->createInstance("com.sun.star.drawing.RectangleShape"), uno::UNO_QUERY);
+    xRect2->setPosition(awt::Point(1000, 1000));
+    xRect2->setSize(awt::Size(10000, 10000));
+    uno::Reference<drawing::XShapes> xGroup(
+        xFactory->createInstance("com.sun.star.drawing.GroupShape"), uno::UNO_QUERY);
+    uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(mxComponent, uno::UNO_QUERY);
+    uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPagesSupplier->getDrawPages()->getByIndex(0),
+                                                 uno::UNO_QUERY);
+    uno::Reference<drawing::XShape> xGroupShape(xGroup, uno::UNO_QUERY);
+    xDrawPage->add(xGroupShape);
+    xGroup->add(xRect1);
+    xGroup->add(xRect2);
+    uno::Reference<text::XTextRange> xRect2Text(xRect2, uno::UNO_QUERY);
+    xRect2Text->setString("x");
+    uno::Sequence<beans::PropertyValue> aGrabBag = {
+        comphelper::makePropertyValue("OOXLayout", true),
+    };
+    uno::Reference<beans::XPropertySet> xGroupProps(xGroup, uno::UNO_QUERY);
+    xGroupProps->setPropertyValue("InteropGrabBag", uno::Any(aGrabBag));
+
+    // When editing the shape text of the 2nd rectangle (insert a char at the start).
+    SfxViewShell* pViewShell = SfxViewShell::Current();
+    SdrView* pSdrView = pViewShell->GetDrawView();
+    SdrObject* pObject = SdrObject::getSdrObjectFromXShape(xRect2);
+    pSdrView->SdrBeginTextEdit(pObject);
+    EditView& rEditView = pSdrView->GetTextEditOutlinerView()->GetEditView();
+    rEditView.InsertText("y");
+    pSdrView->SdrEndTextEdit();
+
+    // Then make sure that grab-bag is empty to avoid losing the new text.
+    xGroupProps->getPropertyValue("InteropGrabBag") >>= aGrabBag;
+    // Without the accompanying fix in place, this test would have failed with:
+    // assertion failed
+    // - Expression: !aGrabBag.hasElements()
+    // i.e. the grab-bag was still around after modifying the shape, and that grab-bag contained the
+    // old text.
+    CPPUNIT_ASSERT(!aGrabBag.hasElements());
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testRectangleObject)
+{
+    std::unique_ptr<SdrModel> pModel(new SdrModel(nullptr, nullptr, true));
+    pModel->GetItemPool().FreezeIdRanges();
+
+    rtl::Reference<SdrPage> pPage(new SdrPage(*pModel, false));
+    pPage->SetSize(Size(1000, 1000));
+    pModel->InsertPage(pPage.get(), 0);
+
+    tools::Rectangle aSize(Point(), Size(100, 100));
+    rtl::Reference<SdrRectObj> pRectangle = new SdrRectObj(*pModel, aSize);
+    pPage->NbcInsertObject(pRectangle.get());
+    pRectangle->SetMergedItem(XLineStyleItem(drawing::LineStyle_SOLID));
+    pRectangle->SetMergedItem(XLineStartWidthItem(200));
+
+    ScopedVclPtrInstance<VirtualDevice> aVirtualDevice;
+    aVirtualDevice->SetOutputSize(Size(2000, 2000));
+
+    SdrView aView(*pModel, aVirtualDevice);
+    aView.hideMarkHandles();
+    aView.ShowSdrPage(pPage.get());
+
+    sdr::contact::ObjectContactOfObjListPainter aObjectContact(*aVirtualDevice,
+                                                               { pPage->GetObj(0) }, nullptr);
+    const sdr::contact::ViewObjectContact& rDrawPageVOContact
+        = pPage->GetViewContact().GetViewObjectContact(aObjectContact);
+
+    sdr::contact::DisplayInfo aDisplayInfo;
+    drawinglayer::primitive2d::Primitive2DContainer xPrimitiveSequence;
+    rDrawPageVOContact.getPrimitive2DSequenceHierarchy(aDisplayInfo, xPrimitiveSequence);
+
+    drawinglayer::Primitive2dXmlDump aDumper;
+    xmlDocUniquePtr pXmlDoc = aDumper.dumpAndParse(xPrimitiveSequence);
+
+    assertXPath(pXmlDoc, "/primitive2D"_ostr, 1);
+
+    OString aBasePath("/primitive2D/sdrrectangle/polypolygoncolor"_ostr);
+    assertXPath(pXmlDoc, aBasePath, "color"_ostr, "#729fcf");
+
+    assertXPath(pXmlDoc, aBasePath + "/polypolygon", "height"_ostr,
+                "99"); // weird Rectangle is created with size 100
+    assertXPath(pXmlDoc, aBasePath + "/polypolygon", "width"_ostr, "99");
+    assertXPath(pXmlDoc, aBasePath + "/polypolygon", "minx"_ostr, "0");
+    assertXPath(pXmlDoc, aBasePath + "/polypolygon", "miny"_ostr, "0");
+    assertXPath(pXmlDoc, aBasePath + "/polypolygon", "maxx"_ostr, "99");
+    assertXPath(pXmlDoc, aBasePath + "/polypolygon", "maxy"_ostr, "99");
+
+    aBasePath = "/primitive2D/sdrrectangle/polypolygoncolor/polypolygon/polygon"_ostr;
+
+    assertXPath(pXmlDoc, aBasePath + "/point", 5);
+    assertXPath(pXmlDoc, aBasePath + "/point[1]", "x"_ostr, "49.5"); // hmm, weird, why?
+    assertXPath(pXmlDoc, aBasePath + "/point[1]", "y"_ostr, "99");
+    assertXPath(pXmlDoc, aBasePath + "/point[2]", "x"_ostr, "0");
+    assertXPath(pXmlDoc, aBasePath + "/point[2]", "y"_ostr, "99");
+    assertXPath(pXmlDoc, aBasePath + "/point[3]", "x"_ostr, "0");
+    assertXPath(pXmlDoc, aBasePath + "/point[3]", "y"_ostr, "0");
+    assertXPath(pXmlDoc, aBasePath + "/point[4]", "x"_ostr, "99");
+    assertXPath(pXmlDoc, aBasePath + "/point[4]", "y"_ostr, "0");
+    assertXPath(pXmlDoc, aBasePath + "/point[5]", "x"_ostr, "99");
+    assertXPath(pXmlDoc, aBasePath + "/point[5]", "y"_ostr, "99");
+
+    aBasePath = "/primitive2D/sdrrectangle/polygonstroke"_ostr;
+    assertXPath(pXmlDoc, aBasePath, 1);
+
+    assertXPath(pXmlDoc, aBasePath + "/line", "color"_ostr, "#3465a4");
+    assertXPath(pXmlDoc, aBasePath + "/line", "width"_ostr, "0");
+    assertXPath(pXmlDoc, aBasePath + "/line", "linejoin"_ostr, "Round");
+    assertXPath(pXmlDoc, aBasePath + "/line", "linecap"_ostr, "BUTT");
+
+    assertXPathContent(pXmlDoc, aBasePath + "/polygon", "49.5,99 0,99 0,0 99,0 99,99");
+
+    // If solid line, then there is no line stroke information
+    assertXPath(pXmlDoc, aBasePath + "/stroke", 0);
+
+    pPage->RemoveObject(0);
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testAutoHeightMultiColShape)
+{
+    // Given a document containing a shape that has:
+    // 1) automatic height (resize shape to fix text)
+    // 2) multiple columns (2)
+    loadFromFile(u"auto-height-multi-col-shape.pptx");
+
+    // Make sure the in-file shape height is kept, even if nominally the shape height is
+    // automatic:
+    uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(mxComponent, uno::UNO_QUERY);
+    uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPagesSupplier->getDrawPages()->getByIndex(0),
+                                                 uno::UNO_QUERY);
+    uno::Reference<drawing::XShape> xShape(xDrawPage->getByIndex(0), uno::UNO_QUERY);
+    // Without the accompanying fix in place, this test would have failed with:
+    // - Expected: 6882
+    // - Actual  : 3452
+    // i.e. the shape height was smaller than expected, leading to a 2 columns layout instead of
+    // laying out all the text in the first column.
+    // 2477601 is from slide1.xml, <a:ext cx="4229467" cy="2477601"/>.
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(
+        static_cast<sal_Int32>(o3tl::convert(2477601, o3tl::Length::emu, o3tl::Length::mm100)),
+        xShape->getSize().Height, 1);
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testFontWorks)
+{
+    loadFromFile(u"FontWork.odg");
+
+    uno::Reference<drawing::XDrawPagesSupplier> xDrawPagesSupplier(mxComponent,
+                                                                   uno::UNO_QUERY_THROW);
+    CPPUNIT_ASSERT(xDrawPagesSupplier.is());
+    uno::Reference<drawing::XDrawPages> xDrawPages(xDrawPagesSupplier->getDrawPages());
+    uno::Reference<drawing::XDrawPage> xDrawPage(xDrawPages->getByIndex(0), uno::UNO_QUERY_THROW);
+    CPPUNIT_ASSERT(xDrawPage.is());
+    uno::Reference<drawing::XShape> xShape(xDrawPage->getByIndex(0), uno::UNO_QUERY);
+    CPPUNIT_ASSERT(xShape.is());
+
+    auto pDrawPage = dynamic_cast<SvxDrawPage*>(xDrawPage.get());
+    CPPUNIT_ASSERT(pDrawPage);
+    SdrPage* pSdrPage = pDrawPage->GetSdrPage();
+    xmlDocUniquePtr pXmlDoc = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+    assertXPath(pXmlDoc, "/primitive2D"_ostr, 1);
+
+    assertXPath(pXmlDoc, "//scene"_ostr, "projectionMode"_ostr, "Perspective");
+    assertXPath(pXmlDoc, "//scene/extrude3D[1]/fill"_ostr, "color"_ostr, "#ff0000");
+    assertXPath(pXmlDoc, "//scene/extrude3D[1]/object3Dattributes/material"_ostr, "color"_ostr,
+                "#ff0000");
+    // ODF default 50% is represented by Specular Intensity = 2^5. The relationship is not linear.
+    assertXPath(pXmlDoc, "//scene/extrude3D[1]/object3Dattributes/material"_ostr,
+                "specularIntensity"_ostr, "32");
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testTdf148000_EOLinCurvedText)
+{
+    std::vector<OUString> aFilenames
+        = { u"tdf148000_EOLinCurvedText.pptx"_ustr, u"tdf148000_EOLinCurvedText_New.odp"_ustr,
+            u"tdf148000_EOLinCurvedText_Legacy.odp"_ustr };
+
+    for (int i = 0; i < 3; i++)
+    {
+        loadFromFile(aFilenames[i]);
+
+        SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+
+        xmlDocUniquePtr pXmlDoc = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+        // this is a group shape, hence 2 nested objectinfo
+        OString aBasePath = "/primitive2D/objectinfo[4]/objectinfo/unhandled/unhandled/"
+                            "polypolygoncolor/polypolygon/"_ostr;
+
+        // The text is: "O" + eop + "O" + eol + "O"
+        // It should be displayed as 3 line of text. (1 "O" letter in every line)
+        sal_Int32 nY1 = getXPath(pXmlDoc, aBasePath + "polygon[1]/point[1]", "y"_ostr).toInt32();
+        sal_Int32 nY2 = getXPath(pXmlDoc, aBasePath + "polygon[3]/point[1]", "y"_ostr).toInt32();
+        sal_Int32 nY3 = getXPath(pXmlDoc, aBasePath + "polygon[5]/point[1]", "y"_ostr).toInt32();
+
+        sal_Int32 nDiff21 = nY2 - nY1;
+        sal_Int32 nDiff32 = nY3 - nY2;
+
+        // the 2. "O" must be positioned much lower as the 1. "O". (the eop break the line)
+        CPPUNIT_ASSERT_GREATER(sal_Int32(300), nDiff21);
+        if (i < 2)
+        {
+            // the 3. "O" must be positioned even lower with 1 line. (the eol must break the line as well)
+            CPPUNIT_ASSERT_LESS(sal_Int32(50), abs(nDiff32 - nDiff21));
+        }
+        else
+        {
+            // In legacy mode, the 3. "O" must be positioned about the same high as the 2. "O"
+            // the eol not break the line.
+            CPPUNIT_ASSERT_LESS(sal_Int32(50), nDiff32);
+        }
+    }
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testTdf148000_CurvedTextWidth)
+{
+    std::vector<OUString> aFilenames
+        = { u"tdf148000_CurvedTextWidth.pptx"_ustr, u"tdf148000_CurvedTextWidth_New.odp"_ustr,
+            u"tdf148000_CurvedTextWidth_Legacy.odp"_ustr };
+
+    for (int i = 0; i < 3; i++)
+    {
+        loadFromFile(aFilenames[i]);
+
+        SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+
+        xmlDocUniquePtr pXmlDoc = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+        OString aBasePath = "/primitive2D/objectinfo[4]/objectinfo/unhandled/unhandled/"
+                            "polypolygoncolor/polypolygon/"_ostr;
+
+        // The text is: 7 line od "OOOOOOO"
+        // Take the x coord of the 4 "O" on the corners
+        sal_Int32 nX1 = getXPath(pXmlDoc, aBasePath + "polygon[1]/point[1]", "x"_ostr).toInt32();
+        sal_Int32 nX2 = getXPath(pXmlDoc, aBasePath + "polygon[13]/point[1]", "x"_ostr).toInt32();
+        sal_Int32 nX3 = getXPath(pXmlDoc, aBasePath + "polygon[85]/point[1]", "x"_ostr).toInt32();
+        sal_Int32 nX4 = getXPath(pXmlDoc, aBasePath + "polygon[97]/point[1]", "x"_ostr).toInt32();
+
+        if (i < 2)
+        {
+            // All the lines should be positioned similar (start/end is similar)
+            CPPUNIT_ASSERT_LESS(sal_Int32(150), abs(nX3 - nX1));
+            CPPUNIT_ASSERT_LESS(sal_Int32(150), abs(nX4 - nX2));
+        }
+        else
+        {
+            // In legacy mode, the outer lines become much wider
+            CPPUNIT_ASSERT_GREATER(sal_Int32(1500), nX3 - nX1);
+            CPPUNIT_ASSERT_GREATER(sal_Int32(1500), nX2 - nX4);
+        }
+    }
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testSurfaceMetal)
+{
+    loadFromFile(u"tdf140321_metal.odp");
+
+    SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+
+    xmlDocUniquePtr pXmlDoc = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+    // ODF specifies for metal = true specular color as rgb(200,200,200) and adding 15 to specularity
+    // Together with extrusion-first-light-level 67% and extrusion-specularity 80% factor is
+    // 0.67*0.8 * 200/255 = 0.42 and color #6b6b6b
+    assertXPath(pXmlDoc, "(//material)[1]"_ostr, "specular"_ostr, "#6b6b6b");
+    // 3D specularIntensity = 2^(50/10) + 15 = 47, with default extrusion-shininess 50%
+    assertXPath(pXmlDoc, "(//material)[1]"_ostr, "specularIntensity"_ostr, "47");
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testExtrusionPhong)
+{
+    loadFromFile(u"tdf140321_phong.odp");
+
+    SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+
+    xmlDocUniquePtr pXmlDoc = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+    // The rendering method and normals kind were always 'Flat' without the patch.
+    assertXPath(pXmlDoc, "//scene"_ostr, "shadeMode"_ostr, "Phong");
+    assertXPath(pXmlDoc, "//object3Dattributes"_ostr, "normalsKind"_ostr, "Specific");
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testSurfaceMattePPT)
+{
+    loadFromFile(u"tdf140321_Matte_import.ppt");
+
+    SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+
+    xmlDocUniquePtr pXmlDoc = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+    // The preset 'matte' sets the specularity of material to 0. But that alone does not make the
+    // rendering 'matte' in LO. To get a 'matte' effect in LO, specularity of the light need to be
+    // false in addition. To get this, first light is set off and values from first light are copied
+    // to forth light, as only first light is specular. Because first and third lights are off, the
+    // forth light is the second one in the dump. The gray color corresponding to
+    // FirstLightLevel = 38000/2^16 is #949494.
+    assertXPath(pXmlDoc, "(//material)[1]"_ostr, "specular"_ostr, "#000000");
+    assertXPath(pXmlDoc, "(//light)[2]"_ostr, "color"_ostr, "#949494");
+    // To make the second light soft, part of its intensity is moved to lights 5,6,7 and 8.
+    assertXPath(pXmlDoc, "(//light)[1]"_ostr, "color"_ostr, "#1e1e1e");
+    assertXPath(pXmlDoc, "(//light)[3]"_ostr, "color"_ostr, "#3b3b3b");
+    // The 3D property specularIntensity is not related to 'extrusion-specularity' but to
+    // 'extrusion-shininess'. specularIntensity = 2^(shininess/10), here default 32.
+    assertXPath(pXmlDoc, "(//material)[1]"_ostr, "specularIntensity"_ostr, "32");
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testMaterialSpecular)
+{
+    loadFromFile(u"tdf140321_material_specular.odp");
+
+    SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+
+    xmlDocUniquePtr pXmlDoc = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+    CPPUNIT_ASSERT(pXmlDoc);
+
+    // 3D specular color is derived from properties 'extrusion-specularity' and 'extrusion-first-light
+    // -level'. 3D specularIntensity is derived from property 'draw:extrusion-shininess'. Both are
+    // object properties, not scene properties. Those were wrong in various forms before the patch.
+    // Specularity = 77% * first-light-level 67% = 0.5159, which corresponds to gray color #848484.
+    assertXPath(pXmlDoc, "(//material)[1]"_ostr, "specular"_ostr, "#848484");
+    // extrusion-shininess 50% corresponds to 3D specularIntensity 32, use 2^(50/10).
+    assertXPath(pXmlDoc, "(//material)[1]"_ostr, "specularIntensity"_ostr, "32");
+    // extrusion-first-light-level 67% corresponds to gray color #ababab, use 255 * 0.67.
+    assertXPath(pXmlDoc, "(//light)[1]"_ostr, "color"_ostr, "#ababab");
+    // The first light is harsh, the second light soft. So the 3D scene should have 6 lights (1+1+4).
+    assertXPath(pXmlDoc, "//light"_ostr, 6);
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testVideoSnapshot)
+{
+    // Given a slide with a media shape, containing a 4 sec video, red-green-blue-black being the 4
+    // seconds:
+    loadFromFile(u"video-snapshot.pptx");
+    SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+    auto pSdrMediaObj = dynamic_cast<SdrMediaObj*>(pSdrPage->GetObj(0));
+
+    // When getting the red snapshot of the video:
+    Graphic aSnapshot(pSdrMediaObj->getSnapshot());
+
+    // Then make sure the color is correct:
+    const BitmapEx& rBitmap = aSnapshot.GetBitmapExRef();
+    // Without the accompanying fix in place, this test would have failed with:
+    // - Expected: rgba[ff0000ff]
+    // - Actual  : rgba[000000ff]
+    // i.e. the preview was black, not ~red; since we seeked 3 secs into the video, while PowerPoint
+    // doesn't do that.
+    CPPUNIT_ASSERT_EQUAL(Color(0xfe, 0x0, 0x0), rBitmap.GetPixelColor(0, 0));
+
+    // Without the accompanying fix in place, this test would have failed with:
+    // - Expected: 321
+    // - Actual  : 640
+    // i.e. ~25% crop from left and right should result in half width, but it was not reduced.
+    CPPUNIT_ASSERT_EQUAL(static_cast<tools::Long>(321), rBitmap.GetSizePixel().getWidth());
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testPageViewDrawLayerClip)
+{
+    // Given a document with 2 pages, first page footer has an off-page line shape:
+    loadFromFile(u"page-view-draw-layer-clip.docx");
+
+    // When saving that document to PDF:
+    save("writer_pdf_Export");
+
+    // Then make sure that line shape gets clipped:
+    std::unique_ptr<vcl::pdf::PDFiumDocument> pDoc = parsePDFExport();
+    if (!pDoc)
+    {
+        return;
+    }
+    std::unique_ptr<vcl::pdf::PDFiumPage> pPage1 = pDoc->openPage(0);
+    CPPUNIT_ASSERT_EQUAL(3, pPage1->getObjectCount());
+    std::unique_ptr<vcl::pdf::PDFiumPage> pPage2 = pDoc->openPage(1);
+    // Without the accompanying fix in place, this test would have failed with:
+    // - Expected: 2
+    // - Actual  : 3
+    // i.e. the 2nd page had a line shape from the first page's footer.
+    CPPUNIT_ASSERT_EQUAL(2, pPage2->getObjectCount());
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testRectangleObjectMove)
+{
+    std::unique_ptr<SdrModel> pModel(new SdrModel(nullptr, nullptr, true));
+    pModel->GetItemPool().FreezeIdRanges();
+
+    rtl::Reference<SdrPage> pPage(new SdrPage(*pModel, false));
+    pPage->SetSize(Size(50000, 50000));
+    pModel->InsertPage(pPage.get(), 0);
+
+    tools::Rectangle aRect(Point(), Size(100, 100));
+    rtl::Reference<SdrRectObj> pRectangleObject = new SdrRectObj(*pModel, aRect);
+    pPage->NbcInsertObject(pRectangleObject.get());
+
+    CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(), Size(100, 100)),
+                         pRectangleObject->GetLogicRect());
+    pRectangleObject->NbcMove({ 100, 100 });
+    CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(100, 100), Size(100, 100)),
+                         pRectangleObject->GetLogicRect());
+
+    pPage->RemoveObject(0);
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testRectangleObjectRotate)
+{
+    std::unique_ptr<SdrModel> pModel(new SdrModel(nullptr, nullptr, true));
+    pModel->GetItemPool().FreezeIdRanges();
+
+    rtl::Reference<SdrPage> pPage(new SdrPage(*pModel, false));
+    pPage->SetSize(Size(50000, 50000));
+    pModel->InsertPage(pPage.get(), 0);
+
+    {
+        tools::Rectangle aObjectSize(Point(), Size(100, 100));
+        rtl::Reference<SdrRectObj> pRectangleObject = new SdrRectObj(*pModel, aObjectSize);
+        pPage->NbcInsertObject(pRectangleObject.get());
+
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(0, 0), Size(100, 100)),
+                             pRectangleObject->GetLogicRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(0, 0), Size(100, 100)),
+                             pRectangleObject->GetSnapRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(-1, -1), Size(102, 102)),
+                             pRectangleObject->GetCurrentBoundRect());
+
+        auto angle = 9000_deg100;
+        double angleRadians = toRadians(angle);
+        pRectangleObject->NbcRotate(aObjectSize.Center(), angle, std::sin(angleRadians),
+                                    std::cos(angleRadians));
+
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(0, 98), Size(100, 100)),
+                             pRectangleObject->GetLogicRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(0, -1), Size(100, 100)),
+                             pRectangleObject->GetSnapRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(-1, -2), Size(102, 102)),
+                             pRectangleObject->GetCurrentBoundRect());
+
+        pPage->RemoveObject(0);
+    }
+
+    {
+        tools::Rectangle aObjectSize(Point(), Size(100, 100));
+        rtl::Reference<SdrRectObj> pRectangleObject = new SdrRectObj(*pModel, aObjectSize);
+        pPage->NbcInsertObject(pRectangleObject.get());
+
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(0, 0), Size(100, 100)),
+                             pRectangleObject->GetLogicRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(0, 0), Size(100, 100)),
+                             pRectangleObject->GetSnapRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(-1, -1), Size(102, 102)),
+                             pRectangleObject->GetCurrentBoundRect());
+
+        auto angle = -4500_deg100;
+        double angleRadians = toRadians(angle);
+        pRectangleObject->NbcRotate(aObjectSize.Center(), angle, std::sin(angleRadians),
+                                    std::cos(angleRadians));
+
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(49, -20), Size(100, 100)),
+                             pRectangleObject->GetLogicRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(-21, -20), Size(141, 141)),
+                             pRectangleObject->GetSnapRect());
+        CPPUNIT_ASSERT_EQUAL(tools::Rectangle(Point(-22, -21), Size(143, 143)),
+                             pRectangleObject->GetCurrentBoundRect());
+
+        pPage->RemoveObject(0);
+    }
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testRotatePoint)
+{
+    {
+        auto angle = 18000_deg100;
+        double angleRadians = toRadians(angle);
+        Point aPoint(2000, 1000);
+        Point aReference(1000, 1000);
+        RotatePoint(aPoint, aReference, std::sin(angleRadians), std::cos(angleRadians));
+
+        CPPUNIT_ASSERT_EQUAL(Point(0, 1000), aPoint);
+    }
+
+    {
+        auto angle = 9000_deg100;
+        double angleRadians = toRadians(angle);
+        Point aPoint(2000, 1000);
+        Point aReference(1000, 1000);
+        RotatePoint(aPoint, aReference, std::sin(angleRadians), std::cos(angleRadians));
+
+        CPPUNIT_ASSERT_EQUAL(Point(1000, 0), aPoint);
+    }
+
+    {
+        auto angle = 18000_deg100;
+        double angleRadians = toRadians(angle);
+        Point aPoint(100, 100);
+        Point aReference(200, 200);
+        RotatePoint(aPoint, aReference, std::sin(angleRadians), std::cos(angleRadians));
+
+        CPPUNIT_ASSERT_EQUAL(Point(300, 300), aPoint);
+    }
+}
+
+CPPUNIT_TEST_FIXTURE(SvdrawTest, testClipVerticalTextOverflow)
+{
+    // File contains a slide with 4 rectangle shapes with text inside
+    // each have <a:bodyPr vertOverflow="clip">
+    // 1-) Text overflowing the rectangle
+    // 2-) Text not overflowing the rectangle
+    // 3-) (Vertical text) Text overflowing the rectangle
+    // 4-) (Vertical text) Text not overflowing the rectangle
+    loadFromFile(u"clip-vertical-overflow.pptx");
+
+    SdrPage* pSdrPage = getFirstDrawPageWithAssert();
+    xmlDocUniquePtr pDocument = lcl_dumpAndParseFirstObjectWithAssert(pSdrPage);
+
+    // Test vertically overflowing text
+    // Without the accompanying fix in place, this test would have failed with:
+    // equality assertion failed
+    // - Expected: 6
+    // - Actual  : 13
+    // - In <>, XPath contents of child does not match
+    // i.e. the vertically overflowing text wasn't clipped & overflowing text
+    // was drawn anyways.
+    assertXPathContent(pDocument, "count((//sdrblocktext)[4]//textsimpleportion)"_ostr, "6");
+
+    // make sure text is aligned correctly after the overflowing text is clipped
+    assertXPath(pDocument, "((//sdrblocktext)[4]//textsimpleportion)[1]"_ostr, "y"_ostr, "3749");
+    assertXPath(pDocument, "((//sdrblocktext)[4]//textsimpleportion)[6]"_ostr, "y"_ostr, "7559");
+
+    // make sure the text that isn't overflowing is still aligned properly
+    assertXPathContent(pDocument, "count((//sdrblocktext)[5]//textsimpleportion)"_ostr, "3");
+    assertXPath(pDocument, "((//sdrblocktext)[5]//textsimpleportion)[1]"_ostr, "y"_ostr, "5073");
+    assertXPath(pDocument, "((//sdrblocktext)[5]//textsimpleportion)[3]"_ostr, "y"_ostr, "6597");
+
+    // Test vertically overflowing text, with vertical text direction
+    assertXPathContent(pDocument, "count((//sdrblocktext)[6]//textsimpleportion)"_ostr, "12");
+    // make sure text is aligned correctly after the overflowing text is clipped
+    assertXPath(pDocument, "((//sdrblocktext)[6]//textsimpleportion)[1]"_ostr, "x"_ostr, "13093");
+    assertXPath(pDocument, "((//sdrblocktext)[6]//textsimpleportion)[12]"_ostr, "x"_ostr, "4711");
+
+    // make sure the text that isn't overflowing is still aligned properly
+    assertXPathContent(pDocument, "count((//sdrblocktext)[7]//textsimpleportion)"_ostr, "3");
+    assertXPath(pDocument, "((//sdrblocktext)[7]//textsimpleportion)[1]"_ostr, "x"_ostr, "25417");
+    assertXPath(pDocument, "((//sdrblocktext)[7]//textsimpleportion)[3]"_ostr, "x"_ostr, "23893");
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */