Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

31 files changed, 18540 insertions, 0 deletions

diff --git a/svx/source/unodraw/UnoGraphicExporter.cxx b/svx/source/unodraw/UnoGraphicExporter.cxx
new file mode 100644
index 000000000..545259b37
--- /dev/null
+++ b/svx/source/unodraw/UnoGraphicExporter.cxx
@@ -0,0 +1,1306 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vector>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <com/sun/star/drawing/XDrawPage.hpp>
+#include <com/sun/star/drawing/XGraphicExportFilter.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/graphic/XGraphicRenderer.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+#include <com/sun/star/task/XInteractionHandler.hpp>
+#include <com/sun/star/task/XInteractionContinuation.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+#include <tools/debug.hxx>
+#include <tools/urlobj.hxx>
+#include <comphelper/interaction.hxx>
+#include <framework/interaction.hxx>
+#include <com/sun/star/drawing/GraphicFilterRequest.hpp>
+#include <com/sun/star/util/URL.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <osl/diagnose.h>
+#include <vcl/metaact.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/virdev.hxx>
+#include <svl/outstrm.hxx>
+#include <sdr/contact/objectcontactofobjlistpainter.hxx>
+#include <svx/sdr/contact/viewobjectcontact.hxx>
+#include <svx/sdr/contact/viewcontact.hxx>
+#include <svx/sdr/contact/displayinfo.hxx>
+#include <editeng/numitem.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/xoutbmp.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <svx/unoapi.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/fmview.hxx>
+#include <svx/fmmodel.hxx>
+#include <svx/unopage.hxx>
+#include <svx/svdoutl.hxx>
+#include <svx/xlineit0.hxx>
+#include <editeng/flditem.hxx>
+#include "UnoGraphicExporter.hxx"
+#include <memory>
+
+#define MAX_EXT_PIX         2048
+
+using namespace ::comphelper;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::drawing;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::task;
+
+// #i102251#
+#include <editeng/editstat.hxx>
+
+namespace {
+
+    struct ExportSettings
+    {
+        OUString maFilterName;
+        OUString maMediaType;
+        URL maURL;
+        css::uno::Reference< css::io::XOutputStream >         mxOutputStream;
+        css::uno::Reference< css::graphic::XGraphicRenderer > mxGraphicRenderer;
+        css::uno::Reference< css::task::XStatusIndicator >    mxStatusIndicator;
+        css::uno::Reference< css::task::XInteractionHandler > mxInteractionHandler;
+
+        sal_Int32 mnWidth;
+        sal_Int32 mnHeight;
+        bool mbExportOnlyBackground;
+        bool mbScrollText;
+        bool mbUseHighContrast;
+        bool mbTranslucent;
+
+        Sequence< PropertyValue >   maFilterData;
+
+        Fraction    maScaleX;
+        Fraction    maScaleY;
+
+        TriState meAntiAliasing = TRISTATE_INDET;
+
+        explicit ExportSettings(const SdrModel* pSdrModel);
+    };
+
+    ExportSettings::ExportSettings(const SdrModel* pSdrModel)
+    :   mnWidth( 0 )
+        ,mnHeight( 0 )
+        ,mbExportOnlyBackground( false )
+        ,mbScrollText( false )
+        ,mbUseHighContrast( false )
+        ,mbTranslucent( false )
+        ,maScaleX( 1, 1 )
+        ,maScaleY( 1, 1 )
+    {
+        if (pSdrModel)
+        {
+            maScaleX = pSdrModel->GetScaleFraction();
+            maScaleY = pSdrModel->GetScaleFraction();
+        }
+    }
+
+    /** implements a component to export shapes or pages to external graphic formats.
+
+        @implements com.sun.star.drawing.GraphicExportFilter
+    */
+    class GraphicExporter : public WeakImplHelper< XGraphicExportFilter, XServiceInfo >
+    {
+    public:
+        GraphicExporter();
+
+        // XFilter
+        virtual sal_Bool SAL_CALL filter( const Sequence< PropertyValue >& aDescriptor ) override;
+        virtual void SAL_CALL cancel(  ) override;
+
+        // XExporter
+        virtual void SAL_CALL setSourceDocument( const Reference< XComponent >& xDoc ) override;
+
+        // XServiceInfo
+        virtual OUString SAL_CALL getImplementationName(  ) override;
+        virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+        virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+        // XMimeTypeInfo
+        virtual sal_Bool SAL_CALL supportsMimeType( const OUString& MimeTypeName ) override;
+        virtual Sequence< OUString > SAL_CALL getSupportedMimeTypeNames(  ) override;
+
+        VclPtr<VirtualDevice> CreatePageVDev( SdrPage* pPage, long nWidthPixel, long nHeightPixel ) const;
+
+        DECL_LINK( CalcFieldValueHdl, EditFieldInfo*, void );
+
+        void ParseSettings( const Sequence< PropertyValue >& aDescriptor, ExportSettings& rSettings );
+        bool GetGraphic( ExportSettings const & rSettings, Graphic& aGraphic, bool bVectorType );
+
+    private:
+        Reference< XShape >     mxShape;
+        Reference< XDrawPage >  mxPage;
+        Reference< XShapes >    mxShapes;
+        Graphic maGraphic;
+
+        SvxDrawPage*        mpUnoPage;
+
+        Link<EditFieldInfo*,void> maOldCalcFieldValueHdl;
+        sal_Int32           mnPageNumber;
+        SdrPage*            mpCurrentPage;
+        SdrModel*           mpDoc;
+    };
+
+    /** creates a bitmap that is optionally transparent from a metafile
+    */
+    BitmapEx GetBitmapFromMetaFile( const GDIMetaFile& rMtf,bool bIsSelection, const Size* pSize )
+    {
+        // use new primitive conversion tooling
+        basegfx::B2DRange aRange(basegfx::B2DPoint(0.0, 0.0));
+        sal_uInt32 nMaximumQuadraticPixels(500000);
+
+        if(pSize)
+        {
+            // use 100th mm for primitive bitmap converter tool, input is pixel
+            // use a real OutDev to get the correct DPI, the static LogicToLogic assumes 72dpi which is wrong (!)
+            const Size aSize100th(Application::GetDefaultDevice()->PixelToLogic(*pSize, MapMode(MapUnit::Map100thMM)));
+
+            aRange.expand(basegfx::B2DPoint(aSize100th.Width(), aSize100th.Height()));
+
+            // when explicitly pixels are requested from the GraphicExporter, use a *very* high limit
+            // of 16gb (4096x4096 pixels), else use the default for the converters
+            nMaximumQuadraticPixels = std::min(sal_uInt32(4096 * 4096), sal_uInt32(pSize->Width() * pSize->Height()));
+        }
+        else
+        {
+            // use 100th mm for primitive bitmap converter tool
+            const Size aSize100th(OutputDevice::LogicToLogic(rMtf.GetPrefSize(), rMtf.GetPrefMapMode(), MapMode(MapUnit::Map100thMM)));
+
+            aRange.expand(basegfx::B2DPoint(aSize100th.Width(), aSize100th.Height()));
+        }
+
+        // get hairline and full bound rect to evtl. correct logic size by the
+        // equivalent of one pixel to make those visible at right and bottom
+        tools::Rectangle aHairlineRect;
+        const tools::Rectangle aRect(rMtf.GetBoundRect(*Application::GetDefaultDevice(), &aHairlineRect));
+
+        if(!aRect.IsEmpty())
+        {
+            GDIMetaFile aMtf(rMtf);
+
+            if (bIsSelection)
+            {
+                // tdf#105998 Correct the Metafile using information from it's real sizes measured
+                // using rMtf.GetBoundRect above and a copy
+                const Size aOnePixelInMtf(
+                    Application::GetDefaultDevice()->PixelToLogic(
+                        Size(1, 1),
+                        rMtf.GetPrefMapMode()));
+                const Size aHalfPixelInMtf(
+                    (aOnePixelInMtf.getWidth() + 1) / 2,
+                    (aOnePixelInMtf.getHeight() + 1) / 2);
+                const bool bHairlineBR(
+                    !aHairlineRect.IsEmpty() && (aRect.Right() == aHairlineRect.Right() || aRect.Bottom() == aHairlineRect.Bottom()));
+
+                // Move the content to (0,0), usually TopLeft ist slightly
+                // negative. For better visualization, add a half pixel, too
+                aMtf.Move(
+                    aHalfPixelInMtf.getWidth() - aRect.Left(),
+                    aHalfPixelInMtf.getHeight() - aRect.Top());
+
+                // Do not Scale, but set the PrefSize. Some levels deeper the
+                // MetafilePrimitive will add a mapping to the decomposition
+                // (and possibly a clipping) to map the graphic content to
+                // a unit coordinate system.
+                // Size is the measured size plus one pixel if needed (bHairlineBR)
+                // and the moved half pixwel from above
+                aMtf.SetPrefSize(
+                    Size(
+                        aRect.getWidth() + (bHairlineBR ? aOnePixelInMtf.getWidth() : 0) + aHalfPixelInMtf.getWidth(),
+                        aRect.getHeight() + (bHairlineBR ? aOnePixelInMtf.getHeight() : 0) + aHalfPixelInMtf.getHeight()));
+            }
+
+            return convertMetafileToBitmapEx(aMtf, aRange, nMaximumQuadraticPixels);
+        }
+
+        return BitmapEx();
+    }
+
+    Size* CalcSize( sal_Int32 nWidth, sal_Int32 nHeight, const Size& aBoundSize, Size& aOutSize )
+    {
+        if( (nWidth == 0) && (nHeight == 0) )
+            return nullptr;
+
+        if( (nWidth == 0) && (nHeight != 0) && (aBoundSize.Height() != 0) )
+        {
+            nWidth = ( nHeight * aBoundSize.Width() ) / aBoundSize.Height();
+        }
+        else if( (nWidth != 0) && (nHeight == 0) && (aBoundSize.Width() != 0) )
+        {
+            nHeight = ( nWidth * aBoundSize.Height() ) / aBoundSize.Width();
+        }
+
+        aOutSize.setWidth( nWidth );
+        aOutSize.setHeight( nHeight );
+
+        return &aOutSize;
+    }
+
+class ImplExportCheckVisisbilityRedirector : public sdr::contact::ViewObjectContactRedirector
+{
+public:
+    explicit ImplExportCheckVisisbilityRedirector( SdrPage* pCurrentPage );
+
+    virtual drawinglayer::primitive2d::Primitive2DContainer createRedirectedPrimitive2DSequence(
+        const sdr::contact::ViewObjectContact& rOriginal,
+        const sdr::contact::DisplayInfo& rDisplayInfo) override;
+
+private:
+    SdrPage*    mpCurrentPage;
+};
+
+ImplExportCheckVisisbilityRedirector::ImplExportCheckVisisbilityRedirector( SdrPage* pCurrentPage )
+:   ViewObjectContactRedirector(), mpCurrentPage( pCurrentPage )
+{
+}
+
+drawinglayer::primitive2d::Primitive2DContainer ImplExportCheckVisisbilityRedirector::createRedirectedPrimitive2DSequence(
+    const sdr::contact::ViewObjectContact& rOriginal,
+    const sdr::contact::DisplayInfo& rDisplayInfo)
+{
+    SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
+
+    if(pObject)
+    {
+        SdrPage* pPage = mpCurrentPage;
+
+        if(nullptr == pPage)
+        {
+            pPage = pObject->getSdrPageFromSdrObject();
+        }
+
+        if( (pPage == nullptr) || pPage->checkVisibility(rOriginal, rDisplayInfo, false) )
+        {
+            return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
+        }
+
+        return drawinglayer::primitive2d::Primitive2DContainer();
+    }
+    else
+    {
+        // not an object, maybe a page
+        return sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
+    }
+}
+
+GraphicExporter::GraphicExporter()
+: mpUnoPage( nullptr ), mnPageNumber(-1), mpCurrentPage(nullptr), mpDoc( nullptr )
+{
+}
+
+IMPL_LINK(GraphicExporter, CalcFieldValueHdl, EditFieldInfo*, pInfo, void)
+{
+    if( pInfo )
+    {
+        if( mpCurrentPage )
+        {
+            pInfo->SetSdrPage( mpCurrentPage );
+        }
+        else if( mnPageNumber != -1 )
+        {
+            const SvxFieldData* pField = pInfo->GetField().GetField();
+            if( dynamic_cast<const SvxPageField*>( pField) )
+            {
+                OUString aPageNumValue;
+                bool bUpper = false;
+
+                switch(mpDoc->GetPageNumType())
+                {
+                    case css::style::NumberingType::CHARS_UPPER_LETTER:
+                        aPageNumValue += OUStringChar( sal_Unicode((mnPageNumber - 1) % 26 + 'A') );
+                        break;
+                    case css::style::NumberingType::CHARS_LOWER_LETTER:
+                        aPageNumValue += OUStringChar( sal_Unicode((mnPageNumber - 1) % 26 + 'a') );
+                        break;
+                    case css::style::NumberingType::ROMAN_UPPER:
+                        bUpper = true;
+                        [[fallthrough]];
+                    case css::style::NumberingType::ROMAN_LOWER:
+                        aPageNumValue += SvxNumberFormat::CreateRomanString(mnPageNumber, bUpper);
+                        break;
+                    case css::style::NumberingType::NUMBER_NONE:
+                        aPageNumValue = " ";
+                        break;
+                    default:
+                        aPageNumValue += OUString::number( mnPageNumber );
+                }
+
+                pInfo->SetRepresentation( aPageNumValue );
+
+                return;
+            }
+        }
+    }
+
+    maOldCalcFieldValueHdl.Call( pInfo );
+
+    if( pInfo && mpCurrentPage )
+        pInfo->SetSdrPage( nullptr );
+}
+
+/** creates a virtual device for the given page
+
+    @return the returned VirtualDevice is owned by the caller
+*/
+VclPtr<VirtualDevice> GraphicExporter::CreatePageVDev( SdrPage* pPage, long nWidthPixel, long nHeightPixel ) const
+{
+    VclPtr<VirtualDevice>  pVDev = VclPtr<VirtualDevice>::Create();
+    MapMode         aMM( MapUnit::Map100thMM );
+
+    Point aPoint( 0, 0 );
+    Size aPageSize(pPage->GetSize());
+
+    // use scaling?
+    if( nWidthPixel != 0 )
+    {
+        const Fraction aFrac( nWidthPixel, pVDev->LogicToPixel( aPageSize, aMM ).Width() );
+
+        aMM.SetScaleX( aFrac );
+
+        if( nHeightPixel == 0 )
+            aMM.SetScaleY( aFrac );
+    }
+
+    if( nHeightPixel != 0 )
+    {
+        const Fraction aFrac( nHeightPixel, pVDev->LogicToPixel( aPageSize, aMM ).Height() );
+
+        if( nWidthPixel == 0 )
+            aMM.SetScaleX( aFrac );
+
+        aMM.SetScaleY( aFrac );
+    }
+
+    pVDev->SetMapMode( aMM );
+    bool bSuccess(false);
+
+    // #i122820# If available, use pixel size directly
+    if(nWidthPixel && nHeightPixel)
+    {
+        bSuccess = pVDev->SetOutputSizePixel(Size(nWidthPixel, nHeightPixel));
+    }
+    else
+    {
+        bSuccess = pVDev->SetOutputSize(aPageSize);
+    }
+
+    if(bSuccess)
+    {
+        std::unique_ptr<SdrView> pView(new SdrView(*mpDoc, pVDev));
+
+        pView->SetPageVisible( false );
+        pView->SetBordVisible( false );
+        pView->SetGridVisible( false );
+        pView->SetHlplVisible( false );
+        pView->SetGlueVisible( false );
+        pView->ShowSdrPage(pPage);
+
+        vcl::Region aRegion (tools::Rectangle( aPoint, aPageSize ) );
+
+        ImplExportCheckVisisbilityRedirector aRedirector( mpCurrentPage );
+
+        pView->CompleteRedraw(pVDev, aRegion, &aRedirector);
+    }
+    else
+    {
+        OSL_ENSURE(false, "Could not get a VirtualDevice of requested size (!)");
+    }
+
+    return pVDev;
+}
+
+void GraphicExporter::ParseSettings( const Sequence< PropertyValue >& aDescriptor, ExportSettings& rSettings )
+{
+    for( const PropertyValue& rValue : aDescriptor )
+    {
+        if ( rValue.Name == "FilterName" )
+        {
+            rValue.Value >>= rSettings.maFilterName;
+        }
+        else if ( rValue.Name == "MediaType" )
+        {
+            rValue.Value >>= rSettings.maMediaType;
+        }
+        else if ( rValue.Name == "URL" )
+        {
+            if( !( rValue.Value >>= rSettings.maURL ) )
+            {
+                rValue.Value >>= rSettings.maURL.Complete;
+            }
+        }
+        else if ( rValue.Name == "OutputStream" )
+        {
+            rValue.Value >>= rSettings.mxOutputStream;
+        }
+        else if ( rValue.Name == "GraphicRenderer" )
+        {
+            rValue.Value >>= rSettings.mxGraphicRenderer;
+        }
+        else if ( rValue.Name == "StatusIndicator" )
+        {
+            rValue.Value >>= rSettings.mxStatusIndicator;
+        }
+        else if ( rValue.Name == "InteractionHandler" )
+        {
+            rValue.Value >>= rSettings.mxInteractionHandler;
+        }
+        else if( rValue.Name == "Width" )  // for compatibility reasons, deprecated
+        {
+            rValue.Value >>= rSettings.mnWidth;
+        }
+        else if( rValue.Name == "Height" ) // for compatibility reasons, deprecated
+        {
+            rValue.Value >>= rSettings.mnHeight;
+        }
+        else if( rValue.Name == "ExportOnlyBackground" )   // for compatibility reasons, deprecated
+        {
+            rValue.Value >>= rSettings.mbExportOnlyBackground;
+        }
+        else if ( rValue.Name == "FilterData" )
+        {
+            rValue.Value >>= rSettings.maFilterData;
+
+            for( PropertyValue& rDataValue : rSettings.maFilterData )
+            {
+                if ( rDataValue.Name == "Translucent" )
+                {
+                    if ( !( rDataValue.Value >>= rSettings.mbTranslucent ) )  // SJ: TODO: The GIF Transparency is stored as int32 in
+                    {                                               // configuration files, this has to be changed to boolean
+                        sal_Int32 nTranslucent = 0;
+                        if ( rDataValue.Value >>= nTranslucent )
+                            rSettings.mbTranslucent = nTranslucent != 0;
+                    }
+                }
+                else if ( rDataValue.Name == "PixelWidth" )
+                {
+                    rDataValue.Value >>= rSettings.mnWidth;
+                }
+                else if ( rDataValue.Name == "PixelHeight" )
+                {
+                    rDataValue.Value >>= rSettings.mnHeight;
+                }
+                else if( rDataValue.Name == "Width" )  // for compatibility reasons, deprecated
+                {
+                    rDataValue.Value >>= rSettings.mnWidth;
+                    rDataValue.Name = "PixelWidth";
+                }
+                else if( rDataValue.Name == "Height" ) // for compatibility reasons, deprecated
+                {
+                    rDataValue.Value >>= rSettings.mnHeight;
+                    rDataValue.Name = "PixelHeight";
+                }
+                else if ( rDataValue.Name == "ExportOnlyBackground" )
+                {
+                    rDataValue.Value >>= rSettings.mbExportOnlyBackground;
+                }
+                else if ( rDataValue.Name == "HighContrast" )
+                {
+                    rDataValue.Value >>= rSettings.mbUseHighContrast;
+                }
+                else if ( rDataValue.Name == "PageNumber" )
+                {
+                    rDataValue.Value >>= mnPageNumber;
+                }
+                else if ( rDataValue.Name == "ScrollText" )
+                {
+                    // #110496# Read flag solitary scroll text metafile
+                    rDataValue.Value >>= rSettings.mbScrollText;
+                }
+                else if ( rDataValue.Name == "CurrentPage" )
+                {
+                    Reference< XDrawPage >  xPage;
+                    rDataValue.Value >>= xPage;
+                    if( xPage.is() )
+                    {
+                        SvxDrawPage* pUnoPage = comphelper::getUnoTunnelImplementation<SvxDrawPage>( xPage );
+                        if( pUnoPage && pUnoPage->GetSdrPage() )
+                            mpCurrentPage = pUnoPage->GetSdrPage();
+                    }
+                }
+                else if ( rDataValue.Name == "ScaleXNumerator" )
+                {
+                    sal_Int32 nVal = 1;
+                    if( rDataValue.Value >>= nVal )
+                        rSettings.maScaleX = Fraction( nVal, rSettings.maScaleX.GetDenominator() );
+                }
+                else if ( rDataValue.Name == "ScaleXDenominator" )
+                {
+                    sal_Int32 nVal = 1;
+                    if( rDataValue.Value >>= nVal )
+                        rSettings.maScaleX = Fraction( rSettings.maScaleX.GetNumerator(), nVal );
+                }
+                else if ( rDataValue.Name == "ScaleYNumerator" )
+                {
+                    sal_Int32 nVal = 1;
+                    if( rDataValue.Value >>= nVal )
+                        rSettings.maScaleY = Fraction( nVal, rSettings.maScaleY.GetDenominator() );
+                }
+                else if ( rDataValue.Name == "ScaleYDenominator" )
+                {
+                    sal_Int32 nVal = 1;
+                    if( rDataValue.Value >>= nVal )
+                        rSettings.maScaleY = Fraction( rSettings.maScaleY.GetNumerator(), nVal );
+                }
+                else if (rDataValue.Name == "AntiAliasing")
+                {
+                    bool bAntiAliasing;
+                    if (rDataValue.Value >>= bAntiAliasing)
+                        rSettings.meAntiAliasing = bAntiAliasing ? TRISTATE_TRUE : TRISTATE_FALSE;
+                }
+            }
+        }
+    }
+
+    // putting the StatusIndicator that we got from the MediaDescriptor into our local FilterData copy
+    if ( rSettings.mxStatusIndicator.is() )
+    {
+        int i = rSettings.maFilterData.getLength();
+        rSettings.maFilterData.realloc( i + 1 );
+        rSettings.maFilterData[ i ].Name = "StatusIndicator";
+        rSettings.maFilterData[ i ].Value <<= rSettings.mxStatusIndicator;
+    }
+}
+
+bool GraphicExporter::GetGraphic( ExportSettings const & rSettings, Graphic& aGraphic, bool bVectorType )
+{
+    if( !mpDoc || !mpUnoPage )
+        return false;
+
+    SdrPage* pPage = mpUnoPage->GetSdrPage();
+    if( !pPage )
+        return false;
+
+    ScopedVclPtrInstance< VirtualDevice > aVDev;
+    const MapMode       aMap( mpDoc->GetScaleUnit(), Point(), rSettings.maScaleX, rSettings.maScaleY );
+
+    SdrOutliner& rOutl=mpDoc->GetDrawOutliner();
+    maOldCalcFieldValueHdl = rOutl.GetCalcFieldValueHdl();
+    rOutl.SetCalcFieldValueHdl( LINK(this, GraphicExporter, CalcFieldValueHdl) );
+    rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor() );
+
+    // #i102251#
+    const EEControlBits nOldCntrl(rOutl.GetControlWord());
+    EEControlBits nCntrl = nOldCntrl & ~EEControlBits::ONLINESPELLING;
+    rOutl.SetControlWord(nCntrl);
+
+    SdrObject* pTempBackgroundShape = nullptr;
+    std::vector< SdrObject* > aShapes;
+    bool bRet = true;
+
+    // export complete page?
+    if ( !mxShape.is() )
+    {
+        if( rSettings.mbExportOnlyBackground )
+        {
+            const SdrPageProperties* pCorrectProperties = pPage->getCorrectSdrPageProperties();
+
+            if(pCorrectProperties)
+            {
+                pTempBackgroundShape = new SdrRectObj(
+                    *mpDoc,
+                    tools::Rectangle(Point(0,0), pPage->GetSize()));
+                pTempBackgroundShape->SetMergedItemSet(pCorrectProperties->GetItemSet());
+                pTempBackgroundShape->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE));
+                pTempBackgroundShape->NbcSetStyleSheet(pCorrectProperties->GetStyleSheet(), true);
+                aShapes.push_back(pTempBackgroundShape);
+            }
+        }
+        else
+        {
+            const Size aSize( pPage->GetSize() );
+
+            // generate a bitmap to convert it to a pixel format.
+            // For gif pictures there can also be a vector format used (bTranslucent)
+            if ( !bVectorType && !rSettings.mbTranslucent )
+            {
+                long nWidthPix = 0;
+                long nHeightPix = 0;
+                if ( rSettings.mnWidth > 0 && rSettings.mnHeight > 0 )
+                {
+                    nWidthPix = rSettings.mnWidth;
+                    nHeightPix = rSettings.mnHeight;
+                }
+                else
+                {
+                    const Size aSizePix( Application::GetDefaultDevice()->LogicToPixel( aSize, aMap ) );
+                    if (aSizePix.Width() > MAX_EXT_PIX || aSizePix.Height() > MAX_EXT_PIX)
+                    {
+                        if (aSizePix.Width() > MAX_EXT_PIX)
+                            nWidthPix = MAX_EXT_PIX;
+                        else
+                            nWidthPix = aSizePix.Width();
+                        if (aSizePix.Height() > MAX_EXT_PIX)
+                            nHeightPix = MAX_EXT_PIX;
+                        else
+                            nHeightPix = aSizePix.Height();
+
+                        double fWidthDif = static_cast<double>(aSizePix.Width()) / nWidthPix;
+                        double fHeightDif = static_cast<double>(aSizePix.Height()) / nHeightPix;
+
+                        if (fWidthDif > fHeightDif)
+                            nHeightPix = static_cast<long>(aSizePix.Height() / fWidthDif);
+                        else
+                            nWidthPix = static_cast<long>(aSizePix.Width() / fHeightDif);
+                    }
+                    else
+                    {
+                        nWidthPix = aSizePix.Width();
+                        nHeightPix = aSizePix.Height();
+                    }
+                }
+
+                std::unique_ptr<SdrView> xLocalView;
+
+                if (FmFormModel* pFormModel = dynamic_cast<FmFormModel*>(mpDoc))
+                {
+                    xLocalView.reset(new FmFormView(*pFormModel, aVDev));
+                }
+                else
+                {
+                    xLocalView.reset(new SdrView(*mpDoc, aVDev));
+                }
+
+                ScopedVclPtr<VirtualDevice> pVDev(CreatePageVDev( pPage, nWidthPix, nHeightPix ));
+
+                if( pVDev )
+                {
+                    aGraphic = pVDev->GetBitmapEx( Point(), pVDev->GetOutputSize() );
+                    aGraphic.SetPrefMapMode( aMap );
+                    aGraphic.SetPrefSize( aSize );
+                }
+            }
+            // create a metafile to export a vector format
+            else
+            {
+                GDIMetaFile aMtf;
+
+                aVDev->SetMapMode( aMap );
+                if( rSettings.mbUseHighContrast )
+                    aVDev->SetDrawMode( aVDev->GetDrawMode() | DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient );
+                aVDev->EnableOutput( false );
+                aMtf.Record( aVDev );
+                Size aNewSize;
+
+                // create a view
+                std::unique_ptr< SdrView > pView;
+
+                if (FmFormModel *pFormModel = dynamic_cast<FmFormModel*>(mpDoc))
+                {
+                    pView.reset(new FmFormView(*pFormModel, aVDev));
+                }
+                else
+                {
+                    pView.reset(new SdrView(*mpDoc, aVDev));
+                }
+
+                pView->SetBordVisible( false );
+                pView->SetPageVisible( false );
+                pView->ShowSdrPage( pPage );
+
+                // tdf#96922 completely deactivate EditView PageVisualization, including
+                // PageBackground (formerly 'wiese').
+                pView->SetPagePaintingAllowed(false);
+
+                const Point aNewOrg( pPage->GetLeftBorder(), pPage->GetUpperBorder() );
+                aNewSize = Size( aSize.Width() - pPage->GetLeftBorder() - pPage->GetRightBorder(),
+                                 aSize.Height() - pPage->GetUpperBorder() - pPage->GetLowerBorder() );
+                const tools::Rectangle aClipRect( aNewOrg, aNewSize );
+                MapMode         aVMap( aMap );
+
+                aVDev->Push();
+                aVMap.SetOrigin( Point( -aNewOrg.X(), -aNewOrg.Y() ) );
+                aVDev->SetRelativeMapMode( aVMap );
+                aVDev->IntersectClipRegion( aClipRect );
+
+                // Use new StandardCheckVisisbilityRedirector
+                ImplExportCheckVisisbilityRedirector aRedirector( mpCurrentPage );
+
+                pView->CompleteRedraw(aVDev, vcl::Region(tools::Rectangle(aNewOrg, aNewSize)), &aRedirector);
+
+                aVDev->Pop();
+
+                aMtf.Stop();
+                aMtf.WindStart();
+                aMtf.SetPrefMapMode( aMap );
+                aMtf.SetPrefSize( aNewSize );
+
+                // AW: Here the current version was filtering out the MetaActionType::CLIPREGIONs
+                // from the metafile. I asked some other developers why this was done, but no
+                // one knew a direct reason. Since it's in for long time, it may be an old
+                // piece of code. MetaFiles save and load ClipRegions with polygons with preserving
+                // the polygons, so a resolution-independent roundtrip is supported. Removed this
+                // code since it destroys some MetaFiles where ClipRegions are used. Anyways,
+                // just filtering them out is a hack, at least the encapsulated content would need
+                // to be clipped geometrically.
+                aGraphic = Graphic(aMtf);
+
+                pView->HideSdrPage();
+
+                if( rSettings.mbTranslucent )
+                {
+                    Size aOutSize;
+                    aGraphic = GetBitmapFromMetaFile( aGraphic.GetGDIMetaFile(), false, CalcSize( rSettings.mnWidth, rSettings.mnHeight, aNewSize, aOutSize ) );
+                }
+            }
+        }
+    }
+
+    // export only single shape or shape collection
+    else
+    {
+        // build list of SdrObject
+        if( mxShapes.is() )
+        {
+            Reference< XShape > xShape;
+            const sal_Int32 nCount = mxShapes->getCount();
+
+            for( sal_Int32 nIndex = 0; nIndex < nCount; nIndex++ )
+            {
+                mxShapes->getByIndex( nIndex ) >>= xShape;
+                SdrObject* pObj = GetSdrObjectFromXShape( xShape );
+                if( pObj )
+                    aShapes.push_back( pObj );
+            }
+        }
+        else
+        {
+            // only one shape
+            SdrObject* pObj = GetSdrObjectFromXShape( mxShape );
+            if( pObj )
+                aShapes.push_back( pObj );
+        }
+
+        if( aShapes.empty() )
+            bRet = false;
+    }
+
+    if( bRet && !aShapes.empty() )
+    {
+        // special treatment for only one SdrGrafObj that has text
+        bool bSingleGraphic = false;
+
+        if( 1 == aShapes.size() )
+        {
+            if( !bVectorType )
+            {
+                SdrObject* pObj = aShapes.front();
+                if( dynamic_cast<const SdrGrafObj*>( pObj) && !static_cast<SdrGrafObj*>(pObj)->HasText() )
+                {
+                    aGraphic = static_cast<SdrGrafObj*>(pObj)->GetTransformedGraphic();
+                    if ( aGraphic.GetType() == GraphicType::Bitmap )
+                    {
+                        Size aSizePixel( aGraphic.GetSizePixel() );
+                        if( rSettings.mnWidth && rSettings.mnHeight &&
+                            ( ( rSettings.mnWidth != aSizePixel.Width() ) ||
+                              ( rSettings.mnHeight != aSizePixel.Height() ) ) )
+                        {
+                            BitmapEx aBmpEx( aGraphic.GetBitmapEx() );
+                            // export: use highest quality
+                            aBmpEx.Scale( Size( rSettings.mnWidth, rSettings.mnHeight ), BmpScaleFlag::Lanczos );
+                            aGraphic = aBmpEx;
+                        }
+
+                        // #118804# only accept for bitmap graphics, else the
+                        // conversion to bitmap will happen anywhere without size control
+                        // as evtl. defined in rSettings.mnWidth/mnHeight
+                        bSingleGraphic = true;
+                    }
+                }
+            }
+            else if( rSettings.mbScrollText )
+            {
+                SdrObject* pObj = aShapes.front();
+                if( dynamic_cast<const SdrTextObj*>( pObj)
+                    && static_cast<SdrTextObj*>(pObj)->HasText() )
+                {
+                    tools::Rectangle aScrollRectangle;
+                    tools::Rectangle aPaintRectangle;
+
+                    const std::unique_ptr< GDIMetaFile > pMtf(
+                        static_cast<SdrTextObj*>(pObj)->GetTextScrollMetaFileAndRectangle(
+                           aScrollRectangle, aPaintRectangle ) );
+
+                    // take the larger one of the two rectangles (that
+                    // should be the bound rect of the retrieved
+                    // metafile)
+                    tools::Rectangle aTextRect;
+
+                    if( aScrollRectangle.IsInside( aPaintRectangle ) )
+                        aTextRect = aScrollRectangle;
+                    else
+                        aTextRect = aPaintRectangle;
+
+                    // setup pref size and mapmode
+                    pMtf->SetPrefSize( aTextRect.GetSize() );
+
+                    // set actual origin (mtf is at actual shape
+                    // output position)
+                    MapMode aLocalMapMode( aMap );
+                    aLocalMapMode.SetOrigin(
+                        Point( -aPaintRectangle.Left(),
+                               -aPaintRectangle.Top() ) );
+                    pMtf->SetPrefMapMode( aLocalMapMode );
+
+                    pMtf->AddAction( new MetaCommentAction(
+                                         "XTEXT_SCROLLRECT", 0,
+                                         reinterpret_cast<sal_uInt8 const*>(&aScrollRectangle),
+                                         sizeof( tools::Rectangle ) ) );
+                    pMtf->AddAction( new MetaCommentAction(
+                                         "XTEXT_PAINTRECT", 0,
+                                         reinterpret_cast<sal_uInt8 const*>(&aPaintRectangle),
+                                         sizeof( tools::Rectangle ) ) );
+
+                    aGraphic = Graphic( *pMtf );
+
+                    bSingleGraphic = true;
+                }
+            }
+        }
+
+        if( !bSingleGraphic )
+        {
+            // create a metafile for all shapes
+            ScopedVclPtrInstance< VirtualDevice > aOut;
+
+            // calculate bound rect for all shapes
+            tools::Rectangle aBound;
+
+            {
+                for( SdrObject* pObj : aShapes )
+                {
+                    tools::Rectangle aR1(pObj->GetCurrentBoundRect());
+                    if (aBound.IsEmpty())
+                        aBound=aR1;
+                    else
+                        aBound.Union(aR1);
+                }
+            }
+
+            aOut->EnableOutput( false );
+            aOut->SetMapMode( aMap );
+            if( rSettings.mbUseHighContrast )
+                aOut->SetDrawMode( aOut->GetDrawMode() | DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient );
+
+            GDIMetaFile aMtf;
+            aMtf.Clear();
+            aMtf.Record( aOut );
+
+            MapMode aOutMap( aMap );
+            aOutMap.SetOrigin( Point( -aBound.TopLeft().X(), -aBound.TopLeft().Y() ) );
+            aOut->SetRelativeMapMode( aOutMap );
+
+            sdr::contact::DisplayInfo aDisplayInfo;
+
+            if(mpCurrentPage)
+            {
+                if(mpCurrentPage->TRG_HasMasterPage() && pPage->IsMasterPage())
+                {
+                    // MasterPage is processed as another page's SubContent
+                    aDisplayInfo.SetProcessLayers(mpCurrentPage->TRG_GetMasterPageVisibleLayers());
+                    aDisplayInfo.SetSubContentActive(true);
+                }
+            }
+
+            if(!aShapes.empty())
+            {
+                // more effective way to paint a vector of SdrObjects. Hand over the processed page
+                // to have it in the
+                sdr::contact::ObjectContactOfObjListPainter aMultiObjectPainter(*aOut, aShapes, mpCurrentPage);
+                ImplExportCheckVisisbilityRedirector aCheckVisibilityRedirector(mpCurrentPage);
+                aMultiObjectPainter.SetViewObjectContactRedirector(&aCheckVisibilityRedirector);
+
+                aMultiObjectPainter.ProcessDisplay(aDisplayInfo);
+            }
+
+            aMtf.Stop();
+            aMtf.WindStart();
+
+            const Size  aExtSize( aOut->PixelToLogic( Size( 0, 0  ) ) );
+            Size        aBoundSize( aBound.GetWidth() + ( aExtSize.Width() ),
+                                    aBound.GetHeight() + ( aExtSize.Height() ) );
+
+            aMtf.SetPrefMapMode( aMap );
+            aMtf.SetPrefSize( aBoundSize );
+
+            if( !bVectorType )
+            {
+                Size aOutSize;
+                aGraphic = GetBitmapFromMetaFile( aMtf, true, CalcSize( rSettings.mnWidth, rSettings.mnHeight, aBoundSize, aOutSize ) );
+            }
+            else
+            {
+                aGraphic = aMtf;
+            }
+        }
+    }
+
+    if(pTempBackgroundShape)
+    {
+        SdrObject::Free(pTempBackgroundShape);
+    }
+
+    rOutl.SetCalcFieldValueHdl( maOldCalcFieldValueHdl );
+
+    // #i102251#
+    rOutl.SetControlWord(nOldCntrl);
+
+    return bRet;
+
+}
+
+// XFilter
+sal_Bool SAL_CALL GraphicExporter::filter( const Sequence< PropertyValue >& aDescriptor )
+{
+    ::SolarMutexGuard aGuard;
+
+    if( maGraphic.IsNone() && nullptr == mpUnoPage )
+        return false;
+
+    if( maGraphic.IsNone() && ( nullptr == mpUnoPage->GetSdrPage() || nullptr == mpDoc ) )
+        return false;
+
+    GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
+
+    // get the arguments from the descriptor
+    ExportSettings aSettings(mpDoc);
+    ParseSettings(aDescriptor, aSettings);
+
+    const sal_uInt16    nFilter = !aSettings.maMediaType.isEmpty()
+                            ? rFilter.GetExportFormatNumberForMediaType( aSettings.maMediaType )
+                            : rFilter.GetExportFormatNumberForShortName( aSettings.maFilterName );
+    bool            bVectorType = !rFilter.IsExportPixelFormat( nFilter );
+
+    // create the output stuff
+    Graphic aGraphic = maGraphic;
+
+    ErrCode nStatus = ERRCODE_NONE;
+    if (maGraphic.IsNone())
+    {
+        SvtOptionsDrawinglayer aOptions;
+        bool bAntiAliasing = aOptions.IsAntiAliasing();
+        AllSettings aAllSettings = Application::GetSettings();
+        StyleSettings aStyleSettings = aAllSettings.GetStyleSettings();
+        bool bUseFontAAFromSystem = aStyleSettings.GetUseFontAAFromSystem();
+        if (aSettings.meAntiAliasing != TRISTATE_INDET)
+        {
+            // This is safe to do globally as we own the solar mutex.
+            aOptions.SetAntiAliasing(aSettings.meAntiAliasing == TRISTATE_TRUE);
+            // Opt in to have AA affect font rendering as well.
+            aStyleSettings.SetUseFontAAFromSystem(false);
+            aAllSettings.SetStyleSettings(aStyleSettings);
+            Application::SetSettings(aAllSettings);
+        }
+        nStatus = GetGraphic( aSettings, aGraphic, bVectorType ) ? ERRCODE_NONE : ERRCODE_GRFILTER_FILTERERROR;
+        if (aSettings.meAntiAliasing != TRISTATE_INDET)
+        {
+            aOptions.SetAntiAliasing(bAntiAliasing);
+            aStyleSettings.SetUseFontAAFromSystem(bUseFontAAFromSystem);
+            aAllSettings.SetStyleSettings(aStyleSettings);
+            Application::SetSettings(aAllSettings);
+        }
+    }
+
+    if( nStatus == ERRCODE_NONE )
+    {
+        // export graphic only if it has a size
+        const Size aGraphSize( aGraphic.GetPrefSize() );
+        if ( aGraphSize.IsEmpty() )
+        {
+            nStatus = ERRCODE_GRFILTER_FILTERERROR;
+        }
+        else
+        {
+            // now we have a graphic, so export it
+            if( aSettings.mxGraphicRenderer.is() )
+            {
+                // render graphic directly into given renderer
+                aSettings.mxGraphicRenderer->render( aGraphic.GetXGraphic() );
+            }
+            else if( aSettings.mxOutputStream.is() )
+            {
+                // TODO: Either utilize optional XSeekable functionality for the
+                // SvOutputStream, or adapt the graphic filter to not seek anymore.
+                SvMemoryStream aStream( 1024, 1024 );
+
+                nStatus = rFilter.ExportGraphic( aGraphic,"", aStream, nFilter, &aSettings.maFilterData );
+
+                // copy temp stream to XOutputStream
+                SvOutputStream aOutputStream( aSettings.mxOutputStream );
+                aStream.Seek(0);
+                aOutputStream.WriteStream( aStream );
+            }
+            else
+            {
+                INetURLObject aURLObject( aSettings.maURL.Complete );
+                DBG_ASSERT( aURLObject.GetProtocol() != INetProtocol::NotValid, "invalid URL" );
+
+                nStatus = XOutBitmap::ExportGraphic( aGraphic, aURLObject, rFilter, nFilter, &aSettings.maFilterData );
+            }
+        }
+    }
+
+    if ( aSettings.mxInteractionHandler.is() && ( nStatus != ERRCODE_NONE ) )
+    {
+        Any aInteraction;
+        Sequence< css::uno::Reference< css::task::XInteractionContinuation > > lContinuations(1);
+        ::comphelper::OInteractionApprove* pApprove = new ::comphelper::OInteractionApprove();
+        lContinuations[0].set(static_cast< XInteractionContinuation* >(pApprove), UNO_QUERY);
+
+        GraphicFilterRequest aErrorCode;
+        aErrorCode.ErrCode = sal_uInt32(nStatus);
+        aInteraction <<= aErrorCode;
+        aSettings.mxInteractionHandler->handle( framework::InteractionRequest::CreateRequest( aInteraction, lContinuations ) );
+    }
+    return nStatus == ERRCODE_NONE;
+}
+
+void SAL_CALL GraphicExporter::cancel()
+{
+}
+
+// XExporter
+
+/** the source 'document' could be a XDrawPage, a XShape or a generic XShapes */
+void SAL_CALL GraphicExporter::setSourceDocument( const Reference< lang::XComponent >& xComponent )
+{
+    ::SolarMutexGuard aGuard;
+
+    mxShapes = nullptr;
+    mpUnoPage = nullptr;
+
+    try
+    {
+    // any break inside this one loop while will throw an IllegalArgumentException
+    do
+    {
+        mxPage.set( xComponent, UNO_QUERY );
+        mxShapes.set( xComponent, UNO_QUERY );
+        mxShape.set( xComponent, UNO_QUERY );
+
+        // Step 1: try a generic XShapes
+        if( !mxPage.is() && !mxShape.is() && mxShapes.is() )
+        {
+            // we do not support empty shape collections
+            if( 0 == mxShapes->getCount() )
+                break;
+
+            // get first shape to detect corresponding page and model
+            mxShapes->getByIndex(0) >>= mxShape;
+        }
+        else
+        {
+            mxShapes = nullptr;
+        }
+
+        // Step 2: try a shape
+        if( mxShape.is() )
+        {
+            if( nullptr == GetSdrObjectFromXShape( mxShape ) )
+            {
+                // This is not a Draw shape, let's see if it's a Writer one.
+                uno::Reference<beans::XPropertySet> xPropertySet(mxShape, uno::UNO_QUERY);
+                if (!xPropertySet.is())
+                    break;
+                uno::Reference<graphic::XGraphic> xGraphic(
+                    xPropertySet->getPropertyValue("Graphic"), uno::UNO_QUERY);
+                if (!xGraphic.is())
+                    break;
+
+                maGraphic = Graphic(xGraphic);
+                if (!maGraphic.IsNone())
+                    return;
+                else
+                    break;
+            }
+
+            // get page for this shape
+            Reference< XChild > xChild( mxShape, UNO_QUERY );
+            if( !xChild.is() )
+                break;
+
+            Reference< XInterface > xInt;
+            do
+            {
+                xInt = xChild->getParent();
+                mxPage.set( xInt, UNO_QUERY );
+                if( !mxPage.is() )
+                    xChild.set( xInt, UNO_QUERY );
+            }
+            while( !mxPage.is() && xChild.is() );
+
+            if( !mxPage.is() )
+                break;
+        }
+
+        // Step 3: check the page
+        if( !mxPage.is() )
+            break;
+
+        mpUnoPage = comphelper::getUnoTunnelImplementation<SvxDrawPage>( mxPage );
+
+        if( nullptr == mpUnoPage || nullptr == mpUnoPage->GetSdrPage() )
+            break;
+
+        mpDoc = &mpUnoPage->GetSdrPage()->getSdrModelFromSdrPage();
+
+        // Step 4:  If we got a generic XShapes test all contained shapes
+        //          if they belong to the same XDrawPage
+
+        if( mxShapes.is() )
+        {
+            SdrPage* pPage = mpUnoPage->GetSdrPage();
+            SdrObject* pObj;
+            Reference< XShape > xShape;
+
+            bool bOk = true;
+
+            const sal_Int32 nCount = mxShapes->getCount();
+
+            // test all but the first shape if they have the same page than
+            // the first shape
+            for( sal_Int32 nIndex = 1; bOk && ( nIndex < nCount ); nIndex++ )
+            {
+                mxShapes->getByIndex( nIndex ) >>= xShape;
+                pObj = GetSdrObjectFromXShape( xShape );
+                bOk = pObj && pObj->getSdrPageFromSdrObject() == pPage;
+            }
+
+            if( !bOk )
+                break;
+        }
+
+        // no errors so far
+        return;
+    }
+    while( false );
+    }
+    catch( Exception& )
+    {
+    }
+
+    throw IllegalArgumentException();
+}
+
+// XServiceInfo
+OUString SAL_CALL GraphicExporter::getImplementationName(  )
+{
+    return "com.sun.star.comp.Draw.GraphicExporter";
+}
+
+sal_Bool SAL_CALL GraphicExporter::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+Sequence< OUString > SAL_CALL GraphicExporter::getSupportedServiceNames(  )
+{
+    Sequence< OUString > aSupportedServiceNames { "com.sun.star.drawing.GraphicExportFilter" };
+    return aSupportedServiceNames;
+}
+
+// XMimeTypeInfo
+sal_Bool SAL_CALL GraphicExporter::supportsMimeType( const OUString& rMimeTypeName )
+{
+    GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
+    sal_uInt16 nCount = rFilter.GetExportFormatCount();
+    sal_uInt16 nFilter;
+    for( nFilter = 0; nFilter < nCount; nFilter++ )
+    {
+        if( rMimeTypeName == rFilter.GetExportFormatMediaType( nFilter ) )
+        {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+Sequence< OUString > SAL_CALL GraphicExporter::getSupportedMimeTypeNames(  )
+{
+    GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
+    sal_uInt16 nCount = rFilter.GetExportFormatCount();
+    sal_uInt16 nFilter;
+    sal_uInt16 nFound = 0;
+
+    Sequence< OUString > aSeq( nCount );
+    OUString* pStr = aSeq.getArray();
+
+    for( nFilter = 0; nFilter < nCount; nFilter++ )
+    {
+        OUString aMimeType( rFilter.GetExportFormatMediaType( nFilter ) );
+        if( !aMimeType.isEmpty() )
+        {
+            *pStr++ = aMimeType;
+            nFound++;
+        }
+    }
+
+    if( nFound < nCount )
+        aSeq.realloc( nFound );
+
+    return aSeq;
+}
+
+}
+
+Graphic SvxGetGraphicForShape( SdrObject& rShape )
+{
+    Graphic aGraphic;
+    try
+    {
+        rtl::Reference< GraphicExporter > xExporter( new GraphicExporter() );
+        Reference< XComponent > xComp( rShape.getUnoShape(), UNO_QUERY_THROW );
+        xExporter->setSourceDocument( xComp );
+        ExportSettings aSettings(&rShape.getSdrModelFromSdrObject());
+        xExporter->GetGraphic( aSettings, aGraphic, true/*bVector*/ );
+    }
+    catch( Exception& )
+    {
+        OSL_FAIL("SvxGetGraphicForShape(), exception caught!");
+    }
+    return aGraphic;
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_Draw_GraphicExporter_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new GraphicExporter);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/UnoGraphicExporter.hxx b/svx/source/unodraw/UnoGraphicExporter.hxx
new file mode 100644
index 000000000..ace0db252
--- /dev/null
+++ b/svx/source/unodraw/UnoGraphicExporter.hxx
@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SVX_SOURCE_UNODRAW_UNOGRAPHICEXPORTER_HXX
+#define INCLUDED_SVX_SOURCE_UNODRAW_UNOGRAPHICEXPORTER_HXX
+
+#include <sal/config.h>
+
+#include <vcl/graph.hxx>
+
+class SdrObject;
+
+Graphic SvxGetGraphicForShape(SdrObject& rShape);
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/UnoNameItemTable.cxx b/svx/source/unodraw/UnoNameItemTable.cxx
new file mode 100644
index 000000000..612877880
--- /dev/null
+++ b/svx/source/unodraw/UnoNameItemTable.cxx
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <set>
+
+#include <svl/itempool.hxx>
+#include <svl/itemset.hxx>
+#include <comphelper/profilezone.hxx>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include <svx/svdmodel.hxx>
+#include "UnoNameItemTable.hxx"
+#include <vcl/svapp.hxx>
+
+#include <svx/unoapi.hxx>
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+SvxUnoNameItemTable::SvxUnoNameItemTable( SdrModel* pModel, sal_uInt16 nWhich, sal_uInt8 nMemberId ) throw()
+: mpModel( pModel ),
+  mpModelPool( pModel ? &pModel->GetItemPool() : nullptr ),
+  mnWhich( nWhich ), mnMemberId( nMemberId )
+{
+    if( pModel )
+        StartListening( *pModel );
+}
+
+SvxUnoNameItemTable::~SvxUnoNameItemTable() throw()
+{
+    if( mpModel )
+        EndListening( *mpModel );
+    dispose();
+}
+
+bool SvxUnoNameItemTable::isValid( const NameOrIndex* pItem ) const
+{
+    return pItem && !pItem->GetName().isEmpty();
+}
+
+void SvxUnoNameItemTable::dispose()
+{
+    maItemSetVector.clear();
+}
+
+void SvxUnoNameItemTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
+{
+    if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
+        return;
+    const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
+    if( SdrHintKind::ModelCleared == pSdrHint->GetKind() )
+        dispose();
+}
+
+sal_Bool SAL_CALL SvxUnoNameItemTable::supportsService( const  OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+void SvxUnoNameItemTable::ImplInsertByName( const OUString& aName, const uno::Any& aElement )
+{
+    maItemSetVector.push_back( std::make_unique< SfxItemSet >( *mpModelPool, std::initializer_list<SfxItemSet::Pair>{{mnWhich, mnWhich}} ) );
+
+    std::unique_ptr<NameOrIndex> xNewItem(createItem());
+    xNewItem->SetName(aName);
+    xNewItem->PutValue(aElement, mnMemberId);
+    xNewItem->SetWhich(mnWhich);
+    maItemSetVector.back()->Put(*xNewItem);
+}
+
+// XNameContainer
+void SAL_CALL SvxUnoNameItemTable::insertByName( const OUString& aApiName, const uno::Any& aElement )
+{
+    SolarMutexGuard aGuard;
+    comphelper::ProfileZone aZone("SvxUnoNameItemTable::insertByName");
+
+    if( hasByName( aApiName ) )
+        throw container::ElementExistException();
+
+    OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
+
+    ImplInsertByName( aName, aElement );
+}
+
+
+void SAL_CALL SvxUnoNameItemTable::removeByName( const OUString& aApiName )
+{
+    SolarMutexGuard aGuard;
+    comphelper::ProfileZone aZone("SvxUnoNameItemTable::removeByName");
+
+    // a little quickfix for 2.0 to let applications clear api
+    // created items that are not used
+    if ( aApiName == "~clear~" )
+    {
+        dispose();
+        return;
+    }
+
+    OUString sName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
+
+    auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
+        [&](const std::unique_ptr<SfxItemSet>& rpItem) {
+            const NameOrIndex *pItem = static_cast<const NameOrIndex *>(&(rpItem->Get( mnWhich ) ));
+            return sName == pItem->GetName();
+        });
+    if (aIter != maItemSetVector.end())
+    {
+        maItemSetVector.erase( aIter );
+        return;
+    }
+
+    if (!hasByName(sName))
+        throw container::NoSuchElementException();
+}
+
+// XNameReplace
+void SAL_CALL SvxUnoNameItemTable::replaceByName( const OUString& aApiName, const uno::Any& aElement )
+{
+    SolarMutexGuard aGuard;
+
+    OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
+
+    auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
+        [&](const std::unique_ptr<SfxItemSet>& rpItem) {
+            const NameOrIndex *pItem = static_cast<const NameOrIndex *>(&(rpItem->Get( mnWhich ) ));
+            return aName == pItem->GetName();
+        });
+    if (aIter != maItemSetVector.end())
+    {
+        std::unique_ptr<NameOrIndex> xNewItem(createItem());
+        xNewItem->SetName(aName);
+        if (!xNewItem->PutValue(aElement, mnMemberId) || !isValid(xNewItem.get()))
+            throw lang::IllegalArgumentException();
+        (*aIter)->Put(*xNewItem);
+        return;
+    }
+
+    // if it is not in our own sets, modify the pool!
+    bool bFound = false;
+
+    if (mpModelPool)
+    {
+        NameOrIndex aSample(mnWhich, aName);
+        for (const SfxPoolItem* pNameOrIndex : mpModelPool->FindItemSurrogate(mnWhich, aSample))
+            if (isValid(static_cast<const NameOrIndex*>(pNameOrIndex)))
+            {
+                const_cast<SfxPoolItem*>(pNameOrIndex)->PutValue( aElement, mnMemberId );
+                bFound = true;
+            }
+    }
+
+    if( !bFound )
+        throw container::NoSuchElementException();
+
+    ImplInsertByName( aName, aElement );
+
+    if( !hasByName( aName ) )
+        throw container::NoSuchElementException();
+}
+
+// XNameAccess
+uno::Any SAL_CALL SvxUnoNameItemTable::getByName( const OUString& aApiName )
+{
+    SolarMutexGuard aGuard;
+    comphelper::ProfileZone aZone("SvxUnoNameItemTable::getByName");
+
+    OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
+
+    if (mpModelPool && !aName.isEmpty())
+    {
+        NameOrIndex aSample(mnWhich, aName);
+        for (const SfxPoolItem* pFindItem : mpModelPool->FindItemSurrogate(mnWhich, aSample))
+            if (isValid(static_cast<const NameOrIndex*>(pFindItem)))
+            {
+                uno::Any aAny;
+                pFindItem->QueryValue( aAny, mnMemberId );
+                return aAny;
+            }
+    }
+
+    throw container::NoSuchElementException();
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoNameItemTable::getElementNames(  )
+{
+    SolarMutexGuard aGuard;
+
+    std::set< OUString > aNameSet;
+
+
+    if (mpModelPool)
+        for (const SfxPoolItem* pItem : mpModelPool->GetItemSurrogates(mnWhich))
+        {
+            const NameOrIndex *pNameOrIndex = static_cast<const NameOrIndex*>(pItem);
+
+            if( !isValid( pNameOrIndex ) )
+                continue;
+
+            OUString aApiName = SvxUnogetApiNameForItem(mnWhich, pNameOrIndex->GetName());
+            aNameSet.insert(aApiName);
+        }
+
+    return comphelper::containerToSequence(aNameSet);
+}
+
+sal_Bool SAL_CALL SvxUnoNameItemTable::hasByName( const OUString& aApiName )
+{
+    SolarMutexGuard aGuard;
+
+    OUString aName = SvxUnogetInternalNameForItem(mnWhich, aApiName);
+
+    if (aName.isEmpty())
+        return false;
+
+    if (!mpModelPool)
+        return false;
+
+    NameOrIndex aSample(mnWhich, aName);
+    for (const SfxPoolItem* pFindItem : mpModelPool->FindItemSurrogate(mnWhich, aSample))
+        if (isValid(static_cast<const NameOrIndex*>(pFindItem)))
+            return true;
+    return false;
+}
+
+sal_Bool SAL_CALL SvxUnoNameItemTable::hasElements(  )
+{
+    SolarMutexGuard aGuard;
+
+    if (mpModelPool)
+        for (const SfxPoolItem* pItem : mpModelPool->GetItemSurrogates(mnWhich))
+        {
+            const NameOrIndex *pNameOrIndex = static_cast<const NameOrIndex*>(pItem);
+
+            if( isValid( pNameOrIndex ) )
+                return true;
+        }
+
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/UnoNameItemTable.hxx b/svx/source/unodraw/UnoNameItemTable.hxx
new file mode 100644
index 000000000..1bb0b8276
--- /dev/null
+++ b/svx/source/unodraw/UnoNameItemTable.hxx
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SVX_SOURCE_UNODRAW_UNONAMEITEMTABLE_HXX
+#define INCLUDED_SVX_SOURCE_UNODRAW_UNONAMEITEMTABLE_HXX
+
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+
+#include <cppuhelper/implbase.hxx>
+
+#include <memory>
+#include <vector>
+#include <svl/lstner.hxx>
+#include <svx/xit.hxx>
+
+class SdrModel;
+class SfxItemPool;
+class SfxItemSet;
+
+typedef std::vector< std::unique_ptr< SfxItemSet > > ItemPoolVector;
+class SvxUnoNameItemTable : public cppu::WeakImplHelper< css::container::XNameContainer, css::lang::XServiceInfo >,
+                            public SfxListener
+{
+private:
+    SdrModel*       mpModel;
+    SfxItemPool*    mpModelPool;
+    sal_uInt16          mnWhich;
+    sal_uInt8           mnMemberId;
+
+    ItemPoolVector maItemSetVector;
+
+    void ImplInsertByName( const OUString& aName, const css::uno::Any& aElement );
+
+public:
+    SvxUnoNameItemTable( SdrModel* pModel, sal_uInt16 nWhich, sal_uInt8 nMemberId ) throw();
+    virtual ~SvxUnoNameItemTable() throw() override;
+
+    virtual NameOrIndex* createItem() const = 0;
+    virtual bool isValid( const NameOrIndex* pItem ) const;
+
+    void dispose();
+
+    // SfxListener
+    virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) throw () override;
+
+    // XServiceInfo
+    virtual sal_Bool SAL_CALL supportsService( const  OUString& ServiceName ) override;
+
+    // XNameContainer
+    virtual void SAL_CALL insertByName( const  OUString& aName, const  css::uno::Any& aElement ) override;
+    virtual void SAL_CALL removeByName( const  OUString& Name ) override;
+
+    // XNameReplace
+    virtual void SAL_CALL replaceByName( const  OUString& aName, const  css::uno::Any& aElement ) override;
+
+    // XNameAccess
+    virtual css::uno::Any SAL_CALL getByName( const  OUString& aName ) override;
+    virtual css::uno::Sequence<  OUString > SAL_CALL getElementNames(  ) override;
+    virtual sal_Bool SAL_CALL hasByName( const  OUString& aName ) override;
+
+    // XElementAccess
+    virtual sal_Bool SAL_CALL hasElements(  ) override;
+};
+
+#endif // INCLUDED_SVX_SOURCE_UNODRAW_UNONAMEITEMTABLE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/UnoNamespaceMap.cxx b/svx/source/unodraw/UnoNamespaceMap.cxx
new file mode 100644
index 000000000..88c69e4c6
--- /dev/null
+++ b/svx/source/unodraw/UnoNamespaceMap.cxx
@@ -0,0 +1,275 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <climits>
+#include <set>
+
+#include <svx/UnoNamespaceMap.hxx>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <svl/itempool.hxx>
+#include <editeng/xmlcnitm.hxx>
+
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+
+namespace svx
+{
+    namespace {
+
+    /** implements a component to export namespaces of all SvXMLAttrContainerItem inside
+        one or two pools with a variable count of which ids.
+    */
+    class NamespaceMap : public WeakImplHelper< XNameAccess, XServiceInfo >
+    {
+    private:
+        sal_uInt16* mpWhichIds;
+        SfxItemPool* mpPool;
+
+    public:
+        NamespaceMap( sal_uInt16* pWhichIds, SfxItemPool* pPool );
+
+        // XNameAccess
+        virtual Any SAL_CALL getByName( const OUString& aName ) override;
+        virtual Sequence< OUString > SAL_CALL getElementNames(  ) override;
+        virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override;
+
+        // XElementAccess
+        virtual Type SAL_CALL getElementType(  ) override;
+        virtual sal_Bool SAL_CALL hasElements(  ) override;
+
+        // XServiceInfo
+        virtual OUString SAL_CALL getImplementationName(  ) override;
+        virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+        virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
+    };
+
+    }
+
+    Reference< XInterface > NamespaceMap_createInstance( sal_uInt16* pWhichIds, SfxItemPool* pPool )
+    {
+        return static_cast<XWeak*>(new NamespaceMap( pWhichIds, pPool ));
+    }
+
+    static Sequence< OUString > NamespaceMap_getSupportedServiceNames()
+        throw()
+    {
+        Sequence<OUString> aSupportedServiceNames { "com.sun.star.xml.NamespaceMap" };
+        return aSupportedServiceNames;
+    }
+
+    static OUString NamespaceMap_getImplementationName()
+        throw()
+    {
+        return "com.sun.star.comp.Svx.NamespaceMap";
+    }
+
+    namespace {
+
+    class NamespaceIteratorImpl
+    {
+    private:
+        SfxItemPool* mpPool;
+
+        sal_uInt16* mpWhichId;
+
+        std::vector<const SvXMLAttrContainerItem*> mvItems;
+        sal_Int32 mnItem;
+
+        const SvXMLAttrContainerItem* mpCurrentAttr;
+        sal_uInt16 mnCurrentAttr;
+
+    public:
+
+        NamespaceIteratorImpl( sal_uInt16* pWhichIds, SfxItemPool* pPool );
+
+        bool next( OUString& rPrefix, OUString& rURL );
+    };
+
+    }
+}
+
+using namespace ::svx;
+
+
+NamespaceIteratorImpl::NamespaceIteratorImpl( sal_uInt16* pWhichIds, SfxItemPool* pPool )
+{
+    mpPool = pPool;
+    mpCurrentAttr = nullptr;
+    mnCurrentAttr = 0;
+
+    mpWhichId = pWhichIds;
+
+    mnItem = -1;
+    if (mpWhichId && (0 != *mpWhichId) && mpPool)
+    {
+        mvItems.reserve(mpPool->GetItemCount2( *mpWhichId ));
+        for (const SfxPoolItem* pItem : mpPool->GetItemSurrogates( *mpWhichId ))
+            mvItems.push_back(static_cast<const SvXMLAttrContainerItem*>(pItem));
+    }
+}
+
+bool NamespaceIteratorImpl::next( OUString& rPrefix, OUString& rURL )
+{
+    // we still need to process the current attribute
+    if( mpCurrentAttr && (mnCurrentAttr != USHRT_MAX) )
+    {
+        rPrefix = mpCurrentAttr->GetPrefix( mnCurrentAttr );
+        rURL = mpCurrentAttr->GetNamespace( mnCurrentAttr );
+
+        mnCurrentAttr = mpCurrentAttr->GetNextNamespaceIndex( mnCurrentAttr );
+        return true;
+    }
+
+    // we need the next namespace item
+    mpCurrentAttr = nullptr;
+    mnItem++;
+
+    // are we finished with the current whichid?
+    if( mnItem == static_cast<sal_Int32>(mvItems.size()) )
+    {
+        mpWhichId++;
+
+        // are we finished with the current pool?
+        if( 0 == *mpWhichId )
+            return false;
+
+        mnItem = -1;
+        mvItems.clear();
+        if (mpPool)
+        {
+            mvItems.reserve(mpPool->GetItemCount2( *mpWhichId ));
+            for (const SfxPoolItem* pItem2 : mpPool->GetItemSurrogates( *mpWhichId ))
+                mvItems.push_back(static_cast<const SvXMLAttrContainerItem*>(pItem2));
+        }
+        return next( rPrefix, rURL );
+    }
+
+    auto pItem = mvItems[mnItem];
+    // get that item and see if there namespaces inside
+    if( pItem->GetAttrCount() > 0 )
+    {
+        mpCurrentAttr = pItem;
+        mnCurrentAttr = pItem->GetFirstNamespaceIndex();
+    }
+    return next( rPrefix, rURL );
+}
+
+
+NamespaceMap::NamespaceMap( sal_uInt16* pWhichIds, SfxItemPool* pPool )
+: mpWhichIds( pWhichIds ), mpPool( pPool )
+{
+}
+
+// XNameAccess
+Any SAL_CALL NamespaceMap::getByName( const OUString& aName )
+{
+    NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
+
+    OUString aPrefix;
+    OUString aURL;
+
+    bool bFound;
+
+    do
+    {
+        bFound = aIter.next( aPrefix, aURL );
+    }
+    while( bFound && (aPrefix != aName ) );
+
+    if( !bFound )
+        throw NoSuchElementException();
+
+    return makeAny( aURL );
+}
+
+Sequence< OUString > SAL_CALL NamespaceMap::getElementNames()
+{
+    NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
+
+    OUString aPrefix;
+    OUString aURL;
+
+    std::set< OUString > aPrefixSet;
+
+    while( aIter.next( aPrefix, aURL ) )
+        aPrefixSet.insert( aPrefix );
+
+    return comphelper::containerToSequence(aPrefixSet);
+}
+
+sal_Bool SAL_CALL NamespaceMap::hasByName( const OUString& aName )
+{
+    NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
+
+    OUString aPrefix;
+    OUString aURL;
+
+    bool bFound;
+
+    do
+    {
+        bFound = aIter.next( aPrefix, aURL );
+    }
+    while( bFound && (aPrefix != aName ) );
+
+    return bFound;
+}
+
+// XElementAccess
+Type SAL_CALL NamespaceMap::getElementType()
+{
+    return ::cppu::UnoType<OUString>::get();
+}
+
+sal_Bool SAL_CALL NamespaceMap::hasElements()
+{
+    NamespaceIteratorImpl aIter( mpWhichIds, mpPool );
+
+    OUString aPrefix;
+    OUString aURL;
+
+    return aIter.next( aPrefix, aURL );
+}
+
+// XServiceInfo
+OUString SAL_CALL NamespaceMap::getImplementationName(  )
+{
+    return NamespaceMap_getImplementationName();
+}
+
+sal_Bool SAL_CALL NamespaceMap::supportsService( const OUString& serviceName )
+{
+    return cppu::supportsService( this, serviceName );
+}
+
+Sequence< OUString > SAL_CALL NamespaceMap::getSupportedServiceNames(  )
+{
+    return NamespaceMap_getSupportedServiceNames();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/XPropertyTable.cxx b/svx/source/unodraw/XPropertyTable.cxx
new file mode 100644
index 000000000..01e9e1dc4
--- /dev/null
+++ b/svx/source/unodraw/XPropertyTable.cxx
@@ -0,0 +1,669 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <memory>
+#include <XPropertyTable.hxx>
+#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
+#include <com/sun/star/drawing/LineDash.hpp>
+#include <com/sun/star/awt/Gradient.hpp>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/drawing/Hatch.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <o3tl/any.hxx>
+#include <vcl/svapp.hxx>
+
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <svx/xdef.hxx>
+
+#include <svx/unoapi.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+
+using namespace com::sun::star;
+using namespace ::cppu;
+
+namespace {
+
+class SvxUnoXPropertyTable : public WeakImplHelper< container::XNameContainer, lang::XServiceInfo >
+{
+private:
+    XPropertyList*  mpList;
+    sal_Int16 mnWhich;
+
+    long getCount() const { return mpList ? mpList->Count() : 0; }
+    const XPropertyEntry* get(long index) const;
+public:
+    SvxUnoXPropertyTable( sal_Int16 nWhich, XPropertyList* pList ) throw();
+
+    /// @throws uno::RuntimeException
+    virtual uno::Any getAny( const XPropertyEntry* pEntry ) const = 0;
+    /// @throws uno::RuntimeException
+    /// @throws lang::IllegalArgumentException
+    virtual std::unique_ptr<XPropertyEntry> createEntry(const OUString& rName, const uno::Any& rAny) const = 0;
+
+    // XServiceInfo
+    virtual sal_Bool SAL_CALL supportsService( const  OUString& ServiceName ) override;
+
+    // XNameContainer
+    virtual void SAL_CALL insertByName( const  OUString& aName, const  uno::Any& aElement ) override;
+    virtual void SAL_CALL removeByName( const  OUString& Name ) override;
+
+    // XNameReplace
+    virtual void SAL_CALL replaceByName( const  OUString& aName, const  uno::Any& aElement ) override;
+
+    // XNameAccess
+    virtual uno::Any SAL_CALL getByName( const  OUString& aName ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getElementNames(  ) override;
+    virtual sal_Bool SAL_CALL hasByName( const  OUString& aName ) override;
+
+    // XElementAccess
+    virtual sal_Bool SAL_CALL hasElements(  ) override;
+};
+
+}
+
+SvxUnoXPropertyTable::SvxUnoXPropertyTable( sal_Int16 nWhich, XPropertyList* pList ) throw()
+: mpList( pList ), mnWhich( nWhich )
+{
+}
+
+const XPropertyEntry* SvxUnoXPropertyTable::get(long index) const
+{
+    if( mpList )
+        return mpList->Get(index);
+    else
+        return nullptr;
+}
+
+// XServiceInfo
+sal_Bool SAL_CALL SvxUnoXPropertyTable::supportsService( const  OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+// XNameContainer
+void SAL_CALL SvxUnoXPropertyTable::insertByName( const  OUString& aName, const  uno::Any& aElement )
+{
+    SolarMutexGuard aGuard;
+
+    if( nullptr == mpList )
+        throw lang::IllegalArgumentException();
+
+    if( hasByName( aName ) )
+        throw container::ElementExistException();
+
+    OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
+
+    std::unique_ptr<XPropertyEntry> pNewEntry(createEntry(aInternalName, aElement));
+    if (!pNewEntry)
+        throw lang::IllegalArgumentException();
+
+    mpList->Insert(std::move(pNewEntry));
+}
+
+void SAL_CALL SvxUnoXPropertyTable::removeByName( const  OUString& Name )
+{
+    SolarMutexGuard aGuard;
+
+    OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, Name);
+
+    const long nCount = getCount();
+    long i;
+    for( i = 0; i < nCount; i++ )
+    {
+        const XPropertyEntry* pEntry = get(i);
+        if (pEntry && aInternalName == pEntry->GetName())
+        {
+            mpList->Remove(i);
+            return;
+        }
+    }
+
+    throw container::NoSuchElementException();
+}
+
+// XNameReplace
+void SAL_CALL SvxUnoXPropertyTable::replaceByName( const  OUString& aName, const  uno::Any& aElement )
+{
+    SolarMutexGuard aGuard;
+
+    OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
+
+    const long nCount = getCount();
+    long i;
+    for( i = 0; i < nCount; i++ )
+    {
+        const XPropertyEntry* pEntry = get(i);
+        if (pEntry && aInternalName == pEntry->GetName())
+        {
+            std::unique_ptr<XPropertyEntry> pNewEntry(createEntry(aInternalName, aElement));
+            if (!pNewEntry)
+                throw lang::IllegalArgumentException();
+
+            mpList->Replace(std::move(pNewEntry), i);
+            return;
+        }
+    }
+
+    throw container::NoSuchElementException();
+}
+
+// XNameAccess
+uno::Any SAL_CALL SvxUnoXPropertyTable::getByName( const  OUString& aName )
+{
+    SolarMutexGuard aGuard;
+
+    OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
+
+    const long nCount = getCount();
+    long i;
+    for( i = 0; i < nCount; i++ )
+    {
+        const XPropertyEntry* pEntry = get(i);
+
+        if (pEntry && aInternalName == pEntry->GetName())
+            return getAny( pEntry );
+    }
+
+    throw container::NoSuchElementException();
+}
+
+uno::Sequence<  OUString > SAL_CALL SvxUnoXPropertyTable::getElementNames()
+{
+    SolarMutexGuard aGuard;
+
+    const long nCount = getCount();
+    uno::Sequence< OUString > aNames( nCount );
+    OUString* pNames = aNames.getArray();
+    long i;
+    for( i = 0; i < nCount; i++ )
+    {
+        const XPropertyEntry* pEntry = get(i);
+
+        if (pEntry)
+            *pNames++ = SvxUnogetApiNameForItem(mnWhich, pEntry->GetName());
+    }
+
+    return aNames;
+}
+
+sal_Bool SAL_CALL SvxUnoXPropertyTable::hasByName( const  OUString& aName )
+{
+    SolarMutexGuard aGuard;
+
+    OUString aInternalName = SvxUnogetInternalNameForItem(mnWhich, aName);
+
+    const long nCount = mpList?mpList->Count():0;
+    long i;
+    for( i = 0; i < nCount; i++ )
+    {
+        const XPropertyEntry* pEntry = get(i);
+        if (pEntry && aInternalName == pEntry->GetName())
+            return true;
+    }
+
+    return false;
+}
+
+// XElementAccess
+sal_Bool SAL_CALL SvxUnoXPropertyTable::hasElements(  )
+{
+    SolarMutexGuard aGuard;
+
+    return getCount() != 0;
+}
+
+namespace {
+
+class SvxUnoXColorTable : public SvxUnoXPropertyTable
+{
+public:
+    explicit SvxUnoXColorTable( XPropertyList* pList ) throw() : SvxUnoXPropertyTable( XATTR_LINECOLOR, pList ) {};
+
+    // SvxUnoXPropertyTable
+    virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() override;
+    virtual std::unique_ptr<XPropertyEntry> createEntry(const OUString& rName, const uno::Any& rAny) const override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+};
+
+}
+
+uno::Reference< uno::XInterface > SvxUnoXColorTable_createInstance( XPropertyList* pList ) throw()
+{
+    return static_cast<OWeakObject*>(new SvxUnoXColorTable( pList ));
+}
+
+// SvxUnoXPropertyTable
+uno::Any SvxUnoXColorTable::getAny( const XPropertyEntry* pEntry ) const throw()
+{
+    return uno::Any( static_cast<sal_Int32>(static_cast<const XColorEntry*>(pEntry)->GetColor()) );
+}
+
+std::unique_ptr<XPropertyEntry> SvxUnoXColorTable::createEntry(const OUString& rName, const uno::Any& rAny) const
+{
+    Color aColor;
+    if( !(rAny >>= aColor) )
+        return std::unique_ptr<XPropertyEntry>();
+
+    return std::make_unique<XColorEntry>(aColor, rName);
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoXColorTable::getElementType()
+{
+    return ::cppu::UnoType<sal_Int32>::get();
+}
+
+// XServiceInfo
+OUString SAL_CALL SvxUnoXColorTable::getImplementationName(  )
+{
+    return "SvxUnoXColorTable";
+}
+
+uno::Sequence<  OUString > SAL_CALL SvxUnoXColorTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.ColorTable" };
+}
+
+namespace {
+
+class SvxUnoXLineEndTable : public SvxUnoXPropertyTable
+{
+public:
+    explicit SvxUnoXLineEndTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_LINEEND, pTable ) {};
+
+    // SvxUnoXPropertyTable
+    virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() override;
+    virtual std::unique_ptr<XPropertyEntry> createEntry(const OUString& rName, const uno::Any& rAny) const override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+};
+
+}
+
+uno::Reference< uno::XInterface > SvxUnoXLineEndTable_createInstance( XPropertyList* pTable ) throw()
+{
+    return static_cast<OWeakObject*>(new SvxUnoXLineEndTable( pTable ));
+}
+
+// SvxUnoXPropertyTable
+uno::Any SvxUnoXLineEndTable::getAny( const XPropertyEntry* pEntry ) const throw()
+{
+    drawing::PolyPolygonBezierCoords aBezier;
+    basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( static_cast<const XLineEndEntry*>(pEntry)->GetLineEnd(),
+                                                          aBezier );
+    return uno::Any(aBezier);
+}
+
+std::unique_ptr<XPropertyEntry> SvxUnoXLineEndTable::createEntry(const OUString& rName, const uno::Any& rAny) const
+{
+    auto pCoords = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(rAny);
+    if( !pCoords )
+        return std::unique_ptr<XLineEndEntry>();
+
+    basegfx::B2DPolyPolygon aPolyPolygon;
+    if( pCoords->Coordinates.getLength() > 0 )
+        aPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon( *pCoords );
+
+    // #86265# make sure polygon is closed
+    aPolyPolygon.setClosed(true);
+
+    return std::make_unique<XLineEndEntry>(aPolyPolygon, rName);
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoXLineEndTable::getElementType()
+{
+    return cppu::UnoType<drawing::PolyPolygonBezierCoords>::get();
+}
+
+// XServiceInfo
+OUString SAL_CALL SvxUnoXLineEndTable::getImplementationName(  )
+{
+    return "SvxUnoXLineEndTable";
+}
+
+uno::Sequence<  OUString > SAL_CALL SvxUnoXLineEndTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.LineEndTable" };
+}
+
+namespace {
+
+class SvxUnoXDashTable : public SvxUnoXPropertyTable
+{
+public:
+    explicit SvxUnoXDashTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_LINEDASH, pTable ) {};
+
+    // SvxUnoXPropertyTable
+    virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() override;
+    virtual std::unique_ptr<XPropertyEntry> createEntry(const OUString& rName, const uno::Any& rAny) const override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+};
+
+}
+
+uno::Reference< uno::XInterface > SvxUnoXDashTable_createInstance( XPropertyList* pTable ) throw()
+{
+    return static_cast<OWeakObject*>(new SvxUnoXDashTable( pTable ));
+}
+
+// SvxUnoXPropertyTable
+uno::Any SvxUnoXDashTable::getAny( const XPropertyEntry* pEntry ) const throw()
+{
+    const XDash& rXD = static_cast<const XDashEntry*>(pEntry)->GetDash();
+
+    drawing::LineDash aLineDash;
+
+    aLineDash.Style = static_cast<css::drawing::DashStyle>(static_cast<sal_uInt16>(rXD.GetDashStyle()));
+    aLineDash.Dots = rXD.GetDots();
+    aLineDash.DotLen = rXD.GetDotLen();
+    aLineDash.Dashes = rXD.GetDashes();
+    aLineDash.DashLen = rXD.GetDashLen();
+    aLineDash.Distance = rXD.GetDistance();
+
+    return uno::Any(aLineDash);
+}
+
+std::unique_ptr<XPropertyEntry> SvxUnoXDashTable::createEntry(const OUString& rName, const uno::Any& rAny) const
+{
+    drawing::LineDash aLineDash;
+    if(!(rAny >>= aLineDash))
+        return std::unique_ptr<XDashEntry>();
+
+    XDash aXDash;
+
+    aXDash.SetDashStyle(static_cast<css::drawing::DashStyle>(static_cast<sal_uInt16>(aLineDash.Style)));
+    aXDash.SetDots(aLineDash.Dots);
+    aXDash.SetDotLen(aLineDash.DotLen);
+    aXDash.SetDashes(aLineDash.Dashes);
+    aXDash.SetDashLen(aLineDash.DashLen);
+    aXDash.SetDistance(aLineDash.Distance);
+
+    return std::make_unique<XDashEntry>(aXDash, rName);
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoXDashTable::getElementType()
+{
+    return cppu::UnoType<drawing::LineDash>::get();
+}
+
+// XServiceInfo
+OUString SAL_CALL SvxUnoXDashTable::getImplementationName(  )
+{
+    return "SvxUnoXDashTable";
+}
+
+uno::Sequence<  OUString > SAL_CALL SvxUnoXDashTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.DashTable" };
+}
+
+namespace {
+
+class SvxUnoXHatchTable : public SvxUnoXPropertyTable
+{
+public:
+    explicit SvxUnoXHatchTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_FILLHATCH, pTable ) {};
+
+    // SvxUnoXPropertyTable
+    virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() override;
+    virtual std::unique_ptr<XPropertyEntry> createEntry(const OUString& rName, const uno::Any& rAny) const override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+};
+
+}
+
+uno::Reference< uno::XInterface > SvxUnoXHatchTable_createInstance( XPropertyList* pTable ) throw()
+{
+    return static_cast<OWeakObject*>(new SvxUnoXHatchTable( pTable ));
+}
+
+// SvxUnoXPropertyTable
+uno::Any SvxUnoXHatchTable::getAny( const XPropertyEntry* pEntry ) const throw()
+{
+    const XHatch& aHatch = static_cast<const XHatchEntry*>(pEntry)->GetHatch();
+
+    drawing::Hatch aUnoHatch;
+
+    aUnoHatch.Style = aHatch.GetHatchStyle();
+    aUnoHatch.Color = sal_Int32(aHatch.GetColor());
+    aUnoHatch.Distance = aHatch.GetDistance();
+    aUnoHatch.Angle = aHatch.GetAngle();
+
+    return uno::Any(aUnoHatch);
+}
+
+std::unique_ptr<XPropertyEntry> SvxUnoXHatchTable::createEntry(const OUString& rName, const uno::Any& rAny) const
+{
+    drawing::Hatch aUnoHatch;
+    if(!(rAny >>= aUnoHatch))
+        return std::unique_ptr<XHatchEntry>();
+
+    XHatch aXHatch;
+    aXHatch.SetHatchStyle( aUnoHatch.Style );
+    aXHatch.SetColor( Color(aUnoHatch.Color) );
+    aXHatch.SetDistance( aUnoHatch.Distance );
+    aXHatch.SetAngle( aUnoHatch.Angle );
+
+    return std::make_unique<XHatchEntry>(aXHatch, rName);
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoXHatchTable::getElementType()
+{
+    return cppu::UnoType<drawing::Hatch>::get();
+}
+
+// XServiceInfo
+OUString SAL_CALL SvxUnoXHatchTable::getImplementationName(  )
+{
+    return "SvxUnoXHatchTable";
+}
+
+uno::Sequence<  OUString > SAL_CALL SvxUnoXHatchTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.HatchTable" };
+}
+
+namespace {
+
+class SvxUnoXGradientTable : public SvxUnoXPropertyTable
+{
+public:
+    explicit SvxUnoXGradientTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_FILLGRADIENT, pTable ) {};
+
+    // SvxUnoXPropertyTable
+    virtual uno::Any getAny( const XPropertyEntry* pEntry ) const throw() override;
+    virtual std::unique_ptr<XPropertyEntry> createEntry(const OUString& rName, const uno::Any& rAny) const override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+};
+
+}
+
+uno::Reference< uno::XInterface > SvxUnoXGradientTable_createInstance( XPropertyList* pTable ) throw()
+{
+    return static_cast<OWeakObject*>(new SvxUnoXGradientTable( pTable ));
+}
+
+// SvxUnoXPropertyTable
+uno::Any SvxUnoXGradientTable::getAny( const XPropertyEntry* pEntry ) const throw()
+{
+    const XGradient& aXGradient = static_cast<const XGradientEntry*>(pEntry)->GetGradient();
+    awt::Gradient aGradient;
+
+    aGradient.Style = aXGradient.GetGradientStyle();
+    aGradient.StartColor = static_cast<sal_Int32>(aXGradient.GetStartColor());
+    aGradient.EndColor = static_cast<sal_Int32>(aXGradient.GetEndColor());
+    aGradient.Angle = static_cast<short>(aXGradient.GetAngle());
+    aGradient.Border = aXGradient.GetBorder();
+    aGradient.XOffset = aXGradient.GetXOffset();
+    aGradient.YOffset = aXGradient.GetYOffset();
+    aGradient.StartIntensity = aXGradient.GetStartIntens();
+    aGradient.EndIntensity = aXGradient.GetEndIntens();
+    aGradient.StepCount = aXGradient.GetSteps();
+
+    return uno::Any(aGradient);
+}
+
+std::unique_ptr<XPropertyEntry> SvxUnoXGradientTable::createEntry(const OUString& rName, const uno::Any& rAny) const
+{
+    awt::Gradient aGradient;
+    if(!(rAny >>= aGradient))
+        return std::unique_ptr<XPropertyEntry>();
+
+    XGradient aXGradient;
+
+    aXGradient.SetGradientStyle( aGradient.Style );
+    aXGradient.SetStartColor( Color(aGradient.StartColor) );
+    aXGradient.SetEndColor( Color(aGradient.EndColor) );
+    aXGradient.SetAngle( aGradient.Angle );
+    aXGradient.SetBorder( aGradient.Border );
+    aXGradient.SetXOffset( aGradient.XOffset );
+    aXGradient.SetYOffset( aGradient.YOffset );
+    aXGradient.SetStartIntens( aGradient.StartIntensity );
+    aXGradient.SetEndIntens( aGradient.EndIntensity );
+    aXGradient.SetSteps( aGradient.StepCount );
+
+    return std::make_unique<XGradientEntry>(aXGradient, rName);
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoXGradientTable::getElementType()
+{
+    return cppu::UnoType<awt::Gradient>::get();
+}
+
+// XServiceInfo
+OUString SAL_CALL SvxUnoXGradientTable::getImplementationName(  )
+{
+    return "SvxUnoXGradientTable";
+}
+
+uno::Sequence<  OUString > SAL_CALL SvxUnoXGradientTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.GradientTable" };
+}
+
+namespace {
+
+class SvxUnoXBitmapTable : public SvxUnoXPropertyTable
+{
+public:
+    explicit SvxUnoXBitmapTable( XPropertyList* pTable ) throw() : SvxUnoXPropertyTable( XATTR_FILLBITMAP, pTable ) {};
+
+    // SvxUnoXPropertyTable
+    virtual uno::Any getAny( const XPropertyEntry* pEntry ) const override;
+    virtual std::unique_ptr<XPropertyEntry> createEntry(const OUString& rName, const uno::Any& rAny) const override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+};
+
+}
+
+uno::Reference< uno::XInterface > SvxUnoXBitmapTable_createInstance( XPropertyList* pTable ) throw()
+{
+    return static_cast<OWeakObject*>(new SvxUnoXBitmapTable( pTable ));
+}
+
+// SvxUnoXPropertyTable
+uno::Any SvxUnoXBitmapTable::getAny( const XPropertyEntry* pEntry ) const
+{
+    auto xBitmapEntry = static_cast<const XBitmapEntry*>(pEntry);
+    css::uno::Reference<css::awt::XBitmap> xBitmap(xBitmapEntry->GetGraphicObject().GetGraphic().GetXGraphic(), uno::UNO_QUERY);
+    return uno::Any(xBitmap);
+}
+
+std::unique_ptr<XPropertyEntry> SvxUnoXBitmapTable::createEntry(const OUString& rName, const uno::Any& rAny) const
+{
+    if (!rAny.has<uno::Reference<awt::XBitmap>>())
+        return std::unique_ptr<XPropertyEntry>();
+
+    auto xBitmap = rAny.get<uno::Reference<awt::XBitmap>>();
+    if (!xBitmap.is())
+        return nullptr;
+
+    uno::Reference<graphic::XGraphic> xGraphic(xBitmap, uno::UNO_QUERY);
+    if (!xGraphic.is())
+        return nullptr;
+
+    Graphic aGraphic(xGraphic);
+    if (aGraphic.IsNone())
+        return nullptr;
+
+    GraphicObject aGraphicObject(aGraphic);
+    return std::make_unique<XBitmapEntry>(aGraphicObject, rName);
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoXBitmapTable::getElementType()
+{
+    return ::cppu::UnoType<awt::XBitmap>::get();
+}
+
+// XServiceInfo
+OUString SAL_CALL SvxUnoXBitmapTable::getImplementationName(  )
+{
+    return "SvxUnoXBitmapTable";
+}
+
+uno::Sequence<  OUString > SAL_CALL SvxUnoXBitmapTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.BitmapTable" };
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/gluepts.cxx b/svx/source/unodraw/gluepts.cxx
new file mode 100644
index 000000000..37b661ac6
--- /dev/null
+++ b/svx/source/unodraw/gluepts.cxx
@@ -0,0 +1,513 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/container/NoSuchElementException.hpp>
+#include <com/sun/star/container/XIdentifierContainer.hpp>
+#include <com/sun/star/container/XIndexContainer.hpp>
+#include <com/sun/star/drawing/GluePoint2.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+
+#include <cppuhelper/implbase.hxx>
+#include <tools/weakbase.hxx>
+
+#include <svx/svdobj.hxx>
+#include <svx/svdglue.hxx>
+
+#include "gluepts.hxx"
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+const sal_uInt16 NON_USER_DEFINED_GLUE_POINTS = 4;
+
+namespace {
+
+class SvxUnoGluePointAccess : public WeakImplHelper< container::XIndexContainer, container::XIdentifierContainer >
+{
+private:
+    tools::WeakReference<SdrObject>    mpObject;
+
+public:
+    explicit SvxUnoGluePointAccess( SdrObject* pObject ) throw();
+
+    // XIdentifierContainer
+    virtual sal_Int32 SAL_CALL insert( const uno::Any& aElement ) override;
+    virtual void SAL_CALL removeByIdentifier( sal_Int32 Identifier ) override;
+
+    // XIdentifierReplace
+    virtual void SAL_CALL replaceByIdentifer( sal_Int32 Identifier, const uno::Any& aElement ) override;
+
+    // XIdentifierReplace
+    virtual uno::Any SAL_CALL getByIdentifier( sal_Int32 Identifier ) override;
+    virtual uno::Sequence< sal_Int32 > SAL_CALL getIdentifiers(  ) override;
+
+    /* deprecated */
+    // XIndexContainer
+    virtual void SAL_CALL insertByIndex( sal_Int32 Index, const uno::Any& Element ) override;
+    virtual void SAL_CALL removeByIndex( sal_Int32 Index ) override;
+
+    /* deprecated */
+    // XIndexReplace
+    virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const uno::Any& Element ) override;
+
+    /* deprecated */
+    // XIndexAccess
+    virtual sal_Int32 SAL_CALL getCount(  ) override;
+    virtual uno::Any SAL_CALL getByIndex( sal_Int32 Index ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType(  ) override;
+    virtual sal_Bool SAL_CALL hasElements(  ) override;
+};
+
+}
+
+static void convert( const SdrGluePoint& rSdrGlue, drawing::GluePoint2& rUnoGlue ) throw()
+{
+    rUnoGlue.Position.X = rSdrGlue.GetPos().X();
+    rUnoGlue.Position.Y = rSdrGlue.GetPos().Y();
+    rUnoGlue.IsRelative = rSdrGlue.IsPercent();
+
+    SdrAlign eAlign = rSdrGlue.GetAlign();
+    if (eAlign == (SdrAlign::VERT_TOP|SdrAlign::HORZ_LEFT))
+        rUnoGlue.PositionAlignment = drawing::Alignment_TOP_LEFT;
+    else if (eAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP))
+        rUnoGlue.PositionAlignment = drawing::Alignment_TOP;
+    else if (eAlign == (SdrAlign::VERT_TOP|SdrAlign::HORZ_RIGHT))
+        rUnoGlue.PositionAlignment = drawing::Alignment_TOP_RIGHT;
+    else if (eAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER))
+        rUnoGlue.PositionAlignment = drawing::Alignment_CENTER;
+    else if (eAlign == (SdrAlign::HORZ_RIGHT|SdrAlign::VERT_CENTER))
+        rUnoGlue.PositionAlignment = drawing::Alignment_RIGHT;
+    else if (eAlign == (SdrAlign::HORZ_LEFT|SdrAlign::VERT_BOTTOM))
+        rUnoGlue.PositionAlignment = drawing::Alignment_BOTTOM_LEFT;
+    else if (eAlign == (SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM))
+        rUnoGlue.PositionAlignment = drawing::Alignment_BOTTOM;
+    else if (eAlign == (SdrAlign::HORZ_RIGHT|SdrAlign::VERT_BOTTOM))
+        rUnoGlue.PositionAlignment = drawing::Alignment_BOTTOM_RIGHT;
+    else {
+        rUnoGlue.PositionAlignment = drawing::Alignment_LEFT;
+    }
+
+    switch( rSdrGlue.GetEscDir() )
+    {
+    case SdrEscapeDirection::LEFT:
+        rUnoGlue.Escape = drawing::EscapeDirection_LEFT;
+        break;
+    case SdrEscapeDirection::RIGHT:
+        rUnoGlue.Escape = drawing::EscapeDirection_RIGHT;
+        break;
+    case SdrEscapeDirection::TOP:
+        rUnoGlue.Escape = drawing::EscapeDirection_UP;
+        break;
+    case SdrEscapeDirection::BOTTOM:
+        rUnoGlue.Escape = drawing::EscapeDirection_DOWN;
+        break;
+    case SdrEscapeDirection::HORZ:
+        rUnoGlue.Escape = drawing::EscapeDirection_HORIZONTAL;
+        break;
+    case SdrEscapeDirection::VERT:
+        rUnoGlue.Escape = drawing::EscapeDirection_VERTICAL;
+        break;
+//          case SdrEscapeDirection::SMART:
+    default:
+        rUnoGlue.Escape = drawing::EscapeDirection_SMART;
+        break;
+    }
+}
+
+static void convert( const drawing::GluePoint2& rUnoGlue, SdrGluePoint& rSdrGlue ) throw()
+{
+    rSdrGlue.SetPos( Point( rUnoGlue.Position.X, rUnoGlue.Position.Y ) );
+    rSdrGlue.SetPercent( rUnoGlue.IsRelative );
+
+    switch( rUnoGlue.PositionAlignment )
+    {
+    case drawing::Alignment_TOP_LEFT:
+        rSdrGlue.SetAlign( SdrAlign::VERT_TOP|SdrAlign::HORZ_LEFT );
+        break;
+    case drawing::Alignment_TOP:
+        rSdrGlue.SetAlign( SdrAlign::HORZ_CENTER|SdrAlign::VERT_TOP );
+        break;
+    case drawing::Alignment_TOP_RIGHT:
+        rSdrGlue.SetAlign( SdrAlign::VERT_TOP|SdrAlign::HORZ_RIGHT );
+        break;
+    case drawing::Alignment_CENTER:
+        rSdrGlue.SetAlign( SdrAlign::HORZ_CENTER|SdrAlign::VERT_CENTER );
+        break;
+    case drawing::Alignment_RIGHT:
+        rSdrGlue.SetAlign( SdrAlign::HORZ_RIGHT|SdrAlign::VERT_CENTER );
+        break;
+    case drawing::Alignment_BOTTOM_LEFT:
+        rSdrGlue.SetAlign( SdrAlign::HORZ_LEFT|SdrAlign::VERT_BOTTOM );
+        break;
+    case drawing::Alignment_BOTTOM:
+        rSdrGlue.SetAlign( SdrAlign::HORZ_CENTER|SdrAlign::VERT_BOTTOM );
+        break;
+    case drawing::Alignment_BOTTOM_RIGHT:
+        rSdrGlue.SetAlign( SdrAlign::HORZ_RIGHT|SdrAlign::VERT_BOTTOM );
+        break;
+//  case SdrAlign::HORZ_LEFT:
+    default:
+        rSdrGlue.SetAlign( SdrAlign::HORZ_LEFT );
+        break;
+    }
+    switch( rUnoGlue.Escape )
+    {
+    case drawing::EscapeDirection_LEFT:
+        rSdrGlue.SetEscDir(SdrEscapeDirection::LEFT);
+        break;
+    case drawing::EscapeDirection_RIGHT:
+        rSdrGlue.SetEscDir(SdrEscapeDirection::RIGHT);
+        break;
+    case drawing::EscapeDirection_UP:
+        rSdrGlue.SetEscDir(SdrEscapeDirection::TOP);
+        break;
+    case drawing::EscapeDirection_DOWN:
+        rSdrGlue.SetEscDir(SdrEscapeDirection::BOTTOM);
+        break;
+    case drawing::EscapeDirection_HORIZONTAL:
+        rSdrGlue.SetEscDir(SdrEscapeDirection::HORZ);
+        break;
+    case drawing::EscapeDirection_VERTICAL:
+        rSdrGlue.SetEscDir(SdrEscapeDirection::VERT);
+        break;
+//  case drawing::EscapeDirection_SMART:
+    default:
+        rSdrGlue.SetEscDir(SdrEscapeDirection::SMART);
+        break;
+    }
+}
+
+SvxUnoGluePointAccess::SvxUnoGluePointAccess( SdrObject* pObject ) throw()
+: mpObject( pObject )
+{
+}
+
+// XIdentifierContainer
+sal_Int32 SAL_CALL SvxUnoGluePointAccess::insert( const uno::Any& aElement )
+{
+    if( mpObject.is() )
+    {
+        SdrGluePointList* pList = mpObject->ForceGluePointList();
+        if( pList )
+        {
+            // second, insert the new glue point
+            drawing::GluePoint2 aUnoGlue;
+
+            if( aElement >>= aUnoGlue )
+            {
+                SdrGluePoint aSdrGlue;
+                convert( aUnoGlue, aSdrGlue );
+                sal_uInt16 nId = pList->Insert( aSdrGlue );
+
+                // only repaint, no objectchange
+                mpObject->ActionChanged();
+                // mpObject->BroadcastObjectChange();
+
+                return static_cast<sal_Int32>((*pList)[nId].GetId() + NON_USER_DEFINED_GLUE_POINTS) - 1;
+            }
+
+            throw lang::IllegalArgumentException();
+        }
+    }
+
+    return -1;
+}
+
+void SAL_CALL SvxUnoGluePointAccess::removeByIdentifier( sal_Int32 Identifier )
+{
+    if( mpObject.is() && ( Identifier >= NON_USER_DEFINED_GLUE_POINTS ))
+    {
+        const sal_uInt16 nId = static_cast<sal_uInt16>(Identifier - NON_USER_DEFINED_GLUE_POINTS) + 1;
+
+        SdrGluePointList* pList = const_cast<SdrGluePointList*>(mpObject->GetGluePointList());
+        const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
+        sal_uInt16 i;
+
+        for( i = 0; i < nCount; i++ )
+        {
+            if( (*pList)[i].GetId() == nId )
+            {
+                pList->Delete( i );
+
+                // only repaint, no objectchange
+                mpObject->ActionChanged();
+                // mpObject->BroadcastObjectChange();
+
+                return;
+            }
+        }
+    }
+
+    throw container::NoSuchElementException();
+}
+
+// XIdentifierReplace
+void SAL_CALL SvxUnoGluePointAccess::replaceByIdentifer( sal_Int32 Identifier, const uno::Any& aElement )
+{
+    if( mpObject.is() )
+    {
+        struct drawing::GluePoint2 aGluePoint;
+        if( (Identifier < NON_USER_DEFINED_GLUE_POINTS) || !(aElement >>= aGluePoint))
+            throw lang::IllegalArgumentException();
+
+        const sal_uInt16 nId = static_cast<sal_uInt16>( Identifier - NON_USER_DEFINED_GLUE_POINTS ) + 1;
+
+        SdrGluePointList* pList = const_cast< SdrGluePointList* >( mpObject->GetGluePointList() );
+        const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
+        sal_uInt16 i;
+        for( i = 0; i < nCount; i++ )
+        {
+            if( (*pList)[i].GetId() == nId )
+            {
+                // change the glue point
+                SdrGluePoint& rTempPoint = (*pList)[i];
+                convert( aGluePoint, rTempPoint );
+
+                // only repaint, no objectchange
+                mpObject->ActionChanged();
+                // mpObject->BroadcastObjectChange();
+
+                return;
+            }
+        }
+
+        throw container::NoSuchElementException();
+    }
+}
+
+// XIdentifierAccess
+uno::Any SAL_CALL SvxUnoGluePointAccess::getByIdentifier( sal_Int32 Identifier )
+{
+    if( mpObject.is() )
+    {
+        struct drawing::GluePoint2 aGluePoint;
+
+        if( Identifier < NON_USER_DEFINED_GLUE_POINTS ) // default glue point?
+        {
+            SdrGluePoint aTempPoint = mpObject->GetVertexGluePoint( static_cast<sal_uInt16>(Identifier) );
+            aGluePoint.IsUserDefined = false;
+            convert( aTempPoint, aGluePoint );
+            return uno::makeAny( aGluePoint );
+        }
+        else
+        {
+            const sal_uInt16 nId = static_cast<sal_uInt16>( Identifier - NON_USER_DEFINED_GLUE_POINTS ) + 1;
+
+            const SdrGluePointList* pList = mpObject->GetGluePointList();
+            const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
+            for( sal_uInt16 i = 0; i < nCount; i++ )
+            {
+                const SdrGluePoint& rTempPoint = (*pList)[i];
+                if( rTempPoint.GetId() == nId )
+                {
+                    // #i38892#
+                    if(rTempPoint.IsUserDefined())
+                    {
+                        aGluePoint.IsUserDefined = true;
+                    }
+
+                    convert( rTempPoint, aGluePoint );
+                    return uno::makeAny( aGluePoint );
+                }
+            }
+        }
+    }
+
+    throw container::NoSuchElementException();
+}
+
+uno::Sequence< sal_Int32 > SAL_CALL SvxUnoGluePointAccess::getIdentifiers()
+{
+    if( mpObject.is() )
+    {
+        const SdrGluePointList* pList = mpObject->GetGluePointList();
+        const sal_uInt16 nCount = pList ? pList->GetCount() : 0;
+
+        sal_uInt16 i;
+
+        uno::Sequence< sal_Int32 > aIdSequence( nCount + NON_USER_DEFINED_GLUE_POINTS );
+        sal_Int32 *pIdentifier = aIdSequence.getArray();
+
+        for( i = 0; i < NON_USER_DEFINED_GLUE_POINTS; i++ )
+            *pIdentifier++ = static_cast<sal_Int32>(i);
+
+        for( i = 0; i < nCount; i++ )
+            *pIdentifier++ = static_cast<sal_Int32>( (*pList)[i].GetId() + NON_USER_DEFINED_GLUE_POINTS ) - 1;
+
+        return aIdSequence;
+    }
+    else
+    {
+        uno::Sequence< sal_Int32 > aEmpty;
+        return aEmpty;
+    }
+}
+
+/* deprecated */
+
+// XIndexContainer
+void SAL_CALL SvxUnoGluePointAccess::insertByIndex( sal_Int32, const uno::Any& Element )
+{
+    if( mpObject.is() )
+    {
+        SdrGluePointList* pList = mpObject->ForceGluePointList();
+        if( pList )
+        {
+            SdrGluePoint aSdrGlue;
+            drawing::GluePoint2 aUnoGlue;
+
+            if( Element >>= aUnoGlue )
+            {
+                convert( aUnoGlue, aSdrGlue );
+                pList->Insert( aSdrGlue );
+
+                // only repaint, no objectchange
+                mpObject->ActionChanged();
+                // mpObject->BroadcastObjectChange();
+
+                return;
+            }
+
+            throw lang::IllegalArgumentException();
+        }
+    }
+
+    throw lang::IndexOutOfBoundsException();
+}
+
+void SAL_CALL SvxUnoGluePointAccess::removeByIndex( sal_Int32 Index )
+{
+    if( mpObject.is() )
+    {
+        SdrGluePointList* pList = mpObject->ForceGluePointList();
+        if( pList )
+        {
+            Index -= 4;
+            if( Index >= 0 && Index < pList->GetCount() )
+            {
+                pList->Delete( static_cast<sal_uInt16>(Index) );
+
+                // only repaint, no objectchange
+                mpObject->ActionChanged();
+                // mpObject->BroadcastObjectChange();
+
+                return;
+            }
+        }
+    }
+
+    throw lang::IndexOutOfBoundsException();
+}
+
+// XIndexReplace
+void SAL_CALL SvxUnoGluePointAccess::replaceByIndex( sal_Int32 Index, const uno::Any& Element )
+{
+    drawing::GluePoint2 aUnoGlue;
+    if(!(Element >>= aUnoGlue))
+        throw lang::IllegalArgumentException();
+
+    Index -= 4;
+    if( mpObject.is() && Index >= 0 )
+    {
+        SdrGluePointList* pList = const_cast< SdrGluePointList* >( mpObject->GetGluePointList() );
+        if( pList && Index < pList->GetCount() )
+        {
+            SdrGluePoint& rGlue = (*pList)[static_cast<sal_uInt16>(Index)];
+            convert( aUnoGlue, rGlue );
+
+            // only repaint, no objectchange
+            mpObject->ActionChanged();
+            // mpObject->BroadcastObjectChange();
+        }
+    }
+
+    throw lang::IndexOutOfBoundsException();
+}
+
+// XIndexAccess
+sal_Int32 SAL_CALL SvxUnoGluePointAccess::getCount()
+{
+    sal_Int32 nCount = 0;
+    if( mpObject.is() )
+    {
+        // each node has a default of 4 glue points
+        // and any number of user defined glue points
+        nCount += 4;
+
+        const SdrGluePointList* pList = mpObject->GetGluePointList();
+        if( pList )
+            nCount += pList->GetCount();
+    }
+
+    return nCount;
+}
+
+uno::Any SAL_CALL SvxUnoGluePointAccess::getByIndex( sal_Int32 Index )
+{
+    if( Index >= 0 && mpObject.is() )
+    {
+        struct drawing::GluePoint2 aGluePoint;
+
+        if( Index < 4 ) // default glue point?
+        {
+            SdrGluePoint aTempPoint = mpObject->GetVertexGluePoint( static_cast<sal_uInt16>(Index) );
+            aGluePoint.IsUserDefined = false;
+            convert( aTempPoint, aGluePoint );
+            return uno::Any(aGluePoint);
+        }
+        else
+        {
+            Index -= 4;
+            const SdrGluePointList* pList = mpObject->GetGluePointList();
+            if( pList && Index < pList->GetCount() )
+            {
+                const SdrGluePoint& rTempPoint = (*pList)[static_cast<sal_uInt16>(Index)];
+                aGluePoint.IsUserDefined = true;
+                convert( rTempPoint, aGluePoint );
+                return uno::Any(aGluePoint);
+            }
+        }
+    }
+
+    throw lang::IndexOutOfBoundsException();
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoGluePointAccess::getElementType()
+{
+    return cppu::UnoType<drawing::GluePoint2>::get();
+}
+
+sal_Bool SAL_CALL SvxUnoGluePointAccess::hasElements()
+{
+    return mpObject.is();
+}
+
+/**
+ * Create a SvxUnoGluePointAccess
+ */
+uno::Reference< uno::XInterface > SvxUnoGluePointAccess_createInstance( SdrObject* pObject )
+{
+    return *new SvxUnoGluePointAccess(pObject);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/gluepts.hxx b/svx/source/unodraw/gluepts.hxx
new file mode 100644
index 000000000..9747a454f
--- /dev/null
+++ b/svx/source/unodraw/gluepts.hxx
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SVX_SOURCE_UNODRAW_GLUEPTS_HXX
+#define INCLUDED_SVX_SOURCE_UNODRAW_GLUEPTS_HXX
+
+#include <sal/config.h>
+
+#include <com/sun/star/uno/Reference.hxx>
+
+namespace com::sun::star::uno { class XInterface; }
+class SdrObject;
+
+css::uno::Reference<css::uno::XInterface>
+SvxUnoGluePointAccess_createInstance(SdrObject * pObject);
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/recoveryui.cxx b/svx/source/unodraw/recoveryui.cxx
new file mode 100644
index 000000000..56550fd7f
--- /dev/null
+++ b/svx/source/unodraw/recoveryui.cxx
@@ -0,0 +1,331 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_folders.h>
+
+#include <docrecovery.hxx>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/XSynchronousDispatch.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <osl/file.hxx>
+#include <rtl/bootstrap.hxx>
+#include <rtl/ref.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include <vcl/svapp.hxx>
+
+namespace svxdr = svx::DocRecovery;
+using namespace ::osl;
+
+namespace {
+
+class RecoveryUI : public ::cppu::WeakImplHelper< css::lang::XServiceInfo        ,
+                                                   css::frame::XSynchronousDispatch > // => XDispatch!
+{
+
+    // const, types, etcpp.
+    private:
+
+        /** @short TODO */
+        enum EJob
+        {
+            E_JOB_UNKNOWN,
+            E_DO_EMERGENCY_SAVE,
+            E_DO_RECOVERY,
+            E_DO_BRINGTOFRONT,
+        };
+
+
+    // member
+    private:
+
+        /** @short TODO */
+        css::uno::Reference< css::uno::XComponentContext > m_xContext;
+
+        /** @short TODO */
+        weld::Window* m_pParentWindow;
+
+        /** @short TODO */
+        RecoveryUI::EJob m_eJob;
+
+        // Active dialog
+        weld::Dialog* m_pDialog;
+
+    // interface
+    public:
+
+
+        /** @short  TODO */
+        explicit RecoveryUI(const css::uno::Reference< css::uno::XComponentContext >& xContext);
+
+        // css.lang.XServiceInfo
+
+        virtual OUString SAL_CALL getImplementationName() override;
+
+        virtual sal_Bool SAL_CALL supportsService(const OUString& sServiceName) override;
+
+        virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+
+
+        virtual css::uno::Any SAL_CALL dispatchWithReturnValue(const css::util::URL& aURL,
+                                            const css::uno::Sequence< css::beans::PropertyValue >& lArguments ) override;
+
+        void SetActiveDialog(weld::Dialog* pDialog)
+        {
+            m_pDialog = pDialog;
+        }
+
+    // helper
+    private:
+
+        EJob impl_classifyJob(const css::util::URL& aURL);
+
+        bool impl_doEmergencySave();
+
+        bool impl_doRecovery();
+
+        void impl_showAllRecoveredDocs();
+
+        bool impl_doBringToFront();
+};
+
+RecoveryUI::RecoveryUI(const css::uno::Reference< css::uno::XComponentContext >& xContext)
+    : m_xContext(xContext)
+    , m_pParentWindow(nullptr)
+    , m_eJob(RecoveryUI::E_JOB_UNKNOWN)
+    , m_pDialog(nullptr)
+{
+}
+
+OUString SAL_CALL RecoveryUI::getImplementationName()
+{
+    return "com.sun.star.comp.svx.RecoveryUI";
+}
+
+sal_Bool SAL_CALL RecoveryUI::supportsService(const OUString& sServiceName)
+{
+    return cppu::supportsService(this, sServiceName);
+}
+
+css::uno::Sequence< OUString > SAL_CALL RecoveryUI::getSupportedServiceNames()
+{
+    return { "com.sun.star.dialog.RecoveryUI" };
+}
+
+css::uno::Any SAL_CALL RecoveryUI::dispatchWithReturnValue(const css::util::URL& aURL,
+                                                   const css::uno::Sequence< css::beans::PropertyValue >& )
+{
+    // Internally we use VCL ... every call into vcl based code must
+    // be guarded by locking the global solar mutex.
+    ::SolarMutexGuard aSolarLock;
+
+    css::uno::Any aRet;
+    RecoveryUI::EJob eJob = impl_classifyJob(aURL);
+    // TODO think about outside arguments
+
+    switch(eJob)
+    {
+        case RecoveryUI::E_DO_EMERGENCY_SAVE:
+        {
+            bool bRet = impl_doEmergencySave();
+            aRet <<= bRet;
+            break;
+        }
+
+        case RecoveryUI::E_DO_RECOVERY:
+        {
+            bool bRet = impl_doRecovery();
+            aRet <<= bRet;
+            break;
+        }
+
+        case RecoveryUI::E_DO_BRINGTOFRONT:
+        {
+            bool bRet = impl_doBringToFront();
+            aRet <<= bRet;
+            break;
+        }
+
+        default:
+        {
+            aRet <<= false;
+            break;
+        }
+    }
+
+    return aRet;
+}
+
+
+OUString GetCrashConfigDir()
+{
+
+#if defined(_WIN32)
+    OUString    ustrValue = "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/bootstrap.ini:UserInstallation}";
+#elif defined(MACOSX)
+    OUString    ustrValue = "~";
+#else
+    OUString    ustrValue = "$SYSUSERCONFIG";
+#endif
+    rtl::Bootstrap::expandMacros( ustrValue );
+
+#if defined(_WIN32)
+    ustrValue += "/user/crashdata";
+#endif
+    return ustrValue;
+}
+
+
+#if defined(_WIN32)
+#define LCKFILE "crashdat.lck"
+#else
+#define LCKFILE ".crash_report_unsent"
+#endif
+
+
+OUString GetUnsentURL()
+{
+    OUString aURL = GetCrashConfigDir() + "/" LCKFILE;
+    return aURL;
+}
+
+
+bool delete_pending_crash()
+{
+    OUString    aUnsentURL = GetUnsentURL();
+    return ( FileBase::E_None == File::remove( aUnsentURL ) );
+}
+
+RecoveryUI::EJob RecoveryUI::impl_classifyJob(const css::util::URL& aURL)
+{
+    m_eJob = RecoveryUI::E_JOB_UNKNOWN;
+    if (aURL.Protocol == RECOVERY_CMDPART_PROTOCOL)
+    {
+        if (aURL.Path == RECOVERY_CMDPART_DO_EMERGENCY_SAVE)
+            m_eJob = RecoveryUI::E_DO_EMERGENCY_SAVE;
+        else if (aURL.Path == RECOVERY_CMDPART_DO_RECOVERY)
+            m_eJob = RecoveryUI::E_DO_RECOVERY;
+        else if (aURL.Path == RECOVERY_CMDPART_DO_BRINGTOFRONT)
+            m_eJob = RecoveryUI::E_DO_BRINGTOFRONT;
+    }
+
+    return m_eJob;
+}
+
+struct DialogReleaseGuard
+{
+    RecoveryUI& m_rRecoveryUI;
+
+    DialogReleaseGuard(RecoveryUI& rRecoveryUI, weld::Dialog* p)
+        : m_rRecoveryUI(rRecoveryUI)
+    {
+        m_rRecoveryUI.SetActiveDialog(p);
+    }
+    ~DialogReleaseGuard()
+    {
+        m_rRecoveryUI.SetActiveDialog(nullptr);
+    }
+};
+
+bool RecoveryUI::impl_doEmergencySave()
+{
+    // create core service, which implements the real "emergency save" algorithm.
+    rtl::Reference<svxdr::RecoveryCore> pCore = new svxdr::RecoveryCore(m_xContext, true);
+
+    // create dialog for this operation and bind it to the used core service
+    std::unique_ptr<svxdr::SaveDialog> xDialog(new svxdr::SaveDialog(m_pParentWindow, pCore.get()));
+    DialogReleaseGuard dialogReleaseGuard(*this, xDialog->getDialog());
+
+    // start the dialog
+    short nRet = xDialog->run();
+    return (nRet==DLG_RET_OK_AUTOLUNCH);
+}
+
+bool RecoveryUI::impl_doRecovery()
+{
+    // create core service, which implements the real "emergency save" algorithm.
+    rtl::Reference<svxdr::RecoveryCore> pCore = new svxdr::RecoveryCore(m_xContext, false);
+
+    // create all needed dialogs for this operation
+    // and bind it to the used core service
+    std::unique_ptr<svxdr::RecoveryDialog> xDialog(new svxdr::RecoveryDialog(m_pParentWindow, pCore.get()));
+    DialogReleaseGuard dialogReleaseGuard(*this, xDialog->getDialog());
+
+    // start the dialog
+    short nRet = xDialog->run();
+
+    impl_showAllRecoveredDocs();
+
+    delete_pending_crash();
+
+    return nRet != RET_CANCEL;
+}
+
+void RecoveryUI::impl_showAllRecoveredDocs()
+{
+    css::uno::Reference< css::frame::XDesktop2 > xDesktop = css::frame::Desktop::create( m_xContext );
+
+    css::uno::Reference< css::container::XIndexAccess > xTaskContainer(
+        xDesktop->getFrames(),
+        css::uno::UNO_QUERY_THROW);
+
+    sal_Int32 c = xTaskContainer->getCount();
+    sal_Int32 i = 0;
+    for (i=0; i<c; ++i)
+    {
+        try
+        {
+            css::uno::Reference< css::frame::XFrame > xTask;
+            xTaskContainer->getByIndex(i) >>= xTask;
+            if (!xTask.is())
+                continue;
+
+            css::uno::Reference< css::awt::XWindow > xWindow = xTask->getContainerWindow();
+            if (!xWindow.is())
+                continue;
+
+            xWindow->setVisible(true);
+        }
+        catch(const css::uno::RuntimeException&)
+            { throw; }
+        catch(const css::uno::Exception&)
+            { continue; }
+    }
+}
+
+bool RecoveryUI::impl_doBringToFront()
+{
+    if (!m_pDialog || !m_pDialog->get_visible())
+        return false;
+    m_pDialog->present();
+    return true;
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_svx_RecoveryUI_get_implementation(
+    css::uno::XComponentContext *context,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new RecoveryUI(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/shapeimpl.hxx b/svx/source/unodraw/shapeimpl.hxx
new file mode 100644
index 000000000..a1a4e6963
--- /dev/null
+++ b/svx/source/unodraw/shapeimpl.hxx
@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SVX_SOURCE_UNODRAW_SHAPEIMPL_HXX
+#define INCLUDED_SVX_SOURCE_UNODRAW_SHAPEIMPL_HXX
+
+#include <svx/unoprov.hxx>
+#include <svx/unoshape.hxx>
+
+class SvxShapeCaption : public SvxShapeText
+{
+public:
+    explicit SvxShapeCaption(SdrObject* pObj);
+    virtual ~SvxShapeCaption() throw() override;
+};
+class SvxPluginShape : public SvxOle2Shape
+{
+protected:
+    // override these for special property handling in subcasses. Return true if property is handled
+    virtual bool setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue ) override;
+    virtual bool getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue ) override;
+
+public:
+    explicit SvxPluginShape(SdrObject* pObj);
+    virtual ~SvxPluginShape() throw() override;
+
+    virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override;
+    using SvxUnoTextRangeBase::setPropertyValue;
+
+    virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues ) override;
+
+    virtual void Create( SdrObject* pNewOpj, SvxDrawPage* pNewPage ) override;
+};
+class SvxAppletShape : public SvxOle2Shape
+{
+protected:
+    // override these for special property handling in subcasses. Return true if property is handled
+    virtual bool setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue ) override;
+    virtual bool getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue ) override;
+
+public:
+    explicit SvxAppletShape(SdrObject* pObj);
+    virtual ~SvxAppletShape() throw() override;
+
+    virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override;
+    using SvxUnoTextRangeBase::setPropertyValue;
+
+    virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues ) override;
+
+    virtual void Create( SdrObject* pNewOpj, SvxDrawPage* pNewPage ) override;
+};
+class SvxFrameShape : public SvxOle2Shape
+{
+protected:
+    // override these for special property handling in subcasses. Return true if property is handled
+    virtual bool setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue ) override;
+    virtual bool getPropertyValueImpl(const OUString& rName, const SfxItemPropertySimpleEntry* pProperty,
+        css::uno::Any& rValue) override;
+
+public:
+    explicit SvxFrameShape(SdrObject* pObj);
+    virtual ~SvxFrameShape() throw() override;
+
+    virtual void SAL_CALL setPropertyValue( const OUString& aPropertyName, const css::uno::Any& aValue ) override;
+    using SvxUnoTextRangeBase::setPropertyValue;
+
+    virtual void SAL_CALL setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues ) override;
+
+    virtual void Create( SdrObject* pNewOpj, SvxDrawPage* pNewPage ) override;
+};
+
+
+class SvxTableShape : public SvxShape
+{
+protected:
+    // override these for special property handling in subcasses. Return true if property is handled
+    virtual bool setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue ) override;
+    virtual bool getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue ) override;
+
+    virtual void lock() override;
+    virtual void unlock() override;
+
+public:
+
+    explicit SvxTableShape(SdrObject* pObj);
+    virtual ~SvxTableShape() throw() override;
+};
+
+SvxUnoPropertyMapProvider& getSvxMapProvider();
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/shapepropertynotifier.cxx b/svx/source/unodraw/shapepropertynotifier.cxx
new file mode 100644
index 000000000..3cb762eaf
--- /dev/null
+++ b/svx/source/unodraw/shapepropertynotifier.cxx
@@ -0,0 +1,170 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <svx/shapepropertynotifier.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+#include <cppuhelper/interfacecontainer.hxx>
+#include <cppuhelper/weak.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <unordered_map>
+
+namespace
+{
+
+    struct ShapePropertyHash
+    {
+        size_t operator()( svx::ShapeProperty x ) const
+        {
+            return size_t( x );
+        }
+    };
+}
+
+
+namespace svx
+{
+
+
+    using ::com::sun::star::uno::Reference;
+    using ::com::sun::star::uno::UNO_QUERY_THROW;
+    using ::com::sun::star::uno::Exception;
+    using ::com::sun::star::uno::Any;
+    using ::com::sun::star::beans::PropertyChangeEvent;
+    using ::com::sun::star::beans::XPropertyChangeListener;
+    using ::com::sun::star::lang::EventObject;
+    using ::com::sun::star::beans::XPropertySet;
+
+    typedef std::unordered_map< ShapeProperty, std::shared_ptr<IPropertyValueProvider>, ShapePropertyHash  >    PropertyProviders;
+
+    typedef cppu::OMultiTypeInterfaceContainerHelperVar<OUString>
+        PropertyChangeListenerContainer;
+
+    IPropertyValueProvider::~IPropertyValueProvider()
+    {
+    }
+
+    struct PropertyChangeNotifier_Data
+    {
+        ::cppu::OWeakObject&            m_rContext;
+        PropertyProviders               m_aProviders;
+        PropertyChangeListenerContainer m_aPropertyChangeListeners;
+
+        PropertyChangeNotifier_Data( ::cppu::OWeakObject& _rContext, ::osl::Mutex& _rMutex )
+            :m_rContext( _rContext )
+            ,m_aPropertyChangeListeners( _rMutex )
+        {
+        }
+    };
+
+    //= PropertyValueProvider
+
+
+    OUString PropertyValueProvider::getPropertyName() const
+    {
+        return m_sPropertyName;
+    }
+
+
+    void PropertyValueProvider::getCurrentValue( Any& _out_rValue ) const
+    {
+        Reference< XPropertySet > xContextProps( const_cast< PropertyValueProvider* >( this )->m_rContext, UNO_QUERY_THROW );
+        _out_rValue = xContextProps->getPropertyValue( getPropertyName() );
+    }
+
+    PropertyChangeNotifier::PropertyChangeNotifier( ::cppu::OWeakObject& _rOwner, ::osl::Mutex& _rMutex )
+        :m_xData( new PropertyChangeNotifier_Data( _rOwner, _rMutex ) )
+    {
+    }
+
+    PropertyChangeNotifier::~PropertyChangeNotifier()
+    {
+    }
+
+    void PropertyChangeNotifier::registerProvider(const ShapeProperty _eProperty, const std::shared_ptr<IPropertyValueProvider>& _rProvider)
+    {
+        ENSURE_OR_THROW( !!_rProvider, "NULL factory not allowed." );
+
+        OSL_ENSURE( m_xData->m_aProviders.find( _eProperty ) == m_xData->m_aProviders.end(),
+            "PropertyChangeNotifier::registerProvider: factory for this ID already present!" );
+
+        m_xData->m_aProviders[ _eProperty ] = _rProvider;
+    }
+
+    void PropertyChangeNotifier::notifyPropertyChange( const ShapeProperty _eProperty ) const
+    {
+        PropertyProviders::const_iterator provPos = m_xData->m_aProviders.find( _eProperty );
+        OSL_ENSURE( provPos != m_xData->m_aProviders.end(), "PropertyChangeNotifier::notifyPropertyChange: no factory!" );
+        if ( provPos == m_xData->m_aProviders.end() )
+            return;
+
+        OUString sPropertyName( provPos->second->getPropertyName() );
+
+        ::cppu::OInterfaceContainerHelper* pPropListeners = m_xData->m_aPropertyChangeListeners.getContainer( sPropertyName );
+        ::cppu::OInterfaceContainerHelper* pAllListeners = m_xData->m_aPropertyChangeListeners.getContainer( OUString() );
+        if ( !pPropListeners && !pAllListeners )
+            return;
+
+        try
+        {
+            PropertyChangeEvent aEvent;
+            aEvent.Source = m_xData->m_rContext;
+            // Handle/OldValue not supported
+            aEvent.PropertyName = provPos->second->getPropertyName();
+            provPos->second->getCurrentValue( aEvent.NewValue );
+
+            if ( pPropListeners )
+                pPropListeners->notifyEach( &XPropertyChangeListener::propertyChange, aEvent );
+            if ( pAllListeners )
+                pAllListeners->notifyEach( &XPropertyChangeListener::propertyChange, aEvent );
+        }
+        catch( const Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("svx");
+        }
+    }
+
+
+    void PropertyChangeNotifier::addPropertyChangeListener( const OUString& _rPropertyName, const Reference< XPropertyChangeListener >& _rxListener )
+    {
+        m_xData->m_aPropertyChangeListeners.addInterface( _rPropertyName, _rxListener );
+    }
+
+
+    void PropertyChangeNotifier::removePropertyChangeListener( const OUString& _rPropertyName, const Reference< XPropertyChangeListener >& _rxListener )
+    {
+        m_xData->m_aPropertyChangeListeners.removeInterface( _rPropertyName, _rxListener );
+    }
+
+
+    void PropertyChangeNotifier::disposing()
+    {
+        EventObject aEvent;
+        aEvent.Source = m_xData->m_rContext;
+        m_xData->m_aPropertyChangeListeners.disposeAndClear( aEvent );
+    }
+
+
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/tableshape.cxx b/svx/source/unodraw/tableshape.cxx
new file mode 100644
index 000000000..ce25d445f
--- /dev/null
+++ b/svx/source/unodraw/tableshape.cxx
@@ -0,0 +1,177 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include "UnoGraphicExporter.hxx"
+#include "shapeimpl.hxx"
+#include <svx/unoshprp.hxx>
+#include <svx/svdotable.hxx>
+#include <svx/svdpool.hxx>
+
+
+using namespace ::osl;
+using namespace ::cppu;
+using namespace sdr::table;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::beans;
+
+SvxTableShape::SvxTableShape(SdrObject* pObj)
+:   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_TABLE), getSvxMapProvider().GetPropertySet(SVXMAP_TABLE, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+    SetShapeType( "com.sun.star.drawing.TableShape" );
+}
+
+SvxTableShape::~SvxTableShape() throw()
+{
+}
+
+bool SvxTableShape::setPropertyValueImpl(
+    const OUString& rName,
+    const SfxItemPropertySimpleEntry* pProperty,
+    const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_TABLETEMPLATE:
+    {
+        Reference< XIndexAccess > xTemplate;
+
+        if( !(rValue >>= xTemplate) )
+            throw IllegalArgumentException();
+
+        if( HasSdrObject() )
+            static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->setTableStyle(xTemplate);
+
+        return true;
+    }
+    case OWN_ATTR_TABLETEMPLATE_FIRSTROW:
+    case OWN_ATTR_TABLETEMPLATE_LASTROW:
+    case OWN_ATTR_TABLETEMPLATE_FIRSTCOLUMN:
+    case OWN_ATTR_TABLETEMPLATE_LASTCOLUMN:
+    case OWN_ATTR_TABLETEMPLATE_BANDINGROWS:
+    case OWN_ATTR_TABLETEMPLATE_BANDINGCOULUMNS:
+    {
+        if( HasSdrObject() )
+        {
+            TableStyleSettings aSettings( static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->getTableStyleSettings() );
+
+            switch( pProperty->nWID )
+            {
+            case OWN_ATTR_TABLETEMPLATE_FIRSTROW:           rValue >>= aSettings.mbUseFirstRow; break;
+            case OWN_ATTR_TABLETEMPLATE_LASTROW:            rValue >>= aSettings.mbUseLastRow; break;
+            case OWN_ATTR_TABLETEMPLATE_FIRSTCOLUMN:        rValue >>= aSettings.mbUseFirstColumn; break;
+            case OWN_ATTR_TABLETEMPLATE_LASTCOLUMN:         rValue >>= aSettings.mbUseLastColumn; break;
+            case OWN_ATTR_TABLETEMPLATE_BANDINGROWS:        rValue >>= aSettings.mbUseRowBanding; break;
+            case OWN_ATTR_TABLETEMPLATE_BANDINGCOULUMNS:    rValue >>= aSettings.mbUseColumnBanding; break;
+            }
+
+            static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->setTableStyleSettings(aSettings);
+        }
+
+        return true;
+    }
+    default:
+    {
+        return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+    }
+}
+
+bool SvxTableShape::getPropertyValueImpl(
+    const OUString& rName,
+    const SfxItemPropertySimpleEntry* pProperty,
+    css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_OLEMODEL:
+    {
+        if( HasSdrObject() )
+        {
+            rValue <<= static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->getTable();
+        }
+        return true;
+    }
+    case OWN_ATTR_TABLETEMPLATE:
+    {
+        if( HasSdrObject() )
+        {
+            rValue <<= static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->getTableStyle();
+        }
+        return true;
+    }
+    case OWN_ATTR_REPLACEMENT_GRAPHIC:
+    {
+        if( HasSdrObject() )
+        {
+            Graphic aGraphic( SvxGetGraphicForShape( *GetSdrObject() ) );
+            rValue <<= aGraphic.GetXGraphic();
+        }
+        return true;
+    }
+    case OWN_ATTR_TABLETEMPLATE_FIRSTROW:
+    case OWN_ATTR_TABLETEMPLATE_LASTROW:
+    case OWN_ATTR_TABLETEMPLATE_FIRSTCOLUMN:
+    case OWN_ATTR_TABLETEMPLATE_LASTCOLUMN:
+    case OWN_ATTR_TABLETEMPLATE_BANDINGROWS:
+    case OWN_ATTR_TABLETEMPLATE_BANDINGCOULUMNS:
+    {
+        if( HasSdrObject() )
+        {
+            TableStyleSettings aSettings( static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->getTableStyleSettings() );
+
+            switch( pProperty->nWID )
+            {
+            case OWN_ATTR_TABLETEMPLATE_FIRSTROW:           rValue <<= aSettings.mbUseFirstRow; break;
+            case OWN_ATTR_TABLETEMPLATE_LASTROW:            rValue <<= aSettings.mbUseLastRow; break;
+            case OWN_ATTR_TABLETEMPLATE_FIRSTCOLUMN:        rValue <<= aSettings.mbUseFirstColumn; break;
+            case OWN_ATTR_TABLETEMPLATE_LASTCOLUMN:         rValue <<= aSettings.mbUseLastColumn; break;
+            case OWN_ATTR_TABLETEMPLATE_BANDINGROWS:        rValue <<= aSettings.mbUseRowBanding; break;
+            case OWN_ATTR_TABLETEMPLATE_BANDINGCOULUMNS:    rValue <<= aSettings.mbUseColumnBanding; break;
+            }
+        }
+
+        return true;
+    }
+    default:
+    {
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+    }
+}
+
+void SvxTableShape::lock()
+{
+    SvxShape::lock();
+    if( HasSdrObject() )
+        static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->uno_lock();
+}
+
+void SvxTableShape::unlock()
+{
+    if( HasSdrObject() )
+        static_cast< sdr::table::SdrTableObj* >( GetSdrObject() )->uno_unlock();
+    SvxShape::unlock();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unobrushitemhelper.cxx b/svx/source/unodraw/unobrushitemhelper.cxx
new file mode 100644
index 000000000..e6c5758db
--- /dev/null
+++ b/svx/source/unodraw/unobrushitemhelper.cxx
@@ -0,0 +1,340 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <algorithm>
+
+#include <osl/diagnose.h>
+#include <svl/itemset.hxx>
+#include <svx/unobrushitemhelper.hxx>
+#include <svx/xfillit0.hxx>
+#include <svx/xbtmpit.hxx>
+#include <svx/xflbmtit.hxx>
+#include <svx/xflbmpit.hxx>
+#include <svx/xflftrit.hxx>
+#include <svx/xflbstit.hxx>
+#include <svx/xflbckit.hxx>
+#include <svx/xflhtit.hxx>
+#include <svx/xflclit.hxx>
+#include <svx/xfltrit.hxx>
+
+using namespace com::sun::star;
+
+void setSvxBrushItemAsFillAttributesToTargetSet(const SvxBrushItem& rBrush, SfxItemSet& rToSet)
+{
+    // Clear all items from the DrawingLayer FillStyle range (if we have any). All
+    // items that need to be set will be set as hard attributes
+    for(sal_uInt16 a(XATTR_FILL_FIRST); rToSet.Count() && a < XATTR_FILL_LAST; a++)
+    {
+        rToSet.ClearItem(a);
+    }
+
+    const sal_uInt8 nTransparency(rBrush.GetColor().GetTransparency());
+
+    // tdf#89478 check for image first
+    if (GPOS_NONE != rBrush.GetGraphicPos())
+    {
+        // we have a graphic fill, set fill style
+        rToSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP));
+
+        // set graphic (if available)
+        const Graphic* pGraphic = rBrush.GetGraphic();
+
+        if(pGraphic)
+        {
+            rToSet.Put(XFillBitmapItem(OUString(), *pGraphic));
+        }
+        else
+        {
+            OSL_ENSURE(false, "Could not get Graphic from SvxBrushItem (!)");
+        }
+
+        if(GPOS_AREA == rBrush.GetGraphicPos())
+        {
+            // stretch, also means no tile (both items are defaulted to true)
+            rToSet.Put(XFillBmpStretchItem(true));
+            rToSet.Put(XFillBmpTileItem(false));
+
+            // default for stretch is also top-left, but this will not be visible
+            rToSet.Put(XFillBmpPosItem(RectPoint::LT));
+        }
+        else if(GPOS_TILED == rBrush.GetGraphicPos())
+        {
+            // tiled, also means no stretch (both items are defaulted to true)
+            rToSet.Put(XFillBmpStretchItem(false));
+            rToSet.Put(XFillBmpTileItem(true));
+
+            // default for tiled is top-left
+            rToSet.Put(XFillBmpPosItem(RectPoint::LT));
+        }
+        else
+        {
+            // everything else means no tile and no stretch
+            rToSet.Put(XFillBmpStretchItem(false));
+            rToSet.Put(XFillBmpTileItem(false));
+
+            RectPoint aRectPoint(RectPoint::MM);
+
+            switch(rBrush.GetGraphicPos())
+            {
+                case GPOS_LT: aRectPoint = RectPoint::LT; break;
+                case GPOS_MT: aRectPoint = RectPoint::MT; break;
+                case GPOS_RT: aRectPoint = RectPoint::RT; break;
+                case GPOS_LM: aRectPoint = RectPoint::LM; break;
+                case GPOS_MM: aRectPoint = RectPoint::MM; break;
+                case GPOS_RM: aRectPoint = RectPoint::RM; break;
+                case GPOS_LB: aRectPoint = RectPoint::LB; break;
+                case GPOS_MB: aRectPoint = RectPoint::MB; break;
+                case GPOS_RB: aRectPoint = RectPoint::RB; break;
+                default: break; // GPOS_NONE, GPOS_AREA and GPOS_TILED already handled
+            }
+
+            rToSet.Put(XFillBmpPosItem(aRectPoint));
+        }
+
+        // check for graphic's transparency
+        const sal_Int8 nGraphicTransparency(rBrush.getGraphicTransparency());
+
+        if(0 != nGraphicTransparency)
+        {
+            // nGraphicTransparency is in range [0..100]
+            rToSet.Put(XFillTransparenceItem(nGraphicTransparency));
+        }
+    }
+    else if (0xff != nTransparency)
+    {
+        // we have a color fill
+        const Color aColor(rBrush.GetColor().GetRGBColor());
+
+        rToSet.Put(XFillStyleItem(drawing::FillStyle_SOLID));
+        rToSet.Put(XFillColorItem(OUString(), aColor));
+
+        // #125189# nTransparency is in range [0..254], convert to [0..100] which is used in
+        // XFillTransparenceItem (caution with the range which is in an *item-specific* range)
+        rToSet.Put(XFillTransparenceItem(((static_cast<sal_Int32>(nTransparency) * 100) + 127) / 254));
+    }
+    else
+    {
+        // GPOS_NONE == rBrush.GetGraphicPos() && 0xff == rBrush.GetColor().GetTransparency(),
+        // still need to rescue the color used. There are sequences used on the UNO API at
+        // import time (OLE. e.g. chart) which first set RGB color (MID_BACK_COLOR_R_G_B,
+        // color stays transparent) and then set transparency (MID_BACK_COLOR_TRANSPARENCY)
+        // to zero later. When not saving the color, it will be lost.
+        // Also need to set the FillStyle to NONE to express the 0xff transparency flag; this
+        // is needed when e.g. first transparency is set to 0xff and then a Graphic gets set.
+        // When not changing the FillStyle, the next getSvxBrushItemFromSourceSet *will* return
+        // to drawing::FillStyle_SOLID with the rescued color.
+        const Color aColor(rBrush.GetColor().GetRGBColor());
+
+        rToSet.Put(XFillStyleItem(drawing::FillStyle_NONE));
+        rToSet.Put(XFillColorItem(OUString(), aColor));
+    }
+}
+
+static sal_uInt16 getTransparenceForSvxBrushItem(const SfxItemSet& rSourceSet, bool bSearchInParents)
+{
+    sal_uInt16 nFillTransparence(rSourceSet.Get(XATTR_FILLTRANSPARENCE, bSearchInParents).GetValue());
+    const SfxPoolItem* pGradientItem = nullptr;
+
+    if(SfxItemState::SET == rSourceSet.GetItemState(XATTR_FILLFLOATTRANSPARENCE, bSearchInParents, &pGradientItem)
+        && static_cast< const XFillFloatTransparenceItem* >(pGradientItem)->IsEnabled())
+    {
+        const XGradient& rGradient = static_cast< const XFillFloatTransparenceItem* >(pGradientItem)->GetGradientValue();
+        const sal_uInt16 nStartLuminance(rGradient.GetStartColor().GetLuminance());
+        const sal_uInt16 nEndLuminance(rGradient.GetEndColor().GetLuminance());
+
+        // luminance is [0..255], transparence needs to be in [0..100].Maximum is 51200, thus sal_uInt16 is okay to use
+        nFillTransparence = static_cast< sal_uInt16 >(((nStartLuminance + nEndLuminance) * 100) / 512);
+    }
+
+    return nFillTransparence;
+}
+
+static std::unique_ptr<SvxBrushItem> getSvxBrushItemForSolid(const SfxItemSet& rSourceSet, bool bSearchInParents, sal_uInt16 nBackgroundID)
+{
+    Color aFillColor(rSourceSet.Get(XATTR_FILLCOLOR, bSearchInParents).GetColorValue());
+
+    // get evtl. mixed transparence
+    const sal_uInt16 nFillTransparence(getTransparenceForSvxBrushItem(rSourceSet, bSearchInParents));
+
+    if(0 != nFillTransparence)
+    {
+        // #i125189# nFillTransparence is in range [0..100] and needs to be in [0..254] unsigned
+        // It is necessary to use the maximum of 0xfe for transparence for the SvxBrushItem
+        // since the oxff value is used for special purposes (like no fill and derive from parent)
+        const sal_uInt8 aTargetTrans(std::min(sal_uInt8(0xfe), static_cast< sal_uInt8 >((nFillTransparence * 254) / 100)));
+
+        aFillColor.SetTransparency(aTargetTrans);
+    }
+
+    return std::make_unique<SvxBrushItem>(aFillColor, nBackgroundID);
+}
+
+std::unique_ptr<SvxBrushItem> getSvxBrushItemFromSourceSet(const SfxItemSet& rSourceSet, sal_uInt16 nBackgroundID, bool bSearchInParents, bool bXMLImportHack)
+{
+    const XFillStyleItem* pXFillStyleItem(rSourceSet.GetItem<XFillStyleItem>(XATTR_FILLSTYLE, bSearchInParents));
+
+    if(!pXFillStyleItem || drawing::FillStyle_NONE == pXFillStyleItem->GetValue())
+    {
+        // no fill, still need to rescue the evtl. set RGB color, but use as transparent color (we have drawing::FillStyle_NONE)
+        Color aFillColor(rSourceSet.Get(XATTR_FILLCOLOR, bSearchInParents).GetColorValue());
+
+        // for writerfilter: when fill style is none, then don't allow anything other than 0 or auto.
+        if (!bXMLImportHack && aFillColor != Color(0))
+            aFillColor = COL_AUTO;
+
+        aFillColor.SetTransparency(0xff);
+
+        return std::make_unique<SvxBrushItem>(aFillColor, nBackgroundID);
+    }
+
+    auto aRetval = std::make_unique<SvxBrushItem>(nBackgroundID);
+
+    switch(pXFillStyleItem->GetValue())
+    {
+        default:
+        case drawing::FillStyle_NONE:
+        {
+            // already handled above, can not happen again
+            break;
+        }
+        case drawing::FillStyle_SOLID:
+        {
+            // create SvxBrushItem with fill color
+            aRetval = getSvxBrushItemForSolid(rSourceSet, bSearchInParents, nBackgroundID);
+            break;
+        }
+        case drawing::FillStyle_GRADIENT:
+        {
+            // cannot be directly supported, but do the best possible
+            const XGradient aXGradient(rSourceSet.Get(XATTR_FILLGRADIENT).GetGradientValue());
+            const basegfx::BColor aStartColor(aXGradient.GetStartColor().getBColor() * (aXGradient.GetStartIntens() * 0.01));
+            const basegfx::BColor aEndColor(aXGradient.GetEndColor().getBColor() * (aXGradient.GetEndIntens() * 0.01));
+
+            // use half/half mixed color from gradient start and end
+            Color aMixedColor((aStartColor + aEndColor) * 0.5);
+
+            // get evtl. mixed transparence
+            const sal_uInt16 nFillTransparence(getTransparenceForSvxBrushItem(rSourceSet, bSearchInParents));
+
+            if(0 != nFillTransparence)
+            {
+                // #i125189# nFillTransparence is in range [0..100] and needs to be in [0..254] unsigned
+                // It is necessary to use the maximum of 0xfe for transparence for the SvxBrushItem
+                // since the oxff value is used for special purposes (like no fill and derive from parent)
+                const sal_uInt8 aTargetTrans(std::min(sal_uInt8(0xfe), static_cast< sal_uInt8 >((nFillTransparence * 254) / 100)));
+
+                aMixedColor.SetTransparency(aTargetTrans);
+            }
+
+            aRetval = std::make_unique<SvxBrushItem>(aMixedColor, nBackgroundID);
+            break;
+        }
+        case drawing::FillStyle_HATCH:
+        {
+            // cannot be directly supported, but do the best possible
+            const XHatch& rHatch(rSourceSet.Get(XATTR_FILLHATCH).GetHatchValue());
+            const bool bFillBackground(rSourceSet.Get(XATTR_FILLBACKGROUND).GetValue());
+
+            if(bFillBackground)
+            {
+                // hatch is background-filled, use FillColor as if drawing::FillStyle_SOLID
+                aRetval = getSvxBrushItemForSolid(rSourceSet, bSearchInParents, nBackgroundID);
+            }
+            else
+            {
+                // hatch is not background-filled and using hatch color would be too dark; compensate
+                // somewhat by making it more transparent
+                Color aHatchColor(rHatch.GetColor());
+
+                // get evtl. mixed transparence
+                sal_uInt16 nFillTransparence(getTransparenceForSvxBrushItem(rSourceSet, bSearchInParents));
+
+                // take half orig transparence, add half transparent, clamp result
+                nFillTransparence = std::clamp(static_cast<sal_uInt16>((nFillTransparence / 2) + 50), sal_uInt16(0), sal_uInt16(255));
+
+                // #i125189# nFillTransparence is in range [0..100] and needs to be in [0..254] unsigned
+                // It is necessary to use the maximum of 0xfe for transparence for the SvxBrushItem
+                // since the oxff value is used for special purposes (like no fill and derive from parent)
+                const sal_uInt8 aTargetTrans(std::min(sal_uInt8(0xfe), static_cast< sal_uInt8 >((nFillTransparence * 254) / 100)));
+
+                aHatchColor.SetTransparency(aTargetTrans);
+                aRetval = std::make_unique<SvxBrushItem>(aHatchColor, nBackgroundID);
+            }
+
+            break;
+        }
+        case drawing::FillStyle_BITMAP:
+        {
+            // create SvxBrushItem with bitmap info and flags
+            const XFillBitmapItem& rBmpItm = rSourceSet.Get(XATTR_FILLBITMAP, bSearchInParents);
+            const Graphic aGraphic(rBmpItm.GetGraphicObject().GetGraphic());
+
+            // continue idependent of evtl. GraphicType::NONE as aGraphic.GetType(), we still need to rescue positions
+            SvxGraphicPosition aSvxGraphicPosition(GPOS_NONE);
+            const XFillBmpStretchItem& rStretchItem = rSourceSet.Get(XATTR_FILLBMP_STRETCH, bSearchInParents);
+            const XFillBmpTileItem& rTileItem = rSourceSet.Get(XATTR_FILLBMP_TILE, bSearchInParents);
+
+            if(rTileItem.GetValue())
+            {
+                aSvxGraphicPosition = GPOS_TILED;
+            }
+            else if(rStretchItem.GetValue())
+            {
+                aSvxGraphicPosition = GPOS_AREA;
+            }
+            else
+            {
+                const XFillBmpPosItem& rPosItem = rSourceSet.Get(XATTR_FILLBMP_POS, bSearchInParents);
+
+                switch(rPosItem.GetValue())
+                {
+                    case RectPoint::LT: aSvxGraphicPosition = GPOS_LT; break;
+                    case RectPoint::MT: aSvxGraphicPosition = GPOS_MT; break;
+                    case RectPoint::RT: aSvxGraphicPosition = GPOS_RT; break;
+                    case RectPoint::LM: aSvxGraphicPosition = GPOS_LM; break;
+                    case RectPoint::MM: aSvxGraphicPosition = GPOS_MM; break;
+                    case RectPoint::RM: aSvxGraphicPosition = GPOS_RM; break;
+                    case RectPoint::LB: aSvxGraphicPosition = GPOS_LB; break;
+                    case RectPoint::MB: aSvxGraphicPosition = GPOS_MB; break;
+                    case RectPoint::RB: aSvxGraphicPosition = GPOS_RB; break;
+                }
+            }
+
+            // create with given graphic and position
+            aRetval = std::make_unique<SvxBrushItem>(aGraphic, aSvxGraphicPosition, nBackgroundID);
+
+            // get evtl. mixed transparence
+            const sal_uInt16 nFillTransparence(getTransparenceForSvxBrushItem(rSourceSet, bSearchInParents));
+
+            if(0 != nFillTransparence)
+            {
+                // #i125189# nFillTransparence is in range [0..100] and needs to be in [0..100] signed
+                aRetval->setGraphicTransparency(static_cast< sal_Int8 >(nFillTransparence));
+            }
+
+            break;
+        }
+    }
+
+    return aRetval;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unobtabl.cxx b/svx/source/unodraw/unobtabl.cxx
new file mode 100644
index 000000000..0b3dae21f
--- /dev/null
+++ b/svx/source/unodraw/unobtabl.cxx
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svx/xit.hxx>
+#include "UnoNameItemTable.hxx"
+
+#include <svx/xbtmpit.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/unomid.hxx>
+#include <svx/unofill.hxx>
+#include <com/sun/star/awt/XBitmap.hpp>
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+namespace {
+
+class SvxUnoBitmapTable : public SvxUnoNameItemTable
+{
+public:
+    explicit SvxUnoBitmapTable( SdrModel* pModel ) throw();
+
+    virtual NameOrIndex* createItem() const override;
+    virtual bool isValid( const NameOrIndex* pItem ) const override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType(  ) override;
+};
+
+}
+
+SvxUnoBitmapTable::SvxUnoBitmapTable( SdrModel* pModel ) throw()
+: SvxUnoNameItemTable( pModel, XATTR_FILLBITMAP, MID_BITMAP )
+{
+}
+
+bool SvxUnoBitmapTable::isValid( const NameOrIndex* pItem ) const
+{
+    if( SvxUnoNameItemTable::isValid( pItem ) )
+    {
+        const XFillBitmapItem* pBitmapItem = dynamic_cast< const XFillBitmapItem* >( pItem );
+        if( pBitmapItem )
+        {
+            const Graphic& rGraphic = pBitmapItem->GetGraphicObject().GetGraphic();
+
+            return rGraphic.GetSizeBytes() > 0;
+        }
+    }
+
+    return false;
+}
+
+OUString SAL_CALL SvxUnoBitmapTable::getImplementationName()
+{
+    return "SvxUnoBitmapTable";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoBitmapTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.BitmapTable" };
+}
+
+NameOrIndex* SvxUnoBitmapTable::createItem() const
+{
+    return new XFillBitmapItem();
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoBitmapTable::getElementType(  )
+{
+    return ::cppu::UnoType<awt::XBitmap>::get();
+}
+
+/**
+ * Create a bitmaptable
+ */
+uno::Reference< uno::XInterface > SvxUnoBitmapTable_createInstance( SdrModel* pModel )
+{
+    return *new SvxUnoBitmapTable(pModel);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoctabl.cxx b/svx/source/unodraw/unoctabl.cxx
new file mode 100644
index 000000000..ec338a7d0
--- /dev/null
+++ b/svx/source/unodraw/unoctabl.cxx
@@ -0,0 +1,181 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <unotools/pathoptions.hxx>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <rtl/ref.hxx>
+#include <svx/xtable.hxx>
+
+using namespace ::com::sun::star;
+
+namespace {
+
+class SvxUnoColorTable : public cppu::WeakImplHelper< container::XNameContainer, lang::XServiceInfo >
+{
+private:
+    XColorListRef pList;
+
+public:
+    SvxUnoColorTable();
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService( const  OUString& ServiceName ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames() override;
+
+    // XNameContainer
+    virtual void SAL_CALL insertByName( const  OUString& aName, const  uno::Any& aElement ) override;
+    virtual void SAL_CALL removeByName( const  OUString& Name ) override;
+
+    // XNameReplace
+    virtual void SAL_CALL replaceByName( const  OUString& aName, const  uno::Any& aElement ) override;
+
+    // XNameAccess
+    virtual uno::Any SAL_CALL getByName( const  OUString& aName ) override;
+
+    virtual uno::Sequence<  OUString > SAL_CALL getElementNames() override;
+
+    virtual sal_Bool SAL_CALL hasByName( const  OUString& aName ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType() override;
+    virtual sal_Bool SAL_CALL hasElements() override;
+};
+
+SvxUnoColorTable::SvxUnoColorTable()
+  : pList(XPropertyList::AsColorList(
+            XPropertyList::CreatePropertyList(
+              XPropertyListType::Color, SvtPathOptions().GetPalettePath(), "")))
+{
+}
+
+sal_Bool SAL_CALL SvxUnoColorTable::supportsService( const  OUString& ServiceName )
+{
+    return cppu::supportsService( this, ServiceName );
+}
+
+OUString SAL_CALL SvxUnoColorTable::getImplementationName()
+{
+    return "com.sun.star.drawing.SvxUnoColorTable";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoColorTable::getSupportedServiceNames()
+{
+    uno::Sequence<OUString> aSNS { "com.sun.star.drawing.ColorTable" };
+    return aSNS;
+}
+
+// XNameContainer
+void SAL_CALL SvxUnoColorTable::insertByName( const OUString& aName, const uno::Any& aElement )
+{
+    if( hasByName( aName ) )
+        throw container::ElementExistException();
+
+    Color aColor;
+    if( !(aElement >>= aColor) )
+        throw lang::IllegalArgumentException();
+
+    if( pList.is() )
+    {
+        pList->Insert(std::make_unique<XColorEntry>(aColor, aName));
+    }
+}
+
+void SAL_CALL SvxUnoColorTable::removeByName( const OUString& Name )
+{
+    long nIndex = pList.is() ? pList->GetIndex( Name ) : -1;
+    if( nIndex == -1 )
+        throw container::NoSuchElementException();
+
+    pList->Remove( nIndex );
+}
+
+// XNameReplace
+void SAL_CALL SvxUnoColorTable::replaceByName( const OUString& aName, const uno::Any& aElement )
+{
+    Color nColor;
+    if( !(aElement >>= nColor) )
+        throw lang::IllegalArgumentException();
+
+    long nIndex = pList.is() ? pList->GetIndex( aName ) : -1;
+    if( nIndex == -1  )
+        throw container::NoSuchElementException();
+
+    pList->Replace(nIndex, std::make_unique<XColorEntry>(nColor, aName ));
+}
+
+// XNameAccess
+uno::Any SAL_CALL SvxUnoColorTable::getByName( const OUString& aName )
+{
+    long nIndex = pList.is() ? pList->GetIndex( aName ) : -1;
+    if( nIndex == -1 )
+        throw container::NoSuchElementException();
+
+    const XColorEntry* pEntry = pList->GetColor(nIndex);
+    return uno::Any( static_cast<sal_Int32>(pEntry->GetColor().GetRGBColor()) );
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoColorTable::getElementNames()
+{
+    const long nCount = pList.is() ? pList->Count() : 0;
+
+    uno::Sequence< OUString > aSeq( nCount );
+    OUString* pStrings = aSeq.getArray();
+
+    for( long nIndex = 0; nIndex < nCount; nIndex++ )
+    {
+        const XColorEntry* pEntry = pList->GetColor(nIndex);
+        pStrings[nIndex] = pEntry->GetName();
+    }
+
+    return aSeq;
+}
+
+sal_Bool SAL_CALL SvxUnoColorTable::hasByName( const OUString& aName )
+{
+    long nIndex = pList.is() ? pList->GetIndex( aName ) : -1;
+    return nIndex != -1;
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoColorTable::getElementType()
+{
+    return ::cppu::UnoType<sal_Int32>::get();
+}
+
+sal_Bool SAL_CALL SvxUnoColorTable::hasElements()
+{
+    return pList.is() && pList->Count() != 0;
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_drawing_SvxUnoColorTable_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new SvxUnoColorTable);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unodtabl.cxx b/svx/source/unodraw/unodtabl.cxx
new file mode 100644
index 000000000..ae2465900
--- /dev/null
+++ b/svx/source/unodraw/unodtabl.cxx
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/drawing/LineDash.hpp>
+
+#include "UnoNameItemTable.hxx"
+#include <svx/xlndsit.hxx>
+#include <svx/unomid.hxx>
+
+#include <svx/svdmodel.hxx>
+#include <svx/unofill.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+namespace {
+
+class SvxUnoDashTable : public SvxUnoNameItemTable
+{
+public:
+    explicit SvxUnoDashTable( SdrModel* pModel ) throw();
+
+    virtual NameOrIndex* createItem() const override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType(  ) override;
+};
+
+}
+
+SvxUnoDashTable::SvxUnoDashTable( SdrModel* pModel ) throw()
+: SvxUnoNameItemTable( pModel, XATTR_LINEDASH, MID_LINEDASH )
+{
+}
+
+OUString SAL_CALL SvxUnoDashTable::getImplementationName()
+{
+    return "SvxUnoDashTable";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoDashTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.DashTable" };
+}
+
+NameOrIndex* SvxUnoDashTable::createItem() const
+{
+    XLineDashItem* pNewItem = new XLineDashItem();
+    pNewItem->SetWhich( XATTR_LINEDASH ); // set which id for pooling
+    return pNewItem;
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoDashTable::getElementType(  )
+{
+    return cppu::UnoType<drawing::LineDash>::get();
+}
+
+/**
+ * Create a gradienttable
+ */
+uno::Reference< uno::XInterface > SvxUnoDashTable_createInstance( SdrModel* pModel )
+{
+    return *new SvxUnoDashTable(pModel);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unogtabl.cxx b/svx/source/unodraw/unogtabl.cxx
new file mode 100644
index 000000000..fa46aee4e
--- /dev/null
+++ b/svx/source/unodraw/unogtabl.cxx
@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/awt/Gradient.hpp>
+#include "UnoNameItemTable.hxx"
+
+#include <svx/svdmodel.hxx>
+#include <svx/xdef.hxx>
+#include <svx/xflgrit.hxx>
+#include <svx/unofill.hxx>
+#include <svx/unomid.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+namespace {
+
+class SvxUnoGradientTable : public SvxUnoNameItemTable
+{
+public:
+    explicit SvxUnoGradientTable( SdrModel* pModel ) throw();
+
+    virtual NameOrIndex* createItem() const override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType(  ) override;
+};
+
+}
+
+SvxUnoGradientTable::SvxUnoGradientTable( SdrModel* pModel ) throw()
+    : SvxUnoNameItemTable( pModel, XATTR_FILLGRADIENT, MID_FILLGRADIENT )
+{
+}
+
+OUString SAL_CALL SvxUnoGradientTable::getImplementationName()
+{
+    return "SvxUnoGradientTable";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoGradientTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.GradientTable" };
+}
+
+
+// XNameContainer
+NameOrIndex* SvxUnoGradientTable::createItem() const
+{
+    return new XFillGradientItem();
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoGradientTable::getElementType(  )
+{
+    return cppu::UnoType<awt::Gradient>::get();
+}
+
+/**
+ * Create a gradienttable
+ */
+uno::Reference< uno::XInterface > SvxUnoGradientTable_createInstance( SdrModel* pModel )
+{
+    return *new SvxUnoGradientTable(pModel);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unohtabl.cxx b/svx/source/unodraw/unohtabl.cxx
new file mode 100644
index 000000000..47cf857d0
--- /dev/null
+++ b/svx/source/unodraw/unohtabl.cxx
@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/drawing/Hatch.hpp>
+#include "UnoNameItemTable.hxx"
+
+#include <svx/svdmodel.hxx>
+#include <svx/xdef.hxx>
+#include <svx/xflhtit.hxx>
+#include <svx/unomid.hxx>
+#include <svx/unofill.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+namespace {
+
+class SvxUnoHatchTable : public SvxUnoNameItemTable
+{
+public:
+    explicit SvxUnoHatchTable( SdrModel* pModel ) throw();
+
+    virtual NameOrIndex* createItem() const override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType(  ) override;
+};
+
+}
+
+SvxUnoHatchTable::SvxUnoHatchTable( SdrModel* pModel ) throw()
+: SvxUnoNameItemTable( pModel, XATTR_FILLHATCH, MID_FILLHATCH )
+{
+}
+
+OUString SAL_CALL SvxUnoHatchTable::getImplementationName()
+{
+    return "SvxUnoHatchTable";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoHatchTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.HatchTable" };
+}
+
+NameOrIndex* SvxUnoHatchTable::createItem() const
+{
+    return new XFillHatchItem();
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoHatchTable::getElementType(  )
+{
+    return cppu::UnoType<drawing::Hatch>::get();
+}
+
+/**
+ * Create a hatchtable
+ */
+uno::Reference< uno::XInterface > SvxUnoHatchTable_createInstance( SdrModel* pModel )
+{
+    return *new SvxUnoHatchTable(pModel);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unomlstr.cxx b/svx/source/unodraw/unomlstr.cxx
new file mode 100644
index 000000000..b040dc179
--- /dev/null
+++ b/svx/source/unodraw/unomlstr.cxx
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svx/svdobj.hxx>
+#include <vcl/svapp.hxx>
+
+#include <unomlstr.hxx>
+
+using namespace ::com::sun::star;
+
+SvxUnoShapeModifyListener::SvxUnoShapeModifyListener( SdrObject* pObj ) throw()
+{
+    mpObj = pObj;
+}
+
+SvxUnoShapeModifyListener::~SvxUnoShapeModifyListener() throw()
+{
+}
+
+// css::util::XModifyListener
+void SAL_CALL SvxUnoShapeModifyListener::modified(const lang::EventObject& )
+{
+    SolarMutexGuard aGuard;
+    if( mpObj )
+    {
+        mpObj->SetChanged();
+        mpObj->BroadcastObjectChange();
+    }
+}
+
+// css::lang::XEventListener
+void SvxUnoShapeModifyListener::disposing(const lang::EventObject& )
+{
+    invalidate();
+}
+
+// internal
+void SvxUnoShapeModifyListener::invalidate() throw()
+{
+    mpObj = nullptr;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unomod.cxx b/svx/source/unodraw/unomod.cxx
new file mode 100644
index 000000000..6cc9a35f9
--- /dev/null
+++ b/svx/source/unodraw/unomod.cxx
@@ -0,0 +1,681 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
+#include <com/sun/star/lang/NoSupportException.hpp>
+#include <com/sun/star/drawing/XShape.hpp>
+#include <vcl/svapp.hxx>
+#include <svl/itempool.hxx>
+#include <svtools/unoevent.hxx>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <tools/debug.hxx>
+
+#include <cppuhelper/implbase.hxx>
+#include <svx/unofill.hxx>
+#include <editeng/unonrule.hxx>
+#include <svtools/unoimap.hxx>
+#include <sfx2/event.hxx>
+#include <svx/fmdpage.hxx>
+#include <svx/fmmodel.hxx>
+#include <svx/fmpage.hxx>
+#include <svx/unoapi.hxx>
+
+#include <svx/svdmodel.hxx>
+#include <svx/unoprov.hxx>
+#include <svx/unopage.hxx>
+#include <editeng/unofield.hxx>
+#include <svx/unomod.hxx>
+#include <svx/unomodel.hxx>
+#include <svx/svdobj.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/unoshape.hxx>
+#include <svx/xmlgrhlp.hxx>
+
+#include <com/sun/star/text/textfield/Type.hpp>
+
+//-
+
+using namespace ::com::sun::star;
+
+//-
+
+#define QUERYINT( xint ) \
+    if( rType == cppu::UnoType<xint>::get() ) \
+        aAny <<= uno::Reference< xint >(this)
+
+//-
+
+class SvxUnoDrawPagesAccess : public ::cppu::WeakImplHelper< css::drawing::XDrawPages, css::lang::XServiceInfo >
+{
+private:
+    SvxUnoDrawingModel& mrModel;
+
+public:
+    explicit SvxUnoDrawPagesAccess( SvxUnoDrawingModel& rMyModel ) throw();
+
+    // XDrawPages
+    virtual css::uno::Reference< css::drawing::XDrawPage > SAL_CALL insertNewByIndex( sal_Int32 nIndex ) override;
+    virtual void SAL_CALL remove( const css::uno::Reference< css::drawing::XDrawPage >& xPage ) override;
+
+    // XIndexAccess
+    virtual sal_Int32 SAL_CALL getCount() override ;
+    virtual css::uno::Any SAL_CALL getByIndex( sal_Int32 Index ) override;
+
+    // XElementAccess
+    virtual css::uno::Type SAL_CALL getElementType() override;
+    virtual sal_Bool SAL_CALL hasElements() override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) override;
+};
+//-
+
+static const SvEventDescription* ImplGetSupportedMacroItems()
+{
+    static const SvEventDescription aMacroDescriptionsImpl[] =
+    {
+        { SvMacroItemId::OnMouseOver, "OnMouseOver" },
+        { SvMacroItemId::OnMouseOut,  "OnMouseOut" },
+        { SvMacroItemId::NONE, nullptr }
+    };
+
+    return aMacroDescriptionsImpl;
+}
+
+//-
+
+/** fills the given EventObject from the given SdrHint.
+    @returns
+        true    if the SdrHint could be translated to an EventObject<br>
+        false   if not
+*/
+bool SvxUnoDrawMSFactory::createEvent( const SdrModel* pDoc, const SdrHint* pSdrHint, css::document::EventObject& aEvent )
+{
+    const SdrObject* pObj = nullptr;
+    const SdrPage* pPage = nullptr;
+
+    switch( pSdrHint->GetKind() )
+    {
+//              case SdrHintKind::LayerChange:             // layer definition changed
+//              case SdrHintKind::LayerOrderChange:        // layer order changed (Insert/Remove/ChangePos)
+//              case HINT_LAYERSETCHG:          // layer set changed
+//              case HINT_LAYERSETORDERCHG:     // layer set order changed (Insert/Remove/ChangePos)
+
+//      case HINT_PAGECHG:              // page changed
+//          aEvent.EventName = "PageModified";
+//          pPage = pSdrHint->GetPage();
+//          break;
+        case SdrHintKind::PageOrderChange:         // draw or master page order changed (Insert/Remove/ChangePos)
+            aEvent.EventName = "PageOrderModified";
+            pPage = pSdrHint->GetPage();
+            break;
+        case SdrHintKind::ObjectChange:               // object changed
+            aEvent.EventName = "ShapeModified";
+            pObj = pSdrHint->GetObject();
+            break;
+        case SdrHintKind::ObjectInserted:          // add new draw object
+            aEvent.EventName = "ShapeInserted";
+            pObj = pSdrHint->GetObject();
+            break;
+        case SdrHintKind::ObjectRemoved:           // removed draw object from list
+            aEvent.EventName = "ShapeRemoved";
+            pObj = pSdrHint->GetObject();
+            break;
+//                SdrHintKind::DefaultTabChange,   // default tab width changed
+//                SdrHintKind::SwitchToPage,    // #94278# UNDO/REDO at an object evtl. on another page
+//                HINT_OBJLISTCLEAR     // Is called before an SdrObjList will be cleared
+        default:
+            return false;
+    }
+
+    if( pObj )
+        aEvent.Source = const_cast<SdrObject*>(pObj)->getUnoShape();
+    else if( pPage )
+        aEvent.Source = const_cast<SdrPage*>(pPage)->getUnoPage();
+    else
+        aEvent.Source = const_cast<SdrModel*>(pDoc)->getUnoModel();
+
+    return true;
+}
+
+namespace {
+
+css::uno::Reference<css::uno::XInterface> create(
+    OUString const & rServiceSpecifier, OUString const & referer)
+{
+    if( rServiceSpecifier.startsWith("com.sun.star.drawing.") )
+    {
+        sal_uInt32 nType = UHashMap::getId( rServiceSpecifier );
+        if( nType != UHASHMAP_NOTFOUND )
+        {
+            sal_uInt16 nT = static_cast<sal_uInt16>(nType & ~E3D_INVENTOR_FLAG);
+            SdrInventor nI = (nType & E3D_INVENTOR_FLAG) ? SdrInventor::E3d : SdrInventor::Default;
+
+            return uno::Reference< uno::XInterface >( static_cast<drawing::XShape*>(SvxDrawPage::CreateShapeByTypeAndInventor( nT, nI, nullptr, nullptr, referer )) );
+        }
+    }
+    else if (rServiceSpecifier == "com.sun.star.document.ImportGraphicStorageHandler")
+    {
+        rtl::Reference<SvXMLGraphicHelper> pGraphicHelper = SvXMLGraphicHelper::Create( SvXMLGraphicHelperMode::Read );
+        uno::Reference< uno::XInterface> xRet( static_cast< ::cppu::OWeakObject* >( pGraphicHelper.get() ) );
+        return xRet;
+    }
+
+    uno::Reference< uno::XInterface > xRet( SvxUnoDrawMSFactory::createTextField( rServiceSpecifier ) );
+    if( !xRet.is() )
+        throw lang::ServiceNotRegisteredException("unknown service: " + rServiceSpecifier);
+
+    return xRet;
+}
+
+}
+
+uno::Reference< uno::XInterface > SAL_CALL SvxUnoDrawMSFactory::createInstance( const OUString& rServiceSpecifier )
+{
+    return create(rServiceSpecifier, "");
+}
+
+uno::Reference< uno::XInterface > SvxUnoDrawMSFactory::createTextField( const OUString& ServiceSpecifier )
+{
+    return SvxUnoTextCreateTextField( ServiceSpecifier );
+}
+
+uno::Reference< uno::XInterface > SAL_CALL SvxUnoDrawMSFactory::createInstanceWithArguments( const OUString& ServiceSpecifier, const uno::Sequence< css::uno::Any >& Arguments )
+{
+    OUString arg;
+    if ((ServiceSpecifier == "com.sun.star.drawing.GraphicObjectShape"
+         || ServiceSpecifier == "com.sun.star.drawing.MediaShape")
+        && Arguments.getLength() == 1 && (Arguments[0] >>= arg))
+    {
+        return create(ServiceSpecifier, arg);
+    }
+    throw lang::NoSupportException();
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoDrawMSFactory::getAvailableServiceNames()
+{
+    return UHashMap::getServiceNames();
+}
+
+SdrModel& SvxUnoDrawingModel::getSdrModelFromUnoModel() const
+{
+    OSL_ENSURE(mpDoc, "No SdrModel in UnoDrawingModel, should not happen");
+    return *mpDoc;
+}
+
+SvxUnoDrawingModel::SvxUnoDrawingModel(SdrModel* pDoc) throw()
+:   SfxBaseModel(nullptr),
+    SvxFmMSFactory(),
+    css::drawing::XDrawPagesSupplier(),
+    css::lang::XServiceInfo(),
+    css::ucb::XAnyCompareFactory(),
+    mpDoc(pDoc),
+    mxDrawPagesAccess(),
+    mxDashTable(),
+    mxGradientTable(),
+    mxHatchTable(),
+    mxBitmapTable(),
+    mxTransGradientTable(),
+    mxMarkerTable(),
+    maTypeSequence()
+{
+}
+
+SvxUnoDrawingModel::~SvxUnoDrawingModel() throw()
+{
+}
+
+uno::Any SAL_CALL SvxUnoDrawingModel::queryInterface( const uno::Type & rType )
+{
+    uno::Any aAny;
+
+    QUERYINT(lang::XServiceInfo);
+    else QUERYINT(lang::XMultiServiceFactory);
+    else QUERYINT(drawing::XDrawPagesSupplier);
+    else QUERYINT(css::ucb::XAnyCompareFactory);
+    else
+        return SfxBaseModel::queryInterface( rType );
+
+    return aAny;
+}
+
+// XTypeProvider
+uno::Sequence< uno::Type > SAL_CALL SvxUnoDrawingModel::getTypes(  )
+{
+    if( !maTypeSequence.hasElements() )
+    {
+        maTypeSequence = comphelper::concatSequences( SfxBaseModel::getTypes(),
+            uno::Sequence {
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XMultiServiceFactory>::get(),
+                cppu::UnoType<drawing::XDrawPagesSupplier>::get(),
+                cppu::UnoType<css::ucb::XAnyCompareFactory>::get() });
+    }
+    return maTypeSequence;
+}
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxUnoDrawingModel::getImplementationId(  )
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+void SAL_CALL SvxUnoDrawingModel::lockControllers(  )
+{
+    if( mpDoc )
+        mpDoc->setLock(true);
+}
+
+void SAL_CALL SvxUnoDrawingModel::unlockControllers(  )
+{
+    if( mpDoc && mpDoc->isLocked() )
+    {
+        mpDoc->setLock(false);
+    }
+}
+
+sal_Bool SAL_CALL SvxUnoDrawingModel::hasControllersLocked(  )
+{
+    return mpDoc && mpDoc->isLocked();
+}
+
+// XDrawPagesSupplier
+uno::Reference< drawing::XDrawPages > SAL_CALL SvxUnoDrawingModel::getDrawPages()
+{
+    ::SolarMutexGuard aGuard;
+
+    uno::Reference< drawing::XDrawPages >  xDrawPages( mxDrawPagesAccess );
+
+    if( !xDrawPages.is() )
+        mxDrawPagesAccess = xDrawPages = new SvxUnoDrawPagesAccess(*this);
+
+    return xDrawPages;
+}
+
+// XMultiServiceFactory ( SvxFmMSFactory )
+uno::Reference< uno::XInterface > SAL_CALL SvxUnoDrawingModel::createInstance( const OUString& aServiceSpecifier )
+{
+    ::SolarMutexGuard aGuard;
+
+    if( aServiceSpecifier == "com.sun.star.drawing.DashTable" )
+    {
+        if( !mxDashTable.is() )
+            mxDashTable = SvxUnoDashTable_createInstance( mpDoc );
+        return mxDashTable;
+    }
+    if( aServiceSpecifier == "com.sun.star.drawing.GradientTable" )
+    {
+        if( !mxGradientTable.is() )
+            mxGradientTable = SvxUnoGradientTable_createInstance( mpDoc );
+        return mxGradientTable;
+    }
+    if( aServiceSpecifier == "com.sun.star.drawing.HatchTable" )
+    {
+        if( !mxHatchTable.is() )
+            mxHatchTable = SvxUnoHatchTable_createInstance( mpDoc );
+        return mxHatchTable;
+    }
+    if( aServiceSpecifier == "com.sun.star.drawing.BitmapTable" )
+    {
+        if( !mxBitmapTable.is() )
+            mxBitmapTable = SvxUnoBitmapTable_createInstance( mpDoc );
+        return mxBitmapTable;
+    }
+    if( aServiceSpecifier == "com.sun.star.drawing.TransparencyGradientTable" )
+    {
+        if( !mxTransGradientTable.is() )
+            mxTransGradientTable = SvxUnoTransGradientTable_createInstance( mpDoc );
+        return mxTransGradientTable;
+    }
+    if( aServiceSpecifier == "com.sun.star.drawing.MarkerTable" )
+    {
+        if( !mxMarkerTable.is() )
+            mxMarkerTable = SvxUnoMarkerTable_createInstance( mpDoc );
+        return mxMarkerTable;
+    }
+    if( aServiceSpecifier == "com.sun.star.text.NumberingRules" )
+    {
+        return uno::Reference< uno::XInterface >( SvxCreateNumRule( mpDoc ), uno::UNO_QUERY );
+    }
+
+    if ( aServiceSpecifier == "com.sun.star.image.ImageMapRectangleObject" )
+    {
+        return SvUnoImageMapRectangleObject_createInstance( ImplGetSupportedMacroItems() );
+    }
+
+    if ( aServiceSpecifier == "com.sun.star.image.ImageMapCircleObject" )
+    {
+        return SvUnoImageMapCircleObject_createInstance( ImplGetSupportedMacroItems() );
+    }
+
+    if ( aServiceSpecifier == "com.sun.star.image.ImageMapPolygonObject" )
+    {
+        return SvUnoImageMapPolygonObject_createInstance( ImplGetSupportedMacroItems() );
+    }
+
+    if( aServiceSpecifier == "com.sun.star.text.TextField.DateTime" )
+    {
+        return static_cast<cppu::OWeakObject *>(new SvxUnoTextField(text::textfield::Type::DATE));
+    }
+
+    uno::Reference< uno::XInterface > xRet;
+
+    const OUString aPackagePrefix( "com.sun.star.presentation." );
+    if( aServiceSpecifier.startsWith( aPackagePrefix ) )
+    {
+        SvxShape* pShape = nullptr;
+
+        sal_uInt16 nType = OBJ_TEXT;
+        OUString aTypeName = aServiceSpecifier.copy( aPackagePrefix.getLength() );
+        // create a shape wrapper
+        if( aTypeName.startsWith("TitleTextShape") )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "OutlinerShape" ) )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "SubtitleShape" ) )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "GraphicObjectShape" ) )
+        {
+            nType = OBJ_GRAF;
+        }
+        else if( aTypeName.startsWith( "PageShape" ) )
+        {
+            nType = OBJ_PAGE;
+        }
+        else if( aTypeName.startsWith( "OLE2Shape" ) )
+        {
+            nType = OBJ_OLE2;
+        }
+        else if( aTypeName.startsWith( "ChartShape" ) )
+        {
+            nType = OBJ_OLE2;
+        }
+        else if( aTypeName.startsWith( "OrgChartShape" ) )
+        {
+            nType = OBJ_OLE2;
+        }
+        else if( aTypeName.startsWith( "NotesShape" ) )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "HandoutShape" ) )
+        {
+            nType = OBJ_PAGE;
+        }
+        else if( aTypeName.startsWith( "FooterShape" ) )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "HeaderShape" ) )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "SlideNumberShape" ) )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "DateTimeShape" ) )
+        {
+            nType = OBJ_TEXT;
+        }
+        else if( aTypeName.startsWith( "TableShape" ) )
+        {
+            nType = OBJ_TABLE;
+        }
+        else
+        {
+            throw lang::ServiceNotRegisteredException();
+        }
+
+        // create the API wrapper
+        pShape = CreateSvxShapeByTypeAndInventor( nType, SdrInventor::Default, "" );
+
+        // set shape type
+        if( pShape )
+            pShape->SetShapeType(aServiceSpecifier);
+
+        xRet = static_cast<uno::XWeak*>(pShape);
+    }
+    else
+    {
+        xRet = SvxFmMSFactory::createInstance( aServiceSpecifier );
+    }
+
+    return xRet;
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoDrawingModel::getAvailableServiceNames()
+{
+    const uno::Sequence< OUString > aSNS_ORG( SvxFmMSFactory::getAvailableServiceNames() );
+
+    uno::Sequence< OUString > aSNS( 21 );
+
+    sal_uInt16 i = 0;
+
+    aSNS[i++] = "com.sun.star.drawing.DashTable";
+    aSNS[i++] = "com.sun.star.drawing.GradientTable";
+    aSNS[i++] = "com.sun.star.drawing.HatchTable";
+    aSNS[i++] = "com.sun.star.drawing.BitmapTable";
+    aSNS[i++] = "com.sun.star.drawing.TransparencyGradientTable";
+    aSNS[i++] = "com.sun.star.drawing.MarkerTable";
+    aSNS[i++] = "com.sun.star.text.NumberingRules";
+    aSNS[i++] = "com.sun.star.image.ImageMapRectangleObject";
+    aSNS[i++] = "com.sun.star.image.ImageMapCircleObject";
+    aSNS[i++] = "com.sun.star.image.ImageMapPolygonObject";
+
+    aSNS[i++] = "com.sun.star.presentation.TitleTextShape";
+    aSNS[i++] = "com.sun.star.presentation.OutlinerShape";
+    aSNS[i++] = "com.sun.star.presentation.SubtitleShape";
+    aSNS[i++] = "com.sun.star.presentation.GraphicObjectShape";
+    aSNS[i++] = "com.sun.star.presentation.ChartShape";
+    aSNS[i++] = "com.sun.star.presentation.PageShape";
+    aSNS[i++] = "com.sun.star.presentation.OLE2Shape";
+    aSNS[i++] = "com.sun.star.presentation.TableShape";
+    aSNS[i++] = "com.sun.star.presentation.OrgChartShape";
+    aSNS[i++] = "com.sun.star.presentation.NotesShape";
+    aSNS[i++] = "com.sun.star.presentation.HandoutShape";
+
+    DBG_ASSERT( i == aSNS.getLength(), "Sequence overrun!" );
+
+    return comphelper::concatSequences( aSNS_ORG, aSNS );
+}
+
+// lang::XServiceInfo
+OUString SAL_CALL SvxUnoDrawingModel::getImplementationName()
+{
+    return "SvxUnoDrawingModel";
+}
+
+sal_Bool SAL_CALL SvxUnoDrawingModel::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService( this, ServiceName );
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoDrawingModel::getSupportedServiceNames()
+{
+    return { "com.sun.star.drawing.DrawingDocument" };
+}
+
+// XAnyCompareFactory
+uno::Reference< css::ucb::XAnyCompare > SAL_CALL SvxUnoDrawingModel::createAnyCompareByName( const OUString& )
+{
+    return SvxCreateNumRuleCompare();
+}
+
+SvxUnoDrawPagesAccess::SvxUnoDrawPagesAccess( SvxUnoDrawingModel& rMyModel )  throw()
+:   mrModel(rMyModel)
+{
+}
+
+// XIndexAccess
+sal_Int32 SAL_CALL SvxUnoDrawPagesAccess::getCount()
+{
+    ::SolarMutexGuard aGuard;
+
+    sal_Int32 nCount = 0;
+
+    if( mrModel.mpDoc )
+        nCount = mrModel.mpDoc->GetPageCount();
+
+    return nCount;
+}
+
+uno::Any SAL_CALL SvxUnoDrawPagesAccess::getByIndex( sal_Int32 Index )
+{
+    ::SolarMutexGuard aGuard;
+
+    uno::Any aAny;
+
+    if( mrModel.mpDoc )
+    {
+        if( (Index < 0) || (Index >= mrModel.mpDoc->GetPageCount() ) )
+            throw lang::IndexOutOfBoundsException();
+
+        SdrPage* pPage = mrModel.mpDoc->GetPage( static_cast<sal_uInt16>(Index) );
+        if( pPage )
+        {
+            uno::Reference< uno::XInterface > xPage( pPage->mxUnoPage );
+
+            if( !xPage.is() )
+            {
+                if( dynamic_cast<FmFormModel*>( mrModel.mpDoc )  )
+                    xPage = static_cast<drawing::XDrawPage*>(new SvxFmDrawPage( pPage ));
+                else
+                    xPage = static_cast<drawing::XDrawPage*>(new SvxDrawPage( pPage ));
+
+                pPage->mxUnoPage = xPage;
+            }
+
+            aAny <<= xPage;
+        }
+    }
+    return aAny;
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoDrawPagesAccess::getElementType()
+{
+    return cppu::UnoType<drawing::XDrawPage>::get();
+}
+
+sal_Bool SAL_CALL SvxUnoDrawPagesAccess::hasElements()
+{
+    return getCount() > 0;
+}
+
+// XDrawPages
+
+// create a new page with model at given position
+// and return corresponding SdDrawPage
+uno::Reference< drawing::XDrawPage > SAL_CALL SvxUnoDrawPagesAccess::insertNewByIndex( sal_Int32 nIndex )
+{
+    ::SolarMutexGuard aGuard;
+
+    uno::Reference< drawing::XDrawPage > xDrawPage;
+
+    if( mrModel.mpDoc )
+    {
+        SdrPage* pPage;
+
+        if( dynamic_cast<FmFormModel*>( mrModel.mpDoc )  )
+            pPage = new FmFormPage(*static_cast<FmFormModel*>(mrModel.mpDoc));
+        else
+            pPage = new SdrPage(*mrModel.mpDoc);
+
+        mrModel.mpDoc->InsertPage( pPage, static_cast<sal_uInt16>(nIndex) );
+        xDrawPage.set( pPage->getUnoPage(), uno::UNO_QUERY );
+    }
+
+    return xDrawPage;
+}
+
+void SAL_CALL SvxUnoDrawPagesAccess::remove( const uno::Reference< drawing::XDrawPage >& xPage )
+{
+    ::SolarMutexGuard aGuard;
+
+    sal_uInt16 nPageCount = mrModel.mpDoc->GetPageCount();
+    if( nPageCount > 1 )
+    {
+        // get pPage from xPage and get Id (nPos)
+        SvxDrawPage* pSvxPage = comphelper::getUnoTunnelImplementation<SvxDrawPage>( xPage );
+        if( pSvxPage )
+        {
+            SdrPage* pPage = pSvxPage->GetSdrPage();
+            if(pPage)
+            {
+                sal_uInt16 nPage = pPage->GetPageNum();
+                mrModel.mpDoc->DeletePage( nPage );
+            }
+        }
+    }
+}
+
+// XServiceInfo
+
+OUString SAL_CALL SvxUnoDrawPagesAccess::getImplementationName(  )
+{
+    return "SvxUnoDrawPagesAccess";
+}
+
+sal_Bool SAL_CALL SvxUnoDrawPagesAccess::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoDrawPagesAccess::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.DrawPages" };
+}
+
+css::uno::Reference< css::container::XIndexReplace > SvxCreateNumRule(SdrModel* pModel)
+{
+    const SvxNumRule* pDefaultRule = nullptr;
+    if( pModel )
+    {
+        const SvxNumBulletItem* pItem = pModel->GetItemPool().GetSecondaryPool()->GetPoolDefaultItem(EE_PARA_NUMBULLET);
+        if( pItem )
+        {
+            pDefaultRule = pItem->GetNumRule();
+        }
+    }
+
+    if( pDefaultRule )
+    {
+        return SvxCreateNumRule( pDefaultRule );
+    }
+    else
+    {
+        SvxNumRule aTempRule( SvxNumRuleFlags::NONE, 10, false );
+        return SvxCreateNumRule( &aTempRule );
+    }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unomtabl.cxx b/svx/source/unodraw/unomtabl.cxx
new file mode 100644
index 000000000..b930fed67
--- /dev/null
+++ b/svx/source/unodraw/unomtabl.cxx
@@ -0,0 +1,413 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <memory>
+#include <set>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/drawing/PointSequence.hpp>
+
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <svl/itempool.hxx>
+#include <svl/itemset.hxx>
+#include <svl/lstner.hxx>
+#include <svx/xlnedit.hxx>
+#include <svx/xlnstit.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/xdef.hxx>
+
+#include <vector>
+#include <vcl/svapp.hxx>
+
+
+#include <svx/unofill.hxx>
+
+#include <svx/unoapi.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+typedef std::vector<std::unique_ptr<SfxItemSet>> ItemPoolVector;
+
+namespace {
+
+class SvxUnoMarkerTable : public WeakImplHelper< container::XNameContainer, lang::XServiceInfo >,
+                          public SfxListener
+{
+private:
+    SdrModel*       mpModel;
+    SfxItemPool*    mpModelPool;
+
+    ItemPoolVector maItemSetVector;
+
+public:
+    explicit SvxUnoMarkerTable( SdrModel* pModel ) throw();
+    virtual ~SvxUnoMarkerTable() throw() override;
+
+    void dispose();
+
+    // SfxListener
+    virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) throw () override;
+
+    void ImplInsertByName( const OUString& aName, const uno::Any& aElement );
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual sal_Bool SAL_CALL supportsService( const  OUString& ServiceName ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XNameContainer
+    virtual void SAL_CALL insertByName( const  OUString& aName, const  uno::Any& aElement ) override;
+    virtual void SAL_CALL removeByName( const  OUString& Name ) override;
+
+    // XNameReplace
+    virtual void SAL_CALL replaceByName( const  OUString& aName, const  uno::Any& aElement ) override;
+
+    // XNameAccess
+    virtual uno::Any SAL_CALL getByName( const  OUString& aName ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getElementNames(  ) override;
+    virtual sal_Bool SAL_CALL hasByName( const  OUString& aName ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType(  ) override;
+    virtual sal_Bool SAL_CALL hasElements(  ) override;
+};
+
+}
+
+SvxUnoMarkerTable::SvxUnoMarkerTable( SdrModel* pModel ) throw()
+: mpModel( pModel ),
+  mpModelPool( pModel ? &pModel->GetItemPool() : nullptr )
+{
+    if( pModel )
+        StartListening( *pModel );
+}
+
+SvxUnoMarkerTable::~SvxUnoMarkerTable() throw()
+{
+    if( mpModel )
+        EndListening( *mpModel );
+    dispose();
+}
+
+void SvxUnoMarkerTable::dispose()
+{
+    maItemSetVector.clear();
+}
+
+// SfxListener
+void SvxUnoMarkerTable::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
+{
+    if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint)
+    {
+        const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
+        if( SdrHintKind::ModelCleared == pSdrHint->GetKind() )
+            dispose();
+    }
+}
+
+sal_Bool SAL_CALL SvxUnoMarkerTable::supportsService( const  OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+OUString SAL_CALL SvxUnoMarkerTable::getImplementationName()
+{
+    return "SvxUnoMarkerTable";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoMarkerTable::getSupportedServiceNames(  )
+{
+    uno::Sequence<OUString> aSNS { "com.sun.star.drawing.MarkerTable" };
+    return aSNS;
+}
+
+void SvxUnoMarkerTable::ImplInsertByName( const OUString& aName, const uno::Any& aElement )
+{
+    maItemSetVector.push_back(
+        std::make_unique<SfxItemSet>( *mpModelPool, svl::Items<XATTR_LINESTART, XATTR_LINEEND>{} ));
+    auto pInSet = maItemSetVector.back().get();
+
+    XLineEndItem aEndMarker(XATTR_LINEEND);
+    aEndMarker.SetName( aName );
+    aEndMarker.PutValue( aElement, 0 );
+
+    pInSet->Put( aEndMarker );
+
+    XLineStartItem aStartMarker(XATTR_LINESTART);
+    aStartMarker.SetName( aName );
+    aStartMarker.PutValue( aElement, 0 );
+
+    pInSet->Put( aStartMarker );
+}
+
+// XNameContainer
+void SAL_CALL SvxUnoMarkerTable::insertByName( const OUString& aApiName, const uno::Any& aElement )
+{
+    SolarMutexGuard aGuard;
+
+    if( hasByName( aApiName ) )
+        throw container::ElementExistException();
+
+    OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
+
+    ImplInsertByName( aName, aElement );
+}
+
+void SAL_CALL SvxUnoMarkerTable::removeByName( const OUString& aApiName )
+{
+    SolarMutexGuard aGuard;
+
+    // a little quickfix for 2.0 to let applications clear api
+    // created items that are not used
+    if ( aApiName == "~clear~" )
+    {
+        dispose();
+        return;
+    }
+
+    OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
+
+    auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
+        [&aName](const std::unique_ptr<SfxItemSet>& rpItem) {
+            const NameOrIndex *pItem = &(rpItem->Get( XATTR_LINEEND ) );
+            return pItem->GetName() == aName;
+        });
+    if (aIter != maItemSetVector.end())
+    {
+        maItemSetVector.erase( aIter );
+        return;
+    }
+
+    if( !hasByName( aName ) )
+        throw container::NoSuchElementException();
+}
+
+// XNameReplace
+void SAL_CALL SvxUnoMarkerTable::replaceByName( const OUString& aApiName, const uno::Any& aElement )
+{
+    SolarMutexGuard aGuard;
+
+    const OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
+
+    auto aIter = std::find_if(maItemSetVector.begin(), maItemSetVector.end(),
+        [&aName](const std::unique_ptr<SfxItemSet>& rpItem) {
+            const NameOrIndex *pItem = &(rpItem->Get( XATTR_LINEEND ) );
+            return pItem->GetName() == aName;
+        });
+    if (aIter != maItemSetVector.end())
+    {
+        XLineEndItem aEndMarker(XATTR_LINEEND);
+        aEndMarker.SetName( aName );
+        if( !aEndMarker.PutValue( aElement, 0 ) )
+            throw lang::IllegalArgumentException();
+
+        (*aIter)->Put( aEndMarker );
+
+        XLineStartItem aStartMarker(XATTR_LINESTART);
+        aStartMarker.SetName( aName );
+        aStartMarker.PutValue( aElement, 0 );
+
+        (*aIter)->Put( aStartMarker );
+        return;
+    }
+
+    // if it is not in our own sets, modify the pool!
+    bool bFound = false;
+
+    if (mpModelPool)
+        for (const SfxPoolItem* p : mpModelPool->GetItemSurrogates(XATTR_LINESTART))
+        {
+            NameOrIndex *pItem = const_cast<NameOrIndex*>(static_cast<const NameOrIndex*>(p));
+            if( pItem && pItem->GetName() == aName )
+            {
+                pItem->PutValue( aElement, 0 );
+                bFound = true;
+                break;
+            }
+        }
+
+    if (mpModelPool)
+        for (const SfxPoolItem* p : mpModelPool->GetItemSurrogates(XATTR_LINEEND))
+        {
+            NameOrIndex *pItem = const_cast<NameOrIndex*>(static_cast<const NameOrIndex*>(p));
+            if( pItem && pItem->GetName() == aName )
+            {
+                pItem->PutValue( aElement, 0 );
+                bFound = true;
+                break;
+            }
+        }
+
+    if( !bFound )
+        throw container::NoSuchElementException();
+
+    ImplInsertByName( aName, aElement );
+}
+
+static bool getByNameFromPool( const OUString& rSearchName, SfxItemPool const * pPool, sal_uInt16 nWhich, uno::Any& rAny )
+{
+    if (pPool)
+        for (const SfxPoolItem* p : pPool->GetItemSurrogates(nWhich))
+        {
+            const NameOrIndex *pItem = static_cast<const NameOrIndex*>(p);
+
+            if( pItem && pItem->GetName() == rSearchName )
+            {
+                pItem->QueryValue( rAny );
+                return true;
+            }
+        }
+
+    return false;
+}
+
+// XNameAccess
+uno::Any SAL_CALL SvxUnoMarkerTable::getByName( const OUString& aApiName )
+{
+    SolarMutexGuard aGuard;
+
+    OUString aName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aApiName);
+
+    uno::Any aAny;
+
+    if (mpModelPool && !aName.isEmpty())
+    {
+        do
+        {
+            if (getByNameFromPool(aName, mpModelPool, XATTR_LINESTART, aAny))
+                break;
+
+            if (getByNameFromPool(aName, mpModelPool, XATTR_LINEEND, aAny))
+                break;
+
+            throw container::NoSuchElementException();
+        }
+        while(false);
+    }
+
+    return aAny;
+}
+
+static void createNamesForPool( SfxItemPool const * pPool, sal_uInt16 nWhich, std::set< OUString >& rNameSet )
+{
+    for (const SfxPoolItem* p : pPool->GetItemSurrogates(nWhich))
+    {
+        const NameOrIndex* pItem = static_cast<const NameOrIndex*>(p);
+
+        if( pItem == nullptr || pItem->GetName().isEmpty() )
+            continue;
+
+        OUString aName = SvxUnogetApiNameForItem(XATTR_LINEEND, pItem->GetName());
+        rNameSet.insert( aName );
+    }
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoMarkerTable::getElementNames()
+{
+    SolarMutexGuard aGuard;
+
+    std::set< OUString > aNameSet;
+
+    // search model pool for line starts
+    createNamesForPool( mpModelPool, XATTR_LINESTART, aNameSet );
+
+    // search model pool for line ends
+    createNamesForPool( mpModelPool, XATTR_LINEEND, aNameSet );
+
+    return comphelper::containerToSequence(aNameSet);
+}
+
+sal_Bool SAL_CALL SvxUnoMarkerTable::hasByName( const OUString& aName )
+{
+    SolarMutexGuard aGuard;
+
+    if( aName.isEmpty() )
+        return false;
+
+    OUString aSearchName;
+
+    const NameOrIndex *pItem;
+
+    aSearchName = SvxUnogetInternalNameForItem(XATTR_LINESTART, aName);
+    if (mpModelPool)
+        for (const SfxPoolItem* p : mpModelPool->GetItemSurrogates(XATTR_LINESTART))
+        {
+            pItem = static_cast<const NameOrIndex*>(p);
+            if( pItem && pItem->GetName() == aSearchName )
+                return true;
+        }
+
+    aSearchName = SvxUnogetInternalNameForItem(XATTR_LINEEND, aName);
+    if (mpModelPool)
+        for (const SfxPoolItem* p : mpModelPool->GetItemSurrogates(XATTR_LINEEND))
+        {
+            pItem = static_cast<const NameOrIndex*>(p);
+            if( pItem && pItem->GetName() == aSearchName )
+                return true;
+        }
+
+    return false;
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoMarkerTable::getElementType(  )
+{
+    return cppu::UnoType<drawing::PointSequence>::get();
+}
+
+sal_Bool SAL_CALL SvxUnoMarkerTable::hasElements(  )
+{
+    SolarMutexGuard aGuard;
+
+    const NameOrIndex *pItem;
+
+    if (mpModelPool)
+        for (const SfxPoolItem* p : mpModelPool->GetItemSurrogates(XATTR_LINESTART))
+        {
+            pItem = static_cast<const NameOrIndex*>(p);
+            if( pItem && !pItem->GetName().isEmpty() )
+                return true;
+        }
+
+    if (mpModelPool)
+        for (const SfxPoolItem* p : mpModelPool->GetItemSurrogates(XATTR_LINEEND))
+        {
+            pItem = static_cast<const NameOrIndex*>(p);
+            if( pItem && !pItem->GetName().isEmpty() )
+                return true;
+        }
+
+    return false;
+}
+
+/**
+ * Create a hatchtable
+ */
+uno::Reference< uno::XInterface > SvxUnoMarkerTable_createInstance( SdrModel* pModel )
+{
+    return *new SvxUnoMarkerTable(pModel);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unopage.cxx b/svx/source/unodraw/unopage.cxx
new file mode 100644
index 000000000..bba5929f5
--- /dev/null
+++ b/svx/source/unodraw/unopage.cxx
@@ -0,0 +1,903 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_features.h>
+#include <config_feature_desktop.h>
+
+#include <com/sun/star/document/EventObject.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <o3tl/safeint.hxx>
+#include <osl/mutex.hxx>
+#include <comphelper/classids.hxx>
+#include <comphelper/embeddedobjectcontainer.hxx>
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include <svx/svdpool.hxx>
+#include <svx/svdobj.hxx>
+#include <svx/svdoole2.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/strings.hrc>
+#include <svx/svdview.hxx>
+#include <svx/svdpagv.hxx>
+#include <svx/svdundo.hxx>
+#include <svx/unopage.hxx>
+#include "shapeimpl.hxx"
+#include <svx/dialmgr.hxx>
+#include <svx/globl3d.hxx>
+#include <svx/unoprov.hxx>
+#include <svx/unoapi.hxx>
+#include <extrud3d.hxx>
+#include <svx/lathe3d.hxx>
+#include <svx/scene3d.hxx>
+#include <vcl/svapp.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/globname.hxx>
+#include <sal/log.hxx>
+
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::drawing;
+
+UNO3_GETIMPLEMENTATION_IMPL( SvxDrawPage );
+
+SvxDrawPage::SvxDrawPage(SdrPage* pInPage) // TTTT should be reference
+:   mrBHelper(getMutex())
+    ,mpPage(pInPage)
+    ,mpModel(&pInPage->getSdrModelFromSdrPage())  // register at broadcaster
+    ,mpView(new SdrView(pInPage->getSdrModelFromSdrPage())) // create (hidden) view
+{
+    mpView->SetDesignMode();
+}
+
+SvxDrawPage::~SvxDrawPage() throw()
+{
+    if( !mrBHelper.bDisposed )
+    {
+        assert(!"SvxDrawPage must be disposed!");
+        acquire();
+        dispose();
+    }
+}
+
+// XInterface
+void SvxDrawPage::release() throw()
+{
+    OWeakAggObject::release();
+}
+
+// XComponent
+void SvxDrawPage::disposing() throw()
+{
+    if( mpModel )
+    {
+        mpModel = nullptr;
+    }
+
+    mpView.reset();
+    mpPage = nullptr;
+}
+
+// XComponent
+void SvxDrawPage::dispose()
+{
+    SolarMutexGuard aSolarGuard;
+
+    // An frequently programming error is to release the last
+    // reference to this object in the disposing message.
+    // Make it robust, hold a self Reference.
+    uno::Reference< lang::XComponent > xSelf( this );
+
+    // Guard dispose against multiple threading
+    // Remark: It is an error to call dispose more than once
+    bool bDoDispose = false;
+    {
+        osl::MutexGuard aGuard( mrBHelper.rMutex );
+        if( !mrBHelper.bDisposed && !mrBHelper.bInDispose )
+        {
+            // only one call go into this section
+            mrBHelper.bInDispose = true;
+            bDoDispose = true;
+        }
+    }
+
+    // Do not hold the mutex because we are broadcasting
+    if( bDoDispose )
+    {
+        // Create an event with this as sender
+        try
+        {
+            uno::Reference< uno::XInterface > xSource( uno::Reference< uno::XInterface >::query( static_cast<lang::XComponent *>(this) ) );
+            css::document::EventObject aEvt;
+            aEvt.Source = xSource;
+            // inform all listeners to release this object
+            // The listener container are automatically cleared
+            mrBHelper.aLC.disposeAndClear( aEvt );
+            // notify subclasses to do their dispose
+            disposing();
+        }
+        catch(const css::uno::Exception&)
+        {
+            // catch exception and throw again but signal that
+            // the object was disposed. Dispose should be called
+            // only once.
+            osl::MutexGuard aGuard( mrBHelper.rMutex );
+            mrBHelper.bDisposed = true;
+            mrBHelper.bInDispose = false;
+            throw;
+        }
+
+        osl::MutexGuard aGuard( mrBHelper.rMutex );
+        mrBHelper.bDisposed = true;
+        mrBHelper.bInDispose = false;
+    }
+
+}
+
+void SAL_CALL SvxDrawPage::addEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener )
+{
+    SolarMutexGuard aGuard;
+
+    if( mpModel == nullptr )
+        throw lang::DisposedException();
+
+    mrBHelper.addListener( cppu::UnoType<decltype(aListener)>::get() , aListener );
+}
+
+void SAL_CALL SvxDrawPage::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener )
+{
+    SolarMutexGuard aGuard;
+
+    if( mpModel == nullptr )
+        throw lang::DisposedException();
+
+    mrBHelper.removeListener( cppu::UnoType<decltype(aListener)>::get() , aListener );
+}
+
+void SAL_CALL SvxDrawPage::add( const uno::Reference< drawing::XShape >& xShape )
+{
+    SolarMutexGuard aGuard;
+
+    if ( ( mpModel == nullptr ) || ( mpPage == nullptr ) )
+        throw lang::DisposedException();
+
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+
+    if( nullptr == pShape )
+        return;
+
+    SdrObject *pObj = pShape->GetSdrObject();
+    bool bNeededToClone(false);
+
+    if(nullptr != pObj && &pObj->getSdrModelFromSdrObject() != &mpPage->getSdrModelFromSdrPage())
+    {
+        // TTTT UNO API tries to add an existing SvxShape to this SvxDrawPage,
+        // but these use different SdrModels. It was possible before to completely
+        // 'change' a SdrObject to another SdrModel (including dangerous MigrateItemPool
+        // stuff), but is no longer. We need to Clone the SdrObject to the target model
+        // and ::Create a new SvxShape (set SdrObject there, take obver values, ...)
+        SdrObject* pClonedSdrShape(pObj->CloneSdrObject(mpPage->getSdrModelFromSdrPage()));
+        pObj->setUnoShape(nullptr);
+        pClonedSdrShape->setUnoShape(xShape);
+        // pShape->InvalidateSdrObject();
+        // pShape->Create(pClonedSdrShape, this);
+        SdrObject::Free(pObj);
+        pObj = pClonedSdrShape;
+        bNeededToClone = true;
+    }
+
+    if(!pObj)
+    {
+        pObj = CreateSdrObject( xShape );
+        ENSURE_OR_RETURN_VOID( pObj != nullptr, "SvxDrawPage::add: no SdrObject was created!" );
+    }
+    else if ( !pObj->IsInserted() )
+    {
+        mpPage->InsertObject( pObj );
+
+        if(bNeededToClone)
+        {
+            // TTTT Unfortunately in SdrObject::SetPage (see there) the
+            // xShape/UnoShape at the newly cloned SDrObject is *removed* again,
+            // so re-set it here, the caller *may need it* (e.g. Writer)
+            uno::Reference< uno::XInterface > xShapeCheck(pObj->getWeakUnoShape());
+
+            if( !xShapeCheck.is() )
+            {
+                pObj->setUnoShape(xShape);
+            }
+        }
+    }
+
+    pShape->Create( pObj, this );
+    OSL_ENSURE( pShape->GetSdrObject() == pObj, "SvxDrawPage::add: shape does not know about its newly created SdrObject!" );
+
+    if ( !pObj->IsInserted() )
+    {
+        mpPage->InsertObject( pObj );
+    }
+
+    mpModel->SetChanged();
+}
+
+void SAL_CALL SvxDrawPage::addTop( const uno::Reference< drawing::XShape >& xShape )
+{
+    add(xShape);
+}
+
+void SAL_CALL SvxDrawPage::addBottom( const uno::Reference< drawing::XShape >& xShape )
+{
+    SolarMutexGuard aGuard;
+
+    if ( ( mpModel == nullptr ) || ( mpPage == nullptr ) )
+        throw lang::DisposedException();
+
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+
+    if( nullptr == pShape )
+        return;
+
+    SdrObject *pObj = pShape->GetSdrObject();
+
+    if(!pObj)
+    {
+        pObj = CreateSdrObject( xShape, true );
+        ENSURE_OR_RETURN_VOID( pObj != nullptr, "SvxDrawPage::add: no SdrObject was created!" );
+    }
+    else if ( !pObj->IsInserted() )
+    {
+        mpPage->InsertObject( pObj, 0 );
+    }
+
+    pShape->Create( pObj, this );
+    OSL_ENSURE( pShape->GetSdrObject() == pObj, "SvxDrawPage::add: shape does not know about its newly created SdrObject!" );
+
+    if ( !pObj->IsInserted() )
+    {
+        mpPage->InsertObject( pObj, 0 );
+    }
+
+    mpModel->SetChanged();
+}
+
+void SAL_CALL SvxDrawPage::remove( const Reference< drawing::XShape >& xShape )
+{
+    SolarMutexGuard aGuard;
+
+    if( (mpModel == nullptr) || (mpPage == nullptr) )
+        throw lang::DisposedException();
+
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+
+    if (pShape)
+    {
+        SdrObject* pObj = pShape->GetSdrObject();
+        if (pObj)
+        {
+            // remove SdrObject from page
+            const size_t nCount = mpPage->GetObjCount();
+            for( size_t nNum = 0; nNum < nCount; ++nNum )
+            {
+                if(mpPage->GetObj(nNum) == pObj)
+                {
+                    const bool bUndoEnabled = mpModel->IsUndoEnabled();
+
+                    if (bUndoEnabled)
+                    {
+                        mpModel->BegUndo(SvxResId(STR_EditDelete),
+                            pObj->TakeObjNameSingul(), SdrRepeatFunc::Delete);
+
+                        mpModel->AddUndo(mpModel->GetSdrUndoFactory().CreateUndoDeleteObject(*pObj));
+                    }
+
+                    OSL_VERIFY( mpPage->RemoveObject( nNum ) == pObj );
+
+                    if (!bUndoEnabled)
+                        SdrObject::Free(pObj);
+
+                    if (bUndoEnabled)
+                        mpModel->EndUndo();
+
+                    break;
+                }
+            }
+        }
+    }
+
+    mpModel->SetChanged();
+}
+
+void SvxDrawPage::sort( const css::uno::Sequence< sal_Int32 >& sortOrder )
+{
+    auto newOrder = comphelper::sequenceToContainer<std::vector<sal_Int32>>(sortOrder);
+    mpPage->sort(newOrder);
+}
+
+// css::container::XIndexAccess
+sal_Int32 SAL_CALL SvxDrawPage::getCount()
+{
+    SolarMutexGuard aGuard;
+
+    if( (mpModel == nullptr) || (mpPage == nullptr) )
+        throw lang::DisposedException();
+
+    return static_cast<sal_Int32>( mpPage->GetObjCount() );
+}
+
+uno::Any SAL_CALL SvxDrawPage::getByIndex( sal_Int32 Index )
+{
+    SolarMutexGuard aGuard;
+
+    if( (mpModel == nullptr) || (mpPage == nullptr) )
+        throw lang::DisposedException("Model or Page was already disposed!");
+
+    if ( Index < 0 || o3tl::make_unsigned(Index) >= mpPage->GetObjCount() )
+        throw lang::IndexOutOfBoundsException("Index (" + OUString::number(Index)
+                                              + ") needs to be a positive integer smaller than the shape count ("
+                                              + OUString::number(mpPage->GetObjCount()) + ")!");
+
+    SdrObject* pObj = mpPage->GetObj( Index );
+    if( pObj == nullptr )
+        throw uno::RuntimeException("Runtime exception thrown while getting a ref to the SdrObject at index: "
+                                    + OUString::number(Index));
+
+
+    return makeAny(Reference< drawing::XShape >( pObj->getUnoShape(), uno::UNO_QUERY ));
+}
+
+// css::container::XElementAccess
+uno::Type SAL_CALL SvxDrawPage::getElementType()
+{
+    return cppu::UnoType<drawing::XShape>::get();
+}
+
+sal_Bool SAL_CALL SvxDrawPage::hasElements()
+{
+    SolarMutexGuard aGuard;
+
+    if( (mpModel == nullptr) || (mpPage == nullptr) )
+        throw lang::DisposedException();
+
+    return mpPage && mpPage->GetObjCount()>0;
+}
+
+namespace
+{
+    void lcl_markSdrObjectOfShape( const Reference< drawing::XShape >& _rxShape, SdrView& _rView, SdrPageView& _rPageView )
+    {
+        SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( _rxShape );
+        if ( !pShape )
+            return;
+
+        SdrObject* pObj = pShape->GetSdrObject();
+        if ( !pObj )
+            return;
+
+        _rView.MarkObj( pObj, &_rPageView );
+    }
+}
+
+// ATTENTION: SelectObjectsInView selects the css::drawing::Shapes
+// only in the given SdrPageView. It hasn't to be the visible SdrPageView.
+void SvxDrawPage::SelectObjectsInView( const Reference< drawing::XShapes > & aShapes, SdrPageView* pPageView ) throw ()
+{
+    SAL_WARN_IF(!pPageView, "svx", "SdrPageView is NULL!");
+    SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
+
+    if(pPageView!=nullptr && mpView!=nullptr)
+    {
+        mpView->UnmarkAllObj( pPageView );
+
+        long nCount = aShapes->getCount();
+        for( long i = 0; i < nCount; i++ )
+        {
+            uno::Any aAny( aShapes->getByIndex(i) );
+            Reference< drawing::XShape > xShape;
+            if( aAny >>= xShape )
+                lcl_markSdrObjectOfShape( xShape, *mpView, *pPageView );
+        }
+    }
+}
+
+// ATTENTION: SelectObjectInView selects the shape only in the given SdrPageView.
+// It hasn't to be the visible SdrPageView.
+void SvxDrawPage::SelectObjectInView( const Reference< drawing::XShape > & xShape, SdrPageView* pPageView ) throw()
+{
+    SAL_WARN_IF(!pPageView, "svx", "SdrPageView is NULL!");
+    SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
+
+    if(pPageView!=nullptr && mpView != nullptr)
+    {
+        mpView->UnmarkAllObj( pPageView );
+        lcl_markSdrObjectOfShape( xShape, *mpView, *pPageView );
+    }
+}
+
+Reference< drawing::XShapeGroup > SAL_CALL SvxDrawPage::group( const Reference< drawing::XShapes >& xShapes )
+{
+    SolarMutexGuard aGuard;
+
+    if( (mpModel == nullptr) || (mpPage == nullptr) )
+        throw lang::DisposedException();
+
+    SAL_WARN_IF(!mpPage , "svx", "SdrPage is NULL!");
+    SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
+
+    Reference< css::drawing::XShapeGroup >  xShapeGroup;
+    if(mpPage==nullptr||mpView==nullptr||!xShapes.is())
+        return xShapeGroup;
+
+    SdrPageView* pPageView = mpView->ShowSdrPage( mpPage );
+
+    SelectObjectsInView( xShapes, pPageView );
+
+    mpView->GroupMarked();
+
+    mpView->AdjustMarkHdl();
+    const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
+    if( rMarkList.GetMarkCount() == 1 )
+    {
+        SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
+        if( pObj )
+             xShapeGroup.set( pObj->getUnoShape(), UNO_QUERY );
+    }
+
+    mpView->HideSdrPage();
+
+    if( mpModel )
+        mpModel->SetChanged();
+
+    return xShapeGroup;
+}
+
+void SAL_CALL SvxDrawPage::ungroup( const Reference< drawing::XShapeGroup >& aGroup )
+{
+    SolarMutexGuard aGuard;
+
+    if( (mpModel == nullptr) || (mpPage == nullptr) )
+        throw lang::DisposedException();
+
+    SAL_WARN_IF(!mpPage, "svx", "SdrPage is NULL!");
+    SAL_WARN_IF(!mpView, "svx", "SdrView is NULL!");
+
+    if(mpPage==nullptr||mpView==nullptr||!aGroup.is())
+        return;
+
+    SdrPageView* pPageView = mpView->ShowSdrPage( mpPage );
+
+    SelectObjectInView( aGroup, pPageView );
+    mpView->UnGroupMarked();
+
+    mpView->HideSdrPage();
+
+    if( mpModel )
+        mpModel->SetChanged();
+}
+
+SdrObject* SvxDrawPage::CreateSdrObject_(const Reference< drawing::XShape > & xShape)
+{
+    sal_uInt16 nType = 0;
+    SdrInventor nInventor;
+
+    GetTypeAndInventor( nType, nInventor, xShape->getShapeType() );
+    if (!nType)
+        return nullptr;
+
+    awt::Size aSize = xShape->getSize();
+    aSize.Width += 1;
+    aSize.Height += 1;
+    awt::Point aPos = xShape->getPosition();
+    tools::Rectangle aRect( Point( aPos.X, aPos.Y ), Size( aSize.Width, aSize.Height ) );
+
+    SdrObject* pNewObj = SdrObjFactory::MakeNewObject(
+        *mpModel,
+        nInventor,
+        nType,
+        &aRect);
+
+    if (!pNewObj)
+        return nullptr;
+
+    if( auto pScene = dynamic_cast<E3dScene* >(pNewObj) )
+    {
+        // initialise scene
+
+        double fW = static_cast<double>(aSize.Width);
+        double fH = static_cast<double>(aSize.Height);
+
+        Camera3D aCam(pScene->GetCamera());
+        aCam.SetAutoAdjustProjection(false);
+        aCam.SetViewWindow(- fW / 2, - fH / 2, fW, fH);
+        basegfx::B3DPoint aLookAt;
+        basegfx::B3DPoint aCamPos(0.0, 0.0, 10000.0);
+        aCam.SetPosAndLookAt(aCamPos, aLookAt);
+        aCam.SetFocalLength(100.0);
+        pScene->SetCamera(aCam);
+
+        pScene->SetRectsDirty();
+    }
+    else if(dynamic_cast<const E3dExtrudeObj* >(pNewObj) !=  nullptr)
+    {
+        E3dExtrudeObj* pObj = static_cast<E3dExtrudeObj*>(pNewObj);
+        basegfx::B2DPolygon aNewPolygon;
+        aNewPolygon.append(basegfx::B2DPoint(0.0, 0.0));
+        aNewPolygon.append(basegfx::B2DPoint(0.0, 1.0));
+        aNewPolygon.append(basegfx::B2DPoint(1.0, 0.0));
+        aNewPolygon.setClosed(true);
+        pObj->SetExtrudePolygon(basegfx::B2DPolyPolygon(aNewPolygon));
+
+        // #107245# pObj->SetExtrudeCharacterMode(sal_True);
+        pObj->SetMergedItem(Svx3DCharacterModeItem(true));
+    }
+    else if(dynamic_cast<const E3dLatheObj* >(pNewObj) !=  nullptr)
+    {
+        E3dLatheObj* pObj = static_cast<E3dLatheObj*>(pNewObj);
+        basegfx::B2DPolygon aNewPolygon;
+        aNewPolygon.append(basegfx::B2DPoint(0.0, 0.0));
+        aNewPolygon.append(basegfx::B2DPoint(0.0, 1.0));
+        aNewPolygon.append(basegfx::B2DPoint(1.0, 0.0));
+        aNewPolygon.setClosed(true);
+        pObj->SetPolyPoly2D(basegfx::B2DPolyPolygon(aNewPolygon));
+
+        // #107245# pObj->SetLatheCharacterMode(sal_True);
+        pObj->SetMergedItem(Svx3DCharacterModeItem(true));
+    }
+
+    return pNewObj;
+}
+
+void SvxDrawPage::GetTypeAndInventor( sal_uInt16& rType, SdrInventor& rInventor, const OUString& aName ) throw()
+{
+    sal_uInt32 nTempType = UHashMap::getId( aName );
+
+    if( nTempType == UHASHMAP_NOTFOUND )
+    {
+        if( aName == "com.sun.star.drawing.TableShape" ||
+            aName == "com.sun.star.presentation.TableShape" )
+        {
+            rInventor = SdrInventor::Default;
+            rType = OBJ_TABLE;
+        }
+#if HAVE_FEATURE_AVMEDIA
+        else if ( aName == "com.sun.star.presentation.MediaShape" )
+        {
+            rInventor = SdrInventor::Default;
+            rType = OBJ_MEDIA;
+        }
+#endif
+    }
+    else if(nTempType & E3D_INVENTOR_FLAG)
+    {
+        rInventor = SdrInventor::E3d;
+        rType = static_cast<sal_uInt16>(nTempType & ~E3D_INVENTOR_FLAG);
+    }
+    else
+    {
+        rInventor = SdrInventor::Default;
+        rType = static_cast<sal_uInt16>(nTempType);
+
+        switch( rType )
+        {
+            case OBJ_FRAME:
+            case OBJ_OLE2_PLUGIN:
+            case OBJ_OLE2_APPLET:
+                rType = OBJ_OLE2;
+                break;
+        }
+    }
+}
+
+SvxShape* SvxDrawPage::CreateShapeByTypeAndInventor( sal_uInt16 nType, SdrInventor nInventor, SdrObject *pObj, SvxDrawPage *mpPage, OUString const & referer )
+{
+    SvxShape* pRet = nullptr;
+
+    switch( nInventor )
+    {
+        case SdrInventor::E3d:
+        {
+            switch( nType )
+            {
+                case E3D_SCENE_ID :
+                    pRet = new Svx3DSceneObject( pObj, mpPage );
+                    break;
+                case E3D_CUBEOBJ_ID :
+                    pRet = new Svx3DCubeObject( pObj );
+                    break;
+                case E3D_SPHEREOBJ_ID :
+                    pRet = new Svx3DSphereObject( pObj );
+                    break;
+                case E3D_LATHEOBJ_ID :
+                    pRet = new Svx3DLatheObject( pObj );
+                    break;
+                case E3D_EXTRUDEOBJ_ID :
+                    pRet = new Svx3DExtrudeObject( pObj );
+                    break;
+                case E3D_POLYGONOBJ_ID :
+                    pRet = new Svx3DPolygonObject( pObj );
+                    break;
+                default: // unknown 3D-object on page
+                    pRet = new SvxShape( pObj );
+                    break;
+            }
+            break;
+        }
+        case SdrInventor::Default:
+        {
+            switch( nType )
+            {
+                case OBJ_GRUP:
+                    pRet = new SvxShapeGroup( pObj, mpPage );
+                    break;
+                case OBJ_LINE:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_RECT:
+                    pRet = new SvxShapeRect( pObj );
+                    break;
+                case OBJ_CIRC:
+                case OBJ_SECT:
+                case OBJ_CARC:
+                case OBJ_CCUT:
+                    pRet = new SvxShapeCircle( pObj );
+                    break;
+                case OBJ_POLY:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_PLIN:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_SPLNLINE:
+                case OBJ_PATHLINE:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_SPLNFILL:
+                case OBJ_PATHFILL:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_FREELINE:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_FREEFILL:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_CAPTION:
+                    pRet = new SvxShapeCaption( pObj );
+                    break;
+                case OBJ_TITLETEXT:
+                case OBJ_OUTLINETEXT:
+                case OBJ_TEXT:
+                    pRet = new SvxShapeText( pObj );
+                    break;
+                case OBJ_GRAF:
+                    pRet = new SvxGraphicObject( pObj );
+                    break;
+                case OBJ_FRAME:
+                    pRet = new SvxFrameShape( pObj );
+                    break;
+                case OBJ_OLE2_APPLET:
+                    pRet = new SvxAppletShape( pObj );
+                    break;
+                case OBJ_OLE2_PLUGIN:
+                    pRet = new SvxPluginShape( pObj );
+                    break;
+                 case OBJ_OLE2:
+                     {
+                        if( pObj && !pObj->IsEmptyPresObj() && mpPage )
+                        {
+                            SdrPage* pSdrPage = mpPage->GetSdrPage();
+                            if( pSdrPage )
+                            {
+                                SdrModel& rSdrModel(pSdrPage->getSdrModelFromSdrPage());
+                                ::comphelper::IEmbeddedHelper *pPersist = rSdrModel.GetPersist();
+
+                                if( pPersist )
+                                {
+                                    uno::Reference < embed::XEmbeddedObject > xObject = pPersist->getEmbeddedObjectContainer().
+                                            GetEmbeddedObject( static_cast< SdrOle2Obj* >( pObj )->GetPersistName() );
+
+                                    // TODO CL->KA: Why is this not working anymore?
+                                    if( xObject.is() )
+                                    {
+                                        SvGlobalName aClassId( xObject->getClassID() );
+
+                                        const SvGlobalName aAppletClassId( SO3_APPLET_CLASSID );
+                                        const SvGlobalName aPluginClassId( SO3_PLUGIN_CLASSID );
+                                        const SvGlobalName aIFrameClassId( SO3_IFRAME_CLASSID );
+
+                                        if( aPluginClassId == aClassId )
+                                        {
+                                            pRet = new SvxPluginShape( pObj );
+                                            nType = OBJ_OLE2_PLUGIN;
+                                        }
+                                        else if( aAppletClassId == aClassId )
+                                        {
+                                            pRet = new SvxAppletShape( pObj );
+                                            nType = OBJ_OLE2_APPLET;
+                                        }
+                                        else if( aIFrameClassId == aClassId )
+                                        {
+                                            pRet = new SvxFrameShape( pObj );
+                                            nType = OBJ_FRAME;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if( pRet == nullptr )
+                        {
+                            SvxUnoPropertyMapProvider& rSvxMapProvider = getSvxMapProvider();
+                            pRet = new SvxOle2Shape( pObj, rSvxMapProvider.GetMap(SVXMAP_OLE2),  rSvxMapProvider.GetPropertySet(SVXMAP_OLE2, SdrObject::GetGlobalDrawObjectItemPool()) );
+                        }
+                     }
+                    break;
+                case OBJ_EDGE:
+                    pRet = new SvxShapeConnector( pObj );
+                    break;
+                case OBJ_PATHPOLY:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_PATHPLIN:
+                    pRet = new SvxShapePolyPolygon( pObj );
+                    break;
+                case OBJ_PAGE:
+                {
+                    SvxUnoPropertyMapProvider& rSvxMapProvider = getSvxMapProvider();
+                    pRet = new SvxShape( pObj, rSvxMapProvider.GetMap(SVXMAP_PAGE),  rSvxMapProvider.GetPropertySet(SVXMAP_PAGE, SdrObject::GetGlobalDrawObjectItemPool()) );
+                }
+                    break;
+                case OBJ_MEASURE:
+                    pRet = new SvxShapeDimensioning( pObj );
+                    break;
+                case OBJ_UNO:
+                    pRet = new SvxShapeControl( pObj );
+                    break;
+                case OBJ_CUSTOMSHAPE:
+                    pRet = new SvxCustomShape( pObj );
+                    break;
+                case OBJ_MEDIA:
+                    pRet = new SvxMediaShape( pObj, referer );
+                    break;
+                case OBJ_TABLE:
+                    pRet = new SvxTableShape( pObj );
+                    break;
+                default: // unknown 2D-object on page
+                    assert(false && "Not implemented Starone-Shape created");
+                    pRet = new SvxShapeText( pObj );
+                    break;
+            }
+            break;
+        }
+        default: // unknown inventor
+        {
+            assert(false && "Unknown Inventor in SvxDrawPage::CreateShape()");
+            break;
+        }
+    }
+
+    if(pRet)
+    {
+        sal_uInt32 nObjId = nType;
+
+        if( nInventor == SdrInventor::E3d )
+            nObjId |= E3D_INVENTOR_FLAG;
+
+        switch(nObjId)
+        {
+        case OBJ_CCUT:          // segment of circle
+        case OBJ_CARC:          // arc of circle
+        case OBJ_SECT:          // sector
+            nObjId = OBJ_CIRC;
+            break;
+
+        case OBJ_TITLETEXT:
+        case OBJ_OUTLINETEXT:
+            nObjId = OBJ_TEXT;
+            break;
+        }
+
+        pRet->setShapeKind(nObjId);
+    }
+
+    return pRet;
+}
+
+Reference< drawing::XShape >  SvxDrawPage::CreateShape( SdrObject *pObj ) const
+{
+    Reference< drawing::XShape > xShape( CreateShapeByTypeAndInventor(pObj->GetObjIdentifier(),
+                                              pObj->GetObjInventor(),
+                                              pObj,
+                                              const_cast<SvxDrawPage*>(this)));
+    return xShape;
+}
+
+SdrObject *SvxDrawPage::CreateSdrObject( const Reference< drawing::XShape > & xShape, bool bBeginning ) throw()
+{
+    SdrObject* pObj = CreateSdrObject_( xShape );
+    if( pObj)
+    {
+        if ( !pObj->IsInserted() && !pObj->IsDoNotInsertIntoPageAutomatically() )
+        {
+            if(bBeginning)
+                mpPage->InsertObject( pObj, 0 );
+            else
+                mpPage->InsertObject( pObj );
+        }
+    }
+
+    return pObj;
+}
+
+// css::lang::XServiceInfo
+OUString SAL_CALL SvxDrawPage::getImplementationName()
+{
+    return "SvxDrawPage";
+}
+
+sal_Bool SAL_CALL SvxDrawPage::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService( this, ServiceName );
+}
+
+uno::Sequence< OUString > SAL_CALL SvxDrawPage::getSupportedServiceNames()
+{
+    uno::Sequence<OUString> aSeq { "com.sun.star.drawing.ShapeCollection" };
+    return aSeq;
+}
+
+SvxShape* CreateSvxShapeByTypeAndInventor(sal_uInt16 nType, SdrInventor nInventor, OUString const & referer)
+{
+    return SvxDrawPage::CreateShapeByTypeAndInventor( nType, nInventor, nullptr, nullptr, referer );
+}
+
+/** returns a StarOffice API wrapper for the given SdrPage */
+uno::Reference< drawing::XDrawPage > GetXDrawPageForSdrPage( SdrPage* pPage ) throw ()
+{
+    if(pPage)
+    {
+        uno::Reference< drawing::XDrawPage > xDrawPage( pPage->getUnoPage(), uno::UNO_QUERY );
+
+        return xDrawPage;
+    }
+
+    return uno::Reference< drawing::XDrawPage >();
+}
+
+/** returns the SdrObject from the given StarOffice API wrapper */
+SdrPage* GetSdrPageFromXDrawPage( const uno::Reference< drawing::XDrawPage >& xDrawPage ) throw()
+{
+    if(xDrawPage.is())
+    {
+        SvxDrawPage* pDrawPage = comphelper::getUnoTunnelImplementation<SvxDrawPage>( xDrawPage );
+
+        if(pDrawPage)
+        {
+            return pDrawPage->GetSdrPage();
+        }
+    }
+
+    return nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unopool.cxx b/svx/source/unodraw/unopool.cxx
new file mode 100644
index 000000000..ec293ac1b
--- /dev/null
+++ b/svx/source/unodraw/unopool.cxx
@@ -0,0 +1,374 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/beans/PropertyState.hpp>
+
+#include <comphelper/propertysetinfo.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <vcl/svapp.hxx>
+#include <svx/unopool.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svdpool.hxx>
+#include <svx/unoprov.hxx>
+#include <svx/unoshprp.hxx>
+#include <svx/xflbstit.hxx>
+#include <svx/xflbmtit.hxx>
+#include <svx/svdetc.hxx>
+#include <editeng/editeng.hxx>
+#include <tools/debug.hxx>
+
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+SvxUnoDrawPool::SvxUnoDrawPool(SdrModel* pModel, sal_Int32 nServiceId)
+: PropertySetHelper( SvxPropertySetInfoPool::getOrCreate( nServiceId ) ), mpModel( pModel )
+{
+    init();
+}
+
+/* deprecated */
+SvxUnoDrawPool::SvxUnoDrawPool(SdrModel* pModel)
+: PropertySetHelper( SvxPropertySetInfoPool::getOrCreate( SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS ) ), mpModel( pModel )
+{
+    init();
+}
+
+SvxUnoDrawPool::~SvxUnoDrawPool() throw()
+{
+    if (mpDefaultsPool)
+    {
+        SfxItemPool* pOutlPool = mpDefaultsPool->GetSecondaryPool();
+        SfxItemPool::Free(mpDefaultsPool);
+        SfxItemPool::Free(pOutlPool);
+    }
+}
+
+void SvxUnoDrawPool::init()
+{
+    mpDefaultsPool = new SdrItemPool();
+    SfxItemPool* pOutlPool=EditEngine::CreatePool();
+    mpDefaultsPool->SetSecondaryPool(pOutlPool);
+
+    SdrModel::SetTextDefaults( mpDefaultsPool, SdrEngineDefaults::GetFontHeight() );
+    mpDefaultsPool->SetDefaultMetric(SdrEngineDefaults::GetMapUnit());
+    mpDefaultsPool->FreezeIdRanges();
+}
+
+SfxItemPool* SvxUnoDrawPool::getModelPool( bool bReadOnly ) throw()
+{
+    if( mpModel )
+    {
+        return &mpModel->GetItemPool();
+    }
+    else
+    {
+        if( bReadOnly )
+            return mpDefaultsPool;
+        else
+            return nullptr;
+    }
+}
+
+void SvxUnoDrawPool::getAny( SfxItemPool const * pPool, const comphelper::PropertyMapEntry* pEntry, uno::Any& rValue )
+{
+    switch( pEntry->mnHandle )
+    {
+    case OWN_ATTR_FILLBMP_MODE:
+        {
+            if (pPool->GetDefaultItem(XATTR_FILLBMP_TILE).GetValue())
+            {
+                rValue <<= drawing::BitmapMode_REPEAT;
+            }
+            else if (pPool->GetDefaultItem(XATTR_FILLBMP_STRETCH).GetValue())
+            {
+                rValue <<= drawing::BitmapMode_STRETCH;
+            }
+            else
+            {
+                rValue <<= drawing::BitmapMode_NO_REPEAT;
+            }
+            break;
+        }
+    default:
+        {
+            const MapUnit eMapUnit = pPool->GetMetric(static_cast<sal_uInt16>(pEntry->mnHandle));
+
+            sal_uInt8 nMemberId = pEntry->mnMemberId;
+            if( eMapUnit == MapUnit::Map100thMM )
+                nMemberId &= (~CONVERT_TWIPS);
+
+            // Assure, that ID is a Which-ID (it could be a Slot-ID.)
+            // Thus, convert handle to Which-ID.
+            pPool->GetDefaultItem( pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) ) ).QueryValue( rValue, nMemberId );
+        }
+    }
+
+
+    // check for needed metric translation
+    const MapUnit eMapUnit = pPool->GetMetric(static_cast<sal_uInt16>(pEntry->mnHandle));
+    if(pEntry->mnMoreFlags & PropertyMoreFlags::METRIC_ITEM && eMapUnit != MapUnit::Map100thMM)
+    {
+        SvxUnoConvertToMM( eMapUnit, rValue );
+    }
+    // convert int32 to correct enum type if needed
+    else if ( pEntry->maType.getTypeClass() == uno::TypeClass_ENUM && rValue.getValueType() == ::cppu::UnoType<sal_Int32>::get() )
+    {
+        sal_Int32 nEnum;
+        rValue >>= nEnum;
+
+        rValue.setValue( &nEnum, pEntry->maType );
+    }
+}
+
+void SvxUnoDrawPool::putAny( SfxItemPool* pPool, const comphelper::PropertyMapEntry* pEntry, const uno::Any& rValue )
+{
+    uno::Any aValue( rValue );
+
+    const MapUnit eMapUnit = pPool->GetMetric(static_cast<sal_uInt16>(pEntry->mnHandle));
+    if(pEntry->mnMoreFlags & PropertyMoreFlags::METRIC_ITEM && eMapUnit != MapUnit::Map100thMM)
+    {
+        SvxUnoConvertFromMM( eMapUnit, aValue );
+    }
+
+    // Assure, that ID is a Which-ID (it could be a Slot-ID.)
+    // Thus, convert handle to Which-ID.
+    const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) );
+    switch( nWhich )
+    {
+        case OWN_ATTR_FILLBMP_MODE:
+            do
+            {
+                drawing::BitmapMode eMode;
+                if(!(aValue >>= eMode) )
+                {
+                    sal_Int32 nMode = 0;
+                    if(!(aValue >>= nMode))
+                        throw lang::IllegalArgumentException();
+
+                    eMode = static_cast<drawing::BitmapMode>(nMode);
+                }
+
+                pPool->SetPoolDefaultItem( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) );
+                pPool->SetPoolDefaultItem( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) );
+                return;
+            }
+            while(false);
+
+    default:
+        {
+            std::unique_ptr<SfxPoolItem> pNewItem( pPool->GetDefaultItem( nWhich ).Clone() );
+            sal_uInt8 nMemberId = pEntry->mnMemberId;
+            if( pPool->GetMetric(nWhich) == MapUnit::Map100thMM )
+                nMemberId &= (~CONVERT_TWIPS);
+
+            if( !pNewItem->PutValue( aValue, nMemberId ) )
+                throw lang::IllegalArgumentException();
+
+            pPool->SetPoolDefaultItem( *pNewItem );
+        }
+    }
+}
+
+void SvxUnoDrawPool::_setPropertyValues( const comphelper::PropertyMapEntry** ppEntries, const uno::Any* pValues )
+{
+    SolarMutexGuard aGuard;
+
+    SfxItemPool* pPool = getModelPool( false );
+
+    DBG_ASSERT( pPool, "I need a SfxItemPool!" );
+    if( nullptr == pPool )
+        throw beans::UnknownPropertyException( "no pool, no properties..", static_cast<cppu::OWeakObject*>(this));
+
+    while( *ppEntries )
+        putAny( pPool, *ppEntries++, *pValues++ );
+}
+
+void SvxUnoDrawPool::_getPropertyValues( const comphelper::PropertyMapEntry** ppEntries, uno::Any* pValue )
+{
+    SolarMutexGuard aGuard;
+
+    SfxItemPool* pPool = getModelPool( true );
+
+    DBG_ASSERT( pPool, "I need a SfxItemPool!" );
+    if( nullptr == pPool )
+        throw beans::UnknownPropertyException( "no pool, no properties..", static_cast<cppu::OWeakObject*>(this));
+
+    while( *ppEntries )
+        getAny( pPool, *ppEntries++, *pValue++ );
+}
+
+void SvxUnoDrawPool::_getPropertyStates( const comphelper::PropertyMapEntry** ppEntries, beans::PropertyState* pStates )
+{
+    SolarMutexGuard aGuard;
+
+    SfxItemPool* pPool = getModelPool( true );
+
+    if( pPool && pPool != mpDefaultsPool )
+    {
+        while( *ppEntries )
+        {
+            //Assure, that ID is a Which-ID (it could be a Slot-ID.)
+            // Thus, convert handle to Which-ID.
+            const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>((*ppEntries)->mnHandle) );
+
+            switch( nWhich )
+            {
+            case OWN_ATTR_FILLBMP_MODE:
+                {
+                    // use method <IsStaticDefaultItem(..)> instead of using
+                    // probably incompatible item pool <mpDefaultPool>.
+                    if ( IsStaticDefaultItem( &(pPool->GetDefaultItem( XATTR_FILLBMP_STRETCH )) ) ||
+                         IsStaticDefaultItem( &(pPool->GetDefaultItem( XATTR_FILLBMP_TILE )) ) )
+                    {
+                        *pStates = beans::PropertyState_DEFAULT_VALUE;
+                    }
+                    else
+                    {
+                        *pStates = beans::PropertyState_DIRECT_VALUE;
+                    }
+                }
+                break;
+            default:
+                //#i18732# - correction:
+                // use method <IsStaticDefaultItem(..)> instead of using probably
+                // incompatible item pool <mpDefaultPool>.
+                const SfxPoolItem& r1 = pPool->GetDefaultItem( nWhich );
+                //const SfxPoolItem& r2 = mpDefaultPool->GetDefaultItem( nWhich );
+
+                if ( IsStaticDefaultItem( &r1 ) )
+                {
+                    *pStates = beans::PropertyState_DEFAULT_VALUE;
+                }
+                else
+                {
+                    *pStates = beans::PropertyState_DIRECT_VALUE;
+                }
+            }
+
+            pStates++;
+            ppEntries++;
+        }
+    }
+    else
+    {
+        // as long as we have no model, all properties are default
+        while( *ppEntries++ )
+            *pStates++ = beans::PropertyState_DEFAULT_VALUE;
+        return;
+    }
+}
+
+void SvxUnoDrawPool::_setPropertyToDefault( const comphelper::PropertyMapEntry* pEntry )
+{
+    SolarMutexGuard aGuard;
+
+    SfxItemPool* pPool = getModelPool( true );
+
+    // Assure, that ID is a Which-ID (it could be a Slot-ID.)
+    // Thus, convert handle to Which-ID.
+    const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) );
+    if ( pPool && pPool != mpDefaultsPool )
+    {
+        // use method <ResetPoolDefaultItem(..)> instead of using probably incompatible item pool <mpDefaultsPool>.
+        pPool->ResetPoolDefaultItem( nWhich );
+    }
+}
+
+uno::Any SvxUnoDrawPool::_getPropertyDefault( const comphelper::PropertyMapEntry* pEntry )
+{
+    SolarMutexGuard aGuard;
+    //#i18732# - use method <GetPoolDefaultItem(..)> instead of
+    // using probably incompatible item pool <mpDefaultsPool>
+    uno::Any aAny;
+    SfxItemPool* pPool = getModelPool( true );
+    const sal_uInt16 nWhich = pPool->GetWhich( static_cast<sal_uInt16>(pEntry->mnHandle) );
+    const SfxPoolItem *pItem = pPool->GetPoolDefaultItem ( nWhich );
+    if (pItem)
+    {
+        pItem->QueryValue( aAny, pEntry->mnMemberId );
+    }
+
+    return aAny;
+}
+
+// XInterface
+
+uno::Any SAL_CALL SvxUnoDrawPool::queryInterface( const uno::Type & rType )
+{
+    return OWeakAggObject::queryInterface( rType );
+}
+
+uno::Any SAL_CALL SvxUnoDrawPool::queryAggregation( const uno::Type & rType )
+{
+    uno::Any aAny;
+
+    if( rType == cppu::UnoType<lang::XServiceInfo>::get())
+        aAny <<= uno::Reference< lang::XServiceInfo >(this);
+    else if( rType == cppu::UnoType<lang::XTypeProvider>::get())
+        aAny <<= uno::Reference< lang::XTypeProvider >(this);
+    else if( rType == cppu::UnoType<beans::XPropertySet>::get())
+        aAny <<= uno::Reference< beans::XPropertySet >(this);
+    else if( rType == cppu::UnoType<beans::XPropertyState>::get())
+        aAny <<= uno::Reference< beans::XPropertyState >(this);
+    else if( rType == cppu::UnoType<beans::XMultiPropertySet>::get())
+        aAny <<= uno::Reference< beans::XMultiPropertySet >(this);
+    else
+        aAny = OWeakAggObject::queryAggregation( rType );
+
+    return aAny;
+}
+
+uno::Sequence< uno::Type > SAL_CALL SvxUnoDrawPool::getTypes()
+{
+    static const uno::Sequence aTypes {
+        cppu::UnoType<uno::XAggregation>::get(),
+        cppu::UnoType<lang::XServiceInfo>::get(),
+        cppu::UnoType<lang::XTypeProvider>::get(),
+        cppu::UnoType<beans::XPropertySet>::get(),
+        cppu::UnoType<beans::XPropertyState>::get(),
+        cppu::UnoType<beans::XMultiPropertySet>::get() };
+    return aTypes;
+}
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxUnoDrawPool::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+// XServiceInfo
+sal_Bool SAL_CALL SvxUnoDrawPool::supportsService( const  OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+OUString SAL_CALL SvxUnoDrawPool::getImplementationName()
+{
+    return "SvxUnoDrawPool";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoDrawPool::getSupportedServiceNames(  )
+{
+    uno::Sequence<OUString> aSNS { "com.sun.star.drawing.Defaults" };
+    return aSNS;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoprov.cxx b/svx/source/unodraw/unoprov.cxx
new file mode 100644
index 000000000..037c5898b
--- /dev/null
+++ b/svx/source/unodraw/unoprov.cxx
@@ -0,0 +1,2047 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/macros.h>
+#include <com/sun/star/table/XTable.hpp>
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/util/MeasureUnit.hpp>
+#include <com/sun/star/drawing/TextVerticalAdjust.hpp>
+#include <com/sun/star/media/ZoomLevel.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/lang/Locale.hpp>
+#include <tools/fldunit.hxx>
+#include <vcl/svapp.hxx>
+#include <comphelper/propertysetinfo.hxx>
+#include <comphelper/sequence.hxx>
+#include <svx/dialmgr.hxx>
+#include <svx/unoapi.hxx>
+#include <svx/unoshprp.hxx>
+#include <svx/svx3ditems.hxx>
+#include <svx/svxids.hrc>
+#include <svx/globl3d.hxx>
+#include <svx/strings.hrc>
+#include <strings.hxx>
+#include <svx/svdobj.hxx>
+
+#include "shapeimpl.hxx"
+#include <unordered_map>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans::PropertyAttribute;
+using ::com::sun::star::drawing::TextVerticalAdjust;
+
+static SfxItemPropertyMapEntry const * ImplGetSvxShapePropertyMap()
+{
+    static SfxItemPropertyMapEntry const aShapePropertyMap_Impl[] =
+    {
+        EDGERADIUS_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aShapePropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxTextShapePropertyMap()
+{
+    static SfxItemPropertyMapEntry const aTextShapePropertyMap_Impl[] =
+    {
+        EDGERADIUS_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES_NO_SHEAR
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aTextShapePropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxConnectorPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aConnectorPropertyMap_Impl[] =
+    {
+        SPECIAL_CONNECTOR_PROPERTIES
+        EDGERADIUS_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aConnectorPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxDimensioningPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aDimensioningPropertyMap_Impl[] =
+    {
+        SPECIAL_DIMENSIONING_PROPERTIES
+        EDGERADIUS_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aDimensioningPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxCirclePropertyMap()
+{
+    static SfxItemPropertyMapEntry const aCirclePropertyMap_Impl[] =
+    {
+        SPECIAL_CIRCLE_PROPERTIES
+        EDGERADIUS_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aCirclePropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxPolyPolygonPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aPolyPolygonPropertyMap_Impl[] =
+    {
+        { OUString("Geometry"), OWN_ATTR_BASE_GEOMETRY, cppu::UnoType<css::drawing::PointSequenceSequence>::get(), 0, 0 },
+        SPECIAL_POLYGON_PROPERTIES
+        SPECIAL_POLYPOLYGON_PROPERTIES
+        SPECIAL_POLYPOLYGONBEZIER_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aPolyPolygonPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxGraphicObjectPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aGraphicObjectPropertyMap_Impl[] =
+    {
+        SPECIAL_GRAPHOBJ_PROPERTIES
+
+        // #i25616#
+        FILL_PROPERTIES
+
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+
+        // #i118485# Full properties now, shear included
+        MISC_OBJ_PROPERTIES
+
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("IsMirrored"), OWN_ATTR_MIRRORED, cppu::UnoType<bool>::get(), 0, 0},
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("GraphicStream"), OWN_ATTR_GRAPHIC_STREAM, cppu::UnoType<css::io::XInputStream>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aGraphicObjectPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvx3DSceneObjectPropertyMap()
+{
+    static SfxItemPropertyMapEntry const a3DSceneObjectPropertyMap_Impl[] =
+    {
+        SPECIAL_3DSCENEOBJECT_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SHADOW_PROPERTIES
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return a3DSceneObjectPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvx3DCubeObjectPropertyMap()
+{
+    static SfxItemPropertyMapEntry const a3DCubeObjectPropertyMap_Impl[] =
+    {
+        SPECIAL_3DCUBEOBJECT_PROPERTIES
+        MISC_3D_OBJ_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SHADOW_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return a3DCubeObjectPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvx3DSphereObjectPropertyMap()
+{
+    static SfxItemPropertyMapEntry const a3DSphereObjectPropertyMap_Impl[] =
+    {
+        SPECIAL_3DSPHEREOBJECT_PROPERTIES
+        MISC_3D_OBJ_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SHADOW_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+    return a3DSphereObjectPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvx3DLatheObjectPropertyMap()
+{
+    static SfxItemPropertyMapEntry const a3DLatheObjectPropertyMap_Impl[] =
+    {
+        SPECIAL_3DLATHEOBJECT_PROPERTIES
+
+        // #107245# New 3D properties which are possible for lathe and extrude 3d objects
+        SPECIAL_3DLATHEANDEXTRUDEOBJ_PROPERTIES
+
+        SPECIAL_3DBACKSCALE_PROPERTIES
+        MISC_3D_OBJ_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SHADOW_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return a3DLatheObjectPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvx3DExtrudeObjectPropertyMap()
+{
+    static SfxItemPropertyMapEntry const a3DExtrudeObjectPropertyMap_Impl[] =
+    {
+        SPECIAL_3DEXTRUDEOBJECT_PROPERTIES
+
+        // #107245# New 3D properties which are possible for lathe and extrude 3d objects
+        SPECIAL_3DLATHEANDEXTRUDEOBJ_PROPERTIES
+
+        SPECIAL_3DBACKSCALE_PROPERTIES
+        MISC_3D_OBJ_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SHADOW_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return a3DExtrudeObjectPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvx3DPolygonObjectPropertyMap()
+{
+    static SfxItemPropertyMapEntry const a3DPolygonObjectPropertyMap_Impl[] =
+    {
+        SPECIAL_3DPOLYGONOBJECT_PROPERTIES
+        MISC_3D_OBJ_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SHADOW_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return a3DPolygonObjectPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxAllPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aAllPropertyMap_Impl[] =
+    {
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        FILL_PROPERTIES
+        EDGERADIUS_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SPECIAL_CONNECTOR_PROPERTIES
+        SPECIAL_DIMENSIONING_PROPERTIES
+        SPECIAL_CIRCLE_PROPERTIES
+        SPECIAL_POLYGON_PROPERTIES
+        SPECIAL_POLYPOLYGON_PROPERTIES
+        SPECIAL_POLYPOLYGONBEZIER_PROPERTIES
+        SPECIAL_GRAPHOBJ_PROPERTIES
+        SPECIAL_3DSCENEOBJECT_PROPERTIES
+        MISC_3D_OBJ_PROPERTIES
+        SPECIAL_3DCUBEOBJECT_PROPERTIES
+        SPECIAL_3DSPHEREOBJECT_PROPERTIES
+        SPECIAL_3DLATHEOBJECT_PROPERTIES
+        SPECIAL_3DEXTRUDEOBJECT_PROPERTIES
+
+        // #107245# New 3D properties which are possible for lathe and extrude 3d objects
+        SPECIAL_3DLATHEANDEXTRUDEOBJ_PROPERTIES
+
+        SPECIAL_3DBACKSCALE_PROPERTIES
+        SPECIAL_3DPOLYGONOBJECT_PROPERTIES
+        { OUString("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS, cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aAllPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxGroupPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aGroupPropertyMap_Impl[] =
+    {
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aGroupPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxOle2PropertyMap()
+{
+    static SfxItemPropertyMapEntry const aOle2PropertyMap_Impl[] =
+    {
+        // #i118485# Adding properties for line, fill, text, shadow, fontwork, rotate, shear
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        FONTWORK_PROPERTIES
+
+        { OUString("ThumbnailGraphic"),         OWN_ATTR_THUMBNAIL          , cppu::UnoType<css::graphic::XGraphic>::get(), 0, 0 },
+        { OUString("Model"),                    OWN_ATTR_OLEMODEL           , cppu::UnoType<css::frame::XModel>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("EmbeddedObject"),           OWN_ATTR_OLE_EMBEDDED_OBJECT, cppu::UnoType<css::embed::XEmbeddedObject>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("EmbeddedObjectNoNewClient"),OWN_ATTR_OLE_EMBEDDED_OBJECT_NONEWCLIENT, cppu::UnoType<css::embed::XEmbeddedObject>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("OriginalSize"),             OWN_ATTR_OLESIZE            , cppu::UnoType<css::awt::Size>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("CLSID"),                    OWN_ATTR_CLSID              , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString("IsInternal"),               OWN_ATTR_INTERNAL_OLE       , cppu::UnoType<bool>::get() , css::beans::PropertyAttribute::READONLY,     0},
+        { OUString("VisibleArea"),              OWN_ATTR_OLE_VISAREA        , cppu::UnoType<css::awt::Rectangle>::get(), 0, 0},
+        { OUString("Aspect"),                   OWN_ATTR_OLE_ASPECT         , cppu::UnoType<sal_Int64>::get(), 0, 0},
+        { OUString(UNO_NAME_OLE2_PERSISTNAME),  OWN_ATTR_PERSISTNAME        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString("LinkURL"),                  OWN_ATTR_OLE_LINKURL        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString(UNO_NAME_GRAPHOBJ_GRAPHIC),   OWN_ATTR_VALUE_GRAPHIC     , cppu::UnoType<css::graphic::XGraphic>::get(),     0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aOle2PropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxPluginPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aPluginPropertyMap_Impl[] =
+    {
+        { OUString("PluginMimeType"),           OWN_ATTR_PLUGIN_MIMETYPE    , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString("PluginURL"),                OWN_ATTR_PLUGIN_URL         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString("PluginCommands"),           OWN_ATTR_PLUGIN_COMMANDS    , cppu::UnoType<css::uno::Sequence< css::beans::PropertyValue >>::get(), 0, 0},
+        { OUString("Transformation"),           OWN_ATTR_TRANSFORMATION     , cppu::UnoType<css::drawing::HomogenMatrix3>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_ZORDER),   OWN_ATTR_ZORDER             , cppu::UnoType<sal_Int32>::get(),      0,      0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERID),  SDRATTR_LAYERID             , cppu::UnoType<sal_Int16>::get(),      0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERNAME),SDRATTR_LAYERNAME           , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_LINKDISPLAYBITMAP), OWN_ATTR_LDBITMAP           , cppu::UnoType<css::awt::XBitmap>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_LINKDISPLAYNAME),   OWN_ATTR_LDNAME             , cppu::UnoType<OUString>::get(),   css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_OLE2_METAFILE),     OWN_ATTR_METAFILE           , cppu::UnoType<css::uno::Sequence<sal_Int8>>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("ThumbnailGraphic"),         OWN_ATTR_THUMBNAIL          , cppu::UnoType<css::graphic::XGraphic>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_MOVEPROTECT),      SDRATTR_OBJMOVEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_SIZEPROTECT),      SDRATTR_OBJSIZEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_OLE2_PERSISTNAME),  OWN_ATTR_PERSISTNAME        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString("LinkURL"),                  OWN_ATTR_OLE_LINKURL        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_BOUNDRECT), OWN_ATTR_BOUNDRECT,            cppu::UnoType<css::awt::Rectangle>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("VisibleArea"),              OWN_ATTR_OLE_VISAREA        , cppu::UnoType<css::awt::Rectangle>::get(), 0, 0},
+        { OUString("UINameSingular"),               OWN_ATTR_UINAME_SINGULAR        , ::cppu::UnoType<OUString>::get(),    css::beans::PropertyAttribute::READONLY,   0},
+        // #i68101#
+        { OUString(UNO_NAME_MISC_OBJ_TITLE),        OWN_ATTR_MISC_OBJ_TITLE         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_DESCRIPTION),  OWN_ATTR_MISC_OBJ_DESCRIPTION   , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aPluginPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxFramePropertyMap()
+{
+    //TODO/LATER: new properties for ScrollingMode and DefaultBorder
+    static SfxItemPropertyMapEntry const aFramePropertyMap_Impl[] =
+    {
+        { OUString("FrameURL"),                 OWN_ATTR_FRAME_URL          , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString("FrameName"),                OWN_ATTR_FRAME_NAME         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString("FrameIsAutoScroll"),        OWN_ATTR_FRAME_ISAUTOSCROLL , cppu::UnoType<bool>::get() , css::beans::PropertyAttribute::MAYBEVOID, 0},
+        { OUString("FrameIsBorder"),            OWN_ATTR_FRAME_ISBORDER     , cppu::UnoType<bool>::get() , 0, 0},
+        { OUString("FrameMarginWidth"),         OWN_ATTR_FRAME_MARGIN_WIDTH , cppu::UnoType<sal_Int32>::get(),      0,      0},
+        { OUString("FrameMarginHeight"),        OWN_ATTR_FRAME_MARGIN_HEIGHT, cppu::UnoType<sal_Int32>::get(),      0,      0},
+        { OUString("Transformation"),           OWN_ATTR_TRANSFORMATION     , cppu::UnoType<css::drawing::HomogenMatrix3>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_ZORDER),   OWN_ATTR_ZORDER             , cppu::UnoType<sal_Int32>::get(),      0,      0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERID),  SDRATTR_LAYERID             , cppu::UnoType<sal_Int16>::get(),      0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERNAME),SDRATTR_LAYERNAME           , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_LINKDISPLAYBITMAP), OWN_ATTR_LDBITMAP           , cppu::UnoType<css::awt::XBitmap>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_LINKDISPLAYNAME),   OWN_ATTR_LDNAME             , cppu::UnoType<OUString>::get(),   css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_OLE2_METAFILE),     OWN_ATTR_METAFILE           , cppu::UnoType<css::uno::Sequence<sal_Int8>>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("ThumbnailGraphic"),         OWN_ATTR_THUMBNAIL          , cppu::UnoType<css::graphic::XGraphic>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_MOVEPROTECT),      SDRATTR_OBJMOVEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_SIZEPROTECT),      SDRATTR_OBJSIZEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_OLE2_PERSISTNAME),  OWN_ATTR_PERSISTNAME        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString("LinkURL"),                  OWN_ATTR_OLE_LINKURL        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_BOUNDRECT), OWN_ATTR_BOUNDRECT,            cppu::UnoType<css::awt::Rectangle>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("VisibleArea"),              OWN_ATTR_OLE_VISAREA        , cppu::UnoType<css::awt::Rectangle>::get(), 0, 0},
+        { OUString("UINameSingular"),               OWN_ATTR_UINAME_SINGULAR        , ::cppu::UnoType<OUString>::get(),    css::beans::PropertyAttribute::READONLY,   0},
+        // #i68101#
+        { OUString(UNO_NAME_MISC_OBJ_TITLE),        OWN_ATTR_MISC_OBJ_TITLE         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_DESCRIPTION),  OWN_ATTR_MISC_OBJ_DESCRIPTION   , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aFramePropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxAppletPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aAppletPropertyMap_Impl[] =
+    {
+        { OUString("AppletCodeBase"),           OWN_ATTR_APPLET_CODEBASE    , cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString("AppletName"),               OWN_ATTR_APPLET_NAME        , cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString("AppletCode"),               OWN_ATTR_APPLET_CODE        , cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString("AppletCommands"),           OWN_ATTR_APPLET_COMMANDS    , cppu::UnoType<css::uno::Sequence< css::beans::PropertyValue >>::get(), 0, 0},
+        { OUString("AppletDocBase"),            OWN_ATTR_APPLET_DOCBASE     , cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString("AppletIsScript"),           OWN_ATTR_APPLET_ISSCRIPT    , cppu::UnoType<bool>::get(), 0, 0 },
+        { OUString("Transformation"),           OWN_ATTR_TRANSFORMATION     , cppu::UnoType<css::drawing::HomogenMatrix3>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_ZORDER),   OWN_ATTR_ZORDER             , cppu::UnoType<sal_Int32>::get(),      0,      0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERID),  SDRATTR_LAYERID             , cppu::UnoType<sal_Int16>::get(),      0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERNAME),SDRATTR_LAYERNAME           , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_LINKDISPLAYBITMAP), OWN_ATTR_LDBITMAP           , cppu::UnoType<css::awt::XBitmap>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_LINKDISPLAYNAME),   OWN_ATTR_LDNAME             , cppu::UnoType<OUString>::get(),   css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_OLE2_METAFILE),     OWN_ATTR_METAFILE           , cppu::UnoType<css::uno::Sequence<sal_Int8>>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("ThumbnailGraphic"),         OWN_ATTR_THUMBNAIL          , cppu::UnoType<css::graphic::XGraphic>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_MOVEPROTECT),      SDRATTR_OBJMOVEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_SIZEPROTECT),      SDRATTR_OBJSIZEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_OLE2_PERSISTNAME),  OWN_ATTR_PERSISTNAME        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString("LinkURL"),                  OWN_ATTR_OLE_LINKURL        , cppu::UnoType<OUString>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_BOUNDRECT), OWN_ATTR_BOUNDRECT,            cppu::UnoType<css::awt::Rectangle>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("VisibleArea"),              OWN_ATTR_OLE_VISAREA        , cppu::UnoType<css::awt::Rectangle>::get(), 0, 0},
+        { OUString("UINameSingular"),               OWN_ATTR_UINAME_SINGULAR        , ::cppu::UnoType<OUString>::get(),    css::beans::PropertyAttribute::READONLY,   0},
+        // #i68101#
+        { OUString(UNO_NAME_MISC_OBJ_TITLE),        OWN_ATTR_MISC_OBJ_TITLE         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_DESCRIPTION),  OWN_ATTR_MISC_OBJ_DESCRIPTION   , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aAppletPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxControlShapePropertyMap()
+{
+    static SfxItemPropertyMapEntry const aControlPropertyMap_Impl[] =
+    {
+        // the following properties are mapped to the XControl Model of this shape
+        { OUString(UNO_NAME_EDIT_CHAR_FONTNAME),        0,  cppu::UnoType<OUString>::get(),  0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_FONTSTYLENAME),   0,  cppu::UnoType<OUString>::get(),  0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_FONTFAMILY),      0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_FONTCHARSET),     0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_HEIGHT),          0,  cppu::UnoType<float>::get(),            0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_FONTPITCH),       0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_POSTURE),         0,  cppu::UnoType<css::awt::FontSlant>::get(),0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_WEIGHT),          0,  cppu::UnoType<float>::get(),            0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_UNDERLINE),       0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_STRIKEOUT),       0,  cppu::UnoType<sal_Int16>::get(),        0, 0},
+        { OUString(UNO_NAME_EDIT_CHAR_CASEMAP),         0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString(UNO_NAME_EDIT_CHAR_COLOR),           0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
+        { OUString("CharBackColor"),                    0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
+        { OUString("CharBackTransparent"),              0,  cppu::UnoType<bool>::get(),             0, 0 },
+        { OUString("CharRelief"),                       0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString("CharUnderlineColor"),               0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
+        { OUString("CharKerning"),                      0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString("CharWordMode"),                     0,  cppu::UnoType<bool>::get(),                    0, 0 },
+        { OUString(UNO_NAME_EDIT_PARA_ADJUST),          0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString("TextVerticalAdjust"),               0,  cppu::UnoType<TextVerticalAdjust>::get(), MAYBEVOID, 0 },
+        { OUString("ControlBackground"),                0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
+        { OUString("ControlBorder"),                    0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString("ControlBorderColor"),               0,  cppu::UnoType<sal_Int32>::get(),        0, 0 },
+        { OUString("ControlSymbolColor"),               0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString("ImageScaleMode"),                   0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_MOVEPROTECT),      SDRATTR_OBJMOVEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_SIZEPROTECT),      SDRATTR_OBJSIZEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString("ControlTextEmphasis"),              0,  cppu::UnoType<sal_Int16>::get(),        0, 0 },
+        { OUString("ControlWritingMode"),               0,  cppu::UnoType< sal_Int16 >::get(), 0, 0},
+        // the following properties are handled by SvxShape
+        { OUString("Transformation"),           OWN_ATTR_TRANSFORMATION     , cppu::UnoType<css::drawing::HomogenMatrix3>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_ZORDER),   OWN_ATTR_ZORDER             , cppu::UnoType<sal_Int32>::get(),      0,      0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERID),  SDRATTR_LAYERID             , cppu::UnoType<sal_Int16>::get(),      0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERNAME),SDRATTR_LAYERNAME           , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_LINKDISPLAYBITMAP), OWN_ATTR_LDBITMAP           , cppu::UnoType<css::awt::XBitmap>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_LINKDISPLAYNAME),   OWN_ATTR_LDNAME             , cppu::UnoType<OUString>::get(),   css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("UserDefinedAttributes"),        SDRATTR_XMLATTRIBUTES,      cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        {OUString("ParaUserDefinedAttributes"),         EE_PARA_XMLATTRIBS,     cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(UNO_NAME_MISC_OBJ_BOUNDRECT), OWN_ATTR_BOUNDRECT,            cppu::UnoType<css::awt::Rectangle>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("UINameSingular"),               OWN_ATTR_UINAME_SINGULAR        , ::cppu::UnoType<OUString>::get(),    css::beans::PropertyAttribute::READONLY,   0},
+        // #i68101#
+        { OUString(UNO_NAME_MISC_OBJ_TITLE),        OWN_ATTR_MISC_OBJ_TITLE         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_DESCRIPTION),  OWN_ATTR_MISC_OBJ_DESCRIPTION   , cppu::UnoType<OUString>::get(),    0,  0},
+        // #i112587#
+        { OUString(UNO_NAME_MISC_OBJ_PRINTABLE),    SDRATTR_OBJPRINTABLE            , cppu::UnoType<bool>::get(),                      0,  0},
+        { OUString("Visible"),                      SDRATTR_OBJVISIBLE              , cppu::UnoType<bool>::get(),                      0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_INTEROPGRABBAG),   OWN_ATTR_INTEROPGRABBAG,    cppu::UnoType<css::uno::Sequence< css::beans::PropertyValue >>::get(),  0,  0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aControlPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxPageShapePropertyMap()
+{
+    static SfxItemPropertyMapEntry const aPageShapePropertyMap_Impl[] =
+    {
+        { OUString("PageNumber"),               OWN_ATTR_PAGE_NUMBER        , cppu::UnoType<sal_Int32>::get(),      0, 0},
+        { OUString("Transformation"),           OWN_ATTR_TRANSFORMATION     , cppu::UnoType<css::drawing::HomogenMatrix3>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_ZORDER),   OWN_ATTR_ZORDER             , cppu::UnoType<sal_Int32>::get(),      0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERID),  SDRATTR_LAYERID             , cppu::UnoType<sal_Int16>::get(),      0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERNAME),SDRATTR_LAYERNAME           , cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString(UNO_NAME_LINKDISPLAYBITMAP), OWN_ATTR_LDBITMAP           , cppu::UnoType<css::awt::XBitmap>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_LINKDISPLAYNAME),   OWN_ATTR_LDNAME             , cppu::UnoType<OUString>::get(),   css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_MISC_OBJ_MOVEPROTECT),      SDRATTR_OBJMOVEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_SIZEPROTECT),      SDRATTR_OBJSIZEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_BOUNDRECT), OWN_ATTR_BOUNDRECT,            cppu::UnoType<css::awt::Rectangle>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        // #i68101#
+        { OUString(UNO_NAME_MISC_OBJ_TITLE),        OWN_ATTR_MISC_OBJ_TITLE         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_DESCRIPTION),  OWN_ATTR_MISC_OBJ_DESCRIPTION   , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aPageShapePropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxCaptionPropertyMap()
+{
+    static SfxItemPropertyMapEntry const aCaptionPropertyMap_Impl[] =
+    {
+        { OUString("CaptionPoint"),             OWN_ATTR_CAPTION_POINT,     cppu::UnoType<css::awt::Point>::get(),   0, 0 },
+        { OUString("CaptionType"),              SDRATTR_CAPTIONTYPE,        cppu::UnoType<sal_Int16>::get(), 0, 0},
+        { OUString("CaptionIsFixedAngle"),      SDRATTR_CAPTIONFIXEDANGLE,  cppu::UnoType<bool>::get(), 0, 0},
+        { OUString("CaptionAngle"),             SDRATTR_CAPTIONANGLE,       cppu::UnoType<sal_Int32>::get(),    0,  0},
+        { OUString("CaptionGap"),               SDRATTR_CAPTIONGAP,         cppu::UnoType<sal_Int32>::get(),    0,  0, PropertyMoreFlags::METRIC_ITEM},
+        { OUString("CaptionEscapeDirection"),   SDRATTR_CAPTIONESCDIR,      cppu::UnoType<sal_Int32>::get(),    0,  0},
+        { OUString("CaptionIsEscapeRelative"),  SDRATTR_CAPTIONESCISREL,    cppu::UnoType<bool>::get(), 0, 0},
+        { OUString("CaptionEscapeRelative"),    SDRATTR_CAPTIONESCREL,      cppu::UnoType<sal_Int32>::get(),    0,  0},
+        { OUString("CaptionEscapeAbsolute"),    SDRATTR_CAPTIONESCABS,      cppu::UnoType<sal_Int32>::get(),    0,  0, PropertyMoreFlags::METRIC_ITEM},
+        { OUString("CaptionLineLength"),        SDRATTR_CAPTIONLINELEN,     cppu::UnoType<sal_Int32>::get(),    0,  0, PropertyMoreFlags::METRIC_ITEM},
+        { OUString("CaptionIsFitLineLength"),   SDRATTR_CAPTIONFITLINELEN,  cppu::UnoType<bool>::get(), 0, 0},
+        EDGERADIUS_PROPERTIES
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        // #FontWork#
+        FONTWORK_PROPERTIES
+        { OUString("UserDefinedAttributes"),        SDRATTR_XMLATTRIBUTES,      cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        {OUString("ParaUserDefinedAttributes"),         EE_PARA_XMLATTRIBS,     cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aCaptionPropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxCustomShapePropertyMap()
+{
+    static SfxItemPropertyMapEntry const aCustomShapePropertyMap_Impl[] =
+    {
+        { OUString("CustomShapeEngine"),            SDRATTR_CUSTOMSHAPE_ENGINE,         cppu::UnoType<OUString>::get(),  0, 0 },
+        { OUString("CustomShapeData"),          SDRATTR_CUSTOMSHAPE_DATA,               cppu::UnoType<OUString>::get(),  0, 0 },
+        { OUString("CustomShapeGeometry"),      SDRATTR_CUSTOMSHAPE_GEOMETRY,
+        cppu::UnoType<css::uno::Sequence< css::beans::PropertyValue >>::get(),  0, 0 },
+        FILL_PROPERTIES
+        LINE_PROPERTIES
+        LINE_PROPERTIES_START_END
+        SHAPE_DESCRIPTOR_PROPERTIES
+        MISC_OBJ_PROPERTIES
+        LINKTARGET_PROPERTIES
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        TEXT_PROPERTIES
+        {OUString("UserDefinedAttributes"),     SDRATTR_XMLATTRIBUTES,      cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        {OUString("ParaUserDefinedAttributes"), EE_PARA_XMLATTRIBS,         cppu::UnoType<css::container::XNameContainer>::get(),        0,     0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+    return aCustomShapePropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxMediaShapePropertyMap()
+{
+    static SfxItemPropertyMapEntry const aMediaShapePropertyMap_Impl[] =
+    {
+        { OUString(UNO_NAME_MISC_OBJ_ZORDER), OWN_ATTR_ZORDER, cppu::UnoType<sal_Int32>::get(), 0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERID), SDRATTR_LAYERID, cppu::UnoType<sal_Int16>::get(), 0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERNAME), SDRATTR_LAYERNAME, cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString(UNO_NAME_LINKDISPLAYBITMAP), OWN_ATTR_LDBITMAP, cppu::UnoType<css::awt::XBitmap>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_LINKDISPLAYNAME), OWN_ATTR_LDNAME, cppu::UnoType<OUString>::get(),  css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("Transformation"), OWN_ATTR_TRANSFORMATION, cppu::UnoType<css::drawing::HomogenMatrix3>::get(), 0, 0 },
+        { OUString("MediaURL"), OWN_ATTR_MEDIA_URL, cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString("PreferredSize"), OWN_ATTR_MEDIA_PREFERREDSIZE, cppu::UnoType<css::awt::Size>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("Loop"), OWN_ATTR_MEDIA_LOOP, cppu::UnoType<sal_Bool>::get(), 0, 0},
+        { OUString("Mute"), OWN_ATTR_MEDIA_MUTE, cppu::UnoType<sal_Bool>::get(), 0, 0},
+        { OUString("VolumeDB"), OWN_ATTR_MEDIA_VOLUMEDB, cppu::UnoType<sal_Int16>::get(), 0, 0},
+        { OUString("Zoom"), OWN_ATTR_MEDIA_ZOOM, cppu::UnoType<css::media::ZoomLevel>::get(), 0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_MOVEPROTECT), SDRATTR_OBJMOVEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_SIZEPROTECT), SDRATTR_OBJSIZEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_BOUNDRECT), OWN_ATTR_BOUNDRECT, cppu::UnoType<css::awt::Rectangle>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("UINameSingular"),               OWN_ATTR_UINAME_SINGULAR        , ::cppu::UnoType<OUString>::get(),    css::beans::PropertyAttribute::READONLY,   0},
+        // #i68101#
+        { OUString(UNO_NAME_MISC_OBJ_TITLE),        OWN_ATTR_MISC_OBJ_TITLE         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_DESCRIPTION),  OWN_ATTR_MISC_OBJ_DESCRIPTION   , cppu::UnoType<OUString>::get(),    0,  0},
+        {OUString("PrivateStream"), OWN_ATTR_MEDIA_STREAM, cppu::UnoType<css::io::XInputStream>::get(), 0, 0},
+        {OUString("PrivateTempFileURL"), OWN_ATTR_MEDIA_TEMPFILEURL, cppu::UnoType<OUString>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("MediaMimeType"), OWN_ATTR_MEDIA_MIMETYPE, cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString("FallbackGraphic"), OWN_ATTR_FALLBACK_GRAPHIC, cppu::UnoType<css::graphic::XGraphic>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aMediaShapePropertyMap_Impl;
+}
+
+static SfxItemPropertyMapEntry const * ImplGetSvxTableShapePropertyMap()
+{
+    static SfxItemPropertyMapEntry const  aTableShapePropertyMap_Impl[] =
+    {
+        { OUString(UNO_NAME_MISC_OBJ_ZORDER),       OWN_ATTR_ZORDER, cppu::UnoType<sal_Int32>::get(), 0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERID),      SDRATTR_LAYERID, cppu::UnoType<sal_Int16>::get(), 0,    0},
+        { OUString(UNO_NAME_MISC_OBJ_LAYERNAME),    SDRATTR_LAYERNAME, cppu::UnoType<OUString>::get(), 0, 0},
+        { OUString(UNO_NAME_LINKDISPLAYBITMAP),     OWN_ATTR_LDBITMAP, cppu::UnoType<css::awt::XBitmap>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_LINKDISPLAYNAME),       OWN_ATTR_LDNAME, cppu::UnoType<OUString>::get(),    css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("Transformation"),               OWN_ATTR_TRANSFORMATION, cppu::UnoType<css::drawing::HomogenMatrix3>::get(), 0, 0 },
+        { OUString(UNO_NAME_MISC_OBJ_MOVEPROTECT),  SDRATTR_OBJMOVEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_SIZEPROTECT),  SDRATTR_OBJSIZEPROTECT, cppu::UnoType<bool>::get(),0, 0},
+        { OUString(UNO_NAME_MISC_OBJ_BOUNDRECT),    OWN_ATTR_BOUNDRECT, cppu::UnoType<css::awt::Rectangle>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(UNO_NAME_MISC_OBJ_NAME),         SDRATTR_OBJECTNAME, cppu::UnoType<OUString>::get(),    0,      0},
+        { OUString("UINameSingular"),               OWN_ATTR_UINAME_SINGULAR        , ::cppu::UnoType<OUString>::get(),    css::beans::PropertyAttribute::READONLY,   0},
+        { OUString(UNO_NAME_MISC_OBJ_TITLE),        OWN_ATTR_MISC_OBJ_TITLE         , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString(UNO_NAME_MISC_OBJ_DESCRIPTION),  OWN_ATTR_MISC_OBJ_DESCRIPTION   , cppu::UnoType<OUString>::get(),    0,  0},
+        { OUString("Model"),                        OWN_ATTR_OLEMODEL               , cppu::UnoType<css::table::XTable>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString("TableTemplate"),                OWN_ATTR_TABLETEMPLATE          , cppu::UnoType<css::container::XIndexAccess>::get(), 0, 0},
+        { OUString("UseFirstRowStyle"),             OWN_ATTR_TABLETEMPLATE_FIRSTROW, cppu::UnoType<bool>::get(),0, 0},
+        { OUString("UseLastRowStyle"),              OWN_ATTR_TABLETEMPLATE_LASTROW, cppu::UnoType<bool>::get(),0, 0},
+        { OUString("UseFirstColumnStyle"),          OWN_ATTR_TABLETEMPLATE_FIRSTCOLUMN, cppu::UnoType<bool>::get(),0, 0},
+        { OUString("UseLastColumnStyle"),           OWN_ATTR_TABLETEMPLATE_LASTCOLUMN, cppu::UnoType<bool>::get(),0, 0},
+        { OUString("UseBandingRowStyle"),           OWN_ATTR_TABLETEMPLATE_BANDINGROWS, cppu::UnoType<bool>::get(),0, 0},
+        { OUString("UseBandingColumnStyle"),        OWN_ATTR_TABLETEMPLATE_BANDINGCOULUMNS, cppu::UnoType<bool>::get(),0, 0},
+        { OUString("ReplacementGraphic"),           OWN_ATTR_REPLACEMENT_GRAPHIC, cppu::UnoType<css::graphic::XGraphic>::get(), css::beans::PropertyAttribute::READONLY, 0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aTableShapePropertyMap_Impl;
+}
+
+static comphelper::PropertyMapEntry const * ImplGetSvxDrawingDefaultsPropertyMap()
+{
+    static comphelper::PropertyMapEntry const aSvxDrawingDefaultsPropertyMap_Impl[] =
+    {
+        GLOW_PROPERTIES
+        SOFTEDGE_PROPERTIES
+        SHADOW_PROPERTIES
+        LINE_PROPERTIES_DEFAULTS
+        FILL_PROPERTIES_BMP
+        FILL_PROPERTIES_DEFAULTS
+        EDGERADIUS_PROPERTIES
+        TEXT_PROPERTIES_DEFAULTS
+        CONNECTOR_PROPERTIES
+        SPECIAL_DIMENSIONING_PROPERTIES_DEFAULTS
+        MISC_3D_OBJ_PROPERTIES
+        SPECIAL_3DBACKSCALE_PROPERTIES
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aSvxDrawingDefaultsPropertyMap_Impl;
+}
+
+static comphelper::PropertyMapEntry const * ImplGetAdditionalWriterDrawingDefaultsPropertyMap()
+{
+    static comphelper::PropertyMapEntry const aSvxAdditionalDefaultsPropertyMap_Impl[] =
+    {
+        { OUString("IsFollowingTextFlow"), SID_SW_FOLLOW_TEXT_FLOW, cppu::UnoType<bool>::get(), 0, 0},
+        { OUString(), 0, css::uno::Type(), 0, 0 }
+    };
+
+    return aSvxAdditionalDefaultsPropertyMap_Impl;
+}
+
+typedef std::unordered_map< OUString, sal_uInt32 > UHashMapImpl;
+
+namespace {
+
+const UHashMapImpl& GetUHashImpl()
+{
+    static UHashMapImpl const aImpl
+    {
+            { "com.sun.star.drawing.RectangleShape",       OBJ_RECT },
+            { "com.sun.star.drawing.EllipseShape",         OBJ_CIRC },
+            { "com.sun.star.drawing.ControlShape",         OBJ_UNO  },
+            { "com.sun.star.drawing.ConnectorShape",       OBJ_EDGE },
+            { "com.sun.star.drawing.MeasureShape",         OBJ_MEASURE },
+            { "com.sun.star.drawing.LineShape",            OBJ_LINE },
+            { "com.sun.star.drawing.PolyPolygonShape",     OBJ_POLY },
+            { "com.sun.star.drawing.PolyLineShape",        OBJ_PLIN },
+            { "com.sun.star.drawing.OpenBezierShape",      OBJ_PATHLINE },
+            { "com.sun.star.drawing.ClosedBezierShape",    OBJ_PATHFILL },
+            { "com.sun.star.drawing.OpenFreeHandShape",    OBJ_FREELINE },
+            { "com.sun.star.drawing.ClosedFreeHandShape",  OBJ_FREEFILL },
+            { "com.sun.star.drawing.PolyPolygonPathShape", OBJ_PATHPOLY },
+            { "com.sun.star.drawing.PolyLinePathShape",    OBJ_PATHPLIN },
+            { "com.sun.star.drawing.GraphicObjectShape",   OBJ_GRAF },
+            { "com.sun.star.drawing.GroupShape",           OBJ_GRUP },
+            { "com.sun.star.drawing.TextShape",            OBJ_TEXT },
+            { "com.sun.star.drawing.OLE2Shape",            OBJ_OLE2 },
+            { "com.sun.star.drawing.PageShape",            OBJ_PAGE },
+            { "com.sun.star.drawing.CaptionShape",         OBJ_CAPTION },
+            { "com.sun.star.drawing.FrameShape",           OBJ_FRAME },
+            { "com.sun.star.drawing.PluginShape",          OBJ_OLE2_PLUGIN },
+            { "com.sun.star.drawing.AppletShape",          OBJ_OLE2_APPLET },
+            { "com.sun.star.drawing.CustomShape",          OBJ_CUSTOMSHAPE },
+            { "com.sun.star.drawing.MediaShape",           OBJ_MEDIA },
+
+            { "com.sun.star.drawing.Shape3DSceneObject",   E3D_SCENE_ID  | E3D_INVENTOR_FLAG },
+            { "com.sun.star.drawing.Shape3DCubeObject",    E3D_CUBEOBJ_ID    | E3D_INVENTOR_FLAG },
+            { "com.sun.star.drawing.Shape3DSphereObject",  E3D_SPHEREOBJ_ID  | E3D_INVENTOR_FLAG },
+            { "com.sun.star.drawing.Shape3DLatheObject",   E3D_LATHEOBJ_ID   | E3D_INVENTOR_FLAG },
+            { "com.sun.star.drawing.Shape3DExtrudeObject", E3D_EXTRUDEOBJ_ID | E3D_INVENTOR_FLAG },
+            { "com.sun.star.drawing.Shape3DPolygonObject", E3D_POLYGONOBJ_ID | E3D_INVENTOR_FLAG },
+    };
+
+    return aImpl;
+}
+
+}
+
+
+OUString UHashMap::getNameFromId(sal_uInt32 nId)
+{
+    const UHashMapImpl &rMap = GetUHashImpl();
+
+    auto it = std::find_if(rMap.begin(), rMap.end(),
+        [nId](const UHashMapImpl::value_type& rEntry) { return rEntry.second == nId; });
+    if (it != rMap.end())
+        return it->first;
+    OSL_FAIL("[CL] unknown SdrObject identifier");
+    return OUString();
+}
+
+uno::Sequence< OUString > UHashMap::getServiceNames()
+{
+    return comphelper::mapKeysToSequence( GetUHashImpl() );
+}
+
+sal_uInt32 UHashMap::getId( const OUString& rCompareString )
+{
+    const UHashMapImpl &rMap = GetUHashImpl();
+    UHashMapImpl::const_iterator it = rMap.find( rCompareString );
+    if( it == rMap.end() )
+        return UHASHMAP_NOTFOUND;
+    else
+        return it->second;
+}
+
+namespace {
+
+struct theSvxMapProvider :
+    public rtl::Static<SvxUnoPropertyMapProvider, theSvxMapProvider>
+{
+};
+
+}
+
+SvxUnoPropertyMapProvider& getSvxMapProvider()
+{
+    return theSvxMapProvider::get();
+}
+
+
+SvxUnoPropertyMapProvider::SvxUnoPropertyMapProvider()
+{
+    for(sal_uInt16 i=0;i<SVXMAP_END; i++)
+    {
+        aSetArr[i] = nullptr;
+        aMapArr[i] = nullptr;
+    }
+}
+
+SvxUnoPropertyMapProvider::~SvxUnoPropertyMapProvider()
+{
+}
+
+
+const SfxItemPropertyMapEntry* SvxUnoPropertyMapProvider::GetMap(sal_uInt16 nPropertyId)
+{
+    DBG_ASSERT(nPropertyId < SVXMAP_END, "Id ?" );
+    if(!aMapArr[nPropertyId]) {
+        switch(nPropertyId) {
+            case SVXMAP_SHAPE: aMapArr[SVXMAP_SHAPE]=ImplGetSvxShapePropertyMap(); break;
+            case SVXMAP_CONNECTOR: aMapArr[SVXMAP_CONNECTOR]=ImplGetSvxConnectorPropertyMap(); break;
+            case SVXMAP_DIMENSIONING: aMapArr[SVXMAP_DIMENSIONING]=ImplGetSvxDimensioningPropertyMap(); break;
+            case SVXMAP_CIRCLE: aMapArr[SVXMAP_CIRCLE]=ImplGetSvxCirclePropertyMap(); break;
+            case SVXMAP_POLYPOLYGON: aMapArr[SVXMAP_POLYPOLYGON]=ImplGetSvxPolyPolygonPropertyMap(); break;
+            case SVXMAP_GRAPHICOBJECT: aMapArr[SVXMAP_GRAPHICOBJECT]=ImplGetSvxGraphicObjectPropertyMap(); break;
+            case SVXMAP_3DSCENEOBJECT: aMapArr[SVXMAP_3DSCENEOBJECT]=ImplGetSvx3DSceneObjectPropertyMap(); break;
+            case SVXMAP_3DCUBEOBJECT: aMapArr[SVXMAP_3DCUBEOBJECT]=ImplGetSvx3DCubeObjectPropertyMap(); break;
+            case SVXMAP_3DSPHEREOBJECT: aMapArr[SVXMAP_3DSPHEREOBJECT]=ImplGetSvx3DSphereObjectPropertyMap(); break;
+            case SVXMAP_3DLATHEOBJECT: aMapArr[SVXMAP_3DLATHEOBJECT]=ImplGetSvx3DLatheObjectPropertyMap(); break;
+            case SVXMAP_3DEXTRUDEOBJECT: aMapArr[SVXMAP_3DEXTRUDEOBJECT]=ImplGetSvx3DExtrudeObjectPropertyMap(); break;
+            case SVXMAP_3DPOLYGONOBJECT: aMapArr[SVXMAP_3DPOLYGONOBJECT]=ImplGetSvx3DPolygonObjectPropertyMap(); break;
+            case SVXMAP_ALL: aMapArr[SVXMAP_ALL]=ImplGetSvxAllPropertyMap(); break;
+            case SVXMAP_GROUP: aMapArr[SVXMAP_GROUP]=ImplGetSvxGroupPropertyMap(); break;
+            case SVXMAP_CAPTION: aMapArr[SVXMAP_CAPTION]=ImplGetSvxCaptionPropertyMap(); break;
+            case SVXMAP_OLE2: aMapArr[SVXMAP_OLE2]=ImplGetSvxOle2PropertyMap(); break;
+            case SVXMAP_PLUGIN: aMapArr[SVXMAP_PLUGIN]=ImplGetSvxPluginPropertyMap(); break;
+            case SVXMAP_FRAME: aMapArr[SVXMAP_FRAME]=ImplGetSvxFramePropertyMap(); break;
+            case SVXMAP_APPLET: aMapArr[SVXMAP_APPLET]=ImplGetSvxAppletPropertyMap(); break;
+            case SVXMAP_CONTROL: aMapArr[SVXMAP_CONTROL]=ImplGetSvxControlShapePropertyMap(); break;
+            case SVXMAP_TEXT: aMapArr[SVXMAP_TEXT]=ImplGetSvxTextShapePropertyMap(); break;
+            case SVXMAP_CUSTOMSHAPE: aMapArr[SVXMAP_CUSTOMSHAPE]=ImplGetSvxCustomShapePropertyMap(); break;
+            case SVXMAP_MEDIA: aMapArr[SVXMAP_MEDIA]=ImplGetSvxMediaShapePropertyMap(); break;
+            case SVXMAP_TABLE: aMapArr[SVXMAP_TABLE]=ImplGetSvxTableShapePropertyMap(); break;
+            case SVXMAP_PAGE: aMapArr[SVXMAP_PAGE] = ImplGetSvxPageShapePropertyMap(); break;
+
+            default:
+                OSL_FAIL( "Unknown property map for SvxUnoPropertyMapProvider!" );
+        }
+//      Sort(nPropertyId);
+    }
+    return aMapArr[nPropertyId];
+}
+const SvxItemPropertySet* SvxUnoPropertyMapProvider::GetPropertySet(sal_uInt16 nPropertyId, SfxItemPool& rPool)
+{
+    if( !aSetArr[nPropertyId] )
+        aSetArr[nPropertyId].reset(new SvxItemPropertySet( GetMap( nPropertyId ), rPool ));
+    return aSetArr[nPropertyId].get();
+}
+
+/** maps the vcl MapUnit enum to an API constant MeasureUnit.
+    Returns false if conversion is not supported.
+*/
+bool SvxMapUnitToMeasureUnit( const MapUnit eVcl, short& eApi ) throw()
+{
+    switch( eVcl )
+    {
+    case MapUnit::Map100thMM:      eApi = util::MeasureUnit::MM_100TH;     break;
+    case MapUnit::Map10thMM:       eApi = util::MeasureUnit::MM_10TH;      break;
+    case MapUnit::MapMM:            eApi = util::MeasureUnit::MM;           break;
+    case MapUnit::MapCM:            eApi = util::MeasureUnit::CM;           break;
+    case MapUnit::Map1000thInch:   eApi = util::MeasureUnit::INCH_1000TH;  break;
+    case MapUnit::Map100thInch:    eApi = util::MeasureUnit::INCH_100TH;   break;
+    case MapUnit::Map10thInch:     eApi = util::MeasureUnit::INCH_10TH;    break;
+    case MapUnit::MapInch:          eApi = util::MeasureUnit::INCH;         break;
+    case MapUnit::MapPoint:         eApi = util::MeasureUnit::POINT;        break;
+    case MapUnit::MapTwip:          eApi = util::MeasureUnit::TWIP;         break;
+    case MapUnit::MapRelative:      eApi = util::MeasureUnit::PERCENT;      break;
+    default:
+        return false;
+    }
+
+    return true;
+}
+
+/** maps the API constant MeasureUnit to a vcl MapUnit enum.
+    Returns false if conversion is not supported.
+*/
+
+bool SvxMeasureUnitToFieldUnit( const short eApi, FieldUnit& eVcl ) throw()
+{
+    switch( eApi )
+    {
+    case util::MeasureUnit::MM:         eVcl = FieldUnit::MM;        break;
+    case util::MeasureUnit::CM:         eVcl = FieldUnit::CM;        break;
+    case util::MeasureUnit::M:          eVcl = FieldUnit::M;         break;
+    case util::MeasureUnit::KM:         eVcl = FieldUnit::KM;        break;
+    case util::MeasureUnit::TWIP:       eVcl = FieldUnit::TWIP;      break;
+    case util::MeasureUnit::POINT:      eVcl = FieldUnit::POINT;     break;
+    case util::MeasureUnit::PICA:       eVcl = FieldUnit::PICA;      break;
+    case util::MeasureUnit::INCH:       eVcl = FieldUnit::INCH;      break;
+    case util::MeasureUnit::FOOT:       eVcl = FieldUnit::FOOT;      break;
+    case util::MeasureUnit::MILE:       eVcl = FieldUnit::MILE;      break;
+    case util::MeasureUnit::PERCENT:    eVcl = FieldUnit::PERCENT;   break;
+    case util::MeasureUnit::MM_100TH:   eVcl = FieldUnit::MM_100TH;  break;
+    default:
+        return false;
+    }
+
+    return true;
+}
+
+/** maps the vcl MapUnit enum to an API constant MeasureUnit.
+    Returns false if conversion is not supported.
+*/
+bool SvxFieldUnitToMeasureUnit( const FieldUnit eVcl, short& eApi ) throw()
+{
+    switch( eVcl )
+    {
+    case FieldUnit::MM:          eApi = util::MeasureUnit::MM;       break;
+    case FieldUnit::CM:          eApi = util::MeasureUnit::CM;       break;
+    case FieldUnit::M:           eApi = util::MeasureUnit::M;        break;
+    case FieldUnit::KM:          eApi = util::MeasureUnit::KM;       break;
+    case FieldUnit::TWIP:        eApi = util::MeasureUnit::TWIP;     break;
+    case FieldUnit::POINT:       eApi = util::MeasureUnit::POINT;    break;
+    case FieldUnit::PICA:        eApi = util::MeasureUnit::PICA;     break;
+    case FieldUnit::INCH:        eApi = util::MeasureUnit::INCH;     break;
+    case FieldUnit::FOOT:        eApi = util::MeasureUnit::FOOT;     break;
+    case FieldUnit::MILE:        eApi = util::MeasureUnit::MILE;     break;
+    case FieldUnit::PERCENT:     eApi = util::MeasureUnit::PERCENT;  break;
+    case FieldUnit::MM_100TH:    eApi = util::MeasureUnit::MM_100TH; break;
+    default:
+        return false;
+    }
+
+    return true;
+}
+
+static const char* RID_SVXSTR_BMP_DEF[] =
+{
+    RID_SVXSTR_BMP0_DEF,
+    RID_SVXSTR_BMP1_DEF,
+    RID_SVXSTR_BMP2_DEF,
+    RID_SVXSTR_BMP3_DEF,
+    RID_SVXSTR_BMP4_DEF,
+    RID_SVXSTR_BMP5_DEF,
+    RID_SVXSTR_BMP6_DEF,
+    RID_SVXSTR_BMP7_DEF,
+    RID_SVXSTR_BMP8_DEF,
+    RID_SVXSTR_BMP9_DEF,
+    RID_SVXSTR_BMP10_DEF,
+    RID_SVXSTR_BMP11_DEF,
+    RID_SVXSTR_BMP12_DEF,
+    RID_SVXSTR_BMP13_DEF,
+    RID_SVXSTR_BMP14_DEF,
+    RID_SVXSTR_BMP15_DEF,
+    RID_SVXSTR_BMP16_DEF,
+    RID_SVXSTR_BMP17_DEF,
+    RID_SVXSTR_BMP18_DEF,
+    RID_SVXSTR_BMP19_DEF,
+    RID_SVXSTR_BMP20_DEF,
+    RID_SVXSTR_BMP21_DEF,
+    RID_SVXSTR_BMP22_DEF,
+    RID_SVXSTR_BMP23_DEF,
+    RID_SVXSTR_BMP24_DEF,
+    RID_SVXSTR_BMP25_DEF,
+    RID_SVXSTR_BMP26_DEF,
+    RID_SVXSTR_BMP27_DEF,
+    RID_SVXSTR_BMP28_DEF,
+    RID_SVXSTR_BMP29_DEF,
+    RID_SVXSTR_BMP30_DEF,
+    RID_SVXSTR_BMP31_DEF,
+    RID_SVXSTR_BMP32_DEF,
+    RID_SVXSTR_BMP33_DEF,
+    RID_SVXSTR_BMP34_DEF,
+    RID_SVXSTR_BMP35_DEF,
+    RID_SVXSTR_BMP36_DEF,
+    RID_SVXSTR_BMP37_DEF,
+    RID_SVXSTR_BMP38_DEF,
+    RID_SVXSTR_BMP39_DEF,
+    RID_SVXSTR_BMP40_DEF,
+    RID_SVXSTR_BMP41_DEF,
+    RID_SVXSTR_BMP42_DEF,
+    RID_SVXSTR_BMP43_DEF,
+    RID_SVXSTR_BMP44_DEF,
+    RID_SVXSTR_BMP45_DEF,
+    RID_SVXSTR_BMP46_DEF,
+    RID_SVXSTR_BMP47_DEF,
+    RID_SVXSTR_BMP48_DEF,
+    RID_SVXSTR_BMP49_DEF,
+    RID_SVXSTR_BMP50_DEF,
+    RID_SVXSTR_BMP51_DEF,
+    RID_SVXSTR_BMP52_DEF,
+    RID_SVXSTR_BMP53_DEF,
+    RID_SVXSTR_BMP54_DEF,
+    RID_SVXSTR_BMP55_DEF,
+    RID_SVXSTR_BMP56_DEF,
+    RID_SVXSTR_BMP57_DEF,
+    RID_SVXSTR_BMP58_DEF,
+    RID_SVXSTR_BMP59_DEF,
+    RID_SVXSTR_BMP60_DEF,
+    RID_SVXSTR_BMP61_DEF,
+    RID_SVXSTR_BMP62_DEF,
+    RID_SVXSTR_BMP63_DEF,
+    RID_SVXSTR_BMP64_DEF,
+    RID_SVXSTR_BMP65_DEF,
+    RID_SVXSTR_BMP66_DEF,
+    RID_SVXSTR_BMP67_DEF,
+    RID_SVXSTR_BMP68_DEF,
+    RID_SVXSTR_BMP69_DEF,
+    RID_SVXSTR_BMP70_DEF,
+    RID_SVXSTR_BMP71_DEF,
+    RID_SVXSTR_BMP72_DEF,
+    RID_SVXSTR_BMP73_DEF,
+    RID_SVXSTR_BMP74_DEF,
+    RID_SVXSTR_BMP75_DEF,
+    RID_SVXSTR_BMP76_DEF,
+    RID_SVXSTR_BMP77_DEF,
+    RID_SVXSTR_BMP78_DEF,
+    RID_SVXSTR_BMP79_DEF,
+    RID_SVXSTR_BMP80_DEF,
+    RID_SVXSTR_BMP81_DEF,
+    RID_SVXSTR_BMP82_DEF,
+    RID_SVXSTR_BMP83_DEF,
+    RID_SVXSTR_BMP84_DEF,
+    RID_SVXSTR_BMP85_DEF,
+    RID_SVXSTR_BMP86_DEF,
+    RID_SVXSTR_BMP87_DEF,
+    RID_SVXSTR_BMP88_DEF,
+    RID_SVXSTR_BMP89_DEF,
+    RID_SVXSTR_BMP90_DEF,
+    RID_SVXSTR_BMP91_DEF,
+    RID_SVXSTR_BMP92_DEF
+};
+
+static const char* RID_SVXSTR_BMP[] =
+{
+    RID_SVXSTR_BMP0,
+    RID_SVXSTR_BMP1,
+    RID_SVXSTR_BMP2,
+    RID_SVXSTR_BMP3,
+    RID_SVXSTR_BMP4,
+    RID_SVXSTR_BMP5,
+    RID_SVXSTR_BMP6,
+    RID_SVXSTR_BMP7,
+    RID_SVXSTR_BMP8,
+    RID_SVXSTR_BMP9,
+    RID_SVXSTR_BMP10,
+    RID_SVXSTR_BMP11,
+    RID_SVXSTR_BMP12,
+    RID_SVXSTR_BMP13,
+    RID_SVXSTR_BMP14,
+    RID_SVXSTR_BMP15,
+    RID_SVXSTR_BMP16,
+    RID_SVXSTR_BMP17,
+    RID_SVXSTR_BMP18,
+    RID_SVXSTR_BMP19,
+    RID_SVXSTR_BMP20,
+    RID_SVXSTR_BMP21,
+    RID_SVXSTR_BMP22,
+    RID_SVXSTR_BMP23,
+    RID_SVXSTR_BMP24,
+    RID_SVXSTR_BMP25,
+    RID_SVXSTR_BMP26,
+    RID_SVXSTR_BMP27,
+    RID_SVXSTR_BMP28,
+    RID_SVXSTR_BMP29,
+    RID_SVXSTR_BMP30,
+    RID_SVXSTR_BMP31,
+    RID_SVXSTR_BMP32,
+    RID_SVXSTR_BMP33,
+    RID_SVXSTR_BMP34,
+    RID_SVXSTR_BMP35,
+    RID_SVXSTR_BMP36,
+    RID_SVXSTR_BMP37,
+    RID_SVXSTR_BMP38,
+    RID_SVXSTR_BMP39,
+    RID_SVXSTR_BMP40,
+    RID_SVXSTR_BMP41,
+    RID_SVXSTR_BMP42,
+    RID_SVXSTR_BMP43,
+    RID_SVXSTR_BMP44,
+    RID_SVXSTR_BMP45,
+    RID_SVXSTR_BMP46,
+    RID_SVXSTR_BMP47,
+    RID_SVXSTR_BMP48,
+    RID_SVXSTR_BMP49,
+    RID_SVXSTR_BMP50,
+    RID_SVXSTR_BMP51,
+    RID_SVXSTR_BMP52,
+    RID_SVXSTR_BMP53,
+    RID_SVXSTR_BMP54,
+    RID_SVXSTR_BMP55,
+    RID_SVXSTR_BMP56,
+    RID_SVXSTR_BMP57,
+    RID_SVXSTR_BMP58,
+    RID_SVXSTR_BMP59,
+    RID_SVXSTR_BMP60,
+    RID_SVXSTR_BMP61,
+    RID_SVXSTR_BMP62,
+    RID_SVXSTR_BMP63,
+    RID_SVXSTR_BMP64,
+    RID_SVXSTR_BMP65,
+    RID_SVXSTR_BMP66,
+    RID_SVXSTR_BMP67,
+    RID_SVXSTR_BMP68,
+    RID_SVXSTR_BMP69,
+    RID_SVXSTR_BMP70,
+    RID_SVXSTR_BMP71,
+    RID_SVXSTR_BMP72,
+    RID_SVXSTR_BMP73,
+    RID_SVXSTR_BMP74,
+    RID_SVXSTR_BMP75,
+    RID_SVXSTR_BMP76,
+    RID_SVXSTR_BMP77,
+    RID_SVXSTR_BMP78,
+    RID_SVXSTR_BMP79,
+    RID_SVXSTR_BMP80,
+    RID_SVXSTR_BMP81,
+    RID_SVXSTR_BMP82,
+    RID_SVXSTR_BMP83,
+    RID_SVXSTR_BMP84,
+    RID_SVXSTR_BMP85,
+    RID_SVXSTR_BMP86,
+    RID_SVXSTR_BMP87,
+    RID_SVXSTR_BMP88,
+    RID_SVXSTR_BMP89,
+    RID_SVXSTR_BMP90,
+    RID_SVXSTR_BMP91,
+    RID_SVXSTR_BMP92
+};
+
+static const char* RID_SVXSTR_DASH_DEF[] =
+{
+    RID_SVXSTR_DASH0_DEF,
+    RID_SVXSTR_DASH1_DEF,
+    RID_SVXSTR_DASH2_DEF,
+    RID_SVXSTR_DASH3_DEF,
+    RID_SVXSTR_DASH4_DEF,
+    RID_SVXSTR_DASH5_DEF,
+    RID_SVXSTR_DASH6_DEF,
+    RID_SVXSTR_DASH7_DEF,
+    RID_SVXSTR_DASH8_DEF,
+    RID_SVXSTR_DASH9_DEF,
+    RID_SVXSTR_DASH10_DEF,
+    RID_SVXSTR_DASH11_DEF,
+    RID_SVXSTR_DASH12_DEF,
+    RID_SVXSTR_DASH13_DEF,
+    RID_SVXSTR_DASH14_DEF,
+    RID_SVXSTR_DASH15_DEF,
+    RID_SVXSTR_DASH16_DEF,
+    RID_SVXSTR_DASH17_DEF,
+    RID_SVXSTR_DASH18_DEF,
+    RID_SVXSTR_DASH19_DEF,
+    RID_SVXSTR_DASH20_DEF,
+    RID_SVXSTR_DASH21_DEF
+};
+
+static const char* RID_SVXSTR_DASH[] =
+{
+    RID_SVXSTR_DASH0,
+    RID_SVXSTR_DASH1,
+    RID_SVXSTR_DASH2,
+    RID_SVXSTR_DASH3,
+    RID_SVXSTR_DASH4,
+    RID_SVXSTR_DASH5,
+    RID_SVXSTR_DASH6,
+    RID_SVXSTR_DASH7,
+    RID_SVXSTR_DASH8,
+    RID_SVXSTR_DASH9,
+    RID_SVXSTR_DASH10,
+    RID_SVXSTR_DASH11,
+    RID_SVXSTR_DASH12,
+    RID_SVXSTR_DASH13,
+    RID_SVXSTR_DASH14,
+    RID_SVXSTR_DASH15,
+    RID_SVXSTR_DASH16,
+    RID_SVXSTR_DASH17,
+    RID_SVXSTR_DASH18,
+    RID_SVXSTR_DASH19,
+    RID_SVXSTR_DASH20,
+    RID_SVXSTR_DASH21
+};
+
+static const char* RID_SVXSTR_LEND_DEF[] =
+{
+    RID_SVXSTR_LEND0_DEF,
+    RID_SVXSTR_LEND1_DEF,
+    RID_SVXSTR_LEND2_DEF,
+    RID_SVXSTR_LEND3_DEF,
+    RID_SVXSTR_LEND4_DEF,
+    RID_SVXSTR_LEND5_DEF,
+    RID_SVXSTR_LEND6_DEF,
+    RID_SVXSTR_LEND7_DEF,
+    RID_SVXSTR_LEND8_DEF,
+    RID_SVXSTR_LEND9_DEF,
+    RID_SVXSTR_LEND10_DEF,
+    RID_SVXSTR_LEND11_DEF,
+    RID_SVXSTR_LEND12_DEF,
+    RID_SVXSTR_LEND13_DEF,
+    RID_SVXSTR_LEND14_DEF,
+    RID_SVXSTR_LEND15_DEF,
+    RID_SVXSTR_LEND16_DEF,
+    RID_SVXSTR_LEND17_DEF,
+    RID_SVXSTR_LEND18_DEF,
+    RID_SVXSTR_LEND19_DEF,
+    RID_SVXSTR_LEND20_DEF,
+    RID_SVXSTR_LEND21_DEF,
+    RID_SVXSTR_LEND22_DEF,
+    RID_SVXSTR_LEND23_DEF,
+    RID_SVXSTR_LEND24_DEF,
+    RID_SVXSTR_LEND25_DEF,
+    RID_SVXSTR_LEND26_DEF,
+    RID_SVXSTR_LEND27_DEF,
+    RID_SVXSTR_LEND28_DEF,
+    RID_SVXSTR_LEND29_DEF,
+    RID_SVXSTR_LEND30_DEF,
+    RID_SVXSTR_LEND31_DEF
+};
+
+static const char* RID_SVXSTR_LEND[] =
+{
+    RID_SVXSTR_LEND0,
+    RID_SVXSTR_LEND1,
+    RID_SVXSTR_LEND2,
+    RID_SVXSTR_LEND3,
+    RID_SVXSTR_LEND4,
+    RID_SVXSTR_LEND5,
+    RID_SVXSTR_LEND6,
+    RID_SVXSTR_LEND7,
+    RID_SVXSTR_LEND8,
+    RID_SVXSTR_LEND9,
+    RID_SVXSTR_LEND10,
+    RID_SVXSTR_LEND11,
+    RID_SVXSTR_LEND12,
+    RID_SVXSTR_LEND13,
+    RID_SVXSTR_LEND14,
+    RID_SVXSTR_LEND15,
+    RID_SVXSTR_LEND16,
+    RID_SVXSTR_LEND17,
+    RID_SVXSTR_LEND18,
+    RID_SVXSTR_LEND19,
+    RID_SVXSTR_LEND20,
+    RID_SVXSTR_LEND21,
+    RID_SVXSTR_LEND22,
+    RID_SVXSTR_LEND23,
+    RID_SVXSTR_LEND24,
+    RID_SVXSTR_LEND25,
+    RID_SVXSTR_LEND26,
+    RID_SVXSTR_LEND27,
+    RID_SVXSTR_LEND28,
+    RID_SVXSTR_LEND29,
+    RID_SVXSTR_LEND30,
+    RID_SVXSTR_LEND31
+};
+
+static const char* RID_SVXSTR_GRDT_DEF[] =
+{
+    RID_SVXSTR_GRDT0_DEF,
+    RID_SVXSTR_GRDT1_DEF,
+    RID_SVXSTR_GRDT2_DEF,
+    RID_SVXSTR_GRDT3_DEF,
+    RID_SVXSTR_GRDT4_DEF,
+    RID_SVXSTR_GRDT5_DEF,
+    RID_SVXSTR_GRDT6_DEF,
+    RID_SVXSTR_GRDT7_DEF,
+    RID_SVXSTR_GRDT8_DEF,
+    RID_SVXSTR_GRDT9_DEF,
+    RID_SVXSTR_GRDT10_DEF,
+    RID_SVXSTR_GRDT11_DEF,
+    RID_SVXSTR_GRDT12_DEF,
+    RID_SVXSTR_GRDT13_DEF,
+    RID_SVXSTR_GRDT14_DEF,
+    RID_SVXSTR_GRDT15_DEF,
+    RID_SVXSTR_GRDT16_DEF,
+    RID_SVXSTR_GRDT17_DEF,
+    RID_SVXSTR_GRDT18_DEF,
+    RID_SVXSTR_GRDT19_DEF,
+    RID_SVXSTR_GRDT20_DEF,
+    RID_SVXSTR_GRDT21_DEF,
+    RID_SVXSTR_GRDT22_DEF,
+    RID_SVXSTR_GRDT23_DEF,
+    RID_SVXSTR_GRDT24_DEF,
+    RID_SVXSTR_GRDT25_DEF,
+    RID_SVXSTR_GRDT26_DEF,
+    RID_SVXSTR_GRDT27_DEF,
+    RID_SVXSTR_GRDT28_DEF,
+    RID_SVXSTR_GRDT29_DEF,
+    RID_SVXSTR_GRDT30_DEF,
+    RID_SVXSTR_GRDT31_DEF,
+    RID_SVXSTR_GRDT32_DEF,
+    RID_SVXSTR_GRDT33_DEF,
+    RID_SVXSTR_GRDT34_DEF,
+    RID_SVXSTR_GRDT35_DEF,
+    RID_SVXSTR_GRDT36_DEF,
+    RID_SVXSTR_GRDT37_DEF,
+    RID_SVXSTR_GRDT38_DEF,
+    RID_SVXSTR_GRDT39_DEF,
+    RID_SVXSTR_GRDT40_DEF,
+    RID_SVXSTR_GRDT41_DEF,
+    RID_SVXSTR_GRDT42_DEF,
+    RID_SVXSTR_GRDT43_DEF,
+    RID_SVXSTR_GRDT44_DEF,
+    RID_SVXSTR_GRDT45_DEF,
+    RID_SVXSTR_GRDT46_DEF,
+    RID_SVXSTR_GRDT47_DEF,
+    RID_SVXSTR_GRDT48_DEF,
+    RID_SVXSTR_GRDT49_DEF,
+    RID_SVXSTR_GRDT50_DEF,
+    RID_SVXSTR_GRDT51_DEF,
+    RID_SVXSTR_GRDT52_DEF,
+    RID_SVXSTR_GRDT53_DEF,
+    RID_SVXSTR_GRDT54_DEF,
+    RID_SVXSTR_GRDT55_DEF,
+    RID_SVXSTR_GRDT56_DEF,
+    RID_SVXSTR_GRDT57_DEF,
+    RID_SVXSTR_GRDT58_DEF,
+    RID_SVXSTR_GRDT59_DEF,
+    RID_SVXSTR_GRDT60_DEF,
+    RID_SVXSTR_GRDT61_DEF,
+    RID_SVXSTR_GRDT62_DEF,
+    RID_SVXSTR_GRDT63_DEF,
+    RID_SVXSTR_GRDT64_DEF,
+    RID_SVXSTR_GRDT65_DEF,
+    RID_SVXSTR_GRDT66_DEF,
+    RID_SVXSTR_GRDT67_DEF,
+    RID_SVXSTR_GRDT68_DEF,
+    RID_SVXSTR_GRDT69_DEF,
+    RID_SVXSTR_GRDT70_DEF,
+    RID_SVXSTR_GRDT71_DEF,
+    RID_SVXSTR_GRDT72_DEF,
+    RID_SVXSTR_GRDT73_DEF,
+    RID_SVXSTR_GRDT74_DEF,
+    RID_SVXSTR_GRDT75_DEF,
+    RID_SVXSTR_GRDT76_DEF,
+    RID_SVXSTR_GRDT77_DEF,
+    RID_SVXSTR_GRDT78_DEF,
+    RID_SVXSTR_GRDT79_DEF,
+    RID_SVXSTR_GRDT80_DEF,
+    RID_SVXSTR_GRDT81_DEF,
+    RID_SVXSTR_GRDT82_DEF,
+    RID_SVXSTR_GRDT83_DEF,
+    RID_SVXSTR_GRDT84_DEF
+};
+
+static const char* RID_SVXSTR_GRDT[] =
+{
+    RID_SVXSTR_GRDT0,
+    RID_SVXSTR_GRDT1,
+    RID_SVXSTR_GRDT2,
+    RID_SVXSTR_GRDT3,
+    RID_SVXSTR_GRDT4,
+    RID_SVXSTR_GRDT5,
+    RID_SVXSTR_GRDT6,
+    RID_SVXSTR_GRDT7,
+    RID_SVXSTR_GRDT8,
+    RID_SVXSTR_GRDT9,
+    RID_SVXSTR_GRDT10,
+    RID_SVXSTR_GRDT11,
+    RID_SVXSTR_GRDT12,
+    RID_SVXSTR_GRDT13,
+    RID_SVXSTR_GRDT14,
+    RID_SVXSTR_GRDT15,
+    RID_SVXSTR_GRDT16,
+    RID_SVXSTR_GRDT17,
+    RID_SVXSTR_GRDT18,
+    RID_SVXSTR_GRDT19,
+    RID_SVXSTR_GRDT20,
+    RID_SVXSTR_GRDT21,
+    RID_SVXSTR_GRDT22,
+    RID_SVXSTR_GRDT23,
+    RID_SVXSTR_GRDT24,
+    RID_SVXSTR_GRDT25,
+    RID_SVXSTR_GRDT26,
+    RID_SVXSTR_GRDT27,
+    RID_SVXSTR_GRDT28,
+    RID_SVXSTR_GRDT29,
+    RID_SVXSTR_GRDT30,
+    RID_SVXSTR_GRDT31,
+    RID_SVXSTR_GRDT32,
+    RID_SVXSTR_GRDT33,
+    RID_SVXSTR_GRDT34,
+    RID_SVXSTR_GRDT35,
+    RID_SVXSTR_GRDT36,
+    RID_SVXSTR_GRDT37,
+    RID_SVXSTR_GRDT38,
+    RID_SVXSTR_GRDT39,
+    RID_SVXSTR_GRDT40,
+    RID_SVXSTR_GRDT41,
+    RID_SVXSTR_GRDT42,
+    RID_SVXSTR_GRDT43,
+    RID_SVXSTR_GRDT44,
+    RID_SVXSTR_GRDT45,
+    RID_SVXSTR_GRDT46,
+    RID_SVXSTR_GRDT47,
+    RID_SVXSTR_GRDT48,
+    RID_SVXSTR_GRDT49,
+    RID_SVXSTR_GRDT50,
+    RID_SVXSTR_GRDT51,
+    RID_SVXSTR_GRDT52,
+    RID_SVXSTR_GRDT53,
+    RID_SVXSTR_GRDT54,
+    RID_SVXSTR_GRDT55,
+    RID_SVXSTR_GRDT56,
+    RID_SVXSTR_GRDT57,
+    RID_SVXSTR_GRDT58,
+    RID_SVXSTR_GRDT59,
+    RID_SVXSTR_GRDT60,
+    RID_SVXSTR_GRDT61,
+    RID_SVXSTR_GRDT62,
+    RID_SVXSTR_GRDT63,
+    RID_SVXSTR_GRDT64,
+    RID_SVXSTR_GRDT65,
+    RID_SVXSTR_GRDT66,
+    RID_SVXSTR_GRDT67,
+    RID_SVXSTR_GRDT68,
+    RID_SVXSTR_GRDT69,
+    RID_SVXSTR_GRDT70,
+    RID_SVXSTR_GRDT71,
+    RID_SVXSTR_GRDT72,
+    RID_SVXSTR_GRDT73,
+    RID_SVXSTR_GRDT74,
+    RID_SVXSTR_GRDT75,
+    RID_SVXSTR_GRDT76,
+    RID_SVXSTR_GRDT77,
+    RID_SVXSTR_GRDT78,
+    RID_SVXSTR_GRDT79,
+    RID_SVXSTR_GRDT80,
+    RID_SVXSTR_GRDT81,
+    RID_SVXSTR_GRDT82,
+    RID_SVXSTR_GRDT83,
+    RID_SVXSTR_GRDT84
+};
+
+static const char* RID_SVXSTR_HATCHS_DEF[] =
+{
+    RID_SVXSTR_HATCH0_DEF,
+    RID_SVXSTR_HATCH1_DEF,
+    RID_SVXSTR_HATCH2_DEF,
+    RID_SVXSTR_HATCH3_DEF,
+    RID_SVXSTR_HATCH4_DEF,
+    RID_SVXSTR_HATCH5_DEF,
+    RID_SVXSTR_HATCH6_DEF,
+    RID_SVXSTR_HATCH7_DEF,
+    RID_SVXSTR_HATCH8_DEF,
+    RID_SVXSTR_HATCH9_DEF,
+    RID_SVXSTR_HATCH10_DEF,
+    RID_SVXSTR_HATCH11_DEF,
+    RID_SVXSTR_HATCH12_DEF,
+    RID_SVXSTR_HATCH13_DEF,
+    RID_SVXSTR_HATCH14_DEF,
+    RID_SVXSTR_HATCH15_DEF
+};
+
+static const char* RID_SVXSTR_HATCHS[] =
+{
+    RID_SVXSTR_HATCH0,
+    RID_SVXSTR_HATCH1,
+    RID_SVXSTR_HATCH2,
+    RID_SVXSTR_HATCH3,
+    RID_SVXSTR_HATCH4,
+    RID_SVXSTR_HATCH5,
+    RID_SVXSTR_HATCH6,
+    RID_SVXSTR_HATCH7,
+    RID_SVXSTR_HATCH8,
+    RID_SVXSTR_HATCH9,
+    RID_SVXSTR_HATCH10,
+    RID_SVXSTR_HATCH11,
+    RID_SVXSTR_HATCH12,
+    RID_SVXSTR_HATCH13,
+    RID_SVXSTR_HATCH14,
+    RID_SVXSTR_HATCH15
+};
+
+static const char* RID_SVXSTR_TRASNGR_DEF[] =
+{
+    RID_SVXSTR_TRASNGR0_DEF
+};
+
+static const char* RID_SVXSTR_TRASNGR[] =
+{
+    RID_SVXSTR_TRASNGR0
+};
+
+static bool SvxUnoGetResourceRanges( const sal_uInt16 nWhich, const char**& pApiResIds, const char**& pIntResIds, int& nCount ) throw()
+{
+    switch( nWhich )
+    {
+    case XATTR_FILLBITMAP:
+        pApiResIds = RID_SVXSTR_BMP_DEF;
+        pIntResIds = RID_SVXSTR_BMP;
+        nCount = SAL_N_ELEMENTS(RID_SVXSTR_BMP_DEF);
+        break;
+    case XATTR_LINEDASH:
+        pApiResIds = RID_SVXSTR_DASH_DEF;
+        pIntResIds = RID_SVXSTR_DASH;
+        nCount = SAL_N_ELEMENTS(RID_SVXSTR_DASH_DEF);
+        break;
+
+    case XATTR_LINESTART:
+    case XATTR_LINEEND:
+        pApiResIds = RID_SVXSTR_LEND_DEF;
+        pIntResIds = RID_SVXSTR_LEND;
+        nCount = SAL_N_ELEMENTS(RID_SVXSTR_LEND_DEF);
+        break;
+
+    case XATTR_FILLGRADIENT:
+        pApiResIds = RID_SVXSTR_GRDT_DEF;
+        pIntResIds = RID_SVXSTR_GRDT;
+        nCount = SAL_N_ELEMENTS(RID_SVXSTR_GRDT_DEF);
+        break;
+
+    case XATTR_FILLHATCH:
+        pApiResIds = RID_SVXSTR_HATCHS_DEF;
+        pIntResIds = RID_SVXSTR_HATCHS;
+        nCount = SAL_N_ELEMENTS(RID_SVXSTR_HATCHS_DEF);
+        break;
+
+    case XATTR_FILLFLOATTRANSPARENCE:
+        pApiResIds = RID_SVXSTR_TRASNGR_DEF;
+        pIntResIds = RID_SVXSTR_TRASNGR;
+        nCount = SAL_N_ELEMENTS(RID_SVXSTR_TRASNGR_DEF);
+        break;
+
+    default:
+        return false;
+    }
+    return true;
+}
+
+/// @throws std::exception
+static bool SvxUnoConvertResourceString(const char **pSourceResIds, const char** pDestResIds, int nCount, OUString& rString, bool bToApi)
+{
+    // first, calculate the search string length without an optional number after the name
+    sal_Int32 nLength = rString.getLength();
+    while( nLength > 0 )
+    {
+        const sal_Unicode nChar = rString[ nLength - 1 ];
+        if( (nChar < '0') || (nChar > '9') )
+            break;
+
+        nLength--;
+    }
+
+    // if we cut off a number, also cut of some spaces
+    if( nLength != rString.getLength() )
+    {
+        while( nLength > 0 )
+        {
+            const sal_Unicode nChar = rString[ nLength - 1 ];
+            if( nChar != ' ' )
+                break;
+
+            nLength--;
+        }
+    }
+
+    const OUString aShortString( rString.copy( 0, nLength ) );
+
+    for (int i = 0; i < nCount; ++i)
+    {
+        if (bToApi)
+        {
+            const OUString & aCompare = SvxResId(pSourceResIds[i]);
+            if( aShortString == aCompare )
+            {
+                rString = rString.replaceAt( 0, aShortString.getLength(), OUString::createFromAscii(pDestResIds[i]) );
+                return true;
+            }
+            else if( rString == aCompare )
+            {
+                rString = OUString::createFromAscii(pDestResIds[i]);
+                return true;
+            }
+        }
+        else
+        {
+            auto pCompare = pSourceResIds[i];
+            if( aShortString.equalsAscii(pCompare) )
+            {
+                rString = rString.replaceAt( 0, aShortString.getLength(), SvxResId(pDestResIds[i]) );
+                return true;
+            }
+            else if( rString.equalsAscii(pCompare) )
+            {
+                rString = SvxResId(pDestResIds[i]);
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
+// #i122649# Some comments on the below arrays:
+// - They need to have the same order and count of items
+// - They are used to translate between translated and non-translated color names
+// - To make longer names be found which start with the same basic string,
+//   these have to be in front of others
+
+// It would be nice to:
+// - evtl. organize these in a single array with 2-dimensional inner to eliminate
+//   the possibility to define it wrong
+// - change the compare to also work when a shorter name is in front of a longer one
+
+static const char* SvxUnoColorNameDefResId[] =
+{
+    RID_SVXSTR_COLOR_BLUEGREY_DEF,
+    RID_SVXSTR_COLOR_BLACK_DEF,
+    RID_SVXSTR_COLOR_BLUE_CLASSIC_DEF,
+    RID_SVXSTR_COLOR_BLUE_DEF,
+    RID_SVXSTR_COLOR_GREEN_DEF,
+    RID_SVXSTR_COLOR_RED_DEF,
+    RID_SVXSTR_COLOR_MAGENTA_DEF,
+    RID_SVXSTR_COLOR_GREY_DEF,
+    RID_SVXSTR_COLOR_YELLOWGREEN_DEF,
+    RID_SVXSTR_COLOR_YELLOW_DEF,
+    RID_SVXSTR_COLOR_WHITE_DEF,
+    RID_SVXSTR_COLOR_ORANGE_DEF,
+    RID_SVXSTR_COLOR_BORDEAUX_DEF,
+    RID_SVXSTR_COLOR_PALE_YELLOW_DEF,
+    RID_SVXSTR_COLOR_PALE_GREEN_DEF,
+    RID_SVXSTR_COLOR_DARKVIOLET_DEF,
+    RID_SVXSTR_COLOR_SALMON_DEF,
+    RID_SVXSTR_COLOR_SEABLUE_DEF,
+    RID_SVXSTR_COLOR_CHART_DEF,
+    RID_SVXSTR_COLOR_PURPLE_DEF,
+    RID_SVXSTR_COLOR_SKYBLUE_DEF,
+    RID_SVXSTR_COLOR_PINK_DEF,
+    RID_SVXSTR_COLOR_TURQUOISE_DEF,
+    RID_SVXSTR_COLOR_GOLD_DEF,
+    RID_SVXSTR_COLOR_BRICK_DEF,
+    RID_SVXSTR_COLOR_INDIGO_DEF,
+    RID_SVXSTR_COLOR_TEAL_DEF,
+    RID_SVXSTR_COLOR_LIME_DEF,
+    RID_SVXSTR_COLOR_LIGHTGRAY_DEF,
+    RID_SVXSTR_COLOR_LIGHTYELLOW_DEF,
+    RID_SVXSTR_COLOR_LIGHTGOLD_DEF,
+    RID_SVXSTR_COLOR_LIGHTORANGE_DEF,
+    RID_SVXSTR_COLOR_LIGHTBRICK_DEF,
+    RID_SVXSTR_COLOR_LIGHTRED_DEF,
+    RID_SVXSTR_COLOR_LIGHTMAGENTA_DEF,
+    RID_SVXSTR_COLOR_LIGHTPURPLE_DEF,
+    RID_SVXSTR_COLOR_LIGHTINDIGO_DEF,
+    RID_SVXSTR_COLOR_LIGHTBLUE_DEF,
+    RID_SVXSTR_COLOR_LIGHTTEAL_DEF,
+    RID_SVXSTR_COLOR_LIGHTGREEN_DEF,
+    RID_SVXSTR_COLOR_LIGHTLIME_DEF,
+    RID_SVXSTR_COLOR_DARKGRAY_DEF,
+    RID_SVXSTR_COLOR_DARKYELLOW_DEF,
+    RID_SVXSTR_COLOR_DARKGOLD_DEF,
+    RID_SVXSTR_COLOR_DARKORANGE_DEF,
+    RID_SVXSTR_COLOR_DARKBRICK_DEF,
+    RID_SVXSTR_COLOR_DARKRED_DEF,
+    RID_SVXSTR_COLOR_DARKMAGENTA_DEF,
+    RID_SVXSTR_COLOR_DARKPURPLE_DEF,
+    RID_SVXSTR_COLOR_DARKINDIGO_DEF,
+    RID_SVXSTR_COLOR_DARKBLUE_DEF,
+    RID_SVXSTR_COLOR_DARKTEAL_DEF,
+    RID_SVXSTR_COLOR_DARKGREEN_DEF,
+    RID_SVXSTR_COLOR_DARKLIME_DEF,
+    RID_SVXSTR_COLOR_VIOLET_DEF,
+    RID_SVXSTR_COLOR_VIOLET_OUG_DEF,
+    RID_SVXSTR_COLOR_BLUE_OUG_DEF,
+    RID_SVXSTR_COLOR_AZURE_OUG_DEF,
+    RID_SVXSTR_COLOR_SPRINGGREEN_OUG_DEF,
+    RID_SVXSTR_COLOR_GREEN_OUG_DEF,
+    RID_SVXSTR_COLOR_CHARTREUSEGREEN_OUG_DEF,
+    RID_SVXSTR_COLOR_ORANGE_OUG_DEF,
+    RID_SVXSTR_COLOR_RED_OUG_DEF,
+    RID_SVXSTR_COLOR_ROSE_OUG_DEF,
+    RID_SVXSTR_COLOR_AZURE_DEF,
+    RID_SVXSTR_COLOR_CYAN_DEF,
+    RID_SVXSTR_COLOR_SPRINGGREEN_DEF,
+    RID_SVXSTR_COLOR_CHARTREUSEGREEN_DEF,
+    RID_SVXSTR_COLOR_ROSE_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_GRAY_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_YELLOW_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_AMBER_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_AMBER_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_ORANGE_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_ORANGE_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_ORANGE_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_RED_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_PINK_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_PURPLE_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_PURPLE_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_PURPLE_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_INDIGO_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_BLUE_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_LIGHT_BLUE_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_CYAN_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_TEAL_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_GREEN_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_LIGHT_GREEN_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_LIME_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_BROWN_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_BROWN_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_BLUE_GRAY_A_DEF,
+    RID_SVXSTR_COLOR_MATERIAL_BLUE_GRAY_DEF,
+    RID_SVXSTR_COLOR_LIBRE_GREEN_1_DEF,
+    RID_SVXSTR_COLOR_LIBRE_GREEN_ACCENT_DEF,
+    RID_SVXSTR_COLOR_LIBRE_BLUE_ACCENT_DEF,
+    RID_SVXSTR_COLOR_LIBRE_ORANGE_ACCENT_DEF,
+    RID_SVXSTR_COLOR_LIBRE_PURPLE_DEF,
+    RID_SVXSTR_COLOR_LIBRE_PURPLE_ACCENT_DEF,
+    RID_SVXSTR_COLOR_LIBRE_YELLOW_ACCENT_DEF
+};
+
+static const char* SvxUnoColorNameResId[] =
+{
+    RID_SVXSTR_COLOR_BLUEGREY,
+    RID_SVXSTR_COLOR_BLACK,
+    RID_SVXSTR_COLOR_BLUE_CLASSIC,
+    RID_SVXSTR_COLOR_BLUE,
+    RID_SVXSTR_COLOR_GREEN,
+    RID_SVXSTR_COLOR_RED,
+    RID_SVXSTR_COLOR_MAGENTA,
+    RID_SVXSTR_COLOR_GREY,
+    RID_SVXSTR_COLOR_YELLOWGREEN,
+    RID_SVXSTR_COLOR_YELLOW,
+    RID_SVXSTR_COLOR_WHITE,
+    RID_SVXSTR_COLOR_ORANGE,
+    RID_SVXSTR_COLOR_BORDEAUX,
+    RID_SVXSTR_COLOR_PALE_YELLOW,
+    RID_SVXSTR_COLOR_PALE_GREEN,
+    RID_SVXSTR_COLOR_DARKVIOLET,
+    RID_SVXSTR_COLOR_SALMON,
+    RID_SVXSTR_COLOR_SEABLUE,
+    RID_SVXSTR_COLOR_CHART,
+    RID_SVXSTR_COLOR_PURPLE,
+    RID_SVXSTR_COLOR_SKYBLUE,
+    RID_SVXSTR_COLOR_PINK,
+    RID_SVXSTR_COLOR_TURQUOISE,
+    RID_SVXSTR_COLOR_GOLD,
+    RID_SVXSTR_COLOR_BRICK,
+    RID_SVXSTR_COLOR_INDIGO,
+    RID_SVXSTR_COLOR_TEAL,
+    RID_SVXSTR_COLOR_LIME,
+    RID_SVXSTR_COLOR_LIGHTGRAY,
+    RID_SVXSTR_COLOR_LIGHTYELLOW,
+    RID_SVXSTR_COLOR_LIGHTGOLD,
+    RID_SVXSTR_COLOR_LIGHTORANGE,
+    RID_SVXSTR_COLOR_LIGHTBRICK,
+    RID_SVXSTR_COLOR_LIGHTRED,
+    RID_SVXSTR_COLOR_LIGHTMAGENTA,
+    RID_SVXSTR_COLOR_LIGHTPURPLE,
+    RID_SVXSTR_COLOR_LIGHTINDIGO,
+    RID_SVXSTR_COLOR_LIGHTBLUE,
+    RID_SVXSTR_COLOR_LIGHTTEAL,
+    RID_SVXSTR_COLOR_LIGHTGREEN,
+    RID_SVXSTR_COLOR_LIGHTLIME,
+    RID_SVXSTR_COLOR_DARKGRAY,
+    RID_SVXSTR_COLOR_DARKYELLOW,
+    RID_SVXSTR_COLOR_DARKGOLD,
+    RID_SVXSTR_COLOR_DARKORANGE,
+    RID_SVXSTR_COLOR_DARKBRICK,
+    RID_SVXSTR_COLOR_DARKRED,
+    RID_SVXSTR_COLOR_DARKMAGENTA,
+    RID_SVXSTR_COLOR_DARKPURPLE,
+    RID_SVXSTR_COLOR_DARKINDIGO,
+    RID_SVXSTR_COLOR_DARKBLUE,
+    RID_SVXSTR_COLOR_DARKTEAL,
+    RID_SVXSTR_COLOR_DARKGREEN,
+    RID_SVXSTR_COLOR_DARKLIME,
+    RID_SVXSTR_COLOR_VIOLET,
+    RID_SVXSTR_COLOR_VIOLET_OUG,
+    RID_SVXSTR_COLOR_BLUE_OUG,
+    RID_SVXSTR_COLOR_AZURE_OUG,
+    RID_SVXSTR_COLOR_SPRINGGREEN_OUG,
+    RID_SVXSTR_COLOR_GREEN_OUG,
+    RID_SVXSTR_COLOR_CHARTREUSEGREEN_OUG,
+    RID_SVXSTR_COLOR_ORANGE_OUG,
+    RID_SVXSTR_COLOR_RED_OUG,
+    RID_SVXSTR_COLOR_ROSE_OUG,
+    RID_SVXSTR_COLOR_AZURE,
+    RID_SVXSTR_COLOR_CYAN,
+    RID_SVXSTR_COLOR_SPRINGGREEN,
+    RID_SVXSTR_COLOR_CHARTREUSEGREEN,
+    RID_SVXSTR_COLOR_ROSE,
+    RID_SVXSTR_COLOR_MATERIAL_GRAY_A,
+    RID_SVXSTR_COLOR_MATERIAL_YELLOW_A,
+    RID_SVXSTR_COLOR_MATERIAL_AMBER_A,
+    RID_SVXSTR_COLOR_MATERIAL_AMBER,
+    RID_SVXSTR_COLOR_MATERIAL_ORANGE_A,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_ORANGE_A,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_ORANGE,
+    RID_SVXSTR_COLOR_MATERIAL_RED_A,
+    RID_SVXSTR_COLOR_MATERIAL_PINK_A,
+    RID_SVXSTR_COLOR_MATERIAL_PURPLE_A,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_PURPLE_A,
+    RID_SVXSTR_COLOR_MATERIAL_DEEP_PURPLE,
+    RID_SVXSTR_COLOR_MATERIAL_INDIGO_A,
+    RID_SVXSTR_COLOR_MATERIAL_BLUE_A,
+    RID_SVXSTR_COLOR_MATERIAL_LIGHT_BLUE_A,
+    RID_SVXSTR_COLOR_MATERIAL_CYAN_A,
+    RID_SVXSTR_COLOR_MATERIAL_TEAL_A,
+    RID_SVXSTR_COLOR_MATERIAL_GREEN_A,
+    RID_SVXSTR_COLOR_MATERIAL_LIGHT_GREEN_A,
+    RID_SVXSTR_COLOR_MATERIAL_LIME_A,
+    RID_SVXSTR_COLOR_MATERIAL_BROWN_A,
+    RID_SVXSTR_COLOR_MATERIAL_BROWN,
+    RID_SVXSTR_COLOR_MATERIAL_BLUE_GRAY_A,
+    RID_SVXSTR_COLOR_MATERIAL_BLUE_GRAY,
+    RID_SVXSTR_COLOR_LIBRE_GREEN_1,
+    RID_SVXSTR_COLOR_LIBRE_GREEN_ACCENT,
+    RID_SVXSTR_COLOR_LIBRE_BLUE_ACCENT,
+    RID_SVXSTR_COLOR_LIBRE_ORANGE_ACCENT,
+    RID_SVXSTR_COLOR_LIBRE_PURPLE,
+    RID_SVXSTR_COLOR_LIBRE_PURPLE_ACCENT,
+    RID_SVXSTR_COLOR_LIBRE_YELLOW_ACCENT
+};
+
+/// @throws std::exception
+static bool SvxUnoConvertResourceStringBuiltIn(const char** pSourceResIds, const char** pDestResIds, int nCount, OUString& rString, bool bToApi)
+{
+    //We replace e.g. "Gray 10%" with the translation of Gray, but we shouldn't
+    //replace "Red Hat 1" with the translation of Red :-)
+    sal_Int32 nLength = rString.getLength();
+    while( nLength > 0 )
+    {
+        const sal_Unicode nChar = rString[nLength-1];
+        if (nChar != '%' && (nChar < '0' || nChar > '9'))
+            break;
+        nLength--;
+    }
+    OUString sStr = rString.copy(0, nLength).trim();
+
+    for(int i = 0; i < nCount; ++i )
+    {
+        if (bToApi)
+        {
+            OUString aStrDefName = SvxResId(pSourceResIds[i]);
+            if( sStr == aStrDefName )
+            {
+                OUString aReplace = OUString::createFromAscii(pDestResIds[i]);
+                rString = rString.replaceAt( 0, aStrDefName.getLength(), aReplace );
+                return true;
+            }
+        }
+        else
+        {
+            if( sStr.equalsAscii(pSourceResIds[i]) )
+            {
+                OUString aReplace = SvxResId(pDestResIds[i]);
+                rString = rString.replaceAt( 0, strlen(pSourceResIds[i]), aReplace );
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+/** if the given name is a predefined name for the current language it is replaced by
+    the corresponding api name.
+*/
+OUString SvxUnogetApiNameForItem(const sal_uInt16 nWhich, const OUString& rInternalName)
+{
+    OUString aNew = rInternalName;
+
+    if( nWhich == sal_uInt16(XATTR_LINECOLOR) )
+    {
+        if (SvxUnoConvertResourceStringBuiltIn(SvxUnoColorNameResId, SvxUnoColorNameDefResId, SAL_N_ELEMENTS(SvxUnoColorNameResId), aNew, true))
+        {
+            return aNew;
+        }
+    }
+    else
+    {
+        const char** pApiResIds;
+        const char** pIntResIds;
+        int nCount;
+
+        if( SvxUnoGetResourceRanges(nWhich, pApiResIds, pIntResIds, nCount))
+        {
+            if (SvxUnoConvertResourceString(pIntResIds, pApiResIds, nCount, aNew, true))
+            {
+                return aNew;
+            }
+        }
+    }
+
+    // just use previous name, if nothing else was found.
+    return rInternalName;
+}
+
+/** if the given name is a predefined api name it is replaced by the predefined name
+    for the current language.
+*/
+OUString SvxUnogetInternalNameForItem(const sal_uInt16 nWhich, const OUString& rApiName)
+{
+    OUString aNew = rApiName;
+
+    if( nWhich == sal_uInt16(XATTR_LINECOLOR) )
+    {
+        if (SvxUnoConvertResourceStringBuiltIn(SvxUnoColorNameDefResId, SvxUnoColorNameResId, SAL_N_ELEMENTS(SvxUnoColorNameResId), aNew, false))
+        {
+            return aNew;
+        }
+    }
+    else
+    {
+        const char** pApiResIds;
+        const char** pIntResIds;
+        int nCount;
+
+        if (SvxUnoGetResourceRanges(nWhich, pApiResIds, pIntResIds, nCount))
+        {
+            if (SvxUnoConvertResourceString(pApiResIds, pIntResIds, nCount, aNew, false))
+            {
+                return aNew;
+            }
+        }
+    }
+
+    // just use previous name, if nothing else was found.
+    return rApiName;
+}
+
+
+rtl::Reference<comphelper::PropertySetInfo> const & SvxPropertySetInfoPool::getOrCreate( sal_Int32 nServiceId ) throw()
+{
+    SolarMutexGuard aGuard;
+
+    assert( nServiceId <= SVXUNO_SERVICEID_LASTID );
+
+    if( !mxInfos[ nServiceId ].is() )
+    {
+        mxInfos[nServiceId] = new comphelper::PropertySetInfo();
+
+        switch( nServiceId )
+        {
+        case SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS:
+            mxInfos[SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS]->add( ImplGetSvxDrawingDefaultsPropertyMap() );
+            break;
+        case SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS_WRITER:
+            mxInfos[SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS_WRITER]->add( ImplGetSvxDrawingDefaultsPropertyMap() );
+            mxInfos[SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS_WRITER]->remove( UNO_NAME_EDIT_PARA_IS_HANGING_PUNCTUATION );
+            // OD 13.10.2003 #i18732# - add property map for writer item 'IsFollowingTextFlow'
+            mxInfos[SVXUNO_SERVICEID_COM_SUN_STAR_DRAWING_DEFAULTS_WRITER]->add( ImplGetAdditionalWriterDrawingDefaultsPropertyMap() );
+            break;
+
+        default:
+            OSL_FAIL( "unknown service id!" );
+        }
+    }
+
+    return mxInfos[ nServiceId ];
+}
+
+rtl::Reference<comphelper::PropertySetInfo> SvxPropertySetInfoPool::mxInfos[SVXUNO_SERVICEID_LASTID+1] = { nullptr };
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoshap2.cxx b/svx/source/unodraw/unoshap2.cxx
new file mode 100644
index 000000000..81ee65620
--- /dev/null
+++ b/svx/source/unodraw/unoshap2.cxx
@@ -0,0 +1,1794 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/drawing/PolyPolygonBezierCoords.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <com/sun/star/awt/FontSlant.hpp>
+#include <com/sun/star/style/VerticalAlignment.hpp>
+#include <com/sun/star/drawing/TextVerticalAdjust.hpp>
+#include <com/sun/star/drawing/XEnhancedCustomShapeDefaulter.hpp>
+#include <com/sun/star/awt/TextAlign.hpp>
+#include <com/sun/star/style/ParagraphAdjust.hpp>
+#include <com/sun/star/drawing/PointSequenceSequence.hpp>
+#include <com/sun/star/drawing/PointSequence.hpp>
+#include <com/sun/star/drawing/PolygonKind.hpp>
+#include <com/sun/star/graphic/XGraphic.hpp>
+#include <com/sun/star/drawing/QRCode.hpp>
+#include <o3tl/any.hxx>
+#include <o3tl/safeint.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/wmf.hxx>
+#include <vcl/cvtgrf.hxx>
+#include <vcl/GraphicLoader.hxx>
+
+#include <svx/svdpool.hxx>
+
+#include <editeng/unoprnms.hxx>
+#include <svx/unoshape.hxx>
+#include <svx/unopage.hxx>
+#include <svx/svdobj.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svdouno.hxx>
+#include "shapeimpl.hxx"
+#include <svx/unoshprp.hxx>
+#include <svx/svdoashp.hxx>
+#include <svx/svdviter.hxx>
+#include <svx/svdview.hxx>
+#include <svx/svdopath.hxx>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/point/b2dpoint.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include <svx/svdograf.hxx>
+#include <sal/log.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <tools/stream.hxx>
+
+
+#include <memory>
+
+using namespace ::osl;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+
+#define QUERYINT( xint ) \
+    if( rType == cppu::UnoType<xint>::get() ) \
+        aAny <<= Reference< xint >(this)
+
+SvxShapeGroup::SvxShapeGroup(SdrObject* pObj, SvxDrawPage* pDrawPage)
+    : SvxShape(pObj, getSvxMapProvider().GetMap(SVXMAP_GROUP), getSvxMapProvider().GetPropertySet(SVXMAP_GROUP, SdrObject::GetGlobalDrawObjectItemPool()))
+    , mxPage(pDrawPage)
+{
+}
+
+SvxShapeGroup::~SvxShapeGroup() throw()
+{
+}
+
+void SvxShapeGroup::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
+{
+    SvxShape::Create( pNewObj, pNewPage );
+    mxPage = pNewPage;
+}
+
+
+uno::Any SAL_CALL SvxShapeGroup::queryInterface( const uno::Type & rType )
+{
+    return SvxShape::queryInterface( rType );
+}
+
+uno::Any SAL_CALL SvxShapeGroup::queryAggregation( const uno::Type & rType )
+{
+    uno::Any aAny;
+
+    QUERYINT( drawing::XShapeGroup );
+    else QUERYINT( drawing::XShapes );
+    else QUERYINT( drawing::XShapes2 );
+    else QUERYINT( container::XIndexAccess );
+    else QUERYINT( container::XElementAccess );
+    else
+        return SvxShape::queryAggregation( rType );
+
+    return aAny;
+}
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxShapeGroup::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+// css::drawing::XShape
+
+
+OUString SAL_CALL SvxShapeGroup::getShapeType()
+{
+    return SvxShape::getShapeType();
+}
+
+awt::Point SAL_CALL SvxShapeGroup::getPosition()
+{
+    return SvxShape::getPosition();
+}
+
+
+void SAL_CALL SvxShapeGroup::setPosition( const awt::Point& Position )
+{
+    SvxShape::setPosition(Position);
+}
+
+
+awt::Size SAL_CALL SvxShapeGroup::getSize()
+{
+    return SvxShape::getSize();
+}
+
+
+void SAL_CALL SvxShapeGroup::setSize( const awt::Size& rSize )
+{
+    SvxShape::setSize( rSize );
+}
+
+// drawing::XShapeGroup
+
+
+void SAL_CALL SvxShapeGroup::enterGroup(  )
+{
+    // Todo
+//  pDrView->EnterMarkedGroup();
+}
+
+
+void SAL_CALL SvxShapeGroup::leaveGroup(  )
+{
+    // Todo
+//  pDrView->LeaveOneGroup();
+}
+
+void SvxShapeGroup::addUnoShape( const uno::Reference< drawing::XShape >& xShape, size_t nPos )
+{
+    if (!HasSdrObject() || !mxPage.is())
+    {
+        OSL_FAIL("could not add XShape to group shape!");
+        return;
+    }
+
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+    if (!pShape)
+    {
+        OSL_FAIL("could not add XShape to group shape!");
+        return;
+    }
+
+    SdrObject* pSdrShape = pShape->GetSdrObject();
+    if( pSdrShape == nullptr )
+        pSdrShape = mxPage->CreateSdrObject_( xShape );
+
+    if( pSdrShape->IsInserted() )
+        pSdrShape->getParentSdrObjListFromSdrObject()->RemoveObject( pSdrShape->GetOrdNum() );
+
+    GetSdrObject()->GetSubList()->InsertObject(pSdrShape, nPos);
+    // TTTT Was created using mpModel in CreateSdrObject_ above
+    // TTTT may be good to add an assertion here for the future
+    // pSdrShape->SetModel(GetSdrObject()->GetModel());
+
+    // #85922# It makes no sense to set the layer asked
+    // from the group object since this is an iteration
+    // over the contained objects. In consequence, this
+    // statement erases all layer information from the draw
+    // objects. Layers need to be set at draw objects directly
+    // and have nothing to do with grouping at all.
+    // pSdrShape->SetLayer(pObject->GetLayer());
+
+    // Establish connection between new SdrObject and its wrapper before
+    // inserting the new shape into the group.  There a new wrapper
+    // would be created when this connection would not already exist.
+    pShape->Create( pSdrShape, mxPage.get() );
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+// XShapes
+void SAL_CALL SvxShapeGroup::add( const uno::Reference< drawing::XShape >& xShape )
+{
+    ::SolarMutexGuard aGuard;
+
+    // Add to the top of the stack (i.e. bottom of the list) by default.
+    addUnoShape(xShape, SAL_MAX_SIZE);
+}
+
+
+void SAL_CALL SvxShapeGroup::remove( const uno::Reference< drawing::XShape >& xShape )
+{
+    ::SolarMutexGuard aGuard;
+
+    SdrObject* pSdrShape = nullptr;
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+
+    if( pShape )
+        pSdrShape = pShape->GetSdrObject();
+
+    if( !HasSdrObject() || pSdrShape == nullptr || pSdrShape->getParentSdrObjectFromSdrObject() != GetSdrObject() )
+        throw uno::RuntimeException();
+
+    SdrObjList& rList = *pSdrShape->getParentSdrObjListFromSdrObject();
+
+    const size_t nObjCount = rList.GetObjCount();
+    size_t nObjNum = 0;
+    while( nObjNum < nObjCount )
+    {
+        if(rList.GetObj( nObjNum ) == pSdrShape )
+            break;
+        nObjNum++;
+    }
+
+    if( nObjNum < nObjCount )
+    {
+        // #i29181#
+        // If the SdrObject which is about to be deleted is in any selection,
+        // deselect it first.
+        SdrViewIter aIter( pSdrShape );
+
+        for ( SdrView* pView = aIter.FirstView(); pView; pView = aIter.NextView() )
+        {
+            if(SAL_MAX_SIZE != pView->TryToFindMarkedObject(pSdrShape))
+            {
+                pView->MarkObj(pSdrShape, pView->GetSdrPageView(), true);
+            }
+        }
+
+        SdrObject* pObject = rList.NbcRemoveObject( nObjNum );
+        SdrObject::Free( pObject );
+    }
+    else
+    {
+        SAL_WARN( "svx", "Fatality! SdrObject is not belonging to its SdrObjList! [CL]" );
+    }
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+void SAL_CALL SvxShapeGroup::addTop( const uno::Reference< drawing::XShape >& xShape )
+{
+    SolarMutexGuard aGuard;
+
+    // Add to the top of the stack (i.e. bottom of the list).
+    addUnoShape(xShape, SAL_MAX_SIZE);
+}
+
+void SAL_CALL SvxShapeGroup::addBottom( const uno::Reference< drawing::XShape >& xShape )
+{
+    SolarMutexGuard aGuard;
+
+    // Add to the bottom of the stack (i.e. top of the list).
+    addUnoShape(xShape, 0);
+}
+
+// XIndexAccess
+
+
+sal_Int32 SAL_CALL SvxShapeGroup::getCount()
+{
+    ::SolarMutexGuard aGuard;
+
+    if(!HasSdrObject() || !GetSdrObject()->GetSubList())
+        throw uno::RuntimeException();
+
+    sal_Int32 nRetval = GetSdrObject()->GetSubList()->GetObjCount();
+    return nRetval;
+}
+
+
+uno::Any SAL_CALL SvxShapeGroup::getByIndex( sal_Int32 Index )
+{
+    ::SolarMutexGuard aGuard;
+
+    if( !HasSdrObject() || GetSdrObject()->GetSubList() == nullptr )
+        throw uno::RuntimeException();
+
+    if( Index<0 || GetSdrObject()->GetSubList()->GetObjCount() <= o3tl::make_unsigned(Index) )
+        throw lang::IndexOutOfBoundsException();
+
+    SdrObject* pDestObj = GetSdrObject()->GetSubList()->GetObj( Index );
+
+    if(pDestObj == nullptr)
+        throw lang::IndexOutOfBoundsException();
+
+    Reference< drawing::XShape > xShape( pDestObj->getUnoShape(), uno::UNO_QUERY );
+    return uno::makeAny( xShape );
+}
+
+// css::container::XElementAccess
+
+
+uno::Type SAL_CALL SvxShapeGroup::getElementType()
+{
+    return cppu::UnoType<drawing::XShape>::get();
+}
+
+
+sal_Bool SAL_CALL SvxShapeGroup::hasElements()
+{
+    ::SolarMutexGuard aGuard;
+
+    return HasSdrObject() && GetSdrObject()->GetSubList() && (GetSdrObject()->GetSubList()->GetObjCount() > 0);
+}
+
+SvxShapeConnector::SvxShapeConnector(SdrObject* pObj)
+    : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CONNECTOR), getSvxMapProvider().GetPropertySet(SVXMAP_CONNECTOR, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+
+SvxShapeConnector::~SvxShapeConnector() throw()
+{
+}
+
+
+uno::Any SAL_CALL SvxShapeConnector::queryInterface( const uno::Type & rType )
+{
+    return SvxShapeText::queryInterface( rType );
+}
+
+uno::Any SAL_CALL SvxShapeConnector::queryAggregation( const uno::Type & rType )
+{
+    uno::Any aAny;
+
+    QUERYINT( drawing::XConnectorShape );
+    else
+        return SvxShapeText::queryAggregation( rType );
+
+    return aAny;
+}
+
+// XTypeProvider
+
+uno::Sequence< uno::Type > SAL_CALL SvxShapeConnector::getTypes()
+{
+    return SvxShape::getTypes();
+}
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxShapeConnector::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+// css::drawing::XShape
+
+
+OUString SAL_CALL SvxShapeConnector::getShapeType()
+{
+    return SvxShapeText::getShapeType();
+}
+
+awt::Point SAL_CALL SvxShapeConnector::getPosition()
+{
+    return SvxShapeText::getPosition();
+}
+
+
+void SAL_CALL SvxShapeConnector::setPosition( const awt::Point& Position )
+{
+    SvxShapeText::setPosition(Position);
+}
+
+
+awt::Size SAL_CALL SvxShapeConnector::getSize()
+{
+    return SvxShapeText::getSize();
+}
+
+
+void SAL_CALL SvxShapeConnector::setSize( const awt::Size& rSize )
+{
+    SvxShapeText::setSize( rSize );
+}
+
+
+// XConnectorShape
+
+void SAL_CALL SvxShapeConnector::connectStart( const uno::Reference< drawing::XConnectableShape >& xShape, drawing::ConnectionType )
+{
+    ::SolarMutexGuard aGuard;
+
+    Reference< drawing::XShape > xRef( xShape, UNO_QUERY );
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xRef );
+
+    if( pShape )
+        GetSdrObject()->ConnectToNode( true, pShape->GetSdrObject() );
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+
+void SAL_CALL SvxShapeConnector::connectEnd( const uno::Reference< drawing::XConnectableShape >& xShape, drawing::ConnectionType  )
+{
+    ::SolarMutexGuard aGuard;
+
+    Reference< drawing::XShape > xRef( xShape, UNO_QUERY );
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xRef );
+
+    if( HasSdrObject() && pShape )
+        GetSdrObject()->ConnectToNode( false, pShape->GetSdrObject() );
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+
+void SAL_CALL SvxShapeConnector::disconnectBegin( const uno::Reference< drawing::XConnectableShape >&  )
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+        GetSdrObject()->DisconnectFromNode( true );
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+
+void SAL_CALL SvxShapeConnector::disconnectEnd( const uno::Reference< drawing::XConnectableShape >& )
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+        GetSdrObject()->DisconnectFromNode( false );
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+SvxShapeControl::SvxShapeControl(SdrObject* pObj)
+    : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CONTROL), getSvxMapProvider().GetPropertySet(SVXMAP_CONTROL, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+    setShapeKind( OBJ_UNO );
+}
+
+
+SvxShapeControl::~SvxShapeControl() throw()
+{
+}
+
+
+uno::Any SAL_CALL SvxShapeControl::queryInterface( const uno::Type & rType )
+{
+    return SvxShapeText::queryInterface( rType );
+}
+
+uno::Any SAL_CALL SvxShapeControl::queryAggregation( const uno::Type & rType )
+{
+    uno::Any aAny;
+
+    QUERYINT( drawing::XControlShape );
+    else
+        return SvxShapeText::queryAggregation( rType );
+
+    return aAny;
+}
+
+// XTypeProvider
+
+uno::Sequence< uno::Type > SAL_CALL SvxShapeControl::getTypes()
+{
+    return SvxShape::getTypes();
+}
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxShapeControl::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+// css::drawing::XShape
+
+
+OUString SAL_CALL SvxShapeControl::getShapeType()
+{
+    return SvxShapeText::getShapeType();
+}
+
+awt::Point SAL_CALL SvxShapeControl::getPosition()
+{
+    return SvxShapeText::getPosition();
+}
+
+
+void SAL_CALL SvxShapeControl::setPosition( const awt::Point& Position )
+{
+    SvxShapeText::setPosition(Position);
+}
+
+
+awt::Size SAL_CALL SvxShapeControl::getSize()
+{
+    return SvxShapeText::getSize();
+}
+
+
+void SAL_CALL SvxShapeControl::setSize( const awt::Size& rSize )
+{
+    SvxShapeText::setSize( rSize );
+}
+
+
+// XControlShape
+
+Reference< awt::XControlModel > SAL_CALL SvxShapeControl::getControl()
+{
+    ::SolarMutexGuard aGuard;
+
+    Reference< awt::XControlModel > xModel;
+
+    SdrUnoObj* pUnoObj = dynamic_cast< SdrUnoObj * >(GetSdrObject());
+    if( pUnoObj )
+        xModel = pUnoObj->GetUnoControlModel();
+
+    return xModel;
+}
+
+
+void SAL_CALL SvxShapeControl::setControl( const Reference< awt::XControlModel >& xControl )
+{
+    ::SolarMutexGuard aGuard;
+
+    SdrUnoObj* pUnoObj = dynamic_cast< SdrUnoObj * >(GetSdrObject());
+    if( pUnoObj )
+        pUnoObj->SetUnoControlModel( xControl );
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+static struct
+{
+    const char* mpAPIName;
+    sal_uInt16  mnAPINameLen;
+
+    const char* mpFormName;
+    sal_uInt16  mnFormNameLen;
+}
+const SvxShapeControlPropertyMapping[] =
+{
+    // Warning: The first entry must be FontSlant because the any needs to be converted
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_POSTURE), RTL_CONSTASCII_STRINGPARAM("FontSlant")  }, //  const sal_Int16 => css::awt::FontSlant
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_FONTNAME), RTL_CONSTASCII_STRINGPARAM("FontName") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_FONTSTYLENAME), RTL_CONSTASCII_STRINGPARAM("FontStyleName") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_FONTFAMILY), RTL_CONSTASCII_STRINGPARAM("FontFamily") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_FONTCHARSET), RTL_CONSTASCII_STRINGPARAM("FontCharset") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_HEIGHT), RTL_CONSTASCII_STRINGPARAM("FontHeight") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_FONTPITCH), RTL_CONSTASCII_STRINGPARAM("FontPitch" ) },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_WEIGHT), RTL_CONSTASCII_STRINGPARAM("FontWeight" ) },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_UNDERLINE), RTL_CONSTASCII_STRINGPARAM("FontUnderline") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_STRIKEOUT), RTL_CONSTASCII_STRINGPARAM("FontStrikeout") },
+    { RTL_CONSTASCII_STRINGPARAM("CharKerning"), RTL_CONSTASCII_STRINGPARAM("FontKerning") },
+    { RTL_CONSTASCII_STRINGPARAM("CharWordMode"), RTL_CONSTASCII_STRINGPARAM("FontWordLineMode" ) },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_CHAR_COLOR),   RTL_CONSTASCII_STRINGPARAM("TextColor") },
+    { RTL_CONSTASCII_STRINGPARAM("CharBackColor"), RTL_CONSTASCII_STRINGPARAM("CharBackColor") },
+    { RTL_CONSTASCII_STRINGPARAM("CharBackTransparent"), RTL_CONSTASCII_STRINGPARAM("CharBackTransparent") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_TEXT_CHAINNEXTNAME), RTL_CONSTASCII_STRINGPARAM(UNO_NAME_TEXT_CHAINNEXTNAME) },
+    { RTL_CONSTASCII_STRINGPARAM("CharRelief"),   RTL_CONSTASCII_STRINGPARAM("FontRelief") },
+    { RTL_CONSTASCII_STRINGPARAM("CharUnderlineColor"),   RTL_CONSTASCII_STRINGPARAM("TextLineColor") },
+    { RTL_CONSTASCII_STRINGPARAM(UNO_NAME_EDIT_PARA_ADJUST), RTL_CONSTASCII_STRINGPARAM("Align") },
+    { RTL_CONSTASCII_STRINGPARAM("TextVerticalAdjust"), RTL_CONSTASCII_STRINGPARAM("VerticalAlign") },
+    { RTL_CONSTASCII_STRINGPARAM("ControlBackground"), RTL_CONSTASCII_STRINGPARAM("BackgroundColor") },
+    { RTL_CONSTASCII_STRINGPARAM("ControlSymbolColor"), RTL_CONSTASCII_STRINGPARAM("SymbolColor") },
+    { RTL_CONSTASCII_STRINGPARAM("ControlBorder"), RTL_CONSTASCII_STRINGPARAM("Border") },
+    { RTL_CONSTASCII_STRINGPARAM("ControlBorderColor"), RTL_CONSTASCII_STRINGPARAM("BorderColor") },
+    { RTL_CONSTASCII_STRINGPARAM("ControlTextEmphasis"),  RTL_CONSTASCII_STRINGPARAM("FontEmphasisMark") },
+    { RTL_CONSTASCII_STRINGPARAM("ImageScaleMode"),  RTL_CONSTASCII_STRINGPARAM("ScaleMode") },
+    { RTL_CONSTASCII_STRINGPARAM("ControlWritingMode"), RTL_CONSTASCII_STRINGPARAM("WritingMode") },
+    //added for exporting OCX control
+    { RTL_CONSTASCII_STRINGPARAM("ControlTypeinMSO"), RTL_CONSTASCII_STRINGPARAM("ControlTypeinMSO") },
+    { RTL_CONSTASCII_STRINGPARAM("ObjIDinMSO"), RTL_CONSTASCII_STRINGPARAM("ObjIDinMSO") },
+    { RTL_CONSTASCII_STRINGPARAM("CharCaseMap"), RTL_CONSTASCII_STRINGPARAM("CharCaseMap") },
+    { nullptr,0, nullptr, 0 }
+};
+
+namespace
+{
+    bool lcl_convertPropertyName( const OUString& rApiName, OUString& rInternalName )
+    {
+        sal_uInt16 i = 0;
+        while( SvxShapeControlPropertyMapping[i].mpAPIName )
+        {
+            if( rApiName.reverseCompareToAsciiL( SvxShapeControlPropertyMapping[i].mpAPIName, SvxShapeControlPropertyMapping[i].mnAPINameLen ) == 0 )
+            {
+                rInternalName = OUString( SvxShapeControlPropertyMapping[i].mpFormName, SvxShapeControlPropertyMapping[i].mnFormNameLen, RTL_TEXTENCODING_ASCII_US );
+            }
+            ++i;
+        }
+        return !rInternalName.isEmpty();
+    }
+
+    struct EnumConversionMap
+    {
+        style::ParagraphAdjust   nAPIValue;
+        sal_Int16                nFormValue;
+    };
+
+    EnumConversionMap const aMapAdjustToAlign[] =
+    {
+        // note that order matters:
+        // lcl_convertTextAlignmentToParaAdjustment and lcl_convertParaAdjustmentToTextAlignment search this map from the _beginning_
+        // and use the first matching entry
+        {style::ParagraphAdjust_LEFT,           sal_Int16(awt::TextAlign::LEFT)},
+        {style::ParagraphAdjust_CENTER,         sal_Int16(awt::TextAlign::CENTER)},
+        {style::ParagraphAdjust_RIGHT,          sal_Int16(awt::TextAlign::RIGHT)},
+        {style::ParagraphAdjust_BLOCK,          sal_Int16(awt::TextAlign::RIGHT)},
+        {style::ParagraphAdjust_STRETCH,        sal_Int16(awt::TextAlign::LEFT)},
+        {style::ParagraphAdjust(-1),-1}
+    };
+
+    void lcl_convertTextAlignmentToParaAdjustment( Any& _rValue )
+    {
+        sal_Int16 nValue = sal_Int16();
+        OSL_VERIFY( _rValue >>= nValue );
+
+        for ( auto const & rEntry : aMapAdjustToAlign )
+            if ( nValue == rEntry.nFormValue )
+            {
+                _rValue <<= static_cast<sal_uInt16>(rEntry.nAPIValue);
+                return;
+            }
+    }
+
+    void lcl_convertParaAdjustmentToTextAlignment( Any& _rValue )
+    {
+        sal_Int32 nValue = 0;
+        OSL_VERIFY( _rValue >>= nValue );
+
+        for ( auto const & rEntry : aMapAdjustToAlign )
+            if ( static_cast<style::ParagraphAdjust>(nValue) == rEntry.nAPIValue )
+            {
+                _rValue <<= rEntry.nFormValue;
+                return;
+            }
+    }
+
+    void convertVerticalAdjustToVerticalAlign( Any& _rValue )
+    {
+        if ( !_rValue.hasValue() )
+            return;
+
+        drawing::TextVerticalAdjust eAdjust = drawing::TextVerticalAdjust_TOP;
+        style::VerticalAlignment    eAlign  = style::VerticalAlignment_TOP;
+        if ( !( _rValue >>= eAdjust ) )
+            throw lang::IllegalArgumentException();
+        switch ( eAdjust )
+        {
+        case drawing::TextVerticalAdjust_TOP:    eAlign = style::VerticalAlignment_TOP; break;
+        case drawing::TextVerticalAdjust_BOTTOM: eAlign = style::VerticalAlignment_BOTTOM; break;
+        default:                                 eAlign = style::VerticalAlignment_MIDDLE; break;
+        }
+        _rValue <<= eAlign;
+    }
+
+    void convertVerticalAlignToVerticalAdjust( Any& _rValue )
+    {
+        if ( !_rValue.hasValue() )
+            return;
+        style::VerticalAlignment    eAlign  = style::VerticalAlignment_TOP;
+        drawing::TextVerticalAdjust eAdjust = drawing::TextVerticalAdjust_TOP;
+        OSL_VERIFY( _rValue >>= eAlign );
+        switch ( eAlign )
+        {
+        case style::VerticalAlignment_TOP:    eAdjust = drawing::TextVerticalAdjust_TOP; break;
+        case style::VerticalAlignment_BOTTOM: eAdjust = drawing::TextVerticalAdjust_BOTTOM; break;
+        default:                              eAdjust = drawing::TextVerticalAdjust_CENTER; break;
+        }
+        _rValue <<= eAdjust;
+    }
+}
+
+void SAL_CALL SvxShapeControl::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
+{
+    OUString aFormsName;
+    if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
+    {
+        uno::Reference< beans::XPropertySet > xControl( getControl(), uno::UNO_QUERY );
+        if( xControl.is() )
+        {
+            uno::Reference< beans::XPropertySetInfo > xInfo( xControl->getPropertySetInfo() );
+            if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
+            {
+                uno::Any aConvertedValue( aValue );
+                if ( aFormsName == "FontSlant" )
+                {
+                    awt::FontSlant nSlant;
+                    if( !(aValue >>= nSlant ) )
+                        throw lang::IllegalArgumentException();
+                    aConvertedValue <<= static_cast<sal_Int16>(nSlant);
+                }
+                else if ( aFormsName == "Align" )
+                {
+                    lcl_convertParaAdjustmentToTextAlignment( aConvertedValue );
+                }
+                else if ( aFormsName == "VerticalAlign" )
+                {
+                    convertVerticalAdjustToVerticalAlign( aConvertedValue );
+                }
+
+                xControl->setPropertyValue( aFormsName, aConvertedValue );
+            }
+        }
+    }
+    else
+    {
+        SvxShape::setPropertyValue( aPropertyName, aValue );
+    }
+}
+
+uno::Any SAL_CALL SvxShapeControl::getPropertyValue( const OUString& aPropertyName )
+{
+    OUString aFormsName;
+    if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
+    {
+        uno::Reference< beans::XPropertySet > xControl( getControl(), uno::UNO_QUERY );
+
+        uno::Any aValue;
+        if( xControl.is() )
+        {
+            uno::Reference< beans::XPropertySetInfo > xInfo( xControl->getPropertySetInfo() );
+            if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
+            {
+                aValue = xControl->getPropertyValue( aFormsName );
+                if ( aFormsName == "FontSlant" )
+                {
+                    awt::FontSlant eSlant = awt::FontSlant_NONE;
+                    sal_Int16 nSlant = sal_Int16();
+                    if ( aValue >>= nSlant )
+                    {
+                        eSlant = static_cast<awt::FontSlant>(nSlant);
+                    }
+                    else
+                    {
+                        OSL_VERIFY( aValue >>= eSlant );
+                    }
+                    aValue <<= eSlant;
+                }
+                else if ( aFormsName == "Align" )
+                {
+                    lcl_convertTextAlignmentToParaAdjustment( aValue );
+                }
+                else if ( aFormsName == "VerticalAlign" )
+                {
+                    convertVerticalAlignToVerticalAdjust( aValue );
+                }
+            }
+        }
+
+        return aValue;
+    }
+    else
+    {
+        return SvxShape::getPropertyValue( aPropertyName );
+    }
+
+}
+
+// XPropertyState
+beans::PropertyState SAL_CALL SvxShapeControl::getPropertyState( const OUString& PropertyName )
+{
+    OUString aFormsName;
+    if ( lcl_convertPropertyName( PropertyName, aFormsName ) )
+    {
+        uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
+        uno::Reference< beans::XPropertySet > xPropSet( getControl(), uno::UNO_QUERY );
+
+        if( xControl.is() && xPropSet.is() )
+        {
+            uno::Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
+            if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
+            {
+                return xControl->getPropertyState( aFormsName );
+            }
+        }
+
+        return beans::PropertyState_DEFAULT_VALUE;
+    }
+    else
+    {
+        return SvxShape::getPropertyState( PropertyName );
+    }
+}
+
+void SAL_CALL SvxShapeControl::setPropertyToDefault( const OUString& PropertyName )
+{
+    OUString aFormsName;
+    if ( lcl_convertPropertyName( PropertyName, aFormsName ) )
+    {
+        uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
+        uno::Reference< beans::XPropertySet > xPropSet( getControl(), uno::UNO_QUERY );
+
+        if( xControl.is() && xPropSet.is() )
+        {
+            uno::Reference< beans::XPropertySetInfo > xInfo( xPropSet->getPropertySetInfo() );
+            if( xInfo.is() && xInfo->hasPropertyByName( aFormsName ) )
+            {
+                xControl->setPropertyToDefault( aFormsName );
+            }
+        }
+    }
+    else
+    {
+        SvxShape::setPropertyToDefault( PropertyName );
+    }
+}
+
+uno::Any SAL_CALL SvxShapeControl::getPropertyDefault( const OUString& aPropertyName )
+{
+    OUString aFormsName;
+    if ( lcl_convertPropertyName( aPropertyName, aFormsName ) )
+    {
+        uno::Reference< beans::XPropertyState > xControl( getControl(), uno::UNO_QUERY );
+
+        if( xControl.is() )
+        {
+            Any aDefault( xControl->getPropertyDefault( aFormsName ) );
+            if ( aFormsName == "FontSlant" )
+            {
+                sal_Int16 nSlant( 0 );
+                aDefault >>= nSlant;
+                aDefault <<= static_cast<awt::FontSlant>(nSlant);
+            }
+            else if ( aFormsName == "Align" )
+            {
+                lcl_convertTextAlignmentToParaAdjustment( aDefault );
+            }
+            else if ( aFormsName == "VerticalAlign" )
+            {
+                convertVerticalAlignToVerticalAdjust( aDefault );
+            }
+            return aDefault;
+        }
+
+        throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
+    }
+    else
+    {
+        return SvxShape::getPropertyDefault( aPropertyName );
+    }
+}
+
+SvxShapeDimensioning::SvxShapeDimensioning(SdrObject* pObj)
+    : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_DIMENSIONING), getSvxMapProvider().GetPropertySet(SVXMAP_DIMENSIONING, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+SvxShapeDimensioning::~SvxShapeDimensioning() throw()
+{
+}
+
+SvxShapeCircle::SvxShapeCircle(SdrObject* pObj)
+    : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CIRCLE), getSvxMapProvider().GetPropertySet(SVXMAP_CIRCLE, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+SvxShapeCircle::~SvxShapeCircle() throw()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+SvxShapePolyPolygon::SvxShapePolyPolygon(
+    SdrObject* pObj)
+:   SvxShapeText(
+        pObj,
+        getSvxMapProvider().GetMap(SVXMAP_POLYPOLYGON),
+        getSvxMapProvider().GetPropertySet(SVXMAP_POLYPOLYGON, SdrObject::GetGlobalDrawObjectItemPool()))
+{
+}
+
+SvxShapePolyPolygon::~SvxShapePolyPolygon() throw()
+{
+}
+
+bool SvxShapePolyPolygon::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_VALUE_POLYPOLYGONBEZIER:
+    {
+        if( auto s = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(rValue) )
+        {
+            basegfx::B2DPolyPolygon aNewPolyPolygon(
+                basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(*s));
+
+            // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+            ForceMetricToItemPoolMetric(aNewPolyPolygon);
+
+            SetPolygon(aNewPolyPolygon);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_VALUE_POLYPOLYGON:
+    {
+        if( auto s = o3tl::tryAccess<drawing::PointSequenceSequence>(rValue) )
+        {
+            basegfx::B2DPolyPolygon aNewPolyPolygon(
+                basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(*s));
+
+            // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+            ForceMetricToItemPoolMetric(aNewPolyPolygon);
+
+            SetPolygon(aNewPolyPolygon);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_BASE_GEOMETRY:
+    {
+        drawing::PointSequenceSequence aPointSequenceSequence;
+        drawing::PolyPolygonBezierCoords aPolyPolygonBezierCoords;
+
+        if( rValue >>= aPointSequenceSequence)
+        {
+            if( HasSdrObject() )
+            {
+                basegfx::B2DPolyPolygon aNewPolyPolygon;
+                basegfx::B2DHomMatrix aNewHomogenMatrix;
+
+                GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+                aNewPolyPolygon = basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(aPointSequenceSequence);
+
+                // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+                // Need to adapt aNewPolyPolygon from 100thmm to app-specific
+                ForceMetricToItemPoolMetric(aNewPolyPolygon);
+
+                GetSdrObject()->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+            }
+            return true;
+        }
+        else if( rValue >>= aPolyPolygonBezierCoords)
+        {
+            if( HasSdrObject() )
+            {
+                basegfx::B2DPolyPolygon aNewPolyPolygon;
+                basegfx::B2DHomMatrix aNewHomogenMatrix;
+
+                GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+                aNewPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(aPolyPolygonBezierCoords);
+
+                // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+                ForceMetricToItemPoolMetric(aNewPolyPolygon);
+
+                GetSdrObject()->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+            }
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_VALUE_POLYGON:
+    {
+        if( auto pSequence = o3tl::tryAccess<drawing::PointSequence>(rValue) )
+        {
+            // prepare new polygon
+            basegfx::B2DPolygon aNewPolygon;
+
+            // get pointer to arrays
+            const awt::Point* pArray    = pSequence->getConstArray();
+            const awt::Point* pArrayEnd = pArray + pSequence->getLength();
+
+            for(;pArray != pArrayEnd;++pArray)
+            {
+                aNewPolygon.append(basegfx::B2DPoint(pArray->X, pArray->Y));
+            }
+
+            // check for closed state flag
+            basegfx::utils::checkClosed(aNewPolygon);
+
+            // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+            basegfx::B2DPolyPolygon aNewPolyPolygon(aNewPolygon);
+            ForceMetricToItemPoolMetric(aNewPolyPolygon);
+
+            // set polygon
+            SetPolygon(aNewPolyPolygon);
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw lang::IllegalArgumentException();
+}
+
+bool SvxShapePolyPolygon::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty,
+                                                css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_VALUE_POLYPOLYGONBEZIER:
+    {
+        // pack a tools::PolyPolygon in a struct tools::PolyPolygon
+        basegfx::B2DPolyPolygon aPolyPoly(GetPolygon());
+
+        // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+        ForceMetricTo100th_mm(aPolyPoly);
+
+        drawing::PolyPolygonBezierCoords aRetval;
+        basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords(aPolyPoly, aRetval);
+
+        rValue <<= aRetval;
+        break;
+    }
+    case OWN_ATTR_VALUE_POLYPOLYGON:
+    {
+        // pack a tools::PolyPolygon in a struct tools::PolyPolygon
+        basegfx::B2DPolyPolygon aPolyPoly(GetPolygon());
+
+        // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+        ForceMetricTo100th_mm(aPolyPoly);
+
+        drawing::PointSequenceSequence aRetval( aPolyPoly.count() );
+        basegfx::utils::B2DPolyPolygonToUnoPointSequenceSequence(aPolyPoly, aRetval);
+
+        rValue <<= aRetval;
+        break;
+    }
+    case OWN_ATTR_BASE_GEOMETRY:
+    {
+        // pack a tools::PolyPolygon in struct PolyPolygon
+        basegfx::B2DPolyPolygon aPolyPoly;
+        basegfx::B2DHomMatrix aNewHomogenMatrix;
+
+        if(HasSdrObject())
+        {
+            GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aPolyPoly);
+
+            // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+            ForceMetricTo100th_mm(aPolyPoly);
+        }
+
+        if(aPolyPoly.areControlPointsUsed())
+        {
+            drawing::PolyPolygonBezierCoords aRetval;
+            basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords(aPolyPoly, aRetval);
+            rValue <<= aRetval;
+        }
+        else
+        {
+            drawing::PointSequenceSequence aRetval(aPolyPoly.count());
+            basegfx::utils::B2DPolyPolygonToUnoPointSequenceSequence(aPolyPoly, aRetval);
+            rValue <<= aRetval;
+        }
+        break;
+    }
+    case OWN_ATTR_VALUE_POLYGON:
+    {
+        // pack a tools::PolyPolygon in a struct tools::PolyPolygon
+        basegfx::B2DPolyPolygon aPolyPoly(GetPolygon());
+
+        // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+        ForceMetricTo100th_mm(aPolyPoly);
+
+        const sal_Int32 nCount(0 == aPolyPoly.count() ? 0 : aPolyPoly.getB2DPolygon(0).count());
+        drawing::PointSequence aRetval( nCount );
+
+        if( nCount > 0 )
+        {
+            // get single polygon
+            const basegfx::B2DPolygon& aPoly(aPolyPoly.getB2DPolygon(0));
+
+            // get pointer to arrays
+            awt::Point* pSequence = aRetval.getArray();
+
+            for(sal_Int32 b=0;b<nCount;b++)
+            {
+                const basegfx::B2DPoint aPoint(aPoly.getB2DPoint(b));
+                *pSequence++ = awt::Point( basegfx::fround(aPoint.getX()), basegfx::fround(aPoint.getY()) );
+            }
+        }
+
+        rValue <<= aRetval;
+        break;
+    }
+    case OWN_ATTR_VALUE_POLYGONKIND:
+    {
+        rValue <<= GetPolygonKind();
+        break;
+    }
+    default:
+        return SvxShapeText::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+drawing::PolygonKind SvxShapePolyPolygon::GetPolygonKind() const
+{
+    ::SolarMutexGuard aGuard;
+    drawing::PolygonKind aRetval(drawing::PolygonKind_LINE);
+
+    if(HasSdrObject())
+    {
+        switch(GetSdrObject()->GetObjIdentifier())
+        {
+            case OBJ_POLY:      aRetval = drawing::PolygonKind_POLY; break;
+            case OBJ_PLIN:      aRetval = drawing::PolygonKind_PLIN; break;
+            case OBJ_SPLNLINE:
+            case OBJ_PATHLINE:  aRetval = drawing::PolygonKind_PATHLINE; break;
+            case OBJ_SPLNFILL:
+            case OBJ_PATHFILL:  aRetval = drawing::PolygonKind_PATHFILL; break;
+            case OBJ_FREELINE:  aRetval = drawing::PolygonKind_FREELINE; break;
+            case OBJ_FREEFILL:  aRetval = drawing::PolygonKind_FREEFILL; break;
+        }
+    }
+
+    return aRetval;
+}
+
+void SvxShapePolyPolygon::SetPolygon(const basegfx::B2DPolyPolygon& rNew)
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+        static_cast<SdrPathObj*>(GetSdrObject())->SetPathPoly(rNew);
+}
+
+
+basegfx::B2DPolyPolygon SvxShapePolyPolygon::GetPolygon() const throw()
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+    {
+        return static_cast<SdrPathObj*>(GetSdrObject())->GetPathPoly();
+    }
+    else
+    {
+        return basegfx::B2DPolyPolygon();
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+SvxGraphicObject::SvxGraphicObject(SdrObject* pObj)
+    : SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_GRAPHICOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_GRAPHICOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+SvxGraphicObject::~SvxGraphicObject() throw()
+{
+}
+
+bool SvxGraphicObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    bool bOk = false;
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_VALUE_FILLBITMAP:
+    {
+        if( auto pSeq = o3tl::tryAccess<uno::Sequence<sal_Int8>>(rValue) )
+        {
+            SvMemoryStream  aMemStm;
+            Graphic         aGraphic;
+
+            aMemStm.SetBuffer( const_cast<css::uno::Sequence<sal_Int8> *>(pSeq)->getArray(), pSeq->getLength(), pSeq->getLength() );
+
+            if( GraphicConverter::Import( aMemStm, aGraphic ) == ERRCODE_NONE )
+            {
+                static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(aGraphic);
+                bOk = true;
+            }
+        }
+        else if (rValue.getValueType() == cppu::UnoType<graphic::XGraphic>::get())
+        {
+            auto xGraphic = rValue.get<uno::Reference<graphic::XGraphic>>();
+            if (xGraphic.is())
+            {
+                static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(Graphic(xGraphic));
+                bOk = true;
+            }
+        }
+        else if (rValue.getValueType() == cppu::UnoType<awt::XBitmap>::get())
+        {
+            auto xBitmap = rValue.get<uno::Reference<awt::XBitmap>>();
+            if (xBitmap.is())
+            {
+                uno::Reference<graphic::XGraphic> xGraphic(xBitmap, uno::UNO_QUERY);
+                Graphic aGraphic(xGraphic);
+                static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(aGraphic);
+                bOk = true;
+            }
+        }
+        break;
+    }
+
+    case OWN_ATTR_GRAFSTREAMURL:
+    {
+        OUString aStreamURL;
+
+        if( rValue >>= aStreamURL )
+        {
+            if( !aStreamURL.startsWith( UNO_NAME_GRAPHOBJ_URLPKGPREFIX ) )
+                aStreamURL.clear();
+
+            if( HasSdrObject() )
+            {
+                static_cast<SdrGrafObj*>(GetSdrObject())->SetGrafStreamURL( aStreamURL );
+            }
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_GRAPHIC_URL:
+    {
+        OUString aURL;
+        uno::Reference<awt::XBitmap> xBitmap;
+        if (rValue >>= aURL)
+        {
+            Graphic aGraphic = vcl::graphic::loadFromURL(aURL);
+            if (!aGraphic.IsNone())
+            {
+                static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(aGraphic);
+                bOk = true;
+            }
+        }
+        else if (rValue >>= xBitmap)
+        {
+            uno::Reference<graphic::XGraphic> xGraphic(xBitmap, uno::UNO_QUERY);
+            if (xGraphic.is())
+            {
+                Graphic aGraphic = xGraphic;
+                if (!aGraphic.IsNone())
+                {
+                    static_cast<SdrGrafObj*>(GetSdrObject())->SetGraphic(aGraphic);
+                    bOk = true;
+                }
+            }
+        }
+        break;
+    }
+
+    case OWN_ATTR_VALUE_GRAPHIC:
+    {
+        Reference< graphic::XGraphic > xGraphic( rValue, uno::UNO_QUERY );
+        if( xGraphic.is() )
+        {
+            static_cast< SdrGrafObj*>( GetSdrObject() )->SetGraphic( xGraphic );
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_IS_SIGNATURELINE:
+    {
+        bool bIsSignatureLine;
+        if (rValue >>= bIsSignatureLine)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setIsSignatureLine(bIsSignatureLine);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_ID:
+    {
+        OUString aSignatureLineId;
+        if (rValue >>= aSignatureLineId)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineId(aSignatureLineId);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_NAME:
+    {
+        OUString aSuggestedSignerName;
+        if (rValue >>= aSuggestedSignerName)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSuggestedSignerName(aSuggestedSignerName);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_TITLE:
+    {
+        OUString aSuggestedSignerTitle;
+        if (rValue >>= aSuggestedSignerTitle)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSuggestedSignerTitle(aSuggestedSignerTitle);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_EMAIL:
+    {
+        OUString aSuggestedSignerEmail;
+        if (rValue >>= aSuggestedSignerEmail)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSuggestedSignerEmail(aSuggestedSignerEmail);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SIGNING_INSTRUCTIONS:
+    {
+        OUString aSigningInstructions;
+        if (rValue >>= aSigningInstructions)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineSigningInstructions(aSigningInstructions);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SHOW_SIGN_DATE:
+    {
+        bool bShowSignDate;
+        if (rValue >>= bShowSignDate)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineShowSignDate(bShowSignDate);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_CAN_ADD_COMMENT:
+    {
+        bool bCanAddComment;
+        if (rValue >>= bCanAddComment)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineCanAddComment(bCanAddComment);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_UNSIGNED_IMAGE:
+    {
+        Reference<graphic::XGraphic> xGraphic(rValue, uno::UNO_QUERY);
+        if (xGraphic.is())
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineUnsignedGraphic(xGraphic);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_IS_SIGNED:
+    {
+        bool bIsSigned;
+        if (rValue >>= bIsSigned)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setSignatureLineIsSigned(bIsSigned);
+            bOk = true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_QRCODE:
+    {
+        css::drawing::QRCode aQrCode;
+        if (rValue >>= aQrCode)
+        {
+            static_cast<SdrGrafObj*>(GetSdrObject())->setQrCode(aQrCode);
+            bOk = true;
+        }
+        break;
+    }
+
+    default:
+        return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    if( !bOk )
+        throw lang::IllegalArgumentException();
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+
+    return true;
+}
+
+bool SvxGraphicObject::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_VALUE_FILLBITMAP:
+    {
+        const Graphic& rGraphic = static_cast<SdrGrafObj*>(GetSdrObject())->GetGraphic();
+
+        if (rGraphic.GetType() != GraphicType::GdiMetafile)
+        {
+            uno::Reference<awt::XBitmap> xBitmap(rGraphic.GetXGraphic(), uno::UNO_QUERY);
+            rValue <<= xBitmap;
+        }
+        else
+        {
+            SvMemoryStream aDestStrm( 65535, 65535 );
+
+            ConvertGDIMetaFileToWMF( rGraphic.GetGDIMetaFile(), aDestStrm, nullptr, false );
+            const uno::Sequence<sal_Int8> aSeq(
+                static_cast< const sal_Int8* >(aDestStrm.GetData()),
+                aDestStrm.GetEndOfData());
+            rValue <<= aSeq;
+        }
+        break;
+    }
+
+    case OWN_ATTR_REPLACEMENT_GRAPHIC:
+    {
+        const GraphicObject* pGrafObj = static_cast< SdrGrafObj* >(GetSdrObject())->GetReplacementGraphicObject();
+
+        if (pGrafObj)
+        {
+            rValue <<= pGrafObj->GetGraphic().GetXGraphic();
+        }
+
+        break;
+    }
+
+    case OWN_ATTR_GRAFSTREAMURL:
+    {
+        const OUString  aStreamURL( static_cast<SdrGrafObj*>( GetSdrObject() )->GetGrafStreamURL() );
+        if( !aStreamURL.isEmpty() )
+            rValue <<= aStreamURL;
+        break;
+    }
+
+    case OWN_ATTR_GRAPHIC_URL:
+    case OWN_ATTR_VALUE_GRAPHIC:
+    {
+        if (pProperty->nWID == OWN_ATTR_GRAPHIC_URL)
+        {
+            SAL_WARN("svx", "Getting Graphic by URL is not supported, getting it by value");
+        }
+
+        Reference<graphic::XGraphic> xGraphic;
+        auto pSdrGraphicObject = static_cast<SdrGrafObj*>(GetSdrObject());
+        if (pSdrGraphicObject->GetGraphicObject().GetType() != GraphicType::NONE)
+            xGraphic = pSdrGraphicObject->GetGraphic().GetXGraphic();
+        rValue <<= xGraphic;
+        break;
+    }
+
+    case OWN_ATTR_GRAPHIC_STREAM:
+    {
+        rValue <<= static_cast< SdrGrafObj* >( GetSdrObject() )->getInputStream();
+        break;
+    }
+
+    case OWN_ATTR_IS_SIGNATURELINE:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLine();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_ID:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineId();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_NAME:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSuggestedSignerName();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_TITLE:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSuggestedSignerTitle();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SUGGESTED_SIGNER_EMAIL:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSuggestedSignerEmail();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SIGNING_INSTRUCTIONS:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineSigningInstructions();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_SHOW_SIGN_DATE:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLineShowSignDate();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_CAN_ADD_COMMENT:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLineCanAddComment();
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_UNSIGNED_IMAGE:
+    {
+        Reference<graphic::XGraphic> xGraphic(
+            static_cast<SdrGrafObj*>(GetSdrObject())->getSignatureLineUnsignedGraphic());
+        rValue <<= xGraphic;
+        break;
+    }
+
+    case OWN_ATTR_SIGNATURELINE_IS_SIGNED:
+    {
+        rValue <<= static_cast<SdrGrafObj*>(GetSdrObject())->isSignatureLineSigned();
+        break;
+    }
+
+    case OWN_ATTR_QRCODE:
+    {
+        css::drawing::QRCode* ptr = static_cast<SdrGrafObj*>(GetSdrObject())->getQrCode();
+        if(ptr)
+        {
+            rValue <<= *ptr;
+        }
+        break;
+    }
+
+    default:
+        return SvxShapeText::getPropertyValueImpl(rName, pProperty,rValue);
+    }
+
+    return true;
+}
+
+
+SvxShapeCaption::SvxShapeCaption(SdrObject* pObj)
+: SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_CAPTION), getSvxMapProvider().GetPropertySet(SVXMAP_CAPTION, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+SvxShapeCaption::~SvxShapeCaption() throw()
+{
+}
+
+SvxCustomShape::SvxCustomShape(SdrObject* pObj)
+    : SvxShapeText( pObj, getSvxMapProvider().GetMap( SVXMAP_CUSTOMSHAPE ), getSvxMapProvider().GetPropertySet(SVXMAP_CUSTOMSHAPE, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+SvxCustomShape::~SvxCustomShape() throw()
+{
+}
+
+uno::Any SAL_CALL SvxCustomShape::queryInterface( const uno::Type & rType )
+{
+    return SvxShapeText::queryInterface( rType );
+}
+
+uno::Any SAL_CALL SvxCustomShape::queryAggregation( const uno::Type & rType )
+{
+    css::uno::Any aReturn = SvxShapeText::queryAggregation( rType );
+    if ( !aReturn.hasValue() )
+        aReturn = ::cppu::queryInterface(rType, static_cast<drawing::XEnhancedCustomShapeDefaulter*>(this) );
+    return aReturn;
+}
+
+uno::Sequence< uno::Type > SAL_CALL SvxCustomShape::getTypes()
+{
+    return SvxShapeText::getTypes();
+}
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxCustomShape::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+// css::drawing::XShape
+
+
+awt::Point SAL_CALL SvxCustomShape::getPosition()
+{
+    ::SolarMutexGuard aGuard;
+    if ( HasSdrObject() )
+    {
+        SdrAShapeObjGeoData aCustomShapeGeoData;
+        static_cast<SdrObjCustomShape*>(GetSdrObject())->SaveGeoData( aCustomShapeGeoData );
+
+        bool bMirroredX = false;
+        bool bMirroredY = false;
+
+        if ( HasSdrObject() )
+        {
+            bMirroredX = static_cast<SdrObjCustomShape*>(GetSdrObject())->IsMirroredX();
+            bMirroredY = static_cast<SdrObjCustomShape*>(GetSdrObject())->IsMirroredY();
+        }
+        // get aRect, this is the unrotated snaprect
+        tools::Rectangle aRect(static_cast<SdrObjCustomShape*>(GetSdrObject())->GetLogicRect());
+        tools::Rectangle aRectangle( aRect );
+
+        if ( bMirroredX || bMirroredY )
+        {   // we have to retrieve the unmirrored rect
+
+            GeoStat aNewGeo( aCustomShapeGeoData.aGeo );
+            if ( bMirroredX )
+            {
+                tools::Polygon aPol( Rect2Poly( aRect, aNewGeo ) );
+                tools::Rectangle aBoundRect( aPol.GetBoundRect() );
+
+                Point aRef1( ( aBoundRect.Left() + aBoundRect.Right() ) >> 1, aBoundRect.Top() );
+                Point aRef2( aRef1.X(), aRef1.Y() + 1000 );
+                sal_uInt16 i;
+                sal_uInt16 nPointCount=aPol.GetSize();
+                for (i=0; i<nPointCount; i++)
+                {
+                    MirrorPoint(aPol[i],aRef1,aRef2);
+                }
+                // turn and move polygon
+                tools::Polygon aPol0(aPol);
+                aPol[0]=aPol0[1];
+                aPol[1]=aPol0[0];
+                aPol[2]=aPol0[3];
+                aPol[3]=aPol0[2];
+                aPol[4]=aPol0[1];
+                Poly2Rect(aPol,aRectangle,aNewGeo);
+            }
+            if ( bMirroredY )
+            {
+                tools::Polygon aPol( Rect2Poly( aRectangle, aNewGeo ) );
+                tools::Rectangle aBoundRect( aPol.GetBoundRect() );
+
+                Point aRef1( aBoundRect.Left(), ( aBoundRect.Top() + aBoundRect.Bottom() ) >> 1 );
+                Point aRef2( aRef1.X() + 1000, aRef1.Y() );
+                sal_uInt16 i;
+                sal_uInt16 nPointCount=aPol.GetSize();
+                for (i=0; i<nPointCount; i++)
+                {
+                    MirrorPoint(aPol[i],aRef1,aRef2);
+                }
+                // turn and move polygon
+                tools::Polygon aPol0(aPol);
+                aPol[0]=aPol0[1];
+                aPol[1]=aPol0[0];
+                aPol[2]=aPol0[3];
+                aPol[3]=aPol0[2];
+                aPol[4]=aPol0[1];
+                Poly2Rect( aPol, aRectangle, aNewGeo );
+            }
+        }
+        Point aPt( aRectangle.TopLeft() );
+
+        if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+            aPt -= GetSdrObject()->GetAnchorPos();
+
+        ForceMetricTo100th_mm(aPt);
+        return css::awt::Point( aPt.X(), aPt.Y() );
+    }
+    else
+        return SvxShape::getPosition();
+}
+
+
+void SAL_CALL SvxCustomShape::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
+{
+    ::SolarMutexGuard aGuard;
+
+    SdrObject* pObject = GetSdrObject();
+
+    // tdf#98163 Use a custom slot to have filter code flush the UNO
+    // API implementations of SdrObjCustomShape. Used e.g. by
+    // ~SdXMLCustomShapeContext, see there for more information
+    const OUString sFlushCustomShapeUnoApiObjects("FlushCustomShapeUnoApiObjects");
+    if(sFlushCustomShapeUnoApiObjects == aPropertyName)
+    {
+        SdrObjCustomShape* pTarget = dynamic_cast< SdrObjCustomShape* >(pObject);
+        if(pTarget)
+        {
+            // Luckily, the object causing problems in tdf#93994 is not the
+            // UNO API object, but the XCustomShapeEngine involved. This
+            // object is on-demand replaceable and can be reset here. This
+            // will free the involved EditEngine and VirtualDevice.
+            pTarget->mxCustomShapeEngine.set(nullptr);
+        }
+        // since this case is only for the application cores
+        // we should return from this function now
+        return;
+    }
+
+    bool bCustomShapeGeometry = pObject && aPropertyName == "CustomShapeGeometry";
+
+    bool bMirroredX = false;
+    bool bMirroredY = false;
+
+    if ( bCustomShapeGeometry )
+    {
+        bMirroredX = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredX();
+        bMirroredY = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredY();
+    }
+
+    SvxShape::setPropertyValue( aPropertyName, aValue );
+
+    if ( bCustomShapeGeometry )
+    {
+        static_cast<SdrObjCustomShape*>(pObject)->MergeDefaultAttributes();
+        tools::Rectangle aRect( pObject->GetSnapRect() );
+
+        // #i38892#
+        bool bNeedsMirrorX = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredX() != bMirroredX;
+        bool bNeedsMirrorY = static_cast<SdrObjCustomShape*>(pObject)->IsMirroredY() != bMirroredY;
+
+        std::unique_ptr< SdrGluePointList > pListCopy;
+        if( bNeedsMirrorX || bNeedsMirrorY )
+        {
+            const SdrGluePointList* pList = pObject->GetGluePointList();
+            if( pList )
+                pListCopy.reset( new SdrGluePointList(*pList) );
+        }
+
+        if ( bNeedsMirrorX )
+        {
+            Point aTop( ( aRect.Left() + aRect.Right() ) >> 1, aRect.Top() );
+            Point aBottom( aTop.X(), aTop.Y() + 1000 );
+            pObject->NbcMirror( aTop, aBottom );
+            // NbcMirroring is flipping the current mirror state,
+            // so we have to set the correct state again
+            static_cast<SdrObjCustomShape*>(pObject)->SetMirroredX( !bMirroredX );
+        }
+        if ( bNeedsMirrorY )
+        {
+            Point aLeft( aRect.Left(), ( aRect.Top() + aRect.Bottom() ) >> 1 );
+            Point aRight( aLeft.X() + 1000, aLeft.Y() );
+            pObject->NbcMirror( aLeft, aRight );
+            // NbcMirroring is flipping the current mirror state,
+            // so we have to set the correct state again
+            static_cast<SdrObjCustomShape*>(pObject)->SetMirroredY( !bMirroredY );
+        }
+
+        if( pListCopy )
+        {
+            SdrGluePointList* pNewList = const_cast< SdrGluePointList* >( pObject->GetGluePointList() );
+            if(pNewList)
+                *pNewList = *pListCopy;
+        }
+    }
+}
+
+bool SvxCustomShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case SDRATTR_ROTATEANGLE:
+    {
+        double fAngle = static_cast<SdrObjCustomShape*>(GetSdrObject())->GetObjectRotation();
+        fAngle *= 100;
+        rValue <<= static_cast<sal_Int32>(fAngle);
+        return true;
+    }
+    default:
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+
+void SvxCustomShape::createCustomShapeDefaults( const OUString& rValueType )
+{
+    if (!HasSdrObject())
+    {
+        OSL_FAIL("could not create Custom Shape Defaults!");
+        return;
+    }
+
+    static_cast<SdrObjCustomShape*>(GetSdrObject())->MergeDefaultAttributes( &rValueType );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoshap3.cxx b/svx/source/unodraw/unoshap3.cxx
new file mode 100644
index 000000000..a163da88a
--- /dev/null
+++ b/svx/source/unodraw/unoshap3.cxx
@@ -0,0 +1,1035 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <initializer_list>
+
+#include <com/sun/star/drawing/HomogenMatrix.hpp>
+#include <com/sun/star/drawing/Position3D.hpp>
+#include <com/sun/star/drawing/Direction3D.hpp>
+#include <com/sun/star/drawing/DoubleSequence.hpp>
+#include <com/sun/star/drawing/CameraGeometry.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <o3tl/safeint.hxx>
+#include <vcl/svapp.hxx>
+#include <comphelper/sequence.hxx>
+#include <sal/log.hxx>
+
+#include <svx/svdpool.hxx>
+#include <svx/svditer.hxx>
+#include <svx/unoshape.hxx>
+#include <svx/unopage.hxx>
+#include <svx/cube3d.hxx>
+#include <svx/sphere3d.hxx>
+#include <svx/lathe3d.hxx>
+#include <extrud3d.hxx>
+#include <polygn3d.hxx>
+#include <svx/unoshprp.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/scene3d.hxx>
+#include <basegfx/polygon/b3dpolygon.hxx>
+#include <basegfx/polygon/b3dpolygontools.hxx>
+#include <com/sun/star/drawing/PolyPolygonShape3D.hpp>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <basegfx/matrix/b3dhommatrixtools.hxx>
+#include "shapeimpl.hxx"
+
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+
+#define QUERYINT( xint ) \
+    if( rType == cppu::UnoType<xint>::get() ) \
+        aAny <<= Reference< xint >(this)
+
+Svx3DSceneObject::Svx3DSceneObject(SdrObject* pObj, SvxDrawPage* pDrawPage)
+:   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_3DSCENEOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_3DSCENEOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
+,   mxPage( pDrawPage )
+{
+}
+
+
+Svx3DSceneObject::~Svx3DSceneObject() throw()
+{
+}
+
+
+void Svx3DSceneObject::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
+{
+    SvxShape::Create( pNewObj, pNewPage );
+    mxPage = pNewPage;
+}
+
+
+uno::Any SAL_CALL Svx3DSceneObject::queryAggregation( const uno::Type & rType )
+{
+    uno::Any aAny;
+
+    QUERYINT( drawing::XShapes );
+    else QUERYINT( container::XIndexAccess );
+    else QUERYINT( container::XElementAccess );
+    else
+        return SvxShape::queryAggregation( rType );
+
+    return aAny;
+}
+
+uno::Any SAL_CALL Svx3DSceneObject::queryInterface( const uno::Type & rType )
+{
+    return SvxShape::queryInterface( rType );
+}
+
+// XTypeProvider
+
+uno::Sequence< sal_Int8 > SAL_CALL Svx3DSceneObject::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+
+void SAL_CALL Svx3DSceneObject::add( const Reference< drawing::XShape >& xShape )
+{
+    SolarMutexGuard aGuard;
+
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+
+    if(!HasSdrObject() || !mxPage.is() || pShape == nullptr || nullptr != pShape->GetSdrObject() )
+        throw uno::RuntimeException();
+
+    SdrObject* pSdrShape = mxPage->CreateSdrObject_( xShape );
+    if( dynamic_cast<const E3dObject* >(pSdrShape) !=  nullptr )
+    {
+        GetSdrObject()->GetSubList()->NbcInsertObject( pSdrShape );
+        pShape->Create(pSdrShape, mxPage.get());
+    }
+    else
+    {
+        SdrObject::Free( pSdrShape );
+        throw uno::RuntimeException();
+    }
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+
+void SAL_CALL Svx3DSceneObject::remove( const Reference< drawing::XShape >& xShape )
+{
+    SolarMutexGuard aGuard;
+
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+
+    if(!HasSdrObject() || pShape == nullptr)
+        throw uno::RuntimeException();
+
+    SdrObject* pSdrShape = pShape->GetSdrObject();
+    if(pSdrShape == nullptr || pSdrShape->getParentSdrObjectFromSdrObject() != GetSdrObject())
+    {
+        throw uno::RuntimeException();
+    }
+
+    SdrObjList& rList = *pSdrShape->getParentSdrObjListFromSdrObject();
+
+    const size_t nObjCount = rList.GetObjCount();
+    size_t nObjNum = 0;
+    while( nObjNum < nObjCount )
+    {
+        if(rList.GetObj( nObjNum ) == pSdrShape )
+            break;
+        nObjNum++;
+    }
+
+    if( nObjNum < nObjCount )
+    {
+        SdrObject* pObject = rList.NbcRemoveObject( nObjNum );
+        SdrObject::Free( pObject );
+    }
+    else
+    {
+        SAL_WARN( "svx", "Fatality! SdrObject is not belonging to its SdrObjList! [CL]" );
+    }
+}
+
+
+sal_Int32 SAL_CALL Svx3DSceneObject::getCount()
+{
+    SolarMutexGuard aGuard;
+
+    sal_Int32 nRetval = 0;
+
+    if(HasSdrObject() && dynamic_cast<const E3dScene* >(GetSdrObject()) != nullptr && GetSdrObject()->GetSubList())
+        nRetval = GetSdrObject()->GetSubList()->GetObjCount();
+    return nRetval;
+}
+
+
+uno::Any SAL_CALL Svx3DSceneObject::getByIndex( sal_Int32 Index )
+{
+    SolarMutexGuard aGuard;
+
+    if( !HasSdrObject() || GetSdrObject()->GetSubList() == nullptr )
+        throw uno::RuntimeException();
+
+    if( Index<0 || GetSdrObject()->GetSubList()->GetObjCount() <= o3tl::make_unsigned(Index) )
+        throw lang::IndexOutOfBoundsException();
+
+    SdrObject* pDestObj = GetSdrObject()->GetSubList()->GetObj( Index );
+    if(pDestObj == nullptr)
+        throw lang::IndexOutOfBoundsException();
+
+    Reference< drawing::XShape > xShape( pDestObj->getUnoShape(), uno::UNO_QUERY );
+    return uno::Any(xShape);
+}
+
+
+// css::container::XElementAccess
+
+uno::Type SAL_CALL Svx3DSceneObject::getElementType()
+{
+    return cppu::UnoType<drawing::XShape>::get();
+}
+
+
+sal_Bool SAL_CALL Svx3DSceneObject::hasElements()
+{
+    SolarMutexGuard aGuard;
+
+    return HasSdrObject() && GetSdrObject()->GetSubList() && (GetSdrObject()->GetSubList()->GetObjCount() > 0);
+}
+
+
+static bool ConvertHomogenMatrixToObject( E3dObject* pObject, const Any& rValue )
+{
+    drawing::HomogenMatrix aMat;
+    if( rValue >>= aMat )
+    {
+        pObject->SetTransform(basegfx::utils::UnoHomogenMatrixToB3DHomMatrix(aMat));
+        return true;
+    }
+    return false;
+}
+
+static void ConvertObjectToHomogenMatric( E3dObject const * pObject, Any& rValue )
+{
+    drawing::HomogenMatrix aHomMat;
+    const basegfx::B3DHomMatrix& rMat = pObject->GetTransform();
+    basegfx::utils::B3DHomMatrixToUnoHomogenMatrix(rMat, aHomMat);
+    rValue <<= aHomMat;
+}
+
+namespace {
+
+struct ImpRememberTransAndRect
+{
+    basegfx::B3DHomMatrix                   maMat;
+    tools::Rectangle                   maRect;
+};
+
+}
+
+bool Svx3DSceneObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // patch transformation matrix to the object
+        if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( GetSdrObject() ), rValue ) )
+            return true;
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_CAMERA_GEOMETRY:
+    {
+        // set CameraGeometry at scene
+        E3dScene* pScene = static_cast< E3dScene* >( GetSdrObject() );
+        drawing::CameraGeometry aCamGeo;
+
+        if(rValue >>= aCamGeo)
+        {
+            basegfx::B3DPoint aVRP(aCamGeo.vrp.PositionX, aCamGeo.vrp.PositionY, aCamGeo.vrp.PositionZ);
+            basegfx::B3DVector aVPN(aCamGeo.vpn.DirectionX, aCamGeo.vpn.DirectionY, aCamGeo.vpn.DirectionZ);
+            basegfx::B3DVector aVUP(aCamGeo.vup.DirectionX, aCamGeo.vup.DirectionY, aCamGeo.vup.DirectionZ);
+
+            // rescue scene transformation
+            ImpRememberTransAndRect aSceneTAR;
+            aSceneTAR.maMat = pScene->GetTransform();
+            aSceneTAR.maRect = pScene->GetSnapRect();
+
+            // rescue object transformations
+            SdrObjListIter aIter(pScene->GetSubList(), SdrIterMode::DeepWithGroups);
+            std::vector<basegfx::B3DHomMatrix*> aObjTrans;
+            while(aIter.IsMore())
+            {
+                E3dObject* p3DObj = static_cast<E3dObject*>(aIter.Next());
+                basegfx::B3DHomMatrix* pNew = new basegfx::B3DHomMatrix;
+                *pNew = p3DObj->GetTransform();
+                aObjTrans.push_back(pNew);
+            }
+
+            // reset object transformations
+            aIter.Reset();
+            while(aIter.IsMore())
+            {
+                E3dObject* p3DObj = static_cast<E3dObject*>(aIter.Next());
+                p3DObj->NbcSetTransform(basegfx::B3DHomMatrix());
+            }
+
+            // reset scene transformation and make a complete recalc
+            pScene->NbcSetTransform(basegfx::B3DHomMatrix());
+
+            // fill old camera from new parameters
+            Camera3D aCam(pScene->GetCamera());
+            const basegfx::B3DRange& rVolume = pScene->GetBoundVolume();
+            double fW = rVolume.getWidth();
+            double fH = rVolume.getHeight();
+
+            const SfxItemSet& rSceneSet = pScene->GetMergedItemSet();
+            double fCamPosZ =
+                static_cast<double>(rSceneSet.Get(SDRATTR_3DSCENE_DISTANCE).GetValue());
+            double fCamFocal =
+                static_cast<double>(rSceneSet.Get(SDRATTR_3DSCENE_FOCAL_LENGTH).GetValue());
+
+            aCam.SetAutoAdjustProjection(false);
+            aCam.SetViewWindow(- fW / 2, - fH / 2, fW, fH);
+            basegfx::B3DPoint aLookAt;
+            basegfx::B3DPoint aCamPos(0.0, 0.0, fCamPosZ);
+            aCam.SetPosAndLookAt(aCamPos, aLookAt);
+            aCam.SetFocalLength(fCamFocal / 100.0);
+            aCam.SetDeviceWindow(tools::Rectangle(0, 0, static_cast<long>(fW), static_cast<long>(fH)));
+
+            // set at scene
+            pScene->SetCamera(aCam);
+
+            // #91047# use imported VRP, VPN and VUP (if used)
+            bool bVRPUsed(!aVRP.equal(basegfx::B3DPoint(0.0, 0.0, 1.0)));
+            bool bVPNUsed(!aVPN.equal(basegfx::B3DVector(0.0, 0.0, 1.0)));
+            bool bVUPUsed(!aVUP.equal(basegfx::B3DVector(0.0, 1.0, 0.0)));
+
+            if(bVRPUsed || bVPNUsed || bVUPUsed)
+            {
+                pScene->GetCameraSet().SetViewportValues(aVRP, aVPN, aVUP);
+            }
+
+            // set object transformations again at objects
+            aIter.Reset();
+            sal_uInt32 nIndex(0);
+            while(aIter.IsMore())
+            {
+                E3dObject* p3DObj = static_cast<E3dObject*>(aIter.Next());
+                basegfx::B3DHomMatrix* pMat = aObjTrans[nIndex++];
+                p3DObj->NbcSetTransform(*pMat);
+                delete pMat;
+            }
+
+            // set scene transformation again at scene
+            pScene->NbcSetTransform(aSceneTAR.maMat);
+            pScene->NbcSetSnapRect(aSceneTAR.maRect);
+
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShape::setPropertyValueImpl(rName, pProperty, rValue);
+    }
+
+    throw IllegalArgumentException();
+}
+
+
+bool Svx3DSceneObject::getPropertyValueImpl(const OUString& rName, const SfxItemPropertySimpleEntry* pProperty,
+    css::uno::Any& rValue)
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // patch object to a homogeneous 4x4 matrix
+        ConvertObjectToHomogenMatric( static_cast< E3dObject* >( GetSdrObject() ), rValue );
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_CAMERA_GEOMETRY:
+    {
+        // get CameraGeometry from scene
+        E3dScene* pScene = static_cast< E3dScene* >( GetSdrObject() );
+        drawing::CameraGeometry aCamGeo;
+
+        // fill Vectors from scene camera
+        B3dCamera& aCameraSet = pScene->GetCameraSet();
+        basegfx::B3DPoint aVRP(aCameraSet.GetVRP());
+        basegfx::B3DVector aVPN(aCameraSet.GetVPN());
+        basegfx::B3DVector aVUP(aCameraSet.GetVUV());
+
+        // transfer to structure
+        aCamGeo.vrp.PositionX = aVRP.getX();
+        aCamGeo.vrp.PositionY = aVRP.getY();
+        aCamGeo.vrp.PositionZ = aVRP.getZ();
+        aCamGeo.vpn.DirectionX = aVPN.getX();
+        aCamGeo.vpn.DirectionY = aVPN.getY();
+        aCamGeo.vpn.DirectionZ = aVPN.getZ();
+        aCamGeo.vup.DirectionX = aVUP.getX();
+        aCamGeo.vup.DirectionY = aVUP.getY();
+        aCamGeo.vup.DirectionZ = aVUP.getZ();
+
+        rValue <<= aCamGeo;
+        break;
+    }
+    default:
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+// css::lang::XServiceInfo
+uno::Sequence< OUString > SAL_CALL Svx3DSceneObject::getSupportedServiceNames()
+{
+    return comphelper::concatSequences(
+        SvxShape::getSupportedServiceNames(),
+        std::initializer_list<OUStringLiteral>{ "com.sun.star.drawing.Shape3DScene" });
+}
+
+Svx3DCubeObject::Svx3DCubeObject(SdrObject* pObj)
+:   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_3DCUBEOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_3DCUBEOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+Svx3DCubeObject::~Svx3DCubeObject() throw()
+{
+}
+
+bool Svx3DCubeObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    SolarMutexGuard aGuard;
+
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformationmatrix to the object
+        if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( GetSdrObject() ), rValue ) )
+            return true;
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_POSITION:
+    {
+        // pack position to the object
+        drawing::Position3D aUnoPos;
+        if( rValue >>= aUnoPos )
+        {
+            basegfx::B3DPoint aPos(aUnoPos.PositionX, aUnoPos.PositionY, aUnoPos.PositionZ);
+            static_cast< E3dCubeObj* >( GetSdrObject() )->SetCubePos(aPos);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_SIZE:
+    {
+        // pack size to the object
+        drawing::Direction3D aDirection;
+        if( rValue >>= aDirection )
+        {
+            basegfx::B3DVector aSize(aDirection.DirectionX, aDirection.DirectionY, aDirection.DirectionZ);
+            static_cast< E3dCubeObj* >( GetSdrObject() )->SetCubeSize(aSize);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_POS_IS_CENTER:
+    {
+        bool bNew = false;
+        // pack sal_Bool bPosIsCenter to the object
+        if( rValue >>= bNew )
+        {
+            static_cast< E3dCubeObj* >( GetSdrObject() )->SetPosIsCenter(bNew);
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw IllegalArgumentException();
+}
+
+bool Svx3DCubeObject::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation to a homogeneous matrix
+        ConvertObjectToHomogenMatric( static_cast< E3dObject* >( GetSdrObject() ), rValue );
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_POSITION:
+    {
+        // pack position
+        const basegfx::B3DPoint& rPos = static_cast<E3dCubeObj*>(GetSdrObject())->GetCubePos();
+        drawing::Position3D aPos;
+
+        aPos.PositionX = rPos.getX();
+        aPos.PositionY = rPos.getY();
+        aPos.PositionZ = rPos.getZ();
+
+        rValue <<= aPos;
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_SIZE:
+    {
+        // pack size
+        const basegfx::B3DVector& rSize = static_cast<E3dCubeObj*>(GetSdrObject())->GetCubeSize();
+        drawing::Direction3D aDir;
+
+        aDir.DirectionX = rSize.getX();
+        aDir.DirectionY = rSize.getY();
+        aDir.DirectionZ = rSize.getZ();
+
+        rValue <<= aDir;
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_POS_IS_CENTER:
+    {
+        rValue <<= static_cast<E3dCubeObj*>(GetSdrObject())->GetPosIsCenter();
+        break;
+    }
+    default:
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+// css::lang::XServiceInfo
+uno::Sequence< OUString > SAL_CALL Svx3DCubeObject::getSupportedServiceNames()
+{
+    return comphelper::concatSequences(
+        SvxShape::getSupportedServiceNames(),
+        std::initializer_list<OUStringLiteral>{ "com.sun.star.drawing.Shape3D",
+                                          "com.sun.star.drawing.Shape3DCube" });
+}
+
+Svx3DSphereObject::Svx3DSphereObject(SdrObject* pObj)
+    : SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_3DSPHEREOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_3DSPHEREOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+Svx3DSphereObject::~Svx3DSphereObject() throw()
+{
+}
+
+bool Svx3DSphereObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation matrix to the object
+        if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( GetSdrObject() ), rValue ) )
+            return true;
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_POSITION:
+    {
+        // pack position to the object
+        drawing::Position3D aUnoPos;
+        if( rValue >>= aUnoPos )
+        {
+            basegfx::B3DPoint aPos(aUnoPos.PositionX, aUnoPos.PositionY, aUnoPos.PositionZ);
+            static_cast<E3dSphereObj*>(GetSdrObject())->SetCenter(aPos);
+            return true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_SIZE:
+    {
+        // pack size to the object
+        drawing::Direction3D aDir;
+        if( rValue >>= aDir )
+        {
+            basegfx::B3DVector aPos(aDir.DirectionX, aDir.DirectionY, aDir.DirectionZ);
+            static_cast<E3dSphereObj*>(GetSdrObject())->SetSize(aPos);
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw IllegalArgumentException();
+}
+
+bool Svx3DSphereObject::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation to a homogeneous matrix
+        ConvertObjectToHomogenMatric( static_cast< E3dObject* >( GetSdrObject() ), rValue );
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_POSITION:
+    {
+        // pack position
+        const basegfx::B3DPoint& rPos = static_cast<E3dSphereObj*>(GetSdrObject())->Center();
+        drawing::Position3D aPos;
+
+        aPos.PositionX = rPos.getX();
+        aPos.PositionY = rPos.getY();
+        aPos.PositionZ = rPos.getZ();
+
+        rValue <<= aPos;
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_SIZE:
+    {
+        // pack size
+        const basegfx::B3DVector& rSize = static_cast<E3dSphereObj*>(GetSdrObject())->Size();
+        drawing::Direction3D aDir;
+
+        aDir.DirectionX = rSize.getX();
+        aDir.DirectionY = rSize.getY();
+        aDir.DirectionZ = rSize.getZ();
+
+        rValue <<= aDir;
+        break;
+    }
+    default:
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+// css::lang::XServiceInfo
+uno::Sequence< OUString > SAL_CALL Svx3DSphereObject::getSupportedServiceNames()
+{
+    return comphelper::concatSequences(
+        SvxShape::getSupportedServiceNames(),
+        std::initializer_list<OUStringLiteral>{ "com.sun.star.drawing.Shape3D",
+                                          "com.sun.star.drawing.Shape3DSphere" });
+}
+
+Svx3DLatheObject::Svx3DLatheObject(SdrObject* pObj)
+:   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_3DLATHEOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_3DLATHEOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+Svx3DLatheObject::~Svx3DLatheObject() throw()
+{
+}
+
+static bool PolyPolygonShape3D_to_B3dPolyPolygon(
+    const Any& rValue,
+    basegfx::B3DPolyPolygon& rResultPolygon,
+    bool bCorrectPolygon)
+{
+    drawing::PolyPolygonShape3D aSourcePolyPolygon;
+    if( !(rValue >>= aSourcePolyPolygon) )
+        return false;
+
+    sal_Int32 nOuterSequenceCount = aSourcePolyPolygon.SequenceX.getLength();
+    if(nOuterSequenceCount != aSourcePolyPolygon.SequenceY.getLength() || nOuterSequenceCount != aSourcePolyPolygon.SequenceZ.getLength())
+        return false;
+
+    drawing::DoubleSequence* pInnerSequenceX = aSourcePolyPolygon.SequenceX.getArray();
+    drawing::DoubleSequence* pInnerSequenceY = aSourcePolyPolygon.SequenceY.getArray();
+    drawing::DoubleSequence* pInnerSequenceZ = aSourcePolyPolygon.SequenceZ.getArray();
+    for(sal_Int32 a(0);a<nOuterSequenceCount;a++)
+    {
+        sal_Int32 nInnerSequenceCount = pInnerSequenceX->getLength();
+        if(nInnerSequenceCount != pInnerSequenceY->getLength() || nInnerSequenceCount != pInnerSequenceZ->getLength())
+        {
+            return false;
+        }
+        basegfx::B3DPolygon aNewPolygon;
+        double* pArrayX = pInnerSequenceX->getArray();
+        double* pArrayY = pInnerSequenceY->getArray();
+        double* pArrayZ = pInnerSequenceZ->getArray();
+        for(sal_Int32 b(0);b<nInnerSequenceCount;b++)
+        {
+            aNewPolygon.append(basegfx::B3DPoint(*pArrayX++,*pArrayY++,*pArrayZ++));
+        }
+        pInnerSequenceX++;
+        pInnerSequenceY++;
+        pInnerSequenceZ++;
+
+        // #i101520# correction is needed for imported polygons of old format,
+        // see callers
+        if(bCorrectPolygon)
+        {
+            basegfx::utils::checkClosed(aNewPolygon);
+        }
+
+        rResultPolygon.append(aNewPolygon);
+    }
+    return true;
+}
+
+static void B3dPolyPolygon_to_PolyPolygonShape3D( const basegfx::B3DPolyPolygon& rSourcePolyPolygon, Any& rValue )
+{
+    drawing::PolyPolygonShape3D aRetval;
+    aRetval.SequenceX.realloc(rSourcePolyPolygon.count());
+    aRetval.SequenceY.realloc(rSourcePolyPolygon.count());
+    aRetval.SequenceZ.realloc(rSourcePolyPolygon.count());
+    drawing::DoubleSequence* pOuterSequenceX = aRetval.SequenceX.getArray();
+    drawing::DoubleSequence* pOuterSequenceY = aRetval.SequenceY.getArray();
+    drawing::DoubleSequence* pOuterSequenceZ = aRetval.SequenceZ.getArray();
+    for(sal_uInt32 a(0);a<rSourcePolyPolygon.count();a++)
+    {
+        const basegfx::B3DPolygon& aPoly(rSourcePolyPolygon.getB3DPolygon(a));
+        sal_Int32 nPointCount(aPoly.count());
+        if(aPoly.isClosed()) nPointCount++;
+        pOuterSequenceX->realloc(nPointCount);
+        pOuterSequenceY->realloc(nPointCount);
+        pOuterSequenceZ->realloc(nPointCount);
+        double* pInnerSequenceX = pOuterSequenceX->getArray();
+        double* pInnerSequenceY = pOuterSequenceY->getArray();
+        double* pInnerSequenceZ = pOuterSequenceZ->getArray();
+        for(sal_uInt32 b(0);b<aPoly.count();b++)
+        {
+            const basegfx::B3DPoint aPoint(aPoly.getB3DPoint(b));
+            *pInnerSequenceX++ = aPoint.getX();
+            *pInnerSequenceY++ = aPoint.getY();
+            *pInnerSequenceZ++ = aPoint.getZ();
+        }
+        if(aPoly.isClosed())
+        {
+            const basegfx::B3DPoint aPoint(aPoly.getB3DPoint(0));
+            *pInnerSequenceX++ = aPoint.getX();
+            *pInnerSequenceY++ = aPoint.getY();
+            *pInnerSequenceZ++ = aPoint.getZ();
+        }
+        pOuterSequenceX++;
+        pOuterSequenceY++;
+        pOuterSequenceZ++;
+    }
+    rValue <<= aRetval;
+}
+
+bool Svx3DLatheObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation matrix to the object
+        if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( GetSdrObject() ), rValue ) )
+            return true;
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_POLYPOLYGON3D:
+    {
+        // pack polygon definition to the object
+        basegfx::B3DPolyPolygon aNewB3DPolyPolygon;
+
+        // #i101520# Probably imported
+        if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, true ) )
+        {
+            // #105127# SetPolyPoly3D sets the Svx3DVerticalSegmentsItem to the number
+            // of points of the polygon. Thus, value gets lost. To avoid this, rescue
+            // item here and re-set after setting the polygon.
+            const sal_uInt32 nPrevVerticalSegs(static_cast<E3dLatheObj*>(GetSdrObject())->GetVerticalSegments());
+
+            // set polygon
+            const basegfx::B3DHomMatrix aIdentity;
+            const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(aNewB3DPolyPolygon, aIdentity));
+            static_cast<E3dLatheObj*>(GetSdrObject())->SetPolyPoly2D(aB2DPolyPolygon);
+            const sal_uInt32 nPostVerticalSegs(static_cast<E3dLatheObj*>(GetSdrObject())->GetVerticalSegments());
+
+            if(nPrevVerticalSegs != nPostVerticalSegs)
+            {
+                // restore the vertical segment count
+                static_cast<E3dLatheObj*>(GetSdrObject())->SetMergedItem(makeSvx3DVerticalSegmentsItem(nPrevVerticalSegs));
+            }
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw IllegalArgumentException();
+}
+
+bool Svx3DLatheObject::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation to a homogeneous matrix
+        drawing::HomogenMatrix aHomMat;
+        basegfx::B3DHomMatrix aMat = static_cast<E3dObject*>(GetSdrObject())->GetTransform();
+        basegfx::utils::B3DHomMatrixToUnoHomogenMatrix(aMat, aHomMat);
+        rValue <<= aHomMat;
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_POLYPOLYGON3D:
+    {
+        const basegfx::B2DPolyPolygon& rPolyPoly = static_cast<E3dLatheObj*>(GetSdrObject())->GetPolyPoly2D();
+        const basegfx::B3DPolyPolygon aB3DPolyPolygon(basegfx::utils::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPoly));
+
+        B3dPolyPolygon_to_PolyPolygonShape3D(aB3DPolyPolygon, rValue);
+        break;
+    }
+    default:
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+// css::lang::XServiceInfo
+uno::Sequence< OUString > SAL_CALL Svx3DLatheObject::getSupportedServiceNames()
+{
+    return comphelper::concatSequences(
+        SvxShape::getSupportedServiceNames(),
+        std::initializer_list<OUStringLiteral>{ "com.sun.star.drawing.Shape3D",
+                                          "com.sun.star.drawing.Shape3DLathe" });
+}
+
+Svx3DExtrudeObject::Svx3DExtrudeObject(SdrObject* pObj)
+:   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_3DEXTRUDEOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_3DEXTRUDEOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+Svx3DExtrudeObject::~Svx3DExtrudeObject() throw()
+{
+}
+
+bool Svx3DExtrudeObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation matrix to the object
+        if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( GetSdrObject() ), rValue ) )
+            return true;
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_POLYPOLYGON3D:
+    {
+        // pack polygon definition to the object
+        basegfx::B3DPolyPolygon aNewB3DPolyPolygon;
+
+        // #i101520# Probably imported
+        if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, true ) )
+        {
+            // set polygon
+            const basegfx::B3DHomMatrix aIdentity;
+            const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(aNewB3DPolyPolygon, aIdentity));
+            static_cast<E3dExtrudeObj*>(GetSdrObject())->SetExtrudePolygon(aB2DPolyPolygon);
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw IllegalArgumentException();
+}
+
+bool Svx3DExtrudeObject::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation to a homogeneous matrix
+        drawing::HomogenMatrix aHomMat;
+        basegfx::B3DHomMatrix aMat = static_cast<E3dObject*>(GetSdrObject())->GetTransform();
+        basegfx::utils::B3DHomMatrixToUnoHomogenMatrix(aMat, aHomMat);
+        rValue <<= aHomMat;
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_POLYPOLYGON3D:
+    {
+        // pack polygon definition
+        const basegfx::B2DPolyPolygon& rPolyPoly = static_cast<E3dExtrudeObj*>(GetSdrObject())->GetExtrudePolygon();
+        const basegfx::B3DPolyPolygon aB3DPolyPolygon(basegfx::utils::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPoly));
+
+        B3dPolyPolygon_to_PolyPolygonShape3D(aB3DPolyPolygon, rValue);
+        break;
+    }
+    default:
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+// css::lang::XServiceInfo
+uno::Sequence< OUString > SAL_CALL Svx3DExtrudeObject::getSupportedServiceNames()
+{
+    return comphelper::concatSequences(
+        SvxShape::getSupportedServiceNames(),
+        std::initializer_list<OUStringLiteral>{ "com.sun.star.drawing.Shape3D",
+                                          "com.sun.star.drawing.Shape3DExtrude" });
+}
+
+Svx3DPolygonObject::Svx3DPolygonObject(SdrObject* pObj)
+:   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_3DPOLYGONOBJECT), getSvxMapProvider().GetPropertySet(SVXMAP_3DPOLYGONOBJECT, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+Svx3DPolygonObject::~Svx3DPolygonObject() throw()
+{
+}
+
+bool Svx3DPolygonObject::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        // pack transformation matrix to the object
+        if( ConvertHomogenMatrixToObject( static_cast< E3dObject* >( GetSdrObject() ), rValue ) )
+            return true;
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_POLYPOLYGON3D:
+    {
+        // pack polygon definition to the object
+        basegfx::B3DPolyPolygon aNewB3DPolyPolygon;
+
+        // #i101520# Direct API data (e.g. from chart)
+        if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, false ) )
+        {
+            // set polygon
+            static_cast<E3dPolygonObj*>(GetSdrObject())->SetPolyPolygon3D(aNewB3DPolyPolygon);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_NORMALSPOLYGON3D:
+    {
+        // pack perpendicular definition to the object
+        basegfx::B3DPolyPolygon aNewB3DPolyPolygon;
+
+        // #i101520# Direct API data (e.g. from chart)
+        if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, false ) )
+        {
+            // set polygon
+            static_cast<E3dPolygonObj*>(GetSdrObject())->SetPolyNormals3D(aNewB3DPolyPolygon);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_TEXTUREPOLYGON3D:
+    {
+        // pack texture definition to the object
+        basegfx::B3DPolyPolygon aNewB3DPolyPolygon;
+
+        // #i101520# Direct API data (e.g. from chart)
+        if( PolyPolygonShape3D_to_B3dPolyPolygon( rValue, aNewB3DPolyPolygon, false ) )
+        {
+            // set polygon
+            const basegfx::B3DHomMatrix aIdentity;
+            const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::utils::createB2DPolyPolygonFromB3DPolyPolygon(aNewB3DPolyPolygon, aIdentity));
+            static_cast<E3dPolygonObj*>(GetSdrObject())->SetPolyTexture2D(aB2DPolyPolygon);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_3D_VALUE_LINEONLY:
+    {
+        bool bNew = false;
+        if( rValue >>= bNew )
+        {
+            static_cast<E3dPolygonObj*>(GetSdrObject())->SetLineOnly(bNew);
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw IllegalArgumentException();
+}
+
+bool Svx3DPolygonObject::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_3D_VALUE_TRANSFORM_MATRIX:
+    {
+        ConvertObjectToHomogenMatric( static_cast< E3dObject* >( GetSdrObject() ), rValue );
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_POLYPOLYGON3D:
+    {
+        B3dPolyPolygon_to_PolyPolygonShape3D(static_cast<E3dPolygonObj*>(GetSdrObject())->GetPolyPolygon3D(),rValue);
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_NORMALSPOLYGON3D:
+    {
+        B3dPolyPolygon_to_PolyPolygonShape3D(static_cast<E3dPolygonObj*>(GetSdrObject())->GetPolyNormals3D(),rValue);
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_TEXTUREPOLYGON3D:
+    {
+        // pack texture definition
+        const basegfx::B2DPolyPolygon& rPolyPoly = static_cast<E3dPolygonObj*>(GetSdrObject())->GetPolyTexture2D();
+        const basegfx::B3DPolyPolygon aB3DPolyPolygon(basegfx::utils::createB3DPolyPolygonFromB2DPolyPolygon(rPolyPoly));
+
+        B3dPolyPolygon_to_PolyPolygonShape3D(aB3DPolyPolygon,rValue);
+        break;
+    }
+
+    case OWN_ATTR_3D_VALUE_LINEONLY:
+    {
+        rValue <<= static_cast<E3dPolygonObj*>(GetSdrObject())->GetLineOnly();
+        break;
+    }
+
+    default:
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+// css::lang::XServiceInfo
+uno::Sequence< OUString > SAL_CALL Svx3DPolygonObject::getSupportedServiceNames()
+{
+    return comphelper::concatSequences(
+        SvxShape::getSupportedServiceNames(),
+        std::initializer_list<OUStringLiteral>{ "com.sun.star.drawing.Shape3D",
+                                          "com.sun.star.drawing.Shape3DPolygon" });
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoshap4.cxx b/svx/source/unodraw/unoshap4.cxx
new file mode 100644
index 000000000..eab0cd5bb
--- /dev/null
+++ b/svx/source/unodraw/unoshap4.cxx
@@ -0,0 +1,1013 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/util/XModifiable.hpp>
+#include <com/sun/star/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/embed/XLinkageSupport.hpp>
+#include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
+#include <com/sun/star/embed/Aspects.hpp>
+#include <com/sun/star/task/XInteractionHandler.hpp>
+#include <com/sun/star/ucb/CommandFailedException.hpp>
+#include <com/sun/star/ucb/ContentCreationException.hpp>
+
+#include <svx/svdoole2.hxx>
+#include <svx/svdomedia.hxx>
+#include <svx/svdpool.hxx>
+#include <comphelper/classids.hxx>
+#include <comphelper/embeddedobjectcontainer.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <cppuhelper/exc_hlp.hxx>
+
+#include <toolkit/helper/vclunohelper.hxx>
+
+#include <sot/exchange.hxx>
+
+#include <svx/svdmodel.hxx>
+#include "shapeimpl.hxx"
+
+#include <svx/unoshprp.hxx>
+
+#include <vcl/gdimtf.hxx>
+#include <vcl/wmf.hxx>
+#include <svtools/embedhlp.hxx>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+#include <tools/globname.hxx>
+#include <tools/stream.hxx>
+
+#include <config_features.h>
+
+
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::beans;
+
+
+SvxOle2Shape::SvxOle2Shape(SdrObject* pObject)
+: SvxShapeText( pObject, getSvxMapProvider().GetMap(SVXMAP_OLE2),
+                getSvxMapProvider().GetPropertySet(SVXMAP_OLE2,SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+}
+
+SvxOle2Shape::SvxOle2Shape(SdrObject* pObject, const SfxItemPropertyMapEntry* pPropertyMap, const SvxItemPropertySet* pPropertySet)
+: SvxShapeText( pObject, pPropertyMap, pPropertySet  )
+{
+}
+
+SvxOle2Shape::~SvxOle2Shape() throw()
+{
+}
+
+//XPropertySet
+bool SvxOle2Shape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_OLE_VISAREA:
+    {
+        // TODO/LATER: seems to make no sense for iconified object
+
+        awt::Rectangle aVisArea;
+        if( (rValue >>= aVisArea) && dynamic_cast<const SdrOle2Obj* >(GetSdrObject()) != nullptr)
+        {
+            Size aTmp( aVisArea.X + aVisArea.Width, aVisArea.Y + aVisArea.Height );
+            uno::Reference < embed::XEmbeddedObject > xObj = static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef();
+            if( xObj.is() )
+            {
+                try
+                {
+                    // the API handles with MapUnit::Map100thMM map mode
+                    MapUnit aObjUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( embed::Aspects::MSOLE_CONTENT ) );
+                    aTmp = OutputDevice::LogicToLogic(aTmp, MapMode(MapUnit::Map100thMM), MapMode(aObjUnit));
+                    xObj->setVisualAreaSize( embed::Aspects::MSOLE_CONTENT, awt::Size( aTmp.Width(), aTmp.Height() ) );
+                }
+                catch( uno::Exception& )
+                {
+                    OSL_FAIL( "Couldn't set the visual area for the object!" );
+                }
+            }
+
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_OLE_ASPECT:
+    {
+        sal_Int64 nAspect = 0;
+        if( rValue >>= nAspect )
+        {
+            static_cast<SdrOle2Obj*>(GetSdrObject())->SetAspect( nAspect );
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_CLSID:
+    {
+        OUString aCLSID;
+        if( rValue >>= aCLSID )
+        {
+            // init an OLE object with a global name
+            SvGlobalName aClassName;
+            if( aClassName.MakeId( aCLSID ) )
+            {
+                if( createObject( aClassName ) )
+                    return true;
+            }
+        }
+        break;
+    }
+    case OWN_ATTR_THUMBNAIL:
+    {
+        uno::Reference< graphic::XGraphic > xGraphic( rValue, uno::UNO_QUERY );
+        if( xGraphic.is() )
+        {
+            const Graphic aGraphic(xGraphic);
+            static_cast<SdrOle2Obj*>(GetSdrObject())->SetGraphic(aGraphic);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_VALUE_GRAPHIC:
+    {
+        uno::Reference< graphic::XGraphic > xGraphic( rValue, uno::UNO_QUERY );
+        if( xGraphic.is() )
+        {
+            SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
+            if( pOle )
+            {
+                GraphicObject aGrafObj( xGraphic );
+                const Graphic& aGraphic( aGrafObj.GetGraphic() );
+                pOle->SetGraphicToObj( aGraphic );
+            }
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_PERSISTNAME:
+    {
+        OUString aPersistName;
+        if( rValue >>= aPersistName )
+        {
+            SdrOle2Obj *pOle;
+#if OSL_DEBUG_LEVEL > 0
+            pOle = dynamic_cast<SdrOle2Obj*>(GetSdrObject());
+            assert(pOle);
+#else
+            pOle = static_cast<SdrOle2Obj*>(GetSdrObject());
+#endif
+            pOle->SetPersistName( aPersistName );
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_OLE_LINKURL:
+    {
+        OUString aLinkURL;
+        if( rValue >>= aLinkURL )
+        {
+            createLink( aLinkURL );
+            return true;
+        }
+        break;
+    }
+    default:
+        return SvxShapeText::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw IllegalArgumentException();
+}
+
+bool SvxOle2Shape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_CLSID:
+    {
+        OUString aCLSID;
+        GetClassName_Impl(aCLSID);
+        rValue <<= aCLSID;
+        break;
+    }
+
+    case OWN_ATTR_INTERNAL_OLE:
+    {
+        OUString sCLSID;
+        rValue <<= SotExchange::IsInternal( GetClassName_Impl(sCLSID) );
+        break;
+    }
+
+    case OWN_ATTR_METAFILE:
+    {
+        SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>(GetSdrObject());
+        if( pObj )
+        {
+            const Graphic* pGraphic = pObj->GetGraphic();
+            if( pGraphic )
+            {
+                bool bIsWMF = false;
+                if ( pGraphic->IsGfxLink() )
+                {
+                    GfxLink aLnk = pGraphic->GetGfxLink();
+                    if ( aLnk.GetType() == GfxLinkType::NativeWmf )
+                    {
+                        bIsWMF = true;
+                        uno::Sequence<sal_Int8> aSeq(reinterpret_cast<sal_Int8 const *>(aLnk.GetData()), static_cast<sal_Int32>(aLnk.GetDataSize()));
+                        rValue <<= aSeq;
+                    }
+                }
+                if ( !bIsWMF )
+                {
+                    // #i119735# just use GetGDIMetaFile, it will create a buffered version of contained bitmap now automatically
+                    GDIMetaFile aMtf(pObj->GetGraphic()->GetGDIMetaFile());
+                    SvMemoryStream aDestStrm( 65535, 65535 );
+                    ConvertGDIMetaFileToWMF( aMtf, aDestStrm, nullptr, false );
+                    const uno::Sequence<sal_Int8> aSeq(
+                        static_cast< const sal_Int8* >(aDestStrm.GetData()),
+                        aDestStrm.GetEndOfData());
+                    rValue <<= aSeq;
+                }
+            }
+        }
+        else
+        {
+            rValue = GetBitmap( true );
+        }
+        break;
+    }
+
+    case OWN_ATTR_OLE_VISAREA:
+    {
+        awt::Rectangle aVisArea;
+        if( dynamic_cast<const SdrOle2Obj* >(GetSdrObject()) != nullptr)
+        {
+            MapMode aMapMode( MapUnit::Map100thMM ); // the API uses this map mode
+            Size aTmp = static_cast<SdrOle2Obj*>(GetSdrObject())->GetOrigObjSize( &aMapMode ); // get the size in the requested map mode
+            aVisArea = awt::Rectangle( 0, 0, aTmp.Width(), aTmp.Height() );
+        }
+
+        rValue <<= aVisArea;
+        break;
+    }
+
+    case OWN_ATTR_OLESIZE:
+    {
+        Size aTmp( static_cast<SdrOle2Obj*>(GetSdrObject())->GetOrigObjSize() );
+        rValue <<= awt::Size( aTmp.Width(), aTmp.Height() );
+        break;
+    }
+
+    case OWN_ATTR_OLE_ASPECT:
+    {
+        rValue <<= static_cast<SdrOle2Obj*>(GetSdrObject())->GetAspect();
+        break;
+    }
+
+    case OWN_ATTR_OLEMODEL:
+    case OWN_ATTR_OLE_EMBEDDED_OBJECT:
+    case OWN_ATTR_OLE_EMBEDDED_OBJECT_NONEWCLIENT:
+    {
+        SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>( GetSdrObject() );
+        if( pObj )
+        {
+            uno::Reference < embed::XEmbeddedObject > xObj( pObj->GetObjRef() );
+            if ( xObj.is()
+              && ( pProperty->nWID == OWN_ATTR_OLE_EMBEDDED_OBJECT || pProperty->nWID == OWN_ATTR_OLE_EMBEDDED_OBJECT_NONEWCLIENT || svt::EmbeddedObjectRef::TryRunningState( xObj ) ) )
+            {
+                // Discussed with CL fue to the before GetPaintingPageView
+                // usage. Removed it, former fallback is used now
+                if ( pProperty->nWID == OWN_ATTR_OLEMODEL || pProperty->nWID == OWN_ATTR_OLE_EMBEDDED_OBJECT )
+                {
+                    const bool bSuccess(pObj->AddOwnLightClient());
+                    SAL_WARN_IF(!bSuccess, "svx.svdraw", "An object without client is provided!");
+                }
+
+                if ( pProperty->nWID == OWN_ATTR_OLEMODEL )
+                    rValue <<= pObj->GetObjRef()->getComponent();
+                else
+                    rValue <<= xObj;
+            }
+        }
+        break;
+    }
+
+    case OWN_ATTR_VALUE_GRAPHIC:
+    {
+        uno::Reference< graphic::XGraphic > xGraphic;
+        const Graphic* pGraphic = static_cast<SdrOle2Obj*>( GetSdrObject() )->GetGraphic();
+        if( pGraphic )
+            xGraphic = pGraphic->GetXGraphic();
+        rValue <<= xGraphic;
+        break;
+    }
+
+    case OWN_ATTR_THUMBNAIL:
+    {
+        uno::Reference< graphic::XGraphic > xGraphic;
+        const Graphic* pGraphic = static_cast<SdrOle2Obj*>( GetSdrObject() )->GetGraphic();
+        if( pGraphic )
+            xGraphic = pGraphic->GetXGraphic();
+        rValue <<= xGraphic;
+        break;
+    }
+    case OWN_ATTR_PERSISTNAME:
+    {
+        OUString    aPersistName;
+        SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
+
+        if( pOle )
+        {
+            aPersistName = pOle->GetPersistName();
+            if( !aPersistName.isEmpty() )
+            {
+                ::comphelper::IEmbeddedHelper* pPersist(GetSdrObject()->getSdrModelFromSdrObject().GetPersist());
+                if( (nullptr == pPersist) || !pPersist->getEmbeddedObjectContainer().HasEmbeddedObject( pOle->GetPersistName() ) )
+                    aPersistName.clear();
+            }
+        }
+
+        rValue <<= aPersistName;
+        break;
+    }
+    case OWN_ATTR_OLE_LINKURL:
+    {
+        OUString    aLinkURL;
+        SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
+
+        if( pOle )
+        {
+            uno::Reference< embed::XLinkageSupport > xLink( pOle->GetObjRef(), uno::UNO_QUERY );
+            if ( xLink.is() && xLink->isLink() )
+                aLinkURL = xLink->getLinkURL();
+        }
+
+        rValue <<= aLinkURL;
+        break;
+    }
+    default:
+        return SvxShapeText::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    return true;
+}
+
+bool SvxOle2Shape::createObject( const SvGlobalName &aClassName )
+{
+    DBG_TESTSOLARMUTEX();
+
+    SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
+    if ( !pOle2Obj || !pOle2Obj->IsEmpty() )
+        return false;
+
+    // create storage and inplace object
+    ::comphelper::IEmbeddedHelper*     pPersist = GetSdrObject()->getSdrModelFromSdrObject().GetPersist();
+    OUString              aPersistName;
+    OUString            aTmpStr;
+    if( SvxShape::getPropertyValue( UNO_NAME_OLE2_PERSISTNAME ) >>= aTmpStr )
+        aPersistName = aTmpStr;
+
+    uno::Sequence<beans::PropertyValue> objArgs( comphelper::InitPropertySequence({
+            { "DefaultParentBaseURL", Any(pPersist->getDocumentBaseURL()) }
+        }));
+    //TODO/LATER: how to cope with creation failure?!
+    uno::Reference<embed::XEmbeddedObject> xObj(
+        pPersist->getEmbeddedObjectContainer().CreateEmbeddedObject(
+            aClassName.GetByteSequence(), objArgs, aPersistName));
+    if( xObj.is() )
+    {
+        tools::Rectangle aRect = pOle2Obj->GetLogicRect();
+        if ( aRect.GetWidth() == 101 && aRect.GetHeight() == 101 )
+        {
+            // TODO/LATER: is it possible that this method is used to create an iconified object?
+            // default size
+            try
+            {
+                awt::Size aSz = xObj->getVisualAreaSize( pOle2Obj->GetAspect() );
+                aRect.SetSize( Size( aSz.Width, aSz.Height ) );
+            }
+            catch( embed::NoVisualAreaSizeException& )
+            {}
+            pOle2Obj->SetLogicRect( aRect );
+        }
+        else
+        {
+            awt::Size aSz;
+            Size aSize = aRect.GetSize();
+            aSz.Width = aSize.Width();
+            aSz.Height = aSize.Height();
+            if (aSz.Width != 0 || aSz.Height != 0)
+            {
+                //HACK: can aSz legally be empty?
+                xObj->setVisualAreaSize(  pOle2Obj->GetAspect(), aSz );
+            }
+        }
+
+        // connect the object after the visual area is set
+        aTmpStr = aPersistName;
+        SvxShape::setPropertyValue( UNO_NAME_OLE2_PERSISTNAME, Any( aTmpStr ) );
+
+        // the object is inserted during setting of PersistName property usually
+        if( pOle2Obj->IsEmpty() )
+            pOle2Obj->SetObjRef( xObj );
+    }
+
+    return xObj.is();
+}
+
+void SvxOle2Shape::createLink( const OUString& aLinkURL )
+{
+    DBG_TESTSOLARMUTEX();
+
+    SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
+    if ( !pOle2Obj || !pOle2Obj->IsEmpty() )
+        return;
+
+    OUString aPersistName;
+
+    ::comphelper::IEmbeddedHelper* pPersist = GetSdrObject()->getSdrModelFromSdrObject().GetPersist();
+
+    uno::Sequence< beans::PropertyValue > aMediaDescr( 1 );
+    aMediaDescr[0].Name = "URL";
+    aMediaDescr[0].Value <<= aLinkURL;
+
+    uno::Reference< task::XInteractionHandler > xInteraction = pPersist->getInteractionHandler();
+    if ( xInteraction.is() )
+    {
+        aMediaDescr.realloc( 2 );
+        aMediaDescr[1].Name = "InteractionHandler";
+        aMediaDescr[1].Value <<= xInteraction;
+    }
+
+    //TODO/LATER: how to cope with creation failure?!
+    uno::Reference< embed::XEmbeddedObject > xObj =
+            pPersist->getEmbeddedObjectContainer().InsertEmbeddedLink( aMediaDescr , aPersistName );
+
+    if( xObj.is() )
+    {
+        tools::Rectangle aRect = pOle2Obj->GetLogicRect();
+        if ( aRect.GetWidth() == 101 && aRect.GetHeight() == 101 )
+        {
+            // default size
+            try
+            {
+                awt::Size aSz = xObj->getVisualAreaSize( pOle2Obj->GetAspect() );
+                aRect.SetSize( Size( aSz.Width, aSz.Height ) );
+            }
+            catch( embed::NoVisualAreaSizeException& )
+            {}
+            pOle2Obj->SetLogicRect( aRect );
+        }
+        else
+        {
+            awt::Size aSz;
+            Size aSize = pOle2Obj->GetLogicRect().GetSize();
+            aSz.Width = aSize.Width();
+            aSz.Height = aSize.Height();
+            xObj->setVisualAreaSize(  pOle2Obj->GetAspect(), aSz );
+        }
+
+        // connect the object after the visual area is set
+        SvxShape::setPropertyValue( UNO_NAME_OLE2_PERSISTNAME, uno::makeAny( aPersistName ) );
+
+        // the object is inserted during setting of PersistName property usually
+        if ( pOle2Obj->IsEmpty() )
+            pOle2Obj->SetObjRef( xObj );
+    }
+}
+
+void SvxOle2Shape::resetModifiedState()
+{
+    ::comphelper::IEmbeddedHelper* pPersist = GetSdrObject()->getSdrModelFromSdrObject().GetPersist();
+    if( pPersist && !pPersist->isEnableSetModified() )
+    {
+        SdrOle2Obj* pOle = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
+        if( pOle && !pOle->IsEmpty() )
+        {
+            uno::Reference < util::XModifiable > xMod( pOle->GetObjRef(), uno::UNO_QUERY );
+            if( xMod.is() )
+                // TODO/MBA: what's this?!
+                xMod->setModified( false );
+        }
+    }
+}
+
+SvGlobalName SvxOle2Shape::GetClassName_Impl(OUString& rHexCLSID)
+{
+    DBG_TESTSOLARMUTEX();
+    SvGlobalName aClassName;
+    SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( GetSdrObject() );
+
+    if( pOle2Obj )
+    {
+        rHexCLSID.clear();
+
+        if( pOle2Obj->IsEmpty() )
+        {
+            ::comphelper::IEmbeddedHelper* pPersist = GetSdrObject()->getSdrModelFromSdrObject().GetPersist();
+            if( pPersist )
+            {
+                uno::Reference < embed::XEmbeddedObject > xObj =
+                        pPersist->getEmbeddedObjectContainer().GetEmbeddedObject( pOle2Obj->GetPersistName() );
+                if ( xObj.is() )
+                {
+                    aClassName = SvGlobalName( xObj->getClassID() );
+                    rHexCLSID = aClassName.GetHexName();
+                }
+            }
+        }
+
+        if (rHexCLSID.isEmpty())
+        {
+            const uno::Reference < embed::XEmbeddedObject >& xObj( pOle2Obj->GetObjRef() );
+            if ( xObj.is() )
+            {
+                aClassName = SvGlobalName( xObj->getClassID() );
+                rHexCLSID = aClassName.GetHexName();
+            }
+        }
+    }
+
+    return aClassName;
+}
+
+SvxAppletShape::SvxAppletShape(SdrObject* pObject)
+    : SvxOle2Shape( pObject, getSvxMapProvider().GetMap(SVXMAP_APPLET), getSvxMapProvider().GetPropertySet(SVXMAP_APPLET, SdrObject::GetGlobalDrawObjectItemPool())  )
+{
+    SetShapeType( "com.sun.star.drawing.AppletShape" );
+}
+
+SvxAppletShape::~SvxAppletShape() throw()
+{
+}
+
+void SvxAppletShape::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
+{
+    SvxShape::Create( pNewObj, pNewPage );
+    const SvGlobalName aAppletClassId( SO3_APPLET_CLASSID );
+    createObject(aAppletClassId);
+    SetShapeType( "com.sun.star.drawing.AppletShape" );
+}
+
+void SAL_CALL SvxAppletShape::setPropertyValue( const OUString& aPropertyName, const css::uno::Any& rValue )
+{
+    SvxShape::setPropertyValue( aPropertyName, rValue );
+    resetModifiedState();
+}
+
+void SAL_CALL SvxAppletShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& rValues )
+{
+    SvxShape::setPropertyValues( aPropertyNames, rValues );
+    resetModifiedState();
+}
+
+bool SvxAppletShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    if( (pProperty->nWID >= OWN_ATTR_APPLET_DOCBASE) && (pProperty->nWID <= OWN_ATTR_APPLET_ISSCRIPT) )
+    {
+        if ( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
+        {
+            uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
+            if( xSet.is() )
+            {
+                // allow exceptions to pass through
+                xSet->setPropertyValue( rName, rValue );
+            }
+        }
+        return true;
+    }
+    else
+    {
+        return SvxOle2Shape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+
+bool SvxAppletShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    if( (pProperty->nWID >= OWN_ATTR_APPLET_DOCBASE) && (pProperty->nWID <= OWN_ATTR_APPLET_ISSCRIPT) )
+    {
+        if ( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
+        {
+            uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
+            if( xSet.is() )
+            {
+                rValue = xSet->getPropertyValue( rName );
+            }
+        }
+        return true;
+    }
+    else
+    {
+        return SvxOle2Shape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+
+SvxPluginShape::SvxPluginShape(SdrObject* pObject)
+    : SvxOle2Shape( pObject, getSvxMapProvider().GetMap(SVXMAP_PLUGIN), getSvxMapProvider().GetPropertySet(SVXMAP_PLUGIN, SdrObject::GetGlobalDrawObjectItemPool()) )
+{
+    SetShapeType( "com.sun.star.drawing.PluginShape" );
+}
+
+SvxPluginShape::~SvxPluginShape() throw()
+{
+}
+
+void SvxPluginShape::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
+{
+    SvxShape::Create( pNewObj, pNewPage );
+    const SvGlobalName aPluginClassId( SO3_PLUGIN_CLASSID );
+    createObject(aPluginClassId);
+    SetShapeType( "com.sun.star.drawing.PluginShape" );
+}
+
+void SAL_CALL SvxPluginShape::setPropertyValue( const OUString& aPropertyName, const css::uno::Any& rValue )
+{
+    SvxShape::setPropertyValue( aPropertyName, rValue );
+    resetModifiedState();
+}
+
+void SAL_CALL SvxPluginShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& rValues )
+{
+    SvxShape::setPropertyValues( aPropertyNames, rValues );
+    resetModifiedState();
+}
+
+bool SvxPluginShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    if( (pProperty->nWID >= OWN_ATTR_PLUGIN_MIMETYPE) && (pProperty->nWID <= OWN_ATTR_PLUGIN_COMMANDS) )
+    {
+        if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
+        {
+            uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
+            if( xSet.is() )
+            {
+                // allow exceptions to pass through
+                xSet->setPropertyValue( rName, rValue );
+            }
+        }
+        return true;
+    }
+    else
+    {
+        return SvxOle2Shape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+
+bool SvxPluginShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    if( (pProperty->nWID >= OWN_ATTR_PLUGIN_MIMETYPE) && (pProperty->nWID <= OWN_ATTR_PLUGIN_COMMANDS) )
+    {
+        if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
+        {
+            uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
+            if( xSet.is() )
+            {
+                rValue = xSet->getPropertyValue( rName );
+            }
+        }
+        return true;
+    }
+    else
+    {
+        return SvxOle2Shape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+
+
+SvxFrameShape::SvxFrameShape(SdrObject* pObject)
+: SvxOle2Shape( pObject, getSvxMapProvider().GetMap(SVXMAP_FRAME), getSvxMapProvider().GetPropertySet(SVXMAP_FRAME, SdrObject::GetGlobalDrawObjectItemPool())  )
+{
+    SetShapeType( "com.sun.star.drawing.FrameShape" );
+}
+
+SvxFrameShape::~SvxFrameShape() throw()
+{
+}
+
+void SvxFrameShape::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
+{
+    SvxShape::Create( pNewObj, pNewPage );
+    const SvGlobalName aIFrameClassId( SO3_IFRAME_CLASSID );
+    createObject(aIFrameClassId);
+    SetShapeType( "com.sun.star.drawing.FrameShape" );
+}
+
+void SAL_CALL SvxFrameShape::setPropertyValue( const OUString& aPropertyName, const css::uno::Any& rValue )
+{
+    SvxShape::setPropertyValue( aPropertyName, rValue );
+    resetModifiedState();
+}
+
+void SAL_CALL SvxFrameShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& rValues )
+{
+    SvxShape::setPropertyValues( aPropertyNames, rValues );
+    resetModifiedState();
+}
+
+bool SvxFrameShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    if( (pProperty->nWID >= OWN_ATTR_FRAME_URL) && (pProperty->nWID <= OWN_ATTR_FRAME_MARGIN_HEIGHT) )
+    {
+        if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
+        {
+            uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
+            if( xSet.is() )
+            {
+                // allow exceptions to pass through
+                xSet->setPropertyValue( rName, rValue );
+            }
+        }
+        return true;
+    }
+    else
+    {
+        return SvxOle2Shape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+
+bool SvxFrameShape::getPropertyValueImpl(const OUString& rName, const SfxItemPropertySimpleEntry* pProperty,
+    css::uno::Any& rValue)
+{
+    if( (pProperty->nWID >= OWN_ATTR_FRAME_URL) && (pProperty->nWID <= OWN_ATTR_FRAME_MARGIN_HEIGHT) )
+    {
+        if( svt::EmbeddedObjectRef::TryRunningState( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef() ) )
+        {
+            uno::Reference < beans::XPropertySet > xSet( static_cast<SdrOle2Obj*>(GetSdrObject())->GetObjRef()->getComponent(), uno::UNO_QUERY );
+            if( xSet.is() )
+            {
+                rValue = xSet->getPropertyValue( rName );
+            }
+        }
+        return true;
+    }
+    else
+    {
+        return SvxOle2Shape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+SvxMediaShape::SvxMediaShape(SdrObject* pObj, OUString const & referer)
+:   SvxShape( pObj, getSvxMapProvider().GetMap(SVXMAP_MEDIA), getSvxMapProvider().GetPropertySet(SVXMAP_MEDIA, SdrObject::GetGlobalDrawObjectItemPool()) ),
+    referer_(referer)
+{
+    SetShapeType( "com.sun.star.drawing.MediaShape" );
+}
+
+
+SvxMediaShape::~SvxMediaShape() throw()
+{
+}
+
+
+bool SvxMediaShape::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    if( ((pProperty->nWID >= OWN_ATTR_MEDIA_URL) && (pProperty->nWID <= OWN_ATTR_MEDIA_ZOOM))
+        || (pProperty->nWID == OWN_ATTR_MEDIA_STREAM)
+        || (pProperty->nWID == OWN_ATTR_MEDIA_MIMETYPE) )
+    {
+        SdrMediaObj* pMedia = static_cast< SdrMediaObj* >( GetSdrObject() );
+        ::avmedia::MediaItem aItem;
+        bool bOk = false;
+
+        switch( pProperty->nWID )
+        {
+        case OWN_ATTR_MEDIA_URL:
+#if HAVE_FEATURE_AVMEDIA
+        {
+            OUString aURL;
+            if( rValue >>= aURL )
+            {
+                bOk = true;
+                aItem.setURL( aURL, "", referer_ );
+            }
+        }
+#endif
+        break;
+
+        case OWN_ATTR_MEDIA_LOOP:
+#if HAVE_FEATURE_AVMEDIA
+        {
+            bool bLoop;
+
+            if( rValue >>= bLoop )
+            {
+                bOk = true;
+                aItem.setLoop( bLoop );
+            }
+        }
+#endif
+        break;
+
+        case OWN_ATTR_MEDIA_MUTE:
+#if HAVE_FEATURE_AVMEDIA
+        {
+            bool bMute;
+
+            if( rValue >>= bMute )
+            {
+                bOk = true;
+                aItem.setMute( bMute );
+            }
+        }
+#endif
+        break;
+
+        case OWN_ATTR_MEDIA_VOLUMEDB:
+#if HAVE_FEATURE_AVMEDIA
+        {
+            sal_Int16 nVolumeDB = sal_Int16();
+
+            if( rValue >>= nVolumeDB )
+            {
+                bOk = true;
+                aItem.setVolumeDB( nVolumeDB );
+            }
+        }
+#endif
+        break;
+
+        case OWN_ATTR_MEDIA_ZOOM:
+#if HAVE_FEATURE_AVMEDIA
+        {
+            css::media::ZoomLevel eLevel;
+
+            if( rValue >>= eLevel )
+            {
+                bOk = true;
+                aItem.setZoom( eLevel );
+            }
+        }
+#endif
+        break;
+
+        case OWN_ATTR_MEDIA_MIMETYPE:
+#if HAVE_FEATURE_AVMEDIA
+        {
+            OUString sMimeType;
+            if( rValue >>= sMimeType )
+            {
+                bOk = true;
+                aItem.setMimeType( sMimeType );
+            }
+        }
+#endif
+        break;
+
+        case OWN_ATTR_MEDIA_STREAM:
+#if HAVE_FEATURE_AVMEDIA
+            try
+            {
+                uno::Reference<io::XInputStream> xStream;
+                if (rValue >>= xStream)
+                {
+                    pMedia->SetInputStream(xStream);
+                }
+            }
+            catch (const css::ucb::ContentCreationException&)
+            {
+                css::uno::Any exc = cppu::getCaughtException();
+                throw css::lang::WrappedTargetException(
+                        "ContentCreationException Setting InputStream!",
+                        static_cast<OWeakObject *>(this),
+                        exc);
+            }
+            catch (const css::ucb::CommandFailedException&)
+            {
+                css::uno::Any anyEx = cppu::getCaughtException();
+                throw css::lang::WrappedTargetException(
+                        "CommandFailedException Setting InputStream!",
+                        static_cast<OWeakObject *>(this),
+                        anyEx);
+            }
+#endif
+        break;
+
+        default:
+            OSL_FAIL("SvxMediaShape::setPropertyValueImpl(), unknown argument!");
+        }
+
+        if( bOk )
+        {
+            pMedia->setMediaProperties( aItem );
+            return true;
+        }
+    }
+    else
+    {
+        return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+    }
+
+    throw IllegalArgumentException();
+}
+
+
+bool SvxMediaShape::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    if (   ((pProperty->nWID >= OWN_ATTR_MEDIA_URL) &&
+            (pProperty->nWID <= OWN_ATTR_MEDIA_ZOOM))
+        || (pProperty->nWID == OWN_ATTR_MEDIA_STREAM)
+        || (pProperty->nWID == OWN_ATTR_MEDIA_TEMPFILEURL)
+        || (pProperty->nWID == OWN_ATTR_MEDIA_MIMETYPE)
+        || (pProperty->nWID == OWN_ATTR_FALLBACK_GRAPHIC))
+    {
+        SdrMediaObj* pMedia = static_cast< SdrMediaObj* >( GetSdrObject() );
+        const ::avmedia::MediaItem aItem( pMedia->getMediaProperties() );
+
+        switch( pProperty->nWID )
+        {
+            case OWN_ATTR_MEDIA_URL:
+#if HAVE_FEATURE_AVMEDIA
+                rValue <<= aItem.getURL();
+#endif
+                break;
+
+            case OWN_ATTR_MEDIA_LOOP:
+#if HAVE_FEATURE_AVMEDIA
+                rValue <<= aItem.isLoop();
+#endif
+                break;
+
+            case OWN_ATTR_MEDIA_MUTE:
+#if HAVE_FEATURE_AVMEDIA
+                rValue <<= aItem.isMute();
+#endif
+                break;
+
+            case OWN_ATTR_MEDIA_VOLUMEDB:
+#if HAVE_FEATURE_AVMEDIA
+                rValue <<= aItem.getVolumeDB();
+#endif
+                break;
+
+            case OWN_ATTR_MEDIA_ZOOM:
+#if HAVE_FEATURE_AVMEDIA
+                rValue <<= aItem.getZoom();
+#endif
+                break;
+
+            case OWN_ATTR_MEDIA_STREAM:
+                try
+                {
+                    rValue <<= pMedia->GetInputStream();
+                }
+                catch (const css::ucb::ContentCreationException&)
+                {
+                    css::uno::Any anyEx = cppu::getCaughtException();
+                    throw css::lang::WrappedTargetException(
+                            "ContentCreationException Getting InputStream!",
+                            static_cast < OWeakObject * > ( this ), anyEx );
+                }
+                catch (const css::ucb::CommandFailedException&)
+                {
+                    css::uno::Any anyEx = cppu::getCaughtException();
+                    throw css::lang::WrappedTargetException(
+                            "CommandFailedException Getting InputStream!",
+                            static_cast < OWeakObject * > ( this ), anyEx );
+                }
+
+                break;
+
+            case OWN_ATTR_MEDIA_TEMPFILEURL:
+#if HAVE_FEATURE_AVMEDIA
+                rValue <<= aItem.getTempURL();
+#endif
+                break;
+
+            case OWN_ATTR_MEDIA_MIMETYPE:
+#if HAVE_FEATURE_AVMEDIA
+                rValue <<= aItem.getMimeType();
+#endif
+                break;
+
+            case OWN_ATTR_FALLBACK_GRAPHIC:
+                rValue <<= pMedia->getSnapshot();
+                break;
+
+            default:
+                OSL_FAIL("SvxMediaShape::getPropertyValueImpl(), unknown property!");
+        }
+        return true;
+    }
+    else
+    {
+        return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoshape.cxx b/svx/source/unodraw/unoshape.cxx
new file mode 100644
index 000000000..f5be3192d
--- /dev/null
+++ b/svx/source/unodraw/unoshape.cxx
@@ -0,0 +1,4011 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <cppuhelper/supportsservice.hxx>
+#include <com/sun/star/awt/XBitmap.hpp>
+#include <com/sun/star/awt/Rectangle.hpp>
+#include <com/sun/star/drawing/CircleKind.hpp>
+#include <com/sun/star/lang/NoSupportException.hpp>
+#include <vcl/svapp.hxx>
+#include <svl/itemprop.hxx>
+#include <o3tl/any.hxx>
+#include <osl/mutex.hxx>
+#include <editeng/unotext.hxx>
+#include <svx/svdobj.hxx>
+#include <svx/svdoole2.hxx>
+#include <svx/shapepropertynotifier.hxx>
+#include <comphelper/scopeguard.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <vcl/gfxlink.hxx>
+#include <vcl/virdev.hxx>
+#include <svx/sdangitm.hxx>
+#include <svx/svdlayer.hxx>
+#include <svx/svdopage.hxx>
+#include <svx/xflbstit.hxx>
+#include <svx/xflbmtit.hxx>
+#include <svx/xlnstit.hxx>
+#include <svx/xlnedit.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/globl3d.hxx>
+#include <svx/unopage.hxx>
+#include <svx/unoshape.hxx>
+#include <svx/unoshtxt.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/unoshprp.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/unoapi.hxx>
+#include <svx/svdomeas.hxx>
+#include <svx/svdpool.hxx>
+#include <tools/stream.hxx>
+#include <tools/gen.hxx>
+#include <svx/svdoedge.hxx>
+#include <svx/svdocapt.hxx>
+#include <svx/obj3d.hxx>
+#include <svx/xflftrit.hxx>
+#include <svx/xtable.hxx>
+#include <svx/xbtmpit.hxx>
+#include <svx/xfillit0.hxx>
+#include <svx/xflgrit.hxx>
+#include <svx/xflhtit.hxx>
+#include <svx/xlineit0.hxx>
+#include <svx/xlndsit.hxx>
+#include <svx/unomaster.hxx>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include "gluepts.hxx"
+#include "shapeimpl.hxx"
+#include <sal/log.hxx>
+
+#include <svx/lathe3d.hxx>
+#include <extrud3d.hxx>
+#include <svx/sdr/contact/viewcontact.hxx>
+#include <drawinglayer/geometry/viewinformation2d.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+
+#include <vcl/gdimtf.hxx>
+#include <vcl/wmf.hxx>
+#include <svx/sdtfsitm.hxx>
+#include <svx/svdoutl.hxx>
+
+#include <memory>
+#include <vector>
+#include <iostream>
+
+#include <bitmaps.hlst>
+
+using namespace ::osl;
+using namespace ::cppu;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::container;
+using svx::PropertyValueProvider;
+
+class GDIMetaFile;
+
+struct SvxShapeImpl
+{
+    SvxShape&       mrAntiImpl;
+    std::unique_ptr<SfxItemSet> mpItemSet;
+    sal_uInt32      mnObjId;
+    SvxShapeMaster* mpMaster;
+    bool            mbHasSdrObjectOwnership;
+    bool            mbDisposing;
+
+    /** CL, OD 2005-07-19 #i52126# - this is initially 0 and set when
+     *  a SvxShape::Create() call is executed. It is then set to the created
+     *  SdrObject so a multiple call to SvxShape::Create() with same SdrObject
+     *  is prohibited.
+     */
+    ::tools::WeakReference< SdrObject > mpCreatedObj;
+
+    // for xComponent
+    ::comphelper::OInterfaceContainerHelper2   maDisposeListeners;
+    svx::PropertyChangeNotifier       maPropertyNotifier;
+
+    SvxShapeImpl( SvxShape& _rAntiImpl, ::osl::Mutex& _rMutex )
+        :mrAntiImpl( _rAntiImpl )
+        ,mnObjId( 0 )
+        ,mpMaster( nullptr )
+        ,mbHasSdrObjectOwnership( false )
+        ,mbDisposing( false )
+        ,mpCreatedObj()
+        ,maDisposeListeners( _rMutex )
+        ,maPropertyNotifier( _rAntiImpl, _rMutex )
+    {
+    }
+};
+
+namespace {
+
+class ShapePositionProvider : public PropertyValueProvider
+{
+public:
+    explicit ShapePositionProvider( const SvxShapeImpl& _shapeImpl )
+        :PropertyValueProvider( _shapeImpl.mrAntiImpl, "Position" )
+    {
+    }
+
+protected:
+    virtual void getCurrentValue( Any& _out_rCurrentValue ) const override
+    {
+        _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getPosition();
+    }
+};
+
+
+class ShapeSizeProvider : public PropertyValueProvider
+{
+public:
+    explicit ShapeSizeProvider( const SvxShapeImpl& _shapeImpl )
+        :PropertyValueProvider( _shapeImpl.mrAntiImpl, "Size" )
+    {
+    }
+
+protected:
+    virtual void getCurrentValue( Any& _out_rCurrentValue ) const override
+    {
+        _out_rCurrentValue <<= static_cast< SvxShape& >( getContext() ).getSize();
+    }
+};
+
+/// Calculates what scaling factor will be used for autofit text scaling of this shape.
+sal_Int16 GetTextFitToSizeScale(SdrObject* pObject)
+{
+    SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>(pObject);
+    if (!pTextObj)
+    {
+        return 0;
+    }
+
+    const SfxItemSet& rTextObjSet = pTextObj->GetMergedItemSet();
+    if (rTextObjSet.GetItem<SdrTextFitToSizeTypeItem>(SDRATTR_TEXT_FITTOSIZE)->GetValue()
+        != drawing::TextFitToSizeType_AUTOFIT)
+    {
+        return 0;
+    }
+
+    std::unique_ptr<SdrOutliner> pOutliner
+        = pTextObj->getSdrModelFromSdrObject().createOutliner(OutlinerMode::TextObject);
+    tools::Rectangle aBoundRect(pTextObj->GetCurrentBoundRect());
+    pTextObj->SetupOutlinerFormatting(*pOutliner, aBoundRect);
+    sal_uInt16 nX = 0;
+    sal_uInt16 nY = 0;
+    pOutliner->GetGlobalCharStretching(nX, nY);
+    return nY;
+}
+}
+
+SvxShape::SvxShape( SdrObject* pObject )
+:   maSize(100,100)
+,   mpImpl( new SvxShapeImpl( *this, maMutex ) )
+,   mbIsMultiPropertyCall(false)
+,   mpPropSet(getSvxMapProvider().GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool()))
+,   maPropMapEntries(getSvxMapProvider().GetMap(SVXMAP_SHAPE))
+,   mpSdrObjectWeakReference(pObject)
+,   mnLockCount(0)
+{
+    impl_construct();
+}
+
+
+SvxShape::SvxShape( SdrObject* pObject, const SfxItemPropertyMapEntry* pEntries, const SvxItemPropertySet* pPropertySet )
+:   maSize(100,100)
+,   mpImpl( new SvxShapeImpl( *this, maMutex ) )
+,   mbIsMultiPropertyCall(false)
+,   mpPropSet(pPropertySet)
+,   maPropMapEntries(pEntries)
+,   mpSdrObjectWeakReference(pObject)
+,   mnLockCount(0)
+{
+    impl_construct();
+}
+
+
+SvxShape::~SvxShape() throw()
+{
+    ::SolarMutexGuard aGuard;
+
+    DBG_ASSERT( mnLockCount == 0, "Locked shape was disposed!" );
+
+    if ( mpImpl->mpMaster )
+        mpImpl->mpMaster->dispose();
+
+    if ( HasSdrObject() )
+    {
+        EndListening(GetSdrObject()->getSdrModelFromSdrObject());
+        GetSdrObject()->setUnoShape(nullptr);
+    }
+
+    if( HasSdrObjectOwnership() && HasSdrObject() )
+    {
+        mpImpl->mbHasSdrObjectOwnership = false;
+        SdrObject* pObject = GetSdrObject();
+        SdrObject::Free( pObject );
+    }
+
+    EndListeningAll(); // call explicitly within SolarMutexGuard
+}
+
+
+void SvxShape::TakeSdrObjectOwnership()
+{
+    mpImpl->mbHasSdrObjectOwnership = true;
+}
+
+
+void SvxShape::InvalidateSdrObject()
+{
+    if(HasSdrObject())
+    {
+        EndListening(GetSdrObject()->getSdrModelFromSdrObject());
+    }
+
+    if (HasSdrObjectOwnership())
+        return;
+
+    mpSdrObjectWeakReference.reset(nullptr);
+};
+
+bool SvxShape::HasSdrObjectOwnership() const
+{
+    if ( !mpImpl->mbHasSdrObjectOwnership )
+        return false;
+
+    OSL_ENSURE( HasSdrObject(), "SvxShape::HasSdrObjectOwnership: have the ownership of an object which I don't know!" );
+    return HasSdrObject();
+}
+
+
+void SvxShape::setShapeKind( sal_uInt32 nKind )
+{
+    mpImpl->mnObjId = nKind;
+}
+
+
+sal_uInt32 SvxShape::getShapeKind() const
+{
+    return mpImpl->mnObjId;
+}
+
+
+void SvxShape::setMaster( SvxShapeMaster* pMaster )
+{
+    mpImpl->mpMaster = pMaster;
+}
+
+
+uno::Any SAL_CALL SvxShape::queryAggregation( const uno::Type& rType )
+{
+    if( mpImpl->mpMaster )
+    {
+        uno::Any aAny;
+        if( mpImpl->mpMaster->queryAggregation( rType, aAny ) )
+            return aAny;
+    }
+
+    return SvxShape_UnoImplHelper::queryAggregation(rType);
+}
+
+namespace
+{
+    class theSvxShapeUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSvxShapeUnoTunnelId > {};
+}
+
+const css::uno::Sequence< sal_Int8 > & SvxShape::getUnoTunnelId() throw()
+{
+    return theSvxShapeUnoTunnelId::get().getSeq();
+}
+
+sal_Int64 SAL_CALL SvxShape::getSomething( const css::uno::Sequence< sal_Int8 >& rId )
+{
+    if( isUnoTunnelId<SvxShape>(rId) )
+    {
+        return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+svx::PropertyChangeNotifier& SvxShape::getShapePropertyChangeNotifier()
+{
+    return mpImpl->maPropertyNotifier;
+}
+
+
+void SvxShape::impl_construct()
+{
+    mpImpl->maPropertyNotifier.registerProvider( svx::ShapeProperty::Position,
+        std::make_shared<ShapePositionProvider>( *mpImpl ) );
+    mpImpl->maPropertyNotifier.registerProvider( svx::ShapeProperty::Size,
+        std::make_shared<ShapeSizeProvider>( *mpImpl ) );
+
+    if ( HasSdrObject() )
+    {
+        StartListening(GetSdrObject()->getSdrModelFromSdrObject());
+        impl_initFromSdrObject();
+    }
+}
+
+
+void SvxShape::impl_initFromSdrObject()
+{
+    DBG_TESTSOLARMUTEX();
+    OSL_PRECOND( HasSdrObject(), "SvxShape::impl_initFromSdrObject: not to be called without SdrObject!" );
+    if ( !HasSdrObject() )
+        return;
+
+    osl_atomic_increment( &m_refCount );
+    {
+        GetSdrObject()->setUnoShape(*this);
+    }
+    osl_atomic_decrement( &m_refCount );
+
+    // #i40944#
+    // Do not simply return when no model but do the type corrections
+    // following below.
+    const SdrInventor nInventor = GetSdrObject()->GetObjInventor();
+
+    // is it one of ours (svx) ?
+    if( nInventor == SdrInventor::Default || nInventor == SdrInventor::E3d || nInventor == SdrInventor::FmForm )
+    {
+        if(nInventor == SdrInventor::FmForm)
+        {
+            mpImpl->mnObjId = OBJ_UNO;
+        }
+        else
+        {
+            mpImpl->mnObjId = GetSdrObject()->GetObjIdentifier();
+            if( nInventor == SdrInventor::E3d )
+                mpImpl->mnObjId |= E3D_INVENTOR_FLAG;
+        }
+
+        switch(mpImpl->mnObjId)
+        {
+        case OBJ_CCUT:          // segment of circle
+        case OBJ_CARC:          // arc of circle
+        case OBJ_SECT:          // sector
+            mpImpl->mnObjId = OBJ_CIRC;
+            break;
+        }
+    }
+}
+
+
+void SvxShape::Create( SdrObject* pNewObj, SvxDrawPage* /*pNewPage*/ )
+{
+    DBG_TESTSOLARMUTEX();
+
+    OSL_PRECOND( pNewObj, "SvxShape::Create: invalid new object!" );
+    if ( !pNewObj )
+        return;
+
+    SdrObject* pCreatedObj = mpImpl->mpCreatedObj.get();
+    OSL_ENSURE( ( pCreatedObj == nullptr ) || ( pCreatedObj == pNewObj ),
+        "SvxShape::Create: the same shape used for two different objects?! Strange ..." );
+
+    // Correct condition (#i52126#)
+    if ( pCreatedObj == pNewObj )
+        return;
+
+    // Correct condition (#i52126#)
+    mpImpl->mpCreatedObj = pNewObj;
+
+    if( HasSdrObject() )
+    {
+        EndListening( GetSdrObject()->getSdrModelFromSdrObject() );
+    }
+
+    mpSdrObjectWeakReference.reset( pNewObj );
+
+    if( HasSdrObject() )
+    {
+        StartListening( GetSdrObject()->getSdrModelFromSdrObject() );
+    }
+
+    OSL_ENSURE( !mbIsMultiPropertyCall, "SvxShape::Create: hmm?" );
+        // this was previously set in impl_initFromSdrObject, but I think it was superfluous
+        // (it definitely was in the other context where it was called, but I strongly suppose
+        // it was also superfluous when called from here)
+    impl_initFromSdrObject();
+
+    ObtainSettingsFromPropertySet( *mpPropSet );
+
+    // save user call
+    SdrObjUserCall* pUser = GetSdrObject()->GetUserCall();
+    GetSdrObject()->SetUserCall(nullptr);
+
+    setPosition( maPosition );
+    setSize( maSize );
+
+    // restore user call after we set the initial size
+    GetSdrObject()->SetUserCall( pUser );
+
+    // if this shape was already named, use this name
+    if( !maShapeName.isEmpty() )
+    {
+        GetSdrObject()->SetName( maShapeName );
+        maShapeName.clear();
+    }
+}
+
+void SvxShape::ForceMetricToItemPoolMetric(Pair& rPoint) const throw()
+{
+    DBG_TESTSOLARMUTEX();
+    if(HasSdrObject())
+    {
+        MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0));
+        if(eMapUnit != MapUnit::Map100thMM)
+        {
+            switch(eMapUnit)
+            {
+                case MapUnit::MapTwip :
+                {
+                    rPoint.A() = MM_TO_TWIPS(rPoint.A());
+                    rPoint.B() = MM_TO_TWIPS(rPoint.B());
+                    break;
+                }
+                default:
+                {
+                    OSL_FAIL("AW: Missing unit translation to PoolMetric!");
+                }
+            }
+        }
+    }
+}
+
+void SvxShape::ForceMetricToItemPoolMetric(basegfx::B2DPolyPolygon& rPolyPolygon) const throw()
+{
+    DBG_TESTSOLARMUTEX();
+    if(HasSdrObject())
+    {
+        MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0));
+        if(eMapUnit != MapUnit::Map100thMM)
+        {
+            switch(eMapUnit)
+            {
+                case MapUnit::MapTwip :
+                {
+                    basegfx::B2DHomMatrix aTransform;
+                    const double fMMToTWIPS(72.0 / 127.0);
+
+                    aTransform.scale(fMMToTWIPS, fMMToTWIPS);
+                    rPolyPolygon.transform(aTransform);
+                    break;
+                }
+                default:
+                {
+                    OSL_FAIL("Missing unit translation to PoolMetric!");
+                }
+            }
+        }
+    }
+}
+
+void SvxShape::ForceMetricToItemPoolMetric(basegfx::B2DHomMatrix& rB2DHomMatrix) const throw()
+{
+    DBG_TESTSOLARMUTEX();
+    if(HasSdrObject())
+    {
+        MapUnit eMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0));
+        if(eMapUnit != MapUnit::Map100thMM)
+        {
+            switch(eMapUnit)
+            {
+                case MapUnit::MapTwip :
+                {
+                    const double fMMToTWIPS(72.0 / 127.0);
+                    const basegfx::utils::B2DHomMatrixBufferedDecompose aDecomposedTransform(rB2DHomMatrix);
+                    rB2DHomMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
+                        aDecomposedTransform.getScale() * fMMToTWIPS,
+                        aDecomposedTransform.getShearX(),
+                        aDecomposedTransform.getRotate(),
+                        aDecomposedTransform.getTranslate() * fMMToTWIPS);
+                    break;
+                }
+                default:
+                {
+                    OSL_FAIL("Missing unit translation to PoolMetric!");
+                }
+            }
+        }
+    }
+}
+
+void SvxShape::ForceMetricTo100th_mm(Pair& rPoint) const throw()
+{
+    DBG_TESTSOLARMUTEX();
+    MapUnit eMapUnit = MapUnit::Map100thMM;
+    if(HasSdrObject())
+    {
+        eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0);
+        if(eMapUnit != MapUnit::Map100thMM)
+        {
+            switch(eMapUnit)
+            {
+                case MapUnit::MapTwip :
+                {
+                    rPoint.A() = TWIPS_TO_MM(rPoint.A());
+                    rPoint.B() = TWIPS_TO_MM(rPoint.B());
+                    break;
+                }
+                default:
+                {
+                    OSL_FAIL("AW: Missing unit translation to 100th mm!");
+                }
+            }
+        }
+    }
+}
+
+void SvxShape::ForceMetricTo100th_mm(basegfx::B2DPolyPolygon& rPolyPolygon) const throw()
+{
+    DBG_TESTSOLARMUTEX();
+    MapUnit eMapUnit = MapUnit::Map100thMM;
+    if(HasSdrObject())
+    {
+        eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0);
+        if(eMapUnit != MapUnit::Map100thMM)
+        {
+            switch(eMapUnit)
+            {
+                case MapUnit::MapTwip :
+                {
+                    basegfx::B2DHomMatrix aTransform;
+                    const double fTWIPSToMM(127.0 / 72.0);
+                    aTransform.scale(fTWIPSToMM, fTWIPSToMM);
+                    rPolyPolygon.transform(aTransform);
+                    break;
+                }
+                default:
+                {
+                    OSL_FAIL("Missing unit translation to 100th mm!");
+                }
+            }
+        }
+    }
+}
+
+void SvxShape::ForceMetricTo100th_mm(basegfx::B2DHomMatrix& rB2DHomMatrix) const throw()
+{
+    DBG_TESTSOLARMUTEX();
+    MapUnit eMapUnit = MapUnit::Map100thMM;
+    if(HasSdrObject())
+    {
+        eMapUnit = GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetMetric(0);
+        if(eMapUnit != MapUnit::Map100thMM)
+        {
+            switch(eMapUnit)
+            {
+                case MapUnit::MapTwip :
+                {
+                    const double fTWIPSToMM(127.0 / 72.0);
+                    const basegfx::utils::B2DHomMatrixBufferedDecompose aDecomposedTransform(rB2DHomMatrix);
+                    rB2DHomMatrix = basegfx::utils::createScaleShearXRotateTranslateB2DHomMatrix(
+                        aDecomposedTransform.getScale() * fTWIPSToMM,
+                        aDecomposedTransform.getShearX(),
+                        aDecomposedTransform.getRotate(),
+                        aDecomposedTransform.getTranslate() * fTWIPSToMM);
+                    break;
+                }
+                default:
+                {
+                    OSL_FAIL("Missing unit translation to 100th mm!");
+                }
+            }
+        }
+    }
+}
+
+static void SvxItemPropertySet_ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet,
+  SfxItemSet& rSet, const uno::Reference< beans::XPropertySet >& xSet, const SfxItemPropertyMap* pMap )
+{
+    if(rPropSet.AreThereOwnUsrAnys())
+    {
+        const SfxItemPropertyMap& rSrc = rPropSet.getPropertyMap();
+        PropertyEntryVector_t aSrcPropVector = rSrc.getPropertyEntries();
+
+        for(const auto& rSrcProp : aSrcPropVector)
+        {
+            const sal_uInt16 nWID = rSrcProp.nWID;
+            if(SfxItemPool::IsWhich(nWID)
+                    && (nWID < OWN_ATTR_VALUE_START || nWID > OWN_ATTR_VALUE_END)
+                    && rPropSet.GetUsrAnyForID(rSrcProp))
+                rSet.Put(rSet.GetPool()->GetDefaultItem(nWID));
+        }
+
+        for(const auto& rSrcProp : aSrcPropVector)
+        {
+            if(rSrcProp.nWID)
+            {
+                uno::Any* pUsrAny = rPropSet.GetUsrAnyForID(rSrcProp);
+                if(pUsrAny)
+                {
+                    // search for equivalent entry in pDst
+                    const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( rSrcProp.sName );
+                    if(pEntry)
+                    {
+                        // entry found
+                        if(pEntry->nWID >= OWN_ATTR_VALUE_START && pEntry->nWID <= OWN_ATTR_VALUE_END)
+                        {
+                            // special ID in PropertySet, can only be set
+                            // directly at the object
+                            xSet->setPropertyValue( rSrcProp.sName, *pUsrAny);
+                        }
+                        else
+                        {
+                            SvxItemPropertySet_setPropertyValue(pEntry, *pUsrAny, rSet);
+                        }
+                    }
+                }
+            }
+        }
+        const_cast< SvxItemPropertySet& >(rPropSet).ClearAllUsrAny();
+    }
+}
+
+
+void SvxShape::ObtainSettingsFromPropertySet(const SvxItemPropertySet& rPropSet)
+{
+    DBG_TESTSOLARMUTEX();
+    if(HasSdrObject() && rPropSet.AreThereOwnUsrAnys())
+    {
+        SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), svl::Items<SDRATTR_START, SDRATTR_END>{});
+        Reference< beans::XPropertySet > xShape( static_cast<OWeakObject*>(this), UNO_QUERY );
+        SvxItemPropertySet_ObtainSettingsFromPropertySet(rPropSet, aSet, xShape, &mpPropSet->getPropertyMap() );
+
+        GetSdrObject()->SetMergedItemSetAndBroadcast(aSet);
+
+        GetSdrObject()->ApplyNotPersistAttr( aSet );
+    }
+}
+
+uno::Any SvxShape::GetBitmap( bool bMetaFile /* = false */ ) const
+{
+    DBG_TESTSOLARMUTEX();
+    uno::Any aAny;
+
+    if(!HasSdrObject() || nullptr == GetSdrObject()->getSdrPageFromSdrObject())
+    {
+        return aAny;
+    }
+
+    // tdf#118662 Emulate old behaviour of XclObjComment (see there)
+    const SdrCaptionObj* pSdrCaptionObj(dynamic_cast<SdrCaptionObj*>(GetSdrObject()));
+    if(nullptr != pSdrCaptionObj && pSdrCaptionObj->isSuppressGetBitmap())
+    {
+        return aAny;
+    }
+
+    // tdf#119180 If we do not ask for Metafile and we access a SdrGrafObj,
+    // and content exists and is a Bitmap, take the shortcut.
+    // Do *not* do this for Metafile - as can be seen, requested in that case
+    // is a byte-sequence of a saved WMF format file (see below)
+    if(!bMetaFile)
+    {
+        const SdrGrafObj* pSdrGrafObj(dynamic_cast<SdrGrafObj*>(GetSdrObject()));
+
+        if(nullptr != pSdrGrafObj)
+        {
+            const Graphic& rGraphic(pSdrGrafObj->GetGraphic());
+
+            if(GraphicType::Bitmap == rGraphic.GetType())
+            {
+                Reference< awt::XBitmap > xBmp( rGraphic.GetXGraphic(), UNO_QUERY );
+                aAny <<= xBmp;
+
+                return aAny;
+            }
+        }
+    }
+
+    // tdf#118662 instead of creating an E3dView instance every time to paint
+    // a single SdrObject, use the existing SdrObject::SingleObjectPainter to
+    // use less resources and runtime
+    if(bMetaFile)
+    {
+        ScopedVclPtrInstance< VirtualDevice > pVDev;
+        const tools::Rectangle aBoundRect(GetSdrObject()->GetCurrentBoundRect());
+        GDIMetaFile aMtf;
+
+        pVDev->SetMapMode(MapMode(MapUnit::Map100thMM));
+        pVDev->EnableOutput(false);
+        aMtf.Record(pVDev);
+        GetSdrObject()->SingleObjectPainter(*pVDev);
+        aMtf.Stop();
+        aMtf.WindStart();
+        aMtf.Move(-aBoundRect.Left(), -aBoundRect.Top());
+        aMtf.SetPrefMapMode(MapMode(MapUnit::Map100thMM));
+        aMtf.SetPrefSize(aBoundRect.GetSize());
+
+        SvMemoryStream aDestStrm(65535, 65535);
+
+        ConvertGDIMetaFileToWMF(
+            aMtf,
+            aDestStrm,
+            nullptr,
+            false);
+
+        const uno::Sequence<sal_Int8> aSeq(
+            static_cast< const sal_Int8* >(aDestStrm.GetData()),
+            aDestStrm.GetEndOfData());
+
+        aAny <<= aSeq;
+    }
+    else
+    {
+        drawinglayer::primitive2d::Primitive2DContainer xPrimitives(
+            GetSdrObject()->GetViewContact().getViewIndependentPrimitive2DContainer());
+
+        if(!xPrimitives.empty())
+        {
+            const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
+            basegfx::B2DRange aRange(
+                xPrimitives.getB2DRange(aViewInformation2D));
+
+            if(!aRange.isEmpty())
+            {
+                const MapUnit aSourceMapUnit(GetSdrObject()->getSdrModelFromSdrObject().GetScaleUnit());
+
+                if(MapUnit::Map100thMM != aSourceMapUnit)
+                {
+                    // tdf#119180 This is UNO API and thus works in 100th_mm,
+                    // so if the MapMode from the used SdrModel is *not* equal
+                    // to Map100thMM we need to embed the primitives to an adapting
+                    // homogen transformation for correct values
+                    const basegfx::B2DHomMatrix aMapTransform(
+                        OutputDevice::LogicToLogic(
+                            MapMode(aSourceMapUnit),
+                            MapMode(MapUnit::Map100thMM)));
+
+                    // Embed primitives to get them in 100th mm
+                    const drawinglayer::primitive2d::Primitive2DReference xEmbedRef(
+                        new drawinglayer::primitive2d::TransformPrimitive2D(
+                            aMapTransform,
+                            xPrimitives));
+
+                    xPrimitives = drawinglayer::primitive2d::Primitive2DContainer { xEmbedRef };
+
+                    // Update basegfx::B2DRange aRange, too. Here we have the
+                    // choice of transforming the existing value or get newly by
+                    // again using 'xPrimitives.getB2DRange(aViewInformation2D)'
+                    aRange.transform(aMapTransform);
+                }
+
+                const BitmapEx aBmp(
+                    convertPrimitive2DSequenceToBitmapEx(
+                        xPrimitives,
+                        aRange));
+
+                Graphic aGraph(aBmp);
+
+                aGraph.SetPrefSize(aBmp.GetPrefSize());
+                aGraph.SetPrefMapMode(aBmp.GetPrefMapMode());
+
+                Reference< awt::XBitmap > xBmp( aGraph.GetXGraphic(), UNO_QUERY );
+                aAny <<= xBmp;
+            }
+        }
+    }
+
+    return aAny;
+}
+
+uno::Sequence< uno::Type > SAL_CALL SvxShape::getTypes()
+{
+    if( mpImpl->mpMaster )
+    {
+        return mpImpl->mpMaster->getTypes();
+    }
+    else
+    {
+        return _getTypes();
+    }
+}
+
+
+uno::Sequence< uno::Type > const & SvxShape::_getTypes()
+{
+    switch( mpImpl->mnObjId )
+    {
+    // shapes without text
+    case OBJ_PAGE:
+    case OBJ_FRAME:
+    case OBJ_OLE2_PLUGIN:
+    case OBJ_OLE2_APPLET:
+    case E3D_CUBEOBJ_ID|E3D_INVENTOR_FLAG:
+    case E3D_SPHEREOBJ_ID|E3D_INVENTOR_FLAG:
+    case E3D_LATHEOBJ_ID|E3D_INVENTOR_FLAG:
+    case E3D_EXTRUDEOBJ_ID|E3D_INVENTOR_FLAG:
+    case E3D_POLYGONOBJ_ID|E3D_INVENTOR_FLAG:
+    case OBJ_MEDIA:
+    case OBJ_TABLE:
+        {
+            static uno::Sequence<uno::Type> aTypeSequence{
+                cppu::UnoType<drawing::XShape>::get(),
+                cppu::UnoType<lang::XComponent>::get(),
+                cppu::UnoType<beans::XPropertySet>::get(),
+                cppu::UnoType<beans::XMultiPropertySet>::get(),
+                cppu::UnoType<beans::XPropertyState>::get(),
+                cppu::UnoType<beans::XMultiPropertyStates>::get(),
+                cppu::UnoType<drawing::XGluePointsSupplier>::get(),
+                cppu::UnoType<container::XChild>::get(),
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XTypeProvider>::get(),
+                cppu::UnoType<lang::XUnoTunnel>::get(),
+                cppu::UnoType<container::XNamed>::get(),
+            };
+
+            return aTypeSequence;
+        }
+    // group shape
+    case OBJ_GRUP:
+        {
+            static uno::Sequence<uno::Type> aTypeSequence{
+                cppu::UnoType<drawing::XShape>::get(),
+                cppu::UnoType<lang::XComponent>::get(),
+                cppu::UnoType<beans::XPropertySet>::get(),
+                cppu::UnoType<beans::XMultiPropertySet>::get(),
+                cppu::UnoType<beans::XPropertyState>::get(),
+                cppu::UnoType<beans::XMultiPropertyStates>::get(),
+                cppu::UnoType<drawing::XGluePointsSupplier>::get(),
+                cppu::UnoType<container::XChild>::get(),
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XTypeProvider>::get(),
+                cppu::UnoType<lang::XUnoTunnel>::get(),
+                cppu::UnoType<container::XNamed>::get(),
+                cppu::UnoType<drawing::XShapes>::get(),
+                cppu::UnoType<drawing::XShapeGroup>::get(),
+            };
+
+            return aTypeSequence;
+        }
+    // connector shape
+    case OBJ_EDGE:
+        {
+            static uno::Sequence<uno::Type> aTypeSequence{
+                cppu::UnoType<drawing::XShape>::get(),
+                cppu::UnoType<lang::XComponent>::get(),
+                cppu::UnoType<beans::XPropertySet>::get(),
+                cppu::UnoType<beans::XMultiPropertySet>::get(),
+                cppu::UnoType<beans::XPropertyState>::get(),
+                cppu::UnoType<beans::XMultiPropertyStates>::get(),
+                cppu::UnoType<drawing::XGluePointsSupplier>::get(),
+                cppu::UnoType<container::XChild>::get(),
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XTypeProvider>::get(),
+                cppu::UnoType<lang::XUnoTunnel>::get(),
+                cppu::UnoType<container::XNamed>::get(),
+                cppu::UnoType<drawing::XConnectorShape>::get(),
+                // from SvxUnoTextBase::getTypes()
+                cppu::UnoType<text::XTextAppend>::get(),
+                cppu::UnoType<text::XTextCopy>::get(),
+                cppu::UnoType<container::XEnumerationAccess>::get(),
+                cppu::UnoType<text::XTextRangeMover>::get(),
+            };
+
+            return aTypeSequence;
+        }
+    // control shape
+    case OBJ_UNO:
+        {
+            static uno::Sequence<uno::Type> aTypeSequence{
+                cppu::UnoType<drawing::XShape>::get(),
+                cppu::UnoType<lang::XComponent>::get(),
+                cppu::UnoType<beans::XPropertySet>::get(),
+                cppu::UnoType<beans::XMultiPropertySet>::get(),
+                cppu::UnoType<beans::XPropertyState>::get(),
+                cppu::UnoType<beans::XMultiPropertyStates>::get(),
+                cppu::UnoType<drawing::XGluePointsSupplier>::get(),
+                cppu::UnoType<container::XChild>::get(),
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XTypeProvider>::get(),
+                cppu::UnoType<lang::XUnoTunnel>::get(),
+                cppu::UnoType<container::XNamed>::get(),
+                cppu::UnoType<drawing::XControlShape>::get(),
+            };
+
+            return aTypeSequence;
+        }
+    // 3d scene shape
+    case E3D_SCENE_ID|E3D_INVENTOR_FLAG:
+        {
+            static uno::Sequence<uno::Type> aTypeSequence{
+                cppu::UnoType<drawing::XShape>::get(),
+                cppu::UnoType<lang::XComponent>::get(),
+                cppu::UnoType<beans::XPropertySet>::get(),
+                cppu::UnoType<beans::XMultiPropertySet>::get(),
+                cppu::UnoType<beans::XPropertyState>::get(),
+                cppu::UnoType<beans::XMultiPropertyStates>::get(),
+                cppu::UnoType<drawing::XGluePointsSupplier>::get(),
+                cppu::UnoType<container::XChild>::get(),
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XTypeProvider>::get(),
+                cppu::UnoType<lang::XUnoTunnel>::get(),
+                cppu::UnoType<container::XNamed>::get(),
+                cppu::UnoType<drawing::XShapes>::get(),
+            };
+
+            return aTypeSequence;
+        }
+    case OBJ_CUSTOMSHAPE:
+        {
+            static uno::Sequence<uno::Type> aTypeSequence{
+                cppu::UnoType<drawing::XShape>::get(),
+                cppu::UnoType<lang::XComponent>::get(),
+                cppu::UnoType<beans::XPropertySet>::get(),
+                cppu::UnoType<beans::XMultiPropertySet>::get(),
+                cppu::UnoType<beans::XPropertyState>::get(),
+                cppu::UnoType<beans::XMultiPropertyStates>::get(),
+                cppu::UnoType<drawing::XGluePointsSupplier>::get(),
+                cppu::UnoType<container::XChild>::get(),
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XTypeProvider>::get(),
+                cppu::UnoType<lang::XUnoTunnel>::get(),
+                cppu::UnoType<container::XNamed>::get(),
+                // from SvxUnoTextBase::getTypes()
+                cppu::UnoType<text::XText>::get(),
+                cppu::UnoType<container::XEnumerationAccess>::get(),
+                cppu::UnoType<text::XTextRangeMover>::get(),
+                cppu::UnoType<drawing::XEnhancedCustomShapeDefaulter>::get(),
+            };
+
+            return aTypeSequence;
+        }
+    // shapes with text
+    case OBJ_RECT:
+    case OBJ_CIRC:
+    case OBJ_MEASURE:
+    case OBJ_LINE:
+    case OBJ_POLY:
+    case OBJ_PLIN:
+    case OBJ_PATHLINE:
+    case OBJ_PATHFILL:
+    case OBJ_FREELINE:
+    case OBJ_FREEFILL:
+    case OBJ_PATHPOLY:
+    case OBJ_PATHPLIN:
+    case OBJ_GRAF:
+    case OBJ_TEXT:
+    case OBJ_CAPTION:
+    case OBJ_OLE2: // #i118485# Moved to shapes with text
+    default:
+        {
+            static uno::Sequence<uno::Type> aTypeSequence{
+                cppu::UnoType<drawing::XShape>::get(),
+                cppu::UnoType<lang::XComponent>::get(),
+                cppu::UnoType<beans::XPropertySet>::get(),
+                cppu::UnoType<beans::XMultiPropertySet>::get(),
+                cppu::UnoType<beans::XPropertyState>::get(),
+                cppu::UnoType<beans::XMultiPropertyStates>::get(),
+                cppu::UnoType<drawing::XGluePointsSupplier>::get(),
+                cppu::UnoType<container::XChild>::get(),
+                cppu::UnoType<lang::XServiceInfo>::get(),
+                cppu::UnoType<lang::XTypeProvider>::get(),
+                cppu::UnoType<lang::XUnoTunnel>::get(),
+                cppu::UnoType<container::XNamed>::get(),
+                // from SvxUnoTextBase::getTypes()
+                cppu::UnoType<text::XTextAppend>::get(),
+                cppu::UnoType<text::XTextCopy>::get(),
+                cppu::UnoType<container::XEnumerationAccess>::get(),
+                cppu::UnoType<text::XTextRangeMover>::get(),
+            };
+
+            return aTypeSequence;
+        }
+    }
+}
+
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxShape::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+void SvxShape::Notify( SfxBroadcaster&, const SfxHint& rHint ) throw()
+{
+    DBG_TESTSOLARMUTEX();
+    if( !HasSdrObject() )
+        return;
+
+    // #i55919# SdrHintKind::ObjectChange is only interesting if it's for this object
+    if (rHint.GetId() != SfxHintId::ThisIsAnSdrHint)
+        return;
+    SdrObject* pSdrObject(GetSdrObject());
+    const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
+    if ((pSdrHint->GetKind() != SdrHintKind::ModelCleared) &&
+         (pSdrHint->GetKind() != SdrHintKind::ObjectChange || pSdrHint->GetObject() != pSdrObject ))
+        return;
+
+    uno::Reference< uno::XInterface > xSelf( pSdrObject->getWeakUnoShape() );
+    if( !xSelf.is() )
+    {
+        EndListening(pSdrObject->getSdrModelFromSdrObject());
+        mpSdrObjectWeakReference.reset(nullptr);
+        return;
+    }
+
+    bool bClearMe = false;
+
+    switch( pSdrHint->GetKind() )
+    {
+        case SdrHintKind::ObjectChange:
+        {
+            updateShapeKind();
+            break;
+        }
+        case SdrHintKind::ModelCleared:
+        {
+            bClearMe = true;
+            break;
+        }
+        default:
+            break;
+    };
+
+    if( bClearMe )
+    {
+        if(!HasSdrObjectOwnership())
+        {
+            if(nullptr != pSdrObject)
+            {
+                EndListening(pSdrObject->getSdrModelFromSdrObject());
+                pSdrObject->setUnoShape(nullptr);
+            }
+
+            mpSdrObjectWeakReference.reset(nullptr);
+
+            // SdrModel *is* going down, try to Free SdrObject even
+            // when !HasSdrObjectOwnership
+            if(nullptr != pSdrObject && !pSdrObject->IsInserted())
+            {
+                SdrObject::Free(pSdrObject);
+            }
+        }
+
+        if(!mpImpl->mbDisposing)
+        {
+            dispose();
+        }
+    }
+}
+
+// XShape
+
+
+// The "*LogicRectHack" functions also existed in sch, and those
+// duplicate symbols cause Bad Things To Happen (TM)  #i9462#.
+// Prefixing with 'svx' and marking static to make sure name collisions
+// do not occur.
+
+static bool svx_needLogicRectHack( SdrObject const * pObj )
+{
+    if( pObj->GetObjInventor() == SdrInventor::Default)
+    {
+        switch(pObj->GetObjIdentifier())
+        {
+        case OBJ_GRUP:
+        case OBJ_LINE:
+        case OBJ_POLY:
+        case OBJ_PLIN:
+        case OBJ_PATHLINE:
+        case OBJ_PATHFILL:
+        case OBJ_FREELINE:
+        case OBJ_FREEFILL:
+        case OBJ_SPLNLINE:
+        case OBJ_SPLNFILL:
+        case OBJ_EDGE:
+        case OBJ_PATHPOLY:
+        case OBJ_PATHPLIN:
+        case OBJ_MEASURE:
+            return true;
+        }
+    }
+    return false;
+}
+
+
+static tools::Rectangle svx_getLogicRectHack( SdrObject const * pObj )
+{
+    if(svx_needLogicRectHack(pObj))
+    {
+        return pObj->GetSnapRect();
+    }
+    else
+    {
+        return pObj->GetLogicRect();
+    }
+}
+
+
+static void svx_setLogicRectHack( SdrObject* pObj, const tools::Rectangle& rRect )
+{
+    if(svx_needLogicRectHack(pObj))
+    {
+        pObj->SetSnapRect( rRect );
+    }
+    else
+    {
+        pObj->SetLogicRect( rRect );
+    }
+}
+
+
+awt::Point SAL_CALL SvxShape::getPosition()
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+    {
+        tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) );
+        Point aPt( aRect.Left(), aRect.Top() );
+
+        // Position is relative to anchor, so recalc to absolute position
+        if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+            aPt -= GetSdrObject()->GetAnchorPos();
+
+        ForceMetricTo100th_mm(aPt);
+        return css::awt::Point( aPt.X(), aPt.Y() );
+    }
+    else
+    {
+        return maPosition;
+    }
+}
+
+
+void SAL_CALL SvxShape::setPosition( const awt::Point& Position )
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+    {
+        // do NOT move 3D objects, this would change the homogen
+        // transformation matrix
+        if(dynamic_cast<const E3dCompoundObject* >(GetSdrObject()) == nullptr)
+        {
+            tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) );
+            Point aLocalPos( Position.X, Position.Y );
+            ForceMetricToItemPoolMetric(aLocalPos);
+
+            // Position is absolute, so recalc to position relative to anchor
+            if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+                aLocalPos += GetSdrObject()->GetAnchorPos();
+
+            long nDX = aLocalPos.X() - aRect.Left();
+            long nDY = aLocalPos.Y() - aRect.Top();
+
+            GetSdrObject()->Move( Size( nDX, nDY ) );
+            GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+        }
+    }
+
+    maPosition = Position;
+}
+
+
+awt::Size SAL_CALL SvxShape::getSize()
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+    {
+        tools::Rectangle aRect( svx_getLogicRectHack(GetSdrObject()) );
+        Size aObjSize( aRect.getWidth(), aRect.getHeight() );
+        ForceMetricTo100th_mm(aObjSize);
+        return css::awt::Size( aObjSize.getWidth(), aObjSize.getHeight() );
+    }
+    else
+        return maSize;
+}
+
+
+void SAL_CALL SvxShape::setSize( const awt::Size& rSize )
+{
+    ::SolarMutexGuard aGuard;
+
+    if(HasSdrObject())
+    {
+        // #i123539# optimization for 3D chart object generation: do not use UNO
+        // API commands to get the range, this is too expensive since for 3D
+        // scenes it may recalculate the whole scene since in AOO this depends
+        // on the contained geometry (layouted to show all content)
+        const bool b3DConstruction(dynamic_cast< E3dObject* >(GetSdrObject()) && GetSdrObject()->getSdrModelFromSdrObject().isLocked());
+        tools::Rectangle aRect(
+            b3DConstruction ?
+                tools::Rectangle(maPosition.X, maPosition.Y, maSize.Width, maSize.Height) :
+                svx_getLogicRectHack(GetSdrObject()) );
+        Size aLocalSize( rSize.Width, rSize.Height );
+        ForceMetricToItemPoolMetric(aLocalSize);
+
+        if(GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == OBJ_MEASURE )
+        {
+            Fraction aWdt(aLocalSize.Width(),aRect.Right()-aRect.Left());
+            Fraction aHgt(aLocalSize.Height(),aRect.Bottom()-aRect.Top());
+            Point aPt = GetSdrObject()->GetSnapRect().TopLeft();
+            GetSdrObject()->Resize(aPt,aWdt,aHgt);
+        }
+        else
+        {
+            //aRect.SetSize(aLocalSize); // this call subtract 1 // https://bz.apache.org/ooo/show_bug.cgi?id=83193
+            if ( !aLocalSize.Width() )
+            {
+                aRect.SetWidthEmpty();
+            }
+            else
+                aRect.setWidth(aLocalSize.Width());
+            if ( !aLocalSize.Height() )
+            {
+                aRect.SetHeightEmpty();
+            }
+            else
+                aRect.setHeight(aLocalSize.Height());
+
+            svx_setLogicRectHack( GetSdrObject(), aRect );
+        }
+
+        GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+    }
+    maSize = rSize;
+}
+
+
+// XNamed
+OUString SAL_CALL SvxShape::getName(  )
+{
+    ::SolarMutexGuard aGuard;
+    if( HasSdrObject() )
+    {
+        return GetSdrObject()->GetName();
+    }
+    else
+    {
+        return maShapeName;
+    }
+}
+
+
+void SAL_CALL SvxShape::setName( const OUString& aName )
+{
+    ::SolarMutexGuard aGuard;
+    if( HasSdrObject() )
+    {
+        GetSdrObject()->SetName( aName );
+    }
+    else
+    {
+        maShapeName = aName;
+    }
+}
+
+// XShapeDescriptor
+
+
+OUString SAL_CALL SvxShape::getShapeType()
+{
+    if( !maShapeType.getLength() )
+        return UHashMap::getNameFromId( mpImpl->mnObjId );
+    else
+        return maShapeType;
+}
+
+// XComponent
+
+
+void SAL_CALL SvxShape::dispose()
+{
+    ::SolarMutexGuard aGuard;
+
+    if( mpImpl->mbDisposing )
+        return; // caught a recursion
+
+    mpImpl->mbDisposing = true;
+
+    lang::EventObject aEvt;
+    aEvt.Source = *static_cast<OWeakAggObject*>(this);
+    mpImpl->maDisposeListeners.disposeAndClear(aEvt);
+    mpImpl->maPropertyNotifier.disposing();
+
+    if ( HasSdrObject() )
+    {
+        SdrObject* pObject = GetSdrObject();
+
+        EndListening( pObject->getSdrModelFromSdrObject() );
+        bool bFreeSdrObject = false;
+
+        if ( pObject->IsInserted() && pObject->getSdrPageFromSdrObject() )
+        {
+            OSL_ENSURE( HasSdrObjectOwnership(), "SvxShape::dispose: is the below code correct?" );
+                // normally, we are allowed to free the SdrObject only if we have its ownership.
+                // Why isn't this checked here?
+
+            SdrPage* pPage = pObject->getSdrPageFromSdrObject();
+            // delete the SdrObject from the page
+            const size_t nCount = pPage->GetObjCount();
+            for ( size_t nNum = 0; nNum < nCount; ++nNum )
+            {
+                if ( pPage->GetObj( nNum ) == pObject )
+                {
+                    OSL_VERIFY( pPage->RemoveObject( nNum ) == pObject );
+                    bFreeSdrObject = true;
+                    break;
+                }
+            }
+        }
+
+        pObject->setUnoShape(nullptr);
+
+        if ( bFreeSdrObject )
+        {
+            // in case we have the ownership of the SdrObject, a Free
+            // would do nothing. So ensure the ownership is reset.
+            mpImpl->mbHasSdrObjectOwnership = false;
+            SdrObject::Free( pObject );
+        }
+    }
+}
+
+
+void SAL_CALL SvxShape::addEventListener( const Reference< lang::XEventListener >& xListener )
+{
+    mpImpl->maDisposeListeners.addInterface(xListener);
+}
+
+
+void SAL_CALL SvxShape::removeEventListener( const Reference< lang::XEventListener >& aListener )
+{
+   mpImpl->maDisposeListeners.removeInterface(aListener);
+}
+
+// XPropertySet
+
+
+Reference< beans::XPropertySetInfo > SAL_CALL
+    SvxShape::getPropertySetInfo()
+{
+    if( mpImpl->mpMaster )
+    {
+        return mpImpl->mpMaster->getPropertySetInfo();
+    }
+    else
+    {
+        return _getPropertySetInfo();
+    }
+}
+
+Reference< beans::XPropertySetInfo > const &
+    SvxShape::_getPropertySetInfo()
+{
+    return mpPropSet->getPropertySetInfo();
+}
+
+
+void SAL_CALL SvxShape::addPropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener  )
+{
+    ::osl::MutexGuard aGuard( maMutex );
+    mpImpl->maPropertyNotifier.addPropertyChangeListener( _propertyName, _listener );
+}
+
+
+void SAL_CALL SvxShape::removePropertyChangeListener( const OUString& _propertyName, const Reference< beans::XPropertyChangeListener >& _listener  )
+{
+    ::osl::MutexGuard aGuard( maMutex );
+    mpImpl->maPropertyNotifier.removePropertyChangeListener( _propertyName, _listener );
+}
+
+
+void SAL_CALL SvxShape::addVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >&  )
+{
+    OSL_FAIL( "SvxShape::addVetoableChangeListener: don't have any vetoable properties, so why ...?" );
+}
+
+
+void SAL_CALL SvxShape::removeVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >&  )
+{
+    OSL_FAIL( "SvxShape::removeVetoableChangeListener: don't have any vetoable properties, so why ...?" );
+}
+
+
+bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName )
+{
+    if(HasSdrObject())
+    {
+        SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(), {{nWID, nWID}} );
+
+        if( SetFillAttribute( nWID, rName, aSet, &GetSdrObject()->getSdrModelFromSdrObject() ) )
+        {
+            //GetSdrObject()->SetItemSetAndBroadcast(aSet);
+            GetSdrObject()->SetMergedItemSetAndBroadcast(aSet);
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName, SfxItemSet& rSet, SdrModel const * pModel )
+{
+    // check if an item with the given name and which id is inside the models
+    // pool or the stylesheet pool, if found it's put in the itemset
+    if( !SetFillAttribute( nWID, rName, rSet ) )
+    {
+        // we did not find such item in one of the pools, so we check
+        // the property lists that are loaded for the model for items
+        // that support such.
+        OUString aStrName = SvxUnogetInternalNameForItem(nWID, rName);
+
+        switch( nWID )
+        {
+        case XATTR_FILLBITMAP:
+        {
+            XBitmapListRef pBitmapList = pModel->GetBitmapList();
+
+            if( !pBitmapList.is() )
+                return false;
+
+            long nPos = pBitmapList->GetIndex(aStrName);
+            if( nPos == -1 )
+                return false;
+
+            const XBitmapEntry* pEntry = pBitmapList->GetBitmap(nPos);
+            XFillBitmapItem aBmpItem(rName, pEntry->GetGraphicObject());
+            rSet.Put(aBmpItem);
+            break;
+        }
+        case XATTR_FILLGRADIENT:
+        {
+            XGradientListRef pGradientList = pModel->GetGradientList();
+
+            if( !pGradientList.is() )
+                return false;
+
+            long nPos = pGradientList->GetIndex(aStrName);
+            if( nPos == -1 )
+                return false;
+
+            const XGradientEntry* pEntry = pGradientList->GetGradient(nPos);
+            XFillGradientItem aGrdItem(rName, pEntry->GetGradient());
+            rSet.Put( aGrdItem );
+            break;
+        }
+        case XATTR_FILLHATCH:
+        {
+            XHatchListRef pHatchList = pModel->GetHatchList();
+
+            if( !pHatchList.is() )
+                return false;
+
+            long nPos = pHatchList->GetIndex(aStrName);
+            if( nPos == -1 )
+                return false;
+
+            const XHatchEntry* pEntry = pHatchList->GetHatch( nPos );
+            XFillHatchItem aHatchItem(rName, pEntry->GetHatch());
+            rSet.Put( aHatchItem );
+            break;
+        }
+        case XATTR_LINEEND:
+        case XATTR_LINESTART:
+        {
+            XLineEndListRef pLineEndList = pModel->GetLineEndList();
+
+            if( !pLineEndList.is() )
+                return false;
+
+            long nPos = pLineEndList->GetIndex(aStrName);
+            if( nPos == -1 )
+                return false;
+
+            const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nPos);
+            if( sal_uInt16(XATTR_LINEEND) == nWID )
+            {
+                XLineEndItem aLEItem(rName, pEntry->GetLineEnd());
+                rSet.Put( aLEItem );
+            }
+            else
+            {
+                XLineStartItem aLSItem(rName, pEntry->GetLineEnd());
+                rSet.Put( aLSItem );
+            }
+
+            break;
+        }
+        case XATTR_LINEDASH:
+        {
+            XDashListRef pDashList = pModel->GetDashList();
+
+            if( !pDashList.is() )
+                return false;
+
+            long nPos = pDashList->GetIndex(aStrName);
+            if( nPos == -1 )
+                return false;
+
+            const XDashEntry* pEntry = pDashList->GetDash(nPos);
+            XLineDashItem aDashItem(rName, pEntry->GetDash());
+            rSet.Put( aDashItem );
+            break;
+        }
+        default:
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
+bool SvxShape::SetFillAttribute( sal_uInt16 nWID, const OUString& rName, SfxItemSet& rSet )
+{
+    OUString aName = SvxUnogetInternalNameForItem(nWID, rName);
+
+    if (aName.isEmpty())
+    {
+        switch( nWID )
+        {
+        case XATTR_LINEEND:
+        case XATTR_LINESTART:
+            {
+                const basegfx::B2DPolyPolygon aEmptyPoly;
+                if( nWID == sal_uInt16(XATTR_LINEEND) )
+                    rSet.Put( XLineEndItem( "", aEmptyPoly ) );
+                else
+                    rSet.Put( XLineStartItem( "", aEmptyPoly ) );
+
+                return true;
+            }
+        case XATTR_FILLFLOATTRANSPARENCE:
+            {
+                // #85953# Set a disabled XFillFloatTransparenceItem
+                rSet.Put(XFillFloatTransparenceItem());
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    for (const SfxPoolItem* p : rSet.GetPool()->GetItemSurrogates(nWID))
+    {
+        const NameOrIndex* pItem = static_cast<const NameOrIndex*>(p);
+        if( pItem->GetName() == aName )
+        {
+            rSet.Put( *pItem );
+            return true;
+        }
+    }
+
+    return false;
+}
+
+
+void SAL_CALL SvxShape::setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal )
+{
+    if( mpImpl->mpMaster )
+    {
+        mpImpl->mpMaster->setPropertyValue( rPropertyName, rVal );
+    }
+    else
+    {
+        _setPropertyValue( rPropertyName, rVal );
+    }
+}
+
+void SvxShape::_setPropertyValue( const OUString& rPropertyName, const uno::Any& rVal )
+{
+    ::SolarMutexGuard aGuard;
+
+    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(rPropertyName);
+
+    if (!HasSdrObject())
+    {
+        // Since we have no actual sdr object right now, remember all
+        // properties in a list. These properties will be set when the sdr
+        // object is created.
+
+        if (pMap && pMap->nWID)
+        {
+            // FIXME: We should throw a UnknownPropertyException here.
+            //        But since this class is aggregated from classes that
+            //        support additional properties that we don't know here we
+            //        silently store *all* properties, even if they may be not
+            //        supported after creation.
+            mpPropSet->setPropertyValue( pMap, rVal );
+        }
+
+        return;
+    }
+
+    if (!pMap)
+    {
+        // reduce log noise by ignoring two properties that higher level code queries for on all objects
+        SAL_WARN_IF(rPropertyName != "FromWordArt" && rPropertyName != "GraphicColorMode",
+            "svx.uno", "Unknown Property: " << rPropertyName);
+        throw beans::UnknownPropertyException( rPropertyName, static_cast<cppu::OWeakObject*>(this));
+    }
+
+    if ((pMap->nFlags & beans::PropertyAttribute::READONLY) != 0)
+        throw beans::PropertyVetoException(
+            "Readonly property can't be set: " + rPropertyName,
+            uno::Reference<drawing::XShape>(this));
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+
+    if (setPropertyValueImpl(rPropertyName, pMap, rVal))
+        return;
+
+    DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST, "Not persist item not handled!" );
+    DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" );
+
+    bool bIsNotPersist = pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST && pMap->nWID != SDRATTR_TEXTDIRECTION;
+
+    if( pMap->nWID == SDRATTR_ECKENRADIUS )
+    {
+        sal_Int32 nCornerRadius = 0;
+        if( !(rVal >>= nCornerRadius) || (nCornerRadius < 0) || (nCornerRadius > 5000000))
+            throw IllegalArgumentException();
+    }
+
+    SfxItemSet* pSet;
+    if( mbIsMultiPropertyCall && !bIsNotPersist )
+    {
+        if( mpImpl->mpItemSet == nullptr )
+        {
+            mpImpl->mpItemSet.reset(new SfxItemSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(),  {{pMap->nWID, pMap->nWID}}));
+        }
+        else
+        {
+            mpImpl->mpItemSet->MergeRange(pMap->nWID, pMap->nWID);
+        }
+        pSet = mpImpl->mpItemSet.get();
+    }
+    else
+    {
+        pSet = new SfxItemSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(),  {{pMap->nWID, pMap->nWID}});
+    }
+
+    if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET )
+        pSet->Put(GetSdrObject()->GetMergedItem(pMap->nWID));
+
+    if( !SvxUnoTextRangeBase::SetPropertyValueHelper( pMap, rVal, *pSet ))
+    {
+        if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET )
+        {
+            if(bIsNotPersist)
+            {
+                // not-persistent attribute, get those extra
+                GetSdrObject()->TakeNotPersistAttr(*pSet);
+            }
+        }
+
+        if( pSet->GetItemState( pMap->nWID ) != SfxItemState::SET )
+        {
+            // get default from ItemPool
+            if(SfxItemPool::IsWhich(pMap->nWID))
+                pSet->Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID));
+        }
+
+        if( pSet->GetItemState( pMap->nWID ) == SfxItemState::SET )
+        {
+            SvxItemPropertySet_setPropertyValue( pMap, rVal, *pSet );
+        }
+    }
+
+    if(bIsNotPersist)
+    {
+        // set not-persistent attribute extra
+        GetSdrObject()->ApplyNotPersistAttr( *pSet );
+        delete pSet;
+    }
+    else
+    {
+        // if we have a XMultiProperty call then the item set
+        // will be set in setPropertyValues later
+        if( !mbIsMultiPropertyCall )
+        {
+            GetSdrObject()->SetMergedItemSetAndBroadcast( *pSet );
+
+            delete pSet;
+        }
+    }
+}
+
+
+uno::Any SAL_CALL SvxShape::getPropertyValue( const OUString& PropertyName )
+{
+    if ( mpImpl->mpMaster )
+        return mpImpl->mpMaster->getPropertyValue( PropertyName );
+    else
+        return _getPropertyValue( PropertyName );
+}
+
+
+uno::Any SvxShape::_getPropertyValue( const OUString& PropertyName )
+{
+    ::SolarMutexGuard aGuard;
+
+    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
+
+    uno::Any aAny;
+    if(HasSdrObject())
+    {
+        if(pMap == nullptr )
+            throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
+
+        if( !getPropertyValueImpl( PropertyName, pMap, aAny ) )
+        {
+            DBG_ASSERT( pMap->nWID == SDRATTR_TEXTDIRECTION || (pMap->nWID < SDRATTR_NOTPERSIST_FIRST || pMap->nWID > SDRATTR_NOTPERSIST_LAST), "Not persist item not handled!" );
+            DBG_ASSERT( pMap->nWID < OWN_ATTR_VALUE_START || pMap->nWID > OWN_ATTR_VALUE_END, "Not item property not handled!" );
+
+            SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(),    {{pMap->nWID, pMap->nWID}});
+            aSet.Put(GetSdrObject()->GetMergedItem(pMap->nWID));
+
+            if(SvxUnoTextRangeBase::GetPropertyValueHelper(  aSet, pMap, aAny ))
+                return aAny;
+
+            if(!aSet.Count())
+            {
+                if(pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST)
+                {
+                    // not-persistent attribute, get those extra
+                    GetSdrObject()->TakeNotPersistAttr(aSet);
+                }
+            }
+
+            if(!aSet.Count())
+            {
+                // get default from ItemPool
+                if(SfxItemPool::IsWhich(pMap->nWID))
+                    aSet.Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID));
+            }
+
+            if(aSet.Count())
+                aAny = GetAnyForItem( aSet, pMap );
+        }
+    }
+    else
+    {
+
+// Fixme: we should return default values for OWN_ATTR !
+
+        if(pMap && pMap->nWID)
+//      FixMe: see setPropertyValue
+            aAny = mpPropSet->getPropertyValue( pMap );
+
+    }
+    return aAny;
+}
+
+
+// XMultiPropertySet
+void SAL_CALL SvxShape::setPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames, const css::uno::Sequence< css::uno::Any >& aValues )
+{
+    ::SolarMutexGuard aSolarGuard;
+
+    const sal_Int32 nCount = aPropertyNames.getLength();
+    const OUString* pNames = aPropertyNames.getConstArray();
+
+    const uno::Any* pValues = aValues.getConstArray();
+
+    // make sure mbIsMultiPropertyCall and mpImpl->mpItemSet are
+    // reset even when an exception is thrown
+    const ::comphelper::ScopeGuard aGuard( [this] () { return this->endSetPropertyValues(); } );
+
+    mbIsMultiPropertyCall = true;
+
+    if( mpImpl->mpMaster )
+    {
+        for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
+        {
+            try
+            {
+                setPropertyValue( *pNames, *pValues );
+            }
+            catch( beans::UnknownPropertyException& ) {}
+            catch( uno::Exception& ) {}
+        }
+    }
+    else
+    {
+        uno::Reference< beans::XPropertySet > xSet;
+        queryInterface( cppu::UnoType<beans::XPropertySet>::get()) >>= xSet;
+
+        for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pNames++, pValues++ )
+        {
+            try
+            {
+                xSet->setPropertyValue( *pNames, *pValues );
+            }
+            catch( beans::UnknownPropertyException& ) {}
+            catch( uno::Exception& ) {}
+        }
+    }
+
+    if( mpImpl->mpItemSet && HasSdrObject() )
+        GetSdrObject()->SetMergedItemSetAndBroadcast( *mpImpl->mpItemSet );
+}
+
+
+void SvxShape::endSetPropertyValues()
+{
+    mbIsMultiPropertyCall = false;
+    mpImpl->mpItemSet.reset();
+}
+
+
+css::uno::Sequence< css::uno::Any > SAL_CALL SvxShape::getPropertyValues( const css::uno::Sequence< OUString >& aPropertyNames )
+{
+    const sal_Int32 nCount = aPropertyNames.getLength();
+    const OUString* pNames = aPropertyNames.getConstArray();
+
+    uno::Sequence< uno::Any > aRet( nCount );
+    uno::Any* pValue = aRet.getArray();
+
+    if( mpImpl->mpMaster )
+    {
+        for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
+        {
+            try
+            {
+                *pValue = getPropertyValue( *pNames );
+            }
+            catch( uno::Exception& )
+            {
+                OSL_FAIL( "SvxShape::getPropertyValues, unknown property asked" );
+            }
+        }
+    }
+    else
+    {
+        uno::Reference< beans::XPropertySet > xSet;
+        queryInterface( cppu::UnoType<beans::XPropertySet>::get()) >>= xSet;
+
+        for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++, pValue++, pNames++ )
+        {
+            try
+            {
+                *pValue = xSet->getPropertyValue( *pNames );
+            }
+            catch( uno::Exception& )
+            {
+                OSL_FAIL( "SvxShape::getPropertyValues, unknown property asked" );
+            }
+        }
+    }
+
+    return aRet;
+}
+
+void SAL_CALL SvxShape::addPropertiesChangeListener( const css::uno::Sequence< OUString >& , const css::uno::Reference< css::beans::XPropertiesChangeListener >&  )
+{
+}
+
+void SAL_CALL SvxShape::removePropertiesChangeListener( const css::uno::Reference< css::beans::XPropertiesChangeListener >&  )
+{
+}
+
+void SAL_CALL SvxShape::firePropertiesChangeEvent( const css::uno::Sequence< OUString >& , const css::uno::Reference< css::beans::XPropertiesChangeListener >&  )
+{
+}
+
+
+uno::Any SvxShape::GetAnyForItem( SfxItemSet const & aSet, const SfxItemPropertySimpleEntry* pMap ) const
+{
+    DBG_TESTSOLARMUTEX();
+    uno::Any aAny;
+
+    switch(pMap->nWID)
+    {
+    case SDRATTR_CIRCSTARTANGLE:
+    {
+        const SfxPoolItem* pPoolItem=nullptr;
+        if(aSet.GetItemState(SDRATTR_CIRCSTARTANGLE,false,&pPoolItem)==SfxItemState::SET)
+        {
+            sal_Int32 nAngle = static_cast<const SdrAngleItem*>(pPoolItem)->GetValue();
+            aAny <<= nAngle;
+        }
+        break;
+    }
+
+    case SDRATTR_CIRCENDANGLE:
+    {
+        const SfxPoolItem* pPoolItem=nullptr;
+        if (aSet.GetItemState(SDRATTR_CIRCENDANGLE,false,&pPoolItem)==SfxItemState::SET)
+        {
+            sal_Int32 nAngle = static_cast<const SdrAngleItem*>(pPoolItem)->GetValue();
+            aAny <<= nAngle;
+        }
+        break;
+    }
+
+    case SDRATTR_CIRCKIND:
+    {
+        if( GetSdrObject()->GetObjInventor() == SdrInventor::Default)
+        {
+            drawing::CircleKind eKind;
+            switch(GetSdrObject()->GetObjIdentifier())
+            {
+            case OBJ_CIRC:          // circle, ellipse
+                eKind = drawing::CircleKind_FULL;
+                break;
+            case OBJ_CCUT:          // segment of circle
+                eKind = drawing::CircleKind_CUT;
+                break;
+            case OBJ_CARC:          // arc of circle
+                eKind = drawing::CircleKind_ARC;
+                break;
+            case OBJ_SECT:          // sector
+                eKind = drawing::CircleKind_SECTION;
+                break;
+            }
+            aAny <<= eKind;
+        }
+        break;
+    }
+    default:
+    {
+        // get value from ItemSet
+        aAny = SvxItemPropertySet_getPropertyValue( pMap, aSet );
+
+        if( pMap->aType != aAny.getValueType() )
+        {
+            // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
+            if( ( pMap->aType == ::cppu::UnoType<sal_Int16>::get()) && aAny.getValueType() == ::cppu::UnoType<sal_Int32>::get() )
+            {
+                sal_Int32 nValue = 0;
+                aAny >>= nValue;
+                aAny <<= static_cast<sal_Int16>(nValue);
+            }
+            else
+            {
+                OSL_FAIL("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" );
+            }
+        }
+
+    }
+    }
+
+    return aAny;
+}
+
+
+// XPropertyState
+beans::PropertyState SAL_CALL SvxShape::getPropertyState( const OUString& PropertyName )
+{
+    if( mpImpl->mpMaster )
+    {
+        return mpImpl->mpMaster->getPropertyState( PropertyName );
+    }
+    else
+    {
+        return _getPropertyState( PropertyName );
+    }
+}
+
+beans::PropertyState SvxShape::_getPropertyState( const OUString& PropertyName )
+{
+    ::SolarMutexGuard aGuard;
+
+    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName);
+
+    if( !HasSdrObject() || pMap == nullptr )
+        throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
+
+    beans::PropertyState eState;
+    if( !getPropertyStateImpl( pMap, eState ) )
+    {
+        const SfxItemSet& rSet = GetSdrObject()->GetMergedItemSet();
+
+        switch( rSet.GetItemState( pMap->nWID, false ) )
+        {
+        case SfxItemState::READONLY:
+        case SfxItemState::SET:
+            eState = beans::PropertyState_DIRECT_VALUE;
+            break;
+        case SfxItemState::DEFAULT:
+            eState = beans::PropertyState_DEFAULT_VALUE;
+            break;
+        default:
+            eState = beans::PropertyState_AMBIGUOUS_VALUE;
+            break;
+        }
+
+        // if an item is set, this doesn't mean we want it :)
+        if( beans::PropertyState_DIRECT_VALUE == eState )
+        {
+            switch( pMap->nWID )
+            {
+            // the following items are disabled by changing the
+            // fill style or the line style. so there is no need
+            // to export items without names which should be empty
+            case XATTR_FILLBITMAP:
+            case XATTR_FILLGRADIENT:
+            case XATTR_FILLHATCH:
+            case XATTR_LINEDASH:
+                {
+                    const NameOrIndex* pItem = rSet.GetItem<NameOrIndex>(pMap->nWID);
+                    if( ( pItem == nullptr ) || pItem->GetName().isEmpty() )
+                        eState = beans::PropertyState_DEFAULT_VALUE;
+                }
+                break;
+
+            // #i36115#
+            // If e.g. the LineStart is on NONE and thus the string has length 0, it still
+            // may be a hard attribute covering the set LineStart of the parent (Style).
+            // #i37644#
+            // same is for fill float transparency
+            case XATTR_LINEEND:
+            case XATTR_LINESTART:
+            case XATTR_FILLFLOATTRANSPARENCE:
+                {
+                    const NameOrIndex* pItem = rSet.GetItem<NameOrIndex>(pMap->nWID);
+                    if ( pItem == nullptr )
+                        eState = beans::PropertyState_DEFAULT_VALUE;
+                }
+                break;
+            }
+        }
+    }
+    return eState;
+}
+
+bool SvxShape::setPropertyValueImpl( const OUString&, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_CAPTION_POINT:
+    {
+        awt::Point aPnt;
+        if( rValue >>= aPnt )
+        {
+            Point aVclPoint( aPnt.X, aPnt.Y );
+
+            // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+            // Need to adapt aVclPoint from 100thmm to app-specific
+            ForceMetricToItemPoolMetric(aVclPoint);
+
+            // #90763# position is relative to top left, make it absolute
+            basegfx::B2DPolyPolygon aNewPolyPolygon;
+            basegfx::B2DHomMatrix aNewHomogenMatrix;
+            GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+
+            aVclPoint.AdjustX(basegfx::fround(aNewHomogenMatrix.get(0, 2)) );
+            aVclPoint.AdjustY(basegfx::fround(aNewHomogenMatrix.get(1, 2)) );
+
+            // #88491# position relative to anchor
+            if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+            {
+                aVclPoint += GetSdrObject()->GetAnchorPos();
+            }
+
+            static_cast<SdrCaptionObj*>(GetSdrObject())->SetTailPos(aVclPoint);
+
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_TRANSFORMATION:
+    {
+        drawing::HomogenMatrix3 aMatrix;
+        if(rValue >>= aMatrix)
+        {
+            basegfx::B2DPolyPolygon aNewPolyPolygon;
+            basegfx::B2DHomMatrix aNewHomogenMatrix;
+
+            // tdf#117145 SdrModel data is app-specific
+            GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+
+            aNewHomogenMatrix.set(0, 0, aMatrix.Line1.Column1);
+            aNewHomogenMatrix.set(0, 1, aMatrix.Line1.Column2);
+            aNewHomogenMatrix.set(0, 2, aMatrix.Line1.Column3);
+            aNewHomogenMatrix.set(1, 0, aMatrix.Line2.Column1);
+            aNewHomogenMatrix.set(1, 1, aMatrix.Line2.Column2);
+            aNewHomogenMatrix.set(1, 2, aMatrix.Line2.Column3);
+            aNewHomogenMatrix.set(2, 0, aMatrix.Line3.Column1);
+            aNewHomogenMatrix.set(2, 1, aMatrix.Line3.Column2);
+            aNewHomogenMatrix.set(2, 2, aMatrix.Line3.Column3);
+
+            // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+            // Need to adapt aNewHomogenMatrix from 100thmm to app-specific
+            ForceMetricToItemPoolMetric(aNewHomogenMatrix);
+
+            GetSdrObject()->TRSetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+            return true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_ZORDER:
+    {
+        sal_Int32 nNewOrdNum = 0;
+        if(rValue >>= nNewOrdNum)
+        {
+            SdrObjList* pObjList = GetSdrObject()->getParentSdrObjListFromSdrObject();
+            if( pObjList )
+            {
+                SdrObject* pCheck =
+                            pObjList->SetObjectOrdNum( GetSdrObject()->GetOrdNum(), static_cast<size_t>(nNewOrdNum) );
+                DBG_ASSERT( pCheck == GetSdrObject(), "GetOrdNum() failed!" );
+            }
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_FRAMERECT:
+    {
+        awt::Rectangle aUnoRect;
+        if(rValue >>= aUnoRect)
+        {
+            Point aTopLeft( aUnoRect.X, aUnoRect.Y );
+            Size aObjSize( aUnoRect.Width, aUnoRect.Height );
+            ForceMetricToItemPoolMetric(aTopLeft);
+            ForceMetricToItemPoolMetric(aObjSize);
+            tools::Rectangle aRect;
+            aRect.SetPos(aTopLeft);
+            aRect.SetSize(aObjSize);
+            GetSdrObject()->SetSnapRect(aRect);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_MIRRORED:
+    {
+        bool bMirror;
+        if(rValue >>= bMirror )
+        {
+            SdrGrafObj* pObj = dynamic_cast< SdrGrafObj* >( GetSdrObject() );
+            if( pObj )
+                pObj->SetMirrored(bMirror);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_EDGE_START_OBJ:
+    case OWN_ATTR_EDGE_END_OBJ:
+    case OWN_ATTR_GLUEID_HEAD:
+    case OWN_ATTR_GLUEID_TAIL:
+    case OWN_ATTR_EDGE_START_POS:
+    case OWN_ATTR_EDGE_END_POS:
+    case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
+    {
+        SdrEdgeObj* pEdgeObj = dynamic_cast< SdrEdgeObj* >(GetSdrObject());
+        if(pEdgeObj)
+        {
+            switch(pProperty->nWID)
+            {
+            case OWN_ATTR_EDGE_START_OBJ:
+            case OWN_ATTR_EDGE_END_OBJ:
+                {
+                    Reference< drawing::XShape > xShape;
+                    if( rValue >>= xShape )
+                    {
+                        SdrObject* pNode = GetSdrObjectFromXShape( xShape );
+                        if( pNode )
+                        {
+                            pEdgeObj->ConnectToNode( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ, pNode );
+                            pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_EDGE_START_OBJ );
+                            return true;
+                        }
+                    }
+                    break;
+                }
+
+            case OWN_ATTR_EDGE_START_POS:
+            case OWN_ATTR_EDGE_END_POS:
+                {
+                    awt::Point aUnoPoint;
+                    if( rValue >>= aUnoPoint )
+                    {
+                        Point aPoint( aUnoPoint.X, aUnoPoint.Y );
+
+                        // Reintroduction of fix for issue i59051 (#i108851#)
+                        // perform metric change before applying anchor position,
+                        // because the anchor position is in pool metric.
+                        ForceMetricToItemPoolMetric( aPoint );
+                        if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+                            aPoint += GetSdrObject()->GetAnchorPos();
+
+                        pEdgeObj->SetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS, aPoint );
+                        return true;
+                    }
+                    break;
+                }
+
+            case OWN_ATTR_GLUEID_HEAD:
+            case OWN_ATTR_GLUEID_TAIL:
+                {
+                    sal_Int32 nId = 0;
+                    if( rValue >>= nId )
+                    {
+                        pEdgeObj->setGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD, nId );
+                        return true;
+                    }
+                    break;
+                }
+            case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
+                {
+                    basegfx::B2DPolyPolygon aNewPolyPolygon;
+
+                    // #123616# be a little bit more flexible regarding the data type used
+                    if( auto s = o3tl::tryAccess<drawing::PointSequenceSequence>(rValue) )
+                    {
+                        // get polygpon data from PointSequenceSequence
+                        aNewPolyPolygon = basegfx::utils::UnoPointSequenceSequenceToB2DPolyPolygon(
+                            *s);
+                    }
+                    else if( auto cs = o3tl::tryAccess<drawing::PolyPolygonBezierCoords>(rValue) )
+                    {
+                        // get polygpon data from PolyPolygonBezierCoords
+                        aNewPolyPolygon = basegfx::utils::UnoPolyPolygonBezierCoordsToB2DPolyPolygon(
+                            *cs);
+                    }
+
+                    if(aNewPolyPolygon.count())
+                    {
+                        // Reintroduction of fix for issue i59051 (#i108851#)
+                        ForceMetricToItemPoolMetric( aNewPolyPolygon );
+                        if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+                        {
+                            Point aPoint( GetSdrObject()->GetAnchorPos() );
+                            aNewPolyPolygon.transform(basegfx::utils::createTranslateB2DHomMatrix(aPoint.X(), aPoint.Y()));
+                        }
+                        pEdgeObj->SetEdgeTrackPath( aNewPolyPolygon );
+                        return true;
+                    }
+                }
+            }
+        }
+        break;
+    }
+    case OWN_ATTR_MEASURE_START_POS:
+    case OWN_ATTR_MEASURE_END_POS:
+    {
+        SdrMeasureObj* pMeasureObj = dynamic_cast< SdrMeasureObj* >(GetSdrObject());
+        awt::Point aUnoPoint;
+        if(pMeasureObj && ( rValue >>= aUnoPoint ) )
+        {
+            Point aPoint( aUnoPoint.X, aUnoPoint.Y );
+
+            // Reintroduction of fix for issue #i59051# (#i108851#)
+            ForceMetricToItemPoolMetric( aPoint );
+            if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+                aPoint += GetSdrObject()->GetAnchorPos();
+
+            pMeasureObj->NbcSetPoint( aPoint, pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0 : 1 );
+            pMeasureObj->SetChanged();
+            pMeasureObj->BroadcastObjectChange();
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_FILLBMP_MODE:
+        {
+            drawing::BitmapMode eMode;
+            if(!(rValue >>= eMode) )
+            {
+                sal_Int32 nMode = 0;
+                if(!(rValue >>= nMode))
+                    break;
+
+                eMode = static_cast<drawing::BitmapMode>(nMode);
+            }
+            GetSdrObject()->SetMergedItem( XFillBmpStretchItem( eMode == drawing::BitmapMode_STRETCH ) );
+            GetSdrObject()->SetMergedItem( XFillBmpTileItem( eMode == drawing::BitmapMode_REPEAT ) );
+            return true;
+        }
+
+    case SDRATTR_LAYERID:
+    {
+        sal_Int16 nLayerId = sal_Int16();
+        if( rValue >>= nLayerId )
+        {
+            SdrLayer* pLayer = GetSdrObject()->getSdrModelFromSdrObject().GetLayerAdmin().GetLayerPerID(SdrLayerID(nLayerId));
+            if( pLayer )
+            {
+                GetSdrObject()->SetLayer(SdrLayerID(nLayerId));
+                return true;
+            }
+        }
+        break;
+    }
+
+    case SDRATTR_LAYERNAME:
+    {
+        OUString aLayerName;
+        if( rValue >>= aLayerName )
+        {
+            const SdrLayer* pLayer = GetSdrObject()->getSdrModelFromSdrObject().GetLayerAdmin().GetLayer(aLayerName);
+            if( pLayer != nullptr )
+            {
+                GetSdrObject()->SetLayer( pLayer->GetID() );
+                return true;
+            }
+        }
+        break;
+    }
+    case SDRATTR_ROTATEANGLE:
+    {
+        sal_Int32 nAngle = 0;
+        if( rValue >>= nAngle )
+        {
+            Point aRef1(GetSdrObject()->GetSnapRect().Center());
+            nAngle -= GetSdrObject()->GetRotateAngle();
+            if (nAngle!=0)
+            {
+                double nSin = sin(nAngle * F_PI18000);
+                double nCos = cos(nAngle * F_PI18000);
+                GetSdrObject()->Rotate(aRef1,nAngle,nSin,nCos);
+            }
+            return true;
+        }
+
+        break;
+    }
+
+    case SDRATTR_SHEARANGLE:
+    {
+        sal_Int32 nShear = 0;
+        if( rValue >>= nShear )
+        {
+            nShear -= GetSdrObject()->GetShearAngle();
+            if(nShear != 0 )
+            {
+                Point aRef1(GetSdrObject()->GetSnapRect().Center());
+                double nTan = tan(nShear * F_PI18000);
+                GetSdrObject()->Shear(aRef1,nShear,nTan,false);
+                return true;
+            }
+        }
+
+        break;
+    }
+
+    case OWN_ATTR_INTEROPGRABBAG:
+    {
+        GetSdrObject()->SetGrabBagItem(rValue);
+        return true;
+    }
+
+    case SDRATTR_OBJMOVEPROTECT:
+    {
+        bool bMoveProtect;
+        if( rValue >>= bMoveProtect )
+        {
+            GetSdrObject()->SetMoveProtect(bMoveProtect);
+            return true;
+        }
+        break;
+    }
+    case SDRATTR_OBJECTNAME:
+    {
+        OUString aName;
+        if( rValue >>= aName )
+        {
+            GetSdrObject()->SetName( aName );
+            return true;
+        }
+        break;
+    }
+
+    case OWN_ATTR_TEXTFITTOSIZESCALE:
+    {
+        sal_Int16 nMaxScale = 0;
+        if (rValue >>= nMaxScale)
+        {
+            SdrTextFitToSizeTypeItem aItem(GetSdrObject()->GetMergedItem(SDRATTR_TEXT_FITTOSIZE));
+            aItem.SetMaxScale(nMaxScale);
+            GetSdrObject()->SetMergedItem(aItem);
+            return true;
+        }
+        break;
+    }
+
+    // #i68101#
+    case OWN_ATTR_MISC_OBJ_TITLE:
+    {
+        OUString aTitle;
+        if( rValue >>= aTitle )
+        {
+            GetSdrObject()->SetTitle( aTitle );
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_MISC_OBJ_DESCRIPTION:
+    {
+        OUString aDescription;
+        if( rValue >>= aDescription )
+        {
+            GetSdrObject()->SetDescription( aDescription );
+            return true;
+        }
+        break;
+    }
+
+    case SDRATTR_OBJPRINTABLE:
+    {
+        bool bPrintable;
+        if( rValue >>= bPrintable )
+        {
+            GetSdrObject()->SetPrintable(bPrintable);
+            return true;
+        }
+        break;
+    }
+    case SDRATTR_OBJVISIBLE:
+    {
+        bool bVisible;
+        if( rValue >>= bVisible )
+        {
+            GetSdrObject()->SetVisible(bVisible);
+            return true;
+        }
+        break;
+    }
+    case SDRATTR_OBJSIZEPROTECT:
+    {
+        bool bResizeProtect;
+        if( rValue >>= bResizeProtect )
+        {
+            GetSdrObject()->SetResizeProtect(bResizeProtect);
+            return true;
+        }
+        break;
+    }
+    case OWN_ATTR_PAGE_NUMBER:
+    {
+        sal_Int32 nPageNum = 0;
+        if( (rValue >>= nPageNum) && ( nPageNum >= 0 ) && ( nPageNum <= 0xffff ) )
+        {
+            SdrPageObj* pPageObj = dynamic_cast< SdrPageObj* >(GetSdrObject());
+            if( pPageObj )
+            {
+                SdrModel& rModel(pPageObj->getSdrModelFromSdrObject());
+                SdrPage* pNewPage = nullptr;
+                const sal_uInt16 nDestinationPageNum(static_cast<sal_uInt16>((nPageNum << 1) - 1));
+
+                if(nDestinationPageNum < rModel.GetPageCount())
+                {
+                    pNewPage = rModel.GetPage(nDestinationPageNum);
+                }
+
+                pPageObj->SetReferencedPage(pNewPage);
+            }
+
+            return true;
+        }
+        break;
+    }
+    case XATTR_FILLBITMAP:
+    case XATTR_FILLGRADIENT:
+    case XATTR_FILLHATCH:
+    case XATTR_FILLFLOATTRANSPARENCE:
+    case XATTR_LINEEND:
+    case XATTR_LINESTART:
+    case XATTR_LINEDASH:
+    {
+        if( pProperty->nMemberId == MID_NAME )
+        {
+            OUString aApiName;
+            if( rValue >>= aApiName )
+            {
+                if( SetFillAttribute( pProperty->nWID, aApiName ) )
+                    return true;
+            }
+            break;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    default:
+    {
+        return false;
+    }
+    }
+
+    OUString sExceptionMessage  ("IllegalArgumentException in SvxShape::setPropertyValueImpl."
+                                " Property Type: " + pProperty->aType.getTypeName() + " Property nWID: " + OUString::number(pProperty->nWID)
+                                + " Value Type: " + (rValue.hasValue() ? rValue.getValueTypeName() : "void (no value)"));
+
+    throw lang::IllegalArgumentException(sExceptionMessage, nullptr, 1);
+}
+
+
+bool SvxShape::getPropertyValueImpl( const OUString&, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    switch( pProperty->nWID )
+    {
+    case OWN_ATTR_CAPTION_POINT:
+    {
+        Point aVclPoint = static_cast<SdrCaptionObj*>(GetSdrObject())->GetTailPos();
+
+        // #88491# make pos relative to anchor
+        if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+        {
+            aVclPoint -= GetSdrObject()->GetAnchorPos();
+        }
+
+        // #90763# pos is absolute, make it relative to top left
+        basegfx::B2DPolyPolygon aNewPolyPolygon;
+        basegfx::B2DHomMatrix aNewHomogenMatrix;
+        GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+
+        aVclPoint.AdjustX( -(basegfx::fround(aNewHomogenMatrix.get(0, 2))) );
+        aVclPoint.AdjustY( -(basegfx::fround(aNewHomogenMatrix.get(1, 2))) );
+
+        // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+        // Need to adapt aVclPoint from app-specific to 100thmm
+        ForceMetricTo100th_mm(aVclPoint);
+
+        awt::Point aPnt( aVclPoint.X(), aVclPoint.Y() );
+        rValue <<= aPnt;
+        break;
+    }
+
+    case OWN_ATTR_TRANSFORMATION:
+    {
+        basegfx::B2DPolyPolygon aNewPolyPolygon;
+        basegfx::B2DHomMatrix aNewHomogenMatrix;
+        GetSdrObject()->TRGetBaseGeometry(aNewHomogenMatrix, aNewPolyPolygon);
+        drawing::HomogenMatrix3 aMatrix;
+
+        // tdf#117145 metric of SdrModel is app-specific, metric of UNO API is 100thmm
+        // Need to adapt aNewHomogenMatrix from app-specific to 100thmm
+        ForceMetricTo100th_mm(aNewHomogenMatrix);
+
+        aMatrix.Line1.Column1 = aNewHomogenMatrix.get(0, 0);
+        aMatrix.Line1.Column2 = aNewHomogenMatrix.get(0, 1);
+        aMatrix.Line1.Column3 = aNewHomogenMatrix.get(0, 2);
+        aMatrix.Line2.Column1 = aNewHomogenMatrix.get(1, 0);
+        aMatrix.Line2.Column2 = aNewHomogenMatrix.get(1, 1);
+        aMatrix.Line2.Column3 = aNewHomogenMatrix.get(1, 2);
+        aMatrix.Line3.Column1 = aNewHomogenMatrix.get(2, 0);
+        aMatrix.Line3.Column2 = aNewHomogenMatrix.get(2, 1);
+        aMatrix.Line3.Column3 = aNewHomogenMatrix.get(2, 2);
+
+        rValue <<= aMatrix;
+
+        break;
+    }
+
+    case OWN_ATTR_ZORDER:
+    {
+        rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetOrdNum());
+        break;
+    }
+
+    case OWN_ATTR_BITMAP:
+    {
+        rValue = GetBitmap();
+        if(!rValue.hasValue())
+            throw uno::RuntimeException();
+
+        break;
+    }
+
+    case OWN_ATTR_ISFONTWORK:
+    {
+        rValue <<= dynamic_cast<const SdrTextObj*>(GetSdrObject()) != nullptr && static_cast<SdrTextObj*>(GetSdrObject())->IsFontwork();
+        break;
+    }
+
+    case OWN_ATTR_FRAMERECT:
+    {
+        tools::Rectangle aRect( GetSdrObject()->GetSnapRect() );
+        Point aTopLeft( aRect.TopLeft() );
+        Size aObjSize( aRect.GetWidth(), aRect.GetHeight() );
+        ForceMetricTo100th_mm(aTopLeft);
+        ForceMetricTo100th_mm(aObjSize);
+        css::awt::Rectangle aUnoRect(
+            aTopLeft.X(), aTopLeft.Y(),
+            aObjSize.getWidth(), aObjSize.getHeight() );
+        rValue <<= aUnoRect;
+        break;
+    }
+
+    case OWN_ATTR_BOUNDRECT:
+    {
+        tools::Rectangle aRect( GetSdrObject()->GetCurrentBoundRect() );
+        Point aTopLeft( aRect.TopLeft() );
+        Size aObjSize( aRect.GetWidth(), aRect.GetHeight() );
+        ForceMetricTo100th_mm(aTopLeft);
+        ForceMetricTo100th_mm(aObjSize);
+        css::awt::Rectangle aUnoRect(
+            aTopLeft.X(), aTopLeft.Y(),
+            aObjSize.getWidth(), aObjSize.getHeight() );
+        rValue <<= aUnoRect;
+        break;
+    }
+
+    case OWN_ATTR_LDNAME:
+    {
+        OUString aName( GetSdrObject()->GetName() );
+        rValue <<= aName;
+        break;
+    }
+
+    case OWN_ATTR_LDBITMAP:
+    {
+        OUString sId;
+        if( GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == OBJ_OLE2 )
+        {
+            sId = RID_UNODRAW_OLE2;
+        }
+        else if( GetSdrObject()->GetObjInventor() == SdrInventor::Default && GetSdrObject()->GetObjIdentifier() == OBJ_GRAF )
+        {
+            sId = RID_UNODRAW_GRAPHICS;
+        }
+        else
+        {
+            sId = RID_UNODRAW_OBJECTS;
+        }
+
+        BitmapEx aBmp(sId);
+        Reference<awt::XBitmap> xBmp(VCLUnoHelper::CreateBitmap(aBmp));
+
+        rValue <<= xBmp;
+        break;
+    }
+
+    case OWN_ATTR_MIRRORED:
+    {
+        bool bMirror = false;
+        if( HasSdrObject() && dynamic_cast<const SdrGrafObj*>(GetSdrObject()) != nullptr )
+            bMirror = static_cast<SdrGrafObj*>(GetSdrObject())->IsMirrored();
+
+        rValue <<= bMirror;
+        break;
+    }
+
+    case OWN_ATTR_EDGE_START_OBJ:
+    case OWN_ATTR_EDGE_START_POS:
+    case OWN_ATTR_EDGE_END_POS:
+    case OWN_ATTR_EDGE_END_OBJ:
+    case OWN_ATTR_GLUEID_HEAD:
+    case OWN_ATTR_GLUEID_TAIL:
+    case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
+    {
+        SdrEdgeObj* pEdgeObj = dynamic_cast<SdrEdgeObj*>(GetSdrObject());
+        if(pEdgeObj)
+        {
+            switch(pProperty->nWID)
+            {
+            case OWN_ATTR_EDGE_START_OBJ:
+            case OWN_ATTR_EDGE_END_OBJ:
+                {
+                    SdrObject* pNode = pEdgeObj->GetConnectedNode(pProperty->nWID == OWN_ATTR_EDGE_START_OBJ);
+                    if(pNode)
+                    {
+                        Reference< drawing::XShape > xShape( GetXShapeForSdrObject( pNode ) );
+                        if(xShape.is())
+                            rValue <<= xShape;
+
+                    }
+                    break;
+                }
+
+            case OWN_ATTR_EDGE_START_POS:
+            case OWN_ATTR_EDGE_END_POS:
+                {
+                    Point aPoint( pEdgeObj->GetTailPoint( pProperty->nWID == OWN_ATTR_EDGE_START_POS ) );
+                    if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+                        aPoint -= GetSdrObject()->GetAnchorPos();
+
+                    ForceMetricTo100th_mm( aPoint );
+                    awt::Point aUnoPoint( aPoint.X(), aPoint.Y() );
+
+                    rValue <<= aUnoPoint;
+                    break;
+                }
+            case OWN_ATTR_GLUEID_HEAD:
+            case OWN_ATTR_GLUEID_TAIL:
+                {
+                    rValue <<= pEdgeObj->getGluePointIndex( pProperty->nWID == OWN_ATTR_GLUEID_HEAD );
+                    break;
+                }
+            case OWN_ATTR_EDGE_POLYPOLYGONBEZIER:
+                {
+                    basegfx::B2DPolyPolygon aPolyPoly( pEdgeObj->GetEdgeTrackPath() );
+                    if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+                    {
+                        Point aPoint( GetSdrObject()->GetAnchorPos() );
+                        aPolyPoly.transform(basegfx::utils::createTranslateB2DHomMatrix(-aPoint.X(), -aPoint.Y()));
+                    }
+                    // Reintroduction of fix for issue #i59051# (#i108851#)
+                    ForceMetricTo100th_mm( aPolyPoly );
+                    drawing::PolyPolygonBezierCoords aRetval;
+                    basegfx::utils::B2DPolyPolygonToUnoPolyPolygonBezierCoords( aPolyPoly, aRetval);
+                    rValue <<= aRetval;
+                    break;
+                }
+            }
+        }
+        break;
+    }
+
+    case OWN_ATTR_MEASURE_START_POS:
+    case OWN_ATTR_MEASURE_END_POS:
+    {
+        SdrMeasureObj* pMeasureObj = dynamic_cast<SdrMeasureObj*>(GetSdrObject());
+        if(pMeasureObj)
+        {
+            Point aPoint( pMeasureObj->GetPoint( pProperty->nWID == OWN_ATTR_MEASURE_START_POS ? 0 : 1 ) );
+            if( GetSdrObject()->getSdrModelFromSdrObject().IsWriter() )
+                aPoint -= GetSdrObject()->GetAnchorPos();
+
+            // Reintroduction of fix for issue #i59051# (#i108851#)
+            ForceMetricTo100th_mm( aPoint );
+            awt::Point aUnoPoint( aPoint.X(), aPoint.Y() );
+
+            rValue <<= aUnoPoint;
+            break;
+        }
+        break;
+    }
+
+    case OWN_ATTR_FILLBMP_MODE:
+    {
+        const SfxItemSet& rObjItemSet = GetSdrObject()->GetMergedItemSet();
+
+        if (rObjItemSet.Get(XATTR_FILLBMP_TILE).GetValue())
+        {
+            rValue <<= drawing::BitmapMode_REPEAT;
+        }
+        else if (rObjItemSet.Get(XATTR_FILLBMP_STRETCH).GetValue())
+        {
+            rValue <<= drawing::BitmapMode_STRETCH;
+        }
+        else
+        {
+            rValue <<= drawing::BitmapMode_NO_REPEAT;
+        }
+        break;
+    }
+    case SDRATTR_LAYERID:
+        rValue <<= sal_uInt16(sal_uInt8(GetSdrObject()->GetLayer()));
+        break;
+
+    case SDRATTR_LAYERNAME:
+    {
+        SdrLayer* pLayer = GetSdrObject()->getSdrModelFromSdrObject().GetLayerAdmin().GetLayerPerID(GetSdrObject()->GetLayer());
+        if( pLayer )
+        {
+            rValue <<= pLayer->GetName();
+        }
+        break;
+    }
+
+    case SDRATTR_ROTATEANGLE:
+        rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetRotateAngle());
+        break;
+
+    case SDRATTR_SHEARANGLE:
+        rValue <<= static_cast<sal_Int32>(GetSdrObject()->GetShearAngle());
+        break;
+
+    case OWN_ATTR_INTEROPGRABBAG:
+    {
+        GetSdrObject()->GetGrabBagItem(rValue);
+        break;
+    }
+
+    case SDRATTR_OBJMOVEPROTECT:
+        rValue <<= GetSdrObject()->IsMoveProtect();
+        break;
+
+    case SDRATTR_OBJECTNAME:
+    {
+        OUString aName( GetSdrObject()->GetName() );
+        rValue <<= aName;
+        break;
+    }
+
+    // #i68101#
+    case OWN_ATTR_MISC_OBJ_TITLE:
+    {
+        OUString aTitle( GetSdrObject()->GetTitle() );
+        rValue <<= aTitle;
+        break;
+    }
+
+    case OWN_ATTR_MISC_OBJ_DESCRIPTION:
+    {
+        OUString aDescription( GetSdrObject()->GetDescription() );
+        rValue <<= aDescription;
+        break;
+    }
+
+    case SDRATTR_OBJPRINTABLE:
+        rValue <<= GetSdrObject()->IsPrintable();
+        break;
+
+    case SDRATTR_OBJVISIBLE:
+        rValue <<= GetSdrObject()->IsVisible();
+        break;
+
+    case SDRATTR_OBJSIZEPROTECT:
+        rValue <<= GetSdrObject()->IsResizeProtect();
+        break;
+
+    case OWN_ATTR_PAGE_NUMBER:
+    {
+        SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(GetSdrObject());
+        if(pPageObj)
+        {
+            SdrPage* pPage = pPageObj->GetReferencedPage();
+            sal_Int32 nPageNumber = pPage ? pPage->GetPageNum() : 0;
+            nPageNumber++;
+            nPageNumber >>= 1;
+            rValue <<= nPageNumber;
+        }
+        break;
+    }
+
+    case OWN_ATTR_UINAME_SINGULAR:
+    {
+        rValue <<= GetSdrObject()->TakeObjNameSingul();
+        break;
+    }
+
+    case OWN_ATTR_TEXTFITTOSIZESCALE:
+    {
+        rValue <<= GetTextFitToSizeScale(GetSdrObject());
+        break;
+    }
+
+    case OWN_ATTR_UINAME_PLURAL:
+    {
+        rValue <<= GetSdrObject()->TakeObjNamePlural();
+        break;
+    }
+    case OWN_ATTR_METAFILE:
+    {
+        SdrOle2Obj* pObj = dynamic_cast<SdrOle2Obj*>(GetSdrObject());
+        if( pObj )
+        {
+            const Graphic* pGraphic = pObj->GetGraphic();
+            if( pGraphic )
+            {
+                bool bIsWMF = false;
+                if ( pGraphic->IsGfxLink() )
+                {
+                    GfxLink aLnk = pGraphic->GetGfxLink();
+                    if ( aLnk.GetType() == GfxLinkType::NativeWmf )
+                    {
+                        bIsWMF = true;
+                        uno::Sequence<sal_Int8> aSeq(reinterpret_cast<sal_Int8 const *>(aLnk.GetData()), static_cast<sal_Int32>(aLnk.GetDataSize()));
+                        rValue <<= aSeq;
+                    }
+                }
+                if ( !bIsWMF )
+                {
+                    // #119735# just use GetGDIMetaFile, it will create a buffered version of contained bitmap now automatically
+                    GDIMetaFile aMtf(pObj->GetGraphic()->GetGDIMetaFile());
+                    SvMemoryStream aDestStrm( 65535, 65535 );
+                    ConvertGDIMetaFileToWMF( aMtf, aDestStrm, nullptr, false );
+                    const uno::Sequence<sal_Int8> aSeq(
+                        static_cast< const sal_Int8* >(aDestStrm.GetData()),
+                        aDestStrm.GetEndOfData());
+                    rValue <<= aSeq;
+                }
+            }
+        }
+        else
+        {
+            rValue = GetBitmap( true );
+        }
+        break;
+    }
+
+
+    default:
+        return false;
+    }
+    return true;
+}
+
+
+bool SvxShape::getPropertyStateImpl( const SfxItemPropertySimpleEntry* pProperty, css::beans::PropertyState& rState )
+{
+    if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE )
+    {
+        const SfxItemSet& rSet = GetSdrObject()->GetMergedItemSet();
+
+        if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SfxItemState::SET ||
+            rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SfxItemState::SET )
+        {
+            rState = beans::PropertyState_DIRECT_VALUE;
+        }
+        else
+        {
+            rState = beans::PropertyState_AMBIGUOUS_VALUE;
+        }
+    }
+    else if((( pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) ||
+       ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST )) && ( pProperty->nWID != SDRATTR_TEXTDIRECTION ) )
+    {
+        rState = beans::PropertyState_DIRECT_VALUE;
+    }
+    else
+    {
+        return false;
+    }
+
+    return true;
+}
+
+
+bool SvxShape::setPropertyToDefaultImpl( const SfxItemPropertySimpleEntry* pProperty )
+{
+    if( pProperty->nWID == OWN_ATTR_FILLBMP_MODE )
+    {
+        GetSdrObject()->ClearMergedItem( XATTR_FILLBMP_STRETCH );
+        GetSdrObject()->ClearMergedItem( XATTR_FILLBMP_TILE );
+        return true;
+    }
+    else if((pProperty->nWID >= OWN_ATTR_VALUE_START && pProperty->nWID <= OWN_ATTR_VALUE_END ) ||
+       ( pProperty->nWID >= SDRATTR_NOTPERSIST_FIRST && pProperty->nWID <= SDRATTR_NOTPERSIST_LAST ))
+    {
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+uno::Sequence< beans::PropertyState > SAL_CALL SvxShape::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
+{
+    const sal_Int32 nCount = aPropertyName.getLength();
+    uno::Sequence< beans::PropertyState > aRet( nCount );
+
+    std::transform(aPropertyName.begin(), aPropertyName.end(), aRet.begin(),
+        [this](const OUString& rName) -> beans::PropertyState { return getPropertyState(rName); });
+
+    return aRet;
+}
+
+
+void SAL_CALL SvxShape::setPropertyToDefault( const OUString& PropertyName )
+{
+    if( mpImpl->mpMaster )
+    {
+        mpImpl->mpMaster->setPropertyToDefault( PropertyName );
+    }
+    else
+    {
+        _setPropertyToDefault( PropertyName );
+    }
+}
+
+void SvxShape::_setPropertyToDefault( const OUString& PropertyName )
+{
+    ::SolarMutexGuard aGuard;
+
+    const SfxItemPropertySimpleEntry* pProperty = mpPropSet->getPropertyMapEntry(PropertyName);
+
+    if( !HasSdrObject() || pProperty == nullptr )
+        throw beans::UnknownPropertyException( PropertyName, static_cast<cppu::OWeakObject*>(this));
+
+    if( !setPropertyToDefaultImpl( pProperty ) )
+    {
+        GetSdrObject()->ClearMergedItem( pProperty->nWID );
+    }
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+
+uno::Any SAL_CALL SvxShape::getPropertyDefault( const OUString& aPropertyName )
+{
+    if( mpImpl->mpMaster )
+    {
+        return mpImpl->mpMaster->getPropertyDefault( aPropertyName );
+    }
+    else
+    {
+        return _getPropertyDefault( aPropertyName );
+    }
+}
+
+uno::Any SvxShape::_getPropertyDefault( const OUString& aPropertyName )
+{
+    ::SolarMutexGuard aGuard;
+
+    const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(aPropertyName);
+
+    if( !HasSdrObject() || pMap == nullptr )
+        throw beans::UnknownPropertyException( aPropertyName, static_cast<cppu::OWeakObject*>(this));
+
+    if(( pMap->nWID >= OWN_ATTR_VALUE_START && pMap->nWID <= OWN_ATTR_VALUE_END ) ||
+       ( pMap->nWID >= SDRATTR_NOTPERSIST_FIRST && pMap->nWID <= SDRATTR_NOTPERSIST_LAST ))
+    {
+        return getPropertyValue( aPropertyName );
+    }
+
+    // get default from ItemPool
+    if(!SfxItemPool::IsWhich(pMap->nWID))
+        throw beans::UnknownPropertyException( "No WhichID " + OUString::number(pMap->nWID) + " for " + aPropertyName, static_cast<cppu::OWeakObject*>(this));
+
+    SfxItemSet aSet( GetSdrObject()->getSdrModelFromSdrObject().GetItemPool(),    {{pMap->nWID, pMap->nWID}});
+    aSet.Put(GetSdrObject()->getSdrModelFromSdrObject().GetItemPool().GetDefaultItem(pMap->nWID));
+
+    return GetAnyForItem( aSet, pMap );
+}
+
+// XMultiPropertyStates
+void SvxShape::setAllPropertiesToDefault()
+{
+    ::SolarMutexGuard aGuard;
+
+    if( !HasSdrObject() )
+        throw lang::DisposedException();
+    GetSdrObject()->ClearMergedItem(); // nWhich == 0 => all
+
+    if(dynamic_cast<const SdrGrafObj*>(GetSdrObject()) != nullptr)
+    {
+        // defaults for graphic objects have changed:
+        GetSdrObject()->SetMergedItem( XFillStyleItem( drawing::FillStyle_NONE ) );
+        GetSdrObject()->SetMergedItem( XLineStyleItem( drawing::LineStyle_NONE ) );
+    }
+
+    // #i68523# special handling for Svx3DCharacterModeItem, this is not saved
+    // but needs to be sal_True in svx, pool default (false) in sch. Since sch
+    // does not load lathe or extrude objects, it is possible to set the items
+    // here.
+    // For other solution possibilities, see task description.
+    if( dynamic_cast<const E3dLatheObj* >(GetSdrObject())  != nullptr|| dynamic_cast<const E3dExtrudeObj* >(GetSdrObject()) != nullptr)
+    {
+        GetSdrObject()->SetMergedItem(Svx3DCharacterModeItem(true));
+    }
+
+    GetSdrObject()->getSdrModelFromSdrObject().SetChanged();
+}
+
+void SvxShape::setPropertiesToDefault(
+    const uno::Sequence<OUString>& aPropertyNames )
+{
+    for ( const auto& rPropertyName : aPropertyNames )
+        setPropertyToDefault( rPropertyName );
+}
+
+uno::Sequence<uno::Any> SvxShape::getPropertyDefaults(
+    const uno::Sequence<OUString>& aPropertyNames )
+{
+    ::std::vector<uno::Any> ret;
+    ret.reserve(aPropertyNames.getLength());
+    std::transform(aPropertyNames.begin(), aPropertyNames.end(), std::back_inserter(ret),
+        [this](const OUString& rName) -> uno::Any { return getPropertyDefault(rName); });
+    return uno::Sequence<uno::Any>( ret.data(), ret.size() );
+}
+
+
+// XServiceInfo
+
+OUString SAL_CALL SvxShape::getImplementationName()
+{
+    return "SvxShape";
+}
+
+const char sUNO_service_style_ParagraphProperties[]          = "com.sun.star.style.ParagraphProperties";
+const char sUNO_service_style_ParagraphPropertiesComplex[]   = "com.sun.star.style.ParagraphPropertiesComplex";
+const char sUNO_service_style_ParagraphPropertiesAsian[]     = "com.sun.star.style.ParagraphPropertiesAsian";
+const char sUNO_service_style_CharacterProperties[]          = "com.sun.star.style.CharacterProperties";
+const char sUNO_service_style_CharacterPropertiesComplex[]   = "com.sun.star.style.CharacterPropertiesComplex";
+const char sUNO_service_style_CharacterPropertiesAsian[]     = "com.sun.star.style.CharacterPropertiesAsian";
+
+const char sUNO_service_drawing_FillProperties[]             = "com.sun.star.drawing.FillProperties";
+const char sUNO_service_drawing_TextProperties[]             = "com.sun.star.drawing.TextProperties";
+const char sUNO_service_drawing_LineProperties[]             = "com.sun.star.drawing.LineProperties";
+const char sUNO_service_drawing_ConnectorProperties[]        = "com.sun.star.drawing.ConnectorProperties";
+const char sUNO_service_drawing_MeasureProperties[]          = "com.sun.star.drawing.MeasureProperties";
+const char sUNO_service_drawing_ShadowProperties[]           = "com.sun.star.drawing.ShadowProperties";
+
+const char sUNO_service_drawing_RotationDescriptor[]         = "com.sun.star.drawing.RotationDescriptor";
+
+const char sUNO_service_drawing_Text[]                       = "com.sun.star.drawing.Text";
+const char sUNO_service_drawing_GroupShape[]                 = "com.sun.star.drawing.GroupShape";
+
+const char sUNO_service_drawing_CustomShapeProperties[]      = "com.sun.star.drawing.CustomShapeProperties";
+const char sUNO_service_drawing_CustomShape[]                = "com.sun.star.drawing.CustomShape";
+
+const char sUNO_service_drawing_PolyPolygonDescriptor[]      = "com.sun.star.drawing.PolyPolygonDescriptor";
+const char sUNO_service_drawing_PolyPolygonBezierDescriptor[]= "com.sun.star.drawing.PolyPolygonBezierDescriptor";
+
+const char sUNO_service_drawing_LineShape[]                  = "com.sun.star.drawing.LineShape";
+const char sUNO_service_drawing_Shape[]                      = "com.sun.star.drawing.Shape";
+const char sUNO_service_drawing_RectangleShape[]             = "com.sun.star.drawing.RectangleShape";
+const char sUNO_service_drawing_EllipseShape[]               = "com.sun.star.drawing.EllipseShape";
+const char sUNO_service_drawing_PolyPolygonShape[]           = "com.sun.star.drawing.PolyPolygonShape";
+const char sUNO_service_drawing_PolyLineShape[]              = "com.sun.star.drawing.PolyLineShape";
+const char sUNO_service_drawing_OpenBezierShape[]            = "com.sun.star.drawing.OpenBezierShape";
+const char sUNO_service_drawing_ClosedBezierShape[]          = "com.sun.star.drawing.ClosedBezierShape";
+const char sUNO_service_drawing_TextShape[]                  = "com.sun.star.drawing.TextShape";
+const char sUNO_service_drawing_GraphicObjectShape[]         = "com.sun.star.drawing.GraphicObjectShape";
+const char sUNO_service_drawing_OLE2Shape[]                  = "com.sun.star.drawing.OLE2Shape";
+const char sUNO_service_drawing_PageShape[]                  = "com.sun.star.drawing.PageShape";
+const char sUNO_service_drawing_CaptionShape[]               = "com.sun.star.drawing.CaptionShape";
+const char sUNO_service_drawing_MeasureShape[]               = "com.sun.star.drawing.MeasureShape";
+const char sUNO_service_drawing_FrameShape[]                 = "com.sun.star.drawing.FrameShape";
+const char sUNO_service_drawing_ControlShape[]               = "com.sun.star.drawing.ControlShape";
+const char sUNO_service_drawing_ConnectorShape[]             = "com.sun.star.drawing.ConnectorShape";
+const char sUNO_service_drawing_MediaShape[]                 = "com.sun.star.drawing.MediaShape";
+
+
+uno::Sequence< OUString > SAL_CALL SvxShape::getSupportedServiceNames()
+{
+    if( mpImpl->mpMaster )
+    {
+        return mpImpl->mpMaster->getSupportedServiceNames();
+    }
+    else
+    {
+        return _getSupportedServiceNames();
+    }
+}
+
+uno::Sequence< OUString > SvxShape::_getSupportedServiceNames()
+{
+    ::SolarMutexGuard aGuard;
+
+    if( HasSdrObject() && GetSdrObject()->GetObjInventor() == SdrInventor::Default)
+    {
+        const sal_uInt16 nIdent = GetSdrObject()->GetObjIdentifier();
+
+        switch(nIdent)
+        {
+        case OBJ_GRUP:
+            {
+                static const uno::Sequence<OUString> aSvxShape_GroupServices
+                        = { sUNO_service_drawing_GroupShape,
+                            sUNO_service_drawing_Shape };
+                return aSvxShape_GroupServices;
+            }
+        case OBJ_CUSTOMSHAPE:
+            {
+                static const uno::Sequence<OUString> aSvxShape_CustomShapeServices
+                        = { sUNO_service_drawing_CustomShape,
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_CustomShapeProperties,
+                            sUNO_service_drawing_FillProperties,
+                            sUNO_service_drawing_LineProperties,
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_CustomShapeServices;
+            }
+        case OBJ_LINE:
+            {
+                static const uno::Sequence<OUString> aSvxShape_LineServices
+                        = { sUNO_service_drawing_LineShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_LineProperties,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_PolyPolygonDescriptor,
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_LineServices;
+            }
+
+        case OBJ_RECT:
+            {
+                static const uno::Sequence<OUString> aSvxShape_RectServices
+                        = { sUNO_service_drawing_RectangleShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_FillProperties,
+                            sUNO_service_drawing_LineProperties,
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_RectServices;
+            }
+
+        case OBJ_CIRC:
+        case OBJ_SECT:
+        case OBJ_CARC:
+        case OBJ_CCUT:
+            {
+                static const uno::Sequence<OUString> aSvxShape_CircServices
+                        = { sUNO_service_drawing_EllipseShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_FillProperties,
+                            sUNO_service_drawing_LineProperties,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_CircServices;
+            }
+
+        case OBJ_PATHPLIN:
+        case OBJ_PLIN:
+            {
+                static const uno::Sequence<OUString> aSvxShape_PathServices
+                        = { sUNO_service_drawing_PolyLineShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_LineProperties,
+
+                            sUNO_service_drawing_PolyPolygonDescriptor,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_PathServices;
+            }
+
+        case OBJ_PATHPOLY:
+        case OBJ_POLY:
+            {
+                static const uno::Sequence<OUString> aSvxShape_PolyServices
+                        = { sUNO_service_drawing_PolyPolygonShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_LineProperties,
+                            sUNO_service_drawing_FillProperties,
+
+                            sUNO_service_drawing_PolyPolygonDescriptor,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_PolyServices;
+            }
+
+        case OBJ_FREELINE:
+        case OBJ_PATHLINE:
+            {
+                static const uno::Sequence<OUString> aSvxShape_FreeLineServices
+                        = { sUNO_service_drawing_OpenBezierShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_LineProperties,
+                            sUNO_service_drawing_FillProperties,
+
+                            sUNO_service_drawing_PolyPolygonBezierDescriptor,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_FreeLineServices;
+            }
+
+        case OBJ_FREEFILL:
+        case OBJ_PATHFILL:
+            {
+                static const uno::Sequence<OUString> aSvxShape_FreeFillServices
+                        = { sUNO_service_drawing_ClosedBezierShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_LineProperties,
+                            sUNO_service_drawing_FillProperties,
+
+                            sUNO_service_drawing_PolyPolygonBezierDescriptor,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_FreeFillServices;
+            }
+
+        case OBJ_OUTLINETEXT:
+        case OBJ_TITLETEXT:
+        case OBJ_TEXT:
+            {
+                static const uno::Sequence<OUString> aSvxShape_TextServices
+                        = { sUNO_service_drawing_TextShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_FillProperties,
+                            sUNO_service_drawing_LineProperties,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_TextServices;
+            }
+
+        case OBJ_GRAF:
+            {
+                static const uno::Sequence<OUString> aSvxShape_GrafServices
+                        = { sUNO_service_drawing_GraphicObjectShape,
+
+                            sUNO_service_drawing_Shape,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor};
+                return aSvxShape_GrafServices;
+            }
+
+        case OBJ_OLE2:
+            {
+                static const uno::Sequence<OUString> aSvxShape_Ole2Services
+                        = { sUNO_service_drawing_OLE2Shape,
+                            sUNO_service_drawing_Shape,
+
+                            // #i118485# Added Text, Shadow and Rotation
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_Ole2Services;
+            }
+
+        case OBJ_CAPTION:
+            {
+                static const uno::Sequence<OUString> aSvxShape_CaptionServices
+                        = { sUNO_service_drawing_CaptionShape,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_FillProperties,
+                            sUNO_service_drawing_LineProperties,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_CaptionServices;
+            }
+
+        case OBJ_PAGE:
+            {
+                static const uno::Sequence<OUString> aSvxShape_PageServices
+                        = { sUNO_service_drawing_PageShape,
+                            sUNO_service_drawing_Shape };
+                return aSvxShape_PageServices;
+            }
+
+        case OBJ_MEASURE:
+            {
+                static const uno::Sequence<OUString> aSvxShape_MeasureServices
+                        = { sUNO_service_drawing_MeasureShape,
+
+                            sUNO_service_drawing_MeasureProperties,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_LineProperties,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_PolyPolygonDescriptor,
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_MeasureServices;
+            }
+
+        case OBJ_FRAME:
+            {
+                static const uno::Sequence<OUString> aSvxShape_FrameServices
+                        = { sUNO_service_drawing_FrameShape,
+                            sUNO_service_drawing_Shape };
+                return aSvxShape_FrameServices;
+            }
+
+        case OBJ_UNO:
+            {
+                static const uno::Sequence<OUString> aSvxShape_UnoServices
+                        = { sUNO_service_drawing_ControlShape,
+                            sUNO_service_drawing_Shape };
+                return aSvxShape_UnoServices;
+            }
+
+        case OBJ_EDGE:
+            {
+                static const uno::Sequence<OUString> aSvxShape_EdgeServices
+                        = { sUNO_service_drawing_ConnectorShape,
+                            sUNO_service_drawing_ConnectorProperties,
+
+                            sUNO_service_drawing_Shape,
+                            sUNO_service_drawing_LineProperties,
+
+                            sUNO_service_drawing_Text,
+                            sUNO_service_drawing_TextProperties,
+                            sUNO_service_style_ParagraphProperties,
+                            sUNO_service_style_ParagraphPropertiesComplex,
+                            sUNO_service_style_ParagraphPropertiesAsian,
+                            sUNO_service_style_CharacterProperties,
+                            sUNO_service_style_CharacterPropertiesComplex,
+                            sUNO_service_style_CharacterPropertiesAsian,
+
+                            sUNO_service_drawing_PolyPolygonDescriptor,
+                            sUNO_service_drawing_ShadowProperties,
+                            sUNO_service_drawing_RotationDescriptor };
+                return aSvxShape_EdgeServices;
+            }
+        case OBJ_MEDIA:
+            {
+                static const uno::Sequence<OUString> aSvxShape_MediaServices
+                        = { sUNO_service_drawing_MediaShape,
+                            sUNO_service_drawing_Shape };
+                return aSvxShape_MediaServices;
+            }
+        }
+    }
+    else if( HasSdrObject() && GetSdrObject()->GetObjInventor() == SdrInventor::FmForm)
+    {
+#if OSL_DEBUG_LEVEL > 0
+        const sal_uInt16 nIdent = GetSdrObject()->GetObjIdentifier();
+        OSL_ENSURE( nIdent == OBJ_UNO, "SvxShape::_getSupportedServiceNames: SdrInventor::FmForm, but no UNO object?" );
+#endif
+        static const uno::Sequence<OUString> aSvxShape_UnoServices
+                = { sUNO_service_drawing_ControlShape,
+                    sUNO_service_drawing_Shape };
+        return aSvxShape_UnoServices;
+    }
+    OSL_FAIL( "SvxShape::_getSupportedServiceNames: could not determine object type!" );
+    uno::Sequence< OUString > aSeq;
+    return aSeq;
+}
+
+sal_Bool SAL_CALL SvxShape::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+// XGluePointsSupplier
+uno::Reference< container::XIndexContainer > SAL_CALL SvxShape::getGluePoints()
+{
+    ::SolarMutexGuard aGuard;
+    uno::Reference< container::XIndexContainer > xGluePoints( mxGluePoints );
+
+    if( HasSdrObject() && !xGluePoints.is() )
+    {
+        uno::Reference< container::XIndexContainer > xNew( SvxUnoGluePointAccess_createInstance( GetSdrObject() ), uno::UNO_QUERY );
+        mxGluePoints = xGluePoints = xNew;
+    }
+
+    return xGluePoints;
+}
+
+// XChild
+uno::Reference<uno::XInterface> SAL_CALL SvxShape::getParent()
+{
+    ::SolarMutexGuard aGuard;
+    const SdrObject* pSdrObject(GetSdrObject());
+
+    if(nullptr != pSdrObject)
+    {
+        const SdrObjList* pParentSdrObjList(GetSdrObject()->getParentSdrObjListFromSdrObject());
+
+        if(nullptr != pParentSdrObjList)
+        {
+            // SdrObject is member of a SdrObjList. That may be a SdrObject
+            // (SdrObjGroup or E3dScene) or a SdrPage.
+            // Check for SdrObject first - using getSdrPageFromSdrObjList
+            // *will* get the SdrPage even when the SdrObject is deep buried
+            // in a construct of SdrObjGroup.
+            // We want to ask for the direct parent here...
+            SdrObject* pParentSdrObject(pParentSdrObjList->getSdrObjectFromSdrObjList());
+
+            if(nullptr != pParentSdrObject)
+            {
+                // SdrObject is member of a SdrObject-based Group (SdrObjGroup or E3dScene).
+                return pParentSdrObject->getUnoShape();
+            }
+            else
+            {
+                SdrPage* pParentSdrPage(pParentSdrObjList->getSdrPageFromSdrObjList());
+
+                if(nullptr != pParentSdrPage)
+                {
+                    // SdrObject is inserted to a SdrPage. Since
+                    // we checked for getSdrObjectFromSdrObjList first,
+                    // we can even say that it is directly member of that
+                    // SdrPage.
+                    return pParentSdrPage->getUnoPage();
+                }
+            }
+
+            // not member of any SdrObjList, no parent
+            OSL_FAIL( "SvxShape::getParent(  ): unexpected Parent SdrObjList" );
+        }
+    }
+
+    // no SdrObject, no parent
+    return uno::Reference<uno::XInterface>();
+}
+
+void SAL_CALL SvxShape::setParent( const css::uno::Reference< css::uno::XInterface >& )
+{
+    throw lang::NoSupportException();
+}
+
+
+/** called from the XActionLockable interface methods on initial locking */
+void SvxShape::lock()
+{
+}
+
+
+/** called from the XActionLockable interface methods on final unlock */
+void SvxShape::unlock()
+{
+}
+
+
+// XActionLockable
+sal_Bool SAL_CALL SvxShape::isActionLocked(  )
+{
+    ::SolarMutexGuard aGuard;
+
+    return mnLockCount != 0;
+}
+
+
+void SAL_CALL SvxShape::addActionLock(  )
+{
+    ::SolarMutexGuard aGuard;
+
+    DBG_ASSERT( mnLockCount < 0xffff, "lock overflow in SvxShape!" );
+    mnLockCount++;
+
+    if( mnLockCount == 1 )
+        lock();
+}
+
+
+void SAL_CALL SvxShape::removeActionLock(  )
+{
+    ::SolarMutexGuard aGuard;
+
+    DBG_ASSERT( mnLockCount > 0, "lock underflow in SvxShape!" );
+    mnLockCount--;
+
+    if( mnLockCount == 0 )
+        unlock();
+}
+
+
+void SAL_CALL SvxShape::setActionLocks( sal_Int16 nLock )
+{
+    ::SolarMutexGuard aGuard;
+
+    if( (mnLockCount == 0) && (nLock != 0) )
+        unlock();
+
+    if( (mnLockCount != 0) && (nLock == 0) )
+        lock();
+
+    mnLockCount = static_cast<sal_uInt16>(nLock);
+}
+
+
+sal_Int16 SAL_CALL SvxShape::resetActionLocks(  )
+{
+    ::SolarMutexGuard aGuard;
+
+    if( mnLockCount != 0 )
+        unlock();
+
+    sal_Int16 nOldLocks = static_cast<sal_Int16>(mnLockCount);
+    mnLockCount = 0;
+
+    return nOldLocks;
+}
+
+
+/** since polygon shapes can change their kind during editing, we have
+    to recheck it here.
+    Circle shapes also change their kind, but they are all treated equal
+    so no update is necessary.
+*/
+void SvxShape::updateShapeKind()
+{
+    switch( mpImpl->mnObjId )
+    {
+        case OBJ_LINE:
+        case OBJ_POLY:
+        case OBJ_PLIN:
+        case OBJ_PATHLINE:
+        case OBJ_PATHFILL:
+        case OBJ_FREELINE:
+        case OBJ_FREEFILL:
+        case OBJ_PATHPOLY:
+        case OBJ_PATHPLIN:
+        {
+            const sal_uInt32 nId = GetSdrObject()->GetObjIdentifier();
+
+            if( nId != mpImpl->mnObjId )
+            {
+                mpImpl->mnObjId = nId;
+
+            }
+            break;
+        }
+    }
+}
+
+SvxShapeText::SvxShapeText(SdrObject* pObject)
+: SvxShape( pObject, getSvxMapProvider().GetMap(SVXMAP_TEXT), getSvxMapProvider().GetPropertySet(SVXMAP_TEXT, SdrObject::GetGlobalDrawObjectItemPool()) ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
+{
+    if( pObject )
+        SetEditSource( new SvxTextEditSource( pObject, nullptr ) );
+}
+
+
+SvxShapeText::SvxShapeText(SdrObject* pObject, const SfxItemPropertyMapEntry* pPropertyMap, const SvxItemPropertySet* pPropertySet)
+: SvxShape( pObject, pPropertyMap, pPropertySet ), SvxUnoTextBase( ImplGetSvxUnoOutlinerTextCursorSvxPropertySet() )
+{
+    if( pObject )
+        SetEditSource( new SvxTextEditSource( pObject, nullptr ) );
+}
+
+
+SvxShapeText::~SvxShapeText() throw ()
+{
+    // check if only this instance is registered at the ranges
+    DBG_ASSERT( (nullptr == GetEditSource()) || (GetEditSource()->getRanges().size()==1),
+        "svx::SvxShapeText::~SvxShapeText(), text shape with living text ranges destroyed!");
+}
+
+void SvxShapeText::Create( SdrObject* pNewObj, SvxDrawPage* pNewPage )
+{
+    if( pNewObj && (nullptr == GetEditSource()))
+        SetEditSource( new SvxTextEditSource( pNewObj, nullptr ) );
+    SvxShape::Create( pNewObj, pNewPage );
+}
+
+// XInterface
+
+uno::Any SAL_CALL SvxShapeText::queryInterface( const uno::Type & rType )
+{
+    return SvxShape::queryInterface( rType );
+}
+
+
+uno::Any SAL_CALL SvxShapeText::queryAggregation( const uno::Type & rType )
+{
+    uno::Any aAny( SvxShape::queryAggregation( rType ) );
+    if( aAny.hasValue() )
+        return aAny;
+
+    return SvxUnoTextBase::queryAggregation( rType );
+}
+
+
+// XServiceInfo
+
+OUString SAL_CALL SvxShapeText::getImplementationName()
+{
+    return "SvxShapeText";
+}
+
+
+uno::Sequence< OUString > SAL_CALL SvxShapeText::getSupportedServiceNames()
+{
+    return SvxShape::getSupportedServiceNames();
+}
+
+
+sal_Bool SAL_CALL SvxShapeText::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService(static_cast<SvxShape*>(this), ServiceName);
+}
+
+    // XTypeProvider
+
+uno::Sequence< uno::Type > SAL_CALL SvxShapeText::getTypes()
+{
+    return SvxShape::getTypes();
+}
+
+sal_Int64 SAL_CALL SvxShapeText::getSomething( const css::uno::Sequence< sal_Int8 >& rId )
+{
+    const sal_Int64 nReturn = SvxShape::getSomething( rId );
+    if( nReturn )
+        return nReturn;
+
+    return SvxUnoTextBase::getSomething( rId );
+}
+
+
+uno::Sequence< sal_Int8 > SAL_CALL SvxShapeText::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+
+/** called from the XActionLockable interface methods on initial locking */
+void SvxShapeText::lock()
+{
+    SvxTextEditSource* pEditSource = static_cast<SvxTextEditSource*>(GetEditSource());
+    if( pEditSource )
+        pEditSource->lock();
+}
+
+
+/** called from the XActionLockable interface methods on final unlock */
+void SvxShapeText::unlock()
+{
+    SvxTextEditSource* pEditSource = static_cast<SvxTextEditSource*>(GetEditSource());
+    if( pEditSource )
+        pEditSource->unlock();
+}
+
+// css::text::XTextRange
+uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getStart()
+{
+    ::SolarMutexGuard aGuard;
+    SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
+    if( pForwarder )
+        ::GetSelection( maSelection, pForwarder );
+    return SvxUnoTextBase::getStart();
+
+}
+
+uno::Reference< text::XTextRange > SAL_CALL SvxShapeText::getEnd()
+{
+    ::SolarMutexGuard aGuard;
+    SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
+    if( pForwarder )
+        ::GetSelection( maSelection, pForwarder );
+    return SvxUnoTextBase::getEnd();
+}
+
+OUString SAL_CALL SvxShapeText::getString()
+{
+    ::SolarMutexGuard aGuard;
+    SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
+    if( pForwarder )
+        ::GetSelection( maSelection, pForwarder );
+    return SvxUnoTextBase::getString();
+}
+
+
+void SAL_CALL SvxShapeText::setString( const OUString& aString )
+{
+    ::SolarMutexGuard aGuard;
+    SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : nullptr;
+    if( pForwarder )
+        ::GetSelection( maSelection, pForwarder );
+    SvxUnoTextBase::setString( aString );
+}
+
+// override these for special property handling in subcasses. Return true if property is handled
+bool SvxShapeText::setPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, const css::uno::Any& rValue )
+{
+    // HACK-fix #99090#
+    // since SdrTextObj::SetVerticalWriting exchanges
+    // SDRATTR_TEXT_AUTOGROWWIDTH and SDRATTR_TEXT_AUTOGROWHEIGHT,
+    // we have to set the textdirection here
+
+    if( pProperty->nWID == SDRATTR_TEXTDIRECTION )
+    {
+        SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetSdrObject() );
+        if( pTextObj )
+        {
+            css::text::WritingMode eMode;
+            if( rValue >>= eMode )
+            {
+                pTextObj->SetVerticalWriting( eMode == css::text::WritingMode_TB_RL );
+            }
+        }
+        return true;
+    }
+    return SvxShape::setPropertyValueImpl( rName, pProperty, rValue );
+}
+
+bool SvxShapeText::getPropertyValueImpl( const OUString& rName, const SfxItemPropertySimpleEntry* pProperty, css::uno::Any& rValue )
+{
+    if( pProperty->nWID == SDRATTR_TEXTDIRECTION )
+    {
+        SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetSdrObject() );
+        if( pTextObj && pTextObj->IsVerticalWriting() )
+            rValue <<= css::text::WritingMode_TB_RL;
+        else
+            rValue <<= css::text::WritingMode_LR_TB;
+        return true;
+    }
+
+    return SvxShape::getPropertyValueImpl( rName, pProperty, rValue );
+}
+
+bool SvxShapeText::getPropertyStateImpl( const SfxItemPropertySimpleEntry* pProperty, css::beans::PropertyState& rState )
+{
+    return SvxShape::getPropertyStateImpl( pProperty, rState );
+}
+
+bool SvxShapeText::setPropertyToDefaultImpl( const SfxItemPropertySimpleEntry* pProperty )
+{
+    return SvxShape::setPropertyToDefaultImpl( pProperty );
+}
+
+SvxShapeRect::SvxShapeRect(SdrObject* pObj)
+: SvxShapeText( pObj, getSvxMapProvider().GetMap(SVXMAP_SHAPE), getSvxMapProvider().GetPropertySet(SVXMAP_SHAPE, SdrObject::GetGlobalDrawObjectItemPool()))
+{
+}
+
+SvxShapeRect::~SvxShapeRect() throw()
+{
+}
+
+uno::Any SAL_CALL SvxShapeRect::queryInterface( const uno::Type & rType )
+{
+    return SvxShapeText::queryInterface( rType );
+}
+
+uno::Any SAL_CALL SvxShapeRect::queryAggregation( const uno::Type & rType )
+{
+    return SvxShapeText::queryAggregation( rType );
+}
+
+// XServiceInfo
+
+uno::Sequence< OUString > SvxShapeRect::getSupportedServiceNames()
+{
+    return SvxShape::getSupportedServiceNames();
+}
+
+/** returns a StarOffice API wrapper for the given SdrObject */
+uno::Reference< drawing::XShape > GetXShapeForSdrObject( SdrObject* pObj ) throw ()
+{
+    uno::Reference< drawing::XShape > xShape( pObj->getUnoShape(), uno::UNO_QUERY );
+    return xShape;
+}
+
+/** returns the SdrObject from the given StarOffice API wrapper */
+SdrObject* GetSdrObjectFromXShape( const uno::Reference< drawing::XShape >& xShape ) throw()
+{
+    SvxShape* pShape = comphelper::getUnoTunnelImplementation<SvxShape>( xShape );
+    return pShape ? pShape->GetSdrObject() : nullptr;
+}
+
+
+SdrObject* SdrObject::getSdrObjectFromXShape( const css::uno::Reference< css::uno::XInterface >& xInt )
+{
+    SvxShape* pSvxShape = comphelper::getUnoTunnelImplementation<SvxShape>( xInt );
+    return pSvxShape ? pSvxShape->GetSdrObject() : nullptr;
+}
+
+uno::Any SvxItemPropertySet_getPropertyValue( const SfxItemPropertySimpleEntry* pMap, const SfxItemSet& rSet )
+{
+    if(!pMap || !pMap->nWID)
+        return uno::Any();
+
+    // Check is for items that store either metric values if they are positive or percentage if they are negative.
+    bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY );
+    return SvxItemPropertySet::getPropertyValue( pMap, rSet, (pMap->nWID != SDRATTR_XMLATTRIBUTES), bDontConvertNegativeValues );
+}
+
+void SvxItemPropertySet_setPropertyValue( const SfxItemPropertySimpleEntry* pMap, const uno::Any& rVal, SfxItemSet& rSet )
+{
+    if(!pMap || !pMap->nWID)
+        return;
+
+    bool bDontConvertNegativeValues = ( pMap->nWID == XATTR_FILLBMP_SIZEX || pMap->nWID == XATTR_FILLBMP_SIZEY );
+    SvxItemPropertySet::setPropertyValue( pMap, rVal, rSet, bDontConvertNegativeValues );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoshcol.cxx b/svx/source/unodraw/unoshcol.cxx
new file mode 100644
index 000000000..b1f3a4f4a
--- /dev/null
+++ b/svx/source/unodraw/unoshcol.cxx
@@ -0,0 +1,259 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/document/EventObject.hpp>
+#include <com/sun/star/drawing/XShapes.hpp>
+#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+#include <cppuhelper/implbase3.hxx>
+#include <cppuhelper/interfacecontainer.hxx>
+#include <comphelper/interfacecontainer2.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <osl/mutex.hxx>
+#include <sal/log.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+namespace {
+
+class SvxShapeCollectionMutex
+{
+public:
+    ::osl::Mutex maMutex;
+};
+
+class SvxShapeCollection :
+    public cppu::WeakAggImplHelper3<drawing::XShapes, lang::XServiceInfo, lang::XComponent>,
+    public SvxShapeCollectionMutex
+{
+private:
+    comphelper::OInterfaceContainerHelper2 maShapeContainer;
+
+    cppu::OBroadcastHelper mrBHelper;
+
+public:
+    SvxShapeCollection() throw();
+
+    // XInterface
+    virtual void SAL_CALL release() throw() override;
+
+    // XComponent
+    virtual void SAL_CALL dispose() override;
+    virtual void SAL_CALL addEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener ) override;
+    virtual void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener ) override;
+
+    // XIndexAccess
+    virtual sal_Int32 SAL_CALL getCount() override ;
+    virtual css::uno::Any SAL_CALL getByIndex( sal_Int32 Index ) override;
+
+    // XElementAccess
+    virtual css::uno::Type SAL_CALL getElementType() override;
+    virtual sal_Bool SAL_CALL hasElements() override;
+
+    // XShapes
+    virtual void SAL_CALL add( const css::uno::Reference< css::drawing::XShape >& xShape ) override;
+    virtual void SAL_CALL remove( const css::uno::Reference< css::drawing::XShape >& xShape ) override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+SvxShapeCollection::SvxShapeCollection() throw()
+: maShapeContainer( maMutex ), mrBHelper( maMutex )
+{
+}
+
+// XInterface
+void SvxShapeCollection::release() throw()
+{
+    uno::Reference< uno::XInterface > x( xDelegator );
+    if (! x.is())
+    {
+        if (osl_atomic_decrement( &m_refCount ) == 0)
+        {
+            if (! mrBHelper.bDisposed)
+            {
+                uno::Reference< uno::XInterface > xHoldAlive( static_cast<uno::XWeak*>(this) );
+                // First dispose
+                try
+                {
+                    dispose();
+                }
+                catch(css::uno::Exception&)
+                {
+                    // release should not throw exceptions
+                }
+
+                // only the alive ref holds the object
+                OSL_ASSERT( m_refCount == 1 );
+                // destroy the object if xHoldAlive decrement the refcount to 0
+                return;
+            }
+        }
+        // restore the reference count
+        osl_atomic_increment( &m_refCount );
+    }
+    OWeakAggObject::release();
+}
+
+// XComponent
+void SvxShapeCollection::dispose()
+{
+    // An frequently programming error is to release the last
+    // reference to this object in the disposing message.
+    // Make it robust, hold a self Reference.
+    uno::Reference< lang::XComponent > xSelf( this );
+
+    // Guard dispose against multiple threading
+    // Remark: It is an error to call dispose more than once
+    bool bDoDispose = false;
+    {
+    osl::MutexGuard aGuard( mrBHelper.rMutex );
+    if( !mrBHelper.bDisposed && !mrBHelper.bInDispose )
+    {
+        // only one call go into this section
+        mrBHelper.bInDispose = true;
+        bDoDispose = true;
+    }
+    }
+
+    // Do not hold the mutex because we are broadcasting
+    if( bDoDispose )
+    {
+        // Create an event with this as sender
+        try
+        {
+            uno::Reference< uno::XInterface > xSource( uno::Reference< uno::XInterface >::query( static_cast<lang::XComponent *>(this) ) );
+            document::EventObject aEvt;
+            aEvt.Source = xSource;
+            // inform all listeners to release this object
+            // The listener container are automatically cleared
+            mrBHelper.aLC.disposeAndClear( aEvt );
+            maShapeContainer.clear();
+        }
+        catch(const css::uno::Exception&)
+        {
+            // catch exception and throw again but signal that
+            // the object was disposed. Dispose should be called
+            // only once.
+            mrBHelper.bDisposed = true;
+            mrBHelper.bInDispose = false;
+            throw;
+        }
+
+        // the values bDispose and bInDisposing must set in this order.
+        // No multithread call overcome the "!rBHelper.bDisposed && !rBHelper.bInDispose" guard.
+        mrBHelper.bDisposed = true;
+        mrBHelper.bInDispose = false;
+    }
+    else
+    {
+        // in a multithreaded environment, it can't be avoided, that dispose is called twice.
+        // However this condition is traced, because it MAY indicate an error.
+        SAL_INFO("svx", "dispose called twice" );
+    }
+}
+
+// XComponent
+void SAL_CALL SvxShapeCollection::addEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener )
+{
+    mrBHelper.addListener( cppu::UnoType<decltype(aListener)>::get() , aListener );
+}
+
+// XComponent
+void SAL_CALL SvxShapeCollection::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& aListener )
+{
+    mrBHelper.removeListener( cppu::UnoType<decltype(aListener)>::get() , aListener );
+}
+
+// XShapes
+
+void SAL_CALL SvxShapeCollection::add( const Reference< drawing::XShape >& xShape )
+{
+    maShapeContainer.addInterface( xShape );
+}
+
+
+void SAL_CALL SvxShapeCollection::remove( const uno::Reference< drawing::XShape >& xShape )
+{
+    maShapeContainer.removeInterface( xShape );
+}
+
+
+sal_Int32 SAL_CALL SvxShapeCollection::getCount()
+{
+    return maShapeContainer.getLength();
+}
+
+
+uno::Any SAL_CALL SvxShapeCollection::getByIndex( sal_Int32 Index )
+{
+    if( Index < 0 || Index >= getCount() )
+        throw lang::IndexOutOfBoundsException();
+
+    std::vector< Reference< uno::XInterface> > aElements( maShapeContainer.getElements() );
+
+
+    return uno::makeAny( Reference< drawing::XShape>(static_cast< drawing::XShape* >( aElements[Index].get())) );
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxShapeCollection::getElementType()
+{
+    return cppu::UnoType<drawing::XShape>::get();
+}
+
+sal_Bool SAL_CALL SvxShapeCollection::hasElements()
+{
+    return getCount() != 0;
+}
+
+// XServiceInfo
+OUString SAL_CALL SvxShapeCollection::getImplementationName()
+{
+    return "com.sun.star.drawing.SvxShapeCollection";
+}
+
+sal_Bool SAL_CALL SvxShapeCollection::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService( this, ServiceName);
+}
+
+uno::Sequence< OUString > SAL_CALL SvxShapeCollection::getSupportedServiceNames()
+{
+    return { "com.sun.star.drawing.Shapes", "com.sun.star.drawing.ShapeCollection" };
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_drawing_SvxShapeCollection_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new SvxShapeCollection);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unoshtxt.cxx b/svx/source/unodraw/unoshtxt.cxx
new file mode 100644
index 000000000..61fdc3636
--- /dev/null
+++ b/svx/source/unodraw/unoshtxt.cxx
@@ -0,0 +1,1017 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <memory>
+
+#include <vcl/svapp.hxx>
+
+#include <svx/unoshtxt.hxx>
+#include <editeng/unoedhlp.hxx>
+#include <svl/lstner.hxx>
+#include <rtl/ref.hxx>
+#include <tools/debug.hxx>
+#include <svl/hint.hxx>
+#include <svl/style.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svdoutl.hxx>
+#include <svx/svdobj.hxx>
+#include <svx/svdview.hxx>
+#include <editeng/outliner.hxx>
+#include <editeng/unoforou.hxx>
+#include <editeng/unoviwou.hxx>
+#include <editeng/outlobj.hxx>
+#include <svx/svdotext.hxx>
+#include <svx/svdpage.hxx>
+#include <editeng/editeng.hxx>
+
+#include <editeng/unotext.hxx>
+#include <com/sun/star/linguistic2/LinguServiceManager.hpp>
+#include <comphelper/processfactory.hxx>
+#include <svx/svdotable.hxx>
+#include <cell.hxx>
+#include <unotools/configmgr.hxx>
+
+
+// SvxTextEditSourceImpl
+
+
+/** @descr
+    <p>This class essentially provides the text and view forwarders. If
+    no SdrView is given, this class handles the UNO objects, which are
+    currently not concerned with view issues. In this case,
+    GetViewForwarder() always returns NULL and the underlying
+    EditEngine of the SvxTextForwarder is a background one (i.e. not
+    the official DrawOutliner, but one created exclusively for this
+    object, with no relation to a view).
+    </p>
+
+    <p>If a SdrView is given at construction time, the caller is
+    responsible for destroying this object when the view becomes
+    invalid (the views cannot notify). If GetViewForwarder(sal_True)
+    is called, the underlying shape is put into edit mode, the view
+    forwarder returned encapsulates the OutlinerView and the next call
+    to GetTextForwarder() yields a forwarder encapsulating the actual
+    DrawOutliner. Thus, changes on that Outliner are immediately
+    reflected on the screen. If the object leaves edit mode, the old
+    behaviour is restored.</p>
+ */
+class SvxTextEditSourceImpl : public SfxListener, public SfxBroadcaster, public sdr::ObjectUser
+{
+private:
+    oslInterlockedCount maRefCount;
+
+    SdrObject*                      mpObject;           // TTTT could be reference (?)
+    SdrText*                        mpText;
+    SdrView*                        mpView;
+    VclPtr<const OutputDevice>      mpWindow;
+    SdrModel*                       mpModel;            // TTTT probably not needed -> use SdrModel from SdrObject (?)
+    std::unique_ptr<SdrOutliner>    mpOutliner;
+    std::unique_ptr<SvxOutlinerForwarder> mpTextForwarder;
+    std::unique_ptr<SvxDrawOutlinerViewForwarder> mpViewForwarder;    // if non-NULL, use GetViewModeTextForwarder text forwarder
+    css::uno::Reference< css::linguistic2::XLinguServiceManager2 > m_xLinguServiceManager;
+    Point                           maTextOffset;
+    bool                            mbDataValid;
+    bool                            mbIsLocked;
+    bool                            mbNeedsUpdate;
+    bool                            mbOldUndoMode;
+    bool                            mbForwarderIsEditMode;      // have to reflect that, since ENDEDIT can happen more often
+    bool                            mbShapeIsEditMode;          // only true, if SdrHintKind::BeginEdit was received
+    bool                            mbNotificationsDisabled;    // prevent EditEngine/Outliner notifications (e.g. when setting up forwarder)
+    bool                            mbNotifyEditOutlinerSet;
+
+    SvxUnoTextRangeBaseVec          mvTextRanges;
+
+    SvxTextForwarder*               GetBackgroundTextForwarder();
+    SvxTextForwarder*               GetEditModeTextForwarder();
+    std::unique_ptr<SvxDrawOutlinerViewForwarder> CreateViewForwarder();
+
+    void                            SetupOutliner();
+
+    bool                            HasView() const { return mpView != nullptr; }
+    bool                            IsEditMode() const
+                                    {
+                                        SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( mpObject  );
+                                        return mbShapeIsEditMode && pTextObj && pTextObj->IsTextEditActive();
+                                    }
+
+    void                            dispose();
+
+public:
+    SvxTextEditSourceImpl( SdrObject* pObject, SdrText* pText );
+    SvxTextEditSourceImpl( SdrObject& rObject, SdrText* pText, SdrView& rView, const OutputDevice& rWindow );
+    virtual ~SvxTextEditSourceImpl() override;
+
+    void acquire();
+    void release();
+
+    virtual void            Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
+
+    SvxTextForwarder*       GetTextForwarder();
+    SvxEditViewForwarder*   GetEditViewForwarder( bool );
+    void                    UpdateData();
+
+    void addRange( SvxUnoTextRangeBase* pNewRange );
+    void removeRange( SvxUnoTextRangeBase* pOldRange );
+    const SvxUnoTextRangeBaseVec& getRanges() const { return mvTextRanges;}
+
+    void                    lock();
+    void                    unlock();
+
+    bool                    IsValid() const;
+
+    Point                   LogicToPixel( const Point&, const MapMode& rMapMode );
+    Point                   PixelToLogic( const Point&, const MapMode& rMapMode );
+
+    DECL_LINK( NotifyHdl, EENotify&, void );
+
+    virtual void ObjectInDestruction(const SdrObject& rObject) override;
+
+    void                    UpdateOutliner();
+};
+
+
+SvxTextEditSourceImpl::SvxTextEditSourceImpl( SdrObject* pObject, SdrText* pText )
+  : maRefCount      ( 0 ),
+    mpObject        ( pObject ),
+    mpText          ( pText ),
+    mpView          ( nullptr ),
+    mpWindow        ( nullptr ),
+    mpModel         ( pObject ? &pObject->getSdrModelFromSdrObject() : nullptr ), // TTTT should be reference
+    mbDataValid     ( false ),
+    mbIsLocked      ( false ),
+    mbNeedsUpdate   ( false ),
+    mbOldUndoMode   ( false ),
+    mbForwarderIsEditMode ( false ),
+    mbShapeIsEditMode     ( false ),
+    mbNotificationsDisabled ( false ),
+    mbNotifyEditOutlinerSet ( false )
+{
+    DBG_ASSERT( mpObject, "invalid pObject!" );
+
+    if( !mpText )
+    {
+        SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObject );
+        if( pTextObj )
+            mpText = pTextObj->getText( 0 );
+    }
+
+    if( mpModel )
+        StartListening( *mpModel );
+
+    if( mpObject )
+        mpObject->AddObjectUser( *this );
+}
+
+
+SvxTextEditSourceImpl::SvxTextEditSourceImpl( SdrObject& rObject, SdrText* pText, SdrView& rView, const OutputDevice& rWindow )
+  : maRefCount      ( 0 ),
+    mpObject        ( &rObject ),
+    mpText          ( pText ),
+    mpView          ( &rView ),
+    mpWindow        ( &rWindow ),
+    mpModel         ( &rObject.getSdrModelFromSdrObject() ), // TTTT should be reference
+    mbDataValid     ( false ),
+    mbIsLocked      ( false ),
+    mbNeedsUpdate   ( false ),
+    mbOldUndoMode   ( false ),
+    mbForwarderIsEditMode ( false ),
+    mbShapeIsEditMode     ( true ),
+    mbNotificationsDisabled ( false ),
+    mbNotifyEditOutlinerSet ( false )
+{
+    if( !mpText )
+    {
+        SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObject );
+        if( pTextObj )
+            mpText = pTextObj->getText( 0 );
+    }
+
+    StartListening( *mpModel );
+    StartListening( *mpView );
+    mpObject->AddObjectUser( *this );
+
+    // Init edit mode state from shape info (IsTextEditActive())
+    mbShapeIsEditMode = IsEditMode();
+}
+
+
+SvxTextEditSourceImpl::~SvxTextEditSourceImpl()
+{
+    DBG_ASSERT( !mbIsLocked, "text edit source was not unlocked before dispose!" );
+    if( mpObject )
+        mpObject->RemoveObjectUser( *this );
+
+    dispose();
+}
+
+
+void SvxTextEditSourceImpl::addRange( SvxUnoTextRangeBase* pNewRange )
+{
+    if( pNewRange )
+        if( std::find( mvTextRanges.begin(), mvTextRanges.end(), pNewRange ) == mvTextRanges.end() )
+            mvTextRanges.push_back( pNewRange );
+}
+
+
+void SvxTextEditSourceImpl::removeRange( SvxUnoTextRangeBase* pOldRange )
+{
+    if( pOldRange )
+        mvTextRanges.erase( std::remove(mvTextRanges.begin(), mvTextRanges.end(), pOldRange), mvTextRanges.end() );
+}
+
+
+void SvxTextEditSourceImpl::acquire()
+{
+    osl_atomic_increment( &maRefCount );
+}
+
+
+void SvxTextEditSourceImpl::release()
+{
+    if( ! osl_atomic_decrement( &maRefCount ) )
+        delete this;
+}
+
+void SvxTextEditSourceImpl::Notify(SfxBroadcaster& rBC, const SfxHint& rHint)
+{
+    // #i105988 keep reference to this object
+    rtl::Reference< SvxTextEditSourceImpl > xThis( this );
+
+    if (SfxHintId::Dying == rHint.GetId())
+    {
+        if (&rBC == mpView)
+        {
+            mpView = nullptr;
+            mpViewForwarder.reset();
+        }
+    }
+    else if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint)
+    {
+        const SdrHint* pSdrHint = static_cast<const SdrHint*>(&rHint);
+        switch( pSdrHint->GetKind() )
+        {
+            case SdrHintKind::ObjectChange:
+            {
+                mbDataValid = false;                        // Text has to be get again
+
+                if( HasView() )
+                {
+                    // Update maTextOffset, object has changed
+                    // Cannot call that here, since TakeTextRect() (called from there)
+                    // changes outliner content.
+                    // UpdateOutliner();
+
+                    // Broadcast object changes, as they might change visible attributes
+                    SvxViewChangedHint aHint;
+                    Broadcast( aHint );
+                }
+                break;
+            }
+
+            case SdrHintKind::BeginEdit:
+                if( mpObject == pSdrHint->GetObject() )
+                {
+                    // Once SdrHintKind::BeginEdit is broadcast, each EditSource of
+                    // AccessibleCell will handle it here and call below:
+                    // mpView->GetTextEditOutliner()->SetNotifyHdl(), which
+                    // will replace the Notifier for current editable cell. It
+                    // is totally wrong. So add check here to avoid the
+                    // incorrect replacement of notifier.
+
+                    // Currently it only happens on the editsource of
+                    // AccessibleCell
+                    if (mpObject && mpText)
+                    {
+                        sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( mpObject );
+                        if(pTableObj)
+                        {
+                            const sdr::table::CellRef& xCell = pTableObj->getActiveCell();
+                            if (xCell.is())
+                            {
+                                sdr::table::Cell* pCellObj = dynamic_cast< sdr::table::Cell* >( mpText );
+                                if (pCellObj && xCell.get() != pCellObj)
+                                    break;
+                            }
+                        }
+                    }
+                    // invalidate old forwarder
+                    if( !mbForwarderIsEditMode )
+                    {
+                        mpTextForwarder.reset();
+                    }
+
+                    // register as listener - need to broadcast state change messages
+                    if( mpView && mpView->GetTextEditOutliner() )
+                    {
+                        mpView->GetTextEditOutliner()->SetNotifyHdl( LINK(this, SvxTextEditSourceImpl, NotifyHdl) );
+                        mbNotifyEditOutlinerSet = true;
+                    }
+
+                    // Only now we're really in edit mode
+                    mbShapeIsEditMode = true;
+
+                    Broadcast( *pSdrHint );
+                }
+                break;
+
+            case SdrHintKind::EndEdit:
+                if( mpObject == pSdrHint->GetObject() )
+                {
+                    Broadcast( *pSdrHint );
+
+                    // We're no longer in edit mode
+                    mbShapeIsEditMode = false;
+
+                    // remove as listener - outliner might outlive ourselves
+                    if( mpView && mpView->GetTextEditOutliner() )
+                    {
+                        mpView->GetTextEditOutliner()->SetNotifyHdl( Link<EENotify&,void>() );
+                        mbNotifyEditOutlinerSet = false;
+                    }
+
+                    // destroy view forwarder, OutlinerView no longer
+                    // valid (no need for UpdateData(), it's been
+                    // synched on SdrEndTextEdit)
+                    mpViewForwarder.reset();
+
+                    // Invalidate text forwarder, we might
+                    // not be called again before entering edit mode a
+                    // second time! Then, the old outliner might be
+                    // invalid.
+                    if( mbForwarderIsEditMode )
+                    {
+                        mbForwarderIsEditMode = false;
+                        mpTextForwarder.reset();
+                    }
+                }
+                break;
+
+            case SdrHintKind::ModelCleared:
+                dispose();
+                break;
+            default:
+                break;
+        }
+    }
+    else if (const SvxViewChangedHint* pViewHint = dynamic_cast<const SvxViewChangedHint*>(&rHint))
+    {
+        Broadcast( *pViewHint );
+    }
+}
+
+/* this is a callback from the attached SdrObject when it is actually deleted */
+void SvxTextEditSourceImpl::ObjectInDestruction(const SdrObject&)
+{
+    mpObject = nullptr;
+    dispose();
+    Broadcast( SfxHint( SfxHintId::Dying ) );
+}
+
+/* unregister at all objects and set all references to 0 */
+void SvxTextEditSourceImpl::dispose()
+{
+    mpTextForwarder.reset();
+    mpViewForwarder.reset();
+
+    if( mpOutliner )
+    {
+        if( mpModel )
+        {
+            mpModel->disposeOutliner( std::move(mpOutliner) );
+        }
+        else
+        {
+            mpOutliner.reset();
+        }
+    }
+
+    if( mpModel )
+    {
+        EndListening( *mpModel );
+        mpModel = nullptr;
+    }
+
+    if( mpView )
+    {
+        // remove as listener - outliner might outlive ourselves
+        if (mbNotifyEditOutlinerSet && mpView->GetTextEditOutliner())
+        {
+            mpView->GetTextEditOutliner()->SetNotifyHdl(Link<EENotify&,void>());
+            mbNotifyEditOutlinerSet = false;
+        }
+        EndListening( *mpView );
+        mpView = nullptr;
+    }
+
+    if( mpObject )
+    {
+        mpObject->RemoveObjectUser( *this );
+        mpObject = nullptr;
+    }
+    mpWindow = nullptr;
+}
+
+
+void SvxTextEditSourceImpl::SetupOutliner()
+{
+    // only for UAA edit source: setup outliner equivalently as in
+    // SdrTextObj::Paint(), such that formatting equals screen
+    // layout
+    if( mpObject && mpOutliner )
+    {
+        SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( mpObject  );
+        tools::Rectangle aPaintRect;
+        if( pTextObj )
+        {
+            tools::Rectangle aBoundRect( pTextObj->GetCurrentBoundRect() );
+            pTextObj->SetupOutlinerFormatting( *mpOutliner, aPaintRect );
+
+            // calc text offset from shape anchor
+            maTextOffset = aPaintRect.TopLeft() - aBoundRect.TopLeft();
+        }
+    }
+}
+
+
+void SvxTextEditSourceImpl::UpdateOutliner()
+{
+    // only for UAA edit source: update outliner equivalently as in
+    // SdrTextObj::Paint(), such that formatting equals screen
+    // layout
+    if( mpObject && mpOutliner )
+    {
+        SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( mpObject  );
+        tools::Rectangle aPaintRect;
+        if( pTextObj )
+        {
+            tools::Rectangle aBoundRect( pTextObj->GetCurrentBoundRect() );
+            pTextObj->UpdateOutlinerFormatting( *mpOutliner, aPaintRect );
+
+            // calc text offset from shape anchor
+            maTextOffset = aPaintRect.TopLeft() - aBoundRect.TopLeft();
+        }
+    }
+}
+
+
+SvxTextForwarder* SvxTextEditSourceImpl::GetBackgroundTextForwarder()
+{
+    bool bCreated = false;
+
+    // prevent EE/Outliner notifications during setup
+    mbNotificationsDisabled = true;
+
+    if (!mpTextForwarder)
+    {
+        if( mpOutliner == nullptr )
+        {
+            SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( mpObject  );
+            OutlinerMode nOutlMode = OutlinerMode::TextObject;
+            if( pTextObj && pTextObj->IsTextFrame() && pTextObj->GetTextKind() == OBJ_OUTLINETEXT )
+                nOutlMode = OutlinerMode::OutlineObject;
+
+            mpOutliner = mpModel->createOutliner( nOutlMode );
+
+            // Do the setup after outliner creation, would be useless otherwise
+            if( HasView() )
+            {
+                // Setup outliner _before_ filling it
+                SetupOutliner();
+            }
+
+            mpOutliner->SetTextObjNoInit( pTextObj );
+            if( mbIsLocked )
+            {
+                const_cast<EditEngine*>(&(mpOutliner->GetEditEngine()))->SetUpdateMode( false );
+                mbOldUndoMode = mpOutliner->GetEditEngine().IsUndoEnabled();
+                const_cast<EditEngine*>(&(mpOutliner->GetEditEngine()))->EnableUndo( false );
+            }
+
+            if (!utl::ConfigManager::IsFuzzing())
+            {
+                if ( !m_xLinguServiceManager.is() )
+                {
+                    css::uno::Reference< css::uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
+                    m_xLinguServiceManager.set(css::linguistic2::LinguServiceManager::create(xContext));
+                }
+
+                css::uno::Reference< css::linguistic2::XHyphenator > xHyphenator = m_xLinguServiceManager->getHyphenator();
+                if( xHyphenator.is() )
+                    mpOutliner->SetHyphenator( xHyphenator );
+            }
+        }
+
+
+        mpTextForwarder.reset(new SvxOutlinerForwarder( *mpOutliner, (mpObject->GetObjInventor() == SdrInventor::Default) && (mpObject->GetObjIdentifier() == OBJ_OUTLINETEXT) ));
+        // delay listener subscription and UAA initialization until Outliner is fully setup
+        bCreated = true;
+
+        mbForwarderIsEditMode = false;
+        mbDataValid = false;
+    }
+
+    if( mpObject && mpText && !mbDataValid && mpObject->IsInserted() && mpObject->getSdrPageFromSdrObject() )
+    {
+        mpTextForwarder->flushCache();
+
+        OutlinerParaObject* pOutlinerParaObject = nullptr;
+        SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( mpObject  );
+        if( pTextObj && pTextObj->getActiveText() == mpText )
+            pOutlinerParaObject = pTextObj->CreateEditOutlinerParaObject().release(); // Get the OutlinerParaObject if text edit is active
+        bool bOwnParaObj(false);
+
+        if( pOutlinerParaObject )
+            bOwnParaObj = true; // text edit active
+        else
+            pOutlinerParaObject = mpText->GetOutlinerParaObject();
+
+        if( pOutlinerParaObject && ( bOwnParaObj || !mpObject->IsEmptyPresObj() || mpObject->getSdrPageFromSdrObject()->IsMasterPage() ) )
+        {
+            mpOutliner->SetText( *pOutlinerParaObject );
+
+            // put text to object and set EmptyPresObj to FALSE
+            if( mpText && bOwnParaObj && mpObject->IsEmptyPresObj() && pTextObj->IsReallyEdited() )
+            {
+                mpObject->SetEmptyPresObj( false );
+                static_cast< SdrTextObj* >( mpObject)->NbcSetOutlinerParaObjectForText( std::unique_ptr<OutlinerParaObject>(pOutlinerParaObject), mpText );
+
+                // #i103982# Here, due to mpObject->NbcSetOutlinerParaObjectForText, we LOSE ownership of the
+                // OPO, so do NOT delete it when leaving this method (!)
+                bOwnParaObj = false;
+            }
+        }
+        else
+        {
+            bool bVertical = pOutlinerParaObject && pOutlinerParaObject->IsVertical();
+
+            // set objects style sheet on empty outliner
+            SfxStyleSheetPool* pPool = static_cast<SfxStyleSheetPool*>(mpObject->getSdrModelFromSdrObject().GetStyleSheetPool());
+            if( pPool )
+                mpOutliner->SetStyleSheetPool( pPool );
+
+            SfxStyleSheet* pStyleSheet = mpObject->getSdrPageFromSdrObject()->GetTextStyleSheetForObject( mpObject );
+            if( pStyleSheet )
+                mpOutliner->SetStyleSheet( 0, pStyleSheet );
+
+            if( bVertical )
+            {
+                mpOutliner->SetVertical( pOutlinerParaObject->GetDirectVertical());
+                mpOutliner->SetRotation( pOutlinerParaObject->GetRotation());
+            }
+        }
+
+        // maybe we have to set the border attributes
+        if (mpOutliner->GetParagraphCount()==1)
+        {
+            // if we only have one paragraph we check if it is empty
+            OUString aStr(mpOutliner->GetText(mpOutliner->GetParagraph(0)));
+
+            if (aStr.isEmpty())
+            {
+                // its empty, so we have to force the outliner to initialise itself
+                mpOutliner->SetText( "", mpOutliner->GetParagraph( 0 ) );
+
+                if(mpObject->GetStyleSheet())
+                    mpOutliner->SetStyleSheet( 0, mpObject->GetStyleSheet());
+            }
+        }
+
+        mbDataValid = true;
+
+        if( bOwnParaObj )
+            delete pOutlinerParaObject;
+    }
+
+    if( bCreated && mpOutliner && HasView() )
+    {
+        // register as listener - need to broadcast state change messages
+        // registration delayed until outliner is completely set up
+        mpOutliner->SetNotifyHdl( LINK(this, SvxTextEditSourceImpl, NotifyHdl) );
+    }
+
+    // prevent EE/Outliner notifications during setup
+    mbNotificationsDisabled = false;
+
+    return mpTextForwarder.get();
+}
+
+
+SvxTextForwarder* SvxTextEditSourceImpl::GetEditModeTextForwarder()
+{
+    if( !mpTextForwarder && HasView() )
+    {
+        SdrOutliner* pEditOutliner = mpView->GetTextEditOutliner();
+
+        if( pEditOutliner )
+        {
+            mpTextForwarder.reset(new SvxOutlinerForwarder( *pEditOutliner, (mpObject->GetObjInventor() == SdrInventor::Default) && (mpObject->GetObjIdentifier() == OBJ_OUTLINETEXT) ));
+            mbForwarderIsEditMode = true;
+        }
+    }
+
+    return mpTextForwarder.get();
+}
+
+
+SvxTextForwarder* SvxTextEditSourceImpl::GetTextForwarder()
+{
+    if( mpObject == nullptr )
+        return nullptr;
+
+    if( mpModel == nullptr )
+        mpModel = &mpObject->getSdrModelFromSdrObject();
+
+    // distinguish the cases
+    // a) connected to view, maybe edit mode is active, can work directly on the EditOutliner
+    // b) background Outliner, reflect changes into ParaOutlinerObject (this is exactly the old UNO code)
+    if( HasView() )
+    {
+        if( IsEditMode() != mbForwarderIsEditMode )
+        {
+            // forwarder mismatch - create new
+            mpTextForwarder.reset();
+        }
+
+        if( IsEditMode() )
+            return GetEditModeTextForwarder();
+        else
+            return GetBackgroundTextForwarder();
+    }
+    else
+    {
+        // tdf#123470 if the text edit mode of the shape is active, then we
+        // cannot trust a previously cached TextForwarder state as the text may
+        // be out of date, so force a refetch in that case.
+        if (IsEditMode())
+        {
+            assert(!mbForwarderIsEditMode); // because without a view there is no other option except !mbForwarderIsEditMode
+            bool bTextEditActive = false;
+            SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>(mpObject);
+            // similar to the GetBackgroundTextForwarder check, see if the text edit is active
+            if (pTextObj && pTextObj->getActiveText() == mpText && pTextObj->CanCreateEditOutlinerParaObject())
+                bTextEditActive = true; // text edit active
+            if (bTextEditActive)
+                mbDataValid = false;
+        }
+
+        return GetBackgroundTextForwarder();
+    }
+}
+
+std::unique_ptr<SvxDrawOutlinerViewForwarder> SvxTextEditSourceImpl::CreateViewForwarder()
+{
+    if( mpView->GetTextEditOutlinerView() && mpObject )
+    {
+        // register as listener - need to broadcast state change messages
+        mpView->GetTextEditOutliner()->SetNotifyHdl( LINK(this, SvxTextEditSourceImpl, NotifyHdl) );
+        mbNotifyEditOutlinerSet = true;
+
+        SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( mpObject  );
+        if( pTextObj )
+        {
+            tools::Rectangle aBoundRect( pTextObj->GetCurrentBoundRect() );
+            OutlinerView& rOutlView = *mpView->GetTextEditOutlinerView();
+
+            return std::unique_ptr<SvxDrawOutlinerViewForwarder>(new SvxDrawOutlinerViewForwarder( rOutlView, aBoundRect.TopLeft() ));
+        }
+    }
+
+    return nullptr;
+}
+
+SvxEditViewForwarder* SvxTextEditSourceImpl::GetEditViewForwarder( bool bCreate )
+{
+    if( mpObject == nullptr )
+        return nullptr;
+
+    if( mpModel == nullptr )
+        mpModel = &mpObject->getSdrModelFromSdrObject();
+
+    // shall we delete?
+    if( mpViewForwarder )
+    {
+        if( !IsEditMode() )
+        {
+            // destroy all forwarders (no need for UpdateData(),
+            // it's been synched on SdrEndTextEdit)
+            mpViewForwarder.reset();
+        }
+    }
+    // which to create? Directly in edit mode, create new, or none?
+    else if( mpView )
+    {
+        if( IsEditMode() )
+        {
+            // create new view forwarder
+            mpViewForwarder = CreateViewForwarder();
+        }
+        else if( bCreate )
+        {
+            // dispose old text forwarder
+            UpdateData();
+
+            mpTextForwarder.reset();
+
+            // enter edit mode
+            mpView->SdrEndTextEdit();
+
+            if(mpView->SdrBeginTextEdit(mpObject))
+            {
+                SdrTextObj* pTextObj = dynamic_cast<SdrTextObj*>( mpObject  );
+                if (pTextObj && pTextObj->IsTextEditActive())
+                {
+                    // create new view forwarder
+                    mpViewForwarder = CreateViewForwarder();
+                }
+                else
+                {
+                    // failure. Somehow, SdrBeginTextEdit did not set
+                    // our SdrTextObj into edit mode
+                    mpView->SdrEndTextEdit();
+                }
+            }
+        }
+    }
+
+    return mpViewForwarder.get();
+}
+
+
+void SvxTextEditSourceImpl::UpdateData()
+{
+    // if we have a view and in edit mode, we're working with the
+    // DrawOutliner. Thus, all changes made on the text forwarder are
+    // reflected on the view and committed to the model on
+    // SdrEndTextEdit(). Thus, no need for explicit updates here.
+    if( !HasView() || !IsEditMode() )
+    {
+        if( mbIsLocked  )
+        {
+            mbNeedsUpdate = true;
+        }
+        else
+        {
+            if( mpOutliner && mpObject && mpText )
+            {
+                SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mpObject );
+                if( pTextObj )
+                {
+                    if( mpOutliner->GetParagraphCount() != 1 || mpOutliner->GetEditEngine().GetTextLen( 0 ) )
+                    {
+                        if( mpOutliner->GetParagraphCount() > 1 )
+                        {
+                            if (pTextObj->IsTextFrame() && pTextObj->GetTextKind() == OBJ_TITLETEXT)
+                            {
+                                while( mpOutliner->GetParagraphCount() > 1 )
+                                {
+                                    ESelection aSel( 0,mpOutliner->GetEditEngine().GetTextLen( 0 ), 1,0 );
+                                    mpOutliner->QuickInsertLineBreak( aSel );
+                                }
+                            }
+                        }
+
+                        pTextObj->NbcSetOutlinerParaObjectForText( mpOutliner->CreateParaObject(), mpText );
+                    }
+                    else
+                    {
+                        pTextObj->NbcSetOutlinerParaObjectForText( nullptr,mpText );
+                    }
+                }
+
+                if( mpObject->IsEmptyPresObj() )
+                    mpObject->SetEmptyPresObj(false);
+            }
+        }
+    }
+}
+
+void SvxTextEditSourceImpl::lock()
+{
+    mbIsLocked = true;
+    if( mpOutliner )
+    {
+        const_cast<EditEngine*>(&(mpOutliner->GetEditEngine()))->SetUpdateMode( false );
+        mbOldUndoMode = mpOutliner->GetEditEngine().IsUndoEnabled();
+        const_cast<EditEngine*>(&(mpOutliner->GetEditEngine()))->EnableUndo( false );
+    }
+}
+
+void SvxTextEditSourceImpl::unlock()
+{
+    mbIsLocked = false;
+
+    if( mbNeedsUpdate )
+    {
+        UpdateData();
+        mbNeedsUpdate = false;
+    }
+
+    if( mpOutliner )
+    {
+        const_cast<EditEngine*>(&(mpOutliner->GetEditEngine()))->SetUpdateMode( true );
+        const_cast<EditEngine*>(&(mpOutliner->GetEditEngine()))->EnableUndo( mbOldUndoMode );
+    }
+}
+
+bool SvxTextEditSourceImpl::IsValid() const
+{
+    return mpView && mpWindow;
+}
+
+Point SvxTextEditSourceImpl::LogicToPixel( const Point& rPoint, const MapMode& rMapMode )
+{
+    // The responsibilities of ViewForwarder happen to be
+    // somewhat mixed in this case. On the one hand, we need the
+    // different interface queries on the SvxEditSource interface,
+    // since we need both VisAreas. On the other hand, if an
+    // EditViewForwarder exists, maTextOffset does not remain static,
+    // but may change with every key press.
+    if( IsEditMode() )
+    {
+        SvxEditViewForwarder* pForwarder = GetEditViewForwarder(false);
+
+        if( pForwarder )
+            return pForwarder->LogicToPixel( rPoint, rMapMode );
+    }
+    else if( IsValid() && mpModel )
+    {
+        Point aPoint1( rPoint );
+        aPoint1.AdjustX(maTextOffset.X() );
+        aPoint1.AdjustY(maTextOffset.Y() );
+
+        Point aPoint2( OutputDevice::LogicToLogic( aPoint1, rMapMode,
+                                                   MapMode(mpModel->GetScaleUnit()) ) );
+        MapMode aMapMode(mpWindow->GetMapMode());
+        aMapMode.SetOrigin(Point());
+        return mpWindow->LogicToPixel( aPoint2, aMapMode );
+    }
+
+    return Point();
+}
+
+Point SvxTextEditSourceImpl::PixelToLogic( const Point& rPoint, const MapMode& rMapMode )
+{
+    // The responsibilities of ViewForwarder happen to be
+    // somewhat mixed in this case. On the one hand, we need the
+    // different interface queries on the SvxEditSource interface,
+    // since we need both VisAreas. On the other hand, if an
+    // EditViewForwarder exists, maTextOffset does not remain static,
+    // but may change with every key press.
+    if( IsEditMode() )
+    {
+        SvxEditViewForwarder* pForwarder = GetEditViewForwarder(false);
+
+        if( pForwarder )
+            return pForwarder->PixelToLogic( rPoint, rMapMode );
+    }
+    else if( IsValid() && mpModel )
+    {
+        MapMode aMapMode(mpWindow->GetMapMode());
+        aMapMode.SetOrigin(Point());
+        Point aPoint1( mpWindow->PixelToLogic( rPoint, aMapMode ) );
+        Point aPoint2( OutputDevice::LogicToLogic( aPoint1,
+                                                   MapMode(mpModel->GetScaleUnit()),
+                                                   rMapMode ) );
+        aPoint2.AdjustX( -(maTextOffset.X()) );
+        aPoint2.AdjustY( -(maTextOffset.Y()) );
+
+        return aPoint2;
+    }
+
+    return Point();
+}
+
+IMPL_LINK(SvxTextEditSourceImpl, NotifyHdl, EENotify&, rNotify, void)
+{
+    if( !mbNotificationsDisabled )
+    {
+        std::unique_ptr< SfxHint > aHint( SvxEditSourceHelper::EENotification2Hint( &rNotify) );
+
+        if (aHint)
+            Broadcast(*aHint);
+    }
+}
+
+SvxTextEditSource::SvxTextEditSource( SdrObject* pObject, SdrText* pText )
+{
+    mpImpl = new SvxTextEditSourceImpl( pObject, pText );
+}
+
+
+SvxTextEditSource::SvxTextEditSource( SdrObject& rObj, SdrText* pText, SdrView& rView, const OutputDevice& rWindow )
+{
+    mpImpl = new SvxTextEditSourceImpl( rObj, pText, rView, rWindow );
+}
+
+
+SvxTextEditSource::SvxTextEditSource( SvxTextEditSourceImpl* pImpl )
+{
+    mpImpl = pImpl;
+}
+
+
+SvxTextEditSource::~SvxTextEditSource()
+{
+    ::SolarMutexGuard aGuard;
+    mpImpl.clear();
+}
+
+
+std::unique_ptr<SvxEditSource> SvxTextEditSource::Clone() const
+{
+    return std::unique_ptr<SvxEditSource>(new SvxTextEditSource( mpImpl.get() ));
+}
+
+
+SvxTextForwarder* SvxTextEditSource::GetTextForwarder()
+{
+    return mpImpl->GetTextForwarder();
+}
+
+
+SvxEditViewForwarder* SvxTextEditSource::GetEditViewForwarder( bool bCreate )
+{
+    return mpImpl->GetEditViewForwarder( bCreate );
+}
+
+
+SvxViewForwarder* SvxTextEditSource::GetViewForwarder()
+{
+    return this;
+}
+
+
+void SvxTextEditSource::UpdateData()
+{
+    mpImpl->UpdateData();
+}
+
+SfxBroadcaster& SvxTextEditSource::GetBroadcaster() const
+{
+    return *mpImpl;
+}
+
+void SvxTextEditSource::lock()
+{
+    mpImpl->lock();
+}
+
+void SvxTextEditSource::unlock()
+{
+    mpImpl->unlock();
+}
+
+bool SvxTextEditSource::IsValid() const
+{
+    return mpImpl->IsValid();
+}
+
+Point SvxTextEditSource::LogicToPixel( const Point& rPoint, const MapMode& rMapMode ) const
+{
+    return mpImpl->LogicToPixel( rPoint, rMapMode );
+}
+
+Point SvxTextEditSource::PixelToLogic( const Point& rPoint, const MapMode& rMapMode ) const
+{
+    return mpImpl->PixelToLogic( rPoint, rMapMode );
+}
+
+void SvxTextEditSource::addRange( SvxUnoTextRangeBase* pNewRange )
+{
+    mpImpl->addRange( pNewRange );
+}
+
+void SvxTextEditSource::removeRange( SvxUnoTextRangeBase* pOldRange )
+{
+    mpImpl->removeRange( pOldRange );
+}
+
+const SvxUnoTextRangeBaseVec& SvxTextEditSource::getRanges() const
+{
+    return mpImpl->getRanges();
+}
+
+void SvxTextEditSource::UpdateOutliner()
+{
+    mpImpl->UpdateOutliner();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/unodraw/unottabl.cxx b/svx/source/unodraw/unottabl.cxx
new file mode 100644
index 000000000..63ffa7ebe
--- /dev/null
+++ b/svx/source/unodraw/unottabl.cxx
@@ -0,0 +1,87 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/awt/Gradient.hpp>
+#include <svx/xflftrit.hxx>
+
+#include <svx/svdmodel.hxx>
+#include <svx/unofill.hxx>
+#include <svx/unomid.hxx>
+#include "UnoNameItemTable.hxx"
+
+using namespace ::com::sun::star;
+using namespace ::cppu;
+
+namespace {
+
+class SvxUnoTransGradientTable : public SvxUnoNameItemTable
+{
+public:
+    explicit SvxUnoTransGradientTable( SdrModel* pModel ) throw();
+
+    virtual NameOrIndex* createItem() const override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName(  ) override;
+    virtual uno::Sequence<  OUString > SAL_CALL getSupportedServiceNames(  ) override;
+
+    // XElementAccess
+    virtual uno::Type SAL_CALL getElementType(  ) override;
+};
+
+}
+
+SvxUnoTransGradientTable::SvxUnoTransGradientTable( SdrModel* pModel ) throw()
+: SvxUnoNameItemTable( pModel, XATTR_FILLFLOATTRANSPARENCE, MID_FILLGRADIENT )
+{
+}
+
+OUString SAL_CALL SvxUnoTransGradientTable::getImplementationName()
+{
+    return "SvxUnoTransGradientTable";
+}
+
+uno::Sequence< OUString > SAL_CALL SvxUnoTransGradientTable::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.drawing.TransparencyGradientTable" };
+}
+
+NameOrIndex* SvxUnoTransGradientTable::createItem() const
+{
+    XFillFloatTransparenceItem* pNewItem = new XFillFloatTransparenceItem();
+    pNewItem->SetEnabled( true );
+    return pNewItem;
+}
+
+// XElementAccess
+uno::Type SAL_CALL SvxUnoTransGradientTable::getElementType(  )
+{
+    return cppu::UnoType<awt::Gradient>::get();
+}
+
+/**
+ * Create a hatchtable
+ */
+uno::Reference< uno::XInterface > SvxUnoTransGradientTable_createInstance( SdrModel* pModel )
+{
+    return *new SvxUnoTransGradientTable(pModel);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */