aw078: resync to DEV300m68for integration

4 files changed, 115 insertions, 9 deletions

diff --git a/drawinglayer/source/processor2d/canvasprocessor.cxx b/drawinglayer/source/processor2d/canvasprocessor.cxx
index 649c208a6db5..8eb713258b25 100644
--- a/drawinglayer/source/processor2d/canvasprocessor.cxx
+++ b/drawinglayer/source/processor2d/canvasprocessor.cxx
@@ -46,7 +46,7 @@
 #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
 #include <canvas/canvastools.hxx>
-#include <svtools/ctloptions.hxx>
+#include <svl/ctloptions.hxx>
 #include <vcl/svapp.hxx>
 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
 #include <basegfx/polygon/b2dpolygonclipper.hxx>
diff --git a/drawinglayer/source/processor2d/hittestprocessor2d.cxx b/drawinglayer/source/processor2d/hittestprocessor2d.cxx
index ce9cadb6b40a..b10e10706520 100644
--- a/drawinglayer/source/processor2d/hittestprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/hittestprocessor2d.cxx
@@ -272,9 +272,11 @@ namespace drawinglayer
                 // {
                 //     // empty 3D scene; Check for border hit
                 //     const basegfx::B2DRange aRange(rCandidate.getB2DRange(getViewInformation2D()));
-                //     basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
-                //
-                //     mbHit = checkHairlineHitWithTolerance(aOutline, getDiscreteHitTolerance());
+                //     if(!aRange.isEmpty())
+                //     {
+                //          const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
+                //          mbHit = checkHairlineHitWithTolerance(aOutline, getDiscreteHitTolerance());
+                //     }
                 // }
             }
         }
@@ -475,9 +477,12 @@ namespace drawinglayer
                 {
                     // for text use the BoundRect of the primitive itself
                     const basegfx::B2DRange aRange(rCandidate.getB2DRange(getViewInformation2D()));
-                    basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
 
-                    mbHit = checkFillHitWithTolerance(basegfx::B2DPolyPolygon(aOutline), getDiscreteHitTolerance());
+                    if(!aRange.isEmpty())
+                    {
+                        const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
+                        mbHit = checkFillHitWithTolerance(basegfx::B2DPolyPolygon(aOutline), getDiscreteHitTolerance());
+                    }
 
                     break;
                 }
@@ -497,9 +502,12 @@ namespace drawinglayer
                         // - For Bitamps, the mask and/or alpha information may be used
                         // - For MetaFiles, the MetaFile content may be used
                         const basegfx::B2DRange aRange(rCandidate.getB2DRange(getViewInformation2D()));
-                        basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
 
-                        mbHit = checkFillHitWithTolerance(basegfx::B2DPolyPolygon(aOutline), getDiscreteHitTolerance());
+                        if(!aRange.isEmpty())
+                        {
+                            const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aRange));
+                            mbHit = checkFillHitWithTolerance(basegfx::B2DPolyPolygon(aOutline), getDiscreteHitTolerance());
+                        }
                     }
 
                     break;
diff --git a/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx b/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
index 5a74b0471b7f..66863b1b2875 100644
--- a/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
@@ -216,6 +216,12 @@ namespace drawinglayer
                     RenderPolyPolygonBitmapPrimitive2D(static_cast< const primitive2d::PolyPolygonBitmapPrimitive2D& >(rCandidate));
                     break;
                 }
+                case PRIMITIVE2D_ID_POLYPOLYGONBITMAPPRIMITIVE2D :
+                {
+                    // direct draw of bitmap
+                    RenderPolyPolygonBitmapPrimitive2D(static_cast< const primitive2d::PolyPolygonBitmapPrimitive2D& >(rCandidate));
+                    break;
+                }
                 case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
                 {
                     // direct draw of PolyPolygon with color
diff --git a/drawinglayer/source/processor2d/vclprocessor2d.cxx b/drawinglayer/source/processor2d/vclprocessor2d.cxx
index 9def01619286..5614183ceb6b 100644
--- a/drawinglayer/source/processor2d/vclprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclprocessor2d.cxx
@@ -58,7 +58,7 @@
 #include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
 #include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
 #include <drawinglayer/primitive2d/wrongspellprimitive2d.hxx>
-#include <svtools/ctloptions.hxx>
+#include <svl/ctloptions.hxx>
 #include <vcl/svapp.hxx>
 #include <drawinglayer/primitive2d/pagepreviewprimitive2d.hxx>
 #include <tools/diagnose_ex.h>
@@ -630,6 +630,98 @@ namespace drawinglayer
             }
         }
 
+        // direct draw of bitmap
+        void VclProcessor2D::RenderPolyPolygonBitmapPrimitive2D(const primitive2d::PolyPolygonBitmapPrimitive2D& rPolygonCandidate)
+        {
+            bool bDone(false);
+            const basegfx::B2DPolyPolygon& rPolyPolygon = rPolygonCandidate.getB2DPolyPolygon();
+
+            if(rPolyPolygon.count())
+            {
+                const attribute::FillBitmapAttribute& rFillBitmapAttribute = rPolygonCandidate.getFillBitmap();
+                const Bitmap& rBitmap = rFillBitmapAttribute.getBitmap();
+
+                if(rBitmap.IsEmpty())
+                {
+                    // empty bitmap, done
+                    bDone = true;
+                }
+                else
+                {
+                    // try to catch cases where the bitmap will be color-modified to a single
+                    // color (e.g. shadow). This would NOT be optimizable with an alpha channel
+                    // at the Bitmap which we do not have here. When this should change, this
+                    // optimization has to be reworked accordingly.
+                    const sal_uInt32 nBColorModifierStackCount(maBColorModifierStack.count());
+
+                    if(nBColorModifierStackCount)
+                    {
+                        const basegfx::BColorModifier& rTopmostModifier = maBColorModifierStack.getBColorModifier(nBColorModifierStackCount - 1);
+
+                        if(basegfx::BCOLORMODIFYMODE_REPLACE == rTopmostModifier.getMode())
+                        {
+                            // the bitmap fill is in unified color, so we can replace it with
+                            // a single polygon fill. The form of the fill depends on tiling
+                            if(rFillBitmapAttribute.getTiling())
+                            {
+                                // with tiling, fill the whole PolyPolygon with the modifier color
+                                basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolyPolygon);
+
+                                aLocalPolyPolygon.transform(maCurrentTransformation);
+                                mpOutputDevice->SetLineColor();
+                                mpOutputDevice->SetFillColor(Color(rTopmostModifier.getBColor()));
+                                mpOutputDevice->DrawPolyPolygon(aLocalPolyPolygon);
+                            }
+                            else
+                            {
+                                // without tiling, only the area common to the bitmap tile and the
+                                // PolyPolygon is filled. Create the bitmap tile area in object
+                                // coordinates. For this, the object transformation needs to be created
+                                // from the already scaled PolyPolygon. The tile area in object
+                                // coordinates wil always be non-rotated, so it's not necessary to
+                                // work with a polygon here
+                                basegfx::B2DRange aTileRange(rFillBitmapAttribute.getTopLeft(),
+                                    rFillBitmapAttribute.getTopLeft() + rFillBitmapAttribute.getSize());
+                                const basegfx::B2DRange aPolyPolygonRange(rPolyPolygon.getB2DRange());
+                                basegfx::B2DHomMatrix aNewObjectTransform;
+
+                                aNewObjectTransform.set(0, 0, aPolyPolygonRange.getWidth());
+                                aNewObjectTransform.set(1, 1, aPolyPolygonRange.getHeight());
+                                aNewObjectTransform.set(0, 2, aPolyPolygonRange.getMinX());
+                                aNewObjectTransform.set(1, 2, aPolyPolygonRange.getMinY());
+                                aTileRange.transform(aNewObjectTransform);
+
+                                // now clip the object polyPolygon against the tile range
+                                // to get the common area (OR)
+                                basegfx::B2DPolyPolygon aTarget = basegfx::tools::clipPolyPolygonOnRange(rPolyPolygon, aTileRange, true, false);
+
+                                if(aTarget.count())
+                                {
+                                    aTarget.transform(maCurrentTransformation);
+                                    mpOutputDevice->SetLineColor();
+                                    mpOutputDevice->SetFillColor(Color(rTopmostModifier.getBColor()));
+                                    mpOutputDevice->DrawPolyPolygon(aTarget);
+                                }
+                            }
+
+                            bDone = true;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                // empty polyPolygon, done
+                bDone = true;
+            }
+
+            if(!bDone)
+            {
+                // use default decomposition
+                process(rPolygonCandidate.get2DDecomposition(getViewInformation2D()));
+            }
+        }
+
         // direct draw of PolyPolygon with color
         void VclProcessor2D::RenderPolyPolygonColorPrimitive2D(const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate)
         {