vcl/headless/CairoCommon.cxx                    |  131 ++++++++++++++++++++++++
 vcl/headless/SvpGraphicsBackend.cxx             |  125 +---------------------
 vcl/inc/headless/CairoCommon.hxx                |    8 +
 vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx |   28 +++++
 vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx |   11 ++
 vcl/unx/generic/gdi/gdiimpl.cxx                 |   34 ------
 vcl/unx/generic/gdi/gdiimpl.hxx                 |   13 --
 7 files changed, 187 insertions(+), 163 deletions(-)

New commits:
commit 6effda72259243dab5d3bbe619b2f10244b55164
Author:     Caolán McNamara <caol...@redhat.com>
AuthorDate: Tue Jan 3 20:02:41 2023 +0000
Commit:     Caolán McNamara <caol...@redhat.com>
CommitDate: Thu Jan 5 10:49:14 2023 +0000

    move drawAlphaRect into CairoCommon and reuse from X11CairoSalGraphicsImpl
    
    Change-Id: Ic9155117dd8586db5738cd7a620818af8bb28f81
    Reviewed-on: https://gerrit.libreoffice.org/c/core/+/145028
    Tested-by: Jenkins
    Reviewed-by: Caolán McNamara <caol...@redhat.com>

diff --git a/vcl/headless/CairoCommon.cxx b/vcl/headless/CairoCommon.cxx
index 14932adc6470..a43849f18ad1 100644
--- a/vcl/headless/CairoCommon.cxx
+++ b/vcl/headless/CairoCommon.cxx
@@ -888,6 +888,59 @@ bool CairoCommon::drawPolyLine(cairo_t* cr, 
basegfx::B2DRange* pExtents, const C
     return true;
 }
 
+bool CairoCommon::drawAlphaRect(cairo_t* cr, basegfx::B2DRange* pExtents, 
const Color& rLineColor,
+                                const Color& rFillColor, tools::Long nX, 
tools::Long nY,
+                                tools::Long nWidth, tools::Long nHeight, 
sal_uInt8 nTransparency)
+{
+    const bool bHasFill(rFillColor != SALCOLOR_NONE);
+    const bool bHasLine(rLineColor != SALCOLOR_NONE);
+
+    if (!bHasFill && !bHasLine)
+        return true;
+
+    const double fTransparency = nTransparency * (1.0 / 100);
+
+    if (bHasFill)
+    {
+        cairo_rectangle(cr, nX, nY, nWidth, nHeight);
+
+        applyColor(cr, rFillColor, fTransparency);
+
+        if (pExtents)
+        {
+            // set FillDamage
+            *pExtents = getClippedFillDamage(cr);
+        }
+
+        cairo_fill(cr);
+    }
+
+    if (bHasLine)
+    {
+        // PixelOffset used: Set PixelOffset as linear transformation
+        // Note: Was missing here - probably not by purpose (?)
+        cairo_matrix_t aMatrix;
+        cairo_matrix_init_translate(&aMatrix, 0.5, 0.5);
+        cairo_set_matrix(cr, &aMatrix);
+
+        cairo_rectangle(cr, nX, nY, nWidth, nHeight);
+
+        applyColor(cr, rLineColor, fTransparency);
+
+        if (pExtents)
+        {
+            // expand with possible StrokeDamage
+            basegfx::B2DRange stroke_extents = getClippedStrokeDamage(cr);
+            
stroke_extents.transform(basegfx::utils::createTranslateB2DHomMatrix(0.5, 0.5));
+            pExtents->expand(stroke_extents);
+        }
+
+        cairo_stroke(cr);
+    }
+
+    return true;
+}
+
 bool CairoCommon::drawGradient(cairo_t* cr, basegfx::B2DRange* pExtents, bool 
bAntiAlias,
                                const tools::PolyPolygon& rPolyPolygon, const 
Gradient& rGradient)
 {
diff --git a/vcl/headless/SvpGraphicsBackend.cxx 
b/vcl/headless/SvpGraphicsBackend.cxx
index cedf105a2e94..71734759906d 100644
--- a/vcl/headless/SvpGraphicsBackend.cxx
+++ b/vcl/headless/SvpGraphicsBackend.cxx
@@ -820,57 +820,17 @@ bool SvpGraphicsBackend::hasFastDrawTransformedBitmap() 
const { return false; }
 bool SvpGraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, 
tools::Long nWidth,
                                        tools::Long nHeight, sal_uInt8 
nTransparency)
 {
-    const bool bHasFill(m_rCairoCommon.m_aFillColor != SALCOLOR_NONE);
-    const bool bHasLine(m_rCairoCommon.m_aLineColor != SALCOLOR_NONE);
-
-    if (!(bHasFill || bHasLine))
-    {
-        return true;
-    }
-
     cairo_t* cr = m_rCairoCommon.getCairoContext(false, getAntiAlias());
-    m_rCairoCommon.clipRegion(cr);
-
-    const double fTransparency = nTransparency * (1.0 / 100);
-
-    // To make releaseCairoContext work, use empty extents
     basegfx::B2DRange extents;
+    m_rCairoCommon.clipRegion(cr);
 
-    if (bHasFill)
-    {
-        cairo_rectangle(cr, nX, nY, nWidth, nHeight);
-
-        CairoCommon::applyColor(cr, m_rCairoCommon.m_aFillColor, 
fTransparency);
-
-        // set FillDamage
-        extents = getClippedFillDamage(cr);
-
-        cairo_fill(cr);
-    }
-
-    if (bHasLine)
-    {
-        // PixelOffset used: Set PixelOffset as linear transformation
-        // Note: Was missing here - probably not by purpose (?)
-        cairo_matrix_t aMatrix;
-        cairo_matrix_init_translate(&aMatrix, 0.5, 0.5);
-        cairo_set_matrix(cr, &aMatrix);
-
-        cairo_rectangle(cr, nX, nY, nWidth, nHeight);
-
-        CairoCommon::applyColor(cr, m_rCairoCommon.m_aLineColor, 
fTransparency);
-
-        // expand with possible StrokeDamage
-        basegfx::B2DRange stroke_extents = getClippedStrokeDamage(cr);
-        
stroke_extents.transform(basegfx::utils::createTranslateB2DHomMatrix(0.5, 0.5));
-        extents.expand(stroke_extents);
-
-        cairo_stroke(cr);
-    }
+    const bool bRetval(CairoCommon::drawAlphaRect(cr, &extents, 
m_rCairoCommon.m_aLineColor,
+                                                  m_rCairoCommon.m_aFillColor, 
nX, nY, nWidth,
+                                                  nHeight, nTransparency));
 
     m_rCairoCommon.releaseCairoContext(cr, false, extents);
 
-    return true;
+    return bRetval;
 }
 
 bool SvpGraphicsBackend::drawGradient(const tools::PolyPolygon& rPolyPolygon,
diff --git a/vcl/inc/headless/CairoCommon.hxx b/vcl/inc/headless/CairoCommon.hxx
index e3a8778fff0b..c0938ef58e3d 100644
--- a/vcl/inc/headless/CairoCommon.hxx
+++ b/vcl/inc/headless/CairoCommon.hxx
@@ -162,6 +162,10 @@ struct VCL_DLLPUBLIC CairoCommon
                              basegfx::B2DLineJoin eLineJoin, 
css::drawing::LineCap eLineCap,
                              double fMiterMinimumAngle, bool 
bPixelSnapHairline);
 
+    static bool drawAlphaRect(cairo_t* cr, basegfx::B2DRange* pExtents, const 
Color& rLineColor,
+                              const Color& rFillColor, tools::Long nX, 
tools::Long nY,
+                              tools::Long nWidth, tools::Long nHeight, 
sal_uInt8 nTransparency);
+
     static bool drawGradient(cairo_t* cr, basegfx::B2DRange* pExtents, bool 
bAntiAlias,
                              const tools::PolyPolygon& rPolyPolygon, const 
Gradient& rGradient);
 
diff --git a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx 
b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
index 8ce73a41b3b8..58c5567cdbd4 100644
--- a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
+++ b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
@@ -151,6 +151,20 @@ bool X11CairoSalGraphicsImpl::drawPolyLine(const 
basegfx::B2DHomMatrix& rObjectT
     return bRetval;
 }
 
+bool X11CairoSalGraphicsImpl::drawAlphaRect(tools::Long nX, tools::Long nY, 
tools::Long nWidth,
+                                            tools::Long nHeight, sal_uInt8 
nTransparency)
+{
+    cairo_t* cr = mrX11Common.getCairoContext();
+    clipRegion(cr);
+
+    const bool bRetval(CairoCommon::drawAlphaRect(cr, nullptr, mnPenColor, 
mnFillColor, nX, nY,
+                                                  nWidth, nHeight, 
nTransparency));
+
+    X11Common::releaseCairoContext(cr);
+
+    return bRetval;
+}
+
 bool X11CairoSalGraphicsImpl::drawGradient(const tools::PolyPolygon& 
rPolyPolygon,
                                            const Gradient& rGradient)
 {
diff --git a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx 
b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
index 8684cdc6216a..853c4cad3252 100644
--- a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
+++ b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
@@ -86,6 +86,15 @@ public:
                       css::drawing::LineCap eLineCap, double 
fMiterMinimumAngle,
                       bool bPixelSnapHairline) override;
 
+    /** Render solid rectangle with given transparency
+
+        @param nTransparency
+        Transparency value (0-255) to use. 0 blits and opaque, 255 a
+        fully transparent rectangle
+     */
+    bool drawAlphaRect(tools::Long nX, tools::Long nY, tools::Long nWidth, 
tools::Long nHeight,
+                       sal_uInt8 nTransparency) override;
+
     bool drawGradient(const tools::PolyPolygon& rPolygon, const Gradient& 
rGradient) override;
 
     bool implDrawGradient(basegfx::B2DPolyPolygon const& rPolyPolygon,
diff --git a/vcl/unx/generic/gdi/gdiimpl.cxx b/vcl/unx/generic/gdi/gdiimpl.cxx
index 745608887b57..b9ccd388d0f7 100644
--- a/vcl/unx/generic/gdi/gdiimpl.cxx
+++ b/vcl/unx/generic/gdi/gdiimpl.cxx
@@ -857,35 +857,6 @@ bool X11SalGraphicsImpl::hasFastDrawTransformedBitmap() 
const
     return false;
 }
 
-bool X11SalGraphicsImpl::drawAlphaRect( tools::Long nX, tools::Long nY, 
tools::Long nWidth,
-                                    tools::Long nHeight, sal_uInt8 
nTransparency )
-{
-    if( ! mrParent.m_pFrame && ! mrParent.m_pVDev )
-        return false;
-
-    if( mbPenGC || !mbBrushGC || mbXORMode )
-        return false; // can only perform solid fills without XOR.
-
-    if( mrParent.m_pVDev && static_cast< X11SalVirtualDevice* 
>(mrParent.m_pVDev)->GetDepth() < 8 )
-        return false;
-
-    Picture aDstPic = GetXRenderPicture();
-    if( !aDstPic )
-        return false;
-
-    const double fTransparency = (100 - nTransparency) * (1.0/100);
-    const XRenderColor aRenderColor = GetXRenderColor( mnBrushColor , 
fTransparency);
-
-    XRenderPeer& rPeer = XRenderPeer::GetInstance();
-    rPeer.FillRectangle( PictOpOver,
-                         aDstPic,
-                         &aRenderColor,
-                         nX, nY,
-                         nWidth, nHeight );
-
-    return true;
-}
-
 void X11SalGraphicsImpl::drawMask( const SalTwoRect& rPosAry,
                                const SalBitmap &rSalBitmap,
                                Color nMaskColor )
