#119125# corected gradient rendering, added stuff to add Title and Description to primitives for later usage

6 files changed, 85 insertions, 59 deletions

diff --git a/drawinglayer/Library_drawinglayer.mk b/drawinglayer/Library_drawinglayer.mk
index 5e80ba2fcc4a..fe9882b0eb4b 100644
--- a/drawinglayer/Library_drawinglayer.mk
+++ b/drawinglayer/Library_drawinglayer.mk
@@ -111,6 +111,7 @@ $(eval $(call gb_Library_add_exception_objects,drawinglayer,\
 	drawinglayer/source/primitive2d/mediaprimitive2d \
 	drawinglayer/source/primitive2d/metafileprimitive2d \
 	drawinglayer/source/primitive2d/modifiedcolorprimitive2d \
+	drawinglayer/source/primitive2d/objectinfoprimitive2d \
 	drawinglayer/source/primitive2d/pagepreviewprimitive2d \
 	drawinglayer/source/primitive2d/patternfillprimitive2d \
 	drawinglayer/source/primitive2d/polypolygonprimitive2d \
diff --git a/drawinglayer/Package_inc.mk b/drawinglayer/Package_inc.mk
index ca9ec4ef7a14..ca7345a9c579 100644
--- a/drawinglayer/Package_inc.mk
+++ b/drawinglayer/Package_inc.mk
@@ -49,6 +49,7 @@ $(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/
 $(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/mediaprimitive2d.hxx,drawinglayer/primitive2d/mediaprimitive2d.hxx))
 $(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/metafileprimitive2d.hxx,drawinglayer/primitive2d/metafileprimitive2d.hxx))
 $(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx,drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx))
+$(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/objectinfoprimitive2d.hxx,drawinglayer/primitive2d/objectinfoprimitive2d.hxx))
 $(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/pagepreviewprimitive2d.hxx,drawinglayer/primitive2d/pagepreviewprimitive2d.hxx))
 $(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/patternfillprimitive2d.hxx,drawinglayer/primitive2d/patternfillprimitive2d.hxx))
 $(eval $(call gb_Package_add_file,drawinglayer_inc,inc/drawinglayer/primitive2d/pointarrayprimitive2d.hxx,drawinglayer/primitive2d/pointarrayprimitive2d.hxx))
diff --git a/drawinglayer/inc/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx b/drawinglayer/inc/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
index 4a57ad4dcaaf..aac9dfb7e170 100644
--- a/drawinglayer/inc/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
@@ -104,6 +104,7 @@
 #define PRIMITIVE2D_ID_SVGRADIALATOMPRIMITIVE2D             (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 65)
 #define PRIMITIVE2D_ID_CROPPRIMITIVE2D                      (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 66)
 #define PRIMITIVE2D_ID_PATTERNFILLPRIMITIVE2D               (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 67)
+#define PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D                (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 68)
 
 //////////////////////////////////////////////////////////////////////////////
 
diff --git a/drawinglayer/inc/drawinglayer/primitive2d/svggradientprimitive2d.hxx b/drawinglayer/inc/drawinglayer/primitive2d/svggradientprimitive2d.hxx
index 5e15c1518ec9..8b8510e7a8ca 100644
--- a/drawinglayer/inc/drawinglayer/primitive2d/svggradientprimitive2d.hxx
+++ b/drawinglayer/inc/drawinglayer/primitive2d/svggradientprimitive2d.hxx
@@ -196,6 +196,7 @@ namespace drawinglayer
                 const basegfx::B2DPoint& rStart,
                 const basegfx::B2DPoint& rEnd,
                 SpreadMethod aSpreadMethod = Spread_pad);
+            virtual ~SvgLinearGradientPrimitive2D();
 
             /// data read access
             const basegfx::B2DPoint& getEnd() const { return maEnd; }
@@ -209,7 +210,7 @@ namespace drawinglayer
             /// provide unique ID
             DeclPrimitrive2DIDBlock()
         };
-} // end of namespace primitive2d
+    } // end of namespace primitive2d
 } // end of namespace drawinglayer
 
 //////////////////////////////////////////////////////////////////////////////
@@ -263,6 +264,7 @@ namespace drawinglayer
                 double fRadius,
                 SpreadMethod aSpreadMethod = Spread_pad,
                 const basegfx::B2DPoint* pFocal = 0);
