use std::optional for SALCOLOR_NONE

instead of re-using an actual real color value, because it will totally
not work when I convert vcl to use alpha instead of transparency

Change-Id: I01f043e0b65ffd852989dfe28f2b9d5a43c9c3d7
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/145075
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

16 files changed, 205 insertions, 194 deletions

diff --git a/include/vcl/salgtype.hxx b/include/vcl/salgtype.hxx
index a6559d68da23..efd5cc8060d3 100644
--- a/include/vcl/salgtype.hxx
+++ b/include/vcl/salgtype.hxx
@@ -33,8 +33,6 @@ enum class DeviceFormat {
 #endif
                         };
 
-constexpr ::Color SALCOLOR_NONE ( ColorTransparency, 0xFF, 0xFF, 0xFF, 0xFF );
-
 struct SalTwoRect
 {
     tools::Long        mnSrcX;
diff --git a/vcl/headless/CairoCommon.cxx b/vcl/headless/CairoCommon.cxx
index 291bc7e36380..0779cb65c564 100644
--- a/vcl/headless/CairoCommon.cxx
+++ b/vcl/headless/CairoCommon.cxx
@@ -609,14 +609,14 @@ void CairoCommon::clipRegion(cairo_t* cr, const vcl::Region& rClipRegion)
 
 void CairoCommon::clipRegion(cairo_t* cr) { CairoCommon::clipRegion(cr, m_aClipRegion); }
 
-void CairoCommon::drawPixel(cairo_t* cr, basegfx::B2DRange* pExtents, const Color& rLineColor,
-                            tools::Long nX, tools::Long nY)
+void CairoCommon::drawPixel(cairo_t* cr, basegfx::B2DRange* pExtents,
+                            const std::optional<Color>& rLineColor, tools::Long nX, tools::Long nY)
 {
-    if (rLineColor == SALCOLOR_NONE)
+    if (!rLineColor)
         return;
 
     cairo_rectangle(cr, nX, nY, 1, 1);
-    CairoCommon::applyColor(cr, rLineColor, 0.0);
+    CairoCommon::applyColor(cr, *rLineColor, 0.0);
     cairo_fill(cr);
 
     if (pExtents)
@@ -687,9 +687,11 @@ void CairoCommon::drawLine(cairo_t* cr, basegfx::B2DRange* pExtents, const Color
     cairo_stroke(cr);
 }
 
-void CairoCommon::drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents, const Color& rLineColor,
-                                  const Color& rFillColor, bool bAntiAlias, sal_uInt32 nPoly,
-                                  const sal_uInt32* pPointCounts, const Point** pPtAry)
+void CairoCommon::drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents,
+                                  const std::optional<Color>& rLineColor,
+                                  const std::optional<Color>& rFillColor, bool bAntiAlias,
+                                  sal_uInt32 nPoly, const sal_uInt32* pPointCounts,
+                                  const Point** pPtAry)
 {
     basegfx::B2DPolyPolygon aPolyPoly;
     for (sal_uInt32 nPolygon = 0; nPolygon < nPoly; ++nPolygon)
@@ -711,13 +713,14 @@ void CairoCommon::drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents, cons
                     aPolyPoly, 0.0);
 }
 
-bool CairoCommon::drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents, const Color& rLineColor,
-                                  const Color& rFillColor, bool bAntiAlias,
+bool CairoCommon::drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents,
+                                  const std::optional<Color>& rLineColor,
+                                  const std::optional<Color>& rFillColor, bool bAntiAlias,
                                   const basegfx::B2DHomMatrix& rObjectToDevice,
                                   const basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency)
 {
-    const bool bHasFill(rFillColor != SALCOLOR_NONE);
-    const bool bHasLine(rLineColor != SALCOLOR_NONE);
+    const bool bHasFill(rFillColor.has_value());
+    const bool bHasLine(rLineColor.has_value());
 
     if (0 == rPolyPolygon.count() || !(bHasFill || bHasLine) || fTransparency < 0.0
         || fTransparency >= 1.0)
@@ -746,7 +749,7 @@ bool CairoCommon::drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents, cons
     {
         add_polygon_path(cr, rPolyPolygon, rObjectToDevice, !bAntiAlias);
 
-        CairoCommon::applyColor(cr, rFillColor, fTransparency);
+        CairoCommon::applyColor(cr, *rFillColor, fTransparency);
         if (pExtents)
         {
             // Get FillDamage (will be extended for LineDamage below)
@@ -765,7 +768,7 @@ bool CairoCommon::drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents, cons
 
         add_polygon_path(cr, rPolyPolygon, rObjectToDevice, !bAntiAlias);
 
-        CairoCommon::applyColor(cr, rLineColor, fTransparency);
+        CairoCommon::applyColor(cr, *rLineColor, fTransparency);
 
         if (pExtents)
         {
@@ -1067,12 +1070,14 @@ 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)
+bool CairoCommon::drawAlphaRect(cairo_t* cr, basegfx::B2DRange* pExtents,
+                                const std::optional<Color>& rLineColor,
+                                const std::optional<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);
+    const bool bHasFill(rFillColor.has_value());
+    const bool bHasLine(rLineColor.has_value());
 
     if (!bHasFill && !bHasLine)
         return true;
@@ -1083,7 +1088,7 @@ bool CairoCommon::drawAlphaRect(cairo_t* cr, basegfx::B2DRange* pExtents, const
     {
         cairo_rectangle(cr, nX, nY, nWidth, nHeight);
 
-        applyColor(cr, rFillColor, fTransparency);
+        applyColor(cr, *rFillColor, fTransparency);
 
         if (pExtents)
         {
@@ -1104,7 +1109,7 @@ bool CairoCommon::drawAlphaRect(cairo_t* cr, basegfx::B2DRange* pExtents, const
 
         cairo_rectangle(cr, nX, nY, nWidth, nHeight);
 
-        applyColor(cr, rLineColor, fTransparency);
+        applyColor(cr, *rLineColor, fTransparency);
 
         if (pExtents)
         {
diff --git a/vcl/headless/SvpGraphicsBackend.cxx b/vcl/headless/SvpGraphicsBackend.cxx
index 0878930373e4..bf79416d88b7 100644
--- a/vcl/headless/SvpGraphicsBackend.cxx
+++ b/vcl/headless/SvpGraphicsBackend.cxx
@@ -53,13 +53,13 @@ tools::Long SvpGraphicsBackend::GetGraphicsWidth() const
     return m_rCairoCommon.m_pSurface ? m_rCairoCommon.m_aFrameSize.getX() : 0;
 }
 
-void SvpGraphicsBackend::SetLineColor() { m_rCairoCommon.m_aLineColor = SALCOLOR_NONE; }
+void SvpGraphicsBackend::SetLineColor() { m_rCairoCommon.m_oLineColor = std::nullopt; }
 
-void SvpGraphicsBackend::SetLineColor(Color nColor) { m_rCairoCommon.m_aLineColor = nColor; }
+void SvpGraphicsBackend::SetLineColor(Color nColor) { m_rCairoCommon.m_oLineColor = nColor; }
 
-void SvpGraphicsBackend::SetFillColor() { m_rCairoCommon.m_aFillColor = SALCOLOR_NONE; }
+void SvpGraphicsBackend::SetFillColor() { m_rCairoCommon.m_oFillColor = std::nullopt; }
 
-void SvpGraphicsBackend::SetFillColor(Color nColor) { m_rCairoCommon.m_aFillColor = nColor; }
+void SvpGraphicsBackend::SetFillColor(Color nColor) { m_rCairoCommon.m_oFillColor = nColor; }
 
 void SvpGraphicsBackend::SetXORMode(bool bSet, bool /*bInvertOnly*/)
 {
@@ -71,13 +71,13 @@ void SvpGraphicsBackend::SetROPLineColor(SalROPColor nROPColor)
     switch (nROPColor)
     {
         case SalROPColor::N0:
-            m_rCairoCommon.m_aLineColor = Color(0, 0, 0);
+            m_rCairoCommon.m_oLineColor = Color(0, 0, 0);
             break;
         case SalROPColor::N1:
-            m_rCairoCommon.m_aLineColor = Color(0xff, 0xff, 0xff);
+            m_rCairoCommon.m_oLineColor = Color(0xff, 0xff, 0xff);
             break;
         case SalROPColor::Invert:
-            m_rCairoCommon.m_aLineColor = Color(0xff, 0xff, 0xff);
+            m_rCairoCommon.m_oLineColor = Color(0xff, 0xff, 0xff);
             break;
     }
 }
@@ -87,20 +87,20 @@ void SvpGraphicsBackend::SetROPFillColor(SalROPColor nROPColor)
     switch (nROPColor)
     {
         case SalROPColor::N0:
-            m_rCairoCommon.m_aFillColor = Color(0, 0, 0);
+            m_rCairoCommon.m_oFillColor = Color(0, 0, 0);
             break;
         case SalROPColor::N1:
-            m_rCairoCommon.m_aFillColor = Color(0xff, 0xff, 0xff);
+            m_rCairoCommon.m_oFillColor = Color(0xff, 0xff, 0xff);
             break;
         case SalROPColor::Invert:
-            m_rCairoCommon.m_aFillColor = Color(0xff, 0xff, 0xff);
+            m_rCairoCommon.m_oFillColor = Color(0xff, 0xff, 0xff);
             break;
     }
 }
 
 void SvpGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY)
 {
-    drawPixel(nX, nY, m_rCairoCommon.m_aLineColor);
+    drawPixel(nX, nY, *m_rCairoCommon.m_oLineColor);
 }
 
 void SvpGraphicsBackend::drawPixel(tools::Long nX, tools::Long nY, Color aColor)
@@ -121,7 +121,7 @@ void SvpGraphicsBackend::drawLine(tools::Long nX1, tools::Long nY1, tools::Long
     basegfx::B2DRange extents;
     m_rCairoCommon.clipRegion(cr);
 
-    CairoCommon::drawLine(cr, &extents, m_rCairoCommon.m_aLineColor, getAntiAlias(), nX1, nY1, nX2,
+    CairoCommon::drawLine(cr, &extents, *m_rCairoCommon.m_oLineColor, getAntiAlias(), nX1, nY1, nX2,
                           nY2);
 
     m_rCairoCommon.releaseCairoContext(cr, false, extents);
@@ -136,8 +136,8 @@ void SvpGraphicsBackend::drawRect(tools::Long nX, tools::Long nY, tools::Long nW
 void SvpGraphicsBackend::implDrawRect(double nX, double nY, double nWidth, double nHeight)
 {
     // fast path for the common case of simply creating a solid block of color
-    if (m_rCairoCommon.m_aFillColor != SALCOLOR_NONE && m_rCairoCommon.m_aLineColor != SALCOLOR_NONE
-        && m_rCairoCommon.m_aFillColor == m_rCairoCommon.m_aLineColor)
+    if (m_rCairoCommon.m_oFillColor && m_rCairoCommon.m_oLineColor
+        && m_rCairoCommon.m_oFillColor == m_rCairoCommon.m_oLineColor)
     {
         double fTransparency = 0;
 
@@ -163,7 +163,7 @@ void SvpGraphicsBackend::implDrawRect(double nX, double nY, double nWidth, doubl
 
         cairo_rectangle(cr, nX, nY, nWidth, nHeight);
 
-        CairoCommon::applyColor(cr, m_rCairoCommon.m_aFillColor, fTransparency);
+        CairoCommon::applyColor(cr, *m_rCairoCommon.m_oFillColor, fTransparency);
         // Get FillDamage (will be extended for LineDamage below)
         extents = getClippedFillDamage(cr);
 
@@ -175,36 +175,36 @@ void SvpGraphicsBackend::implDrawRect(double nX, double nY, double nWidth, doubl
     }
 
     // because of the -1 hack we have to do fill and draw separately
-    Color aOrigFillColor = m_rCairoCommon.m_aFillColor;
-    Color aOrigLineColor = m_rCairoCommon.m_aLineColor;
-    m_rCairoCommon.m_aFillColor = SALCOLOR_NONE;
-    m_rCairoCommon.m_aLineColor = SALCOLOR_NONE;
+    std::optional<Color> aOrigFillColor = m_rCairoCommon.m_oFillColor;
+    std::optional<Color> aOrigLineColor = m_rCairoCommon.m_oLineColor;
+    m_rCairoCommon.m_oFillColor = std::nullopt;
+    m_rCairoCommon.m_oLineColor = std::nullopt;
 
-    if (aOrigFillColor != SALCOLOR_NONE)
+    if (aOrigFillColor)
     {
         basegfx::B2DPolygon aRect = basegfx::utils::createPolygonFromRect(
             basegfx::B2DRectangle(nX, nY, nX + nWidth, nY + nHeight));
-        m_rCairoCommon.m_aFillColor = aOrigFillColor;
+        m_rCairoCommon.m_oFillColor = aOrigFillColor;
 
         drawPolyPolygon(basegfx::B2DHomMatrix(), basegfx::B2DPolyPolygon(aRect), 0.0);
 
-        m_rCairoCommon.m_aFillColor = SALCOLOR_NONE;
+        m_rCairoCommon.m_oFillColor = std::nullopt;
     }
 
-    if (aOrigLineColor != SALCOLOR_NONE)
+    if (aOrigLineColor)
     {
         // need same -1 hack as X11SalGraphicsImpl::drawRect
         basegfx::B2DPolygon aRect = basegfx::utils::createPolygonFromRect(
             basegfx::B2DRectangle(nX, nY, nX + nWidth - 1, nY + nHeight - 1));
-        m_rCairoCommon.m_aLineColor = aOrigLineColor;
+        m_rCairoCommon.m_oLineColor = aOrigLineColor;
 
         drawPolyPolygon(basegfx::B2DHomMatrix(), basegfx::B2DPolyPolygon(aRect), 0.0);
 
-        m_rCairoCommon.m_aLineColor = SALCOLOR_NONE;
+        m_rCairoCommon.m_oLineColor = std::nullopt;
     }
 
-    m_rCairoCommon.m_aFillColor = aOrigFillColor;
-    m_rCairoCommon.m_aLineColor = aOrigLineColor;
+    m_rCairoCommon.m_oFillColor = aOrigFillColor;
+    m_rCairoCommon.m_oLineColor = aOrigLineColor;
 }
 
 void SvpGraphicsBackend::drawPolyLine(sal_uInt32 nPoints, const Point* pPtAry)
@@ -238,8 +238,8 @@ void SvpGraphicsBackend::drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32* pPo
     basegfx::B2DRange extents;
     m_rCairoCommon.clipRegion(cr);
 
-    CairoCommon::drawPolyPolygon(cr, &extents, m_rCairoCommon.m_aLineColor,
-                                 m_rCairoCommon.m_aFillColor, getAntiAlias(), nPoly, pPointCounts,
+    CairoCommon::drawPolyPolygon(cr, &extents, m_rCairoCommon.m_oLineColor,
+                                 m_rCairoCommon.m_oFillColor, getAntiAlias(), nPoly, pPointCounts,
                                  pPtAry);
 
     m_rCairoCommon.releaseCairoContext(cr, true, extents);
@@ -253,8 +253,8 @@ bool SvpGraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToD
     basegfx::B2DRange extents;
     m_rCairoCommon.clipRegion(cr);
 
-    bool bRetVal(CairoCommon::drawPolyPolygon(cr, &extents, m_rCairoCommon.m_aLineColor,
-                                              m_rCairoCommon.m_aFillColor, getAntiAlias(),
+    bool bRetVal(CairoCommon::drawPolyPolygon(cr, &extents, m_rCairoCommon.m_oLineColor,
+                                              m_rCairoCommon.m_oFillColor, getAntiAlias(),
                                               rObjectToDevice, rPolyPolygon, fTransparency));
 
     m_rCairoCommon.releaseCairoContext(cr, true, extents);
@@ -283,7 +283,7 @@ bool SvpGraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevi
     basegfx::B2DRange aExtents;
     m_rCairoCommon.clipRegion(cr);
 
-    bool bRetval(CairoCommon::drawPolyLine(cr, &aExtents, m_rCairoCommon.m_aLineColor,
+    bool bRetval(CairoCommon::drawPolyLine(cr, &aExtents, *m_rCairoCommon.m_oLineColor,
                                            getAntiAlias(), rObjectToDevice, rPolyLine,
                                            fTransparency, fLineWidth, pStroke, eLineJoin, eLineCap,
                                            fMiterMinimumAngle, bPixelSnapHairline));
@@ -710,10 +710,9 @@ bool SvpGraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, tools::Lo
     basegfx::B2DRange extents;
     m_rCairoCommon.clipRegion(cr);
 
-    const bool bRetval(CairoCommon::drawAlphaRect(cr, &extents, m_rCairoCommon.m_aLineColor,
-                                                  m_rCairoCommon.m_aFillColor, nX, nY, nWidth,
+    const bool bRetval(CairoCommon::drawAlphaRect(cr, &extents, *m_rCairoCommon.m_oLineColor,
+                                                  *m_rCairoCommon.m_oFillColor, nX, nY, nWidth,
                                                   nHeight, nTransparency));
-
     m_rCairoCommon.releaseCairoContext(cr, false, extents);
 
     return bRetval;
diff --git a/vcl/inc/headless/CairoCommon.hxx b/vcl/inc/headless/CairoCommon.hxx
index d9a4d8c60a72..7489ecaad969 100644
--- a/vcl/inc/headless/CairoCommon.hxx
+++ b/vcl/inc/headless/CairoCommon.hxx
@@ -39,6 +39,7 @@
 #include <basegfx/polygon/b2dpolypolygon.hxx>
 #include <basegfx/polygon/b2dpolygon.hxx>
 
+#include <optional>
 #include <unordered_map>
 
 typedef struct _cairo cairo_t;
@@ -124,15 +125,15 @@ struct VCL_DLLPUBLIC CairoCommon
     cairo_surface_t* m_pSurface;
     basegfx::B2IVector m_aFrameSize;
     vcl::Region m_aClipRegion;
-    Color m_aLineColor;
-    Color m_aFillColor;
+    std::optional<Color> m_oLineColor;
+    std::optional<Color> m_oFillColor;
     PaintMode m_ePaintMode;
     double m_fScale;
 
     CairoCommon()
         : m_pSurface(nullptr)
-        , m_aLineColor(Color(0x00, 0x00, 0x00))
-        , m_aFillColor(Color(0xFF, 0xFF, 0XFF))
+        , m_oLineColor(Color(0x00, 0x00, 0x00))
+        , m_oFillColor(Color(0xFF, 0xFF, 0XFF))
         , m_ePaintMode(PaintMode::Over)
         , m_fScale(1.0)
     {
@@ -152,8 +153,8 @@ struct VCL_DLLPUBLIC CairoCommon
     void clipRegion(cairo_t* cr);
     static void clipRegion(cairo_t* cr, const vcl::Region& rClipRegion);
 
-    static void drawPixel(cairo_t* cr, basegfx::B2DRange* pExtents, const Color& rLineColor,
-                          tools::Long nX, tools::Long nY);
+    static void drawPixel(cairo_t* cr, basegfx::B2DRange* pExtents,
+                          const std::optional<Color>& rLineColor, tools::Long nX, tools::Long nY);
 
     static Color getPixel(cairo_surface_t* pSurface, tools::Long nX, tools::Long nY);
 
@@ -161,12 +162,14 @@ struct VCL_DLLPUBLIC CairoCommon
                          bool bAntiAlias, tools::Long nX1, tools::Long nY1, tools::Long nX2,
                          tools::Long nY2);
 
-    static void drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents, const Color& rLineColor,
-                                const Color& rFillColor, bool bAntiAlias, sal_uInt32 nPoly,
-                                const sal_uInt32* pPoints, const Point** pPtAry);
+    static void drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents,
+                                const std::optional<Color>& rLineColor,
+                                const std::optional<Color>& rFillColor, bool bAntiAlias,
+                                sal_uInt32 nPoly, const sal_uInt32* pPoints, const Point** pPtAry);
 
-    static bool drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents, const Color& rLineColor,
-                                const Color& rFillColor, bool bAntiAlias,
+    static bool drawPolyPolygon(cairo_t* cr, basegfx::B2DRange* pExtents,
+                                const std::optional<Color>& rLineColor,
+                                const std::optional<Color>& rFillColor, bool bAntiAlias,
                                 const basegfx::B2DHomMatrix& rObjectToDevice,
                                 const basegfx::B2DPolyPolygon&, double fTransparency);
 
@@ -180,9 +183,11 @@ 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 drawAlphaRect(cairo_t* cr, basegfx::B2DRange* pExtents,
+                              const std::optional<Color>& rLineColor,
+                              const std::optional<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/inc/qt5/QtGraphics.hxx b/vcl/inc/qt5/QtGraphics.hxx
index b87e6d80b648..ea227634017d 100644
--- a/vcl/inc/qt5/QtGraphics.hxx
+++ b/vcl/inc/qt5/QtGraphics.hxx
@@ -24,6 +24,7 @@
 #include <salgdi.hxx>
 
 #include <memory>
+#include <optional>
 
 #include <QtGui/QPainter>
 #include <QtGui/QPainterPath>
@@ -50,8 +51,8 @@ class QtGraphicsBackend final : public SalGraphicsImpl, public QtGraphicsBase
     QImage* m_pQImage;
     QRegion m_aClipRegion;
     QPainterPath m_aClipPath;
-    Color m_aLineColor;
-    Color m_aFillColor;
+    std::optional<Color> m_oLineColor;
+    std::optional<Color> m_oFillColor;
     QPainter::CompositionMode m_eCompositionMode;
 
 public:
diff --git a/vcl/inc/skia/gdiimpl.hxx b/vcl/inc/skia/gdiimpl.hxx
index b2bac2c9702c..c4a445aa66c1 100644
--- a/vcl/inc/skia/gdiimpl.hxx
+++ b/vcl/inc/skia/gdiimpl.hxx
@@ -28,6 +28,7 @@
 #include <skia/utils.hxx>
 
 #include <SkPaint.h>
+#include <optional>
 
 class SkiaFlushIdle;
 class GenericSalLayout;
@@ -320,9 +321,9 @@ protected:
     // Create SkPaint set up for gradient drawing.
     SkPaint makeGradientPaint() const;
     // Create SkPaint set up for text drawing.
-    SkPaint makeTextPaint(Color color) const;
+    SkPaint makeTextPaint(std::optional<Color> color) const;
     // Create SkPaint for unspecified pixel drawing. Avoid if possible.
-    SkPaint makePixelPaint(Color color) const;
+    SkPaint makePixelPaint(std::optional<Color> color) const;
 
     template <typename charT, typename traits>
     friend inline std::basic_ostream<charT, traits>&
@@ -350,8 +351,8 @@ protected:
     // Note that we generally use VCL coordinates, which is not mSurface coordinates if mScaling!=1.
     SkIRect mDirtyRect; // The area that has been changed since the last performFlush().
     vcl::Region mClipRegion;
-    Color mLineColor;
-    Color mFillColor;
+    std::optional<Color> moLineColor;
+    std::optional<Color> moFillColor;
     enum class XorMode
     {
         None,
@@ -388,23 +389,23 @@ inline SkPaint SkiaSalGraphicsImpl::makePaintInternal() const
 
 inline SkPaint SkiaSalGraphicsImpl::makeLinePaint(double transparency) const
 {
-    assert(mLineColor != SALCOLOR_NONE);
+    assert(moLineColor.has_value());
     SkPaint paint = makePaintInternal();
     paint.setColor(transparency == 0
-                       ? SkiaHelper::toSkColor(mLineColor)
-                       : SkiaHelper::toSkColorWithTransparency(mLineColor, transparency));
+                       ? SkiaHelper::toSkColor(*moLineColor)
+                       : SkiaHelper::toSkColorWithTransparency(*moLineColor, transparency));
     paint.setStyle(SkPaint::kStroke_Style);
     return paint;
 }
 
 inline SkPaint SkiaSalGraphicsImpl::makeFillPaint(double transparency) const
 {
-    assert(mFillColor != SALCOLOR_NONE);
+    assert(moFillColor.has_value());
     SkPaint paint = makePaintInternal();
     paint.setColor(transparency == 0
-                       ? SkiaHelper::toSkColor(mFillColor)
-                       : SkiaHelper::toSkColorWithTransparency(mFillColor, transparency));
-    if (mLineColor == mFillColor)
+                       ? SkiaHelper::toSkColor(*moFillColor)
+                       : SkiaHelper::toSkColorWithTransparency(*moFillColor, transparency));
+    if (moLineColor == moFillColor)
         paint.setStyle(SkPaint::kStrokeAndFill_Style);
     else
         paint.setStyle(SkPaint::kFill_Style);
@@ -415,19 +416,19 @@ inline SkPaint SkiaSalGraphicsImpl::makeBitmapPaint() const { return makePaintIn
 
 inline SkPaint SkiaSalGraphicsImpl::makeGradientPaint() const { return makePaintInternal(); }
 
-inline SkPaint SkiaSalGraphicsImpl::makeTextPaint(Color color) const
+inline SkPaint SkiaSalGraphicsImpl::makeTextPaint(std::optional<Color> color) const
 {
-    assert(color != SALCOLOR_NONE);
+    assert(color.has_value());
     SkPaint paint = makePaintInternal();
-    paint.setColor(SkiaHelper::toSkColor(color));
+    paint.setColor(SkiaHelper::toSkColor(*color));
     return paint;
 }
 
-inline SkPaint SkiaSalGraphicsImpl::makePixelPaint(Color color) const
+inline SkPaint SkiaSalGraphicsImpl::makePixelPaint(std::optional<Color> color) const
 {
-    assert(color != SALCOLOR_NONE);
+    assert(color.has_value());
     SkPaint paint = makePaintInternal();
-    paint.setColor(SkiaHelper::toSkColor(color));
+    paint.setColor(SkiaHelper::toSkColor(*color));
     return paint;
 }
 
diff --git a/vcl/inc/unx/saldisp.hxx b/vcl/inc/unx/saldisp.hxx
index a23bcb362c58..83f847d4d78c 100644
--- a/vcl/inc/unx/saldisp.hxx
+++ b/vcl/inc/unx/saldisp.hxx
@@ -155,7 +155,7 @@ public:
                                            int      r,
                                            int      g,
                                            int      b ) const;
-    Pixel           GetPixel( Color nColor ) const;
+    Pixel           GetPixel( std::optional<Color> nColor ) const;
     Color           GetColor( Pixel nPixel ) const;
 };
 
diff --git a/vcl/qt5/QtGraphics_GDI.cxx b/vcl/qt5/QtGraphics_GDI.cxx
index 832f8a09eb2f..08116f85a529 100644
--- a/vcl/qt5/QtGraphics_GDI.cxx
+++ b/vcl/qt5/QtGraphics_GDI.cxx
@@ -36,8 +36,8 @@
 QtGraphicsBackend::QtGraphicsBackend(QtFrame* pFrame, QImage* pQImage)
     : m_pFrame(pFrame)
     , m_pQImage(pQImage)
-    , m_aLineColor(0x00, 0x00, 0x00)
-    , m_aFillColor(0xFF, 0xFF, 0XFF)
+    , m_oLineColor(std::in_place, 0x00, 0x00, 0x00)
+    , m_oFillColor(std::in_place, 0xFF, 0xFF, 0XFF)
     , m_eCompositionMode(QPainter::CompositionMode_SourceOver)
 {
     ResetClipRegion();
@@ -217,13 +217,13 @@ void QtGraphicsBackend::drawLine(tools::Long nX1, tools::Long nY1, tools::Long n
 void QtGraphicsBackend::drawRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
                                  tools::Long nHeight)
 {
-    if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
+    if (!m_oFillColor && !m_oLineColor)
         return;
 
     QtPainter aPainter(*this, true);
-    if (SALCOLOR_NONE != m_aFillColor)
+    if (m_oFillColor)
         aPainter.fillRect(nX, nY, nWidth, nHeight, aPainter.brush());
-    if (SALCOLOR_NONE != m_aLineColor)
+    if (m_oLineColor)
         aPainter.drawRect(nX, nY, nWidth - 1, nHeight - 1);
     aPainter.update(nX, nY, nWidth, nHeight);
 }
@@ -268,7 +268,7 @@ void QtGraphicsBackend::drawPolyPolygon(sal_uInt32 nPolyCount, const sal_uInt32*
                                         const Point** ppPtAry)
 {
     // ignore invisible polygons
-    if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
+    if (!m_oFillColor && !m_oLineColor)
         return;
 
     QPainterPath aPath;
@@ -296,7 +296,7 @@ bool QtGraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDe
                                         double fTransparency)
 {
     // ignore invisible polygons
-    if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
+    if (!m_oFillColor && !m_oLineColor)
         return true;
     if ((fTransparency >= 1.0) || (fTransparency < 0))
         return true;
@@ -307,7 +307,7 @@ bool QtGraphicsBackend::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectToDe
 
     QPainterPath aPath;
     // ignore empty polygons
-    if (!AddPolyPolygonToPath(aPath, aPolyPolygon, !getAntiAlias(), m_aLineColor != SALCOLOR_NONE))
+    if (!AddPolyPolygonToPath(aPath, aPolyPolygon, !getAntiAlias(), m_oLineColor.has_value()))
         return true;
 
     QtPainter aPainter(*this, true, 255 * (1.0 - fTransparency));
@@ -342,7 +342,7 @@ bool QtGraphicsBackend::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDevic
                                      basegfx::B2DLineJoin eLineJoin, css::drawing::LineCap eLineCap,
                                      double fMiterMinimumAngle, bool bPixelSnapHairline)
 {
-    if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
+    if (!m_oFillColor && !m_oLineColor)
     {
         return true;
     }
@@ -651,15 +651,15 @@ bool QtGraphicsBackend::hasFastDrawTransformedBitmap() const { return false; }
 bool QtGraphicsBackend::drawAlphaRect(tools::Long nX, tools::Long nY, tools::Long nWidth,
                                       tools::Long nHeight, sal_uInt8 nTransparency)
 {
-    if (SALCOLOR_NONE == m_aFillColor && SALCOLOR_NONE == m_aLineColor)
+    if (!m_oFillColor && !m_oLineColor)
         return true;
     assert(nTransparency <= 100);
     if (nTransparency > 100)
         nTransparency = 100;
     QtPainter aPainter(*this, true, (100 - nTransparency) * (255.0 / 100));
-    if (SALCOLOR_NONE != m_aFillColor)
+    if (m_oFillColor)
         aPainter.fillRect(nX, nY, nWidth, nHeight, aPainter.brush());
-    if (SALCOLOR_NONE != m_aLineColor)
+    if (m_oLineColor)
         aPainter.drawRect(nX, nY, nWidth - 1, nHeight - 1);
     aPainter.update(nX, nY, nWidth, nHeight);
     return true;
@@ -669,13 +669,13 @@ sal_uInt16 QtGraphicsBackend::GetBitCount() const { return getFormatBits(m_pQIma
 
 tools::Long QtGraphicsBackend::GetGraphicsWidth() const { return m_pQImage->width(); }
 
-void QtGraphicsBackend::SetLineColor() { m_aLineColor = SALCOLOR_NONE; }
+void QtGraphicsBackend::SetLineColor() { m_oLineColor = std::nullopt; }
 
-void QtGraphicsBackend::SetLineColor(Color nColor) { m_aLineColor = nColor; }
+void QtGraphicsBackend::SetLineColor(Color nColor) { m_oLineColor = nColor; }
 
-void QtGraphicsBackend::SetFillColor() { m_aFillColor = SALCOLOR_NONE; }
+void QtGraphicsBackend::SetFillColor() { m_oFillColor = std::nullopt; }
 
-void QtGraphicsBackend::SetFillColor(Color nColor) { m_aFillColor = nColor; }
+void QtGraphicsBackend::SetFillColor(Color nColor) { m_oFillColor = nColor; }
 
 void QtGraphicsBackend::SetXORMode(bool bSet, bool)
 {
diff --git a/vcl/qt5/QtPainter.cxx b/vcl/qt5/QtPainter.cxx
index a4c83bbba6d8..529a7c5783dd 100644
--- a/vcl/qt5/QtPainter.cxx
+++ b/vcl/qt5/QtPainter.cxx
@@ -39,17 +39,17 @@ QtPainter::QtPainter(QtGraphicsBackend& rGraphics, bool bPrepareBrush, sal_uInt8
         setClipPath(rGraphics.m_aClipPath);
     else
         setClipRegion(rGraphics.m_aClipRegion);
-    if (SALCOLOR_NONE != rGraphics.m_aLineColor)
+    if (rGraphics.m_oLineColor)
     {
-        QColor aColor = toQColor(rGraphics.m_aLineColor);
+        QColor aColor = toQColor(*rGraphics.m_oLineColor);
         aColor.setAlpha(nTransparency);
         setPen(aColor);
     }
     else
         setPen(Qt::NoPen);
-    if (bPrepareBrush && SALCOLOR_NONE != rGraphics.m_aFillColor)
+    if (bPrepareBrush && rGraphics.m_oFillColor)
     {
-        QColor aColor = toQColor(rGraphics.m_aFillColor);
+        QColor aColor = toQColor(*rGraphics.m_oFillColor);
         aColor.setAlpha(nTransparency);
         setBrush(aColor);
     }
diff --git a/vcl/skia/gdiimpl.cxx b/vcl/skia/gdiimpl.cxx
index 55f803217bb0..15d901d93ff2 100644
--- a/vcl/skia/gdiimpl.cxx
+++ b/vcl/skia/gdiimpl.cxx
@@ -262,8 +262,8 @@ SkiaSalGraphicsImpl::SkiaSalGraphicsImpl(SalGraphics& rParent, SalGeometryProvid
     : mParent(rParent)
     , mProvider(pProvider)
     , mIsGPU(false)
-    , mLineColor(SALCOLOR_NONE)
-    , mFillColor(SALCOLOR_NONE)
+    , moLineColor(std::nullopt)
+    , moFillColor(std::nullopt)
     , mXorMode(XorMode::None)
     , mFlush(new SkiaFlushIdle(this))
     , mScaling(1)
@@ -618,25 +618,25 @@ tools::Long SkiaSalGraphicsImpl::GetGraphicsWidth() const { return GetWidth(); }
 void SkiaSalGraphicsImpl::SetLineColor()
 {
     checkPendingDrawing();
-    mLineColor = SALCOLOR_NONE;
+    moLineColor = std::nullopt;
 }
 
 void SkiaSalGraphicsImpl::SetLineColor(Color nColor)
 {
     checkPendingDrawing();
-    mLineColor = nColor;
+    moLineColor = nColor;
 }
 
 void SkiaSalGraphicsImpl::SetFillColor()
 {
     checkPendingDrawing();
-    mFillColor = SALCOLOR_NONE;
+    moFillColor = std::nullopt;
 }
 
 void SkiaSalGraphicsImpl::SetFillColor(Color nColor)
 {
     checkPendingDrawing();
-    mFillColor = nColor;
+    moFillColor = nColor;
 }
 
 void SkiaSalGraphicsImpl::SetXORMode(bool set, bool invert)
@@ -655,13 +655,13 @@ void SkiaSalGraphicsImpl::SetROPLineColor(SalROPColor nROPColor)
     switch (nROPColor)
     {
         case SalROPColor::N0:
-            mLineColor = Color(0, 0, 0);
+            moLineColor = Color(0, 0, 0);
             break;
         case SalROPColor::N1:
-            mLineColor = Color(0xff, 0xff, 0xff);
+            moLineColor = Color(0xff, 0xff, 0xff);
             break;
         case SalROPColor::Invert:
-            mLineColor = Color(0xff, 0xff, 0xff);
+            moLineColor = Color(0xff, 0xff, 0xff);
             break;
     }
 }
@@ -672,26 +672,24 @@ void SkiaSalGraphicsImpl::SetROPFillColor(SalROPColor nROPColor)
     switch (nROPColor)
     {
         case SalROPColor::N0:
-            mFillColor = Color(0, 0, 0);
+            moFillColor = Color(0, 0, 0);
             break;
         case SalROPColor::N1:
-            mFillColor = Color(0xff, 0xff, 0xff);
+            moFillColor = Color(0xff, 0xff, 0xff);
             break;
         case SalROPColor::Invert:
-            mFillColor = Color(0xff, 0xff, 0xff);
+            moFillColor = Color(0xff, 0xff, 0xff);
             break;
     }
 }
 
 void SkiaSalGraphicsImpl::drawPixel(tools::Long nX, tools::Long nY)
 {
-    drawPixel(nX, nY, mLineColor);
+    drawPixel(nX, nY, *moLineColor);
 }
 
 void SkiaSalGraphicsImpl::drawPixel(tools::Long nX, tools::Long nY, Color nColor)
 {
-    if (nColor == SALCOLOR_NONE)
-        return;
     preDraw();
     SAL_INFO("vcl.skia.trace", "drawpixel(" << this << "): " << Point(nX, nY) << ":" << nColor);
     addUpdateRegion(SkRect::MakeXYWH(nX, nY, 1, 1));
@@ -712,11 +710,11 @@ void SkiaSalGraphicsImpl::drawPixel(tools::Long nX, tools::Long nY, Color nColor
 void SkiaSalGraphicsImpl::drawLine(tools::Long nX1, tools::Long nY1, tools::Long nX2,
                                    tools::Long nY2)
 {
-    if (mLineColor == SALCOLOR_NONE)
+    if (!moLineColor)
         return;
     preDraw();
     SAL_INFO("vcl.skia.trace", "drawline(" << this << "): " << Point(nX1, nY1) << "->"
-                                           << Point(nX2, nY2) << ":" << mLineColor);
+                                           << Point(nX2, nY2) << ":" << *moLineColor);
     addUpdateRegion(SkRect::MakeLTRB(nX1, nY1, nX2, nY2).makeSorted());
     SkPaint paint = makeLinePaint();
     paint.setAntiAlias(mParent.getAntiAlias());
@@ -736,22 +734,23 @@ void SkiaSalGraphicsImpl::privateDrawAlphaRect(tools::Long nX, tools::Long nY, t
                                                bool blockAA)
 {
     preDraw();
-    SAL_INFO("vcl.skia.trace",
-             "privatedrawrect(" << this << "): " << SkIRect::MakeXYWH(nX, nY, nWidth, nHeight)
-                                << ":" << mLineColor << ":" << mFillColor << ":" << fTransparency);
+    SAL_INFO("vcl.skia.trace", "privatedrawrect("
+                                   << this << "): " << SkIRect::MakeXYWH(nX, nY, nWidth, nHeight)
+                                   << ":" << *moLineColor << ":" << *moFillColor << ":"
+                                   << fTransparency);
     addUpdateRegion(SkRect::MakeXYWH(nX, nY, nWidth, nHeight));
     SkCanvas* canvas = getDrawCanvas();
-    if (mFillColor != SALCOLOR_NONE)
+    if (moFillColor)
     {
         SkPaint paint = makeFillPaint(fTransparency);
         paint.setAntiAlias(!blockAA && mParent.getAntiAlias());
         // HACK: If the polygon is just a line, it still should be drawn. But when filling
         // Skia doesn't draw empty polygons, so in that case ensure the line is drawn.
-        if (mLineColor == SALCOLOR_NONE && SkSize::Make(nWidth, nHeight).isEmpty())
+        if (!moLineColor && SkSize::Make(nWidth, nHeight).isEmpty())
             paint.setStyle(SkPaint::kStroke_Style);
         canvas->drawIRect(SkIRect::MakeXYWH(nX, nY, nWidth, nHeight), paint);
     }
-    if (mLineColor != SALCOLOR_NONE && mLineColor != mFillColor) // otherwise handled by fill
+    if (moLineColor && moLineColor != moFillColor) // otherwise handled by fill
     {
         SkPaint paint = makeLinePaint(fTransparency);
         paint.setAntiAlias(!blockAA && mParent.getAntiAlias());
@@ -828,8 +827,8 @@ bool SkiaSalGraphicsImpl::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectTo
                                           const basegfx::B2DPolyPolygon& rPolyPolygon,
                                           double fTransparency)
 {
-    const bool bHasFill(mFillColor != SALCOLOR_NONE);
-    const bool bHasLine(mLineColor != SALCOLOR_NONE);
+    const bool bHasFill(moFillColor.has_value());
+    const bool bHasLine(moLineColor.has_value());
 
     if (rPolyPolygon.count() == 0 || !(bHasFill || bHasLine) || fTransparency < 0.0
         || fTransparency >= 1.0)
@@ -839,7 +838,7 @@ bool SkiaSalGraphicsImpl::drawPolyPolygon(const basegfx::B2DHomMatrix& rObjectTo
     aPolyPolygon.transform(rObjectToDevice);
 
     SAL_INFO("vcl.skia.trace", "drawpolypolygon(" << this << "): " << aPolyPolygon << ":"
-                                                  << mLineColor << ":" << mFillColor);
+                                                  << *moLineColor << ":" << *moFillColor);
 
     if (delayDrawPolyPolygon(aPolyPolygon, fTransparency))
     {
@@ -880,17 +879,17 @@ void SkiaSalGraphicsImpl::performDrawPolyPolygon(const basegfx::B2DPolyPolygon&
         const SkScalar posFix = useAA ? toSkXYFix : 0;
         polygonPath.offset(toSkX(0) + posFix, toSkY(0) + posFix, nullptr);
     }
-    if (mFillColor != SALCOLOR_NONE)
+    if (moFillColor)
     {
         SkPaint aPaint = makeFillPaint(fTransparency);
         aPaint.setAntiAlias(useAA);
         // HACK: If the polygon is just a line, it still should be drawn. But when filling
         // Skia doesn't draw empty polygons, so in that case ensure the line is drawn.
-        if (mLineColor == SALCOLOR_NONE && polygonPath.getBounds().isEmpty())
+        if (!moLineColor && polygonPath.getBounds().isEmpty())
             aPaint.setStyle(SkPaint::kStroke_Style);
         getDrawCanvas()->drawPath(polygonPath, aPaint);
     }
-    if (mLineColor != SALCOLOR_NONE && mLineColor != mFillColor) // otherwise handled by fill
+    if (moLineColor && moLineColor != moFillColor) // otherwise handled by fill
     {
         SkPaint aPaint = makeLinePaint(fTransparency);
         aPaint.setAntiAlias(useAA);
@@ -934,7 +933,7 @@ bool SkiaSalGraphicsImpl::delayDrawPolyPolygon(const basegfx::B2DPolyPolygon& aP
     if (!mParent.getAntiAlias())
         return false;
     // Only filled polygons without an outline are problematic.
-    if (mFillColor == SALCOLOR_NONE || mLineColor != SALCOLOR_NONE)
+    if (!moFillColor || moLineColor)
         return false;
     // Merge only simple polygons, real polypolygons most likely aren't needlessly split,
     // so they do not need joining.
@@ -1026,14 +1025,14 @@ bool SkiaSalGraphicsImpl::drawPolyLine(const basegfx::B2DHomMatrix& rObjectToDev
                                        css::drawing::LineCap eLineCap, double fMiterMinimumAngle,
                                        bool bPixelSnapHairline)
 {
-    if (!rPolyLine.count() || fTransparency < 0.0 || fTransparency > 1.0
-        || mLineColor == SALCOLOR_NONE)
+    if (!rPolyLine.count() || fTransparency < 0.0 || fTransparency > 1.0 || !moLineColor)
     {
         return true;
     }
 
     preDraw();
-    SAL_INFO("vcl.skia.trace", "drawpolyline(" << this << "): " << rPolyLine << ":" << mLineColor);
+    SAL_INFO("vcl.skia.trace",
+             "drawpolyline(" << this << "): " << rPolyLine << ":" << *moLineColor);
 
     // Adjust line width for object-to-device scale.
     fLineWidth = (rObjectToDevice * basegfx::B2DVector(fLineWidth, 0)).getLength();
diff --git a/vcl/skia/osx/gdiimpl.cxx b/vcl/skia/osx/gdiimpl.cxx
index 1c1b7d2955c3..17a02fd441cf 100644
--- a/vcl/skia/osx/gdiimpl.cxx
+++ b/vcl/skia/osx/gdiimpl.cxx
@@ -239,10 +239,10 @@ bool AquaSkiaSalGraphicsImpl::drawNativeControl(ControlType nType, ControlPart n
     // Setup context state for drawing (performDrawNativeControl() e.g. fills background in some cases).
     CGContextSetFillColorSpace(context, GetSalData()->mxRGBSpace);
     CGContextSetStrokeColorSpace(context, GetSalData()->mxRGBSpace);
-    RGBAColor lineColor(mLineColor);
+    RGBAColor lineColor(*moLineColor);
     CGContextSetRGBStrokeColor(context, lineColor.GetRed(), lineColor.GetGreen(),
                                lineColor.GetBlue(), lineColor.GetAlpha());
-    RGBAColor fillColor(mFillColor);
+    RGBAColor fillColor(*moFillColor);
     CGContextSetRGBFillColor(context, fillColor.GetRed(), fillColor.GetGreen(), fillColor.GetBlue(),
                              fillColor.GetAlpha());
     // Adjust for our drawn-to coordinates in the bitmap.
diff --git a/vcl/unx/generic/app/saldisp.cxx b/vcl/unx/generic/app/saldisp.cxx
index ca3e715bc78a..edb14824c246 100644
--- a/vcl/unx/generic/app/saldisp.cxx
+++ b/vcl/unx/generic/app/saldisp.cxx
@@ -2767,11 +2767,13 @@ bool SalColormap::GetXPixels( XColor &rColor,
     return GetXPixel( rColor, r^0xFF, g^0xFF, b^0xFF );
 }
 
-Pixel SalColormap::GetPixel( Color nColor ) const
+Pixel SalColormap::GetPixel( std::optional<Color> oColor ) const
 {
-    if( SALCOLOR_NONE == nColor )  return 0;
-    if( COL_BLACK == nColor ) return m_nBlackPixel;
-    if( COL_WHITE == nColor ) return m_nWhitePixel;
+    if( !oColor )  return 0;
+    if( COL_BLACK == oColor ) return m_nBlackPixel;
+    if( COL_WHITE == oColor ) return m_nWhitePixel;
+
+    Color nColor = *oColor;
 
     if( m_aVisual.GetClass() == TrueColor )
         return m_aVisual.GetTCPixel( nColor );
diff --git a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
index d655b1d8fb16..60cbf1230400 100644
--- a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
+++ b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.cxx
@@ -25,8 +25,8 @@
 X11CairoSalGraphicsImpl::X11CairoSalGraphicsImpl(X11SalGraphics& rParent, X11Common& rX11Common)
     : X11SalGraphicsImpl(rParent)
     , mrX11Common(rX11Common)
-    , mnPenColor(SALCOLOR_NONE)
-    , mnFillColor(SALCOLOR_NONE)
+    , moPenColor(std::nullopt)
+    , moFillColor(std::nullopt)
 {
 }
 
@@ -36,7 +36,7 @@ void X11CairoSalGraphicsImpl::drawPolyPolygon(sal_uInt32 nPoly, const sal_uInt32
     cairo_t* cr = mrX11Common.getCairoContext(mrParent.GetGeometryProvider());
     clipRegion(cr);
 
-    CairoCommon::drawPolyPolygon(cr, nullptr, mnPenColor, mnFillColor, getAntiAlias(), nPoly,
+    CairoCommon::drawPolyPolygon(cr, nullptr, moPenColor, moFillColor, getAntiAlias(), nPoly,
                                  pPoints, pPtAry);
 
     X11Common::releaseCairoContext(cr);
@@ -49,7 +49,7 @@ bool X11CairoSalGraphicsImpl::drawPolyPolygon(const basegfx::B2DHomMatrix& rObje
     cairo_t* cr = mrX11Common.getCairoContext(mrParent.GetGeometryProvider());
     clipRegion(cr);
 
-    bool bRetVal(CairoCommon::drawPolyPolygon(cr, nullptr, mnPenColor, mnFillColor, getAntiAlias(),
+    bool bRetVal(CairoCommon::drawPolyPolygon(cr, nullptr, moPenColor, moFillColor, getAntiAlias(),
                                               rObjectToDevice, rPolyPolygon, fTransparency));
 
     X11Common::releaseCairoContext(cr);
@@ -58,7 +58,7 @@ bool X11CairoSalGraphicsImpl::drawPolyPolygon(const basegfx::B2DHomMatrix& rObje
 
 void X11CairoSalGraphicsImpl::drawPixel(tools::Long nX, tools::Long nY)
 {
-    drawPixel(nX, nY, mnPenColor);
+    drawPixel(nX, nY, *moPenColor);
 }
 
 void X11CairoSalGraphicsImpl::drawPixel(tools::Long nX, tools::Long nY, Color nColor)
@@ -88,7 +88,7 @@ void X11CairoSalGraphicsImpl::drawLine(tools::Long nX1, tools::Long nY1, tools::
     cairo_t* cr = mrX11Common.getCairoContext(mrParent.GetGeometryProvider());
     clipRegion(cr);
 
-    CairoCommon::drawLine(cr, nullptr, mnPenColor, getAntiAlias(), nX1, nY1, nX2, nY2);
+    CairoCommon::drawLine(cr, nullptr, *moPenColor, getAntiAlias(), nX1, nY1, nX2, nY2);
 
     X11Common::releaseCairoContext(cr);
 }
@@ -111,7 +111,7 @@ bool X11CairoSalGraphicsImpl::drawPolyLine(const basegfx::B2DHomMatrix& rObjectT
     // Use the now available static drawPolyLine from the Cairo-Headless-Fallback
     // that will take care of all needed stuff
     const bool bRetval(CairoCommon::drawPolyLine(
-        cr, nullptr, mnPenColor, getAntiAlias(), rObjectToDevice, rPolyLine, fTransparency,
+        cr, nullptr, *moPenColor, getAntiAlias(), rObjectToDevice, rPolyLine, fTransparency,
         fLineWidth, pStroke, eLineJoin, eLineCap, fMiterMinimumAngle, bPixelSnapHairline));
 
     X11Common::releaseCairoContext(cr);
@@ -125,7 +125,7 @@ bool X11CairoSalGraphicsImpl::drawAlphaRect(tools::Long nX, tools::Long nY, tool
     cairo_t* cr = mrX11Common.getCairoContext(mrParent.GetGeometryProvider());
     clipRegion(cr);
 
-    const bool bRetval(CairoCommon::drawAlphaRect(cr, nullptr, mnPenColor, mnFillColor, nX, nY,
+    const bool bRetval(CairoCommon::drawAlphaRect(cr, nullptr, *moPenColor, *moFillColor, nX, nY,
                                                   nWidth, nHeight, nTransparency));
 
     X11Common::releaseCairoContext(cr);
diff --git a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
index 8e8cf4c68b0f..a1b5b6d475e7 100644
--- a/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
+++ b/vcl/unx/generic/gdi/X11CairoSalGraphicsImpl.hxx
@@ -29,8 +29,8 @@ class X11CairoSalGraphicsImpl : public X11SalGraphicsImpl
 private:
     X11Common& mrX11Common;
     vcl::Region maClipRegion;
-    Color mnPenColor;
-    Color mnFillColor;
+    std::optional<Color> moPenColor;
+    std::optional<Color> moFillColor;
 
     using X11SalGraphicsImpl::drawPolyLine;
 
@@ -51,25 +51,25 @@ public:
 
     void SetLineColor() override
     {
-        mnPenColor = SALCOLOR_NONE;
+        moPenColor = std::nullopt;
         X11SalGraphicsImpl::SetLineColor();
     }
 
     void SetLineColor(Color nColor) override
     {
-        mnPenColor = nColor;
+        moPenColor = nColor;
         X11SalGraphicsImpl::SetLineColor(nColor);
     }
 
     void SetFillColor() override
     {
-        mnFillColor = SALCOLOR_NONE;
+        moFillColor = std::nullopt;
         X11SalGraphicsImpl::SetFillColor();
     }
 
     void SetFillColor(Color nColor) override
     {
-        mnFillColor = nColor;
+        moFillColor = nColor;
         X11SalGraphicsImpl::SetFillColor(nColor);
     }
 
diff --git a/vcl/unx/generic/gdi/gdiimpl.cxx b/vcl/unx/generic/gdi/gdiimpl.cxx
index fc24b6b9969a..2afee55b9a99 100644
--- a/vcl/unx/generic/gdi/gdiimpl.cxx
+++ b/vcl/unx/generic/gdi/gdiimpl.cxx
@@ -121,7 +121,7 @@ namespace
 
 X11SalGraphicsImpl::X11SalGraphicsImpl(X11SalGraphics& rParent):
     mrParent(rParent),
-    mnBrushColor( 0xFF, 0xFF, 0XFF ),
+    moBrushColor( std::in_place, 0xFF, 0xFF, 0XFF ),
     mpBrushGC(nullptr),
     mnBrushPixel(0),
     mbPenGC(false),
@@ -134,7 +134,7 @@ X11SalGraphicsImpl::X11SalGraphicsImpl(X11SalGraphics& rParent):
     mbDitherBrush(false),
     mbXORMode(false),
     mpPenGC(nullptr),
-    mnPenColor( 0x00, 0x00, 0x00 ),
+    moPenColor( std::in_place, 0x00, 0x00, 0x00 ),
     mnPenPixel(0),
     mpMonoGC(nullptr),
     mpCopyGC(nullptr),
@@ -152,8 +152,8 @@ X11SalGraphicsImpl::~X11SalGraphicsImpl()
 
 void X11SalGraphicsImpl::Init()
 {
-    mnPenPixel = mrParent.GetPixel( mnPenColor );
-    mnBrushPixel = mrParent.GetPixel( mnBrushColor );
+    mnPenPixel = mrParent.GetPixel( *moPenColor );
+    mnBrushPixel = mrParent.GetPixel( *moBrushColor );
 }
 
 XID X11SalGraphicsImpl::GetXRenderPicture()
@@ -344,7 +344,7 @@ GC X11SalGraphicsImpl::SelectBrush()
 {
     Display *pDisplay = mrParent.GetXDisplay();
 
-    SAL_WARN_IF( mnBrushColor == SALCOLOR_NONE, "vcl", "Brush Transparent" );
+    SAL_WARN_IF( !moBrushColor, "vcl", "Brush Transparent" );
 
     if( !mpBrushGC )
     {
@@ -397,7 +397,7 @@ GC X11SalGraphicsImpl::SelectPen()
 
     if( !mbPenGC )
     {
-        if( mnPenColor != SALCOLOR_NONE )
+        if( moPenColor )
             XSetForeground( pDisplay, mpPenGC, mnPenPixel );
         XSetFunction  ( pDisplay, mpPenGC, mbXORMode ? GXxor : GXcopy );
         mrParent.SetClipRegion( mpPenGC );
@@ -978,18 +978,18 @@ void X11SalGraphicsImpl::setClipRegion( const vcl::Region& i_rClip )
 
 void X11SalGraphicsImpl::SetLineColor()
 {
-    if( mnPenColor != SALCOLOR_NONE )
+    if( moPenColor )
     {
-        mnPenColor      = SALCOLOR_NONE;
+        moPenColor      = std::nullopt;
         mbPenGC         = false;
     }
 }
 
 void X11SalGraphicsImpl::SetLineColor( Color nColor )
 {
-    if( mnPenColor != nColor )
+    if( moPenColor != nColor )
     {
-        mnPenColor      = nColor;
+        moPenColor      = nColor;
         mnPenPixel      = mrParent.GetPixel( nColor );
         mbPenGC         = false;
     }
@@ -997,24 +997,24 @@ void X11SalGraphicsImpl::SetLineColor( Color nColor )
 
 void X11SalGraphicsImpl::SetFillColor()
 {
-    if( mnBrushColor != SALCOLOR_NONE )
+    if( moBrushColor )
     {
         mbDitherBrush   = false;
-        mnBrushColor    = SALCOLOR_NONE;
+        moBrushColor    = std::nullopt;
         mbBrushGC       = false;
     }
 }
 
 void X11SalGraphicsImpl::SetFillColor( Color nColor )
 {
-    if( mnBrushColor == nColor )
+    if( moBrushColor == nColor )
         return;
 
     mbDitherBrush   = false;
-    mnBrushColor    = nColor;
+    moBrushColor    = nColor;
     mnBrushPixel    = mrParent.GetPixel( nColor );
     if( TrueColor != mrParent.GetColormap().GetVisual().GetClass()
-        && mrParent.GetColormap().GetColor( mnBrushPixel ) != mnBrushColor
+        && mrParent.GetColormap().GetColor( mnBrushPixel ) != moBrushColor
         && nColor != Color( 0x00, 0x00, 0x00 ) // black
         && nColor != Color( 0x00, 0x00, 0x80 ) // blue
         && nColor != Color( 0x00, 0x80, 0x00 ) // green
@@ -1049,7 +1049,7 @@ void X11SalGraphicsImpl::SetROPLineColor( SalROPColor nROPColor )
             mnPenPixel = static_cast<Pixel>(1 << mrParent.GetVisual().GetDepth()) - 1;
             break;
     }
-    mnPenColor  = mrParent.GetColormap().GetColor( mnPenPixel );
+    moPenColor  = mrParent.GetColormap().GetColor( mnPenPixel );
     mbPenGC     = false;
 }
 
@@ -1068,7 +1068,7 @@ void X11SalGraphicsImpl::SetROPFillColor( SalROPColor nROPColor )
             break;
     }
     mbDitherBrush   = false;
-    mnBrushColor    = mrParent.GetColormap().GetColor( mnBrushPixel );
+    moBrushColor    = mrParent.GetColormap().GetColor( mnBrushPixel );
     mbBrushGC       = false;
 }
 
@@ -1089,13 +1089,13 @@ void X11SalGraphicsImpl::SetXORMode( bool bSet, bool )
 
 void X11SalGraphicsImpl::internalDrawPixel( tools::Long nX, tools::Long nY )
 {
-    if( mnPenColor !=  SALCOLOR_NONE )
+    if( moPenColor )
         XDrawPoint( mrParent.GetXDisplay(), mrParent.GetDrawable(), SelectPen(), nX, nY );
 }
 
 void X11SalGraphicsImpl::internalDrawLine( tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2 )
 {
-    if( mnPenColor != SALCOLOR_NONE )
+    if( moPenColor )
     {
         XDrawLine( mrParent.GetXDisplay(), mrParent.GetDrawable(),SelectPen(),
                    nX1, nY1, nX2, nY2 );
@@ -1104,7 +1104,7 @@ void X11SalGraphicsImpl::internalDrawLine( tools::Long nX1, tools::Long nY1, too
 
 void X11SalGraphicsImpl::drawRect( tools::Long nX, tools::Long nY, tools::Long nDX, tools::Long nDY )
 {
-    if( mnBrushColor != SALCOLOR_NONE )
+    if( moBrushColor )
     {
         XFillRectangle( mrParent.GetXDisplay(),
                         mrParent.GetDrawable(),
@@ -1112,7 +1112,7 @@ void X11SalGraphicsImpl::drawRect( tools::Long nX, tools::Long nY, tools::Long n
                         nX, nY, nDX, nDY );
     }
     // description DrawRect is wrong; thus -1
-    if( mnPenColor != SALCOLOR_NONE )
+    if( moPenColor )
         XDrawRectangle( mrParent.GetXDisplay(),
                         mrParent.GetDrawable(),
                         SelectPen(),
@@ -1121,7 +1121,7 @@ void X11SalGraphicsImpl::drawRect( tools::Long nX, tools::Long nY, tools::Long n
 
 void X11SalGraphicsImpl::drawPolyLine( sal_uInt32 nPoints, const Point *pPtAry )
 {
-    if( mnPenColor != SALCOLOR_NONE )
+    if( moPenColor )
     {
         SalPolyLine Points( nPoints, pPtAry );
 
@@ -1184,14 +1184,14 @@ void X11SalGraphicsImpl::drawPolygon( sal_uInt32 nPoints, const Point* pPtAry )
         }
     }
 
-    if( mnBrushColor != SALCOLOR_NONE )
+    if( moBrushColor )
         XFillPolygon( mrParent.GetXDisplay(),
                       mrParent.GetDrawable(),
                       SelectBrush(),
                       &Points[0], nPoints,
                       Complex, CoordModeOrigin );
 
-    if( mnPenColor != SALCOLOR_NONE )
+    if( moPenColor )
         DrawLines( nPoints, Points, SelectPen(), true );
 }
 
@@ -1334,7 +1334,7 @@ bool X11SalGraphicsImpl::drawFilledTriangles(
     }
 
     // set polygon foreground color and opacity
-    XRenderColor aRenderColor = GetXRenderColor( mnBrushColor , fTransparency );
+    XRenderColor aRenderColor = GetXRenderColor( *moBrushColor , fTransparency );
     rRenderPeer.FillRectangle( PictOpSrc, rEntry.m_aPicture, &aRenderColor, 0, 0, 1, 1 );
 
     // set clipping
@@ -1604,8 +1604,8 @@ bool X11SalGraphicsImpl::drawPolyLine(
 
     // temporarily adjust brush color to pen color
     // since the line is drawn as an area-polygon
-    const Color aKeepBrushColor = mnBrushColor;
-    mnBrushColor = mnPenColor;
+    const std::optional<Color> aKeepBrushColor = moBrushColor;
+    moBrushColor = moPenColor;
 
     // create the area-polygon for the line
     const bool bDrawnOk(
@@ -1615,7 +1615,7 @@ bool X11SalGraphicsImpl::drawPolyLine(
             fTransparency));
 
     // restore the original brush GC
-    mnBrushColor = aKeepBrushColor;
+    moBrushColor = aKeepBrushColor;
     return bDrawnOk;
 }
 
diff --git a/vcl/unx/generic/gdi/gdiimpl.hxx b/vcl/unx/generic/gdi/gdiimpl.hxx
index 7b8dca9f5009..4eaf19d2c8ae 100644
--- a/vcl/unx/generic/gdi/gdiimpl.hxx
+++ b/vcl/unx/generic/gdi/gdiimpl.hxx
@@ -28,6 +28,7 @@
 #include <basegfx/polygon/b2dtrapezoid.hxx>
 #include <basegfx/polygon/b2dpolygontriangulator.hxx>
 #include <ControlCacheKey.hxx>
+#include <optional>
 
 /* From <X11/Intrinsic.h> */
 typedef unsigned long Pixel;
@@ -44,7 +45,7 @@ protected:
     X11SalGraphics& mrParent;
 
 private:
-    Color mnBrushColor;
+    std::optional<Color> moBrushColor;
     GC mpBrushGC;      // Brush attributes
     Pixel mnBrushPixel;
 
@@ -60,7 +61,7 @@ private:
     bool mbXORMode : 1;      // is ROP XOR Mode set
 
     GC mpPenGC;        // Pen attributes
-    Color mnPenColor;
+    std::optional<Color> moPenColor;
     Pixel mnPenPixel;