cws tl79: merge with DEV300_m83

62 files changed, 1262 insertions, 1412 deletions

diff --git a/vcl/aqua/inc/salgdi.h b/vcl/aqua/inc/salgdi.h
index d83067cb64b8..247de1b95dec 100644
--- a/vcl/aqua/inc/salgdi.h
+++ b/vcl/aqua/inc/salgdi.h
@@ -230,15 +230,15 @@ public:
     CGPoint*                makeCGptArray(ULONG nPoints, const SalPoint*  pPtAry);
     // native widget rendering methods that require mirroring
     virtual BOOL        hitTestNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                              const Point& aPos, SalControlHandle& rControlHandle, BOOL& rIsInside );
+                                              const Point& aPos, BOOL& rIsInside );
     virtual BOOL        drawNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                           ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                           ControlState nState, const ImplControlValue& aValue,
                                            const rtl::OUString& aCaption );
     virtual BOOL        drawNativeControlText( ControlType nType, ControlPart nPart, const Region& rControlRegion,
                                                ControlState nState, const ImplControlValue& aValue,
-                                               SalControlHandle& rControlHandle, const rtl::OUString& aCaption );
+                                               const rtl::OUString& aCaption );
     virtual BOOL        getNativeControlRegion( ControlType nType, ControlPart nPart, const Region& rControlRegion, ControlState nState,
-                                                const ImplControlValue& aValue, SalControlHandle& rControlHandle, const rtl::OUString& aCaption,
+                                                const ImplControlValue& aValue, const rtl::OUString& aCaption,
                                                 Region &rNativeBoundingRegion, Region &rNativeContentRegion );
 
     // get device resolution