+            virtual ~SvgRadialGradientPrimitive2D();
 
             /// data read access
             double getRadius() const { return mfRadius; }
diff --git a/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx b/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx
index 57a554fe023a..bd1674e1ca23 100644
--- a/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/svggradientprimitive2d.cxx
@@ -356,13 +356,18 @@ namespace drawinglayer
                         rFrom.getColor(), rFrom.getOffset() + nOffset,
                         rTo.getColor(), rTo.getOffset() + nOffset));
 
-                const double fTransFrom(1.0 - rFrom.getOpacity());
-                const double fTransTo(1.0 - rTo.getOpacity());
+                if(!getFullyOpaque())
+                {
+                    const double fTransFrom(1.0 - rFrom.getOpacity());
+                    const double fTransTo(1.0 - rTo.getOpacity());
+                    const basegfx::BColor aColorFrom(fTransFrom, fTransFrom, fTransFrom);
+                    const basegfx::BColor aColorTo(fTransTo, fTransTo, fTransTo);
 
-                rTargetOpacity.push_back(
-                    new SvgLinearAtomPrimitive2D(
-                        basegfx::BColor(fTransFrom, fTransFrom, fTransFrom), rFrom.getOffset() + nOffset,
-                        basegfx::BColor(fTransTo,fTransTo, fTransTo), rTo.getOffset() + nOffset));
+                    rTargetOpacity.push_back(
+                        new SvgLinearAtomPrimitive2D(
+                            aColorFrom, rFrom.getOffset() + nOffset,
+                            aColorTo, rTo.getOffset() + nOffset));
+                }
             }
         }
 
@@ -537,6 +542,10 @@ namespace drawinglayer
         {
         }
 
+        SvgLinearGradientPrimitive2D::~SvgLinearGradientPrimitive2D()
+        {
+        }
+
         bool SvgLinearGradientPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
         {
             const SvgGradientHelper* pSvgGradientHelper = dynamic_cast< const SvgGradientHelper* >(&rPrimitive);
@@ -620,27 +629,30 @@ namespace drawinglayer
                             rTo.getColor(), fScaleTo));
                 }
 
-                const double fTransFrom(1.0 - rFrom.getOpacity());
-                const double fTransTo(1.0 - rTo.getOpacity());
-                const basegfx::BColor aColorFrom(fTransFrom, fTransFrom, fTransFrom);
-                const basegfx::BColor aColorTo(fTransTo, fTransTo, fTransTo);
-
-                if(isFocalSet())
+                if(!getFullyOpaque())
                 {
-                    const basegfx::B2DVector aTranslateFrom(maFocalVector * (maFocalLength - fScaleFrom));
-                    const basegfx::B2DVector aTranslateTo(maFocalVector * (maFocalLength - fScaleTo));
+                    const double fTransFrom(1.0 - rFrom.getOpacity());
+                    const double fTransTo(1.0 - rTo.getOpacity());
+                    const basegfx::BColor aColorFrom(fTransFrom, fTransFrom, fTransFrom);
+                    const basegfx::BColor aColorTo(fTransTo, fTransTo, fTransTo);
 
-                    rTargetOpacity.push_back(
-                        new SvgRadialAtomPrimitive2D(
-                            aColorFrom, fScaleFrom, aTranslateFrom,
-                            aColorTo, fScaleTo, aTranslateTo));
-                }
-                else
-                {
-                    rTargetOpacity.push_back(
-                        new SvgRadialAtomPrimitive2D(
-                            aColorFrom, fScaleFrom,
-                            aColorTo, fScaleTo));
+                    if(isFocalSet())
+                    {
+                        const basegfx::B2DVector aTranslateFrom(maFocalVector * (maFocalLength - fScaleFrom));
+                        const basegfx::B2DVector aTranslateTo(maFocalVector * (maFocalLength - fScaleTo));
+
+                        rTargetOpacity.push_back(
+                            new SvgRadialAtomPrimitive2D(
+                                aColorFrom, fScaleFrom, aTranslateFrom,
+                                aColorTo, fScaleTo, aTranslateTo));
+                    }
+                    else
+                    {
+                        rTargetOpacity.push_back(
+                            new SvgRadialAtomPrimitive2D(
+                                aColorFrom, fScaleFrom,
+                                aColorTo, fScaleTo));
+                    }
                 }
             }
         }
