drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx |   21 ++--
 drawinglayer/source/primitive2d/svggradientprimitive2d.cxx     |   52 
+++++-----
 drawinglayer/source/tools/emfphelperdata.cxx                   |   12 --
 svgio/qa/cppunit/SvgImportTest.cxx                             |   24 ++--
 svgio/source/svgreader/svgfefloodnode.cxx                      |   31 +++--
 svgio/source/svgreader/svgstyleattributes.cxx                  |   24 +++-
 svx/source/sdr/overlay/overlaytools.cxx                        |   20 ++-
 7 files changed, 103 insertions(+), 81 deletions(-)

New commits:
commit 45c45e97e1b3a54689557644edd2ea6c3e6af149
Author:     Armin Le Grand (Collabora) <armin.le.gr...@me.com>
AuthorDate: Sat Jul 20 15:01:37 2024 +0200
Commit:     Armin Le Grand <armin.le.gr...@me.com>
CommitDate: Sat Jul 20 19:31:36 2024 +0200

    CairoSDPR: make use of RGBA PolyPolygon in more cases
    
    Change-Id: I7cd93e5452bce96eef295c766f4cb391ddd67250
    Reviewed-on: https://gerrit.libreoffice.org/c/core/+/170792
    Reviewed-by: Armin Le Grand <armin.le.gr...@me.com>
    Tested-by: Jenkins

diff --git a/drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx 
b/drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx
index ea1b2a56942a..1377ff28ebf3 100644
--- a/drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/backgroundcolorprimitive2d.cxx
@@ -21,7 +21,7 @@
 #include <basegfx/polygon/b2dpolygon.hxx>
 #include <basegfx/polygon/b2dpolygontools.hxx>
 #include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
-#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonRGBAPrimitive2D.hxx>
 #include <drawinglayer/geometry/viewinformation2d.hxx>
 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
 
@@ -43,19 +43,20 @@ namespace drawinglayer::primitive2d
 
             // create decompose geometry
             const basegfx::B2DPolygon 
aOutline(basegfx::utils::createPolygonFromRect(rViewInformation.getViewport()));
-            Primitive2DReference aDecompose(new 
PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aOutline), getBColor()));
 
-            if(getTransparency() != 0.0)
+            if (basegfx::fTools::lessOrEqual(getTransparency(), 0.0))
             {
-                // if used, embed decompose geometry to unified transparency
-                Primitive2DContainer aContent { aDecompose };
-                aDecompose =
-                    new UnifiedTransparencePrimitive2D(
-                        std::move(aContent),
-                        getTransparency());
+                // no transparency
+                return Primitive2DReference {
+                    new 
PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aOutline), getBColor()) };
             }
 