diff --git a/vcl/aqua/source/gdi/salgdi.cxx b/vcl/aqua/source/gdi/salgdi.cxx
index 1ef370f43a92..5b1e24befc9b 100644
--- a/vcl/aqua/source/gdi/salgdi.cxx
+++ b/vcl/aqua/source/gdi/salgdi.cxx
@@ -473,7 +473,6 @@ static void AddPolygonToPath( CGMutablePathRef xPath,
     const CGAffineTransform* pTransform = NULL;
 
     const bool bHasCurves = rPolygon.areControlPointsUsed();
-    bool bPendingCurve = false;
     for( int nPointIdx = 0, nPrevIdx = 0;; nPrevIdx = nPointIdx++ )
     {
         int nClosedIdx = nPointIdx;
@@ -488,7 +487,7 @@ static void AddPolygonToPath( CGMutablePathRef xPath,
 
         ::basegfx::B2DPoint aPoint = rPolygon.getB2DPoint( nClosedIdx );
 
-        if(bPixelSnap)
+        if( bPixelSnap)
         {
             // snap device coordinates to full pixels
             aPoint.setX( basegfx::fround( aPoint.getX() ) );
@@ -498,9 +497,19 @@ static void AddPolygonToPath( CGMutablePathRef xPath,
         if( bLineDraw )
             aPoint += aHalfPointOfs;
 
-        if( !nPointIdx )            // first point
+        if( !nPointIdx ) { // first point => just move there
             CGPathMoveToPoint( xPath, pTransform, aPoint.getX(), aPoint.getY() );
-        else if( !bPendingCurve )   // line segment
+            continue;
+        }
+
+        bool bPendingCurve = false;
+        if( bHasCurves )
+        {
+            bPendingCurve = rPolygon.isNextControlPointUsed( nPrevIdx );
+            bPendingCurve |= rPolygon.isPrevControlPointUsed( nClosedIdx );
+        }
+
+        if( !bPendingCurve )    // line segment
             CGPathAddLineToPoint( xPath, pTransform, aPoint.getX(), aPoint.getY() );
         else                        // cubic bezier segment
         {
@@ -514,9 +523,6 @@ static void AddPolygonToPath( CGMutablePathRef xPath,
             CGPathAddCurveToPoint( xPath, pTransform, aCP1.getX(), aCP1.getY(),
                 aCP2.getX(), aCP2.getY(), aPoint.getX(), aPoint.getY() );
         }
-
-        if( bHasCurves )
-            bPendingCurve = rPolygon.isNextControlPointUsed( nClosedIdx );
     }
 
     if( bClosePath )
diff --git a/vcl/aqua/source/gdi/salnativewidgets.cxx b/vcl/aqua/source/gdi/salnativewidgets.cxx
index b4b843eaca58..5eccf88dc523 100644
--- a/vcl/aqua/source/gdi/salnativewidgets.cxx
+++ b/vcl/aqua/source/gdi/salnativewidgets.cxx
@@ -380,7 +380,7 @@ BOOL AquaSalGraphics::IsNativeControlSupported( ControlType nType, ControlPart n
  *  nType/nPart combination.
  */
 BOOL AquaSalGraphics::hitTestNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                        const Point& rPos, SalControlHandle& rControlHandle, BOOL& rIsInside )
+                        const Point& rPos, BOOL& rIsInside )
 {
     if ( nType == CTRL_SCROLLBAR )
     {
@@ -468,7 +468,6 @@ UInt32 AquaSalGraphics::getTrackState( ControlState nState )
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:     An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the AquaSalGraphics implementation.
  *  aCaption:   A caption or title string (like button text etc)
  */
 BOOL AquaSalGraphics::drawNativeControl(ControlType nType,
@@ -476,7 +475,6 @@ BOOL AquaSalGraphics::drawNativeControl(ControlType nType,
                     const Region& rControlRegion,
                     ControlState nState,
                     const ImplControlValue& aValue,
-                    SalControlHandle& rControlHandle,
                     const rtl::OUString& aCaption )
 {
     BOOL bOK = FALSE;
@@ -1226,12 +1224,11 @@ BOOL AquaSalGraphics::drawNativeControl(ControlType nType,
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:     An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the AquaSalGraphics implementation.
  *  aCaption:   A caption or title string (like button text etc)
  */
 BOOL AquaSalGraphics::drawNativeControlText( ControlType nType, ControlPart nPart, const Region& rControlRegion,
                                                ControlState nState, const ImplControlValue& aValue,
-                                               SalControlHandle& rControlHandle, const rtl::OUString& aCaption )
+                                               const rtl::OUString& aCaption )
 {
     return( FALSE );
 }
@@ -1248,11 +1245,10 @@ BOOL AquaSalGraphics::drawNativeControlText( ControlType nType, ControlPart nPar
  *
  *  rControlRegion: The bounding region of the control in VCL frame coordinates.
  *  aValue:     An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the AquaSalGraphics implementation.
  *  aCaption:       A caption or title string (like button text etc)
  */
 BOOL AquaSalGraphics::getNativeControlRegion( ControlType nType, ControlPart nPart, const Region& rControlRegion, ControlState nState,
-                                               const ImplControlValue& aValue, SalControlHandle& rControlHandle, const rtl::OUString& aCaption,
+                                               const ImplControlValue& aValue, const rtl::OUString& aCaption,
                                                 Region &rNativeBoundingRegion, Region &rNativeContentRegion )
 
 {
diff --git a/vcl/aqua/source/window/salframe.cxx b/vcl/aqua/source/window/salframe.cxx
index 0fd028864bf4..b14354e1b4bd 100644
--- a/vcl/aqua/source/window/salframe.cxx
+++ b/vcl/aqua/source/window/salframe.cxx
@@ -1357,40 +1357,81 @@ void AquaSalFrame::GetWorkArea( Rectangle& rRect )
 SalPointerState AquaSalFrame::GetPointerState()
 {
     SalPointerState state;
+    state.mnState = 0;
 
     // get position
     NSPoint aPt = [mpWindow mouseLocationOutsideOfEventStream];
     CocoaToVCL( aPt, false );
     state.maPos = Point(static_cast<long>(aPt.x), static_cast<long>(aPt.y));
 
-    // FIXME: replace Carbon by Cocoa
-    // Cocoa does not have an equivalent for GetCurrentEventButtonState
-    // and GetCurrentEventKeyModifiers.
-    // we could try to get away with tracking all events for modifierKeys
-    // and all mouse events for button state in VCL_NSApllication::sendEvent,
-    // but it is unclear whether this will get us the same result.
-    // leave in GetCurrentEventButtonState and GetCurrentEventKeyModifiers for now
+    NSEvent* pCur = [NSApp currentEvent];
+    bool bMouseEvent = false;
+    if( pCur )
+    {
+        bMouseEvent = true;
+        switch( [pCur type] )
+        {
+        case NSLeftMouseDown:       state.mnState |= MOUSE_LEFT; break;
+        case NSLeftMouseUp:         break;
+        case NSRightMouseDown:      state.mnState |= MOUSE_RIGHT; break;
+        case NSRightMouseUp:        break;
+        case NSOtherMouseDown:      state.mnState |= ([pCur buttonNumber] == 2) ? MOUSE_MIDDLE : 0; break;
+        case NSOtherMouseUp:        break;
+        case NSMouseMoved:          break;
+        case NSLeftMouseDragged:    state.mnState |= MOUSE_LEFT; break;
+        case NSRightMouseDragged:   state.mnState |= MOUSE_RIGHT; break;
+        case NSOtherMouseDragged:   state.mnState |= ([pCur buttonNumber] == 2) ? MOUSE_MIDDLE : 0; break;
+            break;
+        default:
+            bMouseEvent = false;
+            break;
+        }
+    }
+    if( bMouseEvent )
+    {
+        unsigned int nMask = (unsigned int)[pCur modifierFlags];
+        if( (nMask & NSShiftKeyMask) != 0 )
+            state.mnState |= KEY_SHIFT;
+        if( (nMask & NSControlKeyMask) != 0 )
+            state.mnState |= KEY_MOD3;
+        if( (nMask & NSAlternateKeyMask) != 0 )
+            state.mnState |= KEY_MOD2;
+        if( (nMask & NSCommandKeyMask) != 0 )
+            state.mnState |= KEY_MOD1;
+
+    }
+    else
+    {
+        // FIXME: replace Carbon by Cocoa
+        // Cocoa does not have an equivalent for GetCurrentEventButtonState
+        // and GetCurrentEventKeyModifiers.
+        // we could try to get away with tracking all events for modifierKeys
+        // and all mouse events for button state in VCL_NSApllication::sendEvent,
+        // but it is unclear whether this will get us the same result.
+        // leave in GetCurrentEventButtonState and GetCurrentEventKeyModifiers for now
+
+        // fill in button state
+        UInt32 nState = GetCurrentEventButtonState();
+        state.mnState = 0;
+        if( nState & 1 )
+            state.mnState |= MOUSE_LEFT;    // primary button
+        if( nState & 2 )
+            state.mnState |= MOUSE_RIGHT;   // secondary button
+        if( nState & 4 )
+            state.mnState |= MOUSE_MIDDLE;  // tertiary button
+
+        // fill in modifier state
+        nState = GetCurrentEventKeyModifiers();
+        if( nState & shiftKey )
+            state.mnState |= KEY_SHIFT;
+        if( nState & controlKey )
+            state.mnState |= KEY_MOD3;
+        if( nState & optionKey )
+            state.mnState |= KEY_MOD2;
+        if( nState & cmdKey )
+            state.mnState |= KEY_MOD1;
+    }
 
-    // fill in button state
-    UInt32 nState = GetCurrentEventButtonState();
-    state.mnState = 0;
-    if( nState & 1 )
-        state.mnState |= MOUSE_LEFT;    // primary button
-    if( nState & 2 )
-        state.mnState |= MOUSE_RIGHT;   // secondary button
-    if( nState & 4 )
-        state.mnState |= MOUSE_MIDDLE;  // tertiary button
-
-    // fill in modifier state
-    nState = GetCurrentEventKeyModifiers();
-    if( nState & shiftKey )
-        state.mnState |= KEY_SHIFT;
-    if( nState & controlKey )
-        state.mnState |= KEY_MOD3;
-    if( nState & optionKey )
-        state.mnState |= KEY_MOD2;
-    if( nState & cmdKey )
-        state.mnState |= KEY_MOD1;
 
     return state;
 }
diff --git a/vcl/inc/vcl/dockwin.hxx b/vcl/inc/vcl/dockwin.hxx
index 3a1dca044bb7..61464400d595 100644
--- a/vcl/inc/vcl/dockwin.hxx
+++ b/vcl/inc/vcl/dockwin.hxx
@@ -152,7 +152,7 @@ public:
     void            Unlock();
     BOOL            IsLocked() const;
 
-    void            StartPopupMode( ToolBox* pParentToolBox );
+    void            StartPopupMode( ToolBox* pParentToolBox, ULONG nPopupModeFlags );
     BOOL            IsInPopupMode() const;
 
     void            TitleButtonClick( USHORT nButton );
@@ -234,7 +234,10 @@ public:
     BOOL IsLocked( const Window *pWin );
 
     void    StartPopupMode( ToolBox *pParentToolBox, const Window *pWin );
+    void    StartPopupMode( ToolBox *pParentToolBox, const Window *pWin, ULONG nPopupModeFlags );
+
     BOOL    IsInPopupMode( const Window *pWin );
+    void    EndPopupMode( const Window *pWin );
 
     // required because those methods are not virtual in Window (!!!) and must
     // be availbale from the toolkit
diff --git a/vcl/inc/vcl/graphite_cache.hxx b/vcl/inc/vcl/graphite_cache.hxx
index eba5109c7446..5472b32dd62f 100644
--- a/vcl/inc/vcl/graphite_cache.hxx
+++ b/vcl/inc/vcl/graphite_cache.hxx
@@ -127,7 +127,7 @@ public:
     }
     m_segMap.clear();
   };
-  GrSegRecord * getSegment(ImplLayoutArgs & layoutArgs, bool bIsRtl)
+  GrSegRecord * getSegment(ImplLayoutArgs & layoutArgs, bool bIsRtl, int segCharLimit)
   {
     GrSegRecord * found = NULL;
     // try to find a segment starting at correct place, if not, try to find a
@@ -152,8 +152,6 @@ public:
       if (found->m_seg->startCharacter() <= layoutArgs.mnMinCharPos &&
           found->m_seg->stopCharacter() >= layoutArgs.mnEndCharPos)
       {
-        const size_t seg_char_limit = min(layoutArgs.mnLength, layoutArgs.mnEndCharPos
-          + GraphiteLayout::EXTRA_CONTEXT_LENGTH);
         DBG_ASSERT(found && found->m_seg, "null entry in GraphiteSegmentCache");
         // restore original start character, in case it has changed
         found->m_seg->setTextSourceOffset(found->m_startChar);
@@ -161,7 +159,7 @@ public:
         // interest
         // We could use substr and ==, but substr does a copy,
         // so its probably faster to do it like this
-        for (size_t i = layoutArgs.mnMinCharPos; i < seg_char_limit; i++)
+        for (int i = layoutArgs.mnMinCharPos; i < segCharLimit; i++)
         {
           //if (!found->m_rope->match(rtl::OUString(layoutArgs.mpStr[i], layoutArgs.mnLength), i - found->m_seg->startCharacter()))
           if (found->m_rope->getStr()[i-found->m_seg->startCharacter()] != layoutArgs.mpStr[i])
@@ -171,6 +169,15 @@ public:
         {
             return NULL;
         }
+        if (found->m_seg->stopCharacter() > layoutArgs.mnEndCharPos &&
+            static_cast<int>(found->char2BaseGlyph().size()) > layoutArgs.mnEndCharPos)
+        {
+            // check that the requested end character isn't mid cluster
+            if (found->char2BaseGlyph()[layoutArgs.mnEndCharPos-layoutArgs.mnMinCharPos] == -1)
+            {
+                return NULL;
+            }
+        }
 //        if (found->m_lockCount != 0)
 //          OutputDebugString("Multple users of SegRecord!");
         found->m_lockCount++;
@@ -183,10 +190,8 @@ public:
       // this is expecially needed when editing a large paragraph
       // each edit changes the pointers, but if we don't reuse any segments it gets very
       // slow.
-      const size_t seg_char_limit = min(layoutArgs.mnLength, layoutArgs.mnEndCharPos
-          + GraphiteLayout::EXTRA_CONTEXT_LENGTH);
       rtl::OUString * rope = new rtl::OUString(layoutArgs.mpStr + layoutArgs.mnMinCharPos,
-                                         seg_char_limit - layoutArgs.mnMinCharPos);
+                                         segCharLimit - layoutArgs.mnMinCharPos);
       if (!rope) return NULL;
       size_t nHash = (*(rope)).hashCode();
       GrRMEntry range = m_ropeMap.equal_range(nHash);
diff --git a/vcl/inc/vcl/graphite_layout.hxx b/vcl/inc/vcl/graphite_layout.hxx
index 1fbb11211ca0..520f4620cd90 100644
--- a/vcl/inc/vcl/graphite_layout.hxx
+++ b/vcl/inc/vcl/graphite_layout.hxx
@@ -75,6 +75,14 @@ namespace grutils { class GrFeatureParser; }
 class VCL_DLLPUBLIC GraphiteLayout : public SalLayout
 {
 public:
+    // Mask to allow Word break status to be stored within mvChar2BaseGlyph
+    enum {
+        WORD_BREAK_BEFORE   = 0x40000000,
+        HYPHEN_BREAK_BEFORE = 0x80000000,
+        BREAK_MASK          = 0xC0000000,
+        GLYPH_INDEX_MASK    = 0x3FFFFFFF
+    } LineBreakMask;
+
     class Glyphs : public std::vector<GlyphItem>
     {
     public:
@@ -159,6 +167,7 @@ private:
     std::pair<int,int>    glyph_to_chars(const GlyphItem &) const;
 
     std::pair<long,long>  caret_positions(size_t) const;
+    void expandOrCondense(ImplLayoutArgs &rArgs);
 };
 
 
diff --git a/vcl/inc/vcl/help.hxx b/vcl/inc/vcl/help.hxx
index 4bca986812ed..30308aa8a723 100644
--- a/vcl/inc/vcl/help.hxx
+++ b/vcl/inc/vcl/help.hxx
@@ -48,6 +48,7 @@ class Window;
 #define QUICKHELP_BOTTOM    ((USHORT)0x0020)
 #define QUICKHELP_NOAUTOPOS (QUICKHELP_LEFT | QUICKHELP_CENTER | QUICKHELP_RIGHT | QUICKHELP_TOP | QUICKHELP_VCENTER | QUICKHELP_BOTTOM)
 #define QUICKHELP_CTRLTEXT  ((USHORT)0x0040)
+#define QUICKHELP_NOEVADEPOINTER ((USHORT)0x4000)
 #define QUICKHELP_BIDI_RTL  ((USHORT)0x8000)
 
 // By changes you must also change: rsc/vclrsc.hxx
diff --git a/vcl/inc/vcl/impfont.hxx b/vcl/inc/vcl/impfont.hxx
index 6ce9f21500b5..a1104bbf4a86 100644
--- a/vcl/inc/vcl/impfont.hxx
+++ b/vcl/inc/vcl/impfont.hxx
@@ -177,7 +177,8 @@ class CmapResult;
 class VCL_DLLPUBLIC ImplFontCharMap
 {
 public:
-   explicit             ImplFontCharMap( const CmapResult& );
+    explicit             ImplFontCharMap( const CmapResult& );
+    virtual              ~ImplFontCharMap();
 
     static ImplFontCharMap* GetDefaultMap( bool bSymbols=false);
 
@@ -201,7 +202,6 @@ public:
     int                 GetGlyphIndex( sal_uInt32 ) const;
 
 private:
-    /*virtual*/         ~ImplFontCharMap();
     int                 ImplFindRangeIndex( sal_uInt32 ) const;
 
     // prevent assignment and copy construction
diff --git a/vcl/inc/vcl/lstbox.hxx b/vcl/inc/vcl/lstbox.hxx
index 98cd05d999dd..3659e5aee485 100644
--- a/vcl/inc/vcl/lstbox.hxx
+++ b/vcl/inc/vcl/lstbox.hxx
@@ -130,6 +130,7 @@ public:
 
     virtual USHORT      GetEntryPos( const XubString& rStr ) const;
     virtual USHORT      GetEntryPos( const void* pData ) const;
+            Image       GetEntryImage( USHORT nPos ) const;
     virtual XubString   GetEntry( USHORT nPos ) const;
     virtual USHORT      GetEntryCount() const;
 
diff --git a/vcl/inc/vcl/outdev.hxx b/vcl/inc/vcl/outdev.hxx
index 70c1e6aa624d..9b748f2b5937 100644
--- a/vcl/inc/vcl/outdev.hxx
+++ b/vcl/inc/vcl/outdev.hxx
@@ -39,6 +39,7 @@
 #include <vcl/mapmod.hxx>
 #include <vcl/wall.hxx>
 #include <vcl/settings.hxx>
+#include <vcl/salnativewidgets.hxx>
 #include <tools/poly.hxx>
 #include <basegfx/vector/b2enums.hxx>
 #include <com/sun/star/uno/Reference.h>
@@ -1177,6 +1178,49 @@ public:
     BitmapEx            GetDownsampledBitmapEx( const Size& rDstSz,
                                                 const Point& rSrcPt, const Size& rSrcSz,
                                                 const BitmapEx& rBmpEx, long nMaxBmpDPIX, long nMaxBmpDPIY );
+
+    //-------------------------------------
+    //  Native Widget Rendering functions
+    //-------------------------------------
+
+    // These all just call through to the private mpGraphics functions of the same name.
+
+    // Query the platform layer for control support
+    BOOL                IsNativeControlSupported( ControlType nType, ControlPart nPart );
+
+    // Query the native control to determine if it was acted upon
+    BOOL                HitTestNativeControl(   ControlType nType,
+                                                ControlPart nPart,
+                                                const Region& rControlRegion,
+                                                const Point& aPos,
+                                                BOOL& rIsInside );
+
+    // Request rendering of a particular control and/or part
+    BOOL                DrawNativeControl(  ControlType nType,
+                                            ControlPart nPart,
+                                            const Region& rControlRegion,
+                                            ControlState nState,
+                                            const ImplControlValue& aValue,
+                                            ::rtl::OUString aCaption );
+
+     // Request rendering of a caption string for a control
+    BOOL                DrawNativeControlText(  ControlType nType,
+                                                ControlPart nPart,
+                                                const Region& rControlRegion,
+                                                ControlState nState,
+                                                const ImplControlValue& aValue,
+                                                ::rtl::OUString aCaption );
+
+    // Query the native control's actual drawing region (including adornment)
+    BOOL                GetNativeControlRegion( ControlType nType,
+                                                ControlPart nPart,
+                                                const Region& rControlRegion,
+                                                ControlState nState,
+                                                const ImplControlValue& aValue,
+                                                ::rtl::OUString aCaption,
+                                                Region &rNativeBoundingRegion,
+                                                Region &rNativeContentRegion );
+
 };
 
 #endif // _SV_OUTDEV_HXX
diff --git a/vcl/inc/vcl/salgdi.hxx b/vcl/inc/vcl/salgdi.hxx
index 02e9efbc0f94..510e797678b0 100644
--- a/vcl/inc/vcl/salgdi.hxx
+++ b/vcl/inc/vcl/salgdi.hxx
@@ -159,15 +159,15 @@ protected:
 
     // native widget rendering methods that require mirroring
     virtual BOOL        hitTestNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                              const Point& aPos, SalControlHandle& rControlHandle, BOOL& rIsInside );
+                                              const Point& aPos, BOOL& rIsInside );
     virtual BOOL        drawNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                           ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                           ControlState nState, const ImplControlValue& aValue,
                                            const rtl::OUString& aCaption );
     virtual BOOL        drawNativeControlText( ControlType nType, ControlPart nPart, const Region& rControlRegion,
                                                ControlState nState, const ImplControlValue& aValue,
-                                               SalControlHandle& rControlHandle, const rtl::OUString& aCaption );
+                                               const rtl::OUString& aCaption );
     virtual BOOL        getNativeControlRegion( ControlType nType, ControlPart nPart, const Region& rControlRegion, ControlState nState,
-                                                const ImplControlValue& aValue, SalControlHandle& rControlHandle, const rtl::OUString& aCaption,
+                                                const ImplControlValue& aValue, const rtl::OUString& aCaption,
                                                 Region &rNativeBoundingRegion, Region &rNativeContentRegion );
 
     /** Render bitmap with alpha channel
@@ -442,7 +442,6 @@ public:
                                       ControlPart nPart,
                                       const Region& rControlRegion,
                                       const Point& aPos,
-                                      SalControlHandle& rControlHandle,
                                       BOOL& rIsInside,
                                       const OutputDevice *pOutDev );
 
@@ -452,7 +451,6 @@ public:
                                     const Region& rControlRegion,
                                     ControlState nState,
                                     const ImplControlValue& aValue,
-                                    SalControlHandle& rControlHandle,
                                     const rtl::OUString& aCaption,
                                     const OutputDevice *pOutDev );
 
@@ -462,7 +460,6 @@ public:
                                         const Region& rControlRegion,
                                         ControlState nState,
                                         const ImplControlValue& aValue,
-                                        SalControlHandle& rControlHandle,
                                         const rtl::OUString& aCaption,
                                         const OutputDevice *pOutDev );
 
@@ -472,7 +469,6 @@ public:
                                          const Region& rControlRegion,
                                          ControlState nState,
                                          const ImplControlValue& aValue,
-                                         SalControlHandle& rControlHandle,
                                          const rtl::OUString& aCaption,
                                          Region &rNativeBoundingRegion,
                                          Region &rNativeContentRegion,
diff --git a/vcl/inc/vcl/syswin.hxx b/vcl/inc/vcl/syswin.hxx
index b0e74df9a767..b3a7d9b8775e 100644
--- a/vcl/inc/vcl/syswin.hxx
+++ b/vcl/inc/vcl/syswin.hxx
@@ -179,6 +179,8 @@ private:
     SystemWindow (const SystemWindow &);
     SystemWindow & operator= (const SystemWindow &);
 
+    SAL_DLLPRIVATE void ImplMoveToScreen( long& io_rX, long& io_rY, long i_nWidth, long i_nHeight, Window* i_pConfigureWin );
+
 protected:
     // Single argument ctors shall be explicit.
     explicit        SystemWindow( WindowType nType );
diff --git a/vcl/inc/vcl/vclevent.hxx b/vcl/inc/vcl/vclevent.hxx
index fcf1d2ee0387..8ccb880fce34 100644
--- a/vcl/inc/vcl/vclevent.hxx
+++ b/vcl/inc/vcl/vclevent.hxx
@@ -154,8 +154,8 @@ namespace com { namespace sun { namespace star {
 #define VCLEVENT_TOOLBOX_FORMATCHANGED      1172        // request new layout
 #define VCLEVENT_COMBOBOX_SETTEXT           1173
 // --> OD 2009-04-01 #i92103#
-#define VCLEVENT_LISTBOX_ENTRY_EXPANDED     1174
-#define VCLEVENT_LISTBOX_ENTRY_COLLAPSED    1175
+#define VCLEVENT_ITEM_EXPANDED              1174
+#define VCLEVENT_ITEM_COLLAPSED             1175
 // <--
 #define VCLEVENT_DROPDOWN_PRE_OPEN          1176
 
diff --git a/vcl/inc/vcl/window.h b/vcl/inc/vcl/window.h
index 9d917a09b6de..691c3ed18421 100644
--- a/vcl/inc/vcl/window.h
+++ b/vcl/inc/vcl/window.h
@@ -56,7 +56,6 @@ class VirtualDevice;
 class Cursor;
 class ImplDevFontList;
 class ImplFontCache;
-class SalControlHandle;
 class SmartId;
 class VCLXWindow;
 class SalFrame;
@@ -120,7 +119,6 @@ struct ImplWinData
     USHORT              mnTrackFlags;
     USHORT              mnIsTopWindow;
     BOOL                mbMouseOver;          // tracks mouse over for native widget paint effect
-    SalControlHandle*   mpSalControlHandle;   // native data for NWF
     BOOL                mbEnableNativeWidget; // toggle native widget rendering
     SmartId*            mpSmartHelpId;
     SmartId*            mpSmartUniqueId;
diff --git a/vcl/inc/vcl/window.hxx b/vcl/inc/vcl/window.hxx
index 3d1cc91ee468..8264767e59ad 100644
--- a/vcl/inc/vcl/window.hxx
+++ b/vcl/inc/vcl/window.hxx
@@ -124,6 +124,8 @@ namespace dnd {
 
 namespace vcl { struct ControlLayoutData; }
 
+namespace svt { class PopupWindowControllerImpl; }
+
 // ---------------
 // - WindowTypes -
 // ---------------
@@ -362,6 +364,8 @@ class VCL_DLLPUBLIC Window : public OutputDevice
     friend class ImplPopupFloatWin;
     friend class MenuFloatingWindow;
 
+    friend class svt::PopupWindowControllerImpl;
+
 private:
     // NOTE: to remove many dependencies of other modules
     //       to this central file, all members are now hidden
@@ -548,20 +552,18 @@ public:
     SAL_DLLPRIVATE ::std::vector<Window *>& ImplGetOwnerDrawList();
     SAL_DLLPRIVATE Window*     ImplGetTopmostFrameWindow();
 
-    SAL_DLLPRIVATE Rectangle   ImplGetWindowExtentsRelative( Window *pRelativeWindow, BOOL bClientOnly );
+    SAL_DLLPRIVATE Rectangle   ImplGetWindowExtentsRelative( Window *pRelativeWindow, BOOL bClientOnly ) const;
     SAL_DLLPRIVATE void        ImplNotifyIconifiedState( BOOL bIconified );
     SAL_DLLPRIVATE bool        ImplStopDnd();
     SAL_DLLPRIVATE void        ImplStartDnd();
 
     SAL_DLLPRIVATE static void ImplInitAppFontData( Window* pWindow );
-    SAL_DLLPRIVATE void        ImplInitSalControlHandle();
     SAL_DLLPRIVATE void        ImplPaintToDevice( OutputDevice* pTargetOutDev, const Point& rPos );
 
     SAL_DLLPRIVATE BOOL        ImplIsInTaskPaneList();
     SAL_DLLPRIVATE void        ImplIsInTaskPaneList( BOOL mbIsInTaskList );
     SAL_DLLPRIVATE ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCanvas >
                                ImplGetCanvas( const Size& rFullscreenSize, bool bFullscreen, bool bSpriteCanvas ) const;
-    SAL_DLLPRIVATE void        ImplMoveControlValue( ControlType, const ImplControlValue&, const Point& ) const;
 
 private:
     // Default construction is forbidden and not implemented.
@@ -856,9 +858,9 @@ public:
     Point               AbsoluteScreenToOutputPixel( const Point& rPos ) const;
     Rectangle           GetDesktopRectPixel() const;
     //  window extents including border and decoratrion
-    Rectangle           GetWindowExtentsRelative( Window *pRelativeWindow );
+    Rectangle           GetWindowExtentsRelative( Window *pRelativeWindow ) const;
     // window extents of the client window, coordinates to be used in SetPosPixel
-    Rectangle           GetClientWindowExtentsRelative( Window *pRelativeWindow );
+    Rectangle           GetClientWindowExtentsRelative( Window *pRelativeWindow ) const;
 
     virtual BOOL        IsScrollable() const;
     virtual void        Scroll( long nHorzScroll, long nVertScroll,
@@ -1092,44 +1094,6 @@ public:
     void    EnableNativeWidget( BOOL bEnable = TRUE );
     BOOL    IsNativeWidgetEnabled() const;
 
-    // These all just call through to the private mpWindowImpl->mpFrame functions of the same name.
-
-    // Query the platform layer for control support
-    BOOL                    IsNativeControlSupported( ControlType nType, ControlPart nPart );
-
-    // Query the native control to determine if it was acted upon
-    BOOL                HitTestNativeControl( ControlType nType,
-                                      ControlPart nPart,
-                                      const Region& rControlRegion,
-                                      const Point& aPos,
-                                      BOOL& rIsInside );
-
-    // Request rendering of a particular control and/or part
-    BOOL                DrawNativeControl(    ControlType nType,
-                                      ControlPart nPart,
-                                      const Region& rControlRegion,
-                                      ControlState nState,
-                                      const ImplControlValue& aValue,
-                                      rtl::OUString aCaption );
-
-     // Request rendering of a caption string for a control
-    BOOL                DrawNativeControlText(     ControlType nType,
-                                          ControlPart nPart,
-                                          const Region& rControlRegion,
-                                          ControlState nState,
-                                          const ImplControlValue& aValue,
-                                          rtl::OUString aCaption );
-
-    // Query the native control's actual drawing region (including adornment)
-    BOOL                GetNativeControlRegion(  ControlType nType,
-                                          ControlPart nPart,
-                                          const Region& rControlRegion,
-                                          ControlState nState,
-                                          const ImplControlValue& aValue,
-                                          rtl::OUString aCaption,
-                                          Region &rNativeBoundingRegion,
-                                          Region &rNativeContentRegion );
-
     // a helper method for a Control's Draw method
     void PaintToDevice( OutputDevice* pDevice, const Point& rPos, const Size& rSize );
 
diff --git a/vcl/os2/inc/salgdi.h b/vcl/os2/inc/salgdi.h
index ce486084a5b1..b8dc4eba0199 100644
--- a/vcl/os2/inc/salgdi.h
+++ b/vcl/os2/inc/salgdi.h
@@ -197,15 +197,15 @@ protected:
 #if 0
     // native widget rendering methods that require mirroring
     virtual BOOL        hitTestNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                              const Point& aPos, SalControlHandle& rControlHandle, BOOL& rIsInside );
+                                              const Point& aPos, BOOL& rIsInside );
     virtual BOOL        drawNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                           ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                           ControlState nState, const ImplControlValue& aValue,
                                            rtl::OUString aCaption );
     virtual BOOL        drawNativeControlText( ControlType nType, ControlPart nPart, const Region& rControlRegion,
                                                ControlState nState, const ImplControlValue& aValue,
-                                               SalControlHandle& rControlHandle, rtl::OUString aCaption );
+                                               rtl::OUString aCaption );
     virtual BOOL        getNativeControlRegion( ControlType nType, ControlPart nPart, const Region& rControlRegion, ControlState nState,
-                                                const ImplControlValue& aValue, SalControlHandle& rControlHandle, rtl::OUString aCaption,
+                                                const ImplControlValue& aValue, rtl::OUString aCaption,
                                                 Region &rNativeBoundingRegion, Region &rNativeContentRegion );
 #endif
 
diff --git a/vcl/source/app/help.cxx b/vcl/source/app/help.cxx
index b4ab10887fcd..ac1da931ba06 100644
--- a/vcl/source/app/help.cxx
+++ b/vcl/source/app/help.cxx
@@ -759,18 +759,26 @@ void ImplSetHelpWindowPos( Window* pHelpWin, USHORT nHelpWinStyle, USHORT nStyle
     else if ( ( aPos.Y() + aSz.Height() ) > aScreenRect.Bottom() )
         aPos.Y() = aScreenRect.Bottom() - aSz.Height();
 
-    // the popup must not appear under the mouse
-    // otherwise it would directly be closed due to a focus change...
-    Rectangle aHelpRect( aPos, aSz );
-    if( aHelpRect.IsInside( mPos ) )
+    if( ! (nStyle & QUICKHELP_NOEVADEPOINTER) )
     {
-        Point delta(2,2);
-        Point pSize( aSz.Width(), aSz.Height() );
-        Point pTest( mPos - pSize - delta );
-        if( pTest.X() > aScreenRect.Left() &&  pTest.Y() > aScreenRect.Top() )
-            aPos = pTest;
-        else
-            aPos = mPos + delta;
+        /* the remark below should be obsolete by now as the helpwindow should
+        not be focusable, leaving it as a hint. However it is sensible in most
+        conditions to evade the mouse pointer so the content window is fully visible.
+
+        // the popup must not appear under the mouse
+        // otherwise it would directly be closed due to a focus change...
+        */
+        Rectangle aHelpRect( aPos, aSz );
+        if( aHelpRect.IsInside( mPos ) )
+        {
+            Point delta(2,2);
+            Point pSize( aSz.Width(), aSz.Height() );
+            Point pTest( mPos - pSize - delta );
+            if( pTest.X() > aScreenRect.Left() &&  pTest.Y() > aScreenRect.Top() )
+                aPos = pTest;
+            else
+                aPos = mPos + delta;
+        }
     }
 
     Window* pWindow = pHelpWin->GetParent()->ImplGetFrameWindow();
diff --git a/vcl/source/control/ilstbox.cxx b/vcl/source/control/ilstbox.cxx
index cd74a4cd88ce..ebccfdc1e6bb 100644
--- a/vcl/source/control/ilstbox.cxx
+++ b/vcl/source/control/ilstbox.cxx
@@ -741,6 +741,13 @@ void ImplListBoxWindow::ImplUpdateEntryMetrics( ImplEntryType& rEntry )
                                      aMetrics.nEntryHeight );
     }
 
+    if ( !aMetrics.bText && !aMetrics.bImage && !IsUserDrawEnabled() )
+    {
+        // entries which have no (aka an empty) text, and no image, and are not user-drawn, should be
+        // shown nonetheless
+        aMetrics.nEntryHeight = mnTextHeight + mnBorder;
+    }
+
     if ( aMetrics.nEntryWidth > mnMaxWidth )
         mnMaxWidth = aMetrics.nEntryWidth;
     if ( aMetrics.nEntryHeight > mnMaxHeight )
diff --git a/vcl/source/control/lstbox.cxx b/vcl/source/control/lstbox.cxx
index 70b67c0a3d57..6c7df5b106bf 100644
--- a/vcl/source/control/lstbox.cxx
+++ b/vcl/source/control/lstbox.cxx
@@ -885,6 +885,8 @@ void ListBox::StateChanged( StateChangedType nType )
     {
         SetStyle( ImplInitStyle( GetStyle() ) );
         mpImplLB->GetMainWindow()->EnableSort( ( GetStyle() & WB_SORT ) ? TRUE : FALSE );
+        BOOL bSimpleMode = ( GetStyle() & WB_SIMPLEMODE ) ? TRUE : FALSE;
+        mpImplLB->SetMultiSelectionSimpleMode( bSimpleMode );
     }
     else if( nType == STATE_CHANGE_MIRRORING )
     {
@@ -1081,6 +1083,15 @@ void ListBox::RemoveEntry( USHORT nPos )
 
 // -----------------------------------------------------------------------
 
+Image ListBox::GetEntryImage( USHORT nPos ) const
+{
+    if ( mpImplLB->GetEntryList()->HasEntryImage( nPos ) )
+        return mpImplLB->GetEntryList()->GetEntryImage( nPos );
+    return Image();
+}
+
+// -----------------------------------------------------------------------
+
 USHORT ListBox::GetEntryPos( const XubString& rStr ) const
 {
     USHORT nPos = mpImplLB->GetEntryList()->FindEntry( rStr );
diff --git a/vcl/source/control/tabctrl.cxx b/vcl/source/control/tabctrl.cxx
index 89fbe6d3db78..95f84626b582 100644
--- a/vcl/source/control/tabctrl.cxx
+++ b/vcl/source/control/tabctrl.cxx
@@ -408,6 +408,9 @@ Size TabControl::ImplGetItemSize( ImplTabItem* pItem, long nMaxWidth )
     if( aImageSize.Height() > aSize.Height() )
         aSize.Height() = aImageSize.Height();
 
+    aSize.Width()  += TAB_TABOFFSET_X*2;
+    aSize.Height() += TAB_TABOFFSET_Y*2;
+
     Region aCtrlRegion(  Rectangle( (const Point&)Point( 0, 0 ), aSize ) );
     Region aBoundingRgn, aContentRgn;
     const ImplControlValue aControlValue( BUTTONVALUE_DONTKNOW, rtl::OUString(), 0 );
@@ -419,8 +422,6 @@ Size TabControl::ImplGetItemSize( ImplTabItem* pItem, long nMaxWidth )
         return aCont.GetSize();
     }
 
-    aSize.Width()  += TAB_TABOFFSET_X*2;
-    aSize.Height() += TAB_TABOFFSET_Y*2;
     // For systems without synthetic bold support
     if ( mbExtraSpace )
         aSize.Width() += TAB_EXTRASPACE_X;
diff --git a/vcl/source/fontsubset/cff.cxx b/vcl/source/fontsubset/cff.cxx
index 620ca64f44d9..cb565122ea63 100644
--- a/vcl/source/fontsubset/cff.cxx
+++ b/vcl/source/fontsubset/cff.cxx
@@ -469,7 +469,7 @@ public: // TODO: is public really needed?
 private:
     // typeop exceution context
     int mnStackIdx;
-    ValType mnValStack[ NMAXSTACK];
+    ValType mnValStack[ NMAXSTACK+4];
     ValType mnTransVals[ NMAXTRANS];
 
     int mnHintSize;
@@ -1242,16 +1242,33 @@ void CffSubsetterContext::convertOneTypeEsc( void)
         break;
         }
     case TYPE2OP::HFLEX1: {
-            assert( mnStackIdx == 9 );
-            writeCurveTo( mnStackIdx, -9, -8, -7, -6, -5, -6 );
-            writeCurveTo( mnStackIdx, -4, -6, -3, -2, -1, -8 );
+            assert( mnStackIdx == 9);
+#if 0 // emulate hflex1 as straight line
+            const ValType* pX = &mnValStack[ mnStackIdx];
+            const ValType fDX = pX[-9] + pX[-7] + pX[-5] + pX[-4] + pX[-3] + pX[-1];
+            writeType1Val( fDX);
+            writeTypeOp( TYPE1OP::HLINETO);
+#else // emulate hflex1 as two curves
+            writeCurveTo( mnStackIdx, -9, -8, -7, -6, -5,  0);
+            writeCurveTo( mnStackIdx, -4,  0, -3, -2, -1,  0);
+        // TODO: emulate hflex1 using othersubr call
+#endif
             mnStackIdx -= 9;
         }
         break;
     case TYPE2OP::HFLEX: {
-            assert( mnStackIdx == 7 );
-            writeCurveTo( mnStackIdx, -7,  0, -6, -5, -4, -5 );
-            writeCurveTo( mnStackIdx, -3, -5, -2,  0, -1,  0 );
+            assert( mnStackIdx == 7);
+            ValType* pX = &mnValStack[ mnStackIdx];
+#if 0 // emulate hflex as straight line
+            const ValType fDX = pX[-7] + pX[-6] + pX[-4] + pX[-3] + pX[-2] + pX[-1];
+            writeType1Val( fDX);
+            writeTypeOp( TYPE1OP::HLINETO);
+#else // emulate hflex as two curves
+            pX[+1] = -pX[-5]; // temp: +dy5==-dy2
+            writeCurveTo( mnStackIdx, -7,  0, -6, -5, -4,  0);
+            writeCurveTo( mnStackIdx, -3,  0, -2, +1, -1,  0);
+        // TODO: emulate hflex using othersubr call
+#endif
             mnStackIdx -= 7;
         }
         break;
diff --git a/vcl/source/gdi/image.cxx b/vcl/source/gdi/image.cxx
index e3f63a03d081..e79308b2664e 100644
--- a/vcl/source/gdi/image.cxx
+++ b/vcl/source/gdi/image.cxx
@@ -50,6 +50,10 @@
 #include <vcl/image.h>
 #include <vcl/image.hxx>
 
+#if OSL_DEBUG_LEVEL > 0
+#include <rtl/strbuf.hxx>
+#endif
+
 DBG_NAME( Image )
 DBG_NAME( ImageList )
 
@@ -543,11 +547,19 @@ void ImageAryData::Load(const rtl::OUString &rPrefix)
 
     rtl::OUString aFileName = rPrefix;
     aFileName += maName;
-#ifdef DBG_UTIL
-    bool bSuccess = aImageTree->loadImage( aFileName, aSymbolsStyle, maBitmapEx, true );
-    DBG_ASSERT (bSuccess, "ImageAryData::Failed to load image");
-#else
-    aImageTree->loadImage( aFileName, aSymbolsStyle, maBitmapEx, true );
+#if OSL_DEBUG_LEVEL > 0
+    bool bSuccess =
+#endif
+        aImageTree->loadImage( aFileName, aSymbolsStyle, maBitmapEx, true );
+#if OSL_DEBUG_LEVEL > 0
+    if ( !bSuccess )
+    {
+        ::rtl::OStringBuffer aMessage;
+        aMessage.append( "ImageAryData::Load: failed to load image '" );
+        aMessage.append( ::rtl::OUStringToOString( aFileName, RTL_TEXTENCODING_UTF8 ).getStr() );
+        aMessage.append( "'" );
+        OSL_ENSURE( false, aMessage.makeStringAndClear().getStr() );
+    }
 #endif
 }
 
diff --git a/vcl/source/gdi/makefile.mk b/vcl/source/gdi/makefile.mk
index 75f2b3fffc64..f069828f25f9 100644..100755
--- a/vcl/source/gdi/makefile.mk
+++ b/vcl/source/gdi/makefile.mk
@@ -106,6 +106,7 @@ SLOFILES=	$(EXCEPTIONSFILES)      \
             $(SLO)$/outdev4.obj 	\
             $(SLO)$/outdev5.obj 	\
             $(SLO)$/outdev6.obj 	\
+            $(SLO)$/outdevnative.obj 	\
             $(SLO)$/regband.obj 	\
             $(SLO)$/region.obj		\
             $(SLO)$/wall.obj		\
diff --git a/vcl/source/gdi/metric.cxx b/vcl/source/gdi/metric.cxx
index e5f54df41c9e..325146b6be8a 100644
--- a/vcl/source/gdi/metric.cxx
+++ b/vcl/source/gdi/metric.cxx
@@ -386,8 +386,9 @@ int ImplFontCharMap::GetGlyphIndex( sal_uInt32 cChar ) const
         const bool bSymbolic = (mpRangeCodes[0]>=0xF000) & (mpRangeCodes[1]<=0xF0FF);
         if( !bSymbolic )
             return 0;
-        // check for symbol aliasing (U+F0xx -> U+00xx)
-        nRange = ImplFindRangeIndex( cChar | 0xF000 );
+        // check for symbol aliasing (U+00xx <-> U+F0xx)
+        cChar |= 0xF000;
+        nRange = ImplFindRangeIndex( cChar );
     }
     // check that we are inside a range
     if( (nRange & 1) != 0 )
@@ -401,7 +402,7 @@ int ImplFontCharMap::GetGlyphIndex( sal_uInt32 cChar ) const
         nGlyphIndex += nStartIndex;
     } else {
         // the glyphid array has the glyph index
-        nGlyphIndex = mpGlyphIds[ nGlyphIndex - nStartIndex];
+        nGlyphIndex = mpGlyphIds[ nGlyphIndex - nStartIndex ];
     }
 
     return nGlyphIndex;
diff --git a/vcl/source/gdi/outdev.cxx b/vcl/source/gdi/outdev.cxx
index 62be0130e068..bb5e4e3ba36d 100644
--- a/vcl/source/gdi/outdev.cxx
+++ b/vcl/source/gdi/outdev.cxx
@@ -2383,6 +2383,16 @@ void OutputDevice::impPaintLineGeometryWithEvtlExpand(
     {
         const double fHalfLineWidth((rInfo.GetWidth() * 0.5) + 0.5);
 
+        if(aLinePolyPolygon.areControlPointsUsed())
+        {
+            // #i110768# When area geometry has to be created, do not
+            // use the fallback bezier decomposition inside createAreaGeometry,
+            // but one that is at least as good as ImplSubdivideBezier was.
+            // There, Polygon::AdaptiveSubdivide was used with default parameter
+            // 1.0 as quality index.
+            aLinePolyPolygon = basegfx::tools::adaptiveSubdivideByDistance(aLinePolyPolygon, 1.0);
+        }
+
         for(sal_uInt32 a(0); a < aLinePolyPolygon.count(); a++)
         {
             aFillPolyPolygon.append(basegfx::tools::createAreaGeometry(
diff --git a/vcl/source/gdi/outdev3.cxx b/vcl/source/gdi/outdev3.cxx
index f4fcba72b0c2..949d3df5275f 100644
--- a/vcl/source/gdi/outdev3.cxx
+++ b/vcl/source/gdi/outdev3.cxx
@@ -579,6 +579,7 @@ Font OutputDevice::GetDefaultFont( USHORT nType, LanguageType eLang,
     {
         aFont.SetHeight( nDefaultHeight );
         aFont.SetWeight( WEIGHT_NORMAL );
+        aFont.SetLanguage( eLang );
 
         if ( aFont.GetCharSet() == RTL_TEXTENCODING_DONTKNOW )
             aFont.SetCharSet( gsl_getSystemTextEncoding() );
diff --git a/vcl/source/gdi/outdevnative.cxx b/vcl/source/gdi/outdevnative.cxx
new file mode 100644
index 000000000000..fed41ec4de85
--- /dev/null
+++ b/vcl/source/gdi/outdevnative.cxx
@@ -0,0 +1,290 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org 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 version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+// MARKER(update_precomp.py): autogen include statement, do not remove
+#include "precompiled_vcl.hxx"
+
+#include "vcl/outdev.hxx"
+#include "vcl/window.hxx"
+#include "vcl/salgdi.hxx"
+#include "vcl/salnativewidgets.hxx"
+#include "vcl/pdfextoutdevdata.hxx"
+
+// -----------------------------------------------------------------------
+
+static bool lcl_enableNativeWidget( const OutputDevice& i_rDevice )
+{
+    const OutDevType eType( i_rDevice.GetOutDevType() );
+    switch ( eType )
+    {
+
+    case OUTDEV_WINDOW:
+        return dynamic_cast< const Window* >( &i_rDevice )->IsNativeWidgetEnabled();
+
+    case OUTDEV_VIRDEV:
+    {
+        const ::vcl::ExtOutDevData* pOutDevData( i_rDevice.GetExtOutDevData() );
+        const ::vcl::PDFExtOutDevData* pPDFData( dynamic_cast< const ::vcl::PDFExtOutDevData* >( pOutDevData ) );
+        if ( pPDFData != NULL )
+            return false;
+        return true;
+    }
+
+    default:
+        return false;
+    }
+}
+
+// -----------------------------------------------------------------------
+// These functions are mainly passthrough functions that allow access to
+// the SalFrame behind a Window object for native widget rendering purposes.
+// -----------------------------------------------------------------------
+
+// -----------------------------------------------------------------------
+
+BOOL OutputDevice::IsNativeControlSupported( ControlType nType, ControlPart nPart )
+{
+    if( !lcl_enableNativeWidget( *this ) )
+        return FALSE;
+
+    if ( !mpGraphics )
+        if ( !ImplGetGraphics() )
+            return FALSE;
+
+    return( mpGraphics->IsNativeControlSupported(nType, nPart) );
+}
+
+
+// -----------------------------------------------------------------------
+
+BOOL OutputDevice::HitTestNativeControl( ControlType nType,
+                              ControlPart nPart,
+                              const Region& rControlRegion,
+                              const Point& aPos,
+                              BOOL& rIsInside )
+{
+    if( !lcl_enableNativeWidget( *this ) )
+        return FALSE;
+
+    if ( !mpGraphics )
+        if ( !ImplGetGraphics() )
+            return FALSE;
+
+    Point aWinOffs( mnOutOffX, mnOutOffY );
+    Region screenRegion( rControlRegion );
+    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
+
+    return( mpGraphics->HitTestNativeControl(nType, nPart, screenRegion, Point( aPos.X() + mnOutOffX, aPos.Y() + mnOutOffY ),
+        rIsInside, this ) );
+}
+
+// -----------------------------------------------------------------------
+
+static void lcl_moveControlValue( ControlType nType, const ImplControlValue& aValue, const Point& rDelta )
+{
+    if( aValue.getOptionalVal() )
+    {
+        switch( nType )
+        {
+            case CTRL_SLIDER:
+            {
+                SliderValue* pSlVal = reinterpret_cast<SliderValue*>(aValue.getOptionalVal());
+                pSlVal->maThumbRect.Move( rDelta.X(), rDelta.Y() );
+            }
+            break;
+            case CTRL_SCROLLBAR:
+            {
+                ScrollbarValue* pScVal = reinterpret_cast<ScrollbarValue*>(aValue.getOptionalVal());
+                pScVal->maThumbRect.Move( rDelta.X(), rDelta.Y() );
+                pScVal->maButton1Rect.Move( rDelta.X(), rDelta.Y() );
+                pScVal->maButton2Rect.Move( rDelta.X(), rDelta.Y() );
+            }
+            break;
+            case CTRL_SPINBOX:
+            case CTRL_SPINBUTTONS:
+            {
+                SpinbuttonValue* pSpVal = reinterpret_cast<SpinbuttonValue*>(aValue.getOptionalVal());
+                pSpVal->maUpperRect.Move( rDelta.X(), rDelta.Y() );
+                pSpVal->maLowerRect.Move( rDelta.X(), rDelta.Y() );
+            }
+            break;
+            case CTRL_TOOLBAR:
+            {
+                ToolbarValue* pTVal = reinterpret_cast<ToolbarValue*>(aValue.getOptionalVal());
+                pTVal->maGripRect.Move( rDelta.X(), rDelta.Y() );
+            }
+            break;
+        }
+    }
+}
+
+BOOL OutputDevice::DrawNativeControl( ControlType nType,
+                            ControlPart nPart,
+                            const Region& rControlRegion,
+                            ControlState nState,
+                            const ImplControlValue& aValue,
+                            ::rtl::OUString aCaption )
+{
+    if( !lcl_enableNativeWidget( *this ) )
+        return FALSE;
+
+    /*
+    if( !IsInPaint() && IsPaintTransparent() )
+    {
+        // only required if called directly (ie, we're not in Paint() ):
+        // force redraw (Paint()) for transparent controls
+        // to trigger a repaint of the background
+        Region aClipRgn( GetClipRegion() );
+        if( !rControlRegion.IsEmpty() )
+            aClipRgn.Intersect( rControlRegion );
+        Invalidate( aClipRgn, INVALIDATE_UPDATE );
+        return TRUE;
+    }
+    */
+
+    // make sure the current clip region is initialized correctly
+    if ( !mpGraphics )
+        if ( !ImplGetGraphics() )
+            return FALSE;
+
+    if ( mbInitClipRegion )
+        ImplInitClipRegion();
+    if ( mbOutputClipped )
+        return TRUE;
+
+    if ( mbInitLineColor )
+        ImplInitLineColor();
+    if ( mbInitFillColor )
+        ImplInitFillColor();
+
+    // Convert the coordinates from relative to Window-absolute, so we draw
+    // in the correct place in platform code
+    Point aWinOffs( mnOutOffX, mnOutOffY );
+    Region screenRegion( rControlRegion );
+    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
+
+    // do so for ImplControlValue members, also
+    lcl_moveControlValue( nType, aValue, aWinOffs );
+
+    Region aTestRegion( GetActiveClipRegion() );
+    aTestRegion.Intersect( rControlRegion );
+    if( aTestRegion == rControlRegion )
+        nState |= CTRL_CACHING_ALLOWED;   // control is not clipped, caching allowed
+
+    BOOL bRet = mpGraphics->DrawNativeControl(nType, nPart, screenRegion, nState, aValue, aCaption, this );
+
+    // transform back ImplControlValue members
+    lcl_moveControlValue( nType, aValue, Point()-aWinOffs );
+
+    return bRet;
+}
+
+
+// -----------------------------------------------------------------------
+
+BOOL OutputDevice::DrawNativeControlText(ControlType nType,
+                            ControlPart nPart,
+                            const Region& rControlRegion,
+                            ControlState nState,
+                            const ImplControlValue& aValue,
+                            ::rtl::OUString aCaption )
+{
+    if( !lcl_enableNativeWidget( *this ) )
+        return FALSE;
+
+    // make sure the current clip region is initialized correctly
+    if ( !mpGraphics )
+        if ( !ImplGetGraphics() )
+            return false;
+
+    if ( mbInitClipRegion )
+        ImplInitClipRegion();
+    if ( mbOutputClipped )
+        return true;
+
+    if ( mbInitLineColor )
+        ImplInitLineColor();
+    if ( mbInitFillColor )
+        ImplInitFillColor();
+
+    // Convert the coordinates from relative to Window-absolute, so we draw
+    // in the correct place in platform code
+    Point aWinOffs( mnOutOffX, mnOutOffY );
+    Region screenRegion( rControlRegion );
+    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
+    lcl_moveControlValue( nType, aValue, aWinOffs );
+
+    BOOL bRet = mpGraphics->DrawNativeControlText(nType, nPart, screenRegion, nState, aValue, aCaption, this );
+
+    // transform back ImplControlValue members
+    lcl_moveControlValue( nType, aValue, Point()-aWinOffs );
+
+    return bRet;
+}
+
+
+// -----------------------------------------------------------------------
+
+BOOL OutputDevice::GetNativeControlRegion(  ControlType nType,
+                                ControlPart nPart,
+                                const Region& rControlRegion,
+                                ControlState nState,
+                                const ImplControlValue& aValue,
+                                ::rtl::OUString aCaption,
+                                Region &rNativeBoundingRegion,
+                                Region &rNativeContentRegion )
+{
+    if( !lcl_enableNativeWidget( *this ) )
+        return FALSE;
+
+    if ( !mpGraphics )
+        if ( !ImplGetGraphics() )
+            return FALSE;
+
+    // Convert the coordinates from relative to Window-absolute, so we draw
+    // in the correct place in platform code
+    Point aWinOffs( mnOutOffX, mnOutOffY );
+    Region screenRegion( rControlRegion );
+    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
+    lcl_moveControlValue( nType, aValue, aWinOffs );
+
+    BOOL bRet = mpGraphics->GetNativeControlRegion(nType, nPart, screenRegion, nState, aValue,
+                                aCaption, rNativeBoundingRegion,
+                                rNativeContentRegion, this );
+    if( bRet )
+    {
+        // transform back native regions
+        rNativeBoundingRegion.Move( -aWinOffs.X(), -aWinOffs.Y() );
+        rNativeContentRegion.Move( -aWinOffs.X(), -aWinOffs.Y() );
+    }
+    // transform back ImplControlValue members
+    lcl_moveControlValue( nType, aValue, Point()-aWinOffs );
+
+    return bRet;
+}
+
+
diff --git a/vcl/source/gdi/pdfwriter_impl.cxx b/vcl/source/gdi/pdfwriter_impl.cxx
index 7ee5889ba532..77f7f74fc10e 100644
--- a/vcl/source/gdi/pdfwriter_impl.cxx
+++ b/vcl/source/gdi/pdfwriter_impl.cxx
@@ -9749,7 +9749,7 @@ bool PDFWriterImpl::writeBitmapObject( BitmapEmit& rObject, bool bMask )
             aLine.append( " ]\n" );
         }
     }
-    else if( m_bIsPDF_A1 )
+    else if( m_bIsPDF_A1 && (bWriteMask || aTransparentColor != Color( COL_TRANSPARENT )) )
         m_aErrors.insert( PDFWriter::Warning_Transparency_Omitted_PDFA );
 
     aLine.append( ">>\n"
diff --git a/vcl/source/gdi/pngread.cxx b/vcl/source/gdi/pngread.cxx
index b7eb8e5f50bf..11971db34378 100644
--- a/vcl/source/gdi/pngread.cxx
+++ b/vcl/source/gdi/pngread.cxx
@@ -703,7 +703,7 @@ void PNGReaderImpl::ImplGetGrayPalette( sal_uInt16 nBitDepth )
         nBitDepth = 8;
 
     sal_uInt16  nPaletteEntryCount = 1 << nBitDepth;
-    sal_uInt32  nAdd = 256 / (nPaletteEntryCount - 1);
+    sal_uInt32  nAdd = nBitDepth ? 256 / (nPaletteEntryCount - 1) : 0;
 
     // no bitdepth==2 available
     // but bitdepth==4 with two unused bits is close enough
diff --git a/vcl/source/gdi/salgdilayout.cxx b/vcl/source/gdi/salgdilayout.cxx
index 55d6f7bdd892..84e45979d679 100644
--- a/vcl/source/gdi/salgdilayout.cxx
+++ b/vcl/source/gdi/salgdilayout.cxx
@@ -669,7 +669,7 @@ BOOL    SalGraphics::DrawEPS( long nX, long nY, long nWidth, long nHeight, void*
 }
 
 BOOL SalGraphics::HitTestNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                                const Point& aPos, SalControlHandle& rControlHandle, BOOL& rIsInside, const OutputDevice *pOutDev )
+                                                const Point& aPos, BOOL& rIsInside, const OutputDevice *pOutDev )
 {
     if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
     {
@@ -677,10 +677,10 @@ BOOL SalGraphics::HitTestNativeControl( ControlType nType, ControlPart nPart, co
         Region rgn( rControlRegion );
         mirror( pt.X(), pOutDev );
         mirror( rgn, pOutDev );
-        return hitTestNativeControl( nType, nPart, rgn, pt, rControlHandle, rIsInside );
+        return hitTestNativeControl( nType, nPart, rgn, pt, rIsInside );
     }
     else
-        return hitTestNativeControl( nType, nPart, rControlRegion, aPos, rControlHandle, rIsInside );
+        return hitTestNativeControl( nType, nPart, rControlRegion, aPos, rIsInside );
 }
 
 void SalGraphics::mirror( ControlType nType, const ImplControlValue& rVal, const OutputDevice* pOutDev, bool bBack ) const
@@ -722,7 +722,7 @@ void SalGraphics::mirror( ControlType nType, const ImplControlValue& rVal, const
 }
 
 BOOL SalGraphics::DrawNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                                ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                                ControlState nState, const ImplControlValue& aValue,
                                                 const OUString& aCaption, const OutputDevice *pOutDev )
 {
     if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
@@ -730,33 +730,33 @@ BOOL SalGraphics::DrawNativeControl( ControlType nType, ControlPart nPart, const
         Region rgn( rControlRegion );
         mirror( rgn, pOutDev );
         mirror( nType, aValue, pOutDev );
-        BOOL bRet = drawNativeControl( nType, nPart, rgn, nState, aValue, rControlHandle, aCaption );
+        BOOL bRet = drawNativeControl( nType, nPart, rgn, nState, aValue, aCaption );
         mirror( nType, aValue, pOutDev, true );
         return bRet;
     }
     else
-        return drawNativeControl( nType, nPart, rControlRegion, nState, aValue, rControlHandle, aCaption );
+        return drawNativeControl( nType, nPart, rControlRegion, nState, aValue, aCaption );
 }
 
 BOOL SalGraphics::DrawNativeControlText( ControlType nType, ControlPart nPart, const Region& rControlRegion,
                                                 ControlState nState, const ImplControlValue& aValue,
-                                                SalControlHandle& rControlHandle, const OUString& aCaption, const OutputDevice *pOutDev )
+                                                const OUString& aCaption, const OutputDevice *pOutDev )
 {
     if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
     {
         Region rgn( rControlRegion );
         mirror( rgn, pOutDev );
         mirror( nType, aValue, pOutDev );
-        BOOL bRet = drawNativeControlText( nType, nPart, rgn, nState, aValue, rControlHandle, aCaption );
+        BOOL bRet = drawNativeControlText( nType, nPart, rgn, nState, aValue, aCaption );
         mirror( nType, aValue, pOutDev, true );
         return bRet;
     }
     else
-        return drawNativeControlText( nType, nPart, rControlRegion, nState, aValue, rControlHandle, aCaption );
+        return drawNativeControlText( nType, nPart, rControlRegion, nState, aValue, aCaption );
 }
 
 BOOL SalGraphics::GetNativeControlRegion( ControlType nType, ControlPart nPart, const Region& rControlRegion, ControlState nState,
-                                                const ImplControlValue& aValue, SalControlHandle& rControlHandle, const OUString& aCaption,
+                                                const ImplControlValue& aValue, const OUString& aCaption,
                                                 Region &rNativeBoundingRegion, Region &rNativeContentRegion, const OutputDevice *pOutDev )
 {
     if( (m_nLayout & SAL_LAYOUT_BIDI_RTL) || (pOutDev && pOutDev->IsRTLEnabled()) )
@@ -764,7 +764,7 @@ BOOL SalGraphics::GetNativeControlRegion( ControlType nType, ControlPart nPart,
         Region rgn( rControlRegion );
         mirror( rgn, pOutDev );
         mirror( nType, aValue, pOutDev );
-        if( getNativeControlRegion( nType, nPart, rgn, nState, aValue, rControlHandle, aCaption,
+        if( getNativeControlRegion( nType, nPart, rgn, nState, aValue, aCaption,
                                                 rNativeBoundingRegion, rNativeContentRegion ) )
         {
             mirror( rNativeBoundingRegion, pOutDev, true );
@@ -779,7 +779,7 @@ BOOL SalGraphics::GetNativeControlRegion( ControlType nType, ControlPart nPart,
         }
     }
     else
-        return getNativeControlRegion( nType, nPart, rControlRegion, nState, aValue, rControlHandle, aCaption,
+        return getNativeControlRegion( nType, nPart, rControlRegion, nState, aValue, aCaption,
                                                 rNativeBoundingRegion, rNativeContentRegion );
 }
 
diff --git a/vcl/source/gdi/sallayout.cxx b/vcl/source/gdi/sallayout.cxx
index 80ae3a3a8c7f..5e187944c706 100755
--- a/vcl/source/gdi/sallayout.cxx
+++ b/vcl/source/gdi/sallayout.cxx
@@ -133,20 +133,21 @@ int GetVerticalFlags( sal_UCS4 nChar )
         /* #i52932# remember:
          nChar == 0x2010 || nChar == 0x2015
          nChar == 0x2016 || nChar == 0x2026
-         are GF_NONE also, but already handled in the first if
+         are GF_NONE also, but already handled in the outer if condition
         */
         if((nChar >= 0x3008 && nChar <= 0x301C && nChar != 0x3012)
         || (nChar == 0xFF3B || nChar == 0xFF3D)
         || (nChar >= 0xFF5B && nChar <= 0xFF9F) // halfwidth forms
-        || (nChar == 0xFFE3)
-        || (nChar >= 0x02F800 && nChar <= 0x02FFFF) )
+        || (nChar == 0xFFE3) )
             return GF_NONE; // not rotated
         else if( nChar == 0x30fc )
             return GF_ROTR; // right
         return GF_ROTL;     // left
     }
+    else if( (nChar >= 0x20000) && (nChar <= 0x3FFFF) ) // all SIP/TIP ideographs
+        return GF_ROTL; // left
 
-    return GF_NONE;
+    return GF_NONE; // not rotated as default
 }
 
 // -----------------------------------------------------------------------
@@ -1800,8 +1801,8 @@ void MultiSalLayout::AdjustLayout( ImplLayoutArgs& rArgs )
     int nRunStart, nRunEnd;
     while (rArgs.GetNextRun(&nRunStart, &nRunEnd, &bRtl))
     {
-        if (bRtl) std::fill(vRtl.begin() + ( nRunStart - rArgs.mnMinCharPos ),
-                            vRtl.begin() + ( nRunEnd - rArgs.mnMinCharPos ), true);
+        if (bRtl) std::fill(vRtl.begin() + (nRunStart - rArgs.mnMinCharPos),
+                            vRtl.begin() + (nRunEnd - rArgs.mnMinCharPos), true);
     }
     rArgs.ResetPos();
 
diff --git a/vcl/source/gdi/salnativewidgets-none.cxx b/vcl/source/gdi/salnativewidgets-none.cxx
index 8b87f142ba25..7faf12d062fe 100644
--- a/vcl/source/gdi/salnativewidgets-none.cxx
+++ b/vcl/source/gdi/salnativewidgets-none.cxx
@@ -60,7 +60,6 @@ BOOL SalGraphics::hitTestNativeControl( ControlType,
                               ControlPart,
                               const Region&,
                               const Point&,
-                              SalControlHandle&,
                               BOOL& )
 {
     return( FALSE );
@@ -74,7 +73,6 @@ BOOL SalGraphics::hitTestNativeControl( ControlType,
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:         An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the SalFrame implementation.
  *  aCaption:   A caption or title string (like button text etc)
  */
 BOOL SalGraphics::drawNativeControl(    ControlType,
@@ -82,7 +80,6 @@ BOOL SalGraphics::drawNativeControl(    ControlType,
                             const Region&,
                             ControlState,
                             const ImplControlValue&,
-                            SalControlHandle&,
                             const OUString& )
 {
     return( FALSE );
@@ -97,7 +94,6 @@ BOOL SalGraphics::drawNativeControl(    ControlType,
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:         An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the SalFrame implementation.
  *  aCaption:   A caption or title string (like button text etc)
  */
 BOOL SalGraphics::drawNativeControlText(    ControlType,
@@ -105,7 +101,6 @@ BOOL SalGraphics::drawNativeControlText(    ControlType,
                                 const Region&,
                                 ControlState,
                                 const ImplControlValue&,
-                                SalControlHandle&,
                                 const OUString& )
 {
     return( FALSE );
@@ -123,7 +118,6 @@ BOOL SalGraphics::drawNativeControlText(    ControlType,
  *
  *  rControlRegion: The bounding region of the control in VCL frame coordinates.
  *  aValue:     An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the SalFrame implementation.
  *  aCaption:       A caption or title string (like button text etc)
  */
 BOOL SalGraphics::getNativeControlRegion(  ControlType,
@@ -131,7 +125,6 @@ BOOL SalGraphics::getNativeControlRegion(  ControlType,
                                 const Region&,
                                 ControlState,
                                 const ImplControlValue&,
-                                SalControlHandle&,
                                 const OUString&,
                                 Region &,
                                 Region & )
diff --git a/vcl/source/glyphs/graphite_layout.cxx b/vcl/source/glyphs/graphite_layout.cxx
index 6e75d1fde868..ff2fd8f306b1 100644
--- a/vcl/source/glyphs/graphite_layout.cxx
+++ b/vcl/source/glyphs/graphite_layout.cxx
@@ -353,6 +353,46 @@ std::pair<float,float> GraphiteLayout::Glyphs::appendCluster(gr::Segment & rSeg,
     assert(size() < rGlyph2Char.size());
     rChar2Base[nFirstCharInCluster-rArgs.mnMinCharPos] = size();
     rGlyph2Char[size()] = nFirstCharInCluster;
+
+    // can we break before this cluster?
+    // Glyphs may have either a positive or negative breakWeight refering to
+    // the position after or before the glyph respectively
+    int nPrevBreakWeight = 0;
+    if (nFirstGlyphInCluster > 0)
+    {
+        nPrevBreakWeight = (iGlyphs.first + (nFirstGlyphInCluster - 1))->breakweight();
+    }
+    int nBreakWeight = aFirstGlyph.breakweight();
+    if (nBreakWeight < 0)
+    {
+        // negative means it applies to the position before the glyph's character
+        nBreakWeight *= -1;
+        if (nPrevBreakWeight > 0 && nPrevBreakWeight < nBreakWeight)
+        {
+            // prevBreakWeight wins
+            nBreakWeight = nPrevBreakWeight;
+        }
+    }
+    else
+    {
+        nBreakWeight = 0;
+        // positive means break after
+        if (nPrevBreakWeight > 0)
+            nBreakWeight = nPrevBreakWeight;
+    }
+    if (nBreakWeight > gr::klbNoBreak/*0*/ &&
+        // nBreakWeight <= gr::klbHyphenBreak) // uses Graphite hyphenation
+        nBreakWeight <= gr::klbLetterBreak) // Needed for issue 111272
+    {
+        if (nBreakWeight < gr::klbHyphenBreak)
+            rChar2Base[nFirstCharInCluster-rArgs.mnMinCharPos] |= WORD_BREAK_BEFORE;
+        else
+            rChar2Base[nFirstCharInCluster-rArgs.mnMinCharPos] |= HYPHEN_BREAK_BEFORE;
+    }
+    // always allow a break before a space even if graphite doesn't
+    if (rArgs.mpStr[nFirstCharInCluster] == 0x20)
+        rChar2Base[nFirstCharInCluster-rArgs.mnMinCharPos] |= WORD_BREAK_BEFORE;
+
     bool bBaseGlyph = true;
     for (int j = nFirstGlyphInCluster;
         j != nNextGlyph; j += nDelta)
@@ -409,7 +449,7 @@ std::pair<float,float> GraphiteLayout::Glyphs::appendCluster(gr::Segment & rSeg,
         }
     }
 #ifdef GRLAYOUT_DEBUG
-    fprintf(grLog(),"Cluster g[%d-%d) c[%d-%d)%x x%ld y%f\n", nFirstGlyphInCluster, nNextGlyph, nFirstCharInCluster, nNextChar, rArgs.mpStr[nFirstCharInCluster], nXPos, aFirstGlyph.yOffset());
+    fprintf(grLog(),"Cluster g[%d-%d) c[%d-%d)%x x%ld y%f bw%d\n", nFirstGlyphInCluster, nNextGlyph, nFirstCharInCluster, nNextChar, rArgs.mpStr[nFirstCharInCluster], nXPos, aFirstGlyph.yOffset(), nBreakWeight);
 #endif
     return aBounds;
 }
@@ -641,6 +681,19 @@ gr::Segment * GraphiteLayout::CreateSegment(ImplLayoutArgs& rArgs)
         if (bRtl && (mrFont.getSupportedScriptDirections() & gr::kfsdcHorizRtl))
             maLayout.setRightToLeft(bRtl);
 
+        // Context is often needed beyond the specified end, however, we don't
+        // want it if there has been a direction change, since it is hard
+        // to tell between reordering within one direction and multi-directional
+        // text. Extra context, can also cause problems with ligatures stradling
+        // a hyphenation point, so disable if CTL is disabled.
+        const int  nSegCharLimit = min(rArgs.mnLength, mnEndCharPos + EXTRA_CONTEXT_LENGTH);
+        int limit = rArgs.mnEndCharPos;
+        if ((nSegCharLimit > limit) && !(SAL_LAYOUT_COMPLEX_DISABLED & rArgs.mnFlags))
+        {
+            limit += findSameDirLimit(rArgs.mpStr + rArgs.mnEndCharPos,
+                nSegCharLimit - rArgs.mnEndCharPos, bRtl);
+        }
+
 #ifdef GRCACHE
         GrFontHasher hasher(mrFont);
         sal_Int32 aFontHash = hasher.hashCode(mpFeatures);
@@ -648,7 +701,7 @@ gr::Segment * GraphiteLayout::CreateSegment(ImplLayoutArgs& rArgs)
             (GraphiteCacheHandler::instance).getCache(aFontHash);
         if (pCache)
         {
-            *pSegRecord = pCache->getSegment(rArgs, bRtl);
+            *pSegRecord = pCache->getSegment(rArgs, bRtl, nSegCharLimit);
             if (*pSegRecord)
             {
                 pSegment = (*pSegRecord)->getSegment();
@@ -667,18 +720,6 @@ gr::Segment * GraphiteLayout::CreateSegment(ImplLayoutArgs& rArgs)
         }
 #endif
 
-        // Context is often needed beyond the specified end, however, we don't
-        // want it if there has been a direction change, since it is hard
-        // to tell between reordering within one direction and multi-directional
-        // text.
-        const int  segCharLimit = min(rArgs.mnLength, mnEndCharPos + EXTRA_CONTEXT_LENGTH);
-        int limit = rArgs.mnEndCharPos;
-        if (segCharLimit > limit)
-        {
-            limit += findSameDirLimit(rArgs.mpStr + rArgs.mnEndCharPos,
-                segCharLimit - rArgs.mnEndCharPos, bRtl);
-        }
-
         // Create a new TextSource object for the engine.
         mpTextSrc = new TextSourceAdaptor(rArgs, limit);
         if (mpFeatures) mpTextSrc->setFeatures(mpFeatures);
@@ -795,27 +836,35 @@ bool GraphiteLayout::LayoutGlyphs(ImplLayoutArgs& rArgs, gr::Segment * pSegment)
 
 int GraphiteLayout::GetTextBreak(long maxmnWidth, long char_extra, int factor) const
 {
-    // Adjust maxmnWidth so FindNextBreakPoint returns a sensible answer.
-    maxmnWidth -= (mnEndCharPos-mnMinCharPos-1)*char_extra;  // extra character spacing.
-    maxmnWidth /= factor;                                    // scaling factor.
+#ifdef GRLAYOUT_DEBUG
+    fprintf(grLog(),"Gr::GetTextBreak c[%d-%d) maxWidth %ld char extra %ld factor %d\n",
+        mnMinCharPos, mnEndCharPos, maxmnWidth, char_extra, factor);
+#endif
 
-    // Ask the segment for the nearest whole letter break for the width.
-    //float width;
-    float targetWidth = maxmnWidth/mfScaling;
     // return quickly if this segment is narrower than the target width
-    // (sometimes graphite doesn't seem to realise this!)
-    if (targetWidth > mnWidth)
+    if (maxmnWidth > mnWidth * factor + char_extra * (mnEndCharPos - mnMinCharPos - 1))
         return STRING_LEN;
-    //int    nBreak = mpSegment->findNextBreakPoint(mnMinCharPos,
-    //        gr::klbWordBreak, gr::klbLetterBreak, targetWidth, &width);
 
-    // LineFillSegment seems to give better results that findNextBreakPoint
-    // though it may be slower
-    gr::LayoutEnvironment aLE;
-    gr::LineFillSegment lineSeg(const_cast<gr::Font *>(&mrFont), mpTextSrc, &aLE,
-                                mnMinCharPos, mpTextSrc->getContextLength(),
-                                targetWidth);
-    int nBreak = lineSeg.stopCharacter();
+    long nWidth = mvCharDxs[0] * factor;
+    int nLastBreak = -1;
+    for (size_t i = 1; i < mvCharDxs.size(); i++)
+    {
+        nWidth += char_extra;
+        if (nWidth > maxmnWidth) break;
+        if (mvChar2BaseGlyph[i] != -1)
+        {
+            if (mvChar2BaseGlyph[i] & (WORD_BREAK_BEFORE | HYPHEN_BREAK_BEFORE))
+                nLastBreak = static_cast<int>(i);
+        }
+        nWidth += (mvCharDxs[i] - mvCharDxs[i-1]) * factor;
+    }
+    int nBreak = mnMinCharPos;
+    if (nLastBreak > -1)
+        nBreak += nLastBreak;
+
+#ifdef GRLAYOUT_DEBUG
+    fprintf(grLog(), "Gr::GetTextBreak break after %d\n", nBreak - mnMinCharPos);
+#endif
 
     if (nBreak > mnEndCharPos) nBreak = STRING_LEN;
     else if (nBreak < mnMinCharPos) nBreak = mnMinCharPos;
@@ -833,9 +882,10 @@ long GraphiteLayout::FillDXArray( sal_Int32* pDXArray ) const
     {
         for (size_t i = 0; i < mvCharDxs.size(); i++)
         {
-            assert((mvChar2BaseGlyph[i] >= -1) && (mvChar2BaseGlyph[i] < (signed)mvGlyphs.size()));
+            assert( (mvChar2BaseGlyph[i] == -1) ||
+                ((signed)(mvChar2BaseGlyph[i] & GLYPH_INDEX_MASK) < (signed)mvGlyphs.size()));
             if (mvChar2BaseGlyph[i] != -1 &&
-                mvGlyphs[mvChar2BaseGlyph[i]].mnGlyphIndex == GF_DROPPED)
+                mvGlyphs[mvChar2BaseGlyph[i] & GLYPH_INDEX_MASK].mnGlyphIndex == GF_DROPPED)
             {
                 // when used in MultiSalLayout::GetTextBreak dropped glyphs
                 // must have zero width
@@ -865,7 +915,6 @@ long GraphiteLayout::FillDXArray( sal_Int32* pDXArray ) const
 void  GraphiteLayout::AdjustLayout(ImplLayoutArgs& rArgs)
 {
     SalLayout::AdjustLayout(rArgs);
-
     if(rArgs.mpDXArray)
     {
         std::vector<int> vDeltaWidths(mvGlyphs.size(), 0);
@@ -894,8 +943,75 @@ void  GraphiteLayout::AdjustLayout(ImplLayoutArgs& rArgs)
             }
         }
     }
+    else if (rArgs.mnLayoutWidth > 0)
+    {
+#ifdef GRLAYOUT_DEBUG
+        fprintf(grLog(), "AdjustLayout width %ld=>%ld\n", mnWidth, rArgs.mnLayoutWidth);
+#endif
+        expandOrCondense(rArgs);
+    }
 }
 
+void GraphiteLayout::expandOrCondense(ImplLayoutArgs &rArgs)
+{
+    int nDeltaWidth = rArgs.mnLayoutWidth - mnWidth;
+    if (nDeltaWidth > 0) // expand, just expand between clusters
+    {
+        int nClusterCount = 0;
+        for (size_t j = 0; j < mvGlyphs.size(); j++)
+        {
+            if (mvGlyphs[j].IsClusterStart())
+            {
+                ++nClusterCount;
+            }
+        }
+        if (nClusterCount > 1)
+        {
+            float fExtraPerCluster = static_cast<float>(nDeltaWidth) / static_cast<float>(nClusterCount - 1);
+            int nCluster = 0;
+            int nOffset = 0;
+            for (size_t i = 0; i < mvGlyphs.size(); i++)
+            {
+                if (mvGlyphs[i].IsClusterStart())
+                {
+                    nOffset = fExtraPerCluster * nCluster;
+                    size_t nCharIndex = mvGlyph2Char[i];
+                    mvCharDxs[nCharIndex] += nOffset;
+                    // adjust char dxs for rest of characters in cluster
+                    while (++nCharIndex < mvGlyph2Char.size())
+                    {
+                        int nChar2Base = (mvChar2BaseGlyph[nCharIndex] == -1)? -1 : mvChar2BaseGlyph[nCharIndex] & GLYPH_INDEX_MASK;
+                        if (nChar2Base == -1 || nChar2Base == static_cast<int>(i))
+                            mvCharDxs[nCharIndex] += nOffset;
+                    }
+                    ++nCluster;
+                }
+                mvGlyphs[i].maLinearPos.X() += nOffset;
+            }
+        }
+    }
+    else // condense - apply a factor to all glyph positions
+    {
+        if (mvGlyphs.size() == 0) return;
+        Glyphs::iterator iLastGlyph = mvGlyphs.begin() + (mvGlyphs.size() - 1);
+        // position last glyph using original width
+        float fXFactor = static_cast<float>(rArgs.mnLayoutWidth - iLastGlyph->mnOrigWidth) / static_cast<float>(iLastGlyph->maLinearPos.X());
+#ifdef GRLAYOUT_DEBUG
+        fprintf(grLog(), "Condense by factor %f\n", fXFactor);
+#endif
+        iLastGlyph->maLinearPos.X() = rArgs.mnLayoutWidth - iLastGlyph->mnOrigWidth;
+        Glyphs::iterator iGlyph = mvGlyphs.begin();
+        while (iGlyph != iLastGlyph)
+        {
+            iGlyph->maLinearPos.X() = static_cast<float>(iGlyph->maLinearPos.X()) * fXFactor;
+            ++iGlyph;
+        }
+        for (size_t i = 0; i < mvCharDxs.size(); i++)
+        {
+            mvCharDxs[i] = fXFactor * static_cast<float>(mvCharDxs[i]);
+        }
+    }
+}
 
 void GraphiteLayout::ApplyDXArray(ImplLayoutArgs &args, std::vector<int> & rDeltaWidth)
 {
@@ -917,37 +1033,39 @@ void GraphiteLayout::ApplyDXArray(ImplLayoutArgs &args, std::vector<int> & rDelt
     int nPrevClusterLastChar = -1;
     for (size_t i = 0; i < nChars; i++)
     {
-        if (mvChar2BaseGlyph[i] > -1 && mvChar2BaseGlyph[i] != nPrevClusterGlyph)
+        int nChar2Base = (mvChar2BaseGlyph[i] == -1)? -1 : mvChar2BaseGlyph[i] & GLYPH_INDEX_MASK;
+        if ((nChar2Base > -1) && (nChar2Base != nPrevClusterGlyph))
         {
-            assert((mvChar2BaseGlyph[i] > -1) && (mvChar2BaseGlyph[i] < (signed)mvGlyphs.size()));
-            GlyphItem & gi = mvGlyphs[mvChar2BaseGlyph[i]];
+            assert((nChar2Base > -1) && (nChar2Base < (signed)mvGlyphs.size()));
+            GlyphItem & gi = mvGlyphs[nChar2Base];
             if (!gi.IsClusterStart())
                 continue;
 
             // find last glyph of this cluster
             size_t j = i + 1;
             int nLastChar = i;
-            int nLastGlyph = mvChar2BaseGlyph[i];
+            int nLastGlyph = nChar2Base;
             for (; j < nChars; j++)
             {
-                assert((mvChar2BaseGlyph[j] >= -1) && (mvChar2BaseGlyph[j] < (signed)mvGlyphs.size()));
-                if (mvChar2BaseGlyph[j] != -1 && mvGlyphs[mvChar2BaseGlyph[j]].IsClusterStart())
+                int nChar2BaseJ = (mvChar2BaseGlyph[j] == -1)? -1 : mvChar2BaseGlyph[j] & GLYPH_INDEX_MASK;
+                assert((nChar2BaseJ >= -1) && (nChar2BaseJ < (signed)mvGlyphs.size()));
+                if (nChar2BaseJ != -1 && mvGlyphs[nChar2BaseJ].IsClusterStart())
                 {
-                    nLastGlyph = mvChar2BaseGlyph[j] + ((bRtl)? 1 : -1);
+                    nLastGlyph = nChar2BaseJ + ((bRtl)? 1 : -1);
                     nLastChar = j - 1;
                     break;
                 }
             }
             if (nLastGlyph < 0)
             {
-                nLastGlyph = mvChar2BaseGlyph[i];
+                nLastGlyph = nChar2Base;
             }
             // Its harder to find the last glyph rtl, since the first of
             // cluster is still on the left so we need to search towards
             // the previous cluster to the right
             if (bRtl)
             {
-                nLastGlyph = mvChar2BaseGlyph[i];
+                nLastGlyph = nChar2Base;
                 while (nLastGlyph + 1 < (signed)mvGlyphs.size() &&
                        !mvGlyphs[nLastGlyph+1].IsClusterStart())
                 {
@@ -983,7 +1101,7 @@ void GraphiteLayout::ApplyDXArray(ImplLayoutArgs &args, std::vector<int> & rDelt
             // update glyph positions
             if (bRtl)
             {
-                for (int n = mvChar2BaseGlyph[i]; n <= nLastGlyph; n++)
+                for (int n = nChar2Base; n <= nLastGlyph; n++)
                 {
                     assert((n > - 1) && (n < (signed)mvGlyphs.size()));
                     mvGlyphs[n].maLinearPos.X() += -nDGlyphOrigin + nXOffset;
@@ -991,17 +1109,17 @@ void GraphiteLayout::ApplyDXArray(ImplLayoutArgs &args, std::vector<int> & rDelt
             }
             else
             {
-                for (int n = mvChar2BaseGlyph[i]; n <= nLastGlyph; n++)
+                for (int n = nChar2Base; n <= nLastGlyph; n++)
                 {
                     assert((n > - 1) && (n < (signed)mvGlyphs.size()));
                     mvGlyphs[n].maLinearPos.X() += nDGlyphOrigin + nXOffset;
                 }
             }
-            rDeltaWidth[mvChar2BaseGlyph[i]] = nDWidth;
+            rDeltaWidth[nChar2Base] = nDWidth;
 #ifdef GRLAYOUT_DEBUG
-            fprintf(grLog(),"c%d g%d-%d dW%ld-%ld=%ld dX%ld x%ld\t", (int)i, mvChar2BaseGlyph[i], nLastGlyph, nNewClusterWidth, nOrigClusterWidth, nDWidth, nDGlyphOrigin, mvGlyphs[mvChar2BaseGlyph[i]].maLinearPos.X());
+            fprintf(grLog(),"c%d g%d-%d dW%ld-%ld=%ld dX%ld x%ld\t", (int)i, nChar2Base, nLastGlyph, nNewClusterWidth, nOrigClusterWidth, nDWidth, nDGlyphOrigin, mvGlyphs[nChar2Base].maLinearPos.X());
 #endif
-            nPrevClusterGlyph = mvChar2BaseGlyph[i];
+            nPrevClusterGlyph = nChar2Base;
             nPrevClusterLastChar = nLastChar;
             i = nLastChar;
         }
@@ -1043,7 +1161,7 @@ void GraphiteLayout::kashidaJustify(std::vector<int>& rDeltaWidths, sal_GlyphId
             continue;
         }
         // calculate gap, ignore if too small
-        int nGapWidth = rDeltaWidths[nOrigGlyphIndex];;
+        int nGapWidth = rDeltaWidths[nOrigGlyphIndex];
         // worst case is one kashida even for mini-gaps
         if( 3 * nGapWidth < nKashidaWidth )
         {
@@ -1104,13 +1222,14 @@ void GraphiteLayout::GetCaretPositions( int nArraySize, sal_Int32* pCaretXArray
     {
         if (mvChar2BaseGlyph[nCharSlot] != -1)
         {
-            assert((mvChar2BaseGlyph[nCharSlot] > -1) && (mvChar2BaseGlyph[nCharSlot] < (signed)mvGlyphs.size()));
-            GlyphItem gi = mvGlyphs[mvChar2BaseGlyph[nCharSlot]];
+            int nChar2Base = mvChar2BaseGlyph[nCharSlot] & GLYPH_INDEX_MASK;
+            assert((mvChar2BaseGlyph[nCharSlot] > -1) && (nChar2Base < (signed)mvGlyphs.size()));
+            GlyphItem gi = mvGlyphs[nChar2Base];
             if (gi.mnGlyphIndex == GF_DROPPED)
             {
                 continue;
             }
-            int nCluster = mvChar2BaseGlyph[nCharSlot];
+            int nCluster = nChar2Base;
             long origClusterWidth = gi.mnNewWidth;
             long nMin = gi.maLinearPos.X();
             long nMax = gi.maLinearPos.X() + gi.mnNewWidth;
@@ -1135,7 +1254,7 @@ void GraphiteLayout::GetCaretPositions( int nArraySize, sal_Int32* pCaretXArray
                 pCaretXArray[i] = nMin;
                 pCaretXArray[i+1] = nMax;
             }
-            prevBase = mvChar2BaseGlyph[nCharSlot];
+            prevBase = nChar2Base;
             prevClusterWidth = origClusterWidth;
         }
         else if (prevBase > -1)
@@ -1268,7 +1387,7 @@ int GraphiteLayout::GetNextGlyphs( int length, sal_GlyphId * glyph_out,
 
 #ifdef GRLAYOUT_DEBUG
     fprintf(grLog(),"GetNextGlyphs g%d c%d x%ld,%ld adv%ld, pos %ld,%ld\n", glyph_slot - 1,
-            mvGlyph2Char[glyph_slot-1], glyph_itr->maLinearPos.X(), glyph_itr->maLinearPos.Y(), nGlyphAdvance,
+            GLYPH_INDEX_MASK&mvGlyph2Char[glyph_slot-1], glyph_itr->maLinearPos.X(), glyph_itr->maLinearPos.Y(), nGlyphAdvance,
             aPosOut.X(), aPosOut.Y());
 #endif
 
diff --git a/vcl/source/window/dockmgr.cxx b/vcl/source/window/dockmgr.cxx
index e3a8d2ce35de..e67c2d9ecfd5 100644
--- a/vcl/source/window/dockmgr.cxx
+++ b/vcl/source/window/dockmgr.cxx
@@ -426,11 +426,19 @@ void DockingManager::SetFloatingMode( const Window *pWindow, BOOL bFloating )
         pWrapper->SetFloatingMode( bFloating );
 }
 
-void DockingManager::StartPopupMode( ToolBox *pParentToolBox, const Window *pWindow )
+void DockingManager::StartPopupMode( ToolBox *pParentToolBox, const Window *pWindow, ULONG nFlags )
 {
     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
     if( pWrapper )
-        pWrapper->StartPopupMode( pParentToolBox );
+        pWrapper->StartPopupMode( pParentToolBox, nFlags );
+}
+
+void DockingManager::StartPopupMode( ToolBox *pParentToolBox, const Window *pWindow )
+{
+    StartPopupMode( pParentToolBox, pWindow, FLOATWIN_POPUPMODE_ALLOWTEAROFF         |
+                    FLOATWIN_POPUPMODE_NOFOCUSCLOSE         |
+                    FLOATWIN_POPUPMODE_ALLMOUSEBUTTONCLOSE  |
+                    FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE );
 }
 
 BOOL DockingManager::IsInPopupMode( const Window *pWindow )
@@ -442,6 +450,17 @@ BOOL DockingManager::IsInPopupMode( const Window *pWindow )
         return FALSE;
 }
 
+// -----------------------------------------------------------------------
+
+void DockingManager::EndPopupMode( const Window *pWin )
+{
+    ImplDockingWindowWrapper *pWrapper = GetDockingWindowWrapper( pWin );
+    if( pWrapper && pWrapper->GetFloatingWindow() && pWrapper->GetFloatingWindow()->IsInPopupMode() )
+        pWrapper->GetFloatingWindow()->EndPopupMode();
+}
+
+// -----------------------------------------------------------------------
+
 void DockingManager::AddWindow( const Window *pWindow )
 {
     ImplDockingWindowWrapper* pWrapper = GetDockingWindowWrapper( pWindow );
@@ -515,12 +534,15 @@ private:
     ImplDockingWindowWrapper*   mpDockingWin;
     BOOL                        mbHighlight;
     BOOL                        mbMoving;
+    bool                        mbTrackingEnabled;
     Point                       maDelta;
     Point                       maTearOffPosition;
+    bool                        mbGripAtBottom;
+    bool                        mbHasGrip;
     void                        ImplSetBorder();
 
 public:
-    ImplPopupFloatWin( Window* pParent, ImplDockingWindowWrapper* pDockingWin );
+    ImplPopupFloatWin( Window* pParent, ImplDockingWindowWrapper* pDockingWin, bool bHasGrip );
     ~ImplPopupFloatWin();
 
     virtual ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > CreateAccessible();
@@ -537,9 +559,11 @@ public:
     Point               GetTearOffPosition() const;
     void                DrawGrip();
     void                DrawBorder();
+
+    bool                hasGrip() const { return mbHasGrip; }
 };
 
-ImplPopupFloatWin::ImplPopupFloatWin( Window* pParent, ImplDockingWindowWrapper* pDockingWin ) :
+ImplPopupFloatWin::ImplPopupFloatWin( Window* pParent, ImplDockingWindowWrapper* pDockingWin, bool bHasGrip ) :
     FloatingWindow( pParent, WB_NOBORDER | WB_SYSTEMWINDOW | WB_NOSHADOW)
 {
     mpWindowImpl->mbToolbarFloatingWindow = TRUE;   // indicate window type, required for accessibility
@@ -547,6 +571,9 @@ ImplPopupFloatWin::ImplPopupFloatWin( Window* pParent, ImplDockingWindowWrapper*
     mpDockingWin = pDockingWin;
     mbHighlight = FALSE;
     mbMoving = FALSE;
+    mbTrackingEnabled = FALSE;
+    mbGripAtBottom = TRUE;
+    mbHasGrip = bHasGrip;
 
     ImplSetBorder();
 }
@@ -582,7 +609,9 @@ void ImplPopupFloatWin::ImplSetBorder()
     //  we're using a special border for the grip
     // by setting those members the method SetOutputSizePixel() can
     //  be used to set the proper window size
-    mpWindowImpl->mnTopBorder     = 1 + POPUP_DRAGHEIGHT+2;
+    mpWindowImpl->mnTopBorder     = 1;
+    if( hasGrip() )
+        mpWindowImpl->mnTopBorder += POPUP_DRAGHEIGHT+2;
     mpWindowImpl->mnBottomBorder  = 1;
     mpWindowImpl->mnLeftBorder    = 1;
     mpWindowImpl->mnRightBorder   = 1;
@@ -596,13 +625,25 @@ void ImplPopupFloatWin::Resize()
 
 Rectangle ImplPopupFloatWin::GetDragRect() const
 {
-    return Rectangle( 1, 1, GetOutputSizePixel().Width()-1, 2+POPUP_DRAGHEIGHT );
+    Rectangle aRect;
+    if( hasGrip() )
+    {
+        aRect = Rectangle( 1,1, GetOutputSizePixel().Width()-1, 2+POPUP_DRAGHEIGHT );
+        if( mbGripAtBottom )
+        {
+            int height = GetOutputSizePixel().Height();
+            aRect.Top() = height - 3 - POPUP_DRAGHEIGHT;
+            aRect.Bottom() = aRect.Top() + 1 + POPUP_DRAGHEIGHT;
+        }
+    }
+    return aRect;
 }
 
 Point ImplPopupFloatWin::GetToolboxPosition() const
 {
     // return inner position where a toolbox could be placed
-    Point aPt( 1, 1+GetDragRect().getHeight() );    // grip + border
+    Point aPt( 1, 1 + ((mbGripAtBottom || !hasGrip()) ? 0 : GetDragRect().getHeight()) );    // grip + border
+
     return aPt;
 }
 
@@ -616,7 +657,6 @@ Point ImplPopupFloatWin::GetTearOffPosition() const
 void ImplPopupFloatWin::DrawBorder()
 {
     SetFillColor();
-    SetLineColor( GetSettings().GetStyleSettings().GetShadowColor() );
     Point aPt;
     Rectangle aRect( aPt, GetOutputSizePixel() );
 
@@ -626,9 +666,16 @@ void ImplPopupFloatWin::DrawBorder()
     if( !aItemClipRect.IsEmpty() )
     {
         aItemClipRect.SetPos( AbsoluteScreenToOutputPixel( aItemClipRect.TopLeft() ) );
+
+        // draw the excluded border part with the background color of a toolbox
+        SetClipRegion( Region( aItemClipRect ) );
+        SetLineColor( GetSettings().GetStyleSettings().GetFaceColor() );
+        DrawRect( aRect );
+
         aClipRgn.Exclude( aItemClipRect );
         SetClipRegion( aClipRgn );
     }
+    SetLineColor( GetSettings().GetStyleSettings().GetShadowColor() );
     DrawRect( aRect );
     SetClipRegion( oldClipRgn );
 }
@@ -724,7 +771,8 @@ void ImplPopupFloatWin::Paint( const Rectangle& )
     Rectangle aRect( aPt, GetOutputSizePixel() );
     DrawWallpaper( aRect, Wallpaper( GetSettings().GetStyleSettings().GetFaceGradientColor() ) );
     DrawBorder();
-    DrawGrip();
+    if( hasGrip() )
+        DrawGrip();
 }
 
 void ImplPopupFloatWin::MouseMove( const MouseEvent& rMEvt )
@@ -733,7 +781,7 @@ void ImplPopupFloatWin::MouseMove( const MouseEvent& rMEvt )
 
     if( !ToolBox::AlwaysLocked() )  // no tear off if locking is enabled
     {
-        if( rMEvt.IsLeft() && GetDragRect().IsInside( aMousePos ) )
+        if( mbTrackingEnabled && rMEvt.IsLeft() && GetDragRect().IsInside( aMousePos ) )
         {
             // start window move
             mbMoving = TRUE;
@@ -755,6 +803,7 @@ void ImplPopupFloatWin::MouseMove( const MouseEvent& rMEvt )
 
 void ImplPopupFloatWin::MouseButtonUp( const MouseEvent& rMEvt )
 {
+    mbTrackingEnabled = false;
     FloatingWindow::MouseButtonUp( rMEvt );
 }
 
@@ -769,6 +818,11 @@ void ImplPopupFloatWin::MouseButtonDown( const MouseEvent& rMEvt )
             ImplMirrorFramePos(aState.maPos);
         maTearOffPosition = GetWindow( WINDOW_BORDER )->GetPosPixel();
         maDelta = aState.maPos - maTearOffPosition;
+        mbTrackingEnabled = true;
+    }
+    else
+    {
+        mbTrackingEnabled = false;
     }
 }
 
@@ -1187,7 +1241,7 @@ BOOL ImplDockingWindowWrapper::IsTitleButtonVisible( USHORT nButton ) const
 
 // -----------------------------------------------------------------------
 
-void ImplDockingWindowWrapper::StartPopupMode( ToolBox *pParentToolBox )
+void ImplDockingWindowWrapper::StartPopupMode( ToolBox *pParentToolBox, ULONG nFlags )
 {
     // do nothing if window is floating
     if( IsFloatingMode() )
@@ -1202,7 +1256,7 @@ void ImplDockingWindowWrapper::StartPopupMode( ToolBox *pParentToolBox )
         mpOldBorderWin = NULL;  // no border window found
 
     // the new parent for popup mode
-    ImplPopupFloatWin* pWin = new ImplPopupFloatWin( mpParent, this );
+    ImplPopupFloatWin* pWin = new ImplPopupFloatWin( mpParent, this, (nFlags & FLOATWIN_POPUPMODE_ALLOWTEAROFF) != 0 );
 
     pWin->SetPopupModeEndHdl( LINK( this, ImplDockingWindowWrapper, PopupModeEnd ) );
     pWin->SetText( GetWindow()->GetText() );
@@ -1232,12 +1286,6 @@ void ImplDockingWindowWrapper::StartPopupMode( ToolBox *pParentToolBox )
     // (SetPosPixel etc. check for valid mpFloatWin pointer)
     mpFloatWin = pWin;
 
-    ULONG nFlags =  FLOATWIN_POPUPMODE_ALLOWTEAROFF         |
-                    FLOATWIN_POPUPMODE_NOFOCUSCLOSE         |
-                    FLOATWIN_POPUPMODE_ALLMOUSEBUTTONCLOSE  |
-                    FLOATWIN_POPUPMODE_NOMOUSEUPCLOSE;
-//                    |FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE;
-
     // if the subtoolbar was opened via keyboard make sure that key events
     // will go into subtoolbar
     if( pParentToolBox->IsKeyEvent() )
@@ -1339,7 +1387,7 @@ void ImplDockingWindowWrapper::SetFloatingMode( BOOL bFloatMode )
                 aSettings.SetStyleSettings( aStyleSettings );
                 pWin->SetSettings( aSettings );*/
 
-                mpFloatWin      = pWin;
+//                mpFloatWin      = pWin;
 
 
                 GetWindow()->mpWindowImpl->mpBorderWindow  = NULL;
@@ -1374,6 +1422,8 @@ void ImplDockingWindowWrapper::SetFloatingMode( BOOL bFloatMode )
                 pWin->SetMinOutputSizePixel( maMinOutSize );
                 pWin->SetMaxOutputSizePixel( maMaxOutSize );
 
+                mpFloatWin      = pWin;
+
                 if ( bVisible )
                     GetWindow()->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE );
 
diff --git a/vcl/source/window/menu.cxx b/vcl/source/window/menu.cxx
index ddfb1125d0d7..cebe1d1f596c 100644
--- a/vcl/source/window/menu.cxx
+++ b/vcl/source/window/menu.cxx
@@ -32,6 +32,7 @@
 #include "vcl/salinst.hxx"
 #include "tools/list.hxx"
 #include "tools/debug.hxx"
+#include "tools/diagnose_ex.h"
 #include "vcl/svdata.hxx"
 #include "vcl/svapp.hxx"
 #include "vcl/mnemonic.hxx"
@@ -3464,6 +3465,9 @@ USHORT PopupMenu::Execute( Window* pExecWindow, const Point& rPopupPos )
 
 USHORT PopupMenu::Execute( Window* pExecWindow, const Rectangle& rRect, USHORT nFlags )
 {
+    ENSURE_OR_RETURN( pExecWindow, "PopupMenu::Execute: need a non-NULL window!", 0 );
+
+
     ULONG nPopupModeFlags = 0;
     if ( nFlags & POPUPMENU_EXECUTE_DOWN )
         nPopupModeFlags = FLOATWIN_POPUPMODE_DOWN;
diff --git a/vcl/source/window/seleng.cxx b/vcl/source/window/seleng.cxx
index b4f4d0f2b6df..d4ee01c26d61 100644
--- a/vcl/source/window/seleng.cxx
+++ b/vcl/source/window/seleng.cxx
@@ -200,7 +200,11 @@ void SelectionEngine::CursorPosChanging( BOOL bShift, BOOL bMod1 )
 BOOL SelectionEngine::SelMouseButtonDown( const MouseEvent& rMEvt )
 {
     nFlags &= (~SELENG_CMDEVT);
-    if ( !pFunctionSet || !pWin || rMEvt.GetClicks() > 1 || rMEvt.IsRight() )
+    if ( !pFunctionSet || !pWin )
+        return FALSE;
+    const bool bRightClickCursorPositioning =
+            rMEvt.IsRight() && rMEvt.GetClicks() == 1 && !IsInSelection();
+    if ( (rMEvt.GetClicks() > 1 || rMEvt.IsRight()) && !bRightClickCursorPositioning )
         return FALSE;
 
     USHORT nModifier = rMEvt.GetModifier() | nLockedMods;
diff --git a/vcl/source/window/syswin.cxx b/vcl/source/window/syswin.cxx
index 056b55dc3b61..f3624ef56f59 100644
--- a/vcl/source/window/syswin.cxx
+++ b/vcl/source/window/syswin.cxx
@@ -659,6 +659,63 @@ static void ImplWindowStateToStr( const WindowStateData& rData, ByteString& rStr
 
 // -----------------------------------------------------------------------
 
+void SystemWindow::ImplMoveToScreen( long& io_rX, long& io_rY, long i_nWidth, long i_nHeight, Window* i_pConfigureWin )
+{
+    Rectangle aScreenRect;
+    if( Application::IsMultiDisplay() )
+    {
+        aScreenRect = Application::GetScreenPosSizePixel( GetScreenNumber() );
+    }
+    else
+    {
+        aScreenRect = Application::GetScreenPosSizePixel( 0 );
+        for( unsigned int i = 1; i < Application::GetScreenCount(); i++ )
+            aScreenRect.Union( Application::GetScreenPosSizePixel( i ) );
+    }
+    // unfortunately most of the time width and height are not really known
+    if( i_nWidth < 1 )
+        i_nWidth = 50;
+    if( i_nHeight < 1 )
+        i_nHeight = 50;
+
+    // check left border
+    bool bMove = false;
+    if( io_rX + i_nWidth < aScreenRect.Left() )
+    {
+        bMove = true;
+        io_rX = aScreenRect.Left();
+    }
+    // check right border
+    if( io_rX > aScreenRect.Right() - i_nWidth )
+    {
+        bMove = true;
+        io_rX = aScreenRect.Right() - i_nWidth;
+    }
+    // check top border
+    if( io_rY + i_nHeight < aScreenRect.Top() )
+    {
+        bMove = true;
+        io_rY = aScreenRect.Top();
+    }
+    // check bottom border
+    if( io_rY > aScreenRect.Bottom() - i_nHeight )
+    {
+        bMove = true;
+        io_rY = aScreenRect.Bottom() - i_nHeight;
+    }
+    Window* pParent = i_pConfigureWin->GetParent();
+    if( bMove && pParent )
+    {
+        // calculate absolute screen pos here, since that is what is contained in WindowState
+        Point aParentAbsPos( pParent->OutputToAbsoluteScreenPixel( Point(0,0) ) );
+        Size aParentSizePixel( pParent->GetOutputSizePixel() );
+        Point aPos( (aParentSizePixel.Width() - i_nWidth) / 2,
+                    (aParentSizePixel.Height() - i_nHeight) / 2 );
+        io_rX = aParentAbsPos.X() + aPos.X();
+        io_rY = aParentAbsPos.Y() + aPos.Y();
+    }
+}
+
 void SystemWindow::SetWindowStateData( const WindowStateData& rData )
 {
     ULONG nValidMask = rData.GetMask();
@@ -701,6 +758,10 @@ void SystemWindow::SetWindowStateData( const WindowStateData& rData )
         //nState &= ~(WINDOWSTATE_STATE_MINIMIZED);
         aState.mnState  = nState & SAL_FRAMESTATE_SYSTEMMASK;
 
+        // normalize window positions onto screen
+        ImplMoveToScreen( aState.mnX, aState.mnY, aState.mnWidth, aState.mnHeight, pWindow );
+        ImplMoveToScreen( aState.mnMaximizedX, aState.mnMaximizedY, aState.mnMaximizedWidth, aState.mnMaximizedHeight, pWindow );
+
         // #96568# avoid having multiple frames at the same screen location
         //  do the check only if not maximized
         if( !((rData.GetMask() & WINDOWSTATE_MASK_STATE) && (nState & WINDOWSTATE_STATE_MAXIMIZED)) )
diff --git a/vcl/source/window/window.cxx b/vcl/source/window/window.cxx
index b47aa50a2e72..ca92d9ed6c5b 100644
--- a/vcl/source/window/window.cxx
+++ b/vcl/source/window/window.cxx
@@ -98,6 +98,7 @@
 #include "vcl/lazydelete.hxx"
 
 #include <set>
+#include <typeinfo>
 
 using namespace rtl;
 using namespace ::com::sun::star::uno;
@@ -1322,7 +1323,6 @@ ImplWinData* Window::ImplGetWinData() const
         mpWindowImpl->mpWinData->mnIsTopWindow  = (USHORT) ~0;  // not initialized yet, 0/1 will indicate TopWindow (see IsTopWindow())
         mpWindowImpl->mpWinData->mbMouseOver      = FALSE;
         mpWindowImpl->mpWinData->mbEnableNativeWidget = (pNoNWF && *pNoNWF) ? FALSE : TRUE; // TRUE: try to draw this control with native theme API
-        mpWindowImpl->mpWinData->mpSalControlHandle  = NULL;
         mpWindowImpl->mpWinData->mpSmartHelpId    = NULL;
         mpWindowImpl->mpWinData->mpSmartUniqueId  = NULL;
    }
@@ -4328,6 +4328,27 @@ Window::Window( Window* pParent, const ResId& rResId )
 }
 
 // -----------------------------------------------------------------------
+#if OSL_DEBUG_LEVEL > 0
+namespace
+{
+    void lcl_appendWindowInfo( ByteString& io_rErrorString, const Window& i_rWindow )
+    {
+        // skip border windows, they don't carry information which helps diagnosing the problem
+        const Window* pWindow( &i_rWindow );
+        while ( pWindow && ( pWindow->GetType() == WINDOW_BORDERWINDOW ) )
+            pWindow = pWindow->GetWindow( WINDOW_FIRSTCHILD );
+        if ( !pWindow )
+            pWindow = &i_rWindow;
+
+        io_rErrorString += char(13);
+        io_rErrorString += typeid( *pWindow ).name();
+        io_rErrorString += " (window text: '";
+        io_rErrorString += ByteString( pWindow->GetText(), RTL_TEXTENCODING_UTF8 );
+        io_rErrorString += "')";
+    }
+}
+#endif
+// -----------------------------------------------------------------------
 
 Window::~Window()
 {
@@ -4460,9 +4481,7 @@ Window::~Window()
             if ( ImplIsRealParentPath( pTempWin ) )
             {
                 bError = TRUE;
-                if ( aErrorStr.Len() )
-                    aErrorStr += "; ";
-                aErrorStr += ByteString( pTempWin->GetText(), RTL_TEXTENCODING_UTF8 );
+                lcl_appendWindowInfo( aErrorStr, *pTempWin );
             }
             pTempWin = pTempWin->mpWindowImpl->mpNextOverlap;
         }
@@ -4483,9 +4502,7 @@ Window::~Window()
             if ( ImplIsRealParentPath( pTempWin ) )
             {
                 bError = TRUE;
-                if ( aErrorStr.Len() )
-                    aErrorStr += "; ";
-                aErrorStr += ByteString( pTempWin->GetText(), RTL_TEXTENCODING_UTF8 );
+                lcl_appendWindowInfo( aErrorStr, *pTempWin );
             }
             pTempWin = pTempWin->mpWindowImpl->mpFrameData->mpNextFrame;
         }
@@ -4507,10 +4524,8 @@ Window::~Window()
             pTempWin = mpWindowImpl->mpFirstChild;
             while ( pTempWin )
             {
-                aTempStr += ByteString( pTempWin->GetText(), RTL_TEXTENCODING_UTF8 );
+                lcl_appendWindowInfo( aTempStr, *pTempWin );
                 pTempWin = pTempWin->mpWindowImpl->mpNext;
-                if ( pTempWin )
-                    aTempStr += "; ";
             }
             DBG_ERROR( aTempStr.GetBuffer() );
             GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) );   // abort in non-pro version, this must be fixed!
@@ -4524,10 +4539,8 @@ Window::~Window()
             pTempWin = mpWindowImpl->mpFirstOverlap;
             while ( pTempWin )
             {
-                aTempStr += ByteString( pTempWin->GetText(), RTL_TEXTENCODING_UTF8 );
+                lcl_appendWindowInfo( aTempStr, *pTempWin );
                 pTempWin = pTempWin->mpWindowImpl->mpNext;
-                if ( pTempWin )
-                    aTempStr += "; ";
             }
             DBG_ERROR( aTempStr.GetBuffer() );
             GetpApp()->Abort( String( aTempStr, RTL_TEXTENCODING_UTF8 ) );   // abort in non-pro version, this must be fixed!
@@ -4722,10 +4735,6 @@ Window::~Window()
             delete mpWindowImpl->mpWinData->mpFocusRect;
         if ( mpWindowImpl->mpWinData->mpTrackRect )
             delete mpWindowImpl->mpWinData->mpTrackRect;
-        // Native widget support
-        delete mpWindowImpl->mpWinData->mpSalControlHandle;
-        mpWindowImpl->mpWinData->mpSalControlHandle = NULL;
-
         if ( mpWindowImpl->mpWinData->mpSmartHelpId )
             delete mpWindowImpl->mpWinData->mpSmartHelpId;
         if ( mpWindowImpl->mpWinData->mpSmartUniqueId )
@@ -7444,13 +7453,13 @@ Rectangle Window::ImplOutputToUnmirroredAbsoluteScreenPixel( const Rectangle &rR
 
 // -----------------------------------------------------------------------
 
-Rectangle Window::GetWindowExtentsRelative( Window *pRelativeWindow )
+Rectangle Window::GetWindowExtentsRelative( Window *pRelativeWindow ) const
 {
     // with decoration
     return ImplGetWindowExtentsRelative( pRelativeWindow, FALSE );
 }
 
-Rectangle Window::GetClientWindowExtentsRelative( Window *pRelativeWindow )
+Rectangle Window::GetClientWindowExtentsRelative( Window *pRelativeWindow ) const
 {
     // without decoration
     return ImplGetWindowExtentsRelative( pRelativeWindow, TRUE );
@@ -7458,12 +7467,12 @@ Rectangle Window::GetClientWindowExtentsRelative( Window *pRelativeWindow )
 
 // -----------------------------------------------------------------------
 
-Rectangle Window::ImplGetWindowExtentsRelative( Window *pRelativeWindow, BOOL bClientOnly )
+Rectangle Window::ImplGetWindowExtentsRelative( Window *pRelativeWindow, BOOL bClientOnly ) const
 {
     SalFrameGeometry g = mpWindowImpl->mpFrame->GetGeometry();
     // make sure we use the extent of our border window,
     // otherwise we miss a few pixels
-    Window *pWin = (!bClientOnly && mpWindowImpl->mpBorderWindow) ? mpWindowImpl->mpBorderWindow : this;
+    const Window *pWin = (!bClientOnly && mpWindowImpl->mpBorderWindow) ? mpWindowImpl->mpBorderWindow : this;
 
     Point aPos( pWin->OutputToScreenPixel( Point(0,0) ) );
     aPos.X() += g.nX;
diff --git a/vcl/source/window/window3.cxx b/vcl/source/window/window3.cxx
index aecbc9c3ef0c..65019ba2a4af 100644
--- a/vcl/source/window/window3.cxx
+++ b/vcl/source/window/window3.cxx
@@ -28,269 +28,10 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_vcl.hxx"
 
-#define _SV_WINDOW_CXX
-
-#include "svsys.h"
-#include "vcl/window.h"
 #include "vcl/window.hxx"
 #include "vcl/waitobj.hxx"
-#include "vcl/salgdi.hxx"
-#include "vcl/salnativewidgets.hxx"
-#include "vcl/salctrlhandle.hxx"
-#include "rtl/ustring.hxx"
 #include "vcl/button.hxx"
 
-using namespace rtl;
-
-// -----------------------------------------------------------------------
-// These functions are mainly passthrough functions that allow access to
-// the SalFrame behind a Window object for native widget rendering purposes.
-// -----------------------------------------------------------------------
-
-void Window::ImplInitSalControlHandle()
-{
-    // create SalControlHandle on demand
-    // not needed for ordinary windows
-    // TODO: move creation to SalGraphics
-    //if( !ImplGetWinData()->mpSalControlHandle )
-    //    ImplGetWinData()->mpSalControlHandle = new SalControlHandle;
-}
-
-// -----------------------------------------------------------------------
-
-BOOL Window::IsNativeControlSupported( ControlType nType, ControlPart nPart )
-{
-    if( !IsNativeWidgetEnabled() )
-        return FALSE;
-
-    if ( !mpGraphics )
-        if ( !ImplGetGraphics() )
-            return FALSE;
-
-    return( mpGraphics->IsNativeControlSupported(nType, nPart) );
-}
-
-
-// -----------------------------------------------------------------------
-
-BOOL Window::HitTestNativeControl( ControlType nType,
-                              ControlPart nPart,
-                              const Region& rControlRegion,
-                              const Point& aPos,
-                              BOOL& rIsInside )
-{
-    if( !IsNativeWidgetEnabled() )
-        return FALSE;
-
-    if ( !mpGraphics )
-        if ( !ImplGetGraphics() )
-            return FALSE;
-
-    ImplInitSalControlHandle();
-
-    Point aWinOffs;
-    aWinOffs = OutputToScreenPixel( aWinOffs );
-    Region screenRegion( rControlRegion );
-    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
-
-    return( mpGraphics->HitTestNativeControl(nType, nPart, screenRegion, OutputToScreenPixel( aPos ), *ImplGetWinData()->mpSalControlHandle, rIsInside, this ) );
-}
-
-// -----------------------------------------------------------------------
-
-void Window::ImplMoveControlValue( ControlType nType, const ImplControlValue& aValue, const Point& rDelta ) const
-{
-    if( aValue.getOptionalVal() )
-    {
-        switch( nType )
-        {
-            case CTRL_SLIDER:
-            {
-                SliderValue* pSlVal = reinterpret_cast<SliderValue*>(aValue.getOptionalVal());
-                pSlVal->maThumbRect.Move( rDelta.X(), rDelta.Y() );
-            }
-            break;
-            case CTRL_SCROLLBAR:
-            {
-                ScrollbarValue* pScVal = reinterpret_cast<ScrollbarValue*>(aValue.getOptionalVal());
-                pScVal->maThumbRect.Move( rDelta.X(), rDelta.Y() );
-                pScVal->maButton1Rect.Move( rDelta.X(), rDelta.Y() );
-                pScVal->maButton2Rect.Move( rDelta.X(), rDelta.Y() );
-            }
-            break;
-            case CTRL_SPINBOX:
-            case CTRL_SPINBUTTONS:
-            {
-                SpinbuttonValue* pSpVal = reinterpret_cast<SpinbuttonValue*>(aValue.getOptionalVal());
-                pSpVal->maUpperRect.Move( rDelta.X(), rDelta.Y() );
-                pSpVal->maLowerRect.Move( rDelta.X(), rDelta.Y() );
-            }
-            break;
-            case CTRL_TOOLBAR:
-            {
-                ToolbarValue* pTVal = reinterpret_cast<ToolbarValue*>(aValue.getOptionalVal());
-                pTVal->maGripRect.Move( rDelta.X(), rDelta.Y() );
-            }
-            break;
-        }
-    }
-}
-
-BOOL Window::DrawNativeControl( ControlType nType,
-                            ControlPart nPart,
-                            const Region& rControlRegion,
-                            ControlState nState,
-                            const ImplControlValue& aValue,
-                            OUString aCaption )
-{
-    if( !IsNativeWidgetEnabled() )
-        return FALSE;
-
-    /*
-    if( !IsInPaint() && IsPaintTransparent() )
-    {
-        // only required if called directly (ie, we're not in Paint() ):
-        // force redraw (Paint()) for transparent controls
-        // to trigger a repaint of the background
-        Region aClipRgn( GetClipRegion() );
-        if( !rControlRegion.IsEmpty() )
-            aClipRgn.Intersect( rControlRegion );
-        Invalidate( aClipRgn, INVALIDATE_UPDATE );
-        return TRUE;
-    }
-    */
-
-    ImplInitSalControlHandle();
-
-    // make sure the current clip region is initialized correctly
-    if ( !mpGraphics )
-        if ( !ImplGetGraphics() )
-            return FALSE;
-
-    if ( mbInitClipRegion )
-        ImplInitClipRegion();
-    if ( mbOutputClipped )
-        return TRUE;
-
-    if ( mbInitLineColor )
-        ImplInitLineColor();
-    if ( mbInitFillColor )
-        ImplInitFillColor();
-
-    // Convert the coordinates from relative to Window-absolute, so we draw
-    // in the correct place in platform code
-    Point aWinOffs;
-    aWinOffs = OutputToScreenPixel( aWinOffs );
-    Region screenRegion( rControlRegion );
-    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
-
-    // do so for ImplControlValue members, also
-    ImplMoveControlValue( nType, aValue, aWinOffs );
-
-    Region aTestRegion( GetActiveClipRegion() );
-    aTestRegion.Intersect( rControlRegion );
-    if( aTestRegion == rControlRegion )
-        nState |= CTRL_CACHING_ALLOWED;   // control is not clipped, caching allowed
-
-    BOOL bRet = mpGraphics->DrawNativeControl(nType, nPart, screenRegion, nState, aValue, *ImplGetWinData()->mpSalControlHandle, aCaption, this );
-
-    // transform back ImplControlValue members
-    ImplMoveControlValue( nType, aValue, Point()-aWinOffs );
-
-    return bRet;
-}
-
-
-// -----------------------------------------------------------------------
-
-BOOL Window::DrawNativeControlText(ControlType nType,
-                            ControlPart nPart,
-                            const Region& rControlRegion,
-                            ControlState nState,
-                            const ImplControlValue& aValue,
-                            OUString aCaption )
-{
-    if( !IsNativeWidgetEnabled() )
-        return FALSE;
-
-    ImplInitSalControlHandle();
-
-    // make sure the current clip region is initialized correctly
-    if ( !mpGraphics )
-        if ( !ImplGetGraphics() )
-            return false;
-
-    if ( mbInitClipRegion )
-        ImplInitClipRegion();
-    if ( mbOutputClipped )
-        return true;
-
-    if ( mbInitLineColor )
-        ImplInitLineColor();
-    if ( mbInitFillColor )
-        ImplInitFillColor();
-
-    // Convert the coordinates from relative to Window-absolute, so we draw
-    // in the correct place in platform code
-    Point aWinOffs;
-    aWinOffs = OutputToScreenPixel( aWinOffs );
-    Region screenRegion( rControlRegion );
-    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
-    ImplMoveControlValue( nType, aValue, aWinOffs );
-
-    BOOL bRet = mpGraphics->DrawNativeControlText(nType, nPart, screenRegion, nState, aValue, *ImplGetWinData()->mpSalControlHandle, aCaption, this );
-
-    // transform back ImplControlValue members
-    ImplMoveControlValue( nType, aValue, Point()-aWinOffs );
-
-    return bRet;
-}
-
-
-// -----------------------------------------------------------------------
-
-BOOL Window::GetNativeControlRegion(  ControlType nType,
-                                ControlPart nPart,
-                                const Region& rControlRegion,
-                                ControlState nState,
-                                const ImplControlValue& aValue,
-                                OUString aCaption,
-                                Region &rNativeBoundingRegion,
-                                Region &rNativeContentRegion )
-{
-    if( !IsNativeWidgetEnabled() )
-        return FALSE;
-
-    if ( !mpGraphics )
-        if ( !ImplGetGraphics() )
-            return FALSE;
-
-    ImplInitSalControlHandle();
-
-    // Convert the coordinates from relative to Window-absolute, so we draw
-    // in the correct place in platform code
-    Point aWinOffs;
-    aWinOffs = OutputToScreenPixel( aWinOffs );
-    Region screenRegion( rControlRegion );
-    screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
-    ImplMoveControlValue( nType, aValue, aWinOffs );
-
-    BOOL bRet = mpGraphics->GetNativeControlRegion(nType, nPart, screenRegion, nState, aValue,
-                                *ImplGetWinData()->mpSalControlHandle, aCaption, rNativeBoundingRegion,
-                                rNativeContentRegion, this );
-    if( bRet )
-    {
-        // transform back native regions
-        rNativeBoundingRegion.Move( -aWinOffs.X(), -aWinOffs.Y() );
-        rNativeContentRegion.Move( -aWinOffs.X(), -aWinOffs.Y() );
-    }
-    // transform back ImplControlValue members
-    ImplMoveControlValue( nType, aValue, Point()-aWinOffs );
-
-    return bRet;
-}
-
-
 // -----------------------------------------------------------------------
 
 WaitObject::~WaitObject()
diff --git a/vcl/unx/gtk/app/gtkdata.cxx b/vcl/unx/gtk/app/gtkdata.cxx
index f63f999738a7..2679f4a29c02 100644
--- a/vcl/unx/gtk/app/gtkdata.cxx
+++ b/vcl/unx/gtk/app/gtkdata.cxx
@@ -636,9 +636,6 @@ void GtkXLib::Init()
 
     Display *pDisp = gdk_x11_display_get_xdisplay( pGdkDisp );
 
-    XSetIOErrorHandler    ( (XIOErrorHandler)X11SalData::XIOErrorHdl );
-    XSetErrorHandler      ( (XErrorHandler)X11SalData::XErrorHdl );
-
     m_pGtkSalDisplay = new GtkSalDisplay( pGdkDisp );
 
     gdk_window_add_filter( NULL, call_filterGdkEvent, m_pGtkSalDisplay );
diff --git a/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx b/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx
index de4d55b0230a..cdc72485ae6c 100644
--- a/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx
+++ b/vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx
@@ -191,34 +191,34 @@ static void NWCalcArrowRect( const Rectangle& rButton, Rectangle& rArrow );
 
 //---
 static Rectangle NWGetButtonArea( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
-                                const ImplControlValue& aValue, SalControlHandle& rControlHandle, const OUString& rCaption );
+                                const ImplControlValue& aValue, const OUString& rCaption );
 
 //---
 static Rectangle NWGetEditBoxPixmapRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
-                            const ImplControlValue& aValue, SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const ImplControlValue& aValue, const OUString& rCaption );
 
 static void NWPaintOneEditBox( int nScreen, GdkDrawable * gdkDrawable, GdkRectangle *gdkRect,
                                ControlType nType, ControlPart nPart, Rectangle aEditBoxRect,
                                ControlState nState, const ImplControlValue& aValue,
-                               SalControlHandle& rControlHandle, const OUString& rCaption );
+                               const OUString& rCaption );
 
 //---
 static Rectangle NWGetSpinButtonRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
-                            const ImplControlValue& aValue, SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const ImplControlValue& aValue, const OUString& rCaption );
 
 static void NWPaintOneSpinButton( int nScreen, GdkPixmap * pixmap, ControlType nType, ControlPart nPart, Rectangle aAreaRect,
-                            ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                            ControlState nState, const ImplControlValue& aValue,
                             const OUString& rCaption );
 //---
 static Rectangle NWGetComboBoxButtonRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
-                            const ImplControlValue& aValue, SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const ImplControlValue& aValue, const OUString& rCaption );
 
 //---
 static Rectangle NWGetListBoxButtonRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
-                            const ImplControlValue& aValue, SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const ImplControlValue& aValue, const OUString& rCaption );
 
 static Rectangle NWGetListBoxIndicatorRect( int nScreen, ControlType nType, ControlPart nPart, Rectangle aAreaRect, ControlState nState,
-                            const ImplControlValue& aValue, SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const ImplControlValue& aValue, const OUString& rCaption );
 
 static Rectangle NWGetToolbarRect( int nScreen,
                                    ControlType nType,
@@ -226,7 +226,6 @@ static Rectangle NWGetToolbarRect( int nScreen,
                                    Rectangle aAreaRect,
                                    ControlState nState,
                                    const ImplControlValue& aValue,
-                                   SalControlHandle& rControlHandle,
                                    const OUString& rCaption );
 //---
 
@@ -620,7 +619,6 @@ BOOL GtkSalGraphics::hitTestNativeControl( ControlType      nType,
                                 ControlPart     nPart,
                                 const Region&       rControlRegion,
                                 const Point&        aPos,
-                                SalControlHandle&,
                                 BOOL&           rIsInside )
 {
     if ( ( nType == CTRL_SCROLLBAR ) &&
@@ -725,7 +723,6 @@ BOOL GtkSalGraphics::hitTestNativeControl( ControlType      nType,
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:         An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the SalFrame implementation.
  *  rCaption:   A caption or title string (like button text etc)
  */
 BOOL GtkSalGraphics::drawNativeControl( ControlType nType,
@@ -733,13 +730,12 @@ BOOL GtkSalGraphics::drawNativeControl( ControlType nType,
                             const Region& rControlRegion,
                             ControlState nState,
                             const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle,
                             const OUString& rCaption )
 {
     if( (nType==CTRL_CHECKBOX) && (nPart==PART_ENTIRE_CONTROL) &&
         aValue.getTristateVal() == BUTTONVALUE_MIXED )
     {
-        return drawNativeMixedStateCheck( nType, nPart, rControlRegion, nState, aValue, rControlHandle, rCaption );
+        return drawNativeMixedStateCheck( nType, nPart, rControlRegion, nState, aValue, rCaption );
     }
 
     BOOL            returnVal = FALSE;
@@ -802,61 +798,61 @@ BOOL GtkSalGraphics::drawNativeControl( ControlType nType,
 
     if ( (nType==CTRL_PUSHBUTTON) && (nPart==PART_ENTIRE_CONTROL) )
     {
-        returnVal = NWPaintGTKButton( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKButton( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( (nType==CTRL_RADIOBUTTON) && (nPart==PART_ENTIRE_CONTROL) )
     {
-        returnVal = NWPaintGTKRadio( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKRadio( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( (nType==CTRL_CHECKBOX) && (nPart==PART_ENTIRE_CONTROL) )
     {
-        returnVal = NWPaintGTKCheck( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKCheck( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( (nType==CTRL_SCROLLBAR) && ((nPart==PART_DRAW_BACKGROUND_HORZ) || (nPart==PART_DRAW_BACKGROUND_VERT)) )
     {
-        returnVal = NWPaintGTKScrollbar( nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKScrollbar( nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( ((nType==CTRL_EDITBOX) && ((nPart==PART_ENTIRE_CONTROL) || (nPart==HAS_BACKGROUND_TEXTURE)) )
         || ((nType==CTRL_SPINBOX) && (nPart==HAS_BACKGROUND_TEXTURE))
     || ((nType==CTRL_COMBOBOX) && (nPart==HAS_BACKGROUND_TEXTURE))
     || ((nType==CTRL_LISTBOX) && (nPart==HAS_BACKGROUND_TEXTURE)) )
     {
-        returnVal = NWPaintGTKEditBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKEditBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( ((nType==CTRL_MULTILINE_EDITBOX) && ((nPart==PART_ENTIRE_CONTROL) || (nPart==HAS_BACKGROUND_TEXTURE)) ) )
     {
-        returnVal = NWPaintGTKEditBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKEditBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( ((nType==CTRL_SPINBOX) || (nType==CTRL_SPINBUTTONS))
         && ((nPart==PART_ENTIRE_CONTROL) || (nPart==PART_ALL_BUTTONS)) )
     {
-        returnVal = NWPaintGTKSpinBox( nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKSpinBox( nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( (nType == CTRL_COMBOBOX) &&
         ( (nPart==PART_ENTIRE_CONTROL)
         ||(nPart==PART_BUTTON_DOWN)
         ) )
     {
-        returnVal = NWPaintGTKComboBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKComboBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( (nType==CTRL_TAB_ITEM) || (nType==CTRL_TAB_PANE) || (nType==CTRL_TAB_BODY) || (nType==CTRL_FIXEDBORDER) )
     {
         if ( nType == CTRL_TAB_BODY )
             returnVal = TRUE;
         else
-            returnVal = NWPaintGTKTabItem( nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption);
+            returnVal = NWPaintGTKTabItem( nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption);
     }
     else if ( (nType==CTRL_LISTBOX) && ((nPart==PART_ENTIRE_CONTROL) || (nPart==PART_WINDOW)) )
     {
-        returnVal = NWPaintGTKListBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKListBox( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( (nType== CTRL_TOOLBAR) )
     {
-        returnVal = NWPaintGTKToolbar( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKToolbar( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if ( (nType== CTRL_MENUBAR) )
     {
-        returnVal = NWPaintGTKMenubar( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKMenubar( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if(    (nType == CTRL_MENU_POPUP)
         && (  (nPart == PART_ENTIRE_CONTROL)
@@ -866,19 +862,19 @@ BOOL GtkSalGraphics::drawNativeControl( ControlType nType,
     )
     )
     {
-        returnVal = NWPaintGTKPopupMenu( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKPopupMenu( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if( (nType == CTRL_TOOLTIP) && (nPart == PART_ENTIRE_CONTROL) )
     {
-        returnVal = NWPaintGTKTooltip( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKTooltip( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if( (nType == CTRL_PROGRESS) && (nPart == PART_ENTIRE_CONTROL) )
     {
-        returnVal = NWPaintGTKProgress( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKProgress( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if( (nType == CTRL_LISTNODE) && (nPart == PART_ENTIRE_CONTROL) )
     {
-        returnVal = NWPaintGTKListNode( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKListNode( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
     else if( (nType == CTRL_LISTNET) && (nPart == PART_ENTIRE_CONTROL) )
     {
@@ -887,7 +883,7 @@ BOOL GtkSalGraphics::drawNativeControl( ControlType nType,
     }
     else if( (nType == CTRL_SLIDER) )
     {
-        returnVal = NWPaintGTKSlider( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rControlHandle, rCaption );
+        returnVal = NWPaintGTKSlider( gdkDrawable, nType, nPart, aCtrlRect, aClip, nState, aValue, rCaption );
     }
 
     if( pixmap )
@@ -904,7 +900,6 @@ BOOL GtkSalGraphics::drawNativeMixedStateCheck( ControlType nType,
                                                 const Region& rControlRegion,
                                                 ControlState nState,
                                                 const ImplControlValue& aValue,
-                                                SalControlHandle& rControlHandle,
                                                 const OUString& rCaption )
 {
     // need to emulate something for mixed state
@@ -927,7 +922,7 @@ BOOL GtkSalGraphics::drawNativeMixedStateCheck( ControlType nType,
     SetClipRegion( pFontGC_, aRegion );
     XDestroyRegion( aRegion );
 
-    returnVal = drawNativeControl( nType, nPart, rControlRegion, nState, aValue, rControlHandle, rCaption );
+    returnVal = drawNativeControl( nType, nPart, rControlRegion, nState, aValue, rCaption );
 
     if( returnVal )
     {
@@ -938,7 +933,7 @@ BOOL GtkSalGraphics::drawNativeMixedStateCheck( ControlType nType,
         XUnionRectWithRegion( &aXRect, aRegion, aRegion );
         SetClipRegion( pFontGC_, aRegion );
         XDestroyRegion( aRegion );
-        returnVal = drawNativeControl( nType, nPart, rControlRegion, nState, aValue, rControlHandle, rCaption );
+        returnVal = drawNativeControl( nType, nPart, rControlRegion, nState, aValue, rCaption );
     }
 
     // clean up
@@ -957,7 +952,6 @@ BOOL GtkSalGraphics::drawNativeMixedStateCheck( ControlType nType,
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:         An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the SalFrame implementation.
  *  rCaption:   A caption or title string (like button text etc)
  */
 BOOL GtkSalGraphics::drawNativeControlText( ControlType,
@@ -965,7 +959,6 @@ BOOL GtkSalGraphics::drawNativeControlText( ControlType,
                                 const Region&,
                                 ControlState,
                                 const ImplControlValue&,
-                                SalControlHandle&,
                                 const OUString& )
 {
     return( FALSE );
@@ -983,7 +976,6 @@ BOOL GtkSalGraphics::drawNativeControlText( ControlType,
  *
  *  rControlRegion: The bounding region of the control in VCL frame coordinates.
  *  aValue:     An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the SalFrame implementation.
  *  rCaption:       A caption or title string (like button text etc)
  */
 BOOL GtkSalGraphics::getNativeControlRegion(  ControlType nType,
@@ -991,7 +983,6 @@ BOOL GtkSalGraphics::getNativeControlRegion(  ControlType nType,
                                 const Region& rControlRegion,
                                 ControlState nState,
                                 const ImplControlValue& aValue,
-                                SalControlHandle& rControlHandle,
                                 const OUString& rCaption,
                                 Region &rNativeBoundingRegion,
                                 Region &rNativeContentRegion )
@@ -1003,7 +994,7 @@ BOOL GtkSalGraphics::getNativeControlRegion(  ControlType nType,
     && (rControlRegion.GetBoundRect().GetHeight() > 16) )
     {
         rNativeBoundingRegion = NWGetButtonArea( m_nScreen, nType, nPart, rControlRegion.GetBoundRect(),
-        nState, aValue, rControlHandle, rCaption );
+        nState, aValue, rCaption );
         rNativeContentRegion = rControlRegion;
 
         returnVal = TRUE;
@@ -1011,7 +1002,7 @@ BOOL GtkSalGraphics::getNativeControlRegion(  ControlType nType,
     if ( (nType==CTRL_COMBOBOX) && ((nPart==PART_BUTTON_DOWN) || (nPart==PART_SUB_EDIT)) )
     {
         rNativeBoundingRegion = NWGetComboBoxButtonRect( m_nScreen, nType, nPart, rControlRegion.GetBoundRect(), nState,
-        aValue, rControlHandle, rCaption );
+        aValue, rCaption );
         rNativeContentRegion = rNativeBoundingRegion;
 
         returnVal = TRUE;
@@ -1020,7 +1011,7 @@ BOOL GtkSalGraphics::getNativeControlRegion(  ControlType nType,
     {
 
         rNativeBoundingRegion = NWGetSpinButtonRect( m_nScreen, nType, nPart, rControlRegion.GetBoundRect(), nState,
-        aValue, rControlHandle, rCaption );
+        aValue, rCaption );
         rNativeContentRegion = rNativeBoundingRegion;
 
         returnVal = TRUE;
@@ -1028,7 +1019,7 @@ BOOL GtkSalGraphics::getNativeControlRegion(  ControlType nType,
     if ( (nType==CTRL_LISTBOX) && ((nPart==PART_BUTTON_DOWN) || (nPart==PART_SUB_EDIT)) )
     {
         rNativeBoundingRegion = NWGetListBoxButtonRect( m_nScreen, nType, nPart, rControlRegion.GetBoundRect(), nState,
-        aValue, rControlHandle, rCaption );
+        aValue, rCaption );
         rNativeContentRegion = rNativeBoundingRegion;
 
         returnVal = TRUE;
@@ -1041,7 +1032,7 @@ BOOL GtkSalGraphics::getNativeControlRegion(  ControlType nType,
         (nPart==PART_BUTTON)
         ))
     {
-        rNativeBoundingRegion = NWGetToolbarRect( m_nScreen, nType, nPart, rControlRegion.GetBoundRect(), nState, aValue, rControlHandle, rCaption );
+        rNativeBoundingRegion = NWGetToolbarRect( m_nScreen, nType, nPart, rControlRegion.GetBoundRect(), nState, aValue, rCaption );
         rNativeContentRegion = rNativeBoundingRegion;
         returnVal = TRUE;
     }
@@ -1155,7 +1146,7 @@ BOOL GtkSalGraphics::NWPaintGTKButton(
             const Rectangle& rControlRectangle,
             const clipList& rClipList,
             ControlState nState, const ImplControlValue&,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     GtkStateType    stateType;
     GtkShadowType   shadowType;
@@ -1268,7 +1259,7 @@ BOOL GtkSalGraphics::NWPaintGTKButton(
 
 static Rectangle NWGetButtonArea( int nScreen,
                                   ControlType, ControlPart, Rectangle aAreaRect, ControlState nState,
-                                  const ImplControlValue&, SalControlHandle&, const OUString& )
+                                  const ImplControlValue&, const OUString& )
 {
     gboolean        interiorFocus;
     gint            focusWidth;
@@ -1324,7 +1315,7 @@ BOOL GtkSalGraphics::NWPaintGTKRadio( GdkDrawable* gdkDrawable,
                                       const Rectangle& rControlRectangle,
                                       const clipList& rClipList,
                                       ControlState nState,
-                                      const ImplControlValue& aValue, SalControlHandle&,
+                                      const ImplControlValue& aValue,
                                       const OUString& )
 {
     GtkStateType    stateType;
@@ -1383,7 +1374,7 @@ BOOL GtkSalGraphics::NWPaintGTKCheck( GdkDrawable* gdkDrawable,
                                       const clipList& rClipList,
                                       ControlState nState,
                                       const ImplControlValue& aValue,
-                                      SalControlHandle&, const OUString& )
+                                      const OUString& )
 {
     GtkStateType    stateType;
     GtkShadowType   shadowType;
@@ -1438,7 +1429,7 @@ BOOL GtkSalGraphics::NWPaintGTKScrollbar( ControlType, ControlPart nPart,
                                           const Rectangle& rControlRectangle,
                                           const clipList&,
                                           ControlState nState,
-                                          const ImplControlValue& aValue, SalControlHandle&,
+                                          const ImplControlValue& aValue,
                                           const OUString& )
 {
     ScrollbarValue* pScrollbarVal = (ScrollbarValue *)(aValue.getOptionalVal());
@@ -1844,7 +1835,7 @@ BOOL GtkSalGraphics::NWPaintGTKEditBox( GdkDrawable* gdkDrawable,
                                         const Rectangle& rControlRectangle,
                                         const clipList& rClipList,
                                         ControlState nState,
-                                        const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                        const ImplControlValue& aValue,
                                         const OUString& rCaption )
 {
     Rectangle       pixmapRect;
@@ -1853,7 +1844,7 @@ BOOL GtkSalGraphics::NWPaintGTKEditBox( GdkDrawable* gdkDrawable,
     // Find the overall bounding rect of the buttons's drawing area,
     // plus its actual draw rect excluding adornment
     pixmapRect = NWGetEditBoxPixmapRect( m_nScreen, nType, nPart, rControlRectangle,
-                                         nState, aValue, rControlHandle, rCaption );
+                                         nState, aValue, rCaption );
     for( clipList::const_iterator it = rClipList.begin(); it != rClipList.end(); ++it )
     {
         clipRect.x = it->Left();
@@ -1861,7 +1852,7 @@ BOOL GtkSalGraphics::NWPaintGTKEditBox( GdkDrawable* gdkDrawable,
         clipRect.width = it->GetWidth();
         clipRect.height = it->GetHeight();
 
-        NWPaintOneEditBox( m_nScreen, gdkDrawable, &clipRect, nType, nPart, pixmapRect, nState, aValue, rControlHandle, rCaption );
+        NWPaintOneEditBox( m_nScreen, gdkDrawable, &clipRect, nType, nPart, pixmapRect, nState, aValue, rCaption );
     }
 
     return( TRUE );
@@ -1878,7 +1869,6 @@ static Rectangle NWGetEditBoxPixmapRect(int nScreen,
                                         Rectangle aAreaRect,
                                         ControlState,
                                         const ImplControlValue&,
-                                        SalControlHandle&,
                                         const OUString& )
 {
     Rectangle       pixmapRect = aAreaRect;
@@ -1915,7 +1905,6 @@ static void NWPaintOneEditBox(  int nScreen,
                                 Rectangle               aEditBoxRect,
                                 ControlState            nState,
                                 const ImplControlValue&,
-                                SalControlHandle&,
                                 const OUString& )
 {
     GtkStateType    stateType;
@@ -1984,7 +1973,7 @@ BOOL GtkSalGraphics::NWPaintGTKSpinBox( ControlType nType, ControlPart nPart,
                                         const clipList&,
                                         ControlState nState,
                                         const ImplControlValue& aValue,
-                                        SalControlHandle& rControlHandle, const OUString& rCaption )
+                                        const OUString& rCaption )
 {
     GdkPixmap   *       pixmap;
     Rectangle           pixmapRect;
@@ -2032,8 +2021,8 @@ BOOL GtkSalGraphics::NWPaintGTKSpinBox( ControlType nType, ControlPart nPart,
     if ( !pixmap )
         return( FALSE );
 
-    upBtnRect = NWGetSpinButtonRect( m_nScreen, nType, upBtnPart, pixmapRect, upBtnState, aValue, rControlHandle, rCaption );
-    downBtnRect = NWGetSpinButtonRect( m_nScreen, nType, downBtnPart, pixmapRect, downBtnState, aValue, rControlHandle, rCaption );
+    upBtnRect = NWGetSpinButtonRect( m_nScreen, nType, upBtnPart, pixmapRect, upBtnState, aValue, rCaption );
+    downBtnRect = NWGetSpinButtonRect( m_nScreen, nType, downBtnPart, pixmapRect, downBtnState, aValue, rCaption );
 
     if ( (nType==CTRL_SPINBOX) && (nPart!=PART_ALL_BUTTONS) )
     {
@@ -2043,7 +2032,7 @@ BOOL GtkSalGraphics::NWPaintGTKSpinBox( ControlType nType, ControlPart nPart,
         aEditBoxRect.setX( 0 );
         aEditBoxRect.setY( 0 );
 
-        NWPaintOneEditBox( m_nScreen, pixmap, NULL, nType, nPart, aEditBoxRect, nState, aValue, rControlHandle, rCaption );
+        NWPaintOneEditBox( m_nScreen, pixmap, NULL, nType, nPart, aEditBoxRect, nState, aValue, rCaption );
     }
 
     NWSetWidgetState( gWidgetData[m_nScreen].gSpinButtonWidget, nState, stateType );
@@ -2060,8 +2049,8 @@ BOOL GtkSalGraphics::NWPaintGTKSpinBox( ControlType nType, ControlPart nPart,
             shadowRect.GetWidth(), shadowRect.GetHeight() );
     }
 
-    NWPaintOneSpinButton( m_nScreen, pixmap, nType, upBtnPart, pixmapRect, upBtnState, aValue, rControlHandle, rCaption );
-    NWPaintOneSpinButton( m_nScreen, pixmap, nType, downBtnPart, pixmapRect, downBtnState, aValue, rControlHandle, rCaption );
+    NWPaintOneSpinButton( m_nScreen, pixmap, nType, upBtnPart, pixmapRect, upBtnState, aValue, rCaption );
+    NWPaintOneSpinButton( m_nScreen, pixmap, nType, downBtnPart, pixmapRect, downBtnState, aValue, rCaption );
 
     if( !NWRenderPixmapToScreen(pixmap, pixmapRect) )
     {
@@ -2081,7 +2070,6 @@ static Rectangle NWGetSpinButtonRect( int nScreen,
                                       Rectangle             aAreaRect,
                                       ControlState,
                                       const ImplControlValue&,
-                                      SalControlHandle&,
                                       const OUString& )
 {
     gint            buttonSize;
@@ -2125,7 +2113,6 @@ static void NWPaintOneSpinButton( int nScreen,
                                   Rectangle             aAreaRect,
                                   ControlState          nState,
                                   const ImplControlValue&   aValue,
-                                  SalControlHandle&     rControlHandle,
                                   const OUString&               rCaption )
 {
     Rectangle           buttonRect;
@@ -2137,7 +2124,7 @@ static void NWPaintOneSpinButton( int nScreen,
     NWEnsureGTKSpinButton( nScreen );
     NWConvertVCLStateToGTKState( nState, &stateType, &shadowType );
 
-    buttonRect = NWGetSpinButtonRect( nScreen, nType, nPart, aAreaRect, nState, aValue, rControlHandle, rCaption );
+    buttonRect = NWGetSpinButtonRect( nScreen, nType, nPart, aAreaRect, nState, aValue, rCaption );
 
     NWSetWidgetState( gWidgetData[nScreen].gSpinButtonWidget, nState, stateType );
     gtk_paint_box( gWidgetData[nScreen].gSpinButtonWidget->style, pixmap, stateType, shadowType, NULL, gWidgetData[nScreen].gSpinButtonWidget,
@@ -2169,7 +2156,7 @@ BOOL GtkSalGraphics::NWPaintGTKComboBox( GdkDrawable* gdkDrawable,
                                          const clipList& rClipList,
                                          ControlState nState,
                                          const ImplControlValue& aValue,
-                                         SalControlHandle& rControlHandle, const OUString& rCaption )
+                                         const OUString& rCaption )
 {
     Rectangle       pixmapRect;
     Rectangle       buttonRect;
@@ -2194,7 +2181,7 @@ BOOL GtkSalGraphics::NWPaintGTKComboBox( GdkDrawable* gdkDrawable,
     NWSetWidgetState( gWidgetData[m_nScreen].gComboWidget, nState, stateType );
     NWSetWidgetState( gWidgetData[m_nScreen].gArrowWidget, nState, stateType );
 
-    buttonRect = NWGetComboBoxButtonRect( m_nScreen, nType, PART_BUTTON_DOWN, pixmapRect, nState, aValue, rControlHandle, rCaption );
+    buttonRect = NWGetComboBoxButtonRect( m_nScreen, nType, PART_BUTTON_DOWN, pixmapRect, nState, aValue, rCaption );
     if( nPart == PART_BUTTON_DOWN )
         buttonRect.Left() += 1;
 
@@ -2216,7 +2203,7 @@ BOOL GtkSalGraphics::NWPaintGTKComboBox( GdkDrawable* gdkDrawable,
 
         if( nPart == PART_ENTIRE_CONTROL )
             NWPaintOneEditBox( m_nScreen, gdkDrawable, &clipRect, nType, nPart, aEditBoxRect,
-                               nState, aValue, rControlHandle, rCaption );
+                               nState, aValue, rCaption );
 
         // Buttons must paint opaque since some themes have alpha-channel enabled buttons
         gtk_paint_flat_box( gWidgetData[m_nScreen].gBtnWidget->style, gdkDrawable, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
@@ -2247,7 +2234,6 @@ static Rectangle NWGetComboBoxButtonRect( int nScreen,
                                           Rectangle             aAreaRect,
                                           ControlState,
                                           const ImplControlValue&,
-                                          SalControlHandle&,
                                           const OUString& )
 {
     Rectangle   aButtonRect;
@@ -2302,7 +2288,7 @@ BOOL GtkSalGraphics::NWPaintGTKTabItem( ControlType nType, ControlPart,
                                         const clipList&,
                                         ControlState nState,
                                         const ImplControlValue& aValue,
-                                        SalControlHandle&, const OUString& )
+                                        const OUString& )
 {
     GdkPixmap * pixmap;
     Rectangle       pixmapRect;
@@ -2444,7 +2430,7 @@ BOOL GtkSalGraphics::NWPaintGTKListBox( GdkDrawable* gdkDrawable,
                                         const clipList& rClipList,
                                         ControlState nState,
                                         const ImplControlValue& aValue,
-                                        SalControlHandle& rControlHandle, const OUString& rCaption )
+                                        const OUString& rCaption )
 {
     Rectangle       pixmapRect;
     Rectangle       widgetRect;
@@ -2511,7 +2497,7 @@ BOOL GtkSalGraphics::NWPaintGTKListBox( GdkDrawable* gdkDrawable,
                            y+(widgetRect.Top() - pixmapRect.Top()),
                            widgetRect.GetWidth(), widgetRect.GetHeight() );
             aIndicatorRect = NWGetListBoxIndicatorRect( m_nScreen, nType, nPart, widgetRect, nState,
-                                                        aValue, rControlHandle, rCaption );
+                                                        aValue, rCaption );
             gtk_paint_tab( gWidgetData[m_nScreen].gOptionMenuWidget->style, gdkDrawable, stateType, shadowType, &clipRect,
                            gWidgetData[m_nScreen].gOptionMenuWidget, "optionmenutab",
                            x+(aIndicatorRect.Left() - pixmapRect.Left()),
@@ -2538,7 +2524,7 @@ BOOL GtkSalGraphics::NWPaintGTKToolbar(
             const Rectangle& rControlRectangle,
             const clipList& rClipList,
             ControlState nState, const ImplControlValue& aValue,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     GtkStateType    stateType;
     GtkShadowType   shadowType;
@@ -2685,7 +2671,7 @@ BOOL GtkSalGraphics::NWPaintGTKMenubar(
             const Rectangle& rControlRectangle,
             const clipList& rClipList,
             ControlState nState, const ImplControlValue&,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     GtkStateType    stateType;
     GtkShadowType   shadowType;
@@ -2770,7 +2756,7 @@ BOOL GtkSalGraphics::NWPaintGTKPopupMenu(
             const Rectangle& rControlRectangle,
             const clipList& rClipList,
             ControlState nState, const ImplControlValue&,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     // #i50745# gtk does not draw disabled menu entries (and crux theme
     // even crashes), draw them using vcl functionality.
@@ -2900,7 +2886,7 @@ BOOL GtkSalGraphics::NWPaintGTKTooltip(
             const Rectangle& rControlRectangle,
             const clipList& rClipList,
             ControlState, const ImplControlValue&,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     NWEnsureGTKTooltip( m_nScreen );
 
@@ -2938,7 +2924,7 @@ BOOL GtkSalGraphics::NWPaintGTKListNode(
             const Rectangle& rControlRectangle,
             const clipList&,
             ControlState nState, const ImplControlValue& rValue,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     NWEnsureGTKTreeView( m_nScreen );
 
@@ -2992,7 +2978,7 @@ BOOL GtkSalGraphics::NWPaintGTKProgress(
             const Rectangle& rControlRectangle,
             const clipList&,
             ControlState, const ImplControlValue& rValue,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     NWEnsureGTKProgressBar( m_nScreen );
 
@@ -3056,7 +3042,7 @@ BOOL GtkSalGraphics::NWPaintGTKSlider(
             const Rectangle& rControlRectangle,
             const clipList&,
             ControlState nState, const ImplControlValue& rValue,
-            SalControlHandle&, const OUString& )
+            const OUString& )
 {
     NWEnsureGTKSlider( m_nScreen );
 
@@ -3185,7 +3171,6 @@ static Rectangle NWGetListBoxButtonRect( int nScreen,
                                          Rectangle      aAreaRect,
                                          ControlState,
                                          const ImplControlValue&,
-                                         SalControlHandle&,
                                          const OUString& )
 {
     Rectangle       aPartRect;
@@ -3248,7 +3233,6 @@ static Rectangle NWGetListBoxIndicatorRect( int nScreen,
                                             Rectangle               aAreaRect,
                                             ControlState,
                                             const ImplControlValue&,
-                                            SalControlHandle&,
                                             const OUString& )
 {
     Rectangle       aIndicatorRect;
@@ -3295,7 +3279,6 @@ static Rectangle NWGetToolbarRect(  int nScreen,
                                     Rectangle               aAreaRect,
                                     ControlState,
                                     const ImplControlValue&,
-                                    SalControlHandle&,
                                     const OUString& )
 {
     Rectangle aRet;
@@ -3471,11 +3454,11 @@ void GtkSalGraphics::updateSettings( AllSettings& rSettings )
     aBackColor = getColor( pMenubarStyle->bg[GTK_STATE_NORMAL] );
     aStyleSet.SetMenuBarColor( aBackColor );
     aBackColor = getColor( pMenuStyle->bg[GTK_STATE_NORMAL] );
-    aTextColor = getColor( pMenuTextStyle->text[GTK_STATE_NORMAL] );
+    aTextColor = getColor( pMenuTextStyle->fg[GTK_STATE_NORMAL] );
     aStyleSet.SetMenuColor( aBackColor );
     aStyleSet.SetMenuTextColor( aTextColor );
 
-    aTextColor = getColor( pMenubarStyle->text[GTK_STATE_NORMAL] );
+    aTextColor = getColor( pMenubarStyle->fg[GTK_STATE_NORMAL] );
     aStyleSet.SetMenuBarTextColor( aTextColor );
 
 #if OSL_DEBUG_LEVEL > 1
diff --git a/vcl/unx/gtk/window/gtkframe.cxx b/vcl/unx/gtk/window/gtkframe.cxx
index 3d11ce8a37ea..11d567c85098 100644
--- a/vcl/unx/gtk/window/gtkframe.cxx
+++ b/vcl/unx/gtk/window/gtkframe.cxx
@@ -1353,15 +1353,11 @@ void GtkSalFrame::Show( BOOL bVisible, BOOL bNoActivate )
             //
             // i.e. having a time < that of the toplevel frame means that the toplevel frame gets unfocused.
             // awesome.
-            bool bMetaCity = getDisplay()->getWMAdaptor()->getWindowManagerName().EqualsAscii("Metacity");
-            if( nUserTime == 0 &&
-               ( bMetaCity ||
-                 (
-                    getDisplay()->getWMAdaptor()->getWindowManagerName().EqualsAscii("compiz") &&
-                    (m_nStyle & (SAL_FRAME_STYLE_OWNERDRAWDECORATION))
-                 )
-               )
-              )
+            bool bHack =
+                getDisplay()->getWMAdaptor()->getWindowManagerName().EqualsAscii("Metacity") ||
+                getDisplay()->getWMAdaptor()->getWindowManagerName().EqualsAscii("compiz")
+                ;
+            if( nUserTime == 0 && bHack )
             {
                 /* #i99360# ugly workaround an X11 library bug */
                 nUserTime= getDisplay()->GetLastUserEventTime( true );
@@ -1369,7 +1365,7 @@ void GtkSalFrame::Show( BOOL bVisible, BOOL bNoActivate )
             }
             lcl_set_user_time( GTK_WIDGET(m_pWindow)->window, nUserTime );
 
-            if( bMetaCity && ! bNoActivate && (m_nStyle & SAL_FRAME_STYLE_TOOLWINDOW) )
+            if( bHack && ! bNoActivate && (m_nStyle & SAL_FRAME_STYLE_TOOLWINDOW) )
                 m_bSetFocusOnMap = true;
 
             gtk_widget_show( m_pWindow );
@@ -3240,7 +3236,8 @@ GtkSalFrame::IMHandler::IMHandler( GtkSalFrame* pFrame )
 : m_pFrame(pFrame),
   m_nPrevKeyPresses( 0 ),
   m_pIMContext( NULL ),
-  m_bFocused( true )
+  m_bFocused( true ),
+  m_bPreeditJustChanged( false )
 {
     m_aInputEvent.mpTextAttr = NULL;
     createIMContext();
@@ -3415,6 +3412,8 @@ bool GtkSalFrame::IMHandler::handleKeyEvent( GdkEventKey* pEvent )
         if( aDel.isDeleted() )
             return true;
 
+        m_bPreeditJustChanged = false;
+
         if( bResult )
             return true;
         else
@@ -3444,6 +3443,8 @@ bool GtkSalFrame::IMHandler::handleKeyEvent( GdkEventKey* pEvent )
         if( aDel.isDeleted() )
             return true;
 
+        m_bPreeditJustChanged = false;
+
         std::list<PreviousKeyPress>::iterator    iter     = m_aPrevKeyPresses.begin();
         std::list<PreviousKeyPress>::iterator    iter_end = m_aPrevKeyPresses.end();
         while (iter != iter_end)
@@ -3507,8 +3508,6 @@ void GtkSalFrame::IMHandler::signalIMCommit( GtkIMContext* CONTEXT_ARG, gchar* p
     {
         GTK_YIELD_GRAB();
 
-        bool bWasPreedit = (pThis->m_aInputEvent.mpTextAttr != 0);
-
         pThis->m_aInputEvent.mnTime             = 0;
         pThis->m_aInputEvent.mpTextAttr         = 0;
         pThis->m_aInputEvent.maText             = String( pText, RTL_TEXTENCODING_UTF8 );
@@ -3532,6 +3531,9 @@ void GtkSalFrame::IMHandler::signalIMCommit( GtkIMContext* CONTEXT_ARG, gchar* p
          *  or because there never was a preedit.
          */
         bool bSingleCommit = false;
+        bool bWasPreedit =
+            (pThis->m_aInputEvent.mpTextAttr != 0) ||
+            pThis->m_bPreeditJustChanged;
         if( ! bWasPreedit
             && pThis->m_aInputEvent.maText.Len() == 1
             && ! pThis->m_aPrevKeyPresses.empty()
@@ -3546,7 +3548,6 @@ void GtkSalFrame::IMHandler::signalIMCommit( GtkIMContext* CONTEXT_ARG, gchar* p
                 bSingleCommit = true;
             }
         }
-
         if( ! bSingleCommit )
         {
             pThis->m_pFrame->CallCallback( SALEVENT_EXTTEXTINPUT, (void*)&pThis->m_aInputEvent);
@@ -3594,6 +3595,8 @@ void GtkSalFrame::IMHandler::signalIMPreeditChanged( GtkIMContext*, gpointer im_
         }
     }
 
+    pThis->m_bPreeditJustChanged = true;
+
     bool bEndPreedit = (!pText || !*pText) && pThis->m_aInputEvent.mpTextAttr != NULL;
     pThis->m_aInputEvent.mnTime             = 0;
     pThis->m_aInputEvent.maText             = String( pText, RTL_TEXTENCODING_UTF8 );
@@ -3677,6 +3680,8 @@ void GtkSalFrame::IMHandler::signalIMPreeditEnd( GtkIMContext*, gpointer im_hand
     GtkSalFrame::IMHandler* pThis = (GtkSalFrame::IMHandler*)im_handler;
     GTK_YIELD_GRAB();
 
+    pThis->m_bPreeditJustChanged = true;
+
     vcl::DeletionListener aDel( pThis->m_pFrame );
     pThis->doCallEndExtTextInput();
     if( ! aDel.isDeleted() )
diff --git a/vcl/unx/inc/plugins/gtk/gtkframe.hxx b/vcl/unx/inc/plugins/gtk/gtkframe.hxx
index 88a26b401eed..18dd476fc2c4 100644
--- a/vcl/unx/inc/plugins/gtk/gtkframe.hxx
+++ b/vcl/unx/inc/plugins/gtk/gtkframe.hxx
@@ -130,6 +130,7 @@ class GtkSalFrame : public SalFrame
         int                             m_nPrevKeyPresses; // avoid using size()
         GtkIMContext*                   m_pIMContext;
         bool                            m_bFocused;
+        bool                            m_bPreeditJustChanged;
         SalExtTextInputEvent            m_aInputEvent;
         std::vector< USHORT >           m_aInputFlags;
 
diff --git a/vcl/unx/inc/plugins/gtk/gtkgdi.hxx b/vcl/unx/inc/plugins/gtk/gtkgdi.hxx
index ed3f782c8576..065b5435eeb0 100644
--- a/vcl/unx/inc/plugins/gtk/gtkgdi.hxx
+++ b/vcl/unx/inc/plugins/gtk/gtkgdi.hxx
@@ -64,15 +64,15 @@ public:
     // native widget methods
     virtual BOOL        IsNativeControlSupported( ControlType nType, ControlPart nPart );
     virtual BOOL        hitTestNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                              const Point& aPos, SalControlHandle& rControlHandle, BOOL& rIsInside );
+                                              const Point& aPos, BOOL& rIsInside );
     virtual BOOL        drawNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                           ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                           ControlState nState, const ImplControlValue& aValue,
                                            const rtl::OUString& rCaption );
     virtual BOOL        drawNativeControlText( ControlType nType, ControlPart nPart, const Region& rControlRegion,
                                                ControlState nState, const ImplControlValue& aValue,
-                                               SalControlHandle& rControlHandle, const rtl::OUString& rCaption );
+                                               const rtl::OUString& rCaption );
     virtual BOOL        getNativeControlRegion( ControlType nType, ControlPart nPart, const Region& rControlRegion, ControlState nState,
-                                                const ImplControlValue& aValue, SalControlHandle& rControlHandle, const rtl::OUString& rCaption,
+                                                const ImplControlValue& aValue, const rtl::OUString& rCaption,
                                                 Region &rNativeBoundingRegion, Region &rNativeContentRegion );
 
     //helper methods for frame's UpdateSettings
@@ -101,86 +101,86 @@ protected:
                            const Rectangle& rControlRectangle,
                            const clipList& rClipList,
                            ControlState nState, const ImplControlValue& aValue,
-                           SalControlHandle& rControlHandle, const OUString& rCaption );
+                           const OUString& rCaption );
     BOOL NWPaintGTKRadio( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                           const Rectangle& rControlRectangle,
                           const clipList& rClipList,
                           ControlState nState, const ImplControlValue& aValue,
-                          SalControlHandle& rControlHandle, const OUString& rCaption );
+                          const OUString& rCaption );
     BOOL NWPaintGTKCheck( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                           const Rectangle& rControlRectangle,
                           const clipList& rClipList,
                           ControlState nState, const ImplControlValue& aValue,
-                          SalControlHandle& rControlHandle, const OUString& rCaption );
+                          const OUString& rCaption );
     BOOL NWPaintGTKScrollbar( ControlType nType, ControlPart nPart,
                               const Rectangle& rControlRectangle,
                               const clipList& rClipList,
                               ControlState nState, const ImplControlValue& aValue,
-                              SalControlHandle& rControlHandle, const OUString& rCaption );
+                              const OUString& rCaption );
     BOOL NWPaintGTKEditBox( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
     BOOL NWPaintGTKSpinBox( ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
     BOOL NWPaintGTKComboBox( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                              const Rectangle& rControlRectangle,
                              const clipList& rClipList,
                              ControlState nState, const ImplControlValue& aValue,
-                             SalControlHandle& rControlHandle, const OUString& rCaption );
+                             const OUString& rCaption );
     BOOL NWPaintGTKTabItem( ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
     BOOL NWPaintGTKListBox( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
 
     BOOL NWPaintGTKToolbar( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
     BOOL NWPaintGTKMenubar( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
     BOOL NWPaintGTKPopupMenu( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                               const Rectangle& rControlRectangle,
                               const clipList& rClipList,
                               ControlState nState, const ImplControlValue& aValue,
-                              SalControlHandle& rControlHandle, const OUString& rCaption );
+                              const OUString& rCaption );
     BOOL NWPaintGTKTooltip( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
     BOOL NWPaintGTKProgress( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
     BOOL NWPaintGTKSlider( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                            const Rectangle& rControlRectangle,
                            const clipList& rClipList,
                            ControlState nState, const ImplControlValue& aValue,
-                           SalControlHandle& rControlHandle, const OUString& rCaption );
+                           const OUString& rCaption );
     BOOL NWPaintGTKListNode( GdkDrawable* gdkDrawable, ControlType nType, ControlPart nPart,
                             const Rectangle& rControlRectangle,
                             const clipList& rClipList,
                             ControlState nState, const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle, const OUString& rCaption );
+                            const OUString& rCaption );
 
     BOOL drawNativeMixedStateCheck( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                    ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                    ControlState nState, const ImplControlValue& aValue,
                                     const rtl::OUString& rCaption );
 };
 
diff --git a/vcl/unx/inc/saldisp.hxx b/vcl/unx/inc/saldisp.hxx
index e54d6e828911..3734cbec6ef7 100644
--- a/vcl/unx/inc/saldisp.hxx
+++ b/vcl/unx/inc/saldisp.hxx
@@ -231,6 +231,7 @@ protected:
         XErrorHandler   m_aHandler;
     };
     std::vector< XErrorStackEntry > m_aXErrorHandlerStack;
+    XIOErrorHandler m_aOrigXIOErrorHandler;
 public:
     SalXLib();
     virtual         ~SalXLib();
diff --git a/vcl/unx/inc/salgdi.h b/vcl/unx/inc/salgdi.h
index da69f04b6f8f..6ccea2c4a00c 100644
--- a/vcl/unx/inc/salgdi.h
+++ b/vcl/unx/inc/salgdi.h
@@ -57,6 +57,10 @@ class   ImplLayoutArgs;
 class   X11FontLayout;
 class   ServerFontLayout;
 
+namespace basegfx {
+    class B2DTrapezoid;
+}
+
 // -=-= SalGraphicsData =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 class CairoFontsCache
@@ -289,8 +293,11 @@ public:
     virtual void            drawPolyPolygon( sal_uInt32 nPoly,
                                              const sal_uInt32* pPoints,
                                              PCONSTSALPOINT* pPtAry );
-    virtual bool            drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rPolyPolygon, double fTransparency );
-    virtual bool            drawPolyLine( const ::basegfx::B2DPolygon& rPolygon, const ::basegfx::B2DVector& rLineWidth, basegfx::B2DLineJoin);
+    virtual bool            drawPolyPolygon( const ::basegfx::B2DPolyPolygon&, double fTransparency );
+    virtual bool            drawPolyLine( const ::basegfx::B2DPolygon&, const ::basegfx::B2DVector& rLineWidth, basegfx::B2DLineJoin );
+    virtual bool            drawFilledTrapezoids( const ::basegfx::B2DTrapezoid*, int nTrapCount, double fTransparency );
+
+#if 1 // TODO: remove these obselete methods
     virtual sal_Bool        drawPolyLineBezier( ULONG nPoints,
                                                 const SalPoint* pPtAry,
                                                 const BYTE* pFlgAry );
@@ -301,6 +308,8 @@ public:
                                                    const sal_uInt32* pPoints,
                                                    const SalPoint* const* pPtAry,
                                                    const BYTE* const* pFlgAry );
+#endif
+
     virtual void            copyArea( long nDestX,
                                       long nDestY,
                                       long nSrcX,
diff --git a/vcl/unx/kde/kdedata.cxx b/vcl/unx/kde/kdedata.cxx
index 5e2801e47fc6..34b0ff652cde 100644
--- a/vcl/unx/kde/kdedata.cxx
+++ b/vcl/unx/kde/kdedata.cxx
@@ -182,9 +182,6 @@ void KDEXLib::Init()
 
     SalDisplay *pSalDisplay = new SalKDEDisplay( pDisp );
 
-    XSetIOErrorHandler    ( (XIOErrorHandler)X11SalData::XIOErrorHdl );
-    XSetErrorHandler      ( (XErrorHandler)X11SalData::XErrorHdl );
-
     pInputMethod->CreateMethod( pDisp );
     pInputMethod->AddConnectionWatch( pDisp, (void*)this );
     pSalDisplay->SetInputMethod( pInputMethod );
diff --git a/vcl/unx/kde/salnativewidgets-kde.cxx b/vcl/unx/kde/salnativewidgets-kde.cxx
index ea9161235ac9..3adc9f5c679a 100644
--- a/vcl/unx/kde/salnativewidgets-kde.cxx
+++ b/vcl/unx/kde/salnativewidgets-kde.cxx
@@ -1177,18 +1177,18 @@ class KDESalGraphics : public X11SalGraphics
     virtual BOOL IsNativeControlSupported( ControlType nType, ControlPart nPart );
     virtual BOOL hitTestNativeControl( ControlType nType, ControlPart nPart,
                                        const Region& rControlRegion, const Point& aPos,
-                                       SalControlHandle& rControlHandle, BOOL& rIsInside );
+                                       BOOL& rIsInside );
     virtual BOOL drawNativeControl( ControlType nType, ControlPart nPart,
                                     const Region& rControlRegion, ControlState nState,
-                                    const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                    const ImplControlValue& aValue,
                                     const OUString& aCaption );
     virtual BOOL drawNativeControlText( ControlType nType, ControlPart nPart,
                                         const Region& rControlRegion, ControlState nState,
-                                        const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                        const ImplControlValue& aValue,
                                         const OUString& aCaption );
     virtual BOOL getNativeControlRegion( ControlType nType, ControlPart nPart,
                                          const Region& rControlRegion, ControlState nState,
-                                         const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                         const ImplControlValue& aValue,
                                          const OUString& aCaption,
                                          Region &rNativeBoundingRegion, Region &rNativeContentRegion );
 };
@@ -1242,7 +1242,7 @@ BOOL KDESalGraphics::IsNativeControlSupported( ControlType nType, ControlPart nP
 */
 BOOL KDESalGraphics::hitTestNativeControl( ControlType nType, ControlPart nPart,
                                            const Region& rControlRegion, const Point& rPos,
-                                           SalControlHandle&, BOOL& rIsInside )
+                                           BOOL& rIsInside )
 {
     if ( nType == CTRL_SCROLLBAR )
     {
@@ -1344,15 +1344,12 @@ BOOL KDESalGraphics::hitTestNativeControl( ControlType nType, ControlPart nPart,
     @param aValue
     An optional value (tristate/numerical/string).
 
-    @param rControlHandle
-    Carries platform dependent data and is maintained by the SalFrame implementation.
-
     @param aCaption
     A caption or title string (like button text etc.)
 */
 BOOL KDESalGraphics::drawNativeControl( ControlType nType, ControlPart nPart,
                                         const Region& rControlRegion, ControlState nState,
-                                        const ImplControlValue& aValue, SalControlHandle&,
+                                        const ImplControlValue& aValue,
                                         const OUString& )
 {
     BOOL bReturn = FALSE;
@@ -1489,15 +1486,12 @@ BOOL KDESalGraphics::drawNativeControl( ControlType nType, ControlPart nPart,
     @param aValue
     An optional value (tristate/numerical/string)
 
-    @param rControlHandle
-    Carries platform dependent data and is maintained by the SalFrame implementation.
-
     @param aCaption
     A caption or title string (like button text etc.)
 */
 BOOL KDESalGraphics::drawNativeControlText( ControlType, ControlPart,
                                             const Region&, ControlState,
-                                            const ImplControlValue&, SalControlHandle&,
+                                            const ImplControlValue&,
                                             const OUString& )
 {
     return FALSE;
@@ -1517,15 +1511,12 @@ BOOL KDESalGraphics::drawNativeControlText( ControlType, ControlPart,
     @param aValue
     An optional value (tristate/numerical/string)
 
-    @param rControlHandle
-    Carries platform dependent data and is maintained by the SalFrame implementation.
-
     @param aCaption
     A caption or title string (like button text etc.)
 */
 BOOL KDESalGraphics::getNativeControlRegion( ControlType nType, ControlPart nPart,
                                              const Region& rControlRegion, ControlState nState,
-                                             const ImplControlValue&, SalControlHandle&,
+                                             const ImplControlValue&,
                                              const OUString&,
                                              Region &rNativeBoundingRegion, Region &rNativeContentRegion )
 {
diff --git a/vcl/unx/kde4/KDESalGraphics.cxx b/vcl/unx/kde4/KDESalGraphics.cxx
index 25dd50ce3958..5f8b5d2ae59e 100644
--- a/vcl/unx/kde4/KDESalGraphics.cxx
+++ b/vcl/unx/kde4/KDESalGraphics.cxx
@@ -158,7 +158,7 @@ BOOL KDESalGraphics::IsNativeControlSupported( ControlType type, ControlPart par
 
 BOOL KDESalGraphics::hitTestNativeControl( ControlType, ControlPart,
                                            const Region&, const Point&,
-                                           SalControlHandle&, BOOL& )
+                                           BOOL& )
 {
     return FALSE;
 }
@@ -220,7 +220,7 @@ namespace
 
 BOOL KDESalGraphics::drawNativeControl( ControlType type, ControlPart part,
                                         const Region& rControlRegion, ControlState nControlState,
-                                        const ImplControlValue& value, SalControlHandle&,
+                                        const ImplControlValue& value,
                                         const OUString& )
 {
     // put not implemented types here
@@ -567,7 +567,7 @@ BOOL KDESalGraphics::drawNativeControl( ControlType type, ControlPart part,
 
 BOOL KDESalGraphics::getNativeControlRegion( ControlType type, ControlPart part,
                                              const Region& controlRegion, ControlState controlState,
-                                             const ImplControlValue& val, SalControlHandle&,
+                                             const ImplControlValue& val,
                                              const OUString&,
                                              Region &nativeBoundingRegion, Region &nativeContentRegion )
 {
@@ -744,7 +744,7 @@ BOOL KDESalGraphics::getNativeControlRegion( ControlType type, ControlPart part,
         {
             if( part == PART_BORDER )
             {
-                int size = kapp->style()->pixelMetric(QStyle::PM_LayoutLeftMargin);
+                int size = kapp->style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
                 USHORT nStyle = val.getNumericVal();
                 if( nStyle & FRAME_DRAW_NODRAW )
                 {
diff --git a/vcl/unx/kde4/KDESalGraphics.hxx b/vcl/unx/kde4/KDESalGraphics.hxx
index b5328f462a16..5661d743e0cd 100644
--- a/vcl/unx/kde4/KDESalGraphics.hxx
+++ b/vcl/unx/kde4/KDESalGraphics.hxx
@@ -59,7 +59,7 @@ class KDESalGraphics : public X11SalGraphics
         */
         virtual BOOL hitTestNativeControl( ControlType type, ControlPart part,
                                         const Region& rControlRegion, const Point& aPos,
-                                        SalControlHandle& rControlHandle, BOOL& rIsInside );
+                                        BOOL& rIsInside );
         /** Draw the requested control described by part/nControlState.
 
             @param rControlRegion
@@ -68,15 +68,12 @@ class KDESalGraphics : public X11SalGraphics
             @param aValue
             An optional value (tristate/numerical/string).
 
-            @param rControlHandle
-            Carries platform dependent data and is maintained by the SalFrame implementation.
-
             @param aCaption
             A caption or title string (like button text etc.)
         */
         virtual BOOL drawNativeControl( ControlType type, ControlPart part,
                                         const Region& rControlRegion, ControlState nControlState,
-                                        const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                        const ImplControlValue& aValue,
                                         const rtl::OUString& aCaption );
 
         /** Draw text on the widget.
@@ -85,12 +82,11 @@ class KDESalGraphics : public X11SalGraphics
 
             @param rControlRegion The bounding region of the complete control in VCL frame coordinates.
             @param aValue An optional value (tristate/numerical/string)
-            @param rControlHandle Carries platform dependent data and is maintained by the SalFrame implementation.
             @param aCaption A caption or title string (like button text etc.)
         */
         virtual BOOL drawNativeControlText( ControlType, ControlPart,
                                             const Region&, ControlState,
-                                            const ImplControlValue&, SalControlHandle&,
+                                            const ImplControlValue&,
                                             const rtl::OUString& ) { return false; }
         /** Check if the bounding regions match.
 
@@ -106,15 +102,12 @@ class KDESalGraphics : public X11SalGraphics
             @param aValue
             An optional value (tristate/numerical/string)
 
-            @param rControlHandle
-            Carries platform dependent data and is maintained by the SalFrame implementation.
-
             @param aCaption
             A caption or title string (like button text etc.)
         */
         virtual BOOL getNativeControlRegion( ControlType type, ControlPart part,
                                             const Region& rControlRegion, ControlState nControlState,
-                                            const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                            const ImplControlValue& aValue,
                                             const rtl::OUString& aCaption,
                                             Region &rNativeBoundingRegion, Region &rNativeContentRegion );
 };
\ No newline at end of file
diff --git a/vcl/unx/kde4/KDEXLib.cxx b/vcl/unx/kde4/KDEXLib.cxx
index 2e5b86b79f9c..6a2793b8abe3 100644
--- a/vcl/unx/kde4/KDEXLib.cxx
+++ b/vcl/unx/kde4/KDEXLib.cxx
@@ -148,9 +148,6 @@ void KDEXLib::Init()
 
     ((VCLKDEApplication*)m_pApplication)->disp = pSalDisplay;
 
-    XSetIOErrorHandler    ( (XIOErrorHandler)X11SalData::XIOErrorHdl );
-    XSetErrorHandler      ( (XErrorHandler)X11SalData::XErrorHdl );
-
     pInputMethod->CreateMethod( pDisp );
     pInputMethod->AddConnectionWatch( pDisp, (void*)this );
     pSalDisplay->SetInputMethod( pInputMethod );
@@ -175,4 +172,4 @@ void KDEXLib::doStartup()
         fprintf( stderr, "called KStartupInfo::appStarted()\n" );
         #endif
     }
-}
\ No newline at end of file
+}
diff --git a/vcl/unx/source/app/saldata.cxx b/vcl/unx/source/app/saldata.cxx
index 75d18de0787a..50ef71df8619 100644
--- a/vcl/unx/source/app/saldata.cxx
+++ b/vcl/unx/source/app/saldata.cxx
@@ -353,8 +353,9 @@ SalXLib::SalXLib()
         nFDs_ = m_pTimeoutFDS[0] + 1;
     }
 
-    PushXErrorLevel( !!getenv( "SAL_IGNOREXERRORS" ) );
     m_bHaveSystemChildFrames        = false;
+    m_aOrigXIOErrorHandler = XSetIOErrorHandler ( (XIOErrorHandler)X11SalData::XIOErrorHdl );
+    PushXErrorLevel( !!getenv( "SAL_IGNOREXERRORS" ) );
 }
 
 SalXLib::~SalXLib()
@@ -364,6 +365,7 @@ SalXLib::~SalXLib()
     close (m_pTimeoutFDS[1]);
 
     PopXErrorLevel();
+    XSetIOErrorHandler (m_aOrigXIOErrorHandler);
 }
 
 void SalXLib::PushXErrorLevel( bool bIgnore )
@@ -459,8 +461,6 @@ void SalXLib::Init()
         exit(0);
     }
 
-    XSetIOErrorHandler    ( (XIOErrorHandler)X11SalData::XIOErrorHdl );
-
     SalDisplay *pSalDisplay = new SalX11Display( pDisp );
 
     pInputMethod->CreateMethod( pDisp );
diff --git a/vcl/unx/source/fontmanager/fontconfig.cxx b/vcl/unx/source/fontmanager/fontconfig.cxx
index bc6de4fbc94a..816c8fb0b4c4 100644
--- a/vcl/unx/source/fontmanager/fontconfig.cxx
+++ b/vcl/unx/source/fontmanager/fontconfig.cxx
@@ -123,6 +123,8 @@ class FontCfgWrapper
     FcPattern*      (*m_pFcFontSetMatch)(FcConfig*,FcFontSet**, int, FcPattern*,FcResult*);
     FcBool          (*m_pFcConfigAppFontAddFile)(FcConfig*, const FcChar8*);
     FcBool          (*m_pFcConfigAppFontAddDir)(FcConfig*, const FcChar8*);
+    FcBool          (*m_pFcConfigParseAndLoad)(FcConfig*,const FcChar8*,FcBool);
+
     FcBool          (*m_pFcConfigSubstitute)(FcConfig*,FcPattern*,FcMatchKind);
     FcBool          (*m_pFcPatternAddInteger)(FcPattern*,const char*,int);
     FcBool                    (*m_pFcPatternAddDouble)(FcPattern*,const char*,double);
@@ -221,6 +223,9 @@ public:
     { return m_pFcConfigAppFontAddFile( pConfig, pFileName ); }
     FcBool FcConfigAppFontAddDir(FcConfig* pConfig, const FcChar8* pDirName )
     { return m_pFcConfigAppFontAddDir( pConfig, pDirName ); }
+    FcBool FcConfigParseAndLoad( FcConfig* pConfig, const FcChar8* pFileName, FcBool bComplain )
+    { return m_pFcConfigParseAndLoad( pConfig, pFileName, bComplain ); }
+
     void FcDefaultSubstitute( FcPattern* pPattern )
     { m_pFcDefaultSubstitute( pPattern ); }
     FcPattern* FcFontSetMatch( FcConfig* pConfig, FcFontSet **ppFontSet, int nset, FcPattern* pPattern, FcResult* pResult )
@@ -326,6 +331,8 @@ FontCfgWrapper::FontCfgWrapper()
         loadSymbol( "FcConfigAppFontAddFile" );
     m_pFcConfigAppFontAddDir = (FcBool(*)(FcConfig*, const FcChar8*))
         loadSymbol( "FcConfigAppFontAddDir" );
+    m_pFcConfigParseAndLoad = (FcBool(*)(FcConfig*, const FcChar8*, FcBool))
+        loadSymbol( "FcConfigParseAndLoad" );
     m_pFcDefaultSubstitute = (void(*)(FcPattern *))
         loadSymbol( "FcDefaultSubstitute" );
     m_pFcFontSetMatch = (FcPattern*(*)(FcConfig*,FcFontSet**,int,FcPattern*,FcResult*))
@@ -383,6 +390,7 @@ FontCfgWrapper::FontCfgWrapper()
             m_pFcPatternGetBool             &&
             m_pFcConfigAppFontAddFile               &&
             m_pFcConfigAppFontAddDir                &&
+            m_pFcConfigParseAndLoad             &&
             m_pFcDefaultSubstitute          &&
             m_pFcConfigSubstitute           &&
             m_pFcPatternAddInteger          &&
@@ -767,10 +775,14 @@ int PrintFontManager::countFontconfigFonts( std::hash_map<rtl::OString, int, rtl
                 // set family name
                 if( pUpdate->m_nFamilyName != nFamilyName )
                 {
+#if 0 // fontconfig prefers nameid=16 for the family name which is all fine
+      // but Writer suffers from #i79878#
+      // the only reasonable workaround for now is to use the classic nameid=1
                     pUpdate->m_aAliases.remove( pUpdate->m_nFamilyName );
                     pUpdate->m_aAliases.push_back( pUpdate->m_nFamilyName );
                     pUpdate->m_aAliases.remove( nFamilyName );
                     pUpdate->m_nFamilyName = nFamilyName;
+#endif
                 }
                 if( eWeightRes == FcResultMatch )
                     pUpdate->m_eWeight = convertWeight(weight);
@@ -836,13 +848,25 @@ bool PrintFontManager::addFontconfigDir( const rtl::OString& rDirName )
     if( nVersion <= 20400 )
         return false;
     const char* pDirName = (const char*)rDirName.getStr();
-    bool bRet = (rWrapper.FcConfigAppFontAddDir( rWrapper.FcConfigGetCurrent(), (FcChar8*)pDirName ) == FcTrue);
+    bool bDirOk = (rWrapper.FcConfigAppFontAddDir( rWrapper.FcConfigGetCurrent(), (FcChar8*)pDirName ) == FcTrue);
 
 #if OSL_DEBUG_LEVEL > 1
     fprintf( stderr, "FcConfigAppFontAddDir( \"%s\") => %d\n", pDirName, bRet );
 #endif
 
-    return bRet;
+    if( bDirOk )
+    {
+        const rtl::OString aConfFileName = rDirName + "/fc_local.conf";
+        bool bCfgOk = rWrapper.FcConfigParseAndLoad( rWrapper.FcConfigGetCurrent(),
+                            (FcChar8*)aConfFileName.getStr(), FcTrue );
+        (void)bCfgOk; // silence compiler warning
+
+#if OSL_DEBUG_LEVEL > 1
+        fprintf( stderr, "FcConfigParseAndLoad( \"%s\") => %d\n", aConfFileName.getStr(), bCfgOk );
+#endif
+    }
+
+    return bDirOk;
 }
 
 static void addtopattern(FontCfgWrapper& rWrapper, FcPattern *pPattern,
diff --git a/vcl/unx/source/fontmanager/fontmanager.cxx b/vcl/unx/source/fontmanager/fontmanager.cxx
index 93e3eef53ab3..21183dc567ec 100644
--- a/vcl/unx/source/fontmanager/fontmanager.cxx
+++ b/vcl/unx/source/fontmanager/fontmanager.cxx
@@ -40,6 +40,7 @@
 #include "vcl/fontcache.hxx"
 #include "vcl/fontcache.hxx"
 #include "vcl/fontsubset.hxx"
+#include "vcl/impfont.hxx"
 #include "vcl/strhelper.hxx"
 #include "vcl/ppdparser.hxx"
 #include "vcl/svdata.hxx"
@@ -3795,6 +3796,35 @@ void PrintFontManager::getGlyphWidths( fontID nFont,
                 free( pMetrics );
                 rUnicodeEnc.clear();
             }
+
+            // fill the unicode map
+            // TODO: isn't this map already available elsewhere in the fontmanager?
+            const sal_uInt8* pCmapData = NULL;
+            int nCmapSize = 0;
+            if( GetSfntTable( pTTFont, O_cmap, &pCmapData, &nCmapSize ) )
+            {
+                CmapResult aCmapResult;
+                if( ParseCMAP( pCmapData, nCmapSize, aCmapResult ) )
+                {
+                    const ImplFontCharMap aCharMap( aCmapResult );
+                    for( sal_uInt32 cOld = 0;;)
+                    {
+                        // get next unicode covered by font
+                        const sal_uInt32 c = aCharMap.GetNextChar( cOld );
+                        if( c == cOld )
+                            break;
+                        cOld = c;
+#if 1 // TODO: remove when sal_Unicode covers all of unicode
+                        if( c > (sal_Unicode)~0 )
+                            break;
+#endif
+                        // get the matching glyph index
+                        const sal_uInt32 nGlyphId = aCharMap.GetGlyphIndex( c );
+                        // update the requested map
+                        rUnicodeEnc[ (sal_Unicode)c ] = nGlyphId;
+                    }
+                }
+            }
         }
         CloseTTFont( pTTFont );
     }
diff --git a/vcl/unx/source/gdi/salgdi.cxx b/vcl/unx/source/gdi/salgdi.cxx
index 7637d3b2bd02..15e391256344 100644
--- a/vcl/unx/source/gdi/salgdi.cxx
+++ b/vcl/unx/source/gdi/salgdi.cxx
@@ -50,8 +50,9 @@
 #include "basegfx/polygon/b2dpolygonclipper.hxx"
 #include "basegfx/polygon/b2dlinegeometry.hxx"
 #include "basegfx/matrix/b2dhommatrix.hxx"
-#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include "basegfx/matrix/b2dhommatrixtools.hxx"
 #include "basegfx/polygon/b2dpolypolygoncutter.hxx"
+#include "basegfx/polygon/b2dtrapezoid.hxx"
 
 #include <vector>
 #include <queue>
@@ -1087,115 +1088,6 @@ SystemGraphicsData X11SalGraphics::GetGraphicsData() const
 
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
-// B2DPolygon support methods
-
-namespace { // anonymous namespace to prevent export
-// the methods and structures here are used by the
-// B2DPolyPolygon->RenderTrapezoid conversion algorithm
-
-// compare two line segments
-// assumption: both segments point downward
-// assumption: they must have at least some y-overlap
-// assumption: rA.p1.y <= rB.p1.y
-bool IsLeftOf( const XLineFixed& rA, const XLineFixed& rB )
-{
-    bool bAbove = (rA.p1.y <= rB.p1.y);
-    const XLineFixed& rU = bAbove ? rA : rB;
-    const XLineFixed& rL = bAbove ? rB : rA;
-
-    const XFixed aXDiff = rU.p2.x - rU.p1.x;
-    const XFixed aYDiff = rU.p2.y - rU.p1.y;
-
-    // compare upper point of lower segment with line through upper segment
-    if( (rU.p1.y != rL.p1.y) || (rU.p1.x != rL.p1.x) )
-    {
-        const sal_Int64 n1 = (sal_Int64)aXDiff * (rL.p1.y - rU.p1.y);
-        const sal_Int64 n2 = (sal_Int64)aYDiff * (rL.p1.x - rU.p1.x);
-        if( n1 != n2 )
-            return ((n1 < n2) == bAbove);
-    }
-
-    // compare lower point of lower segment with line through upper segment
-    if( (rU.p2.y != rL.p2.y) || (rU.p2.x != rL.p2.x) )
-    {
-        const sal_Int64 n3 = (sal_Int64)aXDiff * (rL.p2.y - rU.p1.y);
-        const sal_Int64 n4 = (sal_Int64)aYDiff * (rL.p2.x - rU.p1.x);
-        if( n3 != n4 )
-            return ((n3 < n4) == bAbove);
-    }
-
-    // both segments overlap
-    return false;
-}
-
-struct HalfTrapezoid
-{
-    // assumptions:
-    //    maLine.p1.y <= mnY < maLine.p2.y
-    XLineFixed  maLine;
-    XFixed      mnY;
-
-    XFixed  getXMin() const { return std::min( maLine.p1.x, maLine.p2.x); }
-    XFixed  getXMax() const { return std::max( maLine.p1.x, maLine.p2.x); }
-};
-
-class HalfTrapCompare
-{
-public:
-    bool operator()( const HalfTrapezoid& rA, const HalfTrapezoid& rB ) const
-    {
-        bool bIsTopLeft = false;
-        if( rA.mnY != rB.mnY )  // sort top-first if possible
-            bIsTopLeft = (rA.mnY < rB.mnY);
-        else                    // else sort left-first
-            bIsTopLeft = IsLeftOf( rA.maLine, rB.maLine );
-        // adjust to priority_queue sorting convention
-        return !bIsTopLeft;
-    }
-};
-
-typedef std::vector< HalfTrapezoid > HTVector;
-typedef std::priority_queue< HalfTrapezoid, HTVector, HalfTrapCompare > HTQueueBase;
-// we need a priority queue with a reserve() to prevent countless reallocations
-class HTQueue
-:   public HTQueueBase
-{
-public:
-    void    reserve( size_t n ) { c.reserve( n ); }
-    void    swapvec( HTVector& v ) { c.swap( v ); }
-};
-
-typedef std::vector<XTrapezoid> TrapezoidVector;
-
-class TrapezoidXCompare
-{
-    const TrapezoidVector& mrVector;
-public:
-    TrapezoidXCompare( const TrapezoidVector& rVector )
-        : mrVector( rVector ) {}
-    bool operator()( int nA, int nB ) const
-        { return IsLeftOf( mrVector[nA].left, mrVector[nB].left ); }
-};
-
-typedef std::multiset< int, TrapezoidXCompare > ActiveTrapSet;
-
-class TrapezoidYCompare
-{
-    const TrapezoidVector& mrVector;
-public:
-    TrapezoidYCompare( const TrapezoidVector& rVector )
-        : mrVector( rVector ) {}
-    bool operator()( int nA, int nB ) const
-        { return (mrVector[nA].bottom < mrVector[nB].bottom); }
-};
-
-typedef std::multiset< int, TrapezoidYCompare > VerticalTrapSet;
-
-#ifndef DISABLE_SOLVECROSSOVER_WORKAROUND
-void splitIntersectingSegments( HTVector&);
-#endif // DISABLE_SOLVECROSSOVER_WORKAROUND
-} // end of anonymous namespace
-
 // draw a poly-polygon
 bool X11SalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPolyPoly, double fTransparency)
 {
@@ -1219,329 +1111,66 @@ bool X11SalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPoly
     if( pRenderEnv )
         return FALSE;
 
-    // check xrender support for trapezoids
-    XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();
-    if( !rRenderPeer.AreTrapezoidsSupported() )
-        return FALSE;
-    Picture aDstPic = GetXRenderPicture();
-    // check xrender support for this drawable
-    if( !aDstPic )
-        return FALSE;
+    // snap to raster if requested
+    basegfx::B2DPolyPolygon aPolyPoly = rOrigPolyPoly;
+    const bool bSnapToRaster = !getAntiAliasB2DDraw();
+    if( bSnapToRaster )
+        aPolyPoly = basegfx::tools::snapPointsOfHorizontalOrVerticalEdges( aPolyPoly );
 
     // don't bother with polygons outside of visible area
     const basegfx::B2DRange aViewRange( 0, 0, GetGraphicsWidth(), GetGraphicsHeight() );
-    const basegfx::B2DRange aPolyRange = basegfx::tools::getRange( rOrigPolyPoly );
-    const bool bNeedViewClip = aPolyRange.isInside( aViewRange );
-    if( !aPolyRange.overlaps( aViewRange ) )
+    aPolyPoly = basegfx::tools::clipPolyPolygonOnRange( aPolyPoly, aViewRange, true, false );
+    if( !aPolyPoly.count() )
         return true;
 
-    // convert the polypolygon to trapezoids
-
-    // prepare the polypolygon for the algorithm below:
-    // - clip it against the view range
-    // - make sure it contains no self-intersections
-    // while we are at it guess the number of involved polygon points
-    int nHTQueueReserve = 0;
-    basegfx::B2DPolyPolygon aGoodPolyPoly;
-    for( int nOrigPolyIdx = 0; nOrigPolyIdx < nOrigPolyCount; ++nOrigPolyIdx )
-    {
-        const ::basegfx::B2DPolygon aOuterPolygon = rOrigPolyPoly.getB2DPolygon( nOrigPolyIdx );
-
-        // render-trapezoids should be inside the view => clip polygon against view range
-        basegfx::B2DPolyPolygon aClippedPolygon( aOuterPolygon );
-        if( bNeedViewClip )
-        {
-            aClippedPolygon = basegfx::tools::clipPolygonOnRange( aOuterPolygon, aViewRange, true, false );
-            DBG_ASSERT( aClippedPolygon.count(), "polygon confirmed to overlap with view should not get here" );
-        }
-        const int nClippedPolyCount = aClippedPolygon.count();
-        if( !nClippedPolyCount )
-            continue;
-
-#ifndef DISABLE_SOLVECROSSOVER_WORKAROUND
-          for( int nClippedPolyIdx = 0; nClippedPolyIdx < nClippedPolyCount; ++nClippedPolyIdx )
-        {
-            const ::basegfx::B2DPolygon aSolvedPolygon = aClippedPolygon.getB2DPolygon( nClippedPolyIdx );
-            const int nPointCount = aSolvedPolygon.count();
-            aGoodPolyPoly.append( aSolvedPolygon );
-            nHTQueueReserve += aSolvedPolygon.areControlPointsUsed() ? 8 * nPointCount : nPointCount;
-        }
-#else // DISABLE_SOLVECROSSOVER_WORKAROUND
-        // #i103259# polypoly.solveCrossover() fails to remove self-intersections
-        // but polygon.solveCrossover() works. Use it to build the intersection-free polypolygon
-        // TODO: if the self-intersection prevention is too expensive make the trap-algorithm tolerate intersections
-        for( int nClippedPolyIdx = 0; nClippedPolyIdx < nClippedPolyCount; ++nClippedPolyIdx )
-        {
-            ::basegfx::B2DPolygon aUnsolvedPolygon = aClippedPolygon.getB2DPolygon( nClippedPolyIdx );
-            basegfx::B2DPolyPolygon aSolvedPolyPoly( basegfx::tools::solveCrossovers( aUnsolvedPolygon) );
-            const int nSolvedPolyCount = aSolvedPolyPoly.count();
-            for( int nSolvedPolyIdx = 0; nSolvedPolyIdx < nSolvedPolyCount; ++nSolvedPolyIdx )
-            {
-                // build the intersection-free polypolygon one by one
-                const ::basegfx::B2DPolygon aSolvedPolygon = aSolvedPolyPoly.getB2DPolygon( nSolvedPolyIdx );
-                aGoodPolyPoly.append( aSolvedPolygon );
-                // and while we are at it use the conviently available point count to guess the number of needed half-traps
-                const int nPointCount = aSolvedPolygon.count();
-                nHTQueueReserve += aSolvedPolygon.areControlPointsUsed() ? 8 * nPointCount : nPointCount;
-            }
-        }
-#endif // DISABLE_SOLVECROSSOVER_WORKAROUND
-    }
-    // #i100922# try to prevent priority-queue reallocations by reservering enough
-    nHTQueueReserve = ((4*nHTQueueReserve) | 0x1FFF) + 1;
-    HTVector aHTVector;
-    aHTVector.reserve( nHTQueueReserve );
-
-    // first convert the B2DPolyPolygon to HalfTrapezoids
-    const int nGoodPolyCount = aGoodPolyPoly.count();
-    for( int nGoodPolyIdx = 0; nGoodPolyIdx < nGoodPolyCount; ++nGoodPolyIdx )
-    {
-        ::basegfx::B2DPolygon aInnerPolygon = aGoodPolyPoly.getB2DPolygon( nGoodPolyIdx );
-
-        // render-trapezoids have linear edges => get rid of bezier segments
-        if( aInnerPolygon.areControlPointsUsed() )
-            aInnerPolygon = ::basegfx::tools::adaptiveSubdivideByDistance( aInnerPolygon, 0.125 );
-
-        const int nPointCount = aInnerPolygon.count();
-        if( nPointCount >= 3 )
-        {
-            // convert polygon point pairs to HalfTrapezoids
-            // connect the polygon point with the first one if needed
-            XPointFixed aOldXPF = { 0, 0 };
-            XPointFixed aNewXPF;
-            for( int nPointIdx = 0; nPointIdx <= nPointCount; ++nPointIdx, aOldXPF = aNewXPF )
-            {
-                // auto-close the polygon if needed
-                const int k = (nPointIdx < nPointCount) ? nPointIdx : 0;
-                const ::basegfx::B2DPoint& aPoint = aInnerPolygon.getB2DPoint( k );
-
-                // convert the B2DPoint into XRENDER units
-                if(getAntiAliasB2DDraw())
-                {
-                    aNewXPF.x = XDoubleToFixed( aPoint.getX() );
-                    aNewXPF.y = XDoubleToFixed( aPoint.getY() );
-                }
-                else
-                {
-                    aNewXPF.x = XDoubleToFixed( basegfx::fround( aPoint.getX() ) );
-                    aNewXPF.y = XDoubleToFixed( basegfx::fround( aPoint.getY() ) );
-                }
-
-                // check if enough data is available for a new HalfTrapezoid
-                if( nPointIdx == 0 )
-                    continue;
-
-                // construct HalfTrapezoid as topdown segment
-                HalfTrapezoid aHT;
-                if( aNewXPF.y < aOldXPF.y )
-                {
-                    aHT.maLine.p1 = aNewXPF;
-                    aHT.maLine.p2 = aOldXPF;
-                }
-                else
-                {
-                    aHT.maLine.p2 = aNewXPF;
-                    aHT.maLine.p1 = aOldXPF;
-                }
-
-                aHT.mnY = aHT.maLine.p1.y;
+    // tesselate the polypolygon into trapezoids
+    basegfx::B2DTrapezoidVector aB2DTrapVector;
+    basegfx::tools::trapezoidSubdivide( aB2DTrapVector, aPolyPoly );
+    const int nTrapCount = aB2DTrapVector.size();
+    const bool bDrawn = drawFilledTrapezoids( &aB2DTrapVector[0], nTrapCount, fTransparency );
+    return bDrawn;
+}
 
-#if 0 // ignore clipped HalfTrapezoids
-            if( aHT.mnY < 0 )
-                aHT.mnY = 0;
-            else if( aHT.mnY > 10000 )
-                continue;
-#endif
+// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
-                // queue up the HalfTrapezoid
-                aHTVector.push_back( aHT );
-            }
-        }
-    }
+bool X11SalGraphics::drawFilledTrapezoids( const ::basegfx::B2DTrapezoid* pB2DTraps, int nTrapCount, double fTransparency )
+{
+    if( nTrapCount <= 0 )
+        return true;
 
-    if( aHTVector.empty() )
-        return TRUE;
+    Picture aDstPic = GetXRenderPicture();
+    // check xrender support for this drawable
+    if( !aDstPic )
+        return false;
 
-#ifndef DISABLE_SOLVECROSSOVER_WORKAROUND
-    // find intersecting halftraps and split them up
-    // TODO: remove when solveCrossOvers gets fast enough so its use can be enabled above
-    // FAQ: why should segment intersection be handled before adaptiveSubdivide()?
-    // Answer: because it is conceptually much faster
-    // Example: consider two intersecting circles with a diameter of 1000 pixels
-    //      before subdivision: eight bezier segments
-    //      after subdivision: more than a thousand line segments
-    //      since even the best generic intersection finders have a complexity of O((n+k)*log(n+k))
-    //      it shows that testing while the segment count is still low is a much better approach.
-    splitIntersectingSegments( aHTVector);
-#endif // DISABLE_SOLVECROSSOVER_WORKAROUND
-
-    // build queue from vector of intersection-free segments
-    // TODO: is replacing the priority-queue by a sorted vector worth it?
-    std::make_heap( aHTVector.begin(), aHTVector.end(), HalfTrapCompare());
-    HTQueue aHTQueue;
-    aHTQueue.swapvec( aHTVector);
-
-    // then convert the HalfTrapezoids into full Trapezoids
-    TrapezoidVector aTrapVector;
-    aTrapVector.reserve( aHTQueue.size() * 2 ); // just a guess
-
-    TrapezoidXCompare aTrapXCompare( aTrapVector );
-    ActiveTrapSet aActiveTraps( aTrapXCompare );
-
-    TrapezoidYCompare aTrapYCompare( aTrapVector );
-    VerticalTrapSet aVerticalTraps( aTrapYCompare );
-
-    while( !aHTQueue.empty() )
+     // convert the B2DTrapezoids into XRender-Trapezoids
+    typedef std::vector<XTrapezoid> TrapezoidVector;
+    TrapezoidVector aTrapVector( nTrapCount );
+    const basegfx::B2DTrapezoid* pB2DTrap = pB2DTraps;
+    for( int i = 0; i < nTrapCount; ++pB2DTrap, ++i )
     {
-        XTrapezoid aTrapezoid;
-
-        // convert a HalfTrapezoid pair
-        // get the left side of the trapezoid
-        const HalfTrapezoid& rLeft = aHTQueue.top();
-        aTrapezoid.top = rLeft.mnY;
-        aTrapezoid.left = rLeft.maLine;
-        aHTQueue.pop();
-
-        // ignore left segment that would result in an empty trapezoid
-        if( aTrapezoid.left.p2.y <= aTrapezoid.top )
-            continue;
-
-        // get the right side of the trapezoid
-        aTrapezoid.right.p2.y = aTrapezoid.bottom;
-        while( !aHTQueue.empty() ) {
-            const HalfTrapezoid& rRight = aHTQueue.top();
-            aTrapezoid.right = rRight.maLine;
-            aHTQueue.pop();
-            // ignore right segment that would result in an empty trapezoid
-        if( aTrapezoid.right.p2.y > aTrapezoid.top )
-                break;
-        }
-
-        // the topmost endpoint determines the trapezoid bottom
-        aTrapezoid.bottom = aTrapezoid.left.p2.y;
-        if( aTrapezoid.bottom > aTrapezoid.right.p2.y )
-            aTrapezoid.bottom = aTrapezoid.right.p2.y;
-
-        // keep the full Trapezoid candidate
-        aTrapVector.push_back( aTrapezoid );
-
-        // unless it splits another trapezoid that is still active
-        bool bSplit = false;
-        ActiveTrapSet::iterator aActiveTrapsIt = aActiveTraps.begin();
-        while(aActiveTrapsIt != aActiveTraps.end())
-        {
-            XTrapezoid& rLeftTrap = aTrapVector[ *aActiveTrapsIt ];
-
-            // skip until first overlap candidate
-            // TODO: use stl::*er_bound() instead
-            if( IsLeftOf( aTrapezoid.left, rLeftTrap.left) )
-            {
-                ++aActiveTrapsIt;
-                continue;
-            }
-
-            // in the ActiveTrapSet there are still trapezoids where
-            // a vertical overlap with new trapezoids is no longer possible
-            // they could have been removed in the verticaltraps loop below
-            // but this would be expensive and is not needed as we can
-            // simply ignore them until we stumble upon them here.
-            if( rLeftTrap.bottom <= aTrapezoid.top )
-            {
-                ActiveTrapSet::iterator it = aActiveTrapsIt;
-                if( aActiveTrapsIt != aActiveTraps.begin() )
-                {
-                    --aActiveTrapsIt;
-                    aActiveTraps.erase( it );
-                    ++aActiveTrapsIt;
-                }
-                else
-                {
-                    aActiveTraps.erase( it );
-                    aActiveTrapsIt = aActiveTraps.begin();
-                }
-                continue;
-            }
-
-            // check if there is horizontal overlap
-            // aTrapezoid.left==rLeftTrap.right is allowed though
-            if( !IsLeftOf( aTrapezoid.left, rLeftTrap.right ) )
-            {
-                ++aActiveTrapsIt;
-                continue;
-            }
-
-            // prepare to split the old trapezoid and keep its upper part
-            // find the old trapezoids entry in the VerticalTrapSet and remove it
-            typedef std::pair<VerticalTrapSet::iterator, VerticalTrapSet::iterator> VTSPair;
-            VTSPair aVTSPair = aVerticalTraps.equal_range( *aActiveTrapsIt );
-            VerticalTrapSet::iterator aVTSit = aVTSPair.first;
-            for(; aVTSit != aVTSPair.second; ++aVTSit )
-            {
-                if( *aVTSit != *aActiveTrapsIt )
-                    continue;
-                aVerticalTraps.erase( aVTSit );
-                break;
-            }
-            // then update the old trapezoid's bottom
-            rLeftTrap.bottom = aTrapezoid.top;
-            // enter the updated old trapzoid in VerticalTrapSet
-            aVerticalTraps.insert( aVerticalTraps.begin(), *aActiveTrapsIt );
-            // the old trapezoid is no longer active
-            aActiveTraps.erase( aActiveTrapsIt );
-
-            // the trapezoid causing the split has become obsolete
-            // so its both sides have to be re-queued
-            HalfTrapezoid aHT;
-            aHT.mnY = aTrapezoid.top;
-            aHT.maLine = aTrapezoid.left;
-            aHTQueue.push( aHT );
-            aHT.maLine = aTrapezoid.right;
-            aHTQueue.push( aHT );
-
-            bSplit = true;
-            break;
-        }
-
-        // keep or forget the resulting full Trapezoid
-        if( bSplit )
-            aTrapVector.pop_back();
-        else
-        {
-            aActiveTraps.insert( aTrapVector.size()-1 );
-            aVerticalTraps.insert( aTrapVector.size()-1 );
-        }
-
-        // mark trapezoids that can no longer be split as inactive
-        // and recycle their sides which were not fully resolved
-        static const XFixed nMaxTop = +0x7FFFFFFF;
-        const XFixed nNewTop = aHTQueue.empty() ? nMaxTop : aHTQueue.top().mnY;
-        while( !aVerticalTraps.empty() )
-        {
-            // check the next trapezoid to be retired
-            const XTrapezoid& rOldTrap = aTrapVector[ *aVerticalTraps.begin() ];
-            if( nNewTop < rOldTrap.bottom )
-                break;
-            // this trapezoid can no longer be split
-            aVerticalTraps.erase( aVerticalTraps.begin() );
-
-            // recycle its sides that were not fully resolved
-            HalfTrapezoid aHT;
-            aHT.mnY = rOldTrap.bottom;
-
-            if( rOldTrap.left.p2.y > aHT.mnY )
-            {
-                aHT.maLine = rOldTrap.left;
-                aHTQueue.push( aHT );
-            }
-            if( rOldTrap.right.p2.y > aHT.mnY )
-            {
-                aHT.maLine = rOldTrap.right;
-                aHTQueue.push( aHT );
-            }
-        }
+        XTrapezoid& rTrap = aTrapVector[ i ] ;
+
+         // set y-coordinates
+        const double fY1 = pB2DTrap->getTopY();
+        rTrap.left.p1.y = rTrap.right.p1.y = rTrap.top = XDoubleToFixed( fY1 );
+        const double fY2 = pB2DTrap->getBottomY();
+        rTrap.left.p2.y = rTrap.right.p2.y = rTrap.bottom = XDoubleToFixed( fY2 );
+
+         // set x-coordinates
+        const double fXL1 = pB2DTrap->getTopXLeft();
+        rTrap.left.p1.x = XDoubleToFixed( fXL1 );
+        const double fXR1 = pB2DTrap->getTopXRight();
+        rTrap.right.p1.x = XDoubleToFixed( fXR1 );
+        const double fXL2 = pB2DTrap->getBottomXLeft();
+        rTrap.left.p2.x = XDoubleToFixed( fXL2 );
+        const double fXR2 = pB2DTrap->getBottomXRight();
+        rTrap.right.p2.x = XDoubleToFixed( fXR2 );
     }
 
-    // create xrender Picture for polygon foreground
+    // get xrender Picture for polygon foreground
+    // TODO: cache it like the target picture which uses GetXRenderPicture()
+    XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();
     SalDisplay::RenderEntry& rEntry = GetDisplay()->GetRenderEntries( m_nScreen )[ 32 ];
     if( !rEntry.m_aPicture )
     {
@@ -1569,15 +1198,17 @@ bool X11SalGraphics::drawPolyPolygon( const ::basegfx::B2DPolyPolygon& rOrigPoly
     rRenderPeer.CompositeTrapezoids( PictOpOver,
         rEntry.m_aPicture, aDstPic, pMaskFormat, 0, 0, &aTrapVector[0], aTrapVector.size() );
 
-    return TRUE;
+    return true;
 }
 
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 bool X11SalGraphics::drawPolyLine(const ::basegfx::B2DPolygon& rPolygon, const ::basegfx::B2DVector& rLineWidth, basegfx::B2DLineJoin eLineJoin)
 {
+    const bool bIsHairline = (rLineWidth.getX() == rLineWidth.getY()) && (rLineWidth.getX() <= 1.2);
+
     // #i101491#
-    if(rPolygon.count() > 1000)
+    if( !bIsHairline && (rPolygon.count() > 1000) )
     {
         // the used basegfx::tools::createAreaGeometry is simply too
         // expensive with very big polygons; fallback to caller (who
@@ -1587,33 +1218,44 @@ bool X11SalGraphics::drawPolyLine(const ::basegfx::B2DPolygon& rPolygon, const :
         // the same way.
         return false;
     }
-    const XRenderPeer& rRenderPeer = XRenderPeer::GetInstance();
-    if( !rRenderPeer.AreTrapezoidsSupported() )
-        return false;
 
-    // get the area polygon for the line polygon
+    // temporarily adjust brush color to pen color
+    // since the line is drawn as an area-polygon
+    const SalColor aKeepBrushColor = nBrushColor_;
+    nBrushColor_ = nPenColor_;
+
+    // #i11575#desc5#b adjust B2D tesselation result to raster positions
     basegfx::B2DPolygon aPolygon = rPolygon;
-    if( (rLineWidth.getX() != rLineWidth.getY())
-    && !basegfx::fTools::equalZero( rLineWidth.getY() ) )
+    const double fHalfWidth = 0.5 * rLineWidth.getX();
+    aPolygon.transform( basegfx::tools::createTranslateB2DHomMatrix(+fHalfWidth,+fHalfWidth) );
+
+    // shortcut for hairline drawing to improve performance
+    if( bIsHairline )
     {
-        // prepare for createAreaGeometry() with anisotropic linewidth
-        aPolygon.transform(basegfx::tools::createScaleB2DHomMatrix(1.0, rLineWidth.getX() / rLineWidth.getY()));
+        // hairlines can benefit from a simplified tesselation
+        // e.g. for hairlines the linejoin style can be ignored
+        basegfx::B2DTrapezoidVector aB2DTrapVector;
+        basegfx::tools::createLineTrapezoidFromB2DPolygon( aB2DTrapVector, aPolygon, rLineWidth.getX() );
+
+        // draw tesselation result
+        const int nTrapCount = aB2DTrapVector.size();
+        const bool bDrawOk = drawFilledTrapezoids( &aB2DTrapVector[0], nTrapCount, 0.0 );
+
+        // restore the original brush GC
+        nBrushColor_ = aKeepBrushColor;
+        return bDrawOk;
     }
 
-    // special handling for hairlines to improve the drawing performance
-    // TODO: revisit after basegfx performance related changes
-    const bool bIsHairline = (rLineWidth.getX() < 1.2) && (rLineWidth.getY() < 1.2);
-    if( bIsHairline )
+    // get the area polygon for the line polygon
+    if( (rLineWidth.getX() != rLineWidth.getY())
+    && !basegfx::fTools::equalZero( rLineWidth.getY() ) )
     {
-        // for hairlines the linejoin style becomes irrelevant
-        eLineJoin = basegfx::B2DLINEJOIN_NONE;
-        // createAreaGeometry is still too expensive when beziers are involved
-        if( aPolygon.areControlPointsUsed() )
-            aPolygon = ::basegfx::tools::adaptiveSubdivideByDistance( aPolygon, 0.125 );
+        // prepare for createAreaGeometry() with anisotropic linewidth
+        aPolygon.transform( basegfx::tools::createScaleB2DHomMatrix(1.0, rLineWidth.getX() / rLineWidth.getY()));
     }
 
     // create the area-polygon for the line
-    const basegfx::B2DPolyPolygon aAreaPolyPoly( basegfx::tools::createAreaGeometry(aPolygon, 0.5*rLineWidth.getX(), eLineJoin) );
+    const basegfx::B2DPolyPolygon aAreaPolyPoly( basegfx::tools::createAreaGeometry(aPolygon, fHalfWidth, eLineJoin) );
 
     if( (rLineWidth.getX() != rLineWidth.getY())
     && !basegfx::fTools::equalZero( rLineWidth.getX() ) )
@@ -1622,11 +1264,6 @@ bool X11SalGraphics::drawPolyLine(const ::basegfx::B2DPolygon& rPolygon, const :
         aPolygon.transform(basegfx::tools::createScaleB2DHomMatrix(1.0, rLineWidth.getY() / rLineWidth.getX()));
     }
 
-    // temporarily adjust brush color to pen color
-    // since the line is drawn as an area-polygon
-    const SalColor aKeepBrushColor = nBrushColor_;
-    nBrushColor_ = nPenColor_;
-
     // draw each area polypolygon component individually
     // to emulate the polypolygon winding rule "non-zero"
     bool bDrawOk = true;
@@ -1634,7 +1271,7 @@ bool X11SalGraphics::drawPolyLine(const ::basegfx::B2DPolygon& rPolygon, const :
     for( int nPolyIdx = 0; nPolyIdx < nPolyCount; ++nPolyIdx )
     {
         const ::basegfx::B2DPolyPolygon aOnePoly( aAreaPolyPoly.getB2DPolygon( nPolyIdx ) );
-        bDrawOk = drawPolyPolygon( aOnePoly, 0.0);
+        bDrawOk = drawPolyPolygon( aOnePoly, 0.0 );
         if( !bDrawOk )
             break;
     }
@@ -1646,259 +1283,3 @@ bool X11SalGraphics::drawPolyLine(const ::basegfx::B2DPolygon& rPolygon, const :
 
 // -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
-#ifndef DISABLE_SOLVECROSSOVER_WORKAROUND
-// TODO: move the intersection solver into basegfx
-//    and then support bezier-intersection finding too
-
-namespace { // anonymous namespace to prevent export
-
-typedef HalfTrapezoid LineSeg;
-typedef HTVector LSVector;
-
-inline bool operator==( const LineSeg& r1, const LineSeg& r2)
-{
-    if( r1.maLine.p2.y != r2.maLine.p2.y) return false;
-    if( r1.maLine.p2.x != r2.maLine.p2.x) return false;
-    if( r1.maLine.p1.y != r2.maLine.p1.y) return false;
-    if( r1.maLine.p1.x != r2.maLine.p1.x) return false;
-    return true;
-}
-
-struct LSYMinCmp
-{
-    bool operator()( const LineSeg& r1, const LineSeg& r2) const
-        { return r2.maLine.p1.y < r1.maLine.p1.y; }
-};
-
-struct LSYMaxCmp
-{
-    bool operator()( const LineSeg& r1, const LineSeg& r2) const
-        { return r2.maLine.p2.y < r1.maLine.p2.y; }
-};
-
-struct LSXMinCmp
-{
-    bool operator()( const LineSeg& r1, const LineSeg& r2) const
-        { return( r1.getXMin() < r2.getXMin()); }
-};
-
-struct CutPoint
-{
-    XFixed      mnSegmentId;
-    float       mfCutParam;
-    XPointFixed maPoint;
-};
-
-struct CutPointCmp
-{
-    bool operator()( const CutPoint& r1, const CutPoint& r2) const
-    {
-            if( r1.mnSegmentId != r2.mnSegmentId)
-                return (r1.mnSegmentId < r2.mnSegmentId);
-        return (r1.mfCutParam < r2.mfCutParam);
-    }
-};
-
-bool findIntersection( const LineSeg& rLS1, const LineSeg& rLS2, CutPoint aCutPoints[2])
-{
-    // segments intersect at r1.p1 + s*(r1.p2-r1.p1) == r2.p1 + t*(r2.p2-r2.p1)
-    // when both segment-parameters are ((0 <s<1) && (0<t<1))
-    // (r1.p1 - r2.p1) == s * (r1.p1 - r1.p2) + t * (r2.p2 - r2.p1)
-    // =>
-    // (r1.p1x - r2.p1x) == s * (r1.p1x - r1.p2x) + t * (r2.p2x - r2.p1x)
-    // (r1.p1y - r2.p1y) == s * (r1.p1y - r1.p2y) + t * (r2.p2y - r2.p1y)
-    // check if lines are identical or parallel => not intersecting
-    const XLineFixed& r1 = rLS1.maLine;
-    const XLineFixed& r2 = rLS2.maLine;
-    const double fDet = (double)(r1.p1.x - r1.p2.x) * (r2.p2.y - r2.p1.y)
-            - (double)(r2.p2.x - r2.p1.x) * (r1.p1.y - r1.p2.y);
-    static const double fEps = 1e-8;
-    if( fabs(fDet) < fEps)
-        return false;
-    // check if intersecting with first segment
-    const double fS1 = (double)(r2.p2.y - r2.p1.y) * (r1.p1.x - r2.p1.x);
-    const double fS2 = (double)(r2.p2.x - r2.p1.x) * (r2.p1.y - r1.p1.y);
-    const double fS = (fS1 + fS2) / fDet;
-    if( (fS <= +fEps) || (fS >= 1-fEps))
-        return false;
-    // check if intersecting with second segment
-    const double fT1 = (double)(r1.p2.y - r1.p1.y) * (r1.p1.x - r2.p1.x);
-    const double fT2 = (double)(r1.p2.x - r1.p1.x) * (r2.p1.y - r1.p1.y);
-    const double fT = (fT1 + fT2) / fDet;
-    if( (fT <= +fEps) || (fT >= 1-fEps))
-        return false;
-    // force the intersection point to be exactly identical on both segments
-    aCutPoints[0].maPoint.x = (XFixed)(r1.p1.x + fS * (r1.p2.x - r1.p1.x));
-    aCutPoints[0].maPoint.y = (XFixed)(r1.p1.y + fS * (r1.p2.y - r1.p1.y));
-    aCutPoints[1].maPoint.x = aCutPoints[0].maPoint.x;
-    aCutPoints[1].maPoint.y = aCutPoints[0].maPoint.y;
-    aCutPoints[0].mnSegmentId = rLS1.mnY;
-    aCutPoints[0].mfCutParam = (float)fS;
-    aCutPoints[1].mnSegmentId = rLS2.mnY;
-    aCutPoints[1].mfCutParam = (float)fT;
-    return true;
-}
-
-typedef std::priority_queue< LineSeg, LSVector, LSYMinCmp> LSYMinQueueBase;
-typedef std::priority_queue< LineSeg, LSVector, LSYMaxCmp> LSYMaxQueueBase;
-typedef std::multiset< LineSeg, LSXMinCmp> LSXMinSet;
-typedef std::set< CutPoint, CutPointCmp> CutPointSet;
-
-class LSYMinQueue : public LSYMinQueueBase
-{
-public:
-    void    reserve( size_t n)      { c.reserve(n);}
-    void    swapvec( LSVector& v)       { c.swap(v);}
-};
-
-class LSYMaxQueue : public LSYMaxQueueBase
-{
-public:
-    void    reserve( size_t n)      { c.reserve(n);}
-};
-
-void addAndCutSegment( LSVector& rLSVector, const LineSeg& rLS, CutPointSet& rCutPointSet)
-{
-    // short circuit when no segment was cut
-    if( rCutPointSet.empty()) {
-        rLSVector.push_back( rLS);
-        return;
-    }
-
-    // find the first cut point for this segment
-    LineSeg aCS = rLS;
-    CutPoint aMinCutPoint;
-    aMinCutPoint.mnSegmentId = rLS.mnY;
-    aMinCutPoint.mfCutParam = 0.0;
-    CutPointSet::iterator itFirst = rCutPointSet.lower_bound( aMinCutPoint);
-    CutPointSet::iterator it = itFirst;
-    // iterate through all cut points of this segment
-    for(; it != rCutPointSet.end(); ++it) {
-        const CutPoint rCutPoint = (*it);
-        if( rCutPoint.mnSegmentId != rLS.mnY)
-            break;
-        // cut segment at the cutpoint
-        aCS.maLine.p2 = rCutPoint.maPoint;
-        rLSVector.push_back( aCS);
-        // prepare for next segment cut
-        aCS.maLine.p1 = aCS.maLine.p2;
-    }
-    // remove cutparams that will no longer be needed
-    // TODO: is it worth it or should we just keep the cutparams?
-    rCutPointSet.erase( itFirst, it);
-
-    // add segment part remaining after last cut
-    aCS.maLine.p2 = rLS.maLine.p2;
-    rLSVector.push_back( aCS);
-}
-
-void splitIntersectingSegments( LSVector& rLSVector)
-{
-    // get a unique id for each lineseg, temporarily abuse the mnY member
-    LSVector::iterator aLSit = rLSVector.begin();
-    for( int i = 0; aLSit != rLSVector.end(); ++aLSit) {
-        LineSeg& rLS = *aLSit;
-        rLS.mnY = i++;
-    }
-    // get an y-sorted queue from the input vector
-    LSYMinQueue aYMinQueue;
-    std::make_heap( rLSVector.begin(), rLSVector.end(), LSYMinCmp());
-    aYMinQueue.swapvec( rLSVector);
-
-    // prepare the result vector
-    // try to avoid reallocations by guessing a reasonable result size
-    rLSVector.reserve( aYMinQueue.size() * 3/2 );
-
-    // find all intersections
-    CutPointSet aCutPointSet;
-    LSXMinSet aXMinSet;
-    LSYMaxQueue aYMaxQueue;
-    aYMaxQueue.reserve( aYMinQueue.size());
-    // sweep-down and check all segment-pairs that overlap
-    while( !aYMinQueue.empty()) {
-        // get next input-segment
-        const LineSeg& rLS = aYMinQueue.top();
-        // retire obsoleted segments
-        const XFixed fYCur = rLS.maLine.p1.y;
-        while( !aYMaxQueue.empty()) {
-            // check next segment to be retired
-            const LineSeg& rOS = aYMaxQueue.top();
-            if( fYCur < rOS.maLine.p2.y)
-                break;
-            // emit resolved segment into result
-            addAndCutSegment( rLSVector, rOS, aCutPointSet);
-            // find segment to be retired in xmin-compare-set
-            LSXMinSet::iterator itR = aXMinSet.lower_bound( rOS);
-            while( !(*itR == rOS)) ++itR;
-            // retire segment from xmin-compare-set
-            aXMinSet.erase( itR);
-            // this segment is pining for the fjords
-            aYMaxQueue.pop();
-        }
-
-        // iterate over all segments that might overlap
-        // skip over the leftmost segments that cannot overlap
-        const XFixed fXMax = rLS.getXMax();
-        LSXMinSet::const_iterator itC = aXMinSet.begin();
-        for(; itC != aXMinSet.end(); ++itC)
-            if( (*itC).getXMin() <= fXMax)
-                break;
-        // TODO: if the linear search becomes too expensive
-        // then use an XMaxQueue based approach to replace it
-        const XFixed fXMin = rLS.getXMin();
-        for(; itC != aXMinSet.end(); ++itC) {
-            const LineSeg& rOS = *itC;
-            if( fXMin >= rOS.getXMax())
-                continue;
-            if( fXMax < rOS.getXMin())
-                break;
-            CutPoint aCutPoints[2];
-            if( !findIntersection( rLS, rOS, aCutPoints))
-                continue;
-            // remember cut parameters
-            // TODO: std::set seems to use individual allocations
-            //  which results in perf-problems for many entries
-            //  => pre-allocate nodes by using a non-default allocator
-            aCutPointSet.insert( aCutPoints[0]);
-            aCutPointSet.insert( aCutPoints[1]);
-        }
-        // add segment to xmin-compare-set
-         // TODO: do we have a good insertion hint?
-        aXMinSet.insert( /*itC,*/ rLS);
-        // register segment for retirement
-        aYMaxQueue.push( rLS);
-        aYMinQueue.pop();
-    }
-
-    // retire the remaining segments
-    aXMinSet.clear();
-    while( !aYMaxQueue.empty()) {
-        // emit segments and cut them up if needed
-        const LineSeg& rLS = aYMaxQueue.top();
-        addAndCutSegment( rLSVector, rLS, aCutPointSet);
-        aYMaxQueue.pop();
-    }
-
-    // get the segments ready to be consumed by the drawPolygon() caller
-    aLSit = rLSVector.begin();
-    LSVector::iterator aLSit2 = aLSit;
-    for(; aLSit != rLSVector.end(); ++aLSit) {
-        LineSeg& rLS = *aLSit;
-        // restore the segment top member
-        rLS.mnY = rLS.maLine.p1.y;
-        // remove horizontal segments for now
-        // TODO: until the trapezoid converter is adjusted to handle them
-        if( rLS.maLine.p1.y == rLS.maLine.p2.y )
-            continue;
-        *(aLSit2++) = rLS;
-    }
-    if(aLSit2 != aLSit)
-        rLSVector.resize( aLSit2 - rLSVector.begin() );
-}
-
-} // end anonymous namespace
-
-#endif // DISABLE_SOLVECROSSOVER_WORKAROUND
-
-// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-
diff --git a/vcl/unx/source/gdi/salgdi3.cxx b/vcl/unx/source/gdi/salgdi3.cxx
index f00ee26c0d4d..6024b66f6010 100644
--- a/vcl/unx/source/gdi/salgdi3.cxx
+++ b/vcl/unx/source/gdi/salgdi3.cxx
@@ -2041,7 +2041,7 @@ static ImplFontSelectData GetFcSubstitute(const ImplFontSelectData &rFontSelData
 {
     ImplFontSelectData aRet(rFontSelData);
 
-    const rtl::OString aLangAttrib; //TODO: = MsLangId::convertLanguageToIsoByteString( rFontSelData.meLanguage );
+    const rtl::OString aLangAttrib = MsLangId::convertLanguageToIsoByteString( rFontSelData.meLanguage );
 
     psp::italic::type eItalic = psp::italic::Unknown;
     if( rFontSelData.GetSlant() != ITALIC_DONTKNOW )
diff --git a/vcl/util/makefile.mk b/vcl/util/makefile.mk
index d501765c8491..eb54531c375c 100644
--- a/vcl/util/makefile.mk
+++ b/vcl/util/makefile.mk
@@ -299,6 +299,7 @@ SHL2DEPN=$(SHL1IMPLIBN) $(SHL1TARGETN)
 SHL2STDLIBS=\
             $(VCLLIB)\
             $(I18NPAPERLIB)     \
+            $(I18NISOLANGLIB)     \
             $(TOOLSLIB)         \
             $(VOSLIB)           \
             $(BASEGFXLIB)	\
diff --git a/vcl/win/inc/salgdi.h b/vcl/win/inc/salgdi.h
index 6b58e0c5375a..4b97eeb98c0b 100644
--- a/vcl/win/inc/salgdi.h
+++ b/vcl/win/inc/salgdi.h
@@ -228,15 +228,15 @@ protected:
 
     // native widget rendering methods that require mirroring
     virtual BOOL        hitTestNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                              const Point& aPos, SalControlHandle& rControlHandle, BOOL& rIsInside );
+                                              const Point& aPos, BOOL& rIsInside );
     virtual BOOL        drawNativeControl( ControlType nType, ControlPart nPart, const Region& rControlRegion,
-                                           ControlState nState, const ImplControlValue& aValue, SalControlHandle& rControlHandle,
+                                           ControlState nState, const ImplControlValue& aValue,
                                            const rtl::OUString& aCaption );
     virtual BOOL        drawNativeControlText( ControlType nType, ControlPart nPart, const Region& rControlRegion,
                                                ControlState nState, const ImplControlValue& aValue,
-                                               SalControlHandle& rControlHandle, const rtl::OUString& aCaption );
+                                               const rtl::OUString& aCaption );
     virtual BOOL        getNativeControlRegion( ControlType nType, ControlPart nPart, const Region& rControlRegion, ControlState nState,
-                                                const ImplControlValue& aValue, SalControlHandle& rControlHandle, const rtl::OUString& aCaption,
+                                                const ImplControlValue& aValue, const rtl::OUString& aCaption,
                                                 Region &rNativeBoundingRegion, Region &rNativeContentRegion );
 
     virtual bool        drawAlphaBitmap( const SalTwoRect&,
diff --git a/vcl/win/source/gdi/salgdi3.cxx b/vcl/win/source/gdi/salgdi3.cxx
index 1638c4e1bd36..d1b5a9cfdeae 100644
--- a/vcl/win/source/gdi/salgdi3.cxx
+++ b/vcl/win/source/gdi/salgdi3.cxx
@@ -1579,15 +1579,24 @@ HFONT WinSalGraphics::ImplDoSetFont( ImplFontSelectData* i_pFont, float& o_rFont
         && (ImplSalWICompareAscii( aLogFont.lfFaceName, "Courier" ) == 0) )
             lstrcpynW( aLogFont.lfFaceName, L"Courier New", 11 );
 
-        // limit font requests to MAXFONTHEIGHT
+        // #i47675# limit font requests to MAXFONTHEIGHT
         // TODO: share MAXFONTHEIGHT font instance
-        if( -aLogFont.lfHeight <= MAXFONTHEIGHT )
+        if( (-aLogFont.lfHeight <= MAXFONTHEIGHT)
+        &&  (+aLogFont.lfWidth <= MAXFONTHEIGHT) )
+        {
             o_rFontScale = 1.0;
-        else
+        }
+        else if( -aLogFont.lfHeight >= +aLogFont.lfWidth )
         {
             o_rFontScale = -aLogFont.lfHeight / (float)MAXFONTHEIGHT;
             aLogFont.lfHeight = -MAXFONTHEIGHT;
-            aLogFont.lfWidth = static_cast<LONG>( aLogFont.lfWidth / o_rFontScale );
+            aLogFont.lfWidth = FRound( aLogFont.lfWidth / o_rFontScale );
+        }
+        else // #i95867# also limit font widths
+        {
+            o_rFontScale = +aLogFont.lfWidth / (float)MAXFONTHEIGHT;
+            aLogFont.lfWidth = +MAXFONTHEIGHT;
+            aLogFont.lfHeight = FRound( aLogFont.lfHeight / o_rFontScale );
         }
 
         hNewFont = ::CreateFontIndirectW( &aLogFont );
diff --git a/vcl/win/source/gdi/salnativewidgets-luna.cxx b/vcl/win/source/gdi/salnativewidgets-luna.cxx
index d1f11433d532..be5d7f8360bc 100644
--- a/vcl/win/source/gdi/salnativewidgets-luna.cxx
+++ b/vcl/win/source/gdi/salnativewidgets-luna.cxx
@@ -319,7 +319,6 @@ BOOL WinSalGraphics::hitTestNativeControl( ControlType,
                               ControlPart,
                               const Region&,
                               const Point&,
-                              SalControlHandle&,
                               BOOL& )
 {
     return FALSE;
@@ -425,7 +424,6 @@ BOOL ImplDrawNativeControl( HDC hDC, HTHEME hTheme, RECT rc,
                             ControlPart nPart,
                             ControlState nState,
                             const ImplControlValue& aValue,
-                            SalControlHandle&,
                             OUString aCaption )
 {
     // a listbox dropdown is actually a combobox dropdown
@@ -961,7 +959,6 @@ BOOL ImplDrawNativeControl( HDC hDC, HTHEME hTheme, RECT rc,
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:         An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the WinSalGraphics implementation.
  *  aCaption:   A caption or title string (like button text etc)
  */
 BOOL WinSalGraphics::drawNativeControl( ControlType nType,
@@ -969,7 +966,6 @@ BOOL WinSalGraphics::drawNativeControl( ControlType nType,
                             const Region& rControlRegion,
                             ControlState nState,
                             const ImplControlValue& aValue,
-                            SalControlHandle& rControlHandle,
                             const OUString& aCaption )
 {
     BOOL bOk = false;
@@ -1060,7 +1056,7 @@ BOOL WinSalGraphics::drawNativeControl( ControlType nType,
     OUString aCaptionStr( aCaption.replace('~', '&') ); // translate mnemonics
     bOk = ImplDrawNativeControl(mhDC, hTheme, rc,
                             nType, nPart, nState, aValue,
-                            rControlHandle, aCaptionStr );
+                            aCaptionStr );
 
     // restore alignment
     SetTextAlign( mhDC, ta );
@@ -1080,7 +1076,6 @@ BOOL WinSalGraphics::drawNativeControl( ControlType nType,
  *
  *  rControlRegion: The bounding region of the complete control in VCL frame coordinates.
  *  aValue:         An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the WinSalGraphics implementation.
  *  aCaption:   A caption or title string (like button text etc)
  */
 BOOL WinSalGraphics::drawNativeControlText( ControlType,
@@ -1088,7 +1083,6 @@ BOOL WinSalGraphics::drawNativeControlText( ControlType,
                                 const Region&,
                                 ControlState,
                                 const ImplControlValue&,
-                                SalControlHandle&,
                                 const OUString& )
 {
     return( false );
@@ -1106,15 +1100,13 @@ BOOL WinSalGraphics::drawNativeControlText( ControlType,
  *
  *  rControlRegion: The bounding region of the control in VCL frame coordinates.
  *  aValue:     An optional value (tristate/numerical/string)
- *  rControlHandle: Carries platform dependent data and is maintained by the WinSalGraphics implementation.
  *  aCaption:       A caption or title string (like button text etc)
  */
 BOOL WinSalGraphics::getNativeControlRegion(  ControlType nType,
                                 ControlPart nPart,
                                 const Region& rControlRegion,
-                                ControlState,
-                                const ImplControlValue&,
-                                SalControlHandle&,
+                                ControlState nState,
+                                const ImplControlValue& rControlValue,
                                 const OUString&,
                                 Region &rNativeBoundingRegion,
                                 Region &rNativeContentRegion )
@@ -1230,6 +1222,7 @@ BOOL WinSalGraphics::getNativeControlRegion(  ControlType nType,
             }
         }
     }
+
     if( nType == CTRL_SLIDER && ( (nPart == PART_THUMB_HORZ) || (nPart == PART_THUMB_VERT) ) )
     {
         HTHEME hTheme = getThemeHandle( mhWnd, L"Trackbar");
@@ -1258,6 +1251,37 @@ BOOL WinSalGraphics::getNativeControlRegion(  ControlType nType,
         }
     }
 
+    if ( ( nType == CTRL_TAB_ITEM ) && ( nPart == PART_ENTIRE_CONTROL ) )
+    {
+        Rectangle aControlRect( rControlRegion.GetBoundRect() );
+        rNativeContentRegion = aControlRect;
+
+        --aControlRect.Bottom();
+
+        TabitemValue *pValue = static_cast< TabitemValue* >( rControlValue.getOptionalVal() );
+        if ( pValue )
+        {
+            if ( pValue->isBothAligned() )
+                --aControlRect.Right();
+        }
+
+        if ( nState & CTRL_STATE_SELECTED )
+        {
+            aControlRect.Left() -= 2;
+            if ( pValue && !pValue->isBothAligned() )
+            {
+                if ( pValue->isLeftAligned() || pValue->isNotAligned() )
+                    aControlRect.Right() += 2;
+                if ( pValue->isRightAligned() )
+                    aControlRect.Right() += 1;
+            }
+            aControlRect.Top() -= 2;
+            aControlRect.Bottom() += 2;
+        }
+        rNativeBoundingRegion = aControlRect;
+        bRet = TRUE;
+    }
+
     ReleaseDC( mhWnd, hDC );
     return( bRet );
 }
diff --git a/vcl/win/source/window/salframe.cxx b/vcl/win/source/window/salframe.cxx
index a6567464ac5e..7314fd2b6164 100755..100644
--- a/vcl/win/source/window/salframe.cxx
+++ b/vcl/win/source/window/salframe.cxx
@@ -2891,8 +2891,8 @@ void WinSalFrame::UpdateSettings( AllSettings& rSettings )
     BOOL bCompBorder = (aStyleSettings.GetOptions() & (STYLE_OPTION_MACSTYLE | STYLE_OPTION_UNIXSTYLE)) == 0;
     // TODO: once those options vanish: just set bCompBorder to TRUE
     // to have the system colors read
-    aStyleSettings.SetScrollBarSize( Min( GetSystemMetrics( SM_CXVSCROLL ), 20 ) ); // #99956# do not allow huge scrollbars, most of the UI is not scaled anymore
-    aStyleSettings.SetSpinSize( Min( GetSystemMetrics( SM_CXVSCROLL ), 20 ) );
+    aStyleSettings.SetScrollBarSize( GetSystemMetrics( SM_CXVSCROLL ) );
+    aStyleSettings.SetSpinSize( GetSystemMetrics( SM_CXVSCROLL ) );
     aStyleSettings.SetCursorBlinkTime( GetCaretBlinkTime() );
     if ( bCompBorder )
     {