accfixes: merged to m100

14 files changed, 1165 insertions, 283 deletions

diff --git a/toolkit/source/awt/animatedimagespeer.cxx b/toolkit/source/awt/animatedimagespeer.cxx
new file mode 100755
index 000000000000..c9c640d51c60
--- /dev/null
+++ b/toolkit/source/awt/animatedimagespeer.cxx
@@ -0,0 +1,538 @@
+/*************************************************************************
+ * 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.
+ *
+ ************************************************************************/
+
+#include "precompiled_toolkit.hxx"
+
+#include "toolkit/awt/animatedimagespeer.hxx"
+#include "toolkit/helper/property.hxx"
+
+/** === begin UNO includes === **/
+#include <com/sun/star/awt/XAnimatedImages.hpp>
+#include <com/sun/star/awt/Size.hpp>
+#include <com/sun/star/graphic/XGraphicProvider.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/awt/ImageScaleMode.hpp>
+/** === end UNO includes === **/
+
+#include <comphelper/componentcontext.hxx>
+#include <comphelper/namedvaluecollection.hxx>
+#include <comphelper/processfactory.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/urlobj.hxx>
+#include <vcl/throbber.hxx>
+
+#include <limits>
+
+//......................................................................................................................
+namespace toolkit
+{
+//......................................................................................................................
+
+    /** === begin UNO using === **/
+    using ::com::sun::star::uno::Reference;
+    using ::com::sun::star::uno::XInterface;
+    using ::com::sun::star::uno::UNO_QUERY;
+    using ::com::sun::star::uno::UNO_QUERY_THROW;
+    using ::com::sun::star::uno::UNO_SET_THROW;
+    using ::com::sun::star::uno::Exception;
+    using ::com::sun::star::uno::RuntimeException;
+    using ::com::sun::star::uno::Any;
+    using ::com::sun::star::uno::makeAny;
+    using ::com::sun::star::uno::Sequence;
+    using ::com::sun::star::uno::Type;
+    using ::com::sun::star::lang::EventObject;
+    using ::com::sun::star::container::ContainerEvent;
+    using ::com::sun::star::awt::XAnimatedImages;
+    using ::com::sun::star::awt::Size;
+    using ::com::sun::star::lang::XMultiServiceFactory;
+    using ::com::sun::star::graphic::XGraphicProvider;
+    using ::com::sun::star::beans::XPropertySet;
+    using ::com::sun::star::graphic::XGraphic;
+    /** === end UNO using === **/
+    namespace ImageScaleMode = ::com::sun::star::awt::ImageScaleMode;
+
+    //==================================================================================================================
+    //= AnimatedImagesPeer_Data
+    //==================================================================================================================
+    struct CachedImage
+    {
+        ::rtl::OUString                 sImageURL;
+        mutable Reference< XGraphic >   xGraphic;
+
+        CachedImage()
+            :sImageURL()
+            ,xGraphic()
+        {
+        }
+
+        CachedImage( ::rtl::OUString const& i_imageURL )
+            :sImageURL( i_imageURL )
+            ,xGraphic()
+        {
+        }
+    };
+
+    struct AnimatedImagesPeer_Data
+    {
+        AnimatedImagesPeer&                             rAntiImpl;
+        ::std::vector< ::std::vector< CachedImage > >   aCachedImageSets;
+
+        AnimatedImagesPeer_Data( AnimatedImagesPeer& i_antiImpl )
+            :rAntiImpl( i_antiImpl )
+            ,aCachedImageSets()
+        {
+        }
+    };
+
+    //==================================================================================================================
+    //= helper
+    //==================================================================================================================
+    namespace
+    {
+        //--------------------------------------------------------------------------------------------------------------
+        ::rtl::OUString lcl_getHighContrastURL( ::rtl::OUString const& i_imageURL )
+        {
+            INetURLObject aURL( i_imageURL );
+            if ( aURL.GetProtocol() != INET_PROT_PRIV_SOFFICE )
+            {
+                OSL_VERIFY( aURL.insertName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "hicontrast" ) ), false, 0 ) );
+                return aURL.GetMainURL( INetURLObject::NO_DECODE );
+            }
+            // the private: scheme is not considered to be hierarchical by INetURLObject, so manually insert the
+            // segment
+            const sal_Int32 separatorPos = i_imageURL.indexOf( '/' );
+            ENSURE_OR_RETURN( separatorPos != -1, "lcl_getHighContrastURL: unsipported URL scheme - cannot automatically determine HC version!", i_imageURL );
+
+            ::rtl::OUStringBuffer composer;
+            composer.append( i_imageURL.copy( 0, separatorPos ) );
+            composer.appendAscii( "/hicontrast" );
+            composer.append( i_imageURL.copy( separatorPos ) );
+            return composer.makeStringAndClear();
+        }
+
+        //--------------------------------------------------------------------------------------------------------------
+        bool lcl_ensureImage_throw( Reference< XGraphicProvider > const& i_graphicProvider, const bool i_isHighContrast, const CachedImage& i_cachedImage )
+        {
+            if ( !i_cachedImage.xGraphic.is() )
+            {
+                ::comphelper::NamedValueCollection aMediaProperties;
+                if ( i_isHighContrast )
+                {
+                    // try (to find) the high-contrast version of the graphic first
+                    aMediaProperties.put( "URL", lcl_getHighContrastURL( i_cachedImage.sImageURL ) );
+                    i_cachedImage.xGraphic.set( i_graphicProvider->queryGraphic( aMediaProperties.getPropertyValues() ), UNO_QUERY );
+                }
+                if ( !i_cachedImage.xGraphic.is() )
+                {
+                    aMediaProperties.put( "URL", i_cachedImage.sImageURL );
+                    i_cachedImage.xGraphic.set( i_graphicProvider->queryGraphic( aMediaProperties.getPropertyValues() ), UNO_QUERY );
+                }
+            }
+            return i_cachedImage.xGraphic.is();
+        }
+
+        //--------------------------------------------------------------------------------------------------------------
+        Size lcl_getGraphicSizePixel( Reference< XGraphic > const& i_graphic )
+        {
+            Size aSizePixel;
+            try
+            {
+                if ( i_graphic.is() )
+                {
+                    const Reference< XPropertySet > xGraphicProps( i_graphic, UNO_QUERY_THROW );
+                    OSL_VERIFY( xGraphicProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SizePixel" ) ) ) >>= aSizePixel );
+                }
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION();
+            }
+            return aSizePixel;
+        }
+
+        //--------------------------------------------------------------------------------------------------------------
+        void lcl_init( Sequence< ::rtl::OUString > const& i_imageURLs, ::std::vector< CachedImage >& o_images )
+        {
+            o_images.resize(0);
+            size_t count = size_t( i_imageURLs.getLength() );
+            o_images.reserve( count );
+            for ( size_t i = 0; i < count; ++i )
+            {
+                o_images.push_back( CachedImage( i_imageURLs[i] ) );
+            }
+        }
+
+        //--------------------------------------------------------------------------------------------------------------
+        void lcl_updateImageList_nothrow( AnimatedImagesPeer_Data& i_data )
+        {
+            Throbber* pThrobber = dynamic_cast< Throbber* >( i_data.rAntiImpl.GetWindow() );
+            if ( pThrobber == NULL )
+                return;
+
+            try
+            {
+                // collect the image sizes of the different image sets
+                const ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() );
+                const Reference< XGraphicProvider > xGraphicProvider( aContext.createComponent( "com.sun.star.graphic.GraphicProvider" ), UNO_QUERY_THROW );
+
+                const bool isHighContrast = pThrobber->GetSettings().GetStyleSettings().GetHighContrastMode();
+
+                sal_Int32 nPreferredSet = -1;
+                const size_t nImageSetCount = i_data.aCachedImageSets.size();
+                if ( nImageSetCount < 2 )
+                {
+                    nPreferredSet = sal_Int32( nImageSetCount ) - 1;
+                }
+                else
+                {
+                    ::std::vector< Size > aImageSizes( nImageSetCount );
+                    for ( sal_Int32 nImageSet = 0; size_t( nImageSet ) < nImageSetCount; ++nImageSet )
+                    {
+                        ::std::vector< CachedImage > const& rImageSet( i_data.aCachedImageSets[ nImageSet ] );
+                        if  (   ( rImageSet.empty() )
+                            ||  ( !lcl_ensureImage_throw( xGraphicProvider, isHighContrast, rImageSet[0] ) )
+                            )
+                        {
+                            aImageSizes[ nImageSet ] = Size( ::std::numeric_limits< long >::max(), ::std::numeric_limits< long >::max() );
+                        }
+                        else
+                        {
+                            aImageSizes[ nImageSet ] = lcl_getGraphicSizePixel( rImageSet[0].xGraphic );
+                        }
+                    }
+
+                    // find the set with the smallest difference between window size and image size
+                    const ::Size aWindowSizePixel = pThrobber->GetSizePixel();
+                    long nMinimalDistance = ::std::numeric_limits< long >::max();
+                    for (   ::std::vector< Size >::const_iterator check = aImageSizes.begin();
+                            check != aImageSizes.end();
+                            ++check
+                        )
+                    {
+                        if  (   ( check->Width > aWindowSizePixel.Width() )
+                            ||  ( check->Height > aWindowSizePixel.Height() )
+                            )
+                            // do not use an image set which doesn't fit into the window
+                            continue;
+
+                        const sal_Int64 distance =
+                                ( aWindowSizePixel.Width() - check->Width ) * ( aWindowSizePixel.Width() - check->Width )
+                            +   ( aWindowSizePixel.Height() - check->Height ) * ( aWindowSizePixel.Height() - check->Height );
+                        if ( distance < nMinimalDistance )
+                        {
+                            nMinimalDistance = distance;
+                            nPreferredSet = check - aImageSizes.begin();
+                        }
+                    }
+                }
+
+                // found a set?
+                Sequence< Reference< XGraphic > > aImages;
+                if ( ( nPreferredSet >= 0 ) && ( size_t( nPreferredSet ) < nImageSetCount ) )
+                {
+                    // => set the images
+                    ::std::vector< CachedImage > const& rImageSet( i_data.aCachedImageSets[ nPreferredSet ] );
+                    aImages.realloc( rImageSet.size() );
+                    sal_Int32 imageIndex = 0;
+                    for (   ::std::vector< CachedImage >::const_iterator cachedImage = rImageSet.begin();
+                            cachedImage != rImageSet.end();
+                            ++cachedImage, ++imageIndex
+                        )
+                    {
+                        lcl_ensureImage_throw( xGraphicProvider, isHighContrast, *cachedImage );
+                        aImages[ imageIndex ] = cachedImage->xGraphic;
+                    }
+                }
+                pThrobber->setImageList( aImages );
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION();
+            }
+        }
+
+        //--------------------------------------------------------------------------------------------------------------
+        void lcl_updateImageList_nothrow( AnimatedImagesPeer_Data& i_data, const Reference< XAnimatedImages >& i_images )
+        {
+            try
+            {
+                const sal_Int32 nImageSetCount = i_images->getImageSetCount();
+                i_data.aCachedImageSets.resize(0);
+                for ( sal_Int32 set = 0;  set < nImageSetCount; ++set )
+                {
+                    const Sequence< ::rtl::OUString > aImageURLs( i_images->getImageSet( set ) );
+                    ::std::vector< CachedImage > aImages;
+                    lcl_init( aImageURLs, aImages );
+                    i_data.aCachedImageSets.push_back( aImages );
+                }
+
+                lcl_updateImageList_nothrow( i_data );
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION();
+            }
+        }
+    }
+
+    //==================================================================================================================
+    //= AnimatedImagesPeer
+    //==================================================================================================================
+    //------------------------------------------------------------------------------------------------------------------
+    AnimatedImagesPeer::AnimatedImagesPeer()
+        :AnimatedImagesPeer_Base()
+        ,m_pData( new AnimatedImagesPeer_Data( *this ) )
+    {
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    AnimatedImagesPeer::~AnimatedImagesPeer()
+    {
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::startAnimation(  ) throw (RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            pThrobber->start();
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::stopAnimation(  ) throw (RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            pThrobber->stop();
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    ::sal_Bool SAL_CALL AnimatedImagesPeer::isAnimationRunning(  ) throw (RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            return pThrobber->isRunning();
+        return sal_False;
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::setProperty( const ::rtl::OUString& i_propertyName, const Any& i_value ) throw(RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber == NULL )
+        {
+            VCLXWindow::setProperty( i_propertyName, i_value );
+            return;
+        }
+
+        const sal_uInt16 nPropertyId = GetPropertyId( i_propertyName );
+        switch ( nPropertyId )
+        {
+            case BASEPROPERTY_STEP_TIME:
+            {
+                sal_Int32 nStepTime( 0 );
+                if ( i_value >>= nStepTime )
+                    pThrobber->setStepTime( nStepTime );
+                break;
+            }
+            case BASEPROPERTY_AUTO_REPEAT:
+            {
+                sal_Bool bRepeat( sal_True );
+                if ( i_value >>= bRepeat )
+                    pThrobber->setRepeat( bRepeat );
+                break;
+            }
+
+            case BASEPROPERTY_IMAGE_SCALE_MODE:
+            {
+                sal_Int16 nScaleMode( ImageScaleMode::Anisotropic );
+                ImageControl* pImageControl = dynamic_cast< ImageControl* >( GetWindow() );
+                if ( pImageControl && ( i_value >>= nScaleMode ) )
+                {
+                    pImageControl->SetScaleMode( nScaleMode );
+                }
+            }
+            break;
+
+            default:
+                AnimatedImagesPeer_Base::setProperty( i_propertyName, i_value );
+                break;
+        }
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    Any SAL_CALL AnimatedImagesPeer::getProperty( const ::rtl::OUString& i_propertyName ) throw(RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+
+        Any aReturn;
+
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber == NULL )
+            return VCLXWindow::getProperty( i_propertyName );
+
+        const sal_uInt16 nPropertyId = GetPropertyId( i_propertyName );
+        switch ( nPropertyId )
+        {
+        case BASEPROPERTY_STEP_TIME:
+            aReturn <<= pThrobber->getStepTime();
+            break;
+
+        case BASEPROPERTY_AUTO_REPEAT:
+            aReturn <<= pThrobber->getRepeat();
+            break;
+
+        case BASEPROPERTY_IMAGE_SCALE_MODE:
+            {
+                ImageControl const* pImageControl = dynamic_cast< ImageControl* >( GetWindow() );
+                aReturn <<= ( pImageControl ? pImageControl->GetScaleMode() : ImageScaleMode::Anisotropic );
+            }
+            break;
+
+        default:
+            aReturn = AnimatedImagesPeer_Base::getProperty( i_propertyName );
+            break;
+        }
+
+        return aReturn;
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void AnimatedImagesPeer::ProcessWindowEvent( const VclWindowEvent& i_windowEvent )
+    {
+        switch ( i_windowEvent.GetId() )
+        {
+        case VCLEVENT_WINDOW_RESIZE:
+            lcl_updateImageList_nothrow( *m_pData );
+            break;
+        }
+
+        AnimatedImagesPeer_Base::ProcessWindowEvent( i_windowEvent );
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void AnimatedImagesPeer::impl_updateImages_nolck( const Reference< XInterface >& i_animatedImages )
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+
+        lcl_updateImageList_nothrow( *m_pData, Reference< XAnimatedImages >( i_animatedImages, UNO_QUERY_THROW ) );
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::elementInserted( const ContainerEvent& i_event ) throw (RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+        Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
+
+        sal_Int32 nPosition(0);
+        OSL_VERIFY( i_event.Accessor >>= nPosition );
+        size_t position = size_t( nPosition );
+        if ( position > m_pData->aCachedImageSets.size() )
+        {
+            OSL_ENSURE( false, "AnimatedImagesPeer::elementInserted: illegal accessor/index!" );
+            lcl_updateImageList_nothrow( *m_pData, xAnimatedImages );
+        }
+
+        Sequence< ::rtl::OUString > aImageURLs;
+        OSL_VERIFY( i_event.Element >>= aImageURLs );
+        ::std::vector< CachedImage > aImages;
+        lcl_init( aImageURLs, aImages );
+        m_pData->aCachedImageSets.insert( m_pData->aCachedImageSets.begin() + position, aImages );
+        lcl_updateImageList_nothrow( *m_pData );
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::elementRemoved( const ContainerEvent& i_event ) throw (RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+        Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
+
+        sal_Int32 nPosition(0);
+        OSL_VERIFY( i_event.Accessor >>= nPosition );
+        size_t position = size_t( nPosition );
+        if ( position >= m_pData->aCachedImageSets.size() )
+        {
+            OSL_ENSURE( false, "AnimatedImagesPeer::elementRemoved: illegal accessor/index!" );
+            lcl_updateImageList_nothrow( *m_pData, xAnimatedImages );
+        }
+
+        m_pData->aCachedImageSets.erase( m_pData->aCachedImageSets.begin() + position );
+        lcl_updateImageList_nothrow( *m_pData );
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::elementReplaced( const ContainerEvent& i_event ) throw (RuntimeException)
+    {
+        ::vos::OGuard aGuard( GetMutex() );
+        Reference< XAnimatedImages > xAnimatedImages( i_event.Source, UNO_QUERY_THROW );
+
+        sal_Int32 nPosition(0);
+        OSL_VERIFY( i_event.Accessor >>= nPosition );
+        size_t position = size_t( nPosition );
+        if ( position >= m_pData->aCachedImageSets.size() )
+        {
+            OSL_ENSURE( false, "AnimatedImagesPeer::elementReplaced: illegal accessor/index!" );
+            lcl_updateImageList_nothrow( *m_pData, xAnimatedImages );
+        }
+
+        Sequence< ::rtl::OUString > aImageURLs;
+        OSL_VERIFY( i_event.Element >>= aImageURLs );
+        ::std::vector< CachedImage > aImages;
+        lcl_init( aImageURLs, aImages );
+        m_pData->aCachedImageSets[ position ] = aImages;
+        lcl_updateImageList_nothrow( *m_pData );
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::disposing( const EventObject& i_event ) throw (RuntimeException)
+    {
+        VCLXWindow::disposing( i_event );
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::modified( const EventObject& i_event ) throw (RuntimeException)
+    {
+        impl_updateImages_nolck( i_event.Source );
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    void SAL_CALL AnimatedImagesPeer::dispose(  ) throw(RuntimeException)
+    {
+        AnimatedImagesPeer_Base::dispose();
+        ::vos::OGuard aGuard( GetMutex() );
+        m_pData->aCachedImageSets.resize(0);
+    }
+
+//......................................................................................................................
+} // namespace toolkit
+//......................................................................................................................
diff --git a/toolkit/source/awt/vclxaccessiblecomponent.cxx b/toolkit/source/awt/vclxaccessiblecomponent.cxx
index 83589537c62c..de5ebab36b2a 100644
--- a/toolkit/source/awt/vclxaccessiblecomponent.cxx
+++ b/toolkit/source/awt/vclxaccessiblecomponent.cxx
@@ -248,9 +248,9 @@ void VCLXAccessibleComponent::ProcessWindowEvent( const VclWindowEvent& rVclWind
         {
             Window* pWindow = (Window*) rVclWindowEvent.GetData();
             DBG_ASSERT( pWindow, "VCLEVENT_WINDOW_CHILDDESTROYED - Window=?" );
-            if ( pWindow->GetAccessible( FALSE ).is() )
+            if ( pWindow->GetAccessible( sal_False ).is() )
             {
-                aOldValue <<= pWindow->GetAccessible( FALSE );
+                aOldValue <<= pWindow->GetAccessible( sal_False );
                 NotifyAccessibleEvent( accessibility::AccessibleEventId::CHILD, aOldValue, aNewValue );
             }
         }
@@ -568,7 +568,7 @@ uno::Reference< accessibility::XAccessible > VCLXAccessibleComponent::getAccessi
     uno::Reference< accessibility::XAccessible > xAcc;
     if ( GetWindow() )
     {
-        Window* pChild = GetWindow()->GetAccessibleChildWindow( (USHORT)i );
+        Window* pChild = GetWindow()->GetAccessibleChildWindow( (sal_uInt16)i );
         if ( pChild )
             xAcc = pChild->GetAccessible();
     }
@@ -620,7 +620,7 @@ sal_Int32 VCLXAccessibleComponent::getAccessibleIndexInParent(  ) throw (uno::Ru
             if ( pParent )
             {
                 /*
-                for ( USHORT n = pParent->GetAccessibleChildWindowCount(); n; )
+                for ( sal_uInt16 n = pParent->GetAccessibleChildWindowCount(); n; )
                 {
                     Window* pChild = pParent->GetAccessibleChildWindow( --n );
                     if ( pChild == GetWindow() )
diff --git a/toolkit/source/awt/vclxfont.cxx b/toolkit/source/awt/vclxfont.cxx
index 53175ec79d24..9d46107d8522 100644
--- a/toolkit/source/awt/vclxfont.cxx
+++ b/toolkit/source/awt/vclxfont.cxx
@@ -62,7 +62,7 @@ void VCLXFont::Init( ::com::sun::star::awt::XDevice& rxDev, const Font& rFont )
     maFont = rFont;
 }
 
-BOOL VCLXFont::ImplAssertValidFontMetric()
+sal_Bool VCLXFont::ImplAssertValidFontMetric()
 {
     if ( !mpFontMetric && mxDevice.is() )
     {
@@ -75,7 +75,7 @@ BOOL VCLXFont::ImplAssertValidFontMetric()
             pOutDev->SetFont( aOldFont );
         }
     }
-    return mpFontMetric ? TRUE : FALSE;
+    return mpFontMetric ? sal_True : sal_False;
 }
 
 
@@ -149,7 +149,7 @@ sal_Int16 VCLXFont::getCharWidth( sal_Unicode c ) throw(::com::sun::star::uno::R
 
         sal_Int16 nCount = nLast-nFirst + 1;
         aSeq = ::com::sun::star::uno::Sequence<sal_Int16>( nCount );
-        for ( USHORT n = 0; n < nCount; n++ )
+        for ( sal_uInt16 n = 0; n < nCount; n++ )
         {
             aSeq.getArray()[n] = sal::static_int_cast< sal_Int16 >(
                 pOutDev->GetTextWidth(
@@ -204,7 +204,7 @@ void VCLXFont::getKernPairs( ::com::sun::star::uno::Sequence< sal_Unicode >& rnC
         Font aOldFont = pOutDev->GetFont();
         pOutDev->SetFont( maFont );
 
-        ULONG nPairs = pOutDev->GetKerningPairCount();
+        sal_uLong nPairs = pOutDev->GetKerningPairCount();
         if ( nPairs )
         {
             KerningPair* pData = new KerningPair[ nPairs ];
@@ -218,7 +218,7 @@ void VCLXFont::getKernPairs( ::com::sun::star::uno::Sequence< sal_Unicode >& rnC
             sal_Unicode* pChars2 = rnChars2.getArray();
             sal_Int16* pKerns = rnKerns.getArray();
 
-            for ( ULONG n = 0; n < nPairs; n++ )
+            for ( sal_uLong n = 0; n < nPairs; n++ )
             {
                 pChars1[n] = pData[n].nChar1;
                 pChars2[n] = pData[n].nChar2;
diff --git a/toolkit/source/awt/vclxmenu.cxx b/toolkit/source/awt/vclxmenu.cxx
index 5e44df58318e..817899cdcd35 100644
--- a/toolkit/source/awt/vclxmenu.cxx
+++ b/toolkit/source/awt/vclxmenu.cxx
@@ -109,7 +109,7 @@ VCLXMenu::~VCLXMenu()
     }
 }
 
-BOOL VCLXMenu::IsPopupMenu() const
+sal_Bool VCLXMenu::IsPopupMenu() const
 {
     return (mpMenu && ! mpMenu->IsMenuBar());
 }
@@ -714,7 +714,7 @@ namespace
         sal_Bool bMod1  = ((aAWTKey.Modifiers & css::awt::KeyModifier::MOD1 ) == css::awt::KeyModifier::MOD1  );
         sal_Bool bMod2  = ((aAWTKey.Modifiers & css::awt::KeyModifier::MOD2 ) == css::awt::KeyModifier::MOD2  );
         sal_Bool bMod3  = ((aAWTKey.Modifiers & css::awt::KeyModifier::MOD3 ) == css::awt::KeyModifier::MOD3  );
-        USHORT   nKey   = (USHORT)aAWTKey.KeyCode;
+        sal_uInt16   nKey   = (sal_uInt16)aAWTKey.KeyCode;
 
         return KeyCode(nKey, bShift, bMod1, bMod2, bMod3);
     }
@@ -1082,7 +1082,7 @@ DBG_NAME(VCLXMenuBar);
 VCLXMenuBar::VCLXMenuBar()
 {
     DBG_CTOR( VCLXMenuBar, 0 );
-    ImplCreateMenu( FALSE );
+    ImplCreateMenu( sal_False );
 }
 
 VCLXMenuBar::VCLXMenuBar( MenuBar* pMenuBar ) : VCLXMenu( (Menu *)pMenuBar )
@@ -1099,5 +1099,5 @@ DBG_NAME(VCLXPopupMenu);
 VCLXPopupMenu::VCLXPopupMenu()
 {
     DBG_CTOR( VCLXPopupMenu, 0 );
-    ImplCreateMenu( TRUE );
+    ImplCreateMenu( sal_True );
 }
diff --git a/toolkit/source/awt/vclxplugin.hxx b/toolkit/source/awt/vclxplugin.hxx
index 49a2b2950854..2b42eecc5872 100644
--- a/toolkit/source/awt/vclxplugin.hxx
+++ b/toolkit/source/awt/vclxplugin.hxx
@@ -29,7 +29,7 @@
 #define LAYOUT_AWT_VCLXPLUGIN_HXX
 
 #include <toolkit/awt/vclxwindow.hxx>
-#include <vcl/wintypes.hxx>
+#include <tools/wintypes.hxx>
 
 class Control;
 namespace layoutimpl
diff --git a/toolkit/source/awt/vclxregion.cxx b/toolkit/source/awt/vclxregion.cxx
index 3c4bbcad2d79..2a7d56554dd8 100644
--- a/toolkit/source/awt/vclxregion.cxx
+++ b/toolkit/source/awt/vclxregion.cxx
@@ -154,7 +154,7 @@ void VCLXRegion::xOrRegion( const ::com::sun::star::uno::Reference< ::com::sun::
 {
     ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() );
 
-    ULONG nRects = maRegion.GetRectCount();
+    sal_uLong nRects = maRegion.GetRectCount();
     ::com::sun::star::uno::Sequence< ::com::sun::star::awt::Rectangle > aRects( nRects );
 
     Rectangle aRect;
diff --git a/toolkit/source/awt/vclxtabcontrol.cxx b/toolkit/source/awt/vclxtabcontrol.cxx
index 1dfd52678957..773b9922ea56 100644
--- a/toolkit/source/awt/vclxtabcontrol.cxx
+++ b/toolkit/source/awt/vclxtabcontrol.cxx
@@ -134,7 +134,7 @@ TabControl *VCLXTabControl::getTabControl() const throw (uno::RuntimeException)
 sal_Int32 SAL_CALL VCLXTabControl::insertTab() throw (uno::RuntimeException)
 {
     TabControl *pTabControl = getTabControl();
-    USHORT id = sal::static_int_cast< USHORT >( mTabId++ );
+    sal_uInt16 id = sal::static_int_cast< sal_uInt16 >( mTabId++ );
     rtl::OUString title (RTL_CONSTASCII_USTRINGPARAM( "" ) );
     pTabControl->InsertPage( id, title.getStr(), TAB_APPEND );
     pTabControl->SetTabPage( id, new TabPage( pTabControl ) );
@@ -144,17 +144,17 @@ sal_Int32 SAL_CALL VCLXTabControl::insertTab() throw (uno::RuntimeException)
 void SAL_CALL VCLXTabControl::removeTab( sal_Int32 ID ) throw (uno::RuntimeException, IndexOutOfBoundsException)
 {
     TabControl *pTabControl = getTabControl();
-    if ( pTabControl->GetTabPage( sal::static_int_cast< USHORT >( ID ) ) == NULL )
+    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
         throw IndexOutOfBoundsException();
-    pTabControl->RemovePage( sal::static_int_cast< USHORT >( ID ) );
+    pTabControl->RemovePage( sal::static_int_cast< sal_uInt16 >( ID ) );
 }
 
 void SAL_CALL VCLXTabControl::activateTab( sal_Int32 ID ) throw (uno::RuntimeException, IndexOutOfBoundsException)
 {
     TabControl *pTabControl = getTabControl();
-    if ( pTabControl->GetTabPage( sal::static_int_cast< USHORT >( ID ) ) == NULL )
+    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
         throw IndexOutOfBoundsException();
-    pTabControl->SelectTabPage( sal::static_int_cast< USHORT >( ID ) );
+    pTabControl->SelectTabPage( sal::static_int_cast< sal_uInt16 >( ID ) );
 }
 
 sal_Int32 SAL_CALL VCLXTabControl::getActiveTabID() throw (uno::RuntimeException)
@@ -192,7 +192,7 @@ void SAL_CALL VCLXTabControl::removeTabListener( const uno::Reference< awt::XTab
 void SAL_CALL VCLXTabControl::setTabProps( sal_Int32 ID, const uno::Sequence< NamedValue >& Properties ) throw (uno::RuntimeException, IndexOutOfBoundsException)
 {
     TabControl *pTabControl = getTabControl();
-    if ( pTabControl->GetTabPage( sal::static_int_cast< USHORT >( ID ) ) == NULL )
+    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
         throw IndexOutOfBoundsException();
 
     for ( int i = 0; i < Properties.getLength(); i++ )
@@ -203,7 +203,7 @@ void SAL_CALL VCLXTabControl::setTabProps( sal_Int32 ID, const uno::Sequence< Na
         if ( name  == rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Title" ) ) )
         {
             rtl::OUString title = value.get<rtl::OUString>();
-            pTabControl->SetPageText( sal::static_int_cast< USHORT >( ID ), title.getStr() );
+            pTabControl->SetPageText( sal::static_int_cast< sal_uInt16 >( ID ), title.getStr() );
         }
     }
 }
@@ -212,7 +212,7 @@ uno::Sequence< NamedValue > SAL_CALL VCLXTabControl::getTabProps( sal_Int32 ID )
     throw (IndexOutOfBoundsException, uno::RuntimeException)
 {
     TabControl *pTabControl = getTabControl();
-    if ( pTabControl->GetTabPage( sal::static_int_cast< USHORT >( ID ) ) == NULL )
+    if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( ID ) ) == NULL )
         throw IndexOutOfBoundsException();
 
 #define ADD_PROP( seq, i, name, val ) {                                \
@@ -223,8 +223,8 @@ uno::Sequence< NamedValue > SAL_CALL VCLXTabControl::getTabProps( sal_Int32 ID )
     }
 
     uno::Sequence< NamedValue > props( 2 );
-    ADD_PROP( props, 0, "Title", rtl::OUString( pTabControl->GetPageText( sal::static_int_cast< USHORT >( ID ) ) ) );
-    ADD_PROP( props, 1, "Position", pTabControl->GetPagePos( sal::static_int_cast< USHORT >( ID ) ) );
+    ADD_PROP( props, 0, "Title", rtl::OUString( pTabControl->GetPageText( sal::static_int_cast< sal_uInt16 >( ID ) ) ) );
+    ADD_PROP( props, 1, "Position", pTabControl->GetPagePos( sal::static_int_cast< sal_uInt16 >( ID ) ) );
 #undef ADD_PROP
     return props;
 }
@@ -235,7 +235,7 @@ void SAL_CALL VCLXTabControl::draw( sal_Int32 nX, sal_Int32 nY ) throw(uno::Runt
     ::vos::OGuard aGuard( GetMutex() );
 
     TabControl *pTabControl = getTabControl();
-    TabPage *pTabPage = pTabControl->GetTabPage( sal::static_int_cast< USHORT >(  getActiveTabID() ) );
+    TabPage *pTabPage = pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >(  getActiveTabID() ) );
     if ( pTabPage )
     {
         ::Point aPos( nX, nY );
@@ -409,8 +409,8 @@ void SAL_CALL VCLXTabControl::allocateArea (awt::Rectangle const &area)
 
             if ( active )
             {
-                ::Rectangle label_rect = pTabControl->GetTabBounds( sal::static_int_cast< USHORT >( i+1 ) );
-                ::Rectangle page_rect = pTabControl->GetTabPageBounds( sal::static_int_cast< USHORT >( i+1 ) );
+                ::Rectangle label_rect = pTabControl->GetTabBounds( sal::static_int_cast< sal_uInt16 >( i+1 ) );
+                ::Rectangle page_rect = pTabControl->GetTabPageBounds( sal::static_int_cast< sal_uInt16 >( i+1 ) );
 
                 awt::Rectangle childRect;
                 childRect.X = page_rect.Left();
@@ -443,7 +443,7 @@ awt::Size SAL_CALL VCLXTabControl::getMinimumSize()
         if ( child->mxChild.is() )
         {
             // set the title prop here...
-            pTabControl->SetPageText( sal::static_int_cast< USHORT >( i+1 ), child->maTitle.getStr() );
+            pTabControl->SetPageText( sal::static_int_cast< sal_uInt16 >( i+1 ), child->maTitle.getStr() );
 
             awt::Size childSize( child->mxChild->getMinimumSize() );
             childrenSize.Width = SAL_MAX( childSize.Width, childrenSize.Width );
@@ -483,7 +483,7 @@ void VCLXTabControl::ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent
         case VCLEVENT_TABPAGE_REMOVEDALL:
         case VCLEVENT_TABPAGE_PAGETEXTCHANGED:
         {
-            ULONG page = (ULONG) _rVclWindowEvent.GetData();
+            sal_uLong page = (sal_uLong) _rVclWindowEvent.GetData();
             for ( std::list< uno::Reference
                       < awt::XTabListener > >::iterator it
                       = mxTabListeners.begin(); it != mxTabListeners.end(); it++)
@@ -509,7 +509,7 @@ void VCLXTabControl::ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent
                     case VCLEVENT_TABPAGE_REMOVEDALL:
                         for ( int i = 1; i < mTabId; i++)
                         {
-                            if ( pTabControl->GetTabPage( sal::static_int_cast< USHORT >( i ) ) )
+                            if ( pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >( i ) ) )
                                 listener->removed( i );
                         }
                         break;
diff --git a/toolkit/source/awt/vclxtabpagecontainer.cxx b/toolkit/source/awt/vclxtabpagecontainer.cxx
new file mode 100644
index 000000000000..d4f7a5048701
--- /dev/null
+++ b/toolkit/source/awt/vclxtabpagecontainer.cxx
@@ -0,0 +1,233 @@
+/*************************************************************************
+ *
+ * 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.
+ *
+ ************************************************************************/
+#include "precompiled_toolkit.hxx"
+
+#include <toolkit/awt/vclxtabpagecontainer.hxx>
+#include <com/sun/star/awt/tab/XTabPageModel.hpp>
+#include <com/sun/star/awt/XControl.hpp>
+#include <vcl/tabpage.hxx>
+#include <vcl/tabctrl.hxx>
+#include <toolkit/helper/property.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <toolkit/helper/tkresmgr.hxx>
+#include <cppuhelper/typeprovider.hxx>
+
+using ::rtl::OUString;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::view;
+//  ----------------------------------------------------
+//  class VCLXTabPageContainer
+//  ----------------------------------------------------
+void VCLXTabPageContainer::ImplGetPropertyIds( std::list< sal_uInt16 > &rIds )
+{
+    VCLXWindow::ImplGetPropertyIds( rIds );
+}
+
+VCLXTabPageContainer::VCLXTabPageContainer() :
+    m_aTabPageListeners( *this )
+{
+}
+
+VCLXTabPageContainer::~VCLXTabPageContainer()
+{
+#ifndef __SUNPRO_CC
+    OSL_TRACE ("%s", __FUNCTION__);
+#endif
+}
+
+void SAL_CALL VCLXTabPageContainer::draw( sal_Int32 nX, sal_Int32 nY ) throw(RuntimeException)
+{
+    ::vos::OGuard aGuard( GetMutex() );
+    TabControl* pTabControl = (TabControl*)GetWindow();
+    if ( pTabControl )
+    {
+        TabPage *pTabPage = pTabControl->GetTabPage( sal::static_int_cast< sal_uInt16 >(  pTabControl->GetCurPageId( ) ) );
+        if ( pTabPage )
+        {
+            ::Point aPos( nX, nY );
+            ::Size  aSize = pTabPage->GetSizePixel();
+
+            OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
+            aPos  = pDev->PixelToLogic( aPos );
+            aSize = pDev->PixelToLogic( aSize );
+
+            pTabPage->Draw( pDev, aPos, aSize, 0 );
+        }
+    }
+
+    VCLXWindow::draw( nX, nY );
+/*
+    if ( pWindow )
+    {
+        OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
+        if ( !pDev )
+            pDev = pWindow->GetParent();
+
+        Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
+        Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
+
+        pWindow->Draw( pDev, aPos, aSize, WINDOW_DRAW_NOCONTROLS );
+    }
+*/
+}
+
+::com::sun::star::awt::DeviceInfo VCLXTabPageContainer::getInfo() throw(RuntimeException)
+{
+    ::com::sun::star::awt::DeviceInfo aInfo = VCLXDevice::getInfo();
+    return aInfo;
+}
+
+void SAL_CALL VCLXTabPageContainer::setProperty(const ::rtl::OUString& PropertyName,   const Any& Value ) throw(RuntimeException)
+{
+    ::vos::OGuard aGuard( GetMutex() );
+
+    TabControl* pTabPage = (TabControl*)GetWindow();
+    if ( pTabPage )
+    {
+        VCLXWindow::setProperty( PropertyName, Value );
+    }
+}
+::sal_Int16 SAL_CALL VCLXTabPageContainer::getActiveTabPageID() throw (RuntimeException)
+{
+    TabControl* pTabCtrl = (TabControl*)GetWindow();
+    return pTabCtrl != NULL ? pTabCtrl->GetCurPageId( ) : 0;
+}
+void SAL_CALL VCLXTabPageContainer::setActiveTabPageID( ::sal_Int16 _activetabpageid ) throw (RuntimeException)
+{
+    TabControl* pTabCtrl = (TabControl*)GetWindow();
+    if ( pTabCtrl )
+        pTabCtrl->SelectTabPage(_activetabpageid);
+}
+::sal_Int32 SAL_CALL VCLXTabPageContainer::getTabPageCount(  ) throw (RuntimeException)
+{
+    TabControl* pTabCtrl = (TabControl*)GetWindow();
+    return pTabCtrl != NULL ? pTabCtrl->GetPageCount() : 0;
+}
+::sal_Bool SAL_CALL VCLXTabPageContainer::isTabPageActive( ::sal_Int16 tabPageIndex ) throw (RuntimeException)
+{
+    return (getActiveTabPageID() == tabPageIndex);
+}
+Reference< ::com::sun::star::awt::tab::XTabPage > SAL_CALL VCLXTabPageContainer::getTabPage( ::sal_Int16 tabPageIndex ) throw (RuntimeException)
+{
+    return (tabPageIndex >= 0 && tabPageIndex < static_cast<sal_Int16>(m_aTabPages.size())) ? m_aTabPages[tabPageIndex] : NULL;
+}
+Reference< ::com::sun::star::awt::tab::XTabPage > SAL_CALL VCLXTabPageContainer::getTabPageByID( ::sal_Int16 tabPageID ) throw (RuntimeException)
+{
+    ::vos::OClearableGuard aGuard( GetMutex() );
+    Reference< ::com::sun::star::awt::tab::XTabPage > xTabPage;
+    ::std::vector< Reference< ::com::sun::star::awt::tab::XTabPage > >::iterator aIter = m_aTabPages.begin();
+    ::std::vector< Reference< ::com::sun::star::awt::tab::XTabPage > >::iterator aEnd = m_aTabPages.end();
+    for(;aIter != aEnd;++aIter)
+    {
+        Reference< awt::XControl > xControl(*aIter,UNO_QUERY );
+        Reference< awt::tab::XTabPageModel > xP( xControl->getModel(), UNO_QUERY );
+        if ( tabPageID == xP->getTabPageID() )
+        {
+            xTabPage = *aIter;
+            break;
+        }
+    }
+    return xTabPage;
+}
+void SAL_CALL VCLXTabPageContainer::addTabPageListener( const Reference< ::com::sun::star::awt::tab::XTabPageContainerListener >& listener ) throw (RuntimeException)
+{
+    m_aTabPageListeners.addInterface( listener );
+}
+void SAL_CALL VCLXTabPageContainer::removeTabPageListener( const Reference< ::com::sun::star::awt::tab::XTabPageContainerListener >& listener ) throw (RuntimeException)
+{
+    m_aTabPageListeners.removeInterface( listener );
+}
+
+void VCLXTabPageContainer::ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent )
+{
+    ::vos::OClearableGuard aGuard( GetMutex() );
+    TabControl* pTabControl = static_cast< TabControl* >( GetWindow() );
+    if ( pTabControl )
+    {
+        switch ( _rVclWindowEvent.GetId() )
+        {
+            case VCLEVENT_TABPAGE_ACTIVATE:
+            {
+//                allocateArea( maAllocation );
+                sal_uLong page = (sal_uLong)_rVclWindowEvent.GetData();
+                awt::tab::TabPageActivatedEvent aEvent(NULL,page);
+                m_aTabPageListeners.tabPageActivated(aEvent);
+                break;
+            }
+            default:
+                aGuard.clear();
+                VCLXWindow::ProcessWindowEvent( _rVclWindowEvent );
+                break;
+        }
+    }
+}
+void SAL_CALL VCLXTabPageContainer::disposing( const ::com::sun::star::lang::EventObject& /*Source*/ ) throw (::com::sun::star::uno::RuntimeException)
+{
+}
+void SAL_CALL VCLXTabPageContainer::elementInserted( const ::com::sun::star::container::ContainerEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
+{
+    ::vos::OGuard aGuard( GetMutex() );
+    TabControl* pTabCtrl = (TabControl*)GetWindow();
+    Reference< ::com::sun::star::awt::tab::XTabPage > xTabPage(Event.Element,uno::UNO_QUERY);
+    if ( pTabCtrl && xTabPage.is() )
+    {
+        Reference< awt::XControl > xControl(xTabPage,UNO_QUERY );
+        Reference< awt::tab::XTabPageModel > xP( xControl->getModel(), UNO_QUERY );
+        sal_Int16 nPageID = xP->getTabPageID();
+
+        Window* pWindow = VCLUnoHelper::GetWindow(xControl->getPeer());
+        TabPage* pPage = (TabPage*)pWindow;
+        pTabCtrl->InsertPage(nPageID,pPage->GetText());
+
+        pPage->Hide();
+        pTabCtrl->SetTabPage(nPageID,pPage);
+        pTabCtrl->SetHelpText(nPageID,xP->getTooltip());
+        pTabCtrl->SetPageImage(nPageID,TkResMgr::getImageFromURL(xP->getImageURL()));
+        pTabCtrl->SelectTabPage(nPageID);
+        m_aTabPages.push_back(xTabPage);
+    }
+}
+void SAL_CALL VCLXTabPageContainer::elementRemoved( const ::com::sun::star::container::ContainerEvent& Event ) throw (::com::sun::star::uno::RuntimeException)
+{
+    ::vos::OGuard aGuard( GetMutex() );
+    TabControl* pTabCtrl = (TabControl*)GetWindow();
+    Reference< ::com::sun::star::awt::tab::XTabPage > xTabPage(Event.Element,uno::UNO_QUERY);
+    if ( pTabCtrl && xTabPage.is() )
+    {
+        Reference< awt::XControl > xControl(xTabPage,UNO_QUERY );
+        Reference< awt::tab::XTabPageModel > xP( xControl->getModel(), UNO_QUERY );
+        pTabCtrl->RemovePage(xP->getTabPageID());
+        m_aTabPages.erase(::std::remove(m_aTabPages.begin(),m_aTabPages.end(),xTabPage));
+    }
+}
+void SAL_CALL VCLXTabPageContainer::elementReplaced( const ::com::sun::star::container::ContainerEvent& /*Event*/ ) throw (::com::sun::star::uno::RuntimeException)
+{
+}
diff --git a/toolkit/source/awt/vclxtabpagemodel.cxx b/toolkit/source/awt/vclxtabpagemodel.cxx
new file mode 100644
index 000000000000..c7145992bd7f
--- /dev/null
+++ b/toolkit/source/awt/vclxtabpagemodel.cxx
@@ -0,0 +1,150 @@
+/*************************************************************************
+ *
+ * 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.
+ *
+ ************************************************************************/
+#include "precompiled_toolkit.hxx"
+
+#include <toolkit/awt/vclxtabpagemodel.hxx>
+#include <vcl/tabpage.hxx>
+#include <vcl/tabctrl.hxx>
+#include <toolkit/helper/property.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <toolkit/helper/unopropertyarrayhelper.hxx>
+#include <cppuhelper/typeprovider.hxx>
+//  ----------------------------------------------------
+//  class VCLXDialog
+//  ----------------------------------------------------
+
+VCLXTabPageModel::VCLXTabPageModel()
+{
+}
+
+VCLXTabPageModel::~VCLXTabPageModel()
+{
+#ifndef __SUNPRO_CC
+    OSL_TRACE ("%s", __FUNCTION__);
+#endif
+}
+
+void SAL_CALL VCLXTabPageModel::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno::RuntimeException)
+{
+    ::osl::MutexGuard aGuard( GetMutex() );
+    Window* pWindow = GetWindow();
+
+    if ( pWindow )
+    {
+        OutputDevice* pDev = VCLUnoHelper::GetOutputDevice( getGraphics() );
+        if ( !pDev )
+            pDev = pWindow->GetParent();
+
+        Size aSize = pDev->PixelToLogic( pWindow->GetSizePixel() );
+        Point aPos = pDev->PixelToLogic( Point( nX, nY ) );
+
+        pWindow->Draw( pDev, aPos, aSize, WINDOW_DRAW_NOCONTROLS );
+    }
+}
+
+::com::sun::star::awt::DeviceInfo VCLXTabPageModel::getInfo() throw(::com::sun::star::uno::RuntimeException)
+{
+    ::com::sun::star::awt::DeviceInfo aInfo;// = VCLXDevice::getInfo();
+    return aInfo;
+}
+
+
+void SAL_CALL VCLXTabPageModel::setProperty(
+    const ::rtl::OUString& /*PropertyName*/,
+    const ::com::sun::star::uno::Any& /*Value*/ )
+throw(::com::sun::star::uno::RuntimeException)
+{
+    ::osl::MutexGuard aGuard( GetMutex() );
+
+    /*TabPage* pTabPage = (TabPage*)GetWindow();
+    if ( pTabPage )
+    {
+        VCLXWindow::setProperty( PropertyName, Value );
+    }*/
+}
+//XTabPageModel
+::sal_Int16 SAL_CALL VCLXTabPageModel::getTabPageID() throw (::com::sun::star::uno::RuntimeException)
+{
+    return 0;
+}
+::sal_Bool SAL_CALL VCLXTabPageModel::getEnabled() throw (::com::sun::star::uno::RuntimeException)
+{
+    return false;
+}
+void SAL_CALL VCLXTabPageModel::setEnabled( ::sal_Bool _enabled ) throw (::com::sun::star::uno::RuntimeException)
+{
+    //TabControl* pTabControl = (TabControl*)GetWindow();
+    //if ( pTabControl )
+    //  pTabControl->EnablePage(0, true);
+}
+::rtl::OUString SAL_CALL VCLXTabPageModel::getTitle() throw (::com::sun::star::uno::RuntimeException)
+{
+    //TabControl* pTabControl = (TabControl*)GetWindow();
+    //if ( pTabControl )
+    //  return pTabControl->GetPageText(0);
+    //else
+        return ::rtl::OUString::createFromAscii("");
+}
+void SAL_CALL VCLXTabPageModel::setTitle( const ::rtl::OUString& _title ) throw (::com::sun::star::uno::RuntimeException)
+{
+    //TabControl* pTabControl = (TabControl*)GetWindow();
+    //if ( pTabControl )
+    //  pTabControl->SetPageText(0, _title);
+
+}
+::rtl::OUString SAL_CALL VCLXTabPageModel::getImageURL() throw (::com::sun::star::uno::RuntimeException)
+{
+    return ::rtl::OUString::createFromAscii("");
+}
+void SAL_CALL VCLXTabPageModel::setImageURL( const ::rtl::OUString& /*_imageurl*/ ) throw (::com::sun::star::uno::RuntimeException)
+{
+    //m_sImageURL = _imageurl;
+}
+::rtl::OUString SAL_CALL VCLXTabPageModel::getTooltip() throw (::com::sun::star::uno::RuntimeException)
+{
+    //return m_sTooltip;
+    return ::rtl::OUString::createFromAscii("");
+}
+void SAL_CALL VCLXTabPageModel::setTooltip( const ::rtl::OUString& _tooltip ) throw (::com::sun::star::uno::RuntimeException)
+{
+    (void)_tooltip;
+}
+::cppu::IPropertyArrayHelper& VCLXTabPageModel::getInfoHelper()
+{
+     static UnoPropertyArrayHelper* pHelper = NULL;
+     if ( !pHelper )
+     {
+        com::sun::star::uno::Sequence<sal_Int32>    aIDs = ImplGetPropertyIds();
+         pHelper = new UnoPropertyArrayHelper( aIDs );
+    }
+     return *pHelper;
+}
+::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > VCLXTabPageModel::getPropertySetInfo(  ) throw(::com::sun::star::uno::RuntimeException)
+{
+    static ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) );
+    return xInfo;
+}
diff --git a/toolkit/source/awt/vclxtoolkit.cxx b/toolkit/source/awt/vclxtoolkit.cxx
index 1af422bf7f00..dd6e28807bc6 100644
--- a/toolkit/source/awt/vclxtoolkit.cxx
+++ b/toolkit/source/awt/vclxtoolkit.cxx
@@ -33,6 +33,7 @@
 #include <tools/svwin.h>
 #endif
 #include <stdio.h>
+#include <com/sun/star/awt/ImageScaleMode.hpp>
 #include <com/sun/star/awt/WindowAttribute.hpp>
 #include <com/sun/star/awt/VclWindowPeerAttribute.hpp>
 #include <com/sun/star/awt/WindowClass.hpp>
@@ -68,9 +69,12 @@
 #include <toolkit/awt/vclxsystemdependentwindow.hxx>
 #include <toolkit/awt/vclxregion.hxx>
 #include <toolkit/awt/vclxtoolkit.hxx>
+#include <toolkit/awt/vclxtabpagecontainer.hxx>
+#include <toolkit/awt/vclxtabpagemodel.hxx>
 
 #include <toolkit/awt/xsimpleanimation.hxx>
 #include <toolkit/awt/xthrobber.hxx>
+#include <toolkit/awt/animatedimagespeer.hxx>
 #include <toolkit/awt/vclxtopwindow.hxx>
 #include <toolkit/awt/vclxwindow.hxx>
 #include <toolkit/helper/vclunohelper.hxx>
@@ -115,6 +119,7 @@
 #include <vcl/virdev.hxx>
 #include <vcl/window.hxx>
 #include <vcl/wrkwin.hxx>
+#include <vcl/throbber.hxx>
 #include "toolkit/awt/vclxspinbutton.hxx"
 
 #include <tools/debug.hxx>
@@ -313,6 +318,7 @@ static ComponentInfo __FAR_DATA aComponentInfos [] =
     { "scrollbar",          WINDOW_SCROLLBAR },
     { "scrollbarbox",       WINDOW_SCROLLBARBOX },
     { "simpleanimation",    WINDOW_CONTROL },
+    { "animatedimages",     WINDOW_CONTROL },
     { "spinbutton",         WINDOW_SPINBUTTON },
     { "spinfield",          WINDOW_SPINFIELD },
     { "throbber",           WINDOW_CONTROL },
@@ -329,7 +335,9 @@ static ComponentInfo __FAR_DATA aComponentInfos [] =
     { "tristatebox",        WINDOW_TRISTATEBOX },
     { "warningbox",         WINDOW_WARNINGBOX },
     { "window",             WINDOW_WINDOW },
-    { "workwindow",         WINDOW_WORKWINDOW }
+    { "workwindow",         WINDOW_WORKWINDOW },
+    { "tabpagecontainer",   WINDOW_CONTROL },
+    { "tabpagemodel",       WINDOW_TABPAGE }
 };
 
 extern "C"
@@ -384,7 +392,7 @@ sal_uInt16 ImplGetComponentType( const String& rServiceName )
 //  ----------------------------------------------------
 
 static sal_Int32                            nVCLToolkitInstanceCount = 0;
-static BOOL                                 bInitedByVCLToolkit = sal_False;
+static sal_Bool                                 bInitedByVCLToolkit = sal_False;
 //static cppu::OInterfaceContainerHelper *  pToolkits = 0;
 
 static osl::Mutex & getInitMutex()
@@ -680,7 +688,7 @@ Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
             break;
             case WINDOW_CURRENCYFIELD:
                 pNewWindow = new CurrencyField( pParent, nWinBits );
-                static_cast<CurrencyField*>(pNewWindow)->EnableEmptyFieldValue( TRUE );
+                static_cast<CurrencyField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
                 *ppNewComp = new VCLXNumericField;
                 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(CurrencyField*)pNewWindow );
             break;
@@ -689,7 +697,7 @@ Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
             break;
             case WINDOW_DATEFIELD:
                 pNewWindow = new DateField( pParent, nWinBits );
-                static_cast<DateField*>(pNewWindow)->EnableEmptyFieldValue( TRUE );
+                static_cast<DateField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
                 *ppNewComp = new VCLXDateField;
                 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(DateField*)pNewWindow );
             break;
@@ -794,7 +802,7 @@ Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
             break;
             case WINDOW_NUMERICFIELD:
                 pNewWindow = new NumericField( pParent, nWinBits );
-                static_cast<NumericField*>(pNewWindow)->EnableEmptyFieldValue( TRUE );
+                static_cast<NumericField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
                 *ppNewComp = new VCLXNumericField;
                 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(NumericField*)pNewWindow );
             break;
@@ -826,12 +834,12 @@ Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
                 // Since the VCLXRadioButton really cares for it's RadioCheck settings, this is important:
                 // if we enable it, the VCLXRadioButton will use RadioButton::Check instead of RadioButton::SetState
                 // This leads to a strange behaviour if the control is newly created: when settings the initial
-                // state to "checked", the RadioButton::Check (called because RadioCheck=TRUE) will uncheck
+                // state to "checked", the RadioButton::Check (called because RadioCheck=sal_True) will uncheck
                 // _all_other_ radio buttons in the same group. However, at this moment the grouping of the controls
                 // is not really valid: the controls are grouped after they have been created, but we're still in
                 // the creation process, so the RadioButton::Check relies on invalid grouping information.
                 // 07.08.2001 - #87254# - frank.schoenheit@sun.com
-                static_cast<RadioButton*>(pNewWindow)->EnableRadioCheck( FALSE );
+                static_cast<RadioButton*>(pNewWindow)->EnableRadioCheck( sal_False );
             break;
             case WINDOW_SCROLLBAR:
                 pNewWindow = new ScrollBar( pParent, nWinBits );
@@ -863,20 +871,32 @@ Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
             break;
             case WINDOW_TABCONTROL:
                 pNewWindow = new TabControl( pParent, nWinBits );
+                *ppNewComp = new VCLXTabPageContainer;
             break;
             case WINDOW_TABDIALOG:
                 pNewWindow = new TabDialog( pParent, nWinBits );
             break;
             case WINDOW_TABPAGE:
-                pNewWindow = new TabPage( pParent, nWinBits );
-                *ppNewComp = new VCLXTabPage;
+                /*
+                if ( rDescriptor.WindowServiceName.equalsIgnoreAsciiCase(
+                        ::rtl::OUString::createFromAscii("tabpagemodel") ) )
+                {
+                    pNewWindow = new TabControl( pParent, nWinBits );
+                    *ppNewComp = new VCLXTabPageContainer;
+                }
+                else
+                */
+                {
+                    pNewWindow = new TabPage( pParent, nWinBits );
+                    *ppNewComp = new VCLXTabPage;
+                }
             break;
             case WINDOW_TIMEBOX:
                 pNewWindow = new TimeBox( pParent, nWinBits );
             break;
             case WINDOW_TIMEFIELD:
                 pNewWindow = new TimeField( pParent, nWinBits );
-                static_cast<TimeField*>(pNewWindow)->EnableEmptyFieldValue( TRUE );
+                static_cast<TimeField*>(pNewWindow)->EnableEmptyFieldValue( sal_True );
                 *ppNewComp = new VCLXTimeField;
                 ((VCLXFormattedSpinField*)*ppNewComp)->SetFormatter( (FormatterBase*)(TimeField*)pNewWindow );
             break;
@@ -984,22 +1004,35 @@ Window* VCLXToolkit::ImplCreateWindow( VCLXWindow** ppNewComp,
                 }
             break;
             case WINDOW_CONTROL:
-                if ( rDescriptor.WindowServiceName.equalsIgnoreAsciiCase(
-                        ::rtl::OUString::createFromAscii("simpleanimation") ) )
+                if  ( aServiceName.EqualsAscii( "simpleanimation" ) )
                 {
-                    nWinBits |= WB_SCALE;
-                    pNewWindow = new FixedImage( pParent, nWinBits );
+                    pNewWindow = new Throbber( pParent, nWinBits, Throbber::IMAGES_NONE );
+                    ((Throbber*)pNewWindow)->SetScaleMode( css::awt::ImageScaleMode::Anisotropic );
+                        // (compatibility)
                     *ppNewComp = new ::toolkit::XSimpleAnimation;
                 }
-                else if ( rDescriptor.WindowServiceName.equalsIgnoreAsciiCase(
-                        ::rtl::OUString::createFromAscii("throbber") ) )
+                else if ( aServiceName.EqualsAscii( "throbber" ) )
                 {
-                    nWinBits |= WB_SCALE;
-                    pNewWindow = new FixedImage( pParent, nWinBits );
+                    pNewWindow = new Throbber( pParent, nWinBits, Throbber::IMAGES_NONE );
+                    ((Throbber*)pNewWindow)->SetScaleMode( css::awt::ImageScaleMode::Anisotropic );
+                        // (compatibility)
                     *ppNewComp = new ::toolkit::XThrobber;
                 }
+                else if ( rDescriptor.WindowServiceName.equalsIgnoreAsciiCase(
+                        ::rtl::OUString::createFromAscii("tabpagecontainer") ) )
+                {
+                    pNewWindow = new TabControl( pParent, nWinBits );
+                    *ppNewComp = new VCLXTabPageContainer;
+                }
+                else if ( aServiceName.EqualsAscii( "animatedimages" ) )
+                {
+                    pNewWindow = new Throbber( pParent, nWinBits );
+                    *ppNewComp = new ::toolkit::AnimatedImagesPeer;
+                }
             break;
-            default:    DBG_ERRORFILE( "UNO3!" );
+            default:
+                OSL_ENSURE( false, "VCLXToolkit::ImplCreateWindow: unknown window type!" );
+                break;
         }
     }
 
@@ -1043,7 +1076,7 @@ css::uno::Reference< css::awt::XWindowPeer > VCLXToolkit::ImplCreateWindow(
     // try to load the lib
     if ( !fnSvtCreateWindow && !hSvToolsLib )
     {
-        ::rtl::OUString aLibName = ::vcl::unohelper::CreateLibraryName( "svt", TRUE );
+        ::rtl::OUString aLibName = ::vcl::unohelper::CreateLibraryName( "svt", sal_True );
         hSvToolsLib = osl_loadModuleRelative(
             &thisModule, aLibName.pData, SAL_LOADMODULE_DEFAULT );
         if ( hSvToolsLib )
@@ -1090,11 +1123,11 @@ css::uno::Reference< css::awt::XWindowPeer > VCLXToolkit::ImplCreateWindow(
         }
         else
         {
-            pNewComp->SetCreatedWithToolkit( TRUE );
+            pNewComp->SetCreatedWithToolkit( sal_True );
             xRef = pNewComp;
             pNewWindow->SetComponentInterface( xRef );
         }
-        DBG_ASSERT( pNewWindow->GetComponentInterface( FALSE ) == xRef,
+        DBG_ASSERT( pNewWindow->GetComponentInterface( sal_False ) == xRef,
             "VCLXToolkit::createWindow: did #133706# resurge?" );
 
         if ( rDescriptor.WindowAttributes & ::com::sun::star::awt::WindowAttribute::SHOW )
diff --git a/toolkit/source/awt/vclxwindow.cxx b/toolkit/source/awt/vclxwindow.cxx
index 808f3578ef97..669b49e29313 100644
--- a/toolkit/source/awt/vclxwindow.cxx
+++ b/toolkit/source/awt/vclxwindow.cxx
@@ -65,6 +65,7 @@
 #include <vcl/tabpage.hxx>
 #include <vcl/button.hxx>
 #include <comphelper/asyncnotification.hxx>
+#include <comphelper/flagguard.hxx>
 #include <toolkit/helper/solarrelease.hxx>
 #include "stylesettings.hxx"
 #include <tools/urlobj.hxx>
@@ -95,32 +96,6 @@ namespace MouseWheelBehavior = ::com::sun::star::awt::MouseWheelBehavior;
 using ::toolkit::ReleaseSolarMutex;
 
 //====================================================================
-//= misc helpers
-//====================================================================
-namespace
-{
-    //................................................................
-    //. FlagGuard
-    //................................................................
-    class FlagGuard
-    {
-    private:
-        bool&   m_rFlag;
-
-    public:
-        FlagGuard( bool& _rFlag )
-            :m_rFlag( _rFlag )
-        {
-            m_rFlag = true;
-        }
-        ~FlagGuard()
-        {
-            m_rFlag = false;
-        }
-    };
-}
-
-//====================================================================
 //= VCLXWindowImpl
 //====================================================================
 class SAL_DLLPRIVATE VCLXWindowImpl
@@ -151,7 +126,7 @@ private:
     TopWindowListenerMultiplexer        maTopWindowListeners;
 
     CallbackArray                       maCallbackEvents;
-    ULONG                               mnCallbackEventId;
+    sal_uLong                               mnCallbackEventId;
 
 public:
     bool                                mbDisposing             : 1;
@@ -159,7 +134,7 @@ public:
     bool                                mbSynthesizingVCLEvent  : 1;
     bool                                mbWithDefaultProps      : 1;
 
-    ULONG                               mnListenerLockLevel;
+    sal_uLong                               mnListenerLockLevel;
     sal_Int16                           mnWritingMode;
     sal_Int16                           mnContextWritingMode;
 
@@ -895,7 +870,7 @@ void VCLXWindow::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
         {
             if ( mpImpl->getDockableWindowListeners().getLength() )
             {
-                BOOL *p_bFloating = (BOOL*)rVclWindowEvent.GetData();
+                sal_Bool *p_bFloating = (sal_Bool*)rVclWindowEvent.GetData();
 
                 ::com::sun::star::lang::EventObject aEvent;
                 aEvent.Source = (::cppu::OWeakObject*)this;
@@ -954,7 +929,7 @@ void VCLXWindow::SetSynthesizingVCLEvent( sal_Bool _b )
     mpImpl->mbSynthesizingVCLEvent = _b;
 }
 
-BOOL VCLXWindow::IsSynthesizingVCLEvent() const
+sal_Bool VCLXWindow::IsSynthesizingVCLEvent() const
 {
     return mpImpl->mbSynthesizingVCLEvent;
 }
@@ -1095,7 +1070,7 @@ void VCLXWindow::setEnable( sal_Bool bEnable ) throw(::com::sun::star::uno::Runt
     Window* pWindow = GetWindow();
     if ( pWindow )
     {
-        pWindow->Enable( bEnable, FALSE ); // #95824# without children!
+        pWindow->Enable( bEnable, sal_False ); // #95824# without children!
         pWindow->EnableInput( bEnable );
     }
 }
@@ -1120,7 +1095,7 @@ void VCLXWindow::addWindowListener( const ::com::sun::star::uno::Reference< ::co
 
     // #100119# Get all resize events, even if height or width 0, or invisible
     if ( GetWindow() )
-        GetWindow()->EnableAllResize( TRUE );
+        GetWindow()->EnableAllResize( sal_True );
 }
 
 void VCLXWindow::removeWindowListener( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowListener >& rxListener ) throw(::com::sun::star::uno::RuntimeException)
@@ -1353,7 +1328,7 @@ namespace toolkit
         (aStyleSettings.*pSetter)( Color( nColor ) );
 
         aSettings.SetStyleSettings( aStyleSettings );
-        _pWindow->SetSettings( aSettings, TRUE );
+        _pWindow->SetSettings( aSettings, sal_True );
     }
 }
 
@@ -1429,11 +1404,11 @@ namespace
 {
     void    lcl_updateWritingMode( Window& _rWindow, const sal_Int16 _nWritingMode, const sal_Int16 _nContextWritingMode )
     {
-        BOOL bEnableRTL = FALSE;
+        sal_Bool bEnableRTL = sal_False;
         switch ( _nWritingMode )
         {
-        case WritingMode2::LR_TB:   bEnableRTL = FALSE; break;
-        case WritingMode2::RL_TB:   bEnableRTL = TRUE; break;
+        case WritingMode2::LR_TB:   bEnableRTL = sal_False; break;
+        case WritingMode2::RL_TB:   bEnableRTL = sal_True; break;
         case WritingMode2::CONTEXT:
         {
             // consult our ContextWritingMode. If it has an explicit RTL/LTR value, then use
@@ -1441,8 +1416,8 @@ namespace
             // own window for its RTL mode
             switch ( _nContextWritingMode )
             {
-                case WritingMode2::LR_TB:   bEnableRTL = FALSE; break;
-                case WritingMode2::RL_TB:   bEnableRTL = TRUE; break;
+                case WritingMode2::LR_TB:   bEnableRTL = sal_False; break;
+                case WritingMode2::RL_TB:   bEnableRTL = sal_True; break;
                 case WritingMode2::CONTEXT:
                 {
                     const Window* pParent = _rWindow.GetParent();
@@ -1513,7 +1488,7 @@ void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::
             AllSettings aSettings = pWindow->GetSettings();
             MouseSettings aMouseSettings = aSettings.GetMouseSettings();
 
-            USHORT nVclBehavior( MOUSE_WHEEL_FOCUS_ONLY );
+            sal_uInt16 nVclBehavior( MOUSE_WHEEL_FOCUS_ONLY );
             switch ( nWheelBehavior )
             {
             case MouseWheelBehavior::SCROLL_DISABLED:   nVclBehavior = MOUSE_WHEEL_DISABLE;     break;
@@ -1525,7 +1500,7 @@ void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::
 
             aMouseSettings.SetWheelBehavior( nWheelBehavior );
             aSettings.SetMouseSettings( aMouseSettings );
-            pWindow->SetSettings( aSettings, TRUE );
+            pWindow->SetSettings( aSettings, sal_True );
         }
         break;
 
@@ -1680,7 +1655,7 @@ void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::
                         // support transparency only for special controls
                         pWindow->SetBackground();
                         pWindow->SetControlBackground();
-                        pWindow->SetPaintTransparent( TRUE );
+                        pWindow->SetPaintTransparent( sal_True );
                         break;
                     }
 
@@ -1713,7 +1688,7 @@ void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::
                         case WINDOW_RADIOBUTTON:
                         case WINDOW_GROUPBOX:
                         case WINDOW_FIXEDLINE:
-                            pWindow->SetPaintTransparent( FALSE );
+                            pWindow->SetPaintTransparent( sal_False );
                         default: ;
                     }
                     pWindow->Invalidate();  // Falls das Control nicht drauf reagiert
@@ -1945,7 +1920,7 @@ void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::
 
         case BASEPROPERTY_REPEAT:
         {
-            sal_Bool bRepeat( FALSE );
+            sal_Bool bRepeat( sal_False );
             Value >>= bRepeat;
 
             WinBits nStyle = pWindow->GetStyle();
@@ -1968,7 +1943,7 @@ void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::
                 aMouseSettings.SetButtonRepeat( nRepeatDelay );
                 aSettings.SetMouseSettings( aMouseSettings );
 
-                pWindow->SetSettings( aSettings, TRUE );
+                pWindow->SetSettings( aSettings, sal_True );
             }
         }
         break;
@@ -2023,7 +1998,7 @@ void VCLXWindow::setProperty( const ::rtl::OUString& PropertyName, const ::com::
 
             case BASEPROPERTY_MOUSE_WHEEL_BEHAVIOUR:
             {
-                USHORT nVclBehavior = GetWindow()->GetSettings().GetMouseSettings().GetWheelBehavior();
+                sal_uInt16 nVclBehavior = GetWindow()->GetSettings().GetMouseSettings().GetWheelBehavior();
                 sal_Int16 nBehavior = MouseWheelBehavior::SCROLL_FOCUS_ONLY;
                 switch ( nVclBehavior )
                 {
@@ -2347,9 +2322,9 @@ void VCLXWindow::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno:
             // #i40647# / 2005-01-18 / frank.schoenheit@sun.com
             if ( !mpImpl->getDrawingOntoParent_ref() )
             {
-                FlagGuard aDrawingflagGuard( mpImpl->getDrawingOntoParent_ref() );
+                ::comphelper::FlagGuard aDrawingflagGuard( mpImpl->getDrawingOntoParent_ref() );
 
-                BOOL bWasVisible = pWindow->IsVisible();
+                sal_Bool bWasVisible = pWindow->IsVisible();
                 Point aOldPos( pWindow->GetPosPixel() );
 
                 if ( bWasVisible && aOldPos == aPos )
@@ -2374,7 +2349,7 @@ void VCLXWindow::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno:
 
                 pWindow->SetPosPixel( aOldPos );
                 if ( bWasVisible )
-                    pWindow->Show( TRUE );
+                    pWindow->Show( sal_True );
             }
         }
         else if ( pDev )
@@ -2393,12 +2368,12 @@ void VCLXWindow::draw( sal_Int32 nX, sal_Int32 nY ) throw(::com::sun::star::uno:
             }
             else
             {
-                BOOL bOldNW =pWindow->IsNativeWidgetEnabled();
+                sal_Bool bOldNW =pWindow->IsNativeWidgetEnabled();
                 if( bOldNW )
-                    pWindow->EnableNativeWidget(FALSE);
+                    pWindow->EnableNativeWidget(sal_False);
                 pWindow->PaintToDevice( pDev, aP, aSz );
                 if( bOldNW )
-                    pWindow->EnableNativeWidget(TRUE);
+                    pWindow->EnableNativeWidget(sal_True);
             }
         }
     }
@@ -2494,7 +2469,7 @@ sal_Bool SAL_CALL VCLXWindow::isFloating(  ) throw (::com::sun::star::uno::Runti
     if( pWindow )
         return Window::GetDockingManager()->IsFloating( pWindow );
     else
-        return FALSE;
+        return sal_False;
 }
 
 void SAL_CALL VCLXWindow::setFloatingMode( sal_Bool bFloating ) throw (::com::sun::star::uno::RuntimeException)
@@ -2514,7 +2489,7 @@ sal_Bool SAL_CALL VCLXWindow::isLocked(  ) throw (::com::sun::star::uno::Runtime
     if( pWindow )
         return Window::GetDockingManager()->IsLocked( pWindow );
     else
-        return FALSE;
+        return sal_False;
 }
 
 void SAL_CALL VCLXWindow::lock(  ) throw (::com::sun::star::uno::RuntimeException)
@@ -2545,7 +2520,7 @@ sal_Bool SAL_CALL VCLXWindow::isInPopupMode(  ) throw (::com::sun::star::uno::Ru
 {
     // TODO: remove interface in the next incompatible build
     ::vos::OGuard aGuard( GetMutex() );
-    return FALSE;
+    return sal_False;
 }
 
 
@@ -2587,7 +2562,7 @@ sal_Bool SAL_CALL VCLXWindow::isVisible(  ) throw (::com::sun::star::uno::Runtim
     if( GetWindow() )
         return GetWindow()->IsVisible();
     else
-        return FALSE;
+        return sal_False;
 }
 
 sal_Bool SAL_CALL VCLXWindow::isActive(  ) throw (::com::sun::star::uno::RuntimeException)
@@ -2596,7 +2571,7 @@ sal_Bool SAL_CALL VCLXWindow::isActive(  ) throw (::com::sun::star::uno::Runtime
     if( GetWindow() )
         return GetWindow()->IsActive();
     else
-        return FALSE;
+        return sal_False;
 
 }
 
@@ -2606,7 +2581,7 @@ sal_Bool SAL_CALL VCLXWindow::isEnabled(  ) throw (::com::sun::star::uno::Runtim
     if( GetWindow() )
         return GetWindow()->IsEnabled();
     else
-        return FALSE;
+        return sal_False;
 }
 
 sal_Bool SAL_CALL VCLXWindow::hasFocus(  ) throw (::com::sun::star::uno::RuntimeException)
@@ -2615,7 +2590,7 @@ sal_Bool SAL_CALL VCLXWindow::hasFocus(  ) throw (::com::sun::star::uno::Runtime
     if( GetWindow() )
         return GetWindow()->HasFocus();
     else
-        return FALSE;
+        return sal_False;
 }
 
 // ::com::sun::star::beans::XPropertySetInfo
diff --git a/toolkit/source/awt/vclxwindows.cxx b/toolkit/source/awt/vclxwindows.cxx
index 06c9167336a8..2b3bc2b2c01b 100644
--- a/toolkit/source/awt/vclxwindows.cxx
+++ b/toolkit/source/awt/vclxwindows.cxx
@@ -37,6 +37,7 @@
 #include <toolkit/helper/imagealign.hxx>
 #include <toolkit/helper/accessibilityclient.hxx>
 #include <toolkit/helper/fixedhyperbase.hxx>
+#include <toolkit/helper/tkresmgr.hxx>
 #include <cppuhelper/typeprovider.hxx>
 #include <com/sun/star/awt/VisualEffect.hpp>
 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
@@ -62,6 +63,7 @@
 #include <vcl/scrbar.hxx>
 #include <vcl/svapp.hxx>
 #include <vcl/tabpage.hxx>
+#include <vcl/tabctrl.hxx>
 #include <tools/diagnose_ex.h>
 
 #include <boost/bind.hpp>
@@ -135,24 +137,24 @@ namespace toolkit
             sal_Int32 nWhiteLuminance = Color( COL_WHITE ).GetLuminance();
 
             Color aLightShadow( nBackgroundColor );
-            aLightShadow.IncreaseLuminance( (UINT8)( ( nWhiteLuminance - nBackgroundLuminance ) * 2 / 3 ) );
+            aLightShadow.IncreaseLuminance( (sal_uInt8)( ( nWhiteLuminance - nBackgroundLuminance ) * 2 / 3 ) );
             aStyleSettings.SetLightBorderColor( aLightShadow );
 
             Color aLight( nBackgroundColor );
-            aLight.IncreaseLuminance( (UINT8)( ( nWhiteLuminance - nBackgroundLuminance ) * 1 / 3 ) );
+            aLight.IncreaseLuminance( (sal_uInt8)( ( nWhiteLuminance - nBackgroundLuminance ) * 1 / 3 ) );
             aStyleSettings.SetLightColor( aLight );
 
             Color aShadow( nBackgroundColor );
-            aShadow.DecreaseLuminance( (UINT8)( nBackgroundLuminance * 1 / 3 ) );
+            aShadow.DecreaseLuminance( (sal_uInt8)( nBackgroundLuminance * 1 / 3 ) );
             aStyleSettings.SetShadowColor( aShadow );
 
             Color aDarkShadow( nBackgroundColor );
-            aDarkShadow.DecreaseLuminance( (UINT8)( nBackgroundLuminance * 2 / 3 ) );
+            aDarkShadow.DecreaseLuminance( (sal_uInt8)( nBackgroundLuminance * 2 / 3 ) );
             aStyleSettings.SetDarkShadowColor( aDarkShadow );
         }
 
         aSettings.SetStyleSettings( aStyleSettings );
-        _pWindow->SetSettings( aSettings, TRUE );
+        _pWindow->SetSettings( aSettings, sal_True );
     }
 
     Any getButtonLikeFaceColor( const Window* _pWindow )
@@ -173,7 +175,7 @@ namespace toolkit
         _pWindow->SetStyle( nStyle );
     }
 
-    static void setVisualEffect( const Any& _rValue, Window* _pWindow, void (StyleSettings::*pSetter)( USHORT ), sal_Int16 _nFlatBits, sal_Int16 _n3DBits )
+    static void setVisualEffect( const Any& _rValue, Window* _pWindow )
     {
         AllSettings aSettings = _pWindow->GetSettings();
         StyleSettings aStyleSettings = aSettings.GetStyleSettings();
@@ -183,22 +185,22 @@ namespace toolkit
         switch ( nStyle )
         {
         case FLAT:
-            (aStyleSettings.*pSetter)( _nFlatBits );
+            aStyleSettings.SetOptions( aStyleSettings.GetOptions() & ~STYLE_OPTION_MONO );
             break;
         case LOOK3D:
         default:
-            (aStyleSettings.*pSetter)( _n3DBits );
+            aStyleSettings.SetOptions( aStyleSettings.GetOptions() | STYLE_OPTION_MONO );
         }
         aSettings.SetStyleSettings( aStyleSettings );
         _pWindow->SetSettings( aSettings );
     }
 
-    static Any getVisualEffect( Window* _pWindow, USHORT (StyleSettings::*pGetter)( ) const, sal_Int16 _nFlatBits )
+    static Any getVisualEffect( Window* _pWindow )
     {
         Any aEffect;
 
         StyleSettings aStyleSettings = _pWindow->GetSettings().GetStyleSettings();
-        if ( (aStyleSettings.*pGetter)() == _nFlatBits )
+        if ( (aStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
             aEffect <<= (sal_Int16)FLAT;
         else
             aEffect <<= (sal_Int16)LOOK3D;
@@ -219,7 +221,7 @@ void VCLXGraphicControl::ImplSetNewImage()
 {
     OSL_PRECOND( GetWindow(), "VCLXGraphicControl::ImplSetNewImage: window is required to be not-NULL!" );
     Button* pButton = static_cast< Button* >( GetWindow() );
-    pButton->SetModeBitmap( GetBitmap() );
+    pButton->SetModeImage( GetImage() );
 }
 
 void VCLXGraphicControl::setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, short Flags ) throw(::com::sun::star::uno::RuntimeException)
@@ -660,14 +662,14 @@ void VCLXImageControl::ImplSetNewImage()
 {
     OSL_PRECOND( GetWindow(), "VCLXImageControl::ImplSetNewImage: window is required to be not-NULL!" );
     ImageControl* pControl = static_cast< ImageControl* >( GetWindow() );
-    pControl->SetBitmap( GetBitmap() );
+    pControl->SetImage( GetImage() );
 }
 
 ::com::sun::star::awt::Size VCLXImageControl::getMinimumSize(  ) throw(::com::sun::star::uno::RuntimeException)
 {
     ::vos::OGuard aGuard( GetMutex() );
 
-    Size aSz = GetBitmap().GetSizePixel();
+    Size aSz = GetImage().GetSizePixel();
     aSz = ImplCalcWindowSize( aSz );
 
     return AWTSize(aSz);
@@ -961,7 +963,7 @@ void VCLXCheckBox::setProperty( const ::rtl::OUString& PropertyName, const ::com
         switch ( nPropType )
         {
             case BASEPROPERTY_VISUALEFFECT:
-                ::toolkit::setVisualEffect( Value, pCheckBox, &StyleSettings::SetCheckBoxStyle, STYLE_CHECKBOX_MONO, STYLE_CHECKBOX_WIN );
+                ::toolkit::setVisualEffect( Value, pCheckBox );
                 break;
 
             case BASEPROPERTY_TRISTATE:
@@ -998,7 +1000,7 @@ void VCLXCheckBox::setProperty( const ::rtl::OUString& PropertyName, const ::com
         switch ( nPropType )
         {
             case BASEPROPERTY_VISUALEFFECT:
-                aProp = ::toolkit::getVisualEffect( pCheckBox, &StyleSettings::GetCheckBoxStyle, STYLE_CHECKBOX_MONO );
+                aProp = ::toolkit::getVisualEffect( pCheckBox );
                 break;
             case BASEPROPERTY_TRISTATE:
                  aProp <<= (sal_Bool)pCheckBox->IsTriStateEnabled();
@@ -1133,7 +1135,7 @@ void VCLXRadioButton::setProperty( const ::rtl::OUString& PropertyName, const ::
         switch ( nPropType )
         {
             case BASEPROPERTY_VISUALEFFECT:
-                ::toolkit::setVisualEffect( Value, pButton, &StyleSettings::SetRadioButtonStyle, STYLE_RADIOBUTTON_MONO, STYLE_RADIOBUTTON_WIN );
+                ::toolkit::setVisualEffect( Value, pButton );
                 break;
 
             case BASEPROPERTY_STATE:
@@ -1141,7 +1143,7 @@ void VCLXRadioButton::setProperty( const ::rtl::OUString& PropertyName, const ::
                 sal_Int16 n = sal_Int16();
                 if ( Value >>= n )
                 {
-                    BOOL b = n ? sal_True : sal_False;
+                    sal_Bool b = n ? sal_True : sal_False;
                     if ( pButton->IsRadioCheckEnabled() )
                         pButton->Check( b );
                     else
@@ -1176,7 +1178,7 @@ void VCLXRadioButton::setProperty( const ::rtl::OUString& PropertyName, const ::
         switch ( nPropType )
         {
             case BASEPROPERTY_VISUALEFFECT:
-                aProp = ::toolkit::getVisualEffect( pButton, &StyleSettings::GetRadioButtonStyle, STYLE_RADIOBUTTON_MONO );
+                aProp = ::toolkit::getVisualEffect( pButton );
                 break;
             case BASEPROPERTY_STATE:
                 aProp <<= (sal_Int16) ( pButton->IsChecked() ? 1 : 0 );
@@ -1310,11 +1312,11 @@ void VCLXRadioButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent
                 aEvent.ActionCommand = maActionCommand;
                 maActionListeners.actionPerformed( aEvent );
             }
-            ImplClickedOrToggled( FALSE );
+            ImplClickedOrToggled( sal_False );
             break;
 
         case VCLEVENT_RADIOBUTTON_TOGGLE:
-            ImplClickedOrToggled( TRUE );
+            ImplClickedOrToggled( sal_True );
             break;
 
         default:
@@ -1323,7 +1325,7 @@ void VCLXRadioButton::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent
     }
 }
 
-void VCLXRadioButton::ImplClickedOrToggled( BOOL bToggled )
+void VCLXRadioButton::ImplClickedOrToggled( sal_Bool bToggled )
 {
     // In the formulars, RadioChecked is not enabled, call itemStateChanged only for click
     // In the dialog editor, RadioChecked is enabled, call itemStateChanged only for bToggled
@@ -1716,14 +1718,14 @@ void VCLXListBox::selectItemsPos( const ::com::sun::star::uno::Sequence<sal_Int1
     ListBox* pBox = (ListBox*) GetWindow();
     if ( pBox )
     {
-        BOOL bChanged = FALSE;
+        sal_Bool bChanged = sal_False;
         for ( sal_uInt16 n = (sal_uInt16)aPositions.getLength(); n; )
         {
-            USHORT nPos = (USHORT) aPositions.getConstArray()[--n];
+            sal_uInt16 nPos = (sal_uInt16) aPositions.getConstArray()[--n];
             if ( pBox->IsEntryPosSelected( nPos ) != bSelect )
             {
                 pBox->SelectEntryPos( nPos, bSelect );
-                bChanged = TRUE;
+                bChanged = sal_True;
             }
         }
 
@@ -2068,34 +2070,32 @@ void VCLXListBox::ImplCallItemListeners()
         maItemListeners.itemStateChanged( aEvent );
     }
 }
-
 namespace
 {
-    Image lcl_getImageFromURL( const ::rtl::OUString& i_rImageURL )
-    {
-        if ( !i_rImageURL.getLength() )
-            return Image();
+     Image lcl_getImageFromURL( const ::rtl::OUString& i_rImageURL )
+     {
+         if ( !i_rImageURL.getLength() )
+             return Image();
 
         try
         {
-            ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() );
-            Reference< XGraphicProvider > xProvider;
-            if ( aContext.createComponent( "com.sun.star.graphic.GraphicProvider", xProvider ) )
-            {
-                ::comphelper::NamedValueCollection aMediaProperties;
-                aMediaProperties.put( "URL", i_rImageURL );
-                Reference< XGraphic > xGraphic = xProvider->queryGraphic( aMediaProperties.getPropertyValues() );
+             ::comphelper::ComponentContext aContext( ::comphelper::getProcessServiceFactory() );
+             Reference< XGraphicProvider > xProvider;
+             if ( aContext.createComponent( "com.sun.star.graphic.GraphicProvider", xProvider ) )
+             {
+                 ::comphelper::NamedValueCollection aMediaProperties;
+                 aMediaProperties.put( "URL", i_rImageURL );
+                 Reference< XGraphic > xGraphic = xProvider->queryGraphic( aMediaProperties.getPropertyValues() );
                 return Image( xGraphic );
-            }
-        }
-        catch( const uno::Exception& )
-        {
-            DBG_UNHANDLED_EXCEPTION();
-        }
-        return Image();
-    }
+             }
+         }
+         catch( const uno::Exception& )
+         {
+             DBG_UNHANDLED_EXCEPTION();
+         }
+         return Image();
+     }
 }
-
 void SAL_CALL VCLXListBox::listItemInserted( const ItemListEvent& i_rEvent ) throw (RuntimeException)
 {
     ::vos::OGuard aGuard( GetMutex() );
@@ -2107,7 +2107,7 @@ void SAL_CALL VCLXListBox::listItemInserted( const ItemListEvent& i_rEvent ) thr
         "VCLXListBox::listItemInserted: illegal (inconsistent) item position!" );
     pListBox->InsertEntry(
         i_rEvent.ItemText.IsPresent ? i_rEvent.ItemText.Value : ::rtl::OUString(),
-        i_rEvent.ItemImageURL.IsPresent ? lcl_getImageFromURL( i_rEvent.ItemImageURL.Value ) : Image(),
+        i_rEvent.ItemImageURL.IsPresent ? TkResMgr::getImageFromURL( i_rEvent.ItemImageURL.Value ) : Image(),
         i_rEvent.ItemPosition );
 }
 
@@ -2137,7 +2137,7 @@ void SAL_CALL VCLXListBox::listItemModified( const ItemListEvent& i_rEvent ) thr
     // VCL's ListBox does not support changing an entry's text or image, so remove and re-insert
 
     const ::rtl::OUString sNewText = i_rEvent.ItemText.IsPresent ? i_rEvent.ItemText.Value : ::rtl::OUString( pListBox->GetEntry( i_rEvent.ItemPosition ) );
-    const Image aNewImage( i_rEvent.ItemImageURL.IsPresent ? lcl_getImageFromURL( i_rEvent.ItemImageURL.Value ) : pListBox->GetEntryImage( i_rEvent.ItemPosition  ) );
+    const Image aNewImage( i_rEvent.ItemImageURL.IsPresent ? TkResMgr::getImageFromURL( i_rEvent.ItemImageURL.Value ) : pListBox->GetEntryImage( i_rEvent.ItemPosition  ) );
 
     pListBox->RemoveEntry( i_rEvent.ItemPosition );
     pListBox->InsertEntry( sNewText, aNewImage, i_rEvent.ItemPosition );
@@ -2554,6 +2554,15 @@ throw(::com::sun::star::uno::RuntimeException)
                 }
             }
             break;
+            case BASEPROPERTY_TITLE:
+                {
+                    ::rtl::OUString sTitle;
+                    if ( Value >>= sTitle )
+                    {
+                        pTabPage->SetText(sTitle);
+                    }
+                }
+                break;
 
             default:
             {
@@ -3251,7 +3260,7 @@ void VCLXScrollBar::setProperty( const ::rtl::OUString& PropertyName, const ::co
                 }
                 AllSettings aSettings( pScrollBar->GetSettings() );
                 StyleSettings aStyle( aSettings.GetStyleSettings() );
-                ULONG nDragOptions = aStyle.GetDragFullOptions();
+                sal_uLong nDragOptions = aStyle.GetDragFullOptions();
                 if ( bDo )
                     nDragOptions |= DRAGFULL_OPTION_SCROLL;
                 else
diff --git a/toolkit/source/awt/xsimpleanimation.cxx b/toolkit/source/awt/xsimpleanimation.cxx
index c7ccbde118f4..75701cb94b46 100644
--- a/toolkit/source/awt/xsimpleanimation.cxx
+++ b/toolkit/source/awt/xsimpleanimation.cxx
@@ -29,8 +29,8 @@
 #include "precompiled_toolkit.hxx"
 #include "toolkit/awt/xsimpleanimation.hxx"
 #include "toolkit/helper/property.hxx"
-#include "toolkit/helper/throbberimpl.hxx"
 #include <tools/debug.hxx>
+#include <vcl/throbber.hxx>
 
 //........................................................................
 namespace toolkit
@@ -48,54 +48,40 @@ namespace toolkit
     XSimpleAnimation::XSimpleAnimation()
     {
         DBG_CTOR( XSimpleAnimation, NULL );
-        mbRepeat = sal_True;
-        mnStepTime = 100;
-        mpThrobber = new Throbber_Impl( this, mnStepTime, mbRepeat );
     }
 
     //--------------------------------------------------------------------
     XSimpleAnimation::~XSimpleAnimation()
     {
         DBG_DTOR( XSimpleAnimation, NULL );
-        delete mpThrobber;
     }
 
     //--------------------------------------------------------------------
-    IMPLEMENT_FORWARD_XINTERFACE2( XSimpleAnimation, VCLXWindow, XSimpleAnimation_Base )
-
-    //--------------------------------------------------------------------
-    IMPLEMENT_FORWARD_XTYPEPROVIDER2( XSimpleAnimation, VCLXWindow, XSimpleAnimation_Base )
-
-    //--------------------------------------------------------------------
     void SAL_CALL XSimpleAnimation::start() throw ( uno::RuntimeException )
     {
-        mpThrobber->start();
+        ::vos::OGuard aGuard( GetMutex() );
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            pThrobber->start();
     }
 
     //--------------------------------------------------------------------
     void SAL_CALL XSimpleAnimation::stop() throw ( uno::RuntimeException )
     {
-        mpThrobber->stop();
+        ::vos::OGuard aGuard( GetMutex() );
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            pThrobber->stop();
     }
 
     //--------------------------------------------------------------------
     void SAL_CALL XSimpleAnimation::setImageList( const uno::Sequence< uno::Reference< graphic::XGraphic > >& rImageList )
         throw ( uno::RuntimeException )
     {
-        mpThrobber->setImageList( rImageList );
-    }
-
-    //--------------------------------------------------------------------
-    void XSimpleAnimation::ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent )
-    {
-        // TODO: XSimpleAnimation::ProcessWindowEvent
-        //::vos::OClearableGuard aGuard( GetMutex() );
-        //Reference< XSimpleAnimation > xKeepAlive( this );
-        //SpinButton* pSpinButton = static_cast< SpinButton* >( GetWindow() );
-        //if ( !pSpinButton )
-        //    return;
-
-        VCLXWindow::ProcessWindowEvent( _rVclWindowEvent );
+        ::vos::OGuard aGuard( GetMutex() );
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            pThrobber->setImageList( rImageList );
     }
 
     //--------------------------------------------------------------------
@@ -104,33 +90,31 @@ namespace toolkit
     {
         ::vos::OGuard aGuard( GetMutex() );
 
-        if ( GetWindow() )
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber == NULL )
         {
-            sal_uInt16 nPropertyId = GetPropertyId( PropertyName );
-            switch ( nPropertyId )
-            {
-                case BASEPROPERTY_STEP_TIME: {
-                    sal_Int32   nStepTime( 0 );
-                    if ( Value >>= nStepTime )
-                    {
-                        mnStepTime = nStepTime;
-                        mpThrobber->setStepTime( mnStepTime );
-                    }
-
-                    break;
-                }
-                case BASEPROPERTY_REPEAT: {
-                    sal_Bool bRepeat( sal_True );
-                    if ( Value >>= bRepeat )
-                    {
-                        mbRepeat = bRepeat;
-                        mpThrobber->setRepeat( mbRepeat );
-                    }
-                    break;
-                }
-                default:
-                    VCLXWindow::setProperty( PropertyName, Value );
+            VCLXWindow::setProperty( PropertyName, Value );
+            return;
+        }
+
+        sal_uInt16 nPropertyId = GetPropertyId( PropertyName );
+        switch ( nPropertyId )
+        {
+            case BASEPROPERTY_STEP_TIME: {
+                sal_Int32   nStepTime( 0 );
+                if ( Value >>= nStepTime )
+                    pThrobber->setStepTime( nStepTime );
+
+                break;
             }
+            case BASEPROPERTY_REPEAT: {
+                sal_Bool bRepeat( sal_True );
+                if ( Value >>= bRepeat )
+                    pThrobber->setRepeat( bRepeat );
+                break;
+            }
+            default:
+                VCLXWindow::setProperty( PropertyName, Value );
         }
     }
 
@@ -140,22 +124,22 @@ namespace toolkit
     {
         ::vos::OGuard aGuard( GetMutex() );
 
-        uno::Any aReturn;
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber == NULL )
+            return VCLXWindow::getProperty( PropertyName );
 
-        if ( GetWindow() )
+        uno::Any aReturn;
+        sal_uInt16 nPropertyId = GetPropertyId( PropertyName );
+        switch ( nPropertyId )
         {
-            sal_uInt16 nPropertyId = GetPropertyId( PropertyName );
-            switch ( nPropertyId )
-            {
-            case BASEPROPERTY_STEP_TIME:
-                aReturn <<= mnStepTime;
-                break;
-            case BASEPROPERTY_REPEAT:
-                aReturn <<= mbRepeat;
-                break;
-            default:
-                aReturn = VCLXWindow::getProperty( PropertyName );
-            }
+        case BASEPROPERTY_STEP_TIME:
+            aReturn <<= pThrobber->getStepTime();
+            break;
+        case BASEPROPERTY_REPEAT:
+            aReturn <<= pThrobber->getRepeat();
+            break;
+        default:
+            aReturn = VCLXWindow::getProperty( PropertyName );
         }
         return aReturn;
     }
diff --git a/toolkit/source/awt/xthrobber.cxx b/toolkit/source/awt/xthrobber.cxx
index 439fb49c1cbe..3b9b361202e9 100644
--- a/toolkit/source/awt/xthrobber.cxx
+++ b/toolkit/source/awt/xthrobber.cxx
@@ -30,7 +30,6 @@
 #include "toolkit/awt/xthrobber.hxx"
 #include "toolkit/helper/property.hxx"
 #include <toolkit/helper/tkresmgr.hxx>
-#include <toolkit/helper/throbberimpl.hxx>
 
 #ifndef _TOOLKIT_AWT_XTHROBBER_HRC_
 #include "xthrobber.hrc"
@@ -38,6 +37,7 @@
 #include <tools/debug.hxx>
 #include <vcl/fixed.hxx>
 #include <vcl/timer.hxx>
+#include <vcl/throbber.hxx>
 
 //........................................................................
 namespace toolkit
@@ -55,82 +55,37 @@ namespace toolkit
     XThrobber::XThrobber()
     {
         DBG_CTOR( XThrobber, NULL );
-
-        mpThrobber = new Throbber_Impl( this, 100, sal_True );
-
-        InitImageList();
     }
 
     //--------------------------------------------------------------------
     XThrobber::~XThrobber()
     {
         DBG_DTOR( XThrobber, NULL );
-        delete mpThrobber;
     }
 
     //--------------------------------------------------------------------
-    IMPLEMENT_FORWARD_XINTERFACE2( XThrobber, VCLXWindow, XThrobber_Base )
-
-    //--------------------------------------------------------------------
-    IMPLEMENT_FORWARD_XTYPEPROVIDER2( XThrobber, VCLXWindow, XThrobber_Base )
-
-    //--------------------------------------------------------------------
     void SAL_CALL XThrobber::start() throw ( uno::RuntimeException )
     {
-        mpThrobber->start();
+        ::vos::OGuard aGuard( GetMutex() );
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            pThrobber->start();
     }
 
     //--------------------------------------------------------------------
     void SAL_CALL XThrobber::stop() throw ( uno::RuntimeException )
     {
-        mpThrobber->stop();
-    }
-
-    //--------------------------------------------------------------------
-    void XThrobber::ProcessWindowEvent( const VclWindowEvent& _rVclWindowEvent )
-    {
-        static bool bInit = false;
-        if ( !bInit )
-        {
-            // Images won't be shown if set too early
-            mpThrobber->initImage();
-            bInit = true;
-        }
-        // TODO: XSimpleAnimation::ProcessWindowEvent
-        //::vos::OClearableGuard aGuard( GetMutex() );
-        //Reference< XSimpleAnimation > xKeepAlive( this );
-        //SpinButton* pSpinButton = static_cast< SpinButton* >( GetWindow() );
-        //if ( !pSpinButton )
-        //    return;
-
-        VCLXWindow::ProcessWindowEvent( _rVclWindowEvent );
-    }
-
-    //--------------------------------------------------------------------
-    void SAL_CALL XThrobber::setProperty( const ::rtl::OUString& PropertyName, const uno::Any& Value )
-        throw( uno::RuntimeException )
-    {
         ::vos::OGuard aGuard( GetMutex() );
-
-        if ( GetWindow() )
-        {
-            VCLXWindow::setProperty( PropertyName, Value );
-        }
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber != NULL)
+            pThrobber->stop();
     }
 
     //--------------------------------------------------------------------
-    uno::Any SAL_CALL XThrobber::getProperty( const ::rtl::OUString& PropertyName )
-        throw( uno::RuntimeException )
+    void XThrobber::SetWindow( Window* pWindow )
     {
-        ::vos::OGuard aGuard( GetMutex() );
-
-        uno::Any aReturn;
-
-        if ( GetWindow() )
-        {
-            aReturn = VCLXWindow::getProperty( PropertyName );
-        }
-        return aReturn;
+        XThrobber_Base::SetWindow( pWindow );
+        InitImageList();
     }
 
     //--------------------------------------------------------------------
@@ -138,10 +93,15 @@ namespace toolkit
         throw( uno::RuntimeException )
     {
         ::vos::OGuard aGuard( GetMutex() );
+
+        Throbber* pThrobber( dynamic_cast< Throbber* >( GetWindow() ) );
+        if ( pThrobber == NULL)
+            return;
+
         uno::Sequence< uno::Reference< graphic::XGraphic > > aImageList(12);
         sal_uInt16 nIconIdStart = RID_TK_ICON_THROBBER_START;
 
-        if ( mpThrobber->isHCMode() )
+        if ( pThrobber->GetSettings().GetStyleSettings().GetHighContrastMode() )
             nIconIdStart = RID_TK_HC_ICON_THROBBER_START;
 
         for ( sal_uInt16 i=0; i<12; i++ )
@@ -150,7 +110,7 @@ namespace toolkit
             aImageList[i] = aImage.GetXGraphic();
         }
 
-        mpThrobber->setImageList( aImageList );
+        pThrobber->setImageList( aImageList );
     }
 
 //........................................................................