-            return aDecompose;
+            // if transparent, use PolyPolygonRGBAPrimitive2D
+            return Primitive2DReference {
+                new PolyPolygonRGBAPrimitive2D(
+                    basegfx::B2DPolyPolygon(aOutline),
+                    getBColor(),
+                    getTransparency()) };
         }
 
         BackgroundColorPrimitive2D::BackgroundColorPrimitive2D(
diff --git a/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx 
b/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx
index 24f979ce2c9d..3c6e7ab6b494 100644
--- a/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx
@@ -27,6 +27,7 @@
 #include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>
 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonRGBAPrimitive2D.hxx>
 #include <drawinglayer/geometry/viewinformation2d.hxx>
 #include <osl/diagnose.h>
 #include <sal/log.hxx>
@@ -65,39 +66,40 @@ namespace drawinglayer::primitive2d
 {
         Primitive2DReference 
SvgGradientHelper::createSingleGradientEntryFill() const
         {
-            const SvgGradientEntryVector& rEntries = getGradientEntries();
+            const SvgGradientEntryVector& rEntries(getGradientEntries());
             const sal_uInt32 nCount(rEntries.size());
 
-            if(nCount)
+            if(0 == nCount)
             {
-                const SvgGradientEntry& rSingleEntry = rEntries[nCount - 1];
-                const double fOpacity(rSingleEntry.getOpacity());
-
-                if(fOpacity > 0.0)
-                {
-                    Primitive2DReference xRef(
-                        new PolyPolygonColorPrimitive2D(
-                            getPolyPolygon(),
-                            rSingleEntry.getColor()));
-
-                    if(fOpacity < 1.0)
-                    {
-                        Primitive2DContainer aContent { xRef };
+                // no entries, done
+                OSL_ENSURE(false, "Single gradient entry construction without 
entry (!)");
+                return nullptr;
+            }
 
-                        xRef =
-                            new UnifiedTransparencePrimitive2D(
-                                std::move(aContent),
-                                1.0 - fOpacity);
-                    }
+            const SvgGradientEntry& rSingleEntry(rEntries[nCount - 1]);
+            const double fOpacity(rSingleEntry.getOpacity());
 
-                    return xRef;
-                }
+            if (basegfx::fTools::lessOrEqual(fOpacity, 0.0))
+            {
+                // completely opaque, done
+                return nullptr;
             }
-            else
+
+            if (basegfx::fTools::moreOrEqual(fOpacity, 1.0))
             {
-                OSL_ENSURE(false, "Single gradient entry construction without 
entry (!)");
+                // no opacity
+                return Primitive2DReference {
+                    new PolyPolygonColorPrimitive2D(
+                        getPolyPolygon(),
+                        rSingleEntry.getColor()) };
             }
-            return nullptr;
+
+            // if transparent, use PolyPolygonRGBAPrimitive2D
+            return Primitive2DReference {
+                new PolyPolygonRGBAPrimitive2D(
+                    getPolyPolygon(),
+                    rSingleEntry.getColor(),
+                    1.0 - fOpacity) };
         }
 
         void SvgGradientHelper::checkPreconditions()
diff --git a/drawinglayer/source/tools/emfphelperdata.cxx 
b/drawinglayer/source/tools/emfphelperdata.cxx
index 9657fb4f0c41..55eadda06d9c 100644
--- a/drawinglayer/source/tools/emfphelperdata.cxx
+++ b/drawinglayer/source/tools/emfphelperdata.cxx
@@ -31,6 +31,7 @@
 #include <wmfemfhelper.hxx>
 #include <drawinglayer/primitive2d/PolygonStrokeArrowPrimitive2D.hxx>
 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonRGBAPrimitive2D.hxx>
 #include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
 #include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
 #include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>
@@ -683,14 +684,11 @@ namespace emfplushelper
         }
         else
         {
-            const drawinglayer::primitive2d::Primitive2DReference aPrimitive(
-                        new 
drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
-                            polygon,
-                            color.getBColor()));
-
+            // transparent
             mrTargetHolders.Current().append(
-                        new 
drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
-                            drawinglayer::primitive2d::Primitive2DContainer { 
aPrimitive },
+                        new 
drawinglayer::primitive2d::PolyPolygonRGBAPrimitive2D(
+                            polygon,
+                            color.getBColor(),
                             (255 - color.GetAlpha()) / 255.0));
         }
     }
diff --git a/svgio/qa/cppunit/SvgImportTest.cxx 
b/svgio/qa/cppunit/SvgImportTest.cxx
index 0f2478860d9b..e30dc9e0e20c 100644
--- a/svgio/qa/cppunit/SvgImportTest.cxx
+++ b/svgio/qa/cppunit/SvgImportTest.cxx
@@ -325,12 +325,12 @@ CPPUNIT_TEST_FIXTURE(Test, testFilterFeFlood)
 {
     xmlDocUniquePtr pDocument = 
dumpAndParseSvg(u"/svgio/qa/cppunit/data/filterFeFlood.svg");
 
-    assertXPath(pDocument, "/primitive2D/transform/unifiedtransparence"_ostr, 
"transparence"_ostr, u"50"_ustr);
-    assertXPath(pDocument, 
"/primitive2D/transform/unifiedtransparence/polypolygoncolor"_ostr, 
"color"_ostr, u"#008000"_ustr);
-    assertXPath(pDocument, 
"/primitive2D/transform/unifiedtransparence/polypolygoncolor/polypolygon"_ostr, 
"height"_ostr, u"100"_ustr);
-    assertXPath(pDocument, 
"/primitive2D/transform/unifiedtransparence/polypolygoncolor/polypolygon"_ostr, 
"width"_ostr, u"100"_ustr);
-    assertXPath(pDocument, 
"/primitive2D/transform/unifiedtransparence/polypolygoncolor/polypolygon"_ostr, 
"minx"_ostr, u"50"_ustr);
-    assertXPath(pDocument, 
"/primitive2D/transform/unifiedtransparence/polypolygoncolor/polypolygon"_ostr, 
"miny"_ostr, u"50"_ustr);
+    assertXPath(pDocument, "/primitive2D/transform/polypolygonrgba"_ostr, 
"transparence"_ostr, u"50"_ustr);
+    assertXPath(pDocument, "/primitive2D/transform/polypolygonrgba"_ostr, 
"color"_ostr, u"#008000"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/polypolygonrgba/polypolygon"_ostr, "height"_ostr, 
u"100"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/polypolygonrgba/polypolygon"_ostr, "width"_ostr, 
u"100"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/polypolygonrgba/polypolygon"_ostr, "minx"_ostr, 
u"50"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/polypolygonrgba/polypolygon"_ostr, "miny"_ostr, 
u"50"_ustr);
 }
 
 CPPUNIT_TEST_FIXTURE(Test, testFilterFeDropShadow)
@@ -618,8 +618,8 @@ CPPUNIT_TEST_FIXTURE(Test, testTdf155932)
 {
     xmlDocUniquePtr pDocument = 
dumpAndParseSvg(u"/svgio/qa/cppunit/data/tdf155932.svg");
 
-    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/unifiedtransparence"_ostr, 
"transparence"_ostr, u"50"_ustr);
-    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/unifiedtransparence[1]/polypolygoncolor"_ostr,
 "color"_ostr, u"#0000ff"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/polypolygonrgba"_ostr, "transparence"_ostr, 
u"50"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/polypolygonrgba[1]"_ostr, "color"_ostr, 
u"#0000ff"_ustr);
 }
 
 CPPUNIT_TEST_FIXTURE(Test, testTdf97717)
@@ -1050,8 +1050,8 @@ CPPUNIT_TEST_FIXTURE(Test, testTdf155814)
 {
     xmlDocUniquePtr pDocument = 
dumpAndParseSvg(u"/svgio/qa/cppunit/data/tdf155814.svg");
 
-    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/transform/unifiedtransparence"_ostr, 
"transparence"_ostr, u"50"_ustr);
-    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/transform/unifiedtransparence/polypolygoncolor"_ostr,
 "color"_ostr, u"#0000ff"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/transform/polypolygonrgba"_ostr, 
"transparence"_ostr, u"50"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/mask/mask/transform/polypolygonrgba"_ostr, 
"color"_ostr, u"#0000ff"_ustr);
 }
 
 CPPUNIT_TEST_FIXTURE(Test, testClipPathAndStyle)
@@ -1136,7 +1136,7 @@ CPPUNIT_TEST_FIXTURE(Test, test123926)
 {
     xmlDocUniquePtr pDocument = 
dumpAndParseSvg(u"/svgio/qa/cppunit/data/tdf123926.svg");
 
-    assertXPath(pDocument, 
"/primitive2D/transform/transform/transform/unifiedtransparence/polypolygoncolor"_ostr,
 "color"_ostr, u"#7cb5ec"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/transform/transform/polypolygonrgba"_ostr, 
"color"_ostr, u"#7cb5ec"_ustr);
 }
 
 CPPUNIT_TEST_FIXTURE(Test, test47446)
@@ -1370,7 +1370,7 @@ CPPUNIT_TEST_FIXTURE(Test, testTdf155733)
     // Without the fix in place, the softedge would have been applied to the 
second element
     // - Expected: 1
     // - Actual  : 0
-    assertXPath(pDocument, 
"/primitive2D/transform/transform/unifiedtransparence"_ostr, 
"transparence"_ostr, u"50"_ustr);
+    assertXPath(pDocument, 
"/primitive2D/transform/transform/polypolygonrgba"_ostr, "transparence"_ostr, 
u"50"_ustr);
 }
 
 CPPUNIT_TEST_FIXTURE(Test, testTdf158445)
diff --git a/svgio/source/svgreader/svgfefloodnode.cxx 
b/svgio/source/svgreader/svgfefloodnode.cxx
index 8ac62d79c8d9..f1d11b1c443b 100644
--- a/svgio/source/svgreader/svgfefloodnode.cxx
+++ b/svgio/source/svgreader/svgfefloodnode.cxx
@@ -19,7 +19,7 @@
 
 #include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
-#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonRGBAPrimitive2D.hxx>
 #include <basegfx/polygon/b2dpolygontools.hxx>
 #include <svgfefloodnode.hxx>
 #include <o3tl/string_view.hxx>
@@ -143,22 +143,25 @@ void 
SvgFeFloodNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTar
     const double fX(maX.solve(*this, NumberType::xcoordinate));
     const double fY(maY.solve(*this, NumberType::ycoordinate));
     const basegfx::B2DRange aRange(fX, fY, fX + fWidth, fY + fHeight);