@@ -796,7 +808,7 @@ namespace drawinglayer
             maMirroredGradientEntries(),
             mbFocalSet(false)
         {
-            if(pFocal)
+            if(pFocal && !pFocal->equal(getStart()))
             {
                 maFocal = *pFocal;
                 maFocalVector = maFocal - getStart();
@@ -804,6 +816,10 @@ namespace drawinglayer
             }
         }
 
+        SvgRadialGradientPrimitive2D::~SvgRadialGradientPrimitive2D()
+        {
+        }
+
         bool SvgRadialGradientPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
         {
             const SvgGradientHelper* pSvgGradientHelper = dynamic_cast< const SvgGradientHelper* >(&rPrimitive);
@@ -863,28 +879,30 @@ namespace drawinglayer
                 // use color distance and discrete lengths to calculate step count
                 const sal_uInt32 nSteps(calculateStepsForSvgGradient(getColorA(), getColorB(), fDelta, fDiscreteUnit));
 
-                // prepare loop and polygon (with overlap for linear gradients)
-                double fStart(0.0);
-                double fStep(fDelta / nSteps);
+                // prepare polygon in needed width at start position (with discrete overlap)
                 const basegfx::B2DPolygon aPolygon(
                     basegfx::tools::createPolygonFromRect(
                         basegfx::B2DRange(
                             getOffsetA() - fDiscreteUnit,
                             0.0,
-                            getOffsetA() + fStep + fDiscreteUnit,
+                            getOffsetA() + (fDelta / nSteps) + fDiscreteUnit,
                             1.0)));
 
-                // loop and create primitives
+                // prepare loop (inside to outside, [0.0 .. 1.0[)
+                double fUnitScale(0.0);
+                const double fUnitStep(1.0 / nSteps);
+
+                // prepare result set (known size)
                 xRetval.realloc(nSteps);
 
-                for(sal_uInt32 a(0); a < nSteps; a++, fStart += fStep)
+                for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep)
                 {
                     basegfx::B2DPolygon aNew(aPolygon);
 
-                    aNew.transform(basegfx::tools::createTranslateB2DHomMatrix(fStart, 0.0));
+                    aNew.transform(basegfx::tools::createTranslateB2DHomMatrix(fDelta * fUnitScale, 0.0));
                     xRetval[a] = new PolyPolygonColorPrimitive2D(
                         basegfx::B2DPolyPolygon(aNew),
-                        basegfx::interpolate(getColorA(), getColorB(), fStart/fDelta));
+                        basegfx::interpolate(getColorA(), getColorB(), fUnitScale));
                 }
             }
 
@@ -948,24 +966,24 @@ namespace drawinglayer
                 // use color distance and discrete lengths to calculate step count
                 const sal_uInt32 nSteps(calculateStepsForSvgGradient(getColorA(), getColorB(), fDeltaScale, fDiscreteUnit));
 
-                // prepare loop (outside to inside, full polygons, no polypolygons with holes)
-                double fEndScale(getScaleB());
-                double fStepScale(fDeltaScale / nSteps);
+                // prepare loop ([0.0 .. 1.0[, full polygons, no polypolygons with holes)
+                double fUnitScale(0.0);
+                const double fUnitStep(1.0 / nSteps);
 
-                // loop and create primitives
+                // prepare result set (known size)
                 xRetval.realloc(nSteps);
 
-                for(sal_uInt32 a(0); a < nSteps; a++, fEndScale -= fStepScale)
+                for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep)
                 {
-                    const double fUnitScale(fEndScale/fDeltaScale);
                     basegfx::B2DHomMatrix aTransform;
+                    const double fEndScale(getScaleB() - (fDeltaScale * fUnitScale));
 
                     if(isTranslateSet())
                     {
                         const basegfx::B2DVector aTranslate(
                             basegfx::interpolate(
-                                getTranslateA(),
                                 getTranslateB(),
+                                getTranslateA(),
                                 fUnitScale));
 
                         aTransform = basegfx::tools::createScaleTranslateB2DHomMatrix(
@@ -986,7 +1004,7 @@ namespace drawinglayer
                     aNew.transform(aTransform);
                     xRetval[a] = new PolyPolygonColorPrimitive2D(
                         basegfx::B2DPolyPolygon(aNew),
-                        basegfx::interpolate(getColorA(), getColorB(), fUnitScale));
+                        basegfx::interpolate(getColorB(), getColorA(), fUnitScale));
                 }
             }
 
diff --git a/drawinglayer/source/processor2d/vclprocessor2d.cxx b/drawinglayer/source/processor2d/vclprocessor2d.cxx
index 7f6004f75a05..8cb181463d79 100644
--- a/drawinglayer/source/processor2d/vclprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclprocessor2d.cxx
@@ -1404,27 +1404,30 @@ namespace drawinglayer
                 // use color distance and discrete lengths to calculate step count
                 const sal_uInt32 nSteps(calculateStepsForSvgGradient(aColorA, aColorB, fDelta, fDiscreteUnit));
 
-                // prepare loop and polygon
-                double fStart(0.0);
-                double fStep(fDelta / nSteps);
+                // switch off line painting
+                mpOutputDevice->SetLineColor();
+
+                // prepare polygon in needed width at start position (with discrete overlap)
                 const basegfx::B2DPolygon aPolygon(
                     basegfx::tools::createPolygonFromRect(
                         basegfx::B2DRange(
                             rCandidate.getOffsetA() - fDiscreteUnit,
                             0.0,
-                            rCandidate.getOffsetA() + fStep + fDiscreteUnit,
+                            rCandidate.getOffsetA() + (fDelta / nSteps) + fDiscreteUnit,
                             1.0)));
 
-                // switch off line painting
-                mpOutputDevice->SetLineColor();
+
+                // prepare loop ([0.0 .. 1.0[)
+                double fUnitScale(0.0);
+                const double fUnitStep(1.0 / nSteps);
 
                 // loop and paint
-                for(sal_uInt32 a(0); a < nSteps; a++, fStart += fStep)
+                for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep)
                 {
                     basegfx::B2DPolygon aNew(aPolygon);
 
-                    aNew.transform(maCurrentTransformation * basegfx::tools::createTranslateB2DHomMatrix(fStart, 0.0));
-                    mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorA, aColorB, fStart/fDelta)));
+                    aNew.transform(maCurrentTransformation * basegfx::tools::createTranslateB2DHomMatrix(fDelta * fUnitScale, 0.0));
+                    mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorA, aColorB, fUnitScale)));
                     mpOutputDevice->DrawPolyPolygon(basegfx::B2DPolyPolygon(aNew));
                 }
             }
@@ -1446,21 +1449,21 @@ namespace drawinglayer
                 // switch off line painting
                 mpOutputDevice->SetLineColor();
 
-                // prepare loop (outside to inside)
-                double fEndScale(rCandidate.getScaleB());
-                double fStepScale(fDeltaScale / nSteps);
+                // prepare loop ([0.0 .. 1.0[, full polygons, no polypolygons with holes)
+                double fUnitScale(0.0);
+                const double fUnitStep(1.0 / nSteps);
 
-                for(sal_uInt32 a(0); a < nSteps; a++, fEndScale -= fStepScale)
+                for(sal_uInt32 a(0); a < nSteps; a++, fUnitScale += fUnitStep)
                 {
-                    const double fUnitScale(fEndScale/fDeltaScale);
                     basegfx::B2DHomMatrix aTransform;
+                    const double fEndScale(rCandidate.getScaleB() - (fDeltaScale * fUnitScale));
 
                     if(rCandidate.isTranslateSet())
                     {
                         const basegfx::B2DVector aTranslate(
                             basegfx::interpolate(
-                                rCandidate.getTranslateA(),
                                 rCandidate.getTranslateB(),
+                                rCandidate.getTranslateA(),
                                 fUnitScale));
 
                         aTransform = basegfx::tools::createScaleTranslateB2DHomMatrix(
@@ -1479,7 +1482,7 @@ namespace drawinglayer
                     basegfx::B2DPolygon aNew(basegfx::tools::createPolygonFromUnitCircle());
 
                     aNew.transform(maCurrentTransformation * aTransform);
-                    mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorA, aColorB, fUnitScale)));
+                    mpOutputDevice->SetFillColor(Color(basegfx::interpolate(aColorB, aColorA, fUnitScale)));
                     mpOutputDevice->DrawPolyPolygon(basegfx::B2DPolyPolygon(aNew));
                 }
             }