CWS-TOOLING: integrate CWS aw065

2009-06-17 13:48:12 +0200 aw  r273068 : #99385# corrected small error in SCs selection visualisation
2009-06-16 15:45:28 +0200 wg  r273021 : i102838
2009-06-16 12:46:07 +0200 wg  r273016 : i102833
2009-06-11 17:40:29 +0200 aw  r272895 : #i98870# added implementation for getPageCount helper
2009-06-11 16:39:54 +0200 aw  r272885 : #i102663#, #i102667#, #i98870# incluide file typo corrected
2009-06-11 16:24:07 +0200 aw  r272881 : #i102663#, #i102667#, #i98870# changes to SdrText, it's usage in SdrTextPrimitive2D and to OverlayObject base implementation. Also support for PageCountField added
2009-06-11 16:23:52 +0200 aw  r272880 : #i102663#, #i102667#, #i98870# changes to SdrText, it's usage in SdrTextPrimitive2D and to OverlayObject base implementation. Also support for PageCountField added
2009-06-09 13:50:29 +0200 aw  r272769 : #i98917# added support for the OverlayHatchRectanglePrimitive to follow rotation with it's hatch; simplified OverlayHatchRect
2009-06-09 13:04:06 +0200 aw  r272766 : #i98870# re-added PageNumber identification in SdrTextPrimitive2D::get2DDecomposition
2009-06-08 18:56:05 +0200 aw  r272744 : #i99385# added some last corrections to OverlayObjects in SD (had to do some merges on resync, needed to optically check and correct)
2009-06-08 11:17:57 +0200 aw  r272725 : cws aw065: corrections after resync
2009-06-08 11:02:25 +0200 aw  r272723 : cws aw065: corrections after resync
2009-06-08 10:36:22 +0200 aw  r272722 : cws aw065: corrections after resync
2009-06-05 18:57:06 +0200 aw  r272712 : CWS-TOOLING: rebase CWS aw065 to trunk@272291 (milestone: DEV300:m49)
2009-06-05 14:56:34 +0200 aw  r272690 : #i89784# stripped old stuff no longer needed due to text-to-polygon conversion using primitives
2009-06-05 14:50:07 +0200 aw  r272688 : #102091# removed on-model-lock suppression for SdrObject::ActionChanged()
2009-06-05 14:47:29 +0200 aw  r272687 : #102091# corrected local value buffering in ScenePrimitive2D::get2DDecomposition
2009-06-03 17:53:32 +0200 aw  r272599 : #i89784# version before stripping
2009-06-03 17:52:18 +0200 aw  r272598 : #i89784# version before stripping
2009-05-28 17:15:47 +0200 aw  r272420 : #i101872# old stuff removed/stripped
2009-05-28 17:15:32 +0200 aw  r272419 : #i101872# old stuff removed/stripped
2009-05-28 17:15:15 +0200 aw  r272418 : #i101872# old stuff removed/stripped
2009-05-28 17:14:45 +0200 aw  r272417 : #i101872# old stuff removed/stripped
2009-05-28 12:13:56 +0200 aw  r272396 : #i101872# stable hybrid state
2009-05-28 12:13:46 +0200 aw  r272395 : #i101872# stable hybrid state
2009-05-28 12:13:35 +0200 aw  r272394 : #i101872# stable hybrid state
2009-05-28 12:13:20 +0200 aw  r272393 : #i101872# stable hybrid state
2009-05-28 12:13:05 +0200 aw  r272392 : #i101872# stable hybrid state
2009-05-28 12:12:51 +0200 aw  r272391 : #i101872# stable hybrid state
2009-05-15 16:56:02 +0200 aw  r271952 : #i101872# HitTest unifications
2009-05-15 16:55:22 +0200 aw  r271951 : #i101872# HitTest unifications
2009-05-15 16:55:12 +0200 aw  r271950 : #i101872# HitTest unifications
2009-05-15 16:55:01 +0200 aw  r271949 : #i101872# HitTest unifications
2009-05-15 16:54:51 +0200 aw  r271948 : #i101872# HitTest unifications
2009-05-15 16:54:35 +0200 aw  r271947 : #i101872# HitTest unifications
2009-05-15 16:54:22 +0200 aw  r271946 : #i101872# HitTest unifications
2009-05-12 19:08:38 +0200 aw  r271834 : #i101684# corrected AutoShape's preparation of text transformation due to different definitions in TextBounds
2009-05-12 15:44:49 +0200 aw  r271827 : #i89784# expanded TextLayouterDevice::getTextOutlines() to support DXArray and X-Font scaling
2009-05-11 19:40:40 +0200 aw  r271790 : #i99385# extended HitTest primitive usage, removed IsHdlHit implementations; prepared further HitTest simplifications
2009-05-11 19:40:25 +0200 aw  r271789 : #i99385# extended HitTest primitive usage, removed IsHdlHit implementations; prepared further HitTest simplifications
2009-05-11 19:40:12 +0200 aw  r271788 : #i99385# extended HitTest primitive usage, removed IsHdlHit implementations; prepared further HitTest simplifications
2009-05-11 13:01:53 +0200 aw  r271765 : #i99385# corrections and optimizations
2009-05-08 14:48:40 +0200 aw  r271718 : #i1016180# added optimizations in model operations when model is locked
2009-05-08 14:11:45 +0200 aw  r271716 : #i101679# added flush() calls to OverlayManager when interaction step is prepared
2009-05-07 17:44:03 +0200 aw  r271689 : #i99385# last corrections/changes
2009-05-07 17:43:47 +0200 aw  r271688 : #i99385# last corrections/changes
2009-05-07 13:20:09 +0200 aw  r271654 : #i99385# added changes from WFH
2009-05-07 13:19:38 +0200 aw  r271653 : #i99385# added changes from WFH
2009-05-07 13:19:11 +0200 aw  r271652 : #i99385# added changes from WFH
2009-05-07 11:33:17 +0200 aw  r271643 : #i99385# corrections after resync
2009-05-07 11:17:31 +0200 aw  r271642 : #i99385# corrections after resync
2009-05-06 18:46:53 +0200 aw  r271609 : CWS-TOOLING: rebase CWS aw065 to trunk@271427 (milestone: DEV300:m47)
2009-05-05 18:24:03 +0200 aw  r271548 : #i101443# force new text decomposition when TextBackgroundColor has changed
2009-05-05 17:44:42 +0200 aw  r271542 : #i99385# 3rd round, simplifications and corrections done
2009-05-05 17:44:32 +0200 aw  r271541 : #i99385# 3rd round, simplifications and corrections done
2009-05-05 17:44:20 +0200 aw  r271540 : #i99385# 3rd round, simplifications and corrections done
2009-05-05 17:44:09 +0200 aw  r271539 : #i99385# 3rd round, simplifications and corrections done
2009-05-05 15:48:38 +0200 aw  r271527 : #i99385# 2nd round, usages checked and corrected
2009-05-05 15:48:15 +0200 aw  r271526 : #i99385# 2nd round, usages checked and corrected
2009-05-05 15:48:03 +0200 aw  r271525 : #i99385# 2nd round, usages checked and corrected
2009-05-05 15:47:51 +0200 aw  r271524 : #i99385# 2nd round, usages checked and corrected
2009-04-27 18:33:10 +0200 aw  r271300 : #i99385# state commit after all implementations are done
2009-04-27 15:36:53 +0200 aw  r271283 : #i99385# state commit after all implementations are done
2009-04-27 15:27:49 +0200 aw  r271280 : #i99385# state commit after all implementations are done
2009-04-27 15:27:33 +0200 aw  r271279 : #i99385# state commit after all implementations are done
2009-04-27 15:27:00 +0200 aw  r271278 : #i99385# state commit after all implementations are done
2009-04-27 15:26:15 +0200 aw  r271277 : #i99385# state commit after all implementations are done
2009-04-27 15:25:40 +0200 aw  r271275 : #i99385# state commit after all implementations are done
2009-04-27 15:25:19 +0200 aw  r271274 : #i99385# state commit after all implementations are done
2009-04-27 15:24:00 +0200 aw  r271272 : #i99385# state commit after all implementations are done
2009-03-19 17:12:00 +0100 aw  r269757 : #i100360# corrected bitmap's PefSize calculation for bitmap filled objects when Bitmap is Pixel-based on it's mapping
2009-02-19 17:09:47 +0100 aw  r268298 : #i98917# corrected attributes
2009-02-19 17:09:30 +0100 aw  r268297 : #i98917# corrected attributes
2009-02-19 17:08:22 +0100 aw  r268296 : #i98917# corrected attributes
2009-02-19 11:56:25 +0100 aw  r268268 : #i98870# added extra code to react on PageNumber change
2009-02-18 16:57:24 +0100 aw  r268243 : #i98917# in OverlayHatchRect::getGeometry the rotation was not applied to the TopLeft of the centered rectangle, but to the already extended one, thus the visualisation was rotating around the wrong edge

12 files changed, 966 insertions, 31 deletions

diff --git a/drawinglayer/source/attribute/sdrallattribute3d.cxx b/drawinglayer/source/attribute/sdrallattribute3d.cxx
index 44875dda2d19..264d8d0432d1 100644
--- a/drawinglayer/source/attribute/sdrallattribute3d.cxx
+++ b/drawinglayer/source/attribute/sdrallattribute3d.cxx
@@ -64,17 +64,15 @@ namespace drawinglayer
         {
         }
 
-        SdrLineFillShadowAttribute::SdrLineFillShadowAttribute(const SdrLineFillShadowAttribute& rCandidate)
-        :   mpShadow(0L),
-            mpLine(0L),
-            mpLineStartEnd(0L),
-            mpFill(0L),
-            mpFillFloatTransGradient(0L)
+        SdrLineFillShadowAttribute::SdrLineFillShadowAttribute(
+            const SdrLineFillShadowAttribute& rCandidate)
+        :   mpShadow(0),
+            mpLine(0),
+            mpLineStartEnd(0),
+            mpFill(0),
+            mpFillFloatTransGradient(0)
         {
-            if(!(*this == rCandidate))
-            {
-                *this = rCandidate;
-            }
+            *this = rCandidate;
         }
 
         SdrLineFillShadowAttribute::~SdrLineFillShadowAttribute()
@@ -91,14 +89,14 @@ namespace drawinglayer
             // handle mpShadow
             {
                 // delete local mpShadow if necessary
-                if(mpShadow && ((!rCandidate.mpShadow) || (!(*mpShadow == *rCandidate.mpShadow))))
+                if(mpShadow)
                 {
                     delete mpShadow;
-                    mpShadow = 0L;
+                    mpShadow = 0;
                 }
 
                 // copy mpShadow if necessary
-                if(!mpShadow && rCandidate.mpShadow)
+                if(rCandidate.mpShadow)
                 {
                     mpShadow = new SdrShadowAttribute(*rCandidate.mpShadow);
                 }
@@ -107,14 +105,14 @@ namespace drawinglayer
             // handle mpLine
             {
                 // delete local mpLine if necessary
-                if(mpLine && ((!rCandidate.mpLine) || (!(*mpLine == *rCandidate.mpLine))))
+                if(mpLine)
                 {
                     delete mpLine;
-                    mpLine = 0L;
+                    mpLine = 0;
                 }
 
                 // copy mpLine if necessary
-                if(!mpLine && rCandidate.mpLine)
+                if(rCandidate.mpLine)
                 {
                     mpLine = new SdrLineAttribute(*rCandidate.mpLine);
                 }
@@ -123,14 +121,14 @@ namespace drawinglayer
             // handle mpLineStartEnd
             {
                 // delete local mpLineStartEnd if necessary
-                if(mpLineStartEnd && ((!rCandidate.mpLineStartEnd) || (!(*mpLineStartEnd == *rCandidate.mpLineStartEnd))))
+                if(mpLineStartEnd)
                 {
                     delete mpLineStartEnd;
-                    mpLineStartEnd = 0L;
+                    mpLineStartEnd = 0;
                 }
 
                 // copy mpLineStartEnd if necessary
-                if(!mpLineStartEnd && rCandidate.mpLineStartEnd)
+                if(rCandidate.mpLineStartEnd)
                 {
                     mpLineStartEnd = new SdrLineStartEndAttribute(*rCandidate.mpLineStartEnd);
                 }
@@ -139,14 +137,14 @@ namespace drawinglayer
             // handle mpFill
             {
                 // delete local mpFill if necessary
-                if(mpFill && ((!rCandidate.mpFill) || (!(*mpFill == *rCandidate.mpFill))))
+                if(mpFill)
                 {
                     delete mpFill;
-                    mpFill = 0L;
+                    mpFill = 0;
                 }
 
                 // copy mpFill if necessary
-                if(!mpFill && rCandidate.mpFill)
+                if(rCandidate.mpFill)
                 {
                     mpFill = new SdrFillAttribute(*rCandidate.mpFill);
                 }
@@ -155,14 +153,14 @@ namespace drawinglayer
             // handle mpFillFloatTransGradient
             {
                 // delete local mpFillFloatTransGradient if necessary
-                if(mpFillFloatTransGradient && ((!rCandidate.mpFillFloatTransGradient) || (!(*mpFillFloatTransGradient == *rCandidate.mpFillFloatTransGradient))))
+                if(mpFillFloatTransGradient)
                 {
                     delete mpFillFloatTransGradient;
-                    mpFillFloatTransGradient = 0L;
+                    mpFillFloatTransGradient = 0;
                 }
 
                 // copy mpFillFloatTransGradient if necessary
-                if(!mpFillFloatTransGradient && rCandidate.mpFillFloatTransGradient)
+                if(rCandidate.mpFillFloatTransGradient)
                 {
                     mpFillFloatTransGradient = new FillGradientAttribute(*rCandidate.mpFillFloatTransGradient);
                 }
diff --git a/drawinglayer/source/primitive2d/invertprimitive2d.cxx b/drawinglayer/source/primitive2d/invertprimitive2d.cxx
new file mode 100644
index 000000000000..374ec578113d
--- /dev/null
+++ b/drawinglayer/source/primitive2d/invertprimitive2d.cxx
@@ -0,0 +1,65 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: unifiedalphaprimitive2d.cxx,v $
+ *
+ *  $Revision: 1.5 $
+ *
+ *  last change: $Author: aw $ $Date: 2008-05-27 14:11:20 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_drawinglayer.hxx"
+
+#include <drawinglayer/primitive2d/invertprimitive2d.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+using namespace com::sun::star;
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace primitive2d
+    {
+        InvertPrimitive2D::InvertPrimitive2D(
+            const Primitive2DSequence& rChildren)
+        :   GroupPrimitive2D(rChildren)
+        {
+        }
+
+        // provide unique ID
+        ImplPrimitrive2DIDBlock(InvertPrimitive2D, PRIMITIVE2D_ID_INVERTPRIMITIVE2D)
+
+    } // end of namespace primitive2d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/primitive2d/makefile.mk b/drawinglayer/source/primitive2d/makefile.mk
index b909d0fde9f5..e10d1ddbcc71 100644
--- a/drawinglayer/source/primitive2d/makefile.mk
+++ b/drawinglayer/source/primitive2d/makefile.mk
@@ -62,6 +62,7 @@ SLOFILES= \
         $(SLO)$/groupprimitive2d.obj			\
         $(SLO)$/helplineprimitive2d.obj			\
         $(SLO)$/hittestprimitive2d.obj			\
+        $(SLO)$/invertprimitive2d.obj			\
         $(SLO)$/markerarrayprimitive2d.obj		\
         $(SLO)$/pointarrayprimitive2d.obj		\
         $(SLO)$/maskprimitive2d.obj				\
@@ -71,6 +72,7 @@ SLOFILES= \
         $(SLO)$/pagepreviewprimitive2d.obj		\
         $(SLO)$/polypolygonprimitive2d.obj		\
         $(SLO)$/polygonprimitive2d.obj			\
+        $(SLO)$/primitivetools2d.obj			\
         $(SLO)$/sceneprimitive2d.obj			\
         $(SLO)$/shadowprimitive2d.obj			\
         $(SLO)$/structuretagprimitive2d.obj		\
diff --git a/drawinglayer/source/primitive2d/polygonprimitive2d.cxx b/drawinglayer/source/primitive2d/polygonprimitive2d.cxx
index a795e84ed433..b1f42b5a4eff 100644
--- a/drawinglayer/source/primitive2d/polygonprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/polygonprimitive2d.cxx
@@ -116,7 +116,7 @@ namespace drawinglayer
             const basegfx::B2DVector aDashVector(rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(getDiscreteDashLength(), 0.0));
             const double fLogicDashLength(aDashVector.getX());
 
-            if(fLogicDashLength > 0.0)
+            if(fLogicDashLength > 0.0 && !getRGBColorA().equal(getRGBColorB()))
             {
                 // apply dashing; get line and gap snippets
                 ::std::vector< double > aDash;
diff --git a/drawinglayer/source/primitive2d/primitivetools2d.cxx b/drawinglayer/source/primitive2d/primitivetools2d.cxx
new file mode 100644
index 000000000000..d288a697d729
--- /dev/null
+++ b/drawinglayer/source/primitive2d/primitivetools2d.cxx
@@ -0,0 +1,106 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: baseprimitive2d.cxx,v $
+ *
+ *  $Revision: 1.6 $
+ *
+ *  last change: $Author: aw $ $Date: 2008-05-27 14:11:20 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_drawinglayer.hxx"
+
+#include <drawinglayer/primitive2d/primitivetools2d.hxx>
+#include <basegfx/vector/b2dvector.hxx>
+#include <drawinglayer/geometry/viewinformation2d.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace primitive2d
+    {
+        Primitive2DSequence DiscreteMetricDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        {
+            ::osl::MutexGuard aGuard( m_aMutex );
+
+            // get the current DiscreteUnit
+            const double fDiscreteUnit((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0)).getLength());
+
+            if(getLocalDecomposition().hasElements() && !basegfx::fTools::equal(fDiscreteUnit, getDiscreteUnit()))
+            {
+                // conditions of last local decomposition have changed, delete
+                const_cast< DiscreteMetricDependentPrimitive2D* >(this)->setLocalDecomposition(Primitive2DSequence());
+            }
+
+            if(!getLocalDecomposition().hasElements())
+            {
+                // remember new valid DiscreteUnit
+                const_cast< DiscreteMetricDependentPrimitive2D* >(this)->mfDiscreteUnit = fDiscreteUnit;
+            }
+
+            // call base implementation
+            return BasePrimitive2D::get2DDecomposition(rViewInformation);
+        }
+    } // end of namespace primitive2d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace primitive2d
+    {
+        Primitive2DSequence ViewportDependentPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
+        {
+            ::osl::MutexGuard aGuard( m_aMutex );
+
+            // get the current Viewport
+            const basegfx::B2DRange& rViewport = rViewInformation.getViewport();
+
+            if(getLocalDecomposition().hasElements() && !rViewport.equal(getViewport()))
+            {
+                // conditions of last local decomposition have changed, delete
+                const_cast< ViewportDependentPrimitive2D* >(this)->setLocalDecomposition(Primitive2DSequence());
+            }
+
+            if(!getLocalDecomposition().hasElements())
+            {
+                // remember new valid DiscreteUnit
+                const_cast< ViewportDependentPrimitive2D* >(this)->maViewport = rViewport;
+            }
+
+            // call base implementation
+            return BasePrimitive2D::get2DDecomposition(rViewInformation);
+        }
+    } // end of namespace primitive2d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/primitive2d/sceneprimitive2d.cxx b/drawinglayer/source/primitive2d/sceneprimitive2d.cxx
index 73d26a71fa4c..f52af2da6a6d 100644
--- a/drawinglayer/source/primitive2d/sceneprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/sceneprimitive2d.cxx
@@ -363,11 +363,13 @@ namespace drawinglayer
             basegfx::B2DRange aDiscreteRange;
             basegfx::B2DRange aUnitVisibleRange;
             bool bNeedNewDecomposition(false);
+            bool bDiscreteSizesAreCalculated(false);
 
             if(getLocalDecomposition().hasElements())
             {
                 basegfx::B2DRange aVisibleDiscreteRange;
                 calculateDsicreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
+                bDiscreteSizesAreCalculated = true;
 
                 // display has changed and cannot be reused when resolution did change
                 if(!basegfx::fTools::equal(aDiscreteRange.getWidth(), mfOldDiscreteSizeX) ||
@@ -395,6 +397,12 @@ namespace drawinglayer
 
             if(!getLocalDecomposition().hasElements())
             {
+                if(!bDiscreteSizesAreCalculated)
+                {
+                    basegfx::B2DRange aVisibleDiscreteRange;
+                    calculateDsicreteSizes(rViewInformation, aDiscreteRange, aVisibleDiscreteRange, aUnitVisibleRange);
+                }
+
                 // remember last used NewDiscreteSize and NewUnitVisiblePart
                 ScenePrimitive2D* pThat = const_cast< ScenePrimitive2D* >(this);
                 pThat->mfOldDiscreteSizeX = aDiscreteRange.getWidth();
diff --git a/drawinglayer/source/primitive2d/textlayoutdevice.cxx b/drawinglayer/source/primitive2d/textlayoutdevice.cxx
index b8f7d59e6f05..23ec468d83d4 100644
--- a/drawinglayer/source/primitive2d/textlayoutdevice.cxx
+++ b/drawinglayer/source/primitive2d/textlayoutdevice.cxx
@@ -239,8 +239,25 @@ namespace drawinglayer
             basegfx::B2DPolyPolygonVector& rB2DPolyPolyVector,
             const String& rText,
             xub_StrLen nIndex,
-            xub_StrLen nLength)
+            xub_StrLen nLength,
+            // #i89784# added suppirt for DXArray for justified text
+            const ::std::vector< double >& rDXArray,
+            double fFontScaleWidth)
         {
+            std::vector< sal_Int32 > aTransformedDXArray;
+            const sal_uInt32 nDXArraySize(rDXArray.size());
+
+            if(nDXArraySize && basegfx::fTools::more(fFontScaleWidth, 0.0))
+            {
+                OSL_ENSURE(nDXArraySize == nLength, "DXArray size does not correspond to text portion size (!)");
+                aTransformedDXArray.reserve(nDXArraySize);
+
+                for(std::vector< double >::const_iterator aStart(rDXArray.begin()); aStart != rDXArray.end(); aStart++)
+                {
+                    aTransformedDXArray.push_back(basegfx::fround((*aStart) * fFontScaleWidth));
+                }
+            }
+
             return mrDevice.GetTextOutlines(
                 rB2DPolyPolyVector,
                 rText,
@@ -249,7 +266,7 @@ namespace drawinglayer
                 nLength,
                 true,
                 0,
-                0);
+                nDXArraySize ? &(aTransformedDXArray[0]) : 0);
         }
 
         basegfx::B2DRange TextLayouterDevice::getTextBoundRect(
diff --git a/drawinglayer/source/primitive2d/textprimitive2d.cxx b/drawinglayer/source/primitive2d/textprimitive2d.cxx
index bf46f4ab21d0..1b527668db2c 100644
--- a/drawinglayer/source/primitive2d/textprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/textprimitive2d.cxx
@@ -150,12 +150,20 @@ namespace drawinglayer
                     // when under Windows and the font is unequally scaled, need to correct font X-Scaling factor
                     if(bCorrectScale)
                     {
-                        aScale.setX(aScale.getX() * aTextLayouter.getCurrentFontRelation());
+                        const double fFontRelation(aTextLayouter.getCurrentFontRelation());
+                        aScale.setX(aScale.getX() * fFontRelation);
+                        aFontScale.setX(aFontScale.getX() / fFontRelation);
                     }
 #endif
                     // get the text outlines. No DXArray is given (would contain integers equal to unit vector
                     // transformed by object's transformation), let VCL do the job
-                    aTextLayouter.getTextOutlines(rTarget, getText(), getTextPosition(), getTextLength());
+                    aTextLayouter.getTextOutlines(
+                        rTarget, getText(),
+                        getTextPosition(),
+                        getTextLength(),
+                        // #i89784# added support for DXArray for justified text
+                        getDXArray(),
+                        aFontScale.getX());
 
                     // create primitives for the outlines
                     const sal_uInt32 nCount(rTarget.size());
diff --git a/drawinglayer/source/processor2d/hittestprocessor2d.cxx b/drawinglayer/source/processor2d/hittestprocessor2d.cxx
new file mode 100644
index 000000000000..8a2d732cbb2f
--- /dev/null
+++ b/drawinglayer/source/processor2d/hittestprocessor2d.cxx
@@ -0,0 +1,451 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: contourextractor2d.cxx,v $
+ *
+ *  $Revision: 1.6 $
+ *
+ *  last change: $Author: aw $ $Date: 2008-06-24 15:31:08 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_drawinglayer.hxx"
+
+#include <drawinglayer/processor2d/hittestprocessor2d.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
+#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <drawinglayer/primitive2d/alphaprimitive2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <drawinglayer/primitive2d/sceneprimitive2d.hxx>
+#include <drawinglayer/primitive2d/hittestprimitive2d.hxx>
+#include <drawinglayer/primitive2d/pointarrayprimitive2d.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace processor2d
+    {
+        HitTestProcessor2D::HitTestProcessor2D(const geometry::ViewInformation2D& rViewInformation,
+            const basegfx::B2DPoint& rLogicHitPosition,
+            double fLogicHitTolerance,
+            bool bHitTextOnly)
+        :   BaseProcessor2D(rViewInformation),
+            maDiscreteHitPosition(),
+            mfDiscreteHitTolerance(0.0),
+            mbHit(false),
+            mbHitToleranceUsed(false),
+            mbUseHitTestPrimitiveContent(true),
+            mbHitTextOnly(bHitTextOnly)
+        {
+            // init hit tolerance
+            mfDiscreteHitTolerance = fLogicHitTolerance;
+
+            if(basegfx::fTools::less(mfDiscreteHitTolerance, 0.0))
+            {
+                // ensure input parameter for hit tolerance is >= 0.0
+                mfDiscreteHitTolerance = 0.0;
+            }
+            else if(basegfx::fTools::more(mfDiscreteHitTolerance, 0.0))
+            {
+                // generate discrete hit tolerance
+                mfDiscreteHitTolerance = (getViewInformation2D().getObjectToViewTransformation()
+                    * basegfx::B2DVector(mfDiscreteHitTolerance, 0.0)).getLength();
+            }
+
+            // gererate discrete hit position
+            maDiscreteHitPosition = getViewInformation2D().getObjectToViewTransformation() * rLogicHitPosition;
+
+            // check if HitTolerance is used
+            mbHitToleranceUsed = basegfx::fTools::more(getDiscreteHitTolerance(), 0.0);
+        }
+
+        HitTestProcessor2D::~HitTestProcessor2D()
+        {
+        }
+
+        bool HitTestProcessor2D::checkHairlineHitWithTolerance(
+            const basegfx::B2DPolygon& rPolygon,
+            double fDiscreteHitTolerance)
+        {
+            basegfx::B2DPolygon aLocalPolygon(rPolygon);
+            aLocalPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
+
+            // get discrete range
+            basegfx::B2DRange aPolygonRange(aLocalPolygon.getB2DRange());
+
+            if(basegfx::fTools::more(fDiscreteHitTolerance, 0.0))
+            {
+                aPolygonRange.grow(fDiscreteHitTolerance);
+            }
+
+            // do rough range test first
+            if(aPolygonRange.isInside(getDiscreteHitPosition()))
+            {
+                // check if a polygon edge is hit
+                return basegfx::tools::isInEpsilonRange(
+                    aLocalPolygon,
+                    getDiscreteHitPosition(),
+                    fDiscreteHitTolerance);
+            }
+
+            return false;
+        }
+
+        bool HitTestProcessor2D::checkFillHitWithTolerance(
+            const basegfx::B2DPolyPolygon& rPolyPolygon,
+            double fDiscreteHitTolerance)
+        {
+            bool bRetval(false);
+            basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolyPolygon);
+            aLocalPolyPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
+
+            // get discrete range
+            basegfx::B2DRange aPolygonRange(aLocalPolyPolygon.getB2DRange());
+            const bool bDiscreteHitToleranceUsed(basegfx::fTools::more(fDiscreteHitTolerance, 0.0));
+
+            if(bDiscreteHitToleranceUsed)
+            {
+                aPolygonRange.grow(fDiscreteHitTolerance);
+            }
+
+            // do rough range test first
+            if(aPolygonRange.isInside(getDiscreteHitPosition()))
+            {
+                // if a HitTolerance is given, check for polygon edge hit in epsilon first
+                if(bDiscreteHitToleranceUsed &&
+                    basegfx::tools::isInEpsilonRange(
+                        aLocalPolyPolygon,
+                        getDiscreteHitPosition(),
+                        fDiscreteHitTolerance))
+                {
+                    bRetval = true;
+                }
+
+                // check for hit in filled polyPolygon
+                if(!bRetval && basegfx::tools::isInside(
+                    aLocalPolyPolygon,
+                    getDiscreteHitPosition(),
+                    true))
+                {
+                    bRetval = true;
+                }
+            }
+
+            return bRetval;
+        }
+
+        void HitTestProcessor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
+        {
+            if(getHit())
+            {
+                // stop processing as soon as a hit was recognized
+                return;
+            }
+
+            switch(rCandidate.getPrimitiveID())
+            {
+                case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D :
+                {
+                    // remember current ViewInformation2D
+                    const primitive2d::TransformPrimitive2D& rTransformCandidate(static_cast< const primitive2d::TransformPrimitive2D& >(rCandidate));
+                    const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
+
+                    // create new local ViewInformation2D containing transformation
+                    const geometry::ViewInformation2D aViewInformation2D(
+                        getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
+                        getViewInformation2D().getViewTransformation(),
+                        getViewInformation2D().getViewport(),
+                        getViewInformation2D().getVisualizedPage(),
+                        getViewInformation2D().getViewTime(),
+                        getViewInformation2D().getExtendedInformationSequence());
+                    updateViewInformation(aViewInformation2D);
+
+                    // proccess child content recursively
+                    process(rTransformCandidate.getChildren());
+
+                    // restore transformations
+                    updateViewInformation(aLastViewInformation2D);
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        // create hairline in discrete coordinates
+                        const primitive2d::PolygonHairlinePrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate));
+
+                        // use hairline test
+                        mbHit = checkHairlineHitWithTolerance(rPolygonCandidate.getB2DPolygon(), getDiscreteHitTolerance());
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POLYGONMARKERPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        // handle marker like hairline; no need to decompose in dashes
+                        const primitive2d::PolygonMarkerPrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolygonMarkerPrimitive2D& >(rCandidate));
+
+                        // use hairline test
+                        mbHit = checkHairlineHitWithTolerance(rPolygonCandidate.getB2DPolygon(), getDiscreteHitTolerance());
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POLYGONSTROKEPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        // handle stroke evtl. directly; no need to decompose to filled polygon outlines
+                        const primitive2d::PolygonStrokePrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolygonStrokePrimitive2D& >(rCandidate));
+                        const attribute::LineAttribute& rLineAttribute = rPolygonCandidate.getLineAttribute();
+
+                        if(basegfx::fTools::more(rLineAttribute.getWidth(), 0.0))
+                        {
+                            if(basegfx::B2DLINEJOIN_MITER == rLineAttribute.getLineJoin())
+                            {
+                                // if line is mitered, use decomposition since mitered line
+                                // geometry may use more space than the geometry grown by half line width
+                                process(rCandidate.get2DDecomposition(getViewInformation2D()));
+                            }
+                            else
+                            {
+                                // for all other B2DLINEJOIN_* do a hairline HitTest with expanded tolerance
+                                const basegfx::B2DVector aDiscreteHalfLineVector(getViewInformation2D().getObjectToViewTransformation()
+                                    * basegfx::B2DVector(rLineAttribute.getWidth() * 0.5, 0.0));
+                                mbHit = checkHairlineHitWithTolerance(
+                                    rPolygonCandidate.getB2DPolygon(),
+                                    getDiscreteHitTolerance() + aDiscreteHalfLineVector.getLength());
+                            }
+                        }
+                        else
+                        {
+                            // hairline; fallback to hairline test. Do not decompose
+                            // since this may decompose the hairline to dashes
+                            mbHit = checkHairlineHitWithTolerance(rPolygonCandidate.getB2DPolygon(), getDiscreteHitTolerance());
+                        }
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POLYGONWAVEPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        // do not use decompose; just handle like a line with width
+                        const primitive2d::PolygonWavePrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolygonWavePrimitive2D& >(rCandidate));
+                        double fLogicHitTolerance(0.0);
+
+                        // if WaveHeight, grow by it
+                        if(basegfx::fTools::more(rPolygonCandidate.getWaveHeight(), 0.0))
+                        {
+                            fLogicHitTolerance += rPolygonCandidate.getWaveHeight();
+                        }
+
+                        // if line width, grow by it
+                        if(basegfx::fTools::more(rPolygonCandidate.getLineAttribute().getWidth(), 0.0))
+                        {
+                            fLogicHitTolerance += rPolygonCandidate.getLineAttribute().getWidth() * 0.5;
+                        }
+
+                        const basegfx::B2DVector aDiscreteHalfLineVector(getViewInformation2D().getObjectToViewTransformation()
+                            * basegfx::B2DVector(fLogicHitTolerance, 0.0));
+
+                        mbHit = checkHairlineHitWithTolerance(
+                            rPolygonCandidate.getB2DPolygon(),
+                            getDiscreteHitTolerance() + aDiscreteHalfLineVector.getLength());
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        // create filled polyPolygon in discrete coordinates
+                        const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate));
+
+                        // use fill hit test
+                        mbHit = checkFillHitWithTolerance(rPolygonCandidate.getB2DPolyPolygon(), getDiscreteHitTolerance());
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_ALPHAPRIMITIVE2D :
+                {
+                    // sub-transparence group
+                    const primitive2d::AlphaPrimitive2D& rTransCandidate(static_cast< const primitive2d::AlphaPrimitive2D& >(rCandidate));
+
+                    // Currently the transparence content is not taken into account; only
+                    // the children are recursively checked for hit. This may be refined for
+                    // parts where the content is completely transparent if needed.
+                    process(rTransCandidate.getChildren());
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_MASKPRIMITIVE2D :
+                {
+                    // create mask in discrete coordinates; only recursively continue
+                    // with content when HitTest position is inside the mask
+                    const primitive2d::MaskPrimitive2D& rMaskCandidate(static_cast< const primitive2d::MaskPrimitive2D& >(rCandidate));
+
+                    // use fill hit test
+                    if(checkFillHitWithTolerance(rMaskCandidate.getMask(), getDiscreteHitTolerance()))
+                    {
+                        // recursively HitTest children
+                        process(rMaskCandidate.getChildren());
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_SCENEPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        // 2D Scene primitive containing 3D stuff; extract 2D contour in world coordinates
+                        // This may be refined later to an own 3D HitTest renderer which processes the 3D
+                        // geometry directly
+                        const primitive2d::ScenePrimitive2D& rScenePrimitive2DCandidate(static_cast< const primitive2d::ScenePrimitive2D& >(rCandidate));
+                        const primitive2d::Primitive2DSequence xExtracted2DSceneGeometry(rScenePrimitive2DCandidate.getGeometry2D(getViewInformation2D()));
+
+                        if(xExtracted2DSceneGeometry.hasElements())
+                        {
+                            // proccess extracted 2D content
+                            process(xExtracted2DSceneGeometry);
+                        }
+                        else
+                        {
+                            // 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());
+                        }
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D :
+                case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D :
+                case PRIMITIVE2D_ID_GRIDPRIMITIVE2D :
+                case PRIMITIVE2D_ID_HELPLINEPRIMITIVE2D :
+                {
+                    // ignorable primitives
+                    break;
+                }
+                case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D :
+                case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D :
+                {
+                    // 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());
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D :
+                case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D :
+                case PRIMITIVE2D_ID_CONTROLPRIMITIVE2D :
+                case PRIMITIVE2D_ID_FILLGRADIENTPRIMITIVE2D :
+                case PRIMITIVE2D_ID_FILLHATCHPRIMITIVE2D :
+                case PRIMITIVE2D_ID_PAGEPREVIEWPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        // Class of primitives for which just the BoundRect of the primitive itself
+                        // will be used for HitTest currently.
+                        //
+                        // This may be refined in the future, e.g:
+                        // - 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());
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_HITTESTPRIMITIVE2D :
+                {
+                    // HitTest primitive; the default decomposition would return an empty seqence,
+                    // so force this primitive to process it's children directly if the switch is set
+                    // (which is the default). Else, ignore invisible content
+                    if(getUseHitTestPrimitiveContent())
+                    {
+                        const primitive2d::HitTestPrimitive2D& rHitTestCandidate(static_cast< const primitive2d::HitTestPrimitive2D& >(rCandidate));
+                        process(rHitTestCandidate.getChildren());
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D :
+                {
+                    if(!getHitTextOnly())
+                    {
+                        const primitive2d::PointArrayPrimitive2D& rPointArrayCandidate(static_cast< const primitive2d::PointArrayPrimitive2D& >(rCandidate));
+                        const std::vector< basegfx::B2DPoint >& rPositions = rPointArrayCandidate.getPositions();
+                        const sal_uInt32 nCount(rPositions.size());
+
+                        for(sal_uInt32 a(0); !getHit() && a < nCount; a++)
+                        {
+                            const basegfx::B2DPoint aPosition(getViewInformation2D().getObjectToViewTransformation() * rPositions[a]);
+                            const basegfx::B2DVector aDistance(aPosition - getDiscreteHitPosition());
+
+                            if(aDistance.getLength() <= getDiscreteHitTolerance())
+                            {
+                                mbHit = true;
+                            }
+                        }
+                    }
+
+                    break;
+                }
+                default :
+                {
+                    // process recursively
+                    process(rCandidate.get2DDecomposition(getViewInformation2D()));
+
+                    break;
+                }
+            }
+        }
+
+    } // end of namespace processor2d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/processor2d/makefile.mk b/drawinglayer/source/processor2d/makefile.mk
index 38dcb42cd4a0..fcbf2413b61f 100644
--- a/drawinglayer/source/processor2d/makefile.mk
+++ b/drawinglayer/source/processor2d/makefile.mk
@@ -57,7 +57,9 @@ SLOFILES= \
         $(SLO)$/vclmetafileprocessor2d.obj		\
         $(SLO)$/contourextractor2d.obj			\
         $(SLO)$/linegeometryextractor2d.obj		\
-        $(SLO)$/canvasprocessor.obj
+        $(SLO)$/canvasprocessor.obj				\
+        $(SLO)$/hittestprocessor2d.obj			\
+        $(SLO)$/textaspolygonextractor2d.obj
 
 # --- Targets ----------------------------------
 
diff --git a/drawinglayer/source/processor2d/textaspolygonextractor2d.cxx b/drawinglayer/source/processor2d/textaspolygonextractor2d.cxx
new file mode 100644
index 000000000000..9358c7f39c57
--- /dev/null
+++ b/drawinglayer/source/processor2d/textaspolygonextractor2d.cxx
@@ -0,0 +1,255 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: contourextractor2d.cxx,v $
+ *
+ *  $Revision: 1.6 $
+ *
+ *  last change: $Author: aw $ $Date: 2008-06-24 15:31:08 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_drawinglayer.hxx"
+
+#include <drawinglayer/processor2d/textaspolygonextractor2d.hxx>
+#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
+#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
+#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
+#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+
+//////////////////////////////////////////////////////////////////////////////
+
+namespace drawinglayer
+{
+    namespace processor2d
+    {
+        void TextAsPolygonExtractor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
+        {
+            switch(rCandidate.getPrimitiveID())
+            {
+                case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D :
+                {
+                    // TextDecoratedPortionPrimitive2D can produce the following primitives
+                    // when being decomposed:
+                    //
+                    // - TextSimplePortionPrimitive2D
+                    // - PolygonWavePrimitive2D
+                    //      - PolygonStrokePrimitive2D
+                    // - PolygonStrokePrimitive2D
+                    //      - PolyPolygonColorPrimitive2D
+                    //      - PolyPolygonHairlinePrimitive2D
+                    //          - PolygonHairlinePrimitive2D
+                    // - ShadowPrimitive2D
+                    //      - ModifiedColorPrimitive2D
+                    //      - TransformPrimitive2D
+                    // - TextEffectPrimitive2D
+                    //      - ModifiedColorPrimitive2D
+                    //      - TransformPrimitive2D
+                    //      - GroupPrimitive2D
+
+                    // encapsulate with flag and use decomposition
+                    mnInText++;
+                    process(rCandidate.get2DDecomposition(getViewInformation2D()));
+                    mnInText--;
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D :
+                {
+                    // TextSimplePortionPrimitive2D can produce the following primitives
+                    // when being decomposed:
+                    //
+                    // - PolyPolygonColorPrimitive2D
+                    // - TextEffectPrimitive2D
+                    //      - ModifiedColorPrimitive2D
+                    //      - TransformPrimitive2D
+                    //      - GroupPrimitive2D
+
+                    // encapsulate with flag and use decomposition
+                    mnInText++;
+                    process(rCandidate.get2DDecomposition(getViewInformation2D()));
+                    mnInText--;
+
+                    break;
+                }
+
+                // as can be seen from the TextSimplePortionPrimitive2D and the
+                // TextDecoratedPortionPrimitive2D, inside of the mnInText marks
+                // the following primitives can occurr containing geometry data
+                // from text decomposition:
+                //
+                // - PolyPolygonColorPrimitive2D
+                // - PolygonHairlinePrimitive2D
+                // - PolyPolygonHairlinePrimitive2D (for convenience)
+                //
+                case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
+                {
+                    if(mnInText)
+                    {
+                        const primitive2d::PolyPolygonColorPrimitive2D& rPoPoCoCandidate(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate));
+                        basegfx::B2DPolyPolygon aPolyPolygon(rPoPoCoCandidate.getB2DPolyPolygon());
+
+                        if(aPolyPolygon.count())
+                        {
+                            // transform the PolyPolygon
+                            aPolyPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
+
+                            // get evtl. corrected color
+                            const basegfx::BColor aColor(maBColorModifierStack.getModifiedColor(rPoPoCoCandidate.getBColor()));
+
+                            // add to result vector
+                            maTarget.push_back(TextAsPolygonDataNode(aPolyPolygon, aColor, true));
+                        }
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D :
+                {
+                    if(mnInText)
+                    {
+                        const primitive2d::PolygonHairlinePrimitive2D& rPoHaCandidate(static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate));
+                        basegfx::B2DPolygon aPolygon(rPoHaCandidate.getB2DPolygon());
+
+                        if(aPolygon.count())
+                        {
+                            // transform the Polygon
+                            aPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
+
+                            // get evtl. corrected color
+                            const basegfx::BColor aColor(maBColorModifierStack.getModifiedColor(rPoHaCandidate.getBColor()));
+
+                            // add to result vector
+                            maTarget.push_back(TextAsPolygonDataNode(basegfx::B2DPolyPolygon(aPolygon), aColor, false));
+                        }
+                    }
+
+                    break;
+                }
+                case PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D :
+                {
+                    if(mnInText)
+                    {
+                        const primitive2d::PolyPolygonHairlinePrimitive2D& rPoPoHaCandidate(static_cast< const primitive2d::PolyPolygonHairlinePrimitive2D& >(rCandidate));
+                        basegfx::B2DPolyPolygon aPolyPolygon(rPoPoHaCandidate.getB2DPolyPolygon());
+
+                        if(aPolyPolygon.count())
+                        {
+                            // transform the Polygon
+                            aPolyPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
+
+                            // get evtl. corrected color
+                            const basegfx::BColor aColor(maBColorModifierStack.getModifiedColor(rPoPoHaCandidate.getBColor()));
+
+                            // add to result vector
+                            maTarget.push_back(TextAsPolygonDataNode(aPolyPolygon, aColor, false));
+                        }
+                    }
+
+                    break;
+                }
+
+                // usage of color modification stack is needed
+                case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D :
+                {
+                    const primitive2d::ModifiedColorPrimitive2D& rModifiedColorCandidate(static_cast< const primitive2d::ModifiedColorPrimitive2D& >(rCandidate));
+
+                    if(rModifiedColorCandidate.getChildren().hasElements())
+                    {
+                        maBColorModifierStack.push(rModifiedColorCandidate.getColorModifier());
+                        process(rModifiedColorCandidate.getChildren());
+                        maBColorModifierStack.pop();
+                    }
+
+                    break;
+                }
+
+                // usage of transformation stack is needed
+                case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D :
+                {
+                    // remember current transformation and ViewInformation
+                    const primitive2d::TransformPrimitive2D& rTransformCandidate(static_cast< const primitive2d::TransformPrimitive2D& >(rCandidate));
+                    const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
+
+                    // create new transformations for CurrentTransformation and for local ViewInformation2D
+                    const geometry::ViewInformation2D aViewInformation2D(
+                        getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
+                        getViewInformation2D().getViewTransformation(),
+                        getViewInformation2D().getViewport(),
+                        getViewInformation2D().getVisualizedPage(),
+                        getViewInformation2D().getViewTime(),
+                        getViewInformation2D().getExtendedInformationSequence());
+                    updateViewInformation(aViewInformation2D);
+
+                    // proccess content
+                    process(rTransformCandidate.getChildren());
+
+                    // restore transformations
+                    updateViewInformation(aLastViewInformation2D);
+
+                    break;
+                }
+
+                // ignorable primitives
+                case PRIMITIVE2D_ID_SCENEPRIMITIVE2D :
+                case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D :
+                case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D :
+                case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D :
+                case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D :
+                case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D :
+                case PRIMITIVE2D_ID_MASKPRIMITIVE2D :
+                {
+                    break;
+                }
+
+                default :
+                {
+                    // process recursively
+                    process(rCandidate.get2DDecomposition(getViewInformation2D()));
+                    break;
+                }
+            }
+        }
+
+        TextAsPolygonExtractor2D::TextAsPolygonExtractor2D(const geometry::ViewInformation2D& rViewInformation)
+        :   BaseProcessor2D(rViewInformation),
+            maTarget(),
+            maBColorModifierStack(),
+            mnInText(0)
+        {
+        }
+
+        TextAsPolygonExtractor2D::~TextAsPolygonExtractor2D()
+        {
+        }
+    } // end of namespace processor2d
+} // end of namespace drawinglayer
+
+//////////////////////////////////////////////////////////////////////////////
+// eof
diff --git a/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx b/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
index 559974682463..229319f11f75 100644
--- a/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
+++ b/drawinglayer/source/processor2d/vclpixelprocessor2d.cxx
@@ -64,6 +64,7 @@
 #include <vcl/hatch.hxx>
 #include <tools/diagnose_ex.h>
 #include <com/sun/star/awt/PosSize.hpp>
+#include <drawinglayer/primitive2d/invertprimitive2d.hxx>
 #include <cstdio>
 #include <drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx>
 
@@ -532,6 +533,28 @@ namespace drawinglayer
                     // Action: Ignore here, do nothing.
                     break;
                 }
+                case PRIMITIVE2D_ID_INVERTPRIMITIVE2D :
+                {
+                    // invert primitive (currently only used for HighContrast fallback for selection in SW and SC).
+                    // Set OutDev to XOR
+                    mpOutputDevice->Push();
+                    mpOutputDevice->SetRasterOp( ROP_XOR );
+
+                    // force paint color to white by using ColorModifierStack
+                    const basegfx::BColor aColWhite(1.0, 1.0, 1.0);
+                    const basegfx::BColorModifier aColorModifier(aColWhite, 0.0, basegfx::BCOLORMODIFYMODE_REPLACE);
+                    maBColorModifierStack.push(aColorModifier);
+
+                    // process content recursively
+                    process(rCandidate.get2DDecomposition(getViewInformation2D()));
+
+                    // restore ColorModifierStack
+                    maBColorModifierStack.pop();
+
+                    // restore OutDev
+                    mpOutputDevice->Pop();
+                    break;
+                }
                 default :
                 {
                     // process recursively