-
-    drawinglayer::primitive2d::Primitive2DReference xRef(
-        new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
-            
basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aRange)),
-            maFloodColor.getBColor()));
-
-    rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
-
     const double fOpacity(maFloodOpacity.solve(*this));
 
-    if (basegfx::fTools::less(fOpacity, 1.0))
+    if (basegfx::fTools::moreOrEqual(fOpacity, 1.0))
     {
-        xRef = new 
drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(std::move(rTarget),
-                                                                             
1.0 - fOpacity);
-
-        rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+        // no transparence
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{
+            new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
+                
basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aRange)),
+                maFloodColor.getBColor())
+        };
+    }
+    else
+    {
+        // transparence
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{
+            new drawinglayer::primitive2d::PolyPolygonRGBAPrimitive2D(
+                
basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aRange)),
+                maFloodColor.getBColor(), 1.0 - fOpacity)
+        };
     }
 
     pParent->addGraphicSourceToMapper(maResult, rTarget);
diff --git a/svgio/source/svgreader/svgstyleattributes.cxx 
b/svgio/source/svgreader/svgstyleattributes.cxx
index 8c854e753b1d..b5579448492d 100644
--- a/svgio/source/svgreader/svgstyleattributes.cxx
+++ b/svgio/source/svgreader/svgstyleattributes.cxx
@@ -30,6 +30,7 @@
 #include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>
 #include <svggradientnode.hxx>
 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonRGBAPrimitive2D.hxx>
 #include <basegfx/vector/b2enums.hxx>
 #include <drawinglayer/processor2d/linegeometryextractor2d.hxx>
 #include <drawinglayer/processor2d/textaspolygonextractor2d.hxx>
@@ -607,7 +608,7 @@ namespace svgio::svgreader
             if(!(pFill || pFillGradient || pFillPattern))
                 return;
 
-            const double fFillOpacity(getFillOpacity().solve(mrOwner));
+            double fFillOpacity(getFillOpacity().solve(mrOwner));
 
             if(!basegfx::fTools::more(fFillOpacity, 0.0))
                 return;
@@ -627,10 +628,23 @@ namespace svgio::svgreader
             else // if(pFill)
             {
                 // create fill content
-                aNewFill.push_back(
-                    new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
-                    rPath,
-                    *pFill));
+                if(basegfx::fTools::moreOrEqual(fFillOpacity, 1.0))
+                {
+                    // no transparence
+                    aNewFill.push_back(
+                        new 
drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
+                            rPath, *pFill));
+                }
+                else
+                {
+                    // transparence
+                    aNewFill.push_back(
+                        new 
drawinglayer::primitive2d::PolyPolygonRGBAPrimitive2D(
+                            rPath, *pFill, 1.0 - fFillOpacity));
+
+                    // do not embed  again below
+                    fFillOpacity = 1.0;
+                }
             }
 
             if(aNewFill.empty())
diff --git a/svx/source/sdr/overlay/overlaytools.cxx 
b/svx/source/sdr/overlay/overlaytools.cxx
index 2755b7fa3030..3013f7e834d4 100644
--- a/svx/source/sdr/overlay/overlaytools.cxx
+++ b/svx/source/sdr/overlay/overlaytools.cxx
@@ -31,6 +31,7 @@
 #include <drawinglayer/geometry/viewinformation2d.hxx>
 #include <basegfx/matrix/b2dhommatrixtools.hxx>
 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonRGBAPrimitive2D.hxx>
 #include <vcl/svapp.hxx>
 #include <vcl/settings.hxx>
 
@@ -327,17 +328,20 @@ sal_uInt32 
OverlayStaticRectanglePrimitive::getPrimitive2DID() const
                 aPolyPolygon.append(aInnerPolygon);
 
                 // create fill primitive
-                aRetval =
-                    new PolyPolygonColorPrimitive2D(
+                if (basegfx::fTools::lessOrEqual(getTransparence(), 0.0))
+                {
+                    // no transparence
+                    aRetval = new PolyPolygonColorPrimitive2D(
                         std::move(aPolyPolygon),
                         getColor());
-
-                // embed filled to transparency (if used)
-                if(getTransparence() > 0.0)
+                }
+                else
                 {
-                    aRetval = new UnifiedTransparencePrimitive2D(
-                                Primitive2DContainer { std::move(aRetval) },
-                                getTransparence());
+                    // transparence
+                    aRetval = new PolyPolygonRGBAPrimitive2D(
+                        std::move(aPolyPolygon),
+                        getColor(),
+                        getTransparence());
                 }
             }
             else

Reply via email to