diff --git a/vcl/unx/generic/gdi/gdiimpl.hxx b/vcl/unx/generic/gdi/gdiimpl.hxx
index 35d9ea9b4ef9..d46e67c1108d 100644
--- a/vcl/unx/generic/gdi/gdiimpl.hxx
+++ b/vcl/unx/generic/gdi/gdiimpl.hxx
@@ -274,17 +274,6 @@ public:
 
     virtual bool hasFastDrawTransformedBitmap() const override;
 
-    /** Render solid rectangle with given transparency
-
-        @param nTransparency
-        Transparency value (0-255) to use. 0 blits and opaque, 255 a
-        fully transparent rectangle
-     */
-    virtual bool drawAlphaRect(
-                    tools::Long nX, tools::Long nY,
-                    tools::Long nWidth, tools::Long nHeight,
-                    sal_uInt8 nTransparency ) override;
-
 public:
     void Init() override;
 };
commit fa0ecf2a61c24c6485693d81ff820693f21a5ec8
Author:     Caolán McNamara <caol...@redhat.com>
AuthorDate: Tue Jan 3 19:47:32 2023 +0000
Commit:     Caolán McNamara <caol...@redhat.com>
CommitDate: Thu Jan 5 10:49:01 2023 +0000

    move drawGradient into CairoCommon and reuse from X11CairoSalGraphicsImpl
    
    Change-Id: I249afbc4cf6318fd9ed42fef0a2aa71d1a76d9ce
    Reviewed-on: https://gerrit.libreoffice.org/c/core/+/145024
    Tested-by: Jenkins
    Reviewed-by: Caolán McNamara <caol...@redhat.com>

diff --git a/vcl/headless/CairoCommon.cxx b/vcl/headless/CairoCommon.cxx
index cfd463da41e3..14932adc6470 100644
--- a/vcl/headless/CairoCommon.cxx
+++ b/vcl/headless/CairoCommon.cxx
@@ -888,6 +888,84 @@ bool CairoCommon::drawPolyLine(cairo_t* cr, 
basegfx::B2DRange* pExtents, const C
     return true;
 }
 
+bool CairoCommon::drawGradient(cairo_t* cr, basegfx::B2DRange* pExtents, bool 
bAntiAlias,
+                               const tools::PolyPolygon& rPolyPolygon, const 
Gradient& rGradient)
+{
+    if (rGradient.GetStyle() != GradientStyle::Linear
+        && rGradient.GetStyle() != GradientStyle::Radial)
+        return false; // unsupported
+    if (rGradient.GetSteps() != 0)
+        return false; // We can't tell cairo how many colors to use in the 
gradient.
+
+    tools::Rectangle aInputRect(rPolyPolygon.GetBoundRect());
+    if (rPolyPolygon.IsRect())
+    {
+        // Rect->Polygon conversion loses the right and bottom edge, fix that.
+        aInputRect.AdjustRight(1);
+        aInputRect.AdjustBottom(1);
+        basegfx::B2DHomMatrix rObjectToDevice;
+        AddPolygonToPath(cr, tools::Polygon(aInputRect).getB2DPolygon(), 
rObjectToDevice,
+                         !bAntiAlias, false);
+    }
+    else
+    {
+        basegfx::B2DPolyPolygon 
aB2DPolyPolygon(rPolyPolygon.getB2DPolyPolygon());
+        for (auto const& rPolygon : std::as_const(aB2DPolyPolygon))
+        {
+            basegfx::B2DHomMatrix rObjectToDevice;
+            AddPolygonToPath(cr, rPolygon, rObjectToDevice, !bAntiAlias, 
false);
+        }
+    }
+
+    Gradient aGradient(rGradient);
+
+    tools::Rectangle aBoundRect;
+    Point aCenter;
+
+    aGradient.SetAngle(aGradient.GetAngle() + 2700_deg10);
+    aGradient.GetBoundRect(aInputRect, aBoundRect, aCenter);
+    Color aStartColor = aGradient.GetStartColor();
+    Color aEndColor = aGradient.GetEndColor();
+
+    cairo_pattern_t* pattern;
+    if (rGradient.GetStyle() == GradientStyle::Linear)
+    {
+        tools::Polygon aPoly(aBoundRect);
+        aPoly.Rotate(aCenter, aGradient.GetAngle() % 3600_deg10);
+        pattern
+            = cairo_pattern_create_linear(aPoly[0].X(), aPoly[0].Y(), 
aPoly[1].X(), aPoly[1].Y());
+    }
+    else
+    {
+        double radius = std::max(aBoundRect.GetWidth() / 2.0, 
aBoundRect.GetHeight() / 2.0);
+        // Move the center a bit to the top-left (the default VCL algorithm is 
a bit off-center that way,
+        // cairo is the opposite way).
+        pattern = cairo_pattern_create_radial(aCenter.X() - 0.5, aCenter.Y() - 
0.5, 0,
+                                              aCenter.X() - 0.5, aCenter.Y() - 
0.5, radius);
+        std::swap(aStartColor, aEndColor);
+    }
+
+    cairo_pattern_add_color_stop_rgba(
+        pattern, aGradient.GetBorder() / 100.0,
+        aStartColor.GetRed() * aGradient.GetStartIntensity() / 25500.0,
+        aStartColor.GetGreen() * aGradient.GetStartIntensity() / 25500.0,
+        aStartColor.GetBlue() * aGradient.GetStartIntensity() / 25500.0, 1.0);
+
+    cairo_pattern_add_color_stop_rgba(
+        pattern, 1.0, aEndColor.GetRed() * aGradient.GetEndIntensity() / 
25500.0,
+        aEndColor.GetGreen() * aGradient.GetEndIntensity() / 25500.0,
+        aEndColor.GetBlue() * aGradient.GetEndIntensity() / 25500.0, 1.0);
+
+    cairo_set_source(cr, pattern);
+    cairo_pattern_destroy(pattern);
+
+    if (pExtents)
+        *pExtents = getClippedFillDamage(cr);
+    cairo_fill_preserve(cr);
+
+    return true;
+}
+
 bool CairoCommon::implDrawGradient(cairo_t* cr, basegfx::B2DRange* pExtents, 
bool bAntiAlias,
                                    basegfx::B2DPolyPolygon const& rPolyPolygon,
                                    SalGradient const& rGradient)
diff --git a/vcl/headless/SvpGraphicsBackend.cxx 
b/vcl/headless/SvpGraphicsBackend.cxx
index 6f527f350760..cedf105a2e94 100644
--- a/vcl/headless/SvpGraphicsBackend.cxx
+++ b/vcl/headless/SvpGraphicsBackend.cxx
@@ -876,83 +876,16 @@ bool SvpGraphicsBackend::drawAlphaRect(tools::Long nX, 
tools::Long nY, tools::Lo
 bool SvpGraphicsBackend::drawGradient(const tools::PolyPolygon& rPolyPolygon,
                                       const Gradient& rGradient)
 {
-    if (rGradient.GetStyle() != GradientStyle::Linear
-        && rGradient.GetStyle() != GradientStyle::Radial)
-        return false; // unsupported
-    if (rGradient.GetSteps() != 0)
-        return false; // We can't tell cairo how many colors to use in the 
gradient.
-
     cairo_t* cr = m_rCairoCommon.getCairoContext(true, getAntiAlias());
+    basegfx::B2DRange extents;
     m_rCairoCommon.clipRegion(cr);
 
-    tools::Rectangle aInputRect(rPolyPolygon.GetBoundRect());
-    if (rPolyPolygon.IsRect())
-    {
-        // Rect->Polygon conversion loses the right and bottom edge, fix that.
-        aInputRect.AdjustRight(1);
-        aInputRect.AdjustBottom(1);
-        basegfx::B2DHomMatrix rObjectToDevice;
-        AddPolygonToPath(cr, tools::Polygon(aInputRect).getB2DPolygon(), 
rObjectToDevice,
-                         !getAntiAlias(), false);
-    }
-    else
-    {
-        basegfx::B2DPolyPolygon 
aB2DPolyPolygon(rPolyPolygon.getB2DPolyPolygon());
-        for (auto const& rPolygon : std::as_const(aB2DPolyPolygon))
-        {
-            basegfx::B2DHomMatrix rObjectToDevice;
-            AddPolygonToPath(cr, rPolygon, rObjectToDevice, !getAntiAlias(), 
false);
-        }
-    }
-
-    Gradient aGradient(rGradient);
-
-    tools::Rectangle aBoundRect;
-    Point aCenter;
-
-    aGradient.SetAngle(aGradient.GetAngle() + 2700_deg10);
-    aGradient.GetBoundRect(aInputRect, aBoundRect, aCenter);
-    Color aStartColor = aGradient.GetStartColor();
-    Color aEndColor = aGradient.GetEndColor();
-
-    cairo_pattern_t* pattern;
-    if (rGradient.GetStyle() == GradientStyle::Linear)
-    {
-        tools::Polygon aPoly(aBoundRect);
-        aPoly.Rotate(aCenter, aGradient.GetAngle() % 3600_deg10);
-        pattern
-            = cairo_pattern_create_linear(aPoly[0].X(), aPoly[0].Y(), 
aPoly[1].X(), aPoly[1].Y());
-    }
-    else
-    {
-        double radius = std::max(aBoundRect.GetWidth() / 2.0, 
aBoundRect.GetHeight() / 2.0);
-        // Move the center a bit to the top-left (the default VCL algorithm is 
a bit off-center that way,
-        // cairo is the opposite way).
-        pattern = cairo_pattern_create_radial(aCenter.X() - 0.5, aCenter.Y() - 
0.5, 0,
-                                              aCenter.X() - 0.5, aCenter.Y() - 
0.5, radius);
-        std::swap(aStartColor, aEndColor);
-    }
-
-    cairo_pattern_add_color_stop_rgba(
-        pattern, aGradient.GetBorder() / 100.0,
-        aStartColor.GetRed() * aGradient.GetStartIntensity() / 25500.0,
-        aStartColor.GetGreen() * aGradient.GetStartIntensity() / 25500.0,
-        aStartColor.GetBlue() * aGradient.GetStartIntensity() / 25500.0, 1.0);
-
-    cairo_pattern_add_color_stop_rgba(
-        pattern, 1.0, aEndColor.GetRed() * aGradient.GetEndIntensity() / 
25500.0,
-        aEndColor.GetGreen() * aGradient.GetEndIntensity() / 25500.0,
-        aEndColor.GetBlue() * aGradient.GetEndIntensity() / 25500.0, 1.0);
-
-    cairo_set_source(cr, pattern);
-    cairo_pattern_destroy(pattern);
-
-    basegfx::B2DRange extents = getClippedFillDamage(cr);
-    cairo_fill_preserve(cr);
+    const bool bRetval(
+        CairoCommon::drawGradient(cr, &extents, getAntiAlias(), rPolyPolygon, 
rGradient));
 
     m_rCairoCommon.releaseCairoContext(cr, true, extents);
 
-    return true;
+    return bRetval;
 }
 
 bool SvpGraphicsBackend::implDrawGradient(basegfx::B2DPolyPolygon const& 
rPolyPolygon,
diff --git a/vcl/inc/headless/CairoCommon.hxx b/vcl/inc/headless/CairoCommon.hxx
index dfee58b1a9f2..e3a8778fff0b 100644
--- a/vcl/inc/headless/CairoCommon.hxx
+++ b/vcl/inc/headless/CairoCommon.hxx
@@ -45,6 +45,7 @@ typedef struct _cairo cairo_t;
 typedef struct _cairo_surface cairo_surface_t;
 typedef struct _cairo_user_data_key cairo_user_data_key_t;
 
+class Gradient;
 struct SalGradient;
 
 VCL_DLLPUBLIC void dl_cairo_surface_set_device_scale(cairo_surface_t* surface, 
double x_scale,
@@ -161,6 +162,9 @@ struct VCL_DLLPUBLIC CairoCommon
                              basegfx::B2DLineJoin eLineJoin, 
css::drawing::LineCap eLineCap,
                              double fMiterMinimumAngle, bool 
bPixelSnapHairline);
 
+    static bool drawGradient(cairo_t* cr, basegfx::B2DRange* pExtents, bool 
bAntiAlias,
+                             const tools::PolyPolygon& rPolyPolygon, const 
Gradient& rGradient);
+
     static bool implDrawGradient(cairo_t* cr, basegfx::B2DRange* pExtents, 
bool bAntiAlias,
                                  basegfx::B2DPolyPolygon const& rPolyPolygon,
                                  SalGradient const& rGradient);
diff --git a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx 
b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
index 702e9a9d298e..8ce73a41b3b8 100644
--- a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
+++ b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
@@ -151,6 +151,20 @@ bool X11CairoSalGraphicsImpl::drawPolyLine(const 
basegfx::B2DHomMatrix& rObjectT
     return bRetval;
 }
 
+bool X11CairoSalGraphicsImpl::drawGradient(const tools::PolyPolygon& 
rPolyPolygon,
+                                           const Gradient& rGradient)
+{
+    cairo_t* cr = mrX11Common.getCairoContext();
+    clipRegion(cr);
+
+    const bool bRetval(
+        CairoCommon::drawGradient(cr, nullptr, getAntiAlias(), rPolyPolygon, 
rGradient));
+
+    X11Common::releaseCairoContext(cr);
+
+    return bRetval;
+}
+
 bool X11CairoSalGraphicsImpl::implDrawGradient(basegfx::B2DPolyPolygon const& 
rPolyPolygon,
                                                SalGradient const& rGradient)
 {
diff --git a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx 
b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
index 20b92ad8bc55..8684cdc6216a 100644
--- a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
+++ b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
@@ -86,6 +86,8 @@ public:
                       css::drawing::LineCap eLineCap, double 
fMiterMinimumAngle,
                       bool bPixelSnapHairline) override;
 
+    bool drawGradient(const tools::PolyPolygon& rPolygon, const Gradient& 
rGradient) override;
+
     bool implDrawGradient(basegfx::B2DPolyPolygon const& rPolyPolygon,
                           SalGradient const& rGradient) override;
 
diff --git a/vcl/unx/generic/gdi/gdiimpl.cxx b/vcl/unx/generic/gdi/gdiimpl.cxx
index 2bc3bef2eadb..745608887b57 100644
--- a/vcl/unx/generic/gdi/gdiimpl.cxx
+++ b/vcl/unx/generic/gdi/gdiimpl.cxx
@@ -1974,9 +1974,4 @@ tools::Long X11SalGraphicsImpl::GetGraphicsWidth() const
         return 0;
 }
 
-bool X11SalGraphicsImpl::drawGradient(const tools::PolyPolygon& /*rPolygon*/, 
const Gradient& /*rGradient*/)
-{
-    return false;
-}
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/unx/generic/gdi/gdiimpl.hxx b/vcl/unx/generic/gdi/gdiimpl.hxx
index a57298412752..35d9ea9b4ef9 100644
--- a/vcl/unx/generic/gdi/gdiimpl.hxx
+++ b/vcl/unx/generic/gdi/gdiimpl.hxx
@@ -285,8 +285,6 @@ public:
                     tools::Long nWidth, tools::Long nHeight,
                     sal_uInt8 nTransparency ) override;
 
-    virtual bool drawGradient(const tools::PolyPolygon& rPolygon, const 
Gradient& rGradient) override;
-
 public:
     void Init() override;
 };

Reply via email to