Resolves: #i123500# redefined ColorModifiers and ColorModifierStack...

redefined GraphicAttr to be expressed as primitives if needed, enhanced render
and export quality if graphic is modified using graphic attributes

(cherry picked from commit 1e79e8da3f8042f7d7bd94b2c9f03cff7545b05c)

Conflicts:
	basegfx/inc/basegfx/color/bcolor.hxx
	basegfx/inc/basegfx/color/bcolormodifier.hxx
	basegfx/source/color/bcolormodifier.cxx
	drawinglayer/inc/drawinglayer/primitive2d/graphicprimitivehelper2d.hxx
	drawinglayer/inc/drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx
	drawinglayer/inc/drawinglayer/primitive3d/modifiedcolorprimitive3d.hxx
	drawinglayer/source/primitive2d/graphicprimitive2d.cxx
	drawinglayer/source/primitive2d/graphicprimitivehelper2d.cxx
	drawinglayer/source/primitive2d/modifiedcolorprimitive2d.cxx
	drawinglayer/source/primitive3d/modifiedcolorprimitive3d.cxx

Change-Id: Ief2172efc9cc1b9838de48ec7f536c05573c7dc3

1 files changed, 301 insertions, 33 deletions

diff --git a/basegfx/source/color/bcolormodifier.cxx b/basegfx/source/color/bcolormodifier.cxx
index a53715b62304..c1f70267769c 100644
--- a/basegfx/source/color/bcolormodifier.cxx
+++ b/basegfx/source/color/bcolormodifier.cxx
@@ -23,47 +23,315 @@
 
 namespace basegfx
 {
-    ::basegfx::BColor BColorModifier::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    BColorModifier::~BColorModifier()
     {
-        switch(meMode)
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_gray::~BColorModifier_gray()
+    {
+    }
+
+    bool BColorModifier_gray::operator==(const BColorModifier& rCompare) const
+    {
+        return 0 != dynamic_cast< const BColorModifier_gray* >(&rCompare);
+    }
+
+    ::basegfx::BColor BColorModifier_gray::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    {
+        const double fLuminance(aSourceColor.luminance());
+
+        return ::basegfx::BColor(fLuminance, fLuminance, fLuminance);
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_invert::~BColorModifier_invert()
+    {
+    }
+
+    bool BColorModifier_invert::operator==(const BColorModifier& rCompare) const
+    {
+        return 0 != dynamic_cast< const BColorModifier_invert* >(&rCompare);
+    }
+
+    ::basegfx::BColor BColorModifier_invert::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    {
+        return ::basegfx::BColor(1.0 - aSourceColor.getRed(), 1.0 - aSourceColor.getGreen(), 1.0 - aSourceColor.getBlue());
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_luminance_to_alpha::~BColorModifier_luminance_to_alpha()
+    {
+    }
+
+    bool BColorModifier_luminance_to_alpha::operator==(const BColorModifier& rCompare) const
+    {
+        return 0 != dynamic_cast< const BColorModifier_luminance_to_alpha* >(&rCompare);
+    }
+
+    ::basegfx::BColor BColorModifier_luminance_to_alpha::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    {
+        const double fAlpha(1.0 - ((aSourceColor.getRed() * 0.2125) + (aSourceColor.getGreen() * 0.7154) + (aSourceColor.getBlue() * 0.0721)));
+
+        return ::basegfx::BColor(fAlpha, fAlpha, fAlpha);
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_replace::~BColorModifier_replace()
+    {
+    }
+
+    bool BColorModifier_replace::operator==(const BColorModifier& rCompare) const
+    {
+        const BColorModifier_replace* pCompare = dynamic_cast< const BColorModifier_replace* >(&rCompare);
+
+        if(!pCompare)
         {
-            case BCOLORMODIFYMODE_INTERPOLATE :
-            {
-                return interpolate(maBColor, aSourceColor, mfValue);
-            }
-            case BCOLORMODIFYMODE_GRAY :
-            {
-                const double fLuminance(aSourceColor.luminance());
-                return ::basegfx::BColor(fLuminance, fLuminance, fLuminance);
-            }
-            case BCOLORMODIFYMODE_BLACKANDWHITE :
-            {
-                const double fLuminance(aSourceColor.luminance());
-
-                if(fLuminance < mfValue)
-                {
-                    return ::basegfx::BColor::getEmptyBColor();
-                }
-                else
-                {
-                    return ::basegfx::BColor(1.0, 1.0, 1.0);
-                }
-            }
-            case BCOLORMODIFYMODE_INVERT :
-            {
-                return ::basegfx::BColor(1.0 - aSourceColor.getRed(), 1.0 - aSourceColor.getGreen(), 1.0 - aSourceColor.getBlue());
-            }
-            case BCOLORMODIFYMODE_LUMINANCE_TO_ALPHA:
+            return false;
+        }
+
+        return getBColor() == pCompare->getBColor();
+    }
+
+    ::basegfx::BColor BColorModifier_replace::getModifiedColor(const ::basegfx::BColor& /*aSourceColor*/) const
+    {
+        return maBColor;
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_interpolate::~BColorModifier_interpolate()
+    {
+    }
+
+    bool BColorModifier_interpolate::operator==(const BColorModifier& rCompare) const
+    {
+        const BColorModifier_interpolate* pCompare = dynamic_cast< const BColorModifier_interpolate* >(&rCompare);
+
+        if(!pCompare)
+        {
+            return false;
+        }
+
+        return getBColor() == pCompare->getBColor() && getValue() == pCompare->getValue();
+    }
+
+    ::basegfx::BColor BColorModifier_interpolate::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    {
+        return interpolate(maBColor, aSourceColor, mfValue);
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_black_and_white::~BColorModifier_black_and_white()
+    {
+    }
+
+    bool BColorModifier_black_and_white::operator==(const BColorModifier& rCompare) const
+    {
+        const BColorModifier_black_and_white* pCompare = dynamic_cast< const BColorModifier_black_and_white* >(&rCompare);
+
+        if(!pCompare)
+        {
+            return false;
+        }
+
+        return getValue() == pCompare->getValue();
+    }
+
+    ::basegfx::BColor BColorModifier_black_and_white::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    {
+        const double fLuminance(aSourceColor.luminance());
+
+        if(fLuminance < mfValue)
+        {
+            return ::basegfx::BColor::getEmptyBColor();
+        }
+        else
+        {
+            return ::basegfx::BColor(1.0, 1.0, 1.0);
+        }
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_gamma::BColorModifier_gamma(double fValue)
+    :   BColorModifier(),
+        mfValue(fValue),
+        mfInvValue(fValue),
+        mbUseIt(!basegfx::fTools::equal(fValue, 1.0) && basegfx::fTools::more(fValue, 0.0) && basegfx::fTools::lessOrEqual(fValue, 10.0))
+    {
+        if(mbUseIt)
+        {
+            mfInvValue = 1.0 / mfValue;
+        }
+    }
+
+    BColorModifier_gamma::~BColorModifier_gamma()
+    {
+    }
+
+    bool BColorModifier_gamma::operator==(const BColorModifier& rCompare) const
+    {
+        const BColorModifier_gamma* pCompare = dynamic_cast< const BColorModifier_gamma* >(&rCompare);
+
+        if(!pCompare)
+        {
+            return false;
+        }
+
+        // getValue is sufficient, mfInvValue and mbUseIt are only helper values
+        return getValue() == pCompare->getValue();
+    }
+
+    ::basegfx::BColor BColorModifier_gamma::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    {
+        if(mbUseIt)
+        {
+            ::basegfx::BColor aRetval(
+                pow(aSourceColor.getRed(), mfInvValue),
+                pow(aSourceColor.getGreen(), mfInvValue),
+                pow(aSourceColor.getBlue(), mfInvValue));
+
+            aRetval.clamp();
+            return aRetval;
+        }
+        else
+        {
+            return aSourceColor;
+        }
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    BColorModifier_RGBLuminanceContrast::BColorModifier_RGBLuminanceContrast(double fRed, double fGreen, double fBlue, double fLuminance, double fContrast)
+    :   BColorModifier(),
+        mfRed(basegfx::clamp(fRed, -1.0, 1.0)),
+        mfGreen(basegfx::clamp(fGreen, -1.0, 1.0)),
+        mfBlue(basegfx::clamp(fBlue, -1.0, 1.0)),
+        mfLuminance(basegfx::clamp(fLuminance, -1.0, 1.0)),
+        mfContrast(basegfx::clamp(fContrast, -1.0, 1.0)),
+        mfContrastOff(1.0),
+        mfRedOff(0.0),
+        mfGreenOff(0.0),
+        mfBlueOff(0.0),
+        mbUseIt(false)
+    {
+        if(!basegfx::fTools::equalZero(mfRed)
+            || !basegfx::fTools::equalZero(mfGreen)
+            || !basegfx::fTools::equalZero(mfBlue)
+            || !basegfx::fTools::equalZero(mfLuminance)
+            || !basegfx::fTools::equalZero(mfContrast))
+        {
+            // calculate slope
+            if(mfContrast >= 0.0)
             {
-                const double fAlpha(1.0 - ((aSourceColor.getRed() * 0.2125) + (aSourceColor.getGreen() * 0.7154) + (aSourceColor.getBlue() * 0.0721)));
-                return ::basegfx::BColor(fAlpha, fAlpha, fAlpha);
+                mfContrastOff = 128.0 / (128.0 - (mfContrast * 127.0));
             }
-            default : // BCOLORMODIFYMODE_REPLACE
+            else
             {
-                return maBColor;
+                mfContrastOff = ( 128.0 + (mfContrast * 127.0)) / 128.0;
             }
+
+            // calculate unified contrast offset
+            const double fPreparedContrastOff((128.0 - mfContrastOff * 128.0) / 255.0);
+            const double fCombinedOffset(mfLuminance + fPreparedContrastOff);
+
+            // set full offsets
+            mfRedOff = mfRed + fCombinedOffset;
+            mfGreenOff = mfGreen + fCombinedOffset;
+            mfBlueOff = mfBlue + fCombinedOffset;
+
+            mbUseIt = true;
         }
     }
+
+    BColorModifier_RGBLuminanceContrast::~BColorModifier_RGBLuminanceContrast()
+    {
+    }
+
+    bool BColorModifier_RGBLuminanceContrast::operator==(const BColorModifier& rCompare) const
+    {
+        const BColorModifier_RGBLuminanceContrast* pCompare = dynamic_cast< const BColorModifier_RGBLuminanceContrast* >(&rCompare);
+
+        if(!pCompare)
+        {
+            return false;
+        }
+
+        // no need to compare other values, these are just helpers
+        return getRed() == pCompare->getRed()
+            && getGreen() == pCompare->getGreen()
+            && getBlue() == pCompare->getBlue()
+            && getLuminance() == pCompare->getLuminance()
+            && getContrast() == pCompare->getContrast();
+    }
+
+    ::basegfx::BColor BColorModifier_RGBLuminanceContrast::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
+    {
+        if(mbUseIt)
+        {
+            return basegfx::BColor(
+                basegfx::clamp(aSourceColor.getRed() * mfContrastOff + mfRedOff, 0.0, 1.0),
+                basegfx::clamp(aSourceColor.getGreen() * mfContrastOff + mfGreenOff, 0.0, 1.0),
+                basegfx::clamp(aSourceColor.getBlue() * mfContrastOff + mfBlueOff, 0.0, 1.0));
+        }
+        else
+        {
+            return aSourceColor;
+        }
+    }
+} // end of namespace basegfx
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace basegfx
+{
+    ::basegfx::BColor BColorModifierStack::getModifiedColor(const ::basegfx::BColor& rSource) const
+    {
+        if(maBColorModifiers.empty())
+        {
+            return rSource;
+        }
+
+        ::basegfx::BColor aRetval(rSource);
+
+        for(sal_uInt32 a(maBColorModifiers.size()); a;)
+        {
+            a--;
+            aRetval = maBColorModifiers[a]->getModifiedColor(aRetval);
+        }
+
+        return aRetval;
+    }
 } // end of namespace basegfx
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */