Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

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

9 files changed, 4682 insertions, 0 deletions

diff --git a/sd/source/ui/app/optsitem.cxx b/sd/source/ui/app/optsitem.cxx
new file mode 100644
index 000000000..5baff32e2
--- /dev/null
+++ b/sd/source/ui/app/optsitem.cxx
@@ -0,0 +1,1407 @@
+/* -*- 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 <o3tl/any.hxx>
+#include <svx/svdmodel.hxx>
+#include <svx/svxids.hrc>
+#include <tools/debug.hxx>
+#include <tools/helpers.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <unotools/syslocale.hxx>
+#include <osl/diagnose.h>
+
+#include <optsitem.hxx>
+#include <FrameView.hxx>
+#include <sdattr.hrc>
+
+using namespace ::utl;
+using namespace ::com::sun::star::uno;
+
+template< class T > static T getSafeValue( const Any& rAny )
+{
+    T value = T();
+    bool bOk = (rAny >>= value);
+
+    DBG_ASSERT( bOk, "SdOptionsItem, wrong type from configuration!" );
+
+    return value;
+}
+
+
+SdOptionsItem::SdOptionsItem( const SdOptionsGeneric& rParent, const OUString& rSubTree ) :
+    ConfigItem  ( rSubTree ),
+    mrParent    ( rParent )
+{
+}
+
+SdOptionsItem::~SdOptionsItem()
+{
+}
+
+void SdOptionsItem::ImplCommit()
+{
+    if( IsModified() )
+        mrParent.Commit( *this );
+};
+
+void SdOptionsItem::Notify( const css::uno::Sequence<OUString>& )
+{}
+
+Sequence< Any > SdOptionsItem::GetProperties( const Sequence< OUString >& rNames )
+{
+    return ConfigItem::GetProperties( rNames );
+}
+
+bool SdOptionsItem::PutProperties( const Sequence< OUString >& rNames, const Sequence< Any>& rValues )
+{
+    return ConfigItem::PutProperties( rNames, rValues );
+}
+
+SdOptionsGeneric::SdOptionsGeneric(bool bImpress, const OUString& rSubTree)
+    : maSubTree(rSubTree)
+    , mbImpress(bImpress)
+    , mbInit(rSubTree.isEmpty())
+    , mbEnableModify(false)
+{
+}
+
+SdOptionsGeneric::SdOptionsGeneric(SdOptionsGeneric const & rSource)
+{
+    operator=(rSource);
+}
+
+SdOptionsGeneric& SdOptionsGeneric::operator=(SdOptionsGeneric const & rSource)
+{
+    if (this != &rSource)
+    {
+        maSubTree = rSource.maSubTree;
+        mpCfgItem.reset(rSource.mpCfgItem ? new SdOptionsItem(*rSource.mpCfgItem) : nullptr );
+        mbImpress = rSource.mbImpress;
+        mbInit = rSource.mbInit;
+        mbEnableModify = rSource.mbEnableModify;
+    }
+    return *this;
+}
+
+void SdOptionsGeneric::Init() const
+{
+    if( mbInit )
+        return;
+
+    SdOptionsGeneric* pThis = const_cast<SdOptionsGeneric*>(this);
+
+    if( !mpCfgItem )
+        pThis->mpCfgItem.reset( new SdOptionsItem( *this, maSubTree ) );
+    assert(mpCfgItem && "mpCfgItem is set by now");
+
+    const Sequence< OUString >  aNames( GetPropertyNames() );
+    const Sequence< Any >       aValues = mpCfgItem->GetProperties( aNames );
+
+    if( aNames.hasElements() && ( aValues.getLength() == aNames.getLength() ) )
+    {
+        const Any* pValues = aValues.getConstArray();
+
+        pThis->EnableModify( false );
+        pThis->mbInit = pThis->ReadData( pValues );
+        pThis->EnableModify( true );
+    }
+    else
+        pThis->mbInit = true;
+}
+
+SdOptionsGeneric::~SdOptionsGeneric()
+{
+}
+
+void SdOptionsGeneric::Commit( SdOptionsItem& rCfgItem ) const
+{
+    const Sequence< OUString >  aNames( GetPropertyNames() );
+    Sequence< Any >             aValues( aNames.getLength() );
+
+    if( aNames.hasElements() )
+    {
+        if( WriteData( aValues.getArray() ) )
+            rCfgItem.PutProperties( aNames, aValues );
+        else
+        {
+            OSL_FAIL( "PutProperties failed" );
+        }
+    }
+}
+
+Sequence< OUString > SdOptionsGeneric::GetPropertyNames() const
+{
+    sal_uLong           nCount;
+    const char**    ppPropNames;
+
+    GetPropNameArray( ppPropNames, nCount );
+
+    Sequence< OUString > aNames( nCount );
+    OUString*            pNames = aNames.getArray();
+
+    for( sal_uLong i = 0; i < nCount; i++ )
+        pNames[ i ] = OUString::createFromAscii( ppPropNames[ i ] );
+
+    return aNames;
+}
+
+void SdOptionsGeneric::Store()
+{
+    if( mpCfgItem )
+        mpCfgItem->Commit();
+}
+
+bool SdOptionsGeneric::isMetricSystem()
+{
+    SvtSysLocale aSysLocale;
+    MeasurementSystem eSys = aSysLocale.GetLocaleData().getMeasurementSystemEnum();
+
+    return ( eSys == MeasurementSystem::Metric );
+}
+
+/*************************************************************************
+|*
+|* SdOptionsLayout
+|*
+\************************************************************************/
+
+SdOptionsLayout::SdOptionsLayout(bool bImpress, bool bUseConfig) :
+    SdOptionsGeneric( bImpress, bUseConfig ?
+                      ( bImpress ?
+                        OUString( "Office.Impress/Layout" ) :
+                        OUString( "Office.Draw/Layout" ) ) :
+                      OUString() ),
+    bRuler( true ),
+    bMoveOutline( true ),
+    bDragStripes( false ),
+    bHandlesBezier( false ),
+    bHelplines( true ),
+    nMetric(static_cast<sal_uInt16>(isMetricSystem() ? FieldUnit::CM : FieldUnit::INCH)),
+    nDefTab( 1250 )
+{
+    EnableModify( true );
+}
+
+bool SdOptionsLayout::operator==( const SdOptionsLayout& rOpt ) const
+{
+    return( IsRulerVisible() == rOpt.IsRulerVisible() &&
+            IsMoveOutline() == rOpt.IsMoveOutline() &&
+            IsDragStripes() == rOpt.IsDragStripes() &&
+            IsHandlesBezier() == rOpt.IsHandlesBezier() &&
+            IsHelplines() == rOpt.IsHelplines() &&
+            GetMetric() == rOpt.GetMetric() &&
+            GetDefTab() == rOpt.GetDefTab() );
+}
+
+void SdOptionsLayout::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
+{
+    if( isMetricSystem() )
+    {
+        static const char* aPropNamesMetric[] =
+        {
+            "Display/Ruler",
+            "Display/Bezier",
+            "Display/Contour",
+            "Display/Guide",
+            "Display/Helpline",
+            "Other/MeasureUnit/Metric",
+            "Other/TabStop/Metric"
+        };
+        ppNames = aPropNamesMetric;
+        rCount = SAL_N_ELEMENTS(aPropNamesMetric);
+    }
+    else
+    {
+        static const char* aPropNamesNonMetric[] =
+        {
+            "Display/Ruler",
+            "Display/Bezier",
+            "Display/Contour",
+            "Display/Guide",
+            "Display/Helpline",
+            "Other/MeasureUnit/NonMetric",
+            "Other/TabStop/NonMetric"
+        };
+        ppNames = aPropNamesNonMetric;
+        rCount = SAL_N_ELEMENTS(aPropNamesNonMetric);
+    }
+}
+
+bool SdOptionsLayout::ReadData( const Any* pValues )
+{
+    if( pValues[0].hasValue() ) SetRulerVisible( *o3tl::doAccess<bool>(pValues[ 0 ]) );
+    if( pValues[1].hasValue() ) SetHandlesBezier( *o3tl::doAccess<bool>(pValues[ 1 ]) );
+    if( pValues[2].hasValue() ) SetMoveOutline( *o3tl::doAccess<bool>(pValues[ 2 ]) );
+    if( pValues[3].hasValue() ) SetDragStripes( *o3tl::doAccess<bool>(pValues[ 3 ]) );
+    if( pValues[4].hasValue() ) SetHelplines( *o3tl::doAccess<bool>(pValues[ 4 ]) );
+    if( pValues[5].hasValue() ) SetMetric( static_cast<sal_uInt16>(*o3tl::doAccess<sal_Int32>(pValues[ 5 ])) );
+    if( pValues[6].hasValue() ) SetDefTab( static_cast<sal_uInt16>(*o3tl::doAccess<sal_Int32>(pValues[ 6 ])) );
+
+    return true;
+}
+
+bool SdOptionsLayout::WriteData( Any* pValues ) const
+{
+    pValues[ 0 ] <<= IsRulerVisible();
+    pValues[ 1 ] <<= IsHandlesBezier();
+    pValues[ 2 ] <<= IsMoveOutline();
+    pValues[ 3 ] <<= IsDragStripes();
+    pValues[ 4 ] <<= IsHelplines();
+    pValues[ 5 ] <<= static_cast<sal_Int32>(GetMetric());
+    pValues[ 6 ] <<= static_cast<sal_Int32>(GetDefTab());
+
+    return true;
+}
+
+/*************************************************************************
+|*
+|* SdOptionsLayoutItem
+|*
+\************************************************************************/
+
+SdOptionsLayoutItem::SdOptionsLayoutItem()
+:   SfxPoolItem     ( ATTR_OPTIONS_LAYOUT )
+,   maOptionsLayout ( false, false )
+{
+}
+
+SdOptionsLayoutItem::SdOptionsLayoutItem( SdOptions const * pOpts, ::sd::FrameView const * pView )
+:   SfxPoolItem     ( ATTR_OPTIONS_LAYOUT )
+,   maOptionsLayout ( false, false )
+{
+    if( pOpts )
+    {
+        maOptionsLayout.SetMetric( pOpts->GetMetric() );
+        maOptionsLayout.SetDefTab( pOpts->GetDefTab() );
+    }
+
+    if( pView )
+    {
+        maOptionsLayout.SetRulerVisible( pView->HasRuler() );
+        maOptionsLayout.SetMoveOutline( !pView->IsNoDragXorPolys() );
+        maOptionsLayout.SetDragStripes( pView->IsDragStripes() );
+        maOptionsLayout.SetHandlesBezier( pView->IsPlusHandlesAlwaysVisible() );
+        maOptionsLayout.SetHelplines( pView->IsHlplVisible() );
+    }
+    else if( pOpts )
+    {
+        maOptionsLayout.SetRulerVisible( pOpts->IsRulerVisible() );
+        maOptionsLayout.SetMoveOutline( pOpts->IsMoveOutline() );
+        maOptionsLayout.SetDragStripes( pOpts->IsDragStripes() );
+        maOptionsLayout.SetHandlesBezier( pOpts->IsHandlesBezier() );
+        maOptionsLayout.SetHelplines( pOpts->IsHelplines() );
+    }
+}
+
+SdOptionsLayoutItem* SdOptionsLayoutItem::Clone( SfxItemPool* ) const
+{
+    return new SdOptionsLayoutItem( *this );
+}
+
+bool SdOptionsLayoutItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    assert(SfxPoolItem::operator==(rAttr));
+    return maOptionsLayout == static_cast<const SdOptionsLayoutItem&>(rAttr).maOptionsLayout;
+}
+
+void SdOptionsLayoutItem::SetOptions( SdOptions* pOpts ) const
+{
+    if( pOpts )
+    {
+        pOpts->SetRulerVisible( maOptionsLayout.IsRulerVisible() );
+        pOpts->SetMoveOutline( maOptionsLayout.IsMoveOutline() );
+        pOpts->SetDragStripes( maOptionsLayout.IsDragStripes() );
+        pOpts->SetHandlesBezier( maOptionsLayout.IsHandlesBezier() );
+        pOpts->SetHelplines( maOptionsLayout.IsHelplines() );
+        pOpts->SetMetric( maOptionsLayout.GetMetric() );
+        pOpts->SetDefTab( maOptionsLayout.GetDefTab() );
+    }
+}
+
+/*************************************************************************
+|*
+|* SdOptionsContents
+|*
+\************************************************************************/
+
+SdOptionsContents::SdOptionsContents(bool bImpress) :
+    SdOptionsGeneric( bImpress, bImpress ?
+                        OUString( "Office.Impress/Content" ) :
+                        OUString( "Office.Draw/Content" ) )
+{
+    EnableModify( true );
+}
+
+bool SdOptionsContents::operator==(const SdOptionsContents&) const
+{
+    return true;
+}
+
+void SdOptionsContents::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
+{
+    static const char* aPropNames[] =
+    {
+        "Display/PicturePlaceholder",
+        "Display/ContourMode",
+        "Display/LineContour",
+        "Display/TextPlaceholder"
+    };
+
+    rCount = SAL_N_ELEMENTS(aPropNames);
+    ppNames = aPropNames;
+}
+
+bool SdOptionsContents::ReadData(const Any*)
+{
+    return true;
+}
+
+bool SdOptionsContents::WriteData( Any* pValues ) const
+{
+    //#i80528# no draft anymore
+    pValues[ 0 ] <<= false;
+    pValues[ 1 ] <<= false;
+    pValues[ 2 ] <<= false;
+    pValues[ 3 ] <<= false;
+
+    return true;
+}
+/*************************************************************************
+|*
+|* SdOptionsMisc
+|*
+\************************************************************************/
+
+SdOptionsMisc::SdOptionsMisc( bool bImpress, bool bUseConfig ) :
+    SdOptionsGeneric( bImpress, bUseConfig ?
+                      ( bImpress ?
+                        OUString( "Office.Impress/Misc" ) :
+                        OUString( "Office.Draw/Misc" ) ) :
+                      OUString() ),
+    nDefaultObjectSizeWidth(8000),
+    nDefaultObjectSizeHeight(5000),
+    bStartWithTemplate( false ),
+    bMarkedHitMovesAlways( true ),
+    bMoveOnlyDragging( false ),
+    bCrookNoContortion( false ),
+    bQuickEdit( IsImpress() ),
+    bMasterPageCache( true ),
+    bDragWithCopy( false ),
+    bPickThrough( true ),
+    bDoubleClickTextEdit( true ),
+    bClickChangeRotation( false ),
+    bEnableSdremote( false ),
+    bEnablePresenterScreen( true),
+    bSolidDragging( true ),
+    bSummationOfParagraphs( false ),
+    bTabBarVisible( true ),
+    bShowUndoDeleteWarning( true ),
+    bSlideshowRespectZOrder( true ),
+    bShowComments( true ),
+    bPreviewNewEffects( true ),
+    bPreviewChangedEffects( false ),
+    bPreviewTransitions( true ),
+    mnDisplay( 0 ),
+    mnPenColor( 0xff0000 ),
+    mnPenWidth( 150.0 ),
+
+    // The default for 6.1-and-above documents is to use printer-independent
+    // formatting.
+    mnPrinterIndependentLayout (1)
+{
+    EnableModify( true );
+}
+
+bool SdOptionsMisc::operator==( const SdOptionsMisc& rOpt ) const
+{
+    return( IsStartWithTemplate() == rOpt.IsStartWithTemplate() &&
+            IsMarkedHitMovesAlways() == rOpt.IsMarkedHitMovesAlways() &&
+            IsMoveOnlyDragging() == rOpt.IsMoveOnlyDragging() &&
+            IsCrookNoContortion() == rOpt.IsCrookNoContortion() &&
+            IsQuickEdit() == rOpt.IsQuickEdit() &&
+            IsMasterPagePaintCaching() == rOpt.IsMasterPagePaintCaching() &&
+            IsDragWithCopy() == rOpt.IsDragWithCopy() &&
+            IsPickThrough() == rOpt.IsPickThrough() &&
+            IsDoubleClickTextEdit() == rOpt.IsDoubleClickTextEdit() &&
+            IsClickChangeRotation() == rOpt.IsClickChangeRotation() &&
+            IsEnableSdremote() == rOpt.IsEnableSdremote() &&
+            IsEnablePresenterScreen() == rOpt.IsEnablePresenterScreen()&&
+            IsSummationOfParagraphs() == rOpt.IsSummationOfParagraphs() &&
+            IsTabBarVisible() == rOpt.IsTabBarVisible() &&
+            IsSolidDragging() == rOpt.IsSolidDragging() &&
+            IsShowUndoDeleteWarning() == rOpt.IsShowUndoDeleteWarning() &&
+            IsSlideshowRespectZOrder() == rOpt.IsSlideshowRespectZOrder() &&
+            GetPrinterIndependentLayout() == rOpt.GetPrinterIndependentLayout() &&
+            GetDefaultObjectSizeWidth() == rOpt.GetDefaultObjectSizeWidth() &&
+            GetDefaultObjectSizeHeight() == rOpt.GetDefaultObjectSizeHeight() &&
+
+            IsPreviewNewEffects() == rOpt.IsPreviewNewEffects() &&
+            IsPreviewChangedEffects() == rOpt.IsPreviewChangedEffects() &&
+            IsPreviewTransitions() == rOpt.IsPreviewTransitions() &&
+            GetDisplay() == rOpt.GetDisplay() &&
+            IsShowComments() == rOpt.IsShowComments() &&
+            GetPresentationPenColor() == rOpt.GetPresentationPenColor() &&
+            GetPresentationPenWidth() == rOpt.GetPresentationPenWidth()
+        );
+}
+
+void SdOptionsMisc::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
+{
+    static const char* aPropNames[] =
+    {
+        "ObjectMoveable",
+        "NoDistort",
+        "TextObject/QuickEditing",
+        "BackgroundCache",
+        "CopyWhileMoving",
+        "TextObject/Selectable",
+        "DclickTextedit",
+        "RotateClick",
+        "Preview",
+        "ModifyWithAttributes",
+        "DefaultObjectSize/Width",
+        "DefaultObjectSize/Height",
+
+        "Compatibility/PrinterIndependentLayout",
+
+        "ShowComments",
+
+        // just for impress
+        "NewDoc/AutoPilot",
+        "Compatibility/AddBetween",
+        "ShowUndoDeleteWarning",
+        "SlideshowRespectZOrder",
+
+        "PreviewNewEffects",
+        "PreviewChangedEffects",
+        "PreviewTransitions",
+
+        "Display",
+
+        "PenColor",
+        "PenWidth",
+        "Start/EnableSdremote",
+        "Start/EnablePresenterScreen",
+        "TabBarVisible"
+    };
+
+    rCount = ( IsImpress() ? SAL_N_ELEMENTS(aPropNames) : 14 );
+    ppNames = aPropNames;
+}
+
+bool SdOptionsMisc::ReadData( const Any* pValues )
+{
+    if( pValues[0].hasValue() ) SetMarkedHitMovesAlways( *o3tl::doAccess<bool>(pValues[ 0 ]) );
+    if( pValues[1].hasValue() ) SetCrookNoContortion( *o3tl::doAccess<bool>(pValues[ 1 ]) );
+    if( pValues[2].hasValue() ) SetQuickEdit( *o3tl::doAccess<bool>(pValues[ 2 ]) );
+    if( pValues[3].hasValue() ) SetMasterPagePaintCaching( *o3tl::doAccess<bool>(pValues[ 3 ]) );
+    if( pValues[4].hasValue() ) SetDragWithCopy( *o3tl::doAccess<bool>(pValues[ 4 ]) );
+    if( pValues[5].hasValue() ) SetPickThrough( *o3tl::doAccess<bool>(pValues[ 5 ]) );
+    if( pValues[6].hasValue() ) SetDoubleClickTextEdit( *o3tl::doAccess<bool>(pValues[ 6 ]) );
+    if( pValues[7].hasValue() ) SetClickChangeRotation( *o3tl::doAccess<bool>(pValues[ 7 ]) );
+    if( pValues[9].hasValue() ) SetSolidDragging( *o3tl::doAccess<bool>(pValues[ 9 ]) );
+    if( pValues[10].hasValue() ) SetDefaultObjectSizeWidth( *o3tl::doAccess<sal_Int32>(pValues[ 10 ]) );
+    if( pValues[11].hasValue() ) SetDefaultObjectSizeHeight( *o3tl::doAccess<sal_Int32>(pValues[ 11 ]) );
+    if( pValues[12].hasValue() ) SetPrinterIndependentLayout( *o3tl::doAccess<sal_uInt16>(pValues[ 12 ]) );
+
+    if( pValues[13].hasValue() )
+        SetShowComments(  *o3tl::doAccess<bool>(pValues[ 13 ]) );
+
+    // just for Impress
+    if (IsImpress())
+    {
+        if( pValues[14].hasValue() )
+            SetStartWithTemplate( *o3tl::doAccess<bool>(pValues[ 14 ]) );
+        if( pValues[15].hasValue() )
+            SetSummationOfParagraphs( *o3tl::doAccess<bool>(pValues[ 15 ]) );
+        if( pValues[16].hasValue() )
+            SetShowUndoDeleteWarning( *o3tl::doAccess<bool>(pValues[ 16 ]) );
+
+        if( pValues[17].hasValue() )
+            SetSlideshowRespectZOrder(*o3tl::doAccess<bool>(pValues[ 17 ]));
+
+        if( pValues[18].hasValue() )
+            SetPreviewNewEffects(*o3tl::doAccess<bool>(pValues[ 18 ]));
+
+        if( pValues[19].hasValue() )
+            SetPreviewChangedEffects(*o3tl::doAccess<bool>(pValues[ 19 ]));
+
+        if( pValues[20].hasValue() )
+            SetPreviewTransitions(*o3tl::doAccess<bool>(pValues[ 20 ]));
+
+        if( pValues[21].hasValue() )
+            SetDisplay(*o3tl::doAccess<sal_Int32>(pValues[ 21 ]));
+
+        if( pValues[22].hasValue() )
+            SetPresentationPenColor( getSafeValue< sal_Int32 >( pValues[ 22 ] ) );
+
+        if( pValues[23].hasValue() )
+            SetPresentationPenWidth( getSafeValue< double >( pValues[ 23 ] ) );
+
+        if( pValues[24].hasValue() )
+            SetEnableSdremote( *o3tl::doAccess<bool>(pValues[ 24 ]) );
+
+        if( pValues[25].hasValue() )
+            SetEnablePresenterScreen( *o3tl::doAccess<bool>(pValues[ 25 ]) );
+
+        if( pValues[26].hasValue() ) {
+            SetTabBarVisible( *o3tl::doAccess<bool>(pValues[ 26 ]) );
+        }
+    }
+
+    return true;
+}
+
+bool SdOptionsMisc::WriteData( Any* pValues ) const
+{
+    pValues[ 0 ] <<= IsMarkedHitMovesAlways();
+    pValues[ 1 ] <<= IsCrookNoContortion();
+    pValues[ 2 ] <<= IsQuickEdit();
+    pValues[ 3 ] <<= IsMasterPagePaintCaching();
+    pValues[ 4 ] <<= IsDragWithCopy();
+    pValues[ 5 ] <<= IsPickThrough();
+    pValues[ 6 ] <<= IsDoubleClickTextEdit();
+    pValues[ 7 ] <<= IsClickChangeRotation();
+    // The preview is not supported anymore.  Use a dummy value.
+    pValues[ 8 ] <<= double(0);// GetPreviewQuality();
+    pValues[ 9 ] <<= IsSolidDragging();
+    pValues[ 10 ] <<= GetDefaultObjectSizeWidth();
+    pValues[ 11 ] <<= GetDefaultObjectSizeHeight();
+    pValues[ 12 ] <<= GetPrinterIndependentLayout();
+    pValues[ 13 ] <<= IsShowComments();
+
+    // just for Impress
+    if (IsImpress())
+    {
+        pValues[ 14 ] <<= IsStartWithTemplate();
+        pValues[ 15 ] <<= IsSummationOfParagraphs();
+        pValues[ 16 ] <<= IsShowUndoDeleteWarning();
+        pValues[ 17 ] <<= IsSlideshowRespectZOrder();
+
+        pValues[ 18 ] <<= IsPreviewNewEffects();
+        pValues[ 19 ] <<= IsPreviewChangedEffects();
+        pValues[ 20 ] <<= IsPreviewTransitions();
+
+        pValues[ 21 ] <<= GetDisplay();
+
+        pValues[ 22 ] <<= GetPresentationPenColor();
+        pValues[ 23 ] <<= GetPresentationPenWidth();
+        pValues[ 24 ] <<= IsEnableSdremote();
+        pValues[ 25 ] <<= IsEnablePresenterScreen();
+        pValues[ 26 ] <<= IsTabBarVisible();
+    }
+
+    return true;
+}
+
+/*************************************************************************
+|*
+|* SdOptionsMiscItem
+|*
+\************************************************************************/
+
+SdOptionsMiscItem::SdOptionsMiscItem()
+:   SfxPoolItem     ( ATTR_OPTIONS_MISC )
+,   maOptionsMisc   ( false, false )
+{
+}
+
+SdOptionsMiscItem::SdOptionsMiscItem( SdOptions const * pOpts, ::sd::FrameView const * pView )
+:   SfxPoolItem     ( ATTR_OPTIONS_MISC )
+,   maOptionsMisc   ( false, false )
+{
+    if( pOpts )
+    {
+        maOptionsMisc.SetStartWithTemplate( pOpts->IsStartWithTemplate() );
+        maOptionsMisc.SetEnableSdremote( pOpts->IsEnableSdremote() );
+        maOptionsMisc.SetEnablePresenterScreen( pOpts->IsEnablePresenterScreen() );
+        maOptionsMisc.SetSummationOfParagraphs( pOpts->IsSummationOfParagraphs() );
+        maOptionsMisc.SetTabBarVisible( pOpts->IsTabBarVisible() );
+        maOptionsMisc.SetShowUndoDeleteWarning( pOpts->IsShowUndoDeleteWarning() );
+        maOptionsMisc.SetPrinterIndependentLayout( pOpts->GetPrinterIndependentLayout() );
+        maOptionsMisc.SetDefaultObjectSizeWidth( pOpts->GetDefaultObjectSizeWidth() );
+        maOptionsMisc.SetDefaultObjectSizeHeight( pOpts->GetDefaultObjectSizeHeight() );
+
+        maOptionsMisc.SetPreviewNewEffects(pOpts->IsPreviewNewEffects());
+        maOptionsMisc.SetPreviewChangedEffects(pOpts->IsPreviewChangedEffects());
+        maOptionsMisc.SetPreviewTransitions(pOpts->IsPreviewTransitions());
+
+        maOptionsMisc.SetDisplay(pOpts->GetDisplay());
+        maOptionsMisc.SetShowComments( pOpts->IsShowComments() );
+
+        maOptionsMisc.SetPresentationPenColor(pOpts->GetPresentationPenColor() );
+        maOptionsMisc.SetPresentationPenWidth(pOpts->GetPresentationPenWidth() );
+    }
+
+    if( pView )
+    {
+        maOptionsMisc.SetMarkedHitMovesAlways( pView->IsMarkedHitMovesAlways() );
+        maOptionsMisc.SetMoveOnlyDragging( pView->IsMoveOnlyDragging() );
+        maOptionsMisc.SetCrookNoContortion( pView->IsCrookNoContortion() );
+        maOptionsMisc.SetQuickEdit( pView->IsQuickEdit() );
+
+        // #i26631#
+        maOptionsMisc.SetMasterPagePaintCaching( pView->IsMasterPagePaintCaching() );
+
+        maOptionsMisc.SetDragWithCopy( pView->IsDragWithCopy() );
+        maOptionsMisc.SetPickThrough( pView->GetModel()->IsPickThroughTransparentTextFrames() );
+        maOptionsMisc.SetDoubleClickTextEdit( pView->IsDoubleClickTextEdit() );
+        maOptionsMisc.SetClickChangeRotation( pView->IsClickChangeRotation() );
+        maOptionsMisc.SetSolidDragging( pView->IsSolidDragging() );
+    }
+    else if( pOpts )
+    {
+        maOptionsMisc.SetMarkedHitMovesAlways( pOpts->IsMarkedHitMovesAlways() );
+        maOptionsMisc.SetMoveOnlyDragging( pOpts->IsMoveOnlyDragging() );
+        maOptionsMisc.SetCrookNoContortion( pOpts->IsCrookNoContortion() );
+        maOptionsMisc.SetQuickEdit( pOpts->IsQuickEdit() );
+        maOptionsMisc.SetMasterPagePaintCaching( pOpts->IsMasterPagePaintCaching() );
+        maOptionsMisc.SetDragWithCopy( pOpts->IsDragWithCopy() );
+        maOptionsMisc.SetPickThrough( pOpts->IsPickThrough() );
+        maOptionsMisc.SetDoubleClickTextEdit( pOpts->IsDoubleClickTextEdit() );
+        maOptionsMisc.SetClickChangeRotation( pOpts->IsClickChangeRotation() );
+        maOptionsMisc.SetSolidDragging( pOpts->IsSolidDragging() );
+    }
+}
+
+SdOptionsMiscItem* SdOptionsMiscItem::Clone( SfxItemPool* ) const
+{
+    return new SdOptionsMiscItem( *this );
+}
+
+bool SdOptionsMiscItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    assert(SfxPoolItem::operator==(rAttr));
+    return maOptionsMisc == static_cast<const SdOptionsMiscItem&>(rAttr).maOptionsMisc;
+}
+
+void SdOptionsMiscItem::SetOptions( SdOptions* pOpts ) const
+{
+    if( !pOpts )
+        return;
+
+    pOpts->SetStartWithTemplate( maOptionsMisc.IsStartWithTemplate() );
+    pOpts->SetMarkedHitMovesAlways( maOptionsMisc.IsMarkedHitMovesAlways() );
+    pOpts->SetMoveOnlyDragging( maOptionsMisc.IsMoveOnlyDragging() );
+    pOpts->SetCrookNoContortion( maOptionsMisc.IsCrookNoContortion() );
+    pOpts->SetQuickEdit( maOptionsMisc.IsQuickEdit() );
+    pOpts->SetMasterPagePaintCaching( maOptionsMisc.IsMasterPagePaintCaching() );
+    pOpts->SetDragWithCopy( maOptionsMisc.IsDragWithCopy() );
+    pOpts->SetPickThrough( maOptionsMisc.IsPickThrough() );
+    pOpts->SetDoubleClickTextEdit( maOptionsMisc.IsDoubleClickTextEdit() );
+    pOpts->SetClickChangeRotation( maOptionsMisc.IsClickChangeRotation() );
+    pOpts->SetEnableSdremote( maOptionsMisc.IsEnableSdremote() );
+    pOpts->SetEnablePresenterScreen( maOptionsMisc.IsEnablePresenterScreen() );
+    pOpts->SetSummationOfParagraphs( maOptionsMisc.IsSummationOfParagraphs() );
+    pOpts->SetTabBarVisible( maOptionsMisc.IsTabBarVisible() );
+
+    pOpts->SetSolidDragging( maOptionsMisc.IsSolidDragging() );
+    pOpts->SetShowUndoDeleteWarning( maOptionsMisc.IsShowUndoDeleteWarning() );
+    pOpts->SetPrinterIndependentLayout( maOptionsMisc.GetPrinterIndependentLayout() );
+    pOpts->SetShowComments( maOptionsMisc.IsShowComments() );
+    pOpts->SetDefaultObjectSizeWidth( maOptionsMisc.GetDefaultObjectSizeWidth() );
+    pOpts->SetDefaultObjectSizeHeight( maOptionsMisc.GetDefaultObjectSizeHeight() );
+
+    pOpts->SetPreviewNewEffects( maOptionsMisc.IsPreviewNewEffects() );
+    pOpts->SetPreviewChangedEffects( maOptionsMisc.IsPreviewChangedEffects() );
+    pOpts->SetPreviewTransitions( maOptionsMisc.IsPreviewTransitions() );
+
+    pOpts->SetDisplay( maOptionsMisc.GetDisplay() );
+
+    pOpts->SetPresentationPenColor( maOptionsMisc.GetPresentationPenColor() );
+    pOpts->SetPresentationPenWidth( maOptionsMisc.GetPresentationPenWidth() );
+}
+
+/*************************************************************************
+|*
+|* SdOptionsSnap
+|*
+\************************************************************************/
+
+SdOptionsSnap::SdOptionsSnap( bool bImpress, bool bUseConfig ) :
+    SdOptionsGeneric( bImpress, bUseConfig ?
+                      ( bImpress ?
+                        OUString( "Office.Impress/Snap" ) :
+                        OUString( "Office.Draw/Snap" ) ) :
+                      OUString() ),
+    bSnapHelplines( true ),
+    bSnapBorder( true ),
+    bSnapFrame( false ),
+    bSnapPoints( false ),
+    bOrtho( false ),
+    bBigOrtho( true ),
+    bRotate( false ),
+    nSnapArea( 5 ),
+    nAngle( 1500 ),
+    nBezAngle( 1500 )
+
+{
+    EnableModify( true );
+}
+
+bool SdOptionsSnap::operator==( const SdOptionsSnap& rOpt ) const
+{
+    return( IsSnapHelplines() == rOpt.IsSnapHelplines() &&
+            IsSnapBorder() == rOpt.IsSnapBorder() &&
+            IsSnapFrame() == rOpt.IsSnapFrame() &&
+            IsSnapPoints() == rOpt.IsSnapPoints() &&
+            IsOrtho() == rOpt.IsOrtho() &&
+            IsBigOrtho() == rOpt.IsBigOrtho() &&
+            IsRotate() == rOpt.IsRotate() &&
+            GetSnapArea() == rOpt.GetSnapArea() &&
+            GetAngle() == rOpt.GetAngle() &&
+            GetEliminatePolyPointLimitAngle() == rOpt.GetEliminatePolyPointLimitAngle() );
+}
+
+void SdOptionsSnap::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
+{
+    static const char* aPropNames[] =
+    {
+        "Object/SnapLine",
+        "Object/PageMargin",
+        "Object/ObjectFrame",
+        "Object/ObjectPoint",
+        "Position/CreatingMoving",
+        "Position/ExtendEdges",
+        "Position/Rotating",
+        "Object/Range",
+        "Position/RotatingValue",
+        "Position/PointReduction"
+    };
+
+    rCount = SAL_N_ELEMENTS(aPropNames);
+    ppNames = aPropNames;
+}
+
+bool SdOptionsSnap::ReadData( const Any* pValues )
+{
+    if( pValues[0].hasValue() ) SetSnapHelplines( *o3tl::doAccess<bool>(pValues[ 0 ]) );
+    if( pValues[1].hasValue() ) SetSnapBorder( *o3tl::doAccess<bool>(pValues[ 1 ]) );
+    if( pValues[2].hasValue() ) SetSnapFrame( *o3tl::doAccess<bool>(pValues[ 2 ]) );
+    if( pValues[3].hasValue() ) SetSnapPoints( *o3tl::doAccess<bool>(pValues[ 3 ]) );
+    if( pValues[4].hasValue() ) SetOrtho( *o3tl::doAccess<bool>(pValues[ 4 ]) );
+    if( pValues[5].hasValue() ) SetBigOrtho( *o3tl::doAccess<bool>(pValues[ 5 ]) );
+    if( pValues[6].hasValue() ) SetRotate( *o3tl::doAccess<bool>(pValues[ 6 ]) );
+    if( pValues[7].hasValue() ) SetSnapArea( static_cast<sal_Int16>(*o3tl::doAccess<sal_Int32>(pValues[ 7 ])) );
+    if( pValues[8].hasValue() ) SetAngle( Degree100(*o3tl::doAccess<sal_Int32>(pValues[ 8 ])) );
+    if( pValues[9].hasValue() ) SetEliminatePolyPointLimitAngle( Degree100(*o3tl::doAccess<sal_Int32>(pValues[ 9 ])) );
+
+    return true;
+}
+
+bool SdOptionsSnap::WriteData( Any* pValues ) const
+{
+    pValues[ 0 ] <<= IsSnapHelplines();
+    pValues[ 1 ] <<= IsSnapBorder();
+    pValues[ 2 ] <<= IsSnapFrame();
+    pValues[ 3 ] <<= IsSnapPoints();
+    pValues[ 4 ] <<= IsOrtho();
+    pValues[ 5 ] <<= IsBigOrtho();
+    pValues[ 6 ] <<= IsRotate();
+    pValues[ 7 ] <<= static_cast<sal_Int32>(GetSnapArea());
+    pValues[ 8 ] <<= static_cast<sal_Int32>(GetAngle().get());
+    pValues[ 9 ] <<= static_cast<sal_Int32>(GetEliminatePolyPointLimitAngle().get());
+
+    return true;
+}
+
+/*************************************************************************
+|*
+|* SdOptionsSnapItem
+|*
+\************************************************************************/
+
+SdOptionsSnapItem::SdOptionsSnapItem()
+:   SfxPoolItem     ( ATTR_OPTIONS_SNAP )
+,   maOptionsSnap   ( false, false )
+{
+}
+
+SdOptionsSnapItem::SdOptionsSnapItem( SdOptions const * pOpts, ::sd::FrameView const * pView )
+:   SfxPoolItem     ( ATTR_OPTIONS_SNAP )
+,   maOptionsSnap   ( false, false )
+{
+    if( pView )
+    {
+        maOptionsSnap.SetSnapHelplines( pView->IsHlplSnap() );
+        maOptionsSnap.SetSnapBorder( pView->IsBordSnap() );
+        maOptionsSnap.SetSnapFrame( pView->IsOFrmSnap() );
+        maOptionsSnap.SetSnapPoints( pView->IsOPntSnap() );
+        maOptionsSnap.SetOrtho( pView->IsOrtho() );
+        maOptionsSnap.SetBigOrtho( pView->IsBigOrtho() );
+        maOptionsSnap.SetRotate( pView->IsAngleSnapEnabled() );
+        maOptionsSnap.SetSnapArea( pView->GetSnapMagneticPixel() );
+        maOptionsSnap.SetAngle( pView->GetSnapAngle() );
+        maOptionsSnap.SetEliminatePolyPointLimitAngle( pView->GetEliminatePolyPointLimitAngle() );
+    }
+    else if( pOpts )
+    {
+        maOptionsSnap.SetSnapHelplines( pOpts->IsSnapHelplines() );
+        maOptionsSnap.SetSnapBorder( pOpts->IsSnapBorder() );
+        maOptionsSnap.SetSnapFrame( pOpts->IsSnapFrame() );
+        maOptionsSnap.SetSnapPoints( pOpts->IsSnapPoints() );
+        maOptionsSnap.SetOrtho( pOpts->IsOrtho() );
+        maOptionsSnap.SetBigOrtho( pOpts->IsBigOrtho() );
+        maOptionsSnap.SetRotate( pOpts->IsRotate() );
+        maOptionsSnap.SetSnapArea( pOpts->GetSnapArea() );
+        maOptionsSnap.SetAngle( pOpts->GetAngle() );
+        maOptionsSnap.SetEliminatePolyPointLimitAngle( pOpts->GetEliminatePolyPointLimitAngle() );
+    }
+}
+
+SdOptionsSnapItem* SdOptionsSnapItem::Clone( SfxItemPool* ) const
+{
+    return new SdOptionsSnapItem( *this );
+}
+
+bool SdOptionsSnapItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    assert(SfxPoolItem::operator==(rAttr));
+    return maOptionsSnap == static_cast<const SdOptionsSnapItem&>(rAttr).maOptionsSnap;
+}
+
+void SdOptionsSnapItem::SetOptions( SdOptions* pOpts ) const
+{
+    if( !pOpts )
+        return;
+
+    pOpts->SetSnapHelplines( maOptionsSnap.IsSnapHelplines() );
+    pOpts->SetSnapBorder( maOptionsSnap.IsSnapBorder() );
+    pOpts->SetSnapFrame( maOptionsSnap.IsSnapFrame() );
+    pOpts->SetSnapPoints( maOptionsSnap.IsSnapPoints() );
+    pOpts->SetOrtho( maOptionsSnap.IsOrtho() );
+    pOpts->SetBigOrtho( maOptionsSnap.IsBigOrtho() );
+    pOpts->SetRotate( maOptionsSnap.IsRotate() );
+    pOpts->SetSnapArea( maOptionsSnap.GetSnapArea() );
+    pOpts->SetAngle( maOptionsSnap.GetAngle() );
+    pOpts->SetEliminatePolyPointLimitAngle( maOptionsSnap.GetEliminatePolyPointLimitAngle() );
+}
+
+/*************************************************************************
+|*
+|* SdOptionsZoom
+|*
+\************************************************************************/
+
+SdOptionsZoom::SdOptionsZoom( bool bImpress ) :
+    SdOptionsGeneric( bImpress, bImpress ?
+                                 OUString() :
+                                 OUString("Office.Draw/Zoom") ),
+    nX( 1 ),
+    nY( 1 )
+
+{
+    EnableModify( true );
+}
+
+void SdOptionsZoom::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
+{
+    static const char* aPropNames[] =
+    {
+        "ScaleX",
+        "ScaleY"
+    };
+
+    rCount = !IsImpress() ? SAL_N_ELEMENTS(aPropNames) : 0;
+    ppNames = aPropNames;
+}
+
+bool SdOptionsZoom::ReadData( const Any* pValues )
+{
+    sal_Int32 x = 1, y = 1;
+
+    if( pValues[0].hasValue() ) x = *o3tl::doAccess<sal_Int32>(pValues[ 0 ]);
+    if( pValues[1].hasValue() ) y = *o3tl::doAccess<sal_Int32>(pValues[ 1 ]);
+
+    SetScale( x, y );
+
+    return true;
+}
+
+bool SdOptionsZoom::WriteData( Any* pValues ) const
+{
+    sal_Int32 x, y;
+
+    GetScale( x, y );
+
+    pValues[ 0 ] <<= x;
+    pValues[ 1 ] <<= y;
+
+    return true;
+}
+
+/*************************************************************************
+|*
+|* SdOptionsGrid
+|*
+\************************************************************************/
+
+SdOptionsGrid::SdOptionsGrid(bool bImpress) :
+    SdOptionsGeneric( bImpress,
+                      bImpress ?
+                        OUString( "Office.Impress/Grid" ) :
+                        OUString( "Office.Draw/Grid" )
+                    )
+{
+    EnableModify( false );
+    SetDefaults();
+    EnableModify( true );
+}
+
+SdOptionsGrid::~SdOptionsGrid()
+{
+}
+
+void SdOptionsGrid::SetDefaults()
+{
+    const sal_uInt32 nVal = 1000;
+
+    SetFieldDivisionX( nVal );
+    SetFieldDivisionY( nVal );
+    SetFieldDrawX( nVal );
+    SetFieldDrawY( nVal );
+    SetFieldSnapX( nVal );
+    SetFieldSnapY( nVal );
+    SetUseGridSnap( false );
+    SetSynchronize( true );
+    SetGridVisible( false );
+    SetEqualGrid( true );
+}
+
+void SdOptionsGrid::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
+{
+    if( isMetricSystem() )
+    {
+        static const char* aPropNamesMetric[] =
+        {
+            "Resolution/XAxis/Metric",
+            "Resolution/YAxis/Metric",
+            "Subdivision/XAxis",
+            "Subdivision/YAxis",
+            "SnapGrid/XAxis/Metric",
+            "SnapGrid/YAxis/Metric",
+            "Option/SnapToGrid",
+            "Option/Synchronize",
+            "Option/VisibleGrid",
+            "SnapGrid/Size"
+        };
+        ppNames = aPropNamesMetric;
+        rCount = SAL_N_ELEMENTS(aPropNamesMetric);
+    }
+    else
+    {
+        static const char* aPropNamesNonMetric[] =
+        {
+            "Resolution/XAxis/NonMetric",
+            "Resolution/YAxis/NonMetric",
+            "Subdivision/XAxis",
+            "Subdivision/YAxis",
+            "SnapGrid/XAxis/NonMetric",
+            "SnapGrid/YAxis/NonMetric",
+            "Option/SnapToGrid",
+            "Option/Synchronize",
+            "Option/VisibleGrid",
+            "SnapGrid/Size"
+        };
+        ppNames = aPropNamesNonMetric;
+        rCount = SAL_N_ELEMENTS(aPropNamesNonMetric);
+    }
+}
+
+bool SdOptionsGrid::ReadData( const Any* pValues )
+{
+    if( pValues[0].hasValue() ) SetFieldDrawX( *o3tl::doAccess<sal_Int32>(pValues[ 0 ]) );
+    if( pValues[1].hasValue() ) SetFieldDrawY( *o3tl::doAccess<sal_Int32>(pValues[ 1 ]) );
+
+    if( pValues[2].hasValue() )
+    {
+        const sal_uInt32 nDivX = FRound( *o3tl::doAccess<double>(pValues[ 2 ]) );
+        SetFieldDivisionX( SvxOptionsGrid::GetFieldDrawX() / ( nDivX + 1 ) );
+    }
+
+    if( pValues[3].hasValue() )
+    {
+        const sal_uInt32 nDivY = FRound( *o3tl::doAccess<double>(pValues[ 3 ]) );
+        SetFieldDivisionY( SvxOptionsGrid::GetFieldDrawY() / ( nDivY + 1 ) );
+    }
+
+    if( pValues[4].hasValue() ) SetFieldSnapX( *o3tl::doAccess<sal_Int32>(pValues[ 4 ]) );
+    if( pValues[5].hasValue() ) SetFieldSnapY( *o3tl::doAccess<sal_Int32>(pValues[ 5 ]) );
+    if( pValues[6].hasValue() ) SetUseGridSnap( *o3tl::doAccess<bool>(pValues[ 6 ]) );
+    if( pValues[7].hasValue() ) SetSynchronize( *o3tl::doAccess<bool>(pValues[ 7 ]) );
+    if( pValues[8].hasValue() ) SetGridVisible( *o3tl::doAccess<bool>(pValues[ 8 ]) );
+    if( pValues[9].hasValue() ) SetEqualGrid( *o3tl::doAccess<bool>(pValues[ 9 ]) );
+
+    return true;
+}
+
+bool SdOptionsGrid::WriteData( Any* pValues ) const
+{
+    pValues[ 0 ] <<= static_cast<sal_Int32>(GetFieldDrawX());
+    pValues[ 1 ] <<= static_cast<sal_Int32>(GetFieldDrawY());
+    pValues[ 2 ] <<= ( GetFieldDivisionX() ? ( static_cast<double>(GetFieldDrawX()) / GetFieldDivisionX() - 1.0 ) : double(0) );
+    pValues[ 3 ] <<= ( GetFieldDivisionY() ? ( static_cast<double>(GetFieldDrawY()) / GetFieldDivisionY() - 1.0 ) : double(0) );
+    pValues[ 4 ] <<= static_cast<sal_Int32>(GetFieldSnapX());
+    pValues[ 5 ] <<= static_cast<sal_Int32>(GetFieldSnapY());
+    pValues[ 6 ] <<= IsUseGridSnap();
+    pValues[ 7 ] <<= IsSynchronize();
+    pValues[ 8 ] <<= IsGridVisible();
+    pValues[ 9 ] <<= IsEqualGrid();
+
+    return true;
+}
+
+/*************************************************************************
+|*
+|* SdOptionsGridItem
+|*
+\************************************************************************/
+
+SdOptionsGridItem::SdOptionsGridItem( SdOptions const * pOpts ) :
+    SvxGridItem( SID_ATTR_GRID_OPTIONS )
+{
+    SetSynchronize( pOpts->IsSynchronize() );
+    SetEqualGrid( pOpts->IsEqualGrid() );
+
+    SetFieldDrawX( pOpts->GetFieldDrawX() );
+    SetFieldDrawY( pOpts->GetFieldDrawY() );
+    SetFieldDivisionX( pOpts->GetFieldDivisionX() ? ( pOpts->GetFieldDrawX() / pOpts->GetFieldDivisionX() - 1 ) : 0 );
+    SetFieldDivisionY( pOpts->GetFieldDivisionY() ? ( pOpts->GetFieldDrawY() / pOpts->GetFieldDivisionY() - 1 ) : 0 );
+    SetFieldSnapX( pOpts->GetFieldSnapX() );
+    SetFieldSnapY( pOpts->GetFieldSnapY() );
+    SetUseGridSnap( pOpts->IsUseGridSnap() );
+    SetGridVisible( pOpts->IsGridVisible() );
+}
+
+void SdOptionsGridItem::SetOptions( SdOptions* pOpts ) const
+{
+    pOpts->SetFieldDrawX( GetFieldDrawX() );
+    pOpts->SetFieldDivisionX( GetFieldDrawX() / ( GetFieldDivisionX() + 1 ) );
+    pOpts->SetFieldDrawY( GetFieldDrawY() );
+    pOpts->SetFieldDivisionY( GetFieldDrawY() / ( GetFieldDivisionY() + 1 ) );
+    pOpts->SetFieldSnapX( GetFieldSnapX() );
+    pOpts->SetFieldSnapY( GetFieldSnapY() );
+    pOpts->SetUseGridSnap( GetUseGridSnap() );
+    pOpts->SetSynchronize( GetSynchronize() );
+    pOpts->SetGridVisible( GetGridVisible() );
+    pOpts->SetEqualGrid( GetEqualGrid() );
+}
+
+/*************************************************************************
+|*
+|* SdOptionsPrint
+|*
+\************************************************************************/
+
+SdOptionsPrint::SdOptionsPrint( bool bImpress, bool bUseConfig ) :
+    SdOptionsGeneric( bImpress, bUseConfig ?
+                      ( bImpress ?
+                        OUString( "Office.Impress/Print" ) :
+                        OUString( "Office.Draw/Print" ) ) :
+                      OUString() ),
+    bDraw( true ),
+    bNotes( false ),
+    bHandout( false ),
+    bOutline( false ),
+    bDate( false ),
+    bTime( false ),
+    bPagename( false ),
+    bHiddenPages( true ),
+    bPagesize( false ),
+    bPagetile( false ),
+    bWarningPrinter( true ),
+    bWarningSize( false ),
+    bWarningOrientation( false ),
+    bBooklet( false ),
+    bFront( true ),
+    bBack( true ),
+    bCutPage( false ),
+    bPaperbin( false ),
+    mbHandoutHorizontal( true ),
+    mnHandoutPages( 6 ),
+    nQuality( 0 )
+{
+    EnableModify( true );
+}
+
+bool SdOptionsPrint::operator==( const SdOptionsPrint& rOpt ) const
+{
+    return( IsDraw() == rOpt.IsDraw() &&
+            IsNotes() == rOpt.IsNotes() &&
+            IsHandout() == rOpt.IsHandout() &&
+            IsOutline() == rOpt.IsOutline() &&
+            IsDate() == rOpt.IsDate() &&
+            IsTime() == rOpt.IsTime() &&
+            IsPagename() == rOpt.IsPagename() &&
+            IsHiddenPages() == rOpt.IsHiddenPages() &&
+            IsPagesize() == rOpt.IsPagesize() &&
+            IsPagetile() == rOpt.IsPagetile() &&
+            IsWarningPrinter() == rOpt.IsWarningPrinter() &&
+            IsWarningSize() == rOpt.IsWarningSize() &&
+            IsWarningOrientation() == rOpt.IsWarningOrientation() &&
+            IsBooklet() == rOpt.IsBooklet() &&
+            IsFrontPage() == rOpt.IsFrontPage() &&
+            IsBackPage() == rOpt.IsBackPage() &&
+            IsCutPage() == rOpt.IsCutPage() &&
+            IsPaperbin() == rOpt.IsPaperbin() &&
+            GetOutputQuality() == rOpt.GetOutputQuality() &&
+            IsHandoutHorizontal() == rOpt.IsHandoutHorizontal() &&
+            GetHandoutPages() == rOpt.GetHandoutPages() );
+}
+
+void SdOptionsPrint::GetPropNameArray( const char**& ppNames, sal_uLong& rCount ) const
+{
+    if (IsImpress())
+    {
+        static const char* aImpressPropNames[] =
+        {
+            "Other/Date",
+            "Other/Time",
+            "Other/PageName",
+            "Other/HiddenPage",
+            "Page/PageSize",
+            "Page/PageTile",
+            // bWarningPrinter
+            // bWarningSize
+            // bWarningOrientation
+            "Page/Booklet",
+            "Page/BookletFront",
+            "Page/BookletBack",
+            // bCutPage
+            "Other/FromPrinterSetup",
+            "Other/Quality",
+            "Content/Presentation",
+            "Content/Note",
+            "Content/Handout",
+            "Content/Outline",
+            "Other/HandoutHorizontal",
+            "Other/PagesPerHandout"
+        };
+        rCount = SAL_N_ELEMENTS(aImpressPropNames);
+        ppNames = aImpressPropNames;
+    }
+    else
+    {
+        static const char* aDrawPropNames[] =
+        {
+            "Other/Date",
+            "Other/Time",
+            "Other/PageName",
+            "Other/HiddenPage",
+            "Page/PageSize",
+            "Page/PageTile",
+            // bWarningPrinter
+            // bWarningSize
+            // bWarningOrientation
+            "Page/Booklet",
+            "Page/BookletFront",
+            "Page/BookletBack",
+            // bCutPage
+            "Other/FromPrinterSetup",
+            "Other/Quality",
+            "Content/Drawing",
+        };
+        rCount = SAL_N_ELEMENTS(aDrawPropNames);
+        ppNames = aDrawPropNames;
+    }
+}
+
+bool SdOptionsPrint::ReadData( const Any* pValues )
+{
+    if( pValues[0].hasValue() ) SetDate( *o3tl::doAccess<bool>(pValues[ 0 ]) );
+    if( pValues[1].hasValue() ) SetTime( *o3tl::doAccess<bool>(pValues[ 1 ]) );
+    if( pValues[2].hasValue() ) SetPagename( *o3tl::doAccess<bool>(pValues[ 2 ]) );
+    if( pValues[3].hasValue() ) SetHiddenPages( *o3tl::doAccess<bool>(pValues[ 3 ]) );
+    if( pValues[4].hasValue() ) SetPagesize( *o3tl::doAccess<bool>(pValues[ 4 ]) );
+    if( pValues[5].hasValue() ) SetPagetile( *o3tl::doAccess<bool>(pValues[ 5 ]) );
+    if( pValues[6].hasValue() ) SetBooklet( *o3tl::doAccess<bool>(pValues[ 6 ]) );
+    if( pValues[7].hasValue() ) SetFrontPage( *o3tl::doAccess<bool>(pValues[ 7 ]) );
+    if( pValues[8].hasValue() ) SetBackPage( *o3tl::doAccess<bool>(pValues[ 8 ]) );
+    if( pValues[9].hasValue() ) SetPaperbin( *o3tl::doAccess<bool>(pValues[ 9 ]) );
+    if( pValues[10].hasValue() ) SetOutputQuality( static_cast<sal_uInt16>(*o3tl::doAccess<sal_Int32>(pValues[ 10 ])) );
+    if( pValues[11].hasValue() ) SetDraw( *o3tl::doAccess<bool>(pValues[ 11 ]) );
+
+    // just for impress
+    if (IsImpress())
+    {
+        if( pValues[12].hasValue() ) SetNotes( *o3tl::doAccess<bool>(pValues[ 12 ]) );
+        if( pValues[13].hasValue() ) SetHandout( *o3tl::doAccess<bool>(pValues[ 13 ]) );
+        if( pValues[14].hasValue() ) SetOutline( *o3tl::doAccess<bool>(pValues[ 14 ]) );
+        if( pValues[15].hasValue() ) SetHandoutHorizontal( *o3tl::doAccess<bool>(pValues[15]) );
+        if( pValues[16].hasValue() ) SetHandoutPages( static_cast<sal_uInt16>(*o3tl::doAccess<sal_Int32>(pValues[16])) );
+    }
+
+    return true;
+}
+
+bool SdOptionsPrint::WriteData( Any* pValues ) const
+{
+    pValues[ 0 ] <<= IsDate();
+    pValues[ 1 ] <<= IsTime();
+    pValues[ 2 ] <<= IsPagename();
+    pValues[ 3 ] <<= IsHiddenPages();
+    pValues[ 4 ] <<= IsPagesize();
+    pValues[ 5 ] <<= IsPagetile();
+    pValues[ 6 ] <<= IsBooklet();
+    pValues[ 7 ] <<= IsFrontPage();
+    pValues[ 8 ] <<= IsBackPage();
+    pValues[ 9 ] <<= IsPaperbin();
+    pValues[ 10 ] <<= static_cast<sal_Int32>(GetOutputQuality());
+    pValues[ 11 ] <<= IsDraw();
+
+    // just for impress
+    if (IsImpress())
+    {
+        pValues[ 12 ] <<= IsNotes();
+        pValues[ 13 ] <<= IsHandout();
+        pValues[ 14 ] <<= IsOutline();
+        pValues[ 15 ] <<= IsHandoutHorizontal();
+        pValues[ 16 ] <<= GetHandoutPages();
+    }
+
+    return true;
+}
+
+/*************************************************************************
+|*
+|* SdOptionsPrintItem
+|*
+\************************************************************************/
+
+SdOptionsPrintItem::SdOptionsPrintItem()
+:   SfxPoolItem     ( ATTR_OPTIONS_PRINT )
+,   maOptionsPrint  ( false, false )
+{
+}
+
+SdOptionsPrintItem::SdOptionsPrintItem( SdOptions const * pOpts )
+:   SfxPoolItem     ( ATTR_OPTIONS_PRINT )
+,   maOptionsPrint  ( false, false )
+{
+    if( !pOpts )
+        return;
+
+    maOptionsPrint.SetDraw( pOpts->IsDraw() );
+    maOptionsPrint.SetNotes( pOpts->IsNotes() );
+    maOptionsPrint.SetHandout( pOpts->IsHandout() );
+    maOptionsPrint.SetOutline( pOpts->IsOutline() );
+    maOptionsPrint.SetDate( pOpts->IsDate() );
+    maOptionsPrint.SetTime( pOpts->IsTime() );
+    maOptionsPrint.SetPagename( pOpts->IsPagename() );
+    maOptionsPrint.SetHiddenPages( pOpts->IsHiddenPages() );
+    maOptionsPrint.SetPagesize( pOpts->IsPagesize() );
+    maOptionsPrint.SetPagetile( pOpts->IsPagetile() );
+    maOptionsPrint.SetWarningPrinter( pOpts->IsWarningPrinter() );
+    maOptionsPrint.SetWarningSize( pOpts->IsWarningSize() );
+    maOptionsPrint.SetWarningOrientation( pOpts->IsWarningOrientation() );
+    maOptionsPrint.SetBooklet( pOpts->IsBooklet() );
+    maOptionsPrint.SetFrontPage( pOpts->IsFrontPage() );
+    maOptionsPrint.SetBackPage( pOpts->IsBackPage() );
+    maOptionsPrint.SetCutPage( pOpts->IsCutPage() );
+    maOptionsPrint.SetPaperbin( pOpts->IsPaperbin() );
+    maOptionsPrint.SetOutputQuality( pOpts->GetOutputQuality() );
+}
+
+SdOptionsPrintItem* SdOptionsPrintItem::Clone( SfxItemPool* ) const
+{
+    return new SdOptionsPrintItem( *this );
+}
+
+bool SdOptionsPrintItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    assert(SfxPoolItem::operator==(rAttr));
+    return maOptionsPrint == static_cast<const SdOptionsPrintItem&>(rAttr).maOptionsPrint;
+}
+
+void SdOptionsPrintItem::SetOptions( SdOptions* pOpts ) const
+{
+    if( !pOpts )
+        return;
+
+    pOpts->SetDraw( maOptionsPrint.IsDraw() );
+    pOpts->SetNotes( maOptionsPrint.IsNotes() );
+    pOpts->SetHandout( maOptionsPrint.IsHandout() );
+    pOpts->SetOutline( maOptionsPrint.IsOutline() );
+    pOpts->SetDate( maOptionsPrint.IsDate() );
+    pOpts->SetTime( maOptionsPrint.IsTime() );
+    pOpts->SetPagename( maOptionsPrint.IsPagename() );
+    pOpts->SetHiddenPages( maOptionsPrint.IsHiddenPages() );
+    pOpts->SetPagesize( maOptionsPrint.IsPagesize() );
+    pOpts->SetPagetile( maOptionsPrint.IsPagetile() );
+    pOpts->SetWarningPrinter( maOptionsPrint.IsWarningPrinter() );
+    pOpts->SetWarningSize( maOptionsPrint.IsWarningSize() );
+    pOpts->SetWarningOrientation( maOptionsPrint.IsWarningOrientation() );
+    pOpts->SetBooklet( maOptionsPrint.IsBooklet() );
+    pOpts->SetFrontPage( maOptionsPrint.IsFrontPage() );
+    pOpts->SetBackPage( maOptionsPrint.IsBackPage() );
+    pOpts->SetCutPage( maOptionsPrint.IsCutPage() );
+    pOpts->SetPaperbin( maOptionsPrint.IsPaperbin() );
+    pOpts->SetOutputQuality( maOptionsPrint.GetOutputQuality() );
+}
+
+/*************************************************************************
+|*
+|* SdOptions
+|*
+\************************************************************************/
+
+SdOptions::SdOptions(bool bImpress) :
+    SdOptionsLayout( bImpress, true ),
+    SdOptionsContents( bImpress ),
+    SdOptionsMisc( bImpress, true ),
+    SdOptionsSnap( bImpress, true ),
+    SdOptionsZoom( bImpress ),
+    SdOptionsGrid( bImpress ),
+    SdOptionsPrint( bImpress, true )
+{
+}
+
+SdOptions::~SdOptions()
+{
+}
+
+void SdOptions::StoreConfig()
+{
+    SdOptionsLayout::Store();
+    SdOptionsContents::Store();
+    SdOptionsMisc::Store();
+    SdOptionsSnap::Store();
+    SdOptionsZoom::Store();
+    SdOptionsGrid::Store();
+    SdOptionsPrint::Store();
+}
+
+sal_Int32 SdOptionsMisc::GetDisplay() const
+{
+    Init();
+    return mnDisplay;
+}
+
+void SdOptionsMisc::SetDisplay( sal_Int32 nDisplay )
+{
+    if( mnDisplay != nDisplay )
+    {
+        OptionsChanged();
+        mnDisplay = nDisplay;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/scalectrl.cxx b/sd/source/ui/app/scalectrl.cxx
new file mode 100644
index 000000000..0444163b5
--- /dev/null
+++ b/sd/source/ui/app/scalectrl.cxx
@@ -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 .
+ */
+
+#include <scalectrl.hxx>
+
+#include <vcl/commandevent.hxx>
+#include <vcl/status.hxx>
+#include <vcl/weldutils.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <svl/stritem.hxx>
+#include <sfx2/sfxsids.hrc>
+
+#include <ViewShellBase.hxx>
+#include <drawdoc.hxx>
+#include <app.hrc>
+#include <sdresid.hxx>
+#include <strings.hrc>
+
+SFX_IMPL_STATUSBAR_CONTROL(SdScaleControl, SfxStringItem);
+
+// class SdScaleControl ------------------------------------------
+SdScaleControl::SdScaleControl(sal_uInt16 _nSlotId, sal_uInt16 _nId, StatusBar& rStb)
+    : SfxStatusBarControl(_nSlotId, _nId, rStb)
+{
+    GetStatusBar().SetQuickHelpText(GetId(), SdResId(STR_SCALE_TOOLTIP));
+}
+
+SdScaleControl::~SdScaleControl() {}
+
+void SdScaleControl::StateChangedAtStatusBarControl(sal_uInt16 /*nSID*/, SfxItemState eState,
+                                                    const SfxPoolItem* pState)
+{
+    if (eState != SfxItemState::DEFAULT || pState->IsVoidItem())
+        return;
+    auto pStringItem = dynamic_cast<const SfxStringItem*>(pState);
+    GetStatusBar().SetItemText(GetId(), pStringItem->GetValue());
+}
+
+void SdScaleControl::Command(const CommandEvent& rCEvt)
+{
+    if (rCEvt.GetCommand() != CommandEventId::ContextMenu
+        || GetStatusBar().GetItemText(GetId()).isEmpty())
+        return;
+
+    SfxViewFrame* pViewFrame = SfxViewFrame::Current();
+
+    sd::ViewShellBase* pViewShellBase = sd::ViewShellBase::GetViewShellBase(pViewFrame);
+    if (!pViewShellBase)
+        return;
+
+    SdDrawDocument* pDoc = pViewShellBase->GetDocument();
+    if (!pDoc)
+        return;
+
+    std::unique_ptr<weld::Builder> xBuilder(
+        Application::CreateBuilder(nullptr, "modules/simpress/ui/masterpagemenu.ui"));
+    std::unique_ptr<weld::Menu> xPopup(xBuilder->weld_menu("menu"));
+
+    sal_uInt16 aTable[12] = { 1, 2, 4, 5, 8, 10, 16, 20, 30, 40, 50, 100 };
+
+    for (sal_uInt16 i = 11; i > 0; i--)
+        xPopup->append(OUString::number(12 - i), OUString::number(aTable[i]) + ":1");
+    for (sal_uInt16 i = 0; i < 12; i++)
+        xPopup->append(OUString::number(12 + i), "1:" + OUString::number(aTable[i]));
+
+    ::tools::Rectangle aRect(rCEvt.GetMousePosPixel(), Size(1, 1));
+    weld::Window* pParent = weld::GetPopupParent(GetStatusBar(), aRect);
+    OString sResult = xPopup->popup_at_rect(pParent, aRect);
+    if (sResult.isEmpty())
+        return;
+
+    sal_Int32 i = sResult.toUInt32();
+    sal_Int32 nX;
+    sal_Int32 nY;
+    if (i > 11)
+        nX = 1;
+    else
+        nX = aTable[(12 - i) % 12];
+    if (i > 11)
+        nY = aTable[i % 12];
+    else
+        nY = 1;
+    pDoc->SetUIScale(Fraction(nX, nY));
+
+    SfxBindings& pBindings = pViewFrame->GetBindings();
+    pBindings.Invalidate(SID_SCALE); //update statusbar
+    pBindings.Invalidate(SID_ATTR_METRIC); //update sidebar
+    pViewShellBase->UpdateBorder(true); // update ruler
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/sddll.cxx b/sd/source/ui/app/sddll.cxx
new file mode 100644
index 000000000..4e20d0997
--- /dev/null
+++ b/sd/source/ui/app/sddll.cxx
@@ -0,0 +1,269 @@
+/* -*- 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 <avmedia/mediaplayer.hxx>
+#include <avmedia/mediatoolbox.hxx>
+#include <unotools/configmgr.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <svx/fmobjfac.hxx>
+#include <svx/objfac3d.hxx>
+#include <vcl/svapp.hxx>
+
+#include <registerinterfaces.hxx>
+#include <sddll.hxx>
+#include <app.hrc>
+#include <AnimationChildWindow.hxx>
+#include <BezierObjectBar.hxx>
+#include <diactrl.hxx>
+#include <DrawDocShell.hxx>
+#include <FactoryIds.hxx>
+#include <gluectrl.hxx>
+#include <GraphicDocShell.hxx>
+#include <GraphicObjectBar.hxx>
+#include <GraphicViewShell.hxx>
+#include <GraphicViewShellBase.hxx>
+#include <ImpressViewShellBase.hxx>
+#include <PresentationViewShell.hxx>
+#include <PresentationViewShellBase.hxx>
+#include <MediaObjectBar.hxx>
+#include <NavigatorChildWindow.hxx>
+#include <OutlineViewShell.hxx>
+#include <OutlineViewShellBase.hxx>
+#include <PaneChildWindows.hxx>
+#include <SpellDialogChildWindow.hxx>
+#include <SlideSorterViewShell.hxx>
+#include <SlideSorterViewShellBase.hxx>
+#include <SdShapeTypes.hxx>
+#include <TextObjectBar.hxx>
+#include <tmplctrl.hxx>
+#include <scalectrl.hxx>
+
+#include <svx/svxids.hrc>
+#include <svx/bmpmask.hxx>
+#include <svx/clipboardctl.hxx>
+#include <svx/f3dchild.hxx>
+#include <svx/fillctrl.hxx>
+#include <svx/fontwork.hxx>
+#include <svx/formatpaintbrushctrl.hxx>
+#include <svx/grafctrl.hxx>
+#include <svx/hyperdlg.hxx>
+#include <svx/imapdlg.hxx>
+#include <svx/linectrl.hxx>
+#include <svx/modctrl.hxx>
+#include <svx/pszctrl.hxx>
+#include <svx/srchdlg.hxx>
+#include <svx/SvxColorChildWindow.hxx>
+#include <svx/xmlsecctrl.hxx>
+#include <svx/zoomctrl.hxx>
+#include <svx/zoomsliderctrl.hxx>
+#include <svx/tbxctl.hxx>
+#include <sfx2/sidebar/SidebarChildWindow.hxx>
+#include <sfx2/devtools/DevelopmentToolChildWindow.hxx>
+#include <comphelper/lok.hxx>
+#include <sdabstdlg.hxx>
+#include <sdfilter.hxx>
+#include <sdmod.hxx>
+
+using namespace ::com::sun::star;
+
+// Register all Factories
+void SdDLL::RegisterFactorys()
+{
+    if (utl::ConfigManager::IsFuzzing() || SvtModuleOptions().IsImpress())
+    {
+        ::sd::ImpressViewShellBase::RegisterFactory (
+            ::sd::IMPRESS_FACTORY_ID);
+        ::sd::SlideSorterViewShellBase::RegisterFactory (
+            ::sd::SLIDE_SORTER_FACTORY_ID);
+        ::sd::OutlineViewShellBase::RegisterFactory (
+            ::sd::OUTLINE_FACTORY_ID);
+        ::sd::PresentationViewShellBase::RegisterFactory (
+            ::sd::PRESENTATION_FACTORY_ID);
+    }
+    if (!utl::ConfigManager::IsFuzzing() && SvtModuleOptions().IsDraw())
+    {
+        ::sd::GraphicViewShellBase::RegisterFactory (::sd::DRAW_FACTORY_ID);
+    }
+}
+
+// Register all Interfaces
+
+void SdDLL::RegisterInterfaces(const SdModule* pMod)
+{
+    // Module
+    SdModule::RegisterInterface(pMod);
+
+    // View shell base.
+    ::sd::ViewShellBase::RegisterInterface(pMod);
+
+    // DocShells
+    ::sd::DrawDocShell::RegisterInterface(pMod);
+    ::sd::GraphicDocShell::RegisterInterface(pMod);
+
+    // Impress ViewShells
+    ::sd::DrawViewShell::RegisterInterface(pMod);
+    ::sd::OutlineViewShell::RegisterInterface(pMod);
+    ::sd::PresentationViewShell::RegisterInterface(pMod);
+
+    // Draw ViewShell
+    ::sd::GraphicViewShell::RegisterInterface(pMod);
+
+    // Impress ObjectShells
+    ::sd::BezierObjectBar::RegisterInterface(pMod);
+    ::sd::TextObjectBar::RegisterInterface(pMod);
+    ::sd::GraphicObjectBar::RegisterInterface(pMod);
+
+    // Media ObjectShell
+    ::sd::MediaObjectBar::RegisterInterface(pMod);
+
+    // Table ObjectShell
+    ::sd::ui::table::RegisterInterfaces(pMod);
+
+    // View shells for the side panes.
+    ::sd::slidesorter::SlideSorterViewShell::RegisterInterface (pMod);
+}
+
+// Register all Controllers
+
+void SdDLL::RegisterControllers(SdModule* pMod)
+{
+    SdTbxCtlDiaPages::RegisterControl( SID_PAGES_PER_ROW, pMod );
+    SdTbxCtlGlueEscDir::RegisterControl( SID_GLUE_ESCDIR, pMod );
+
+    ::sd::AnimationChildWindow::RegisterChildWindow(false, pMod);
+
+    Svx3DChildWindow::RegisterChildWindow(false, pMod);
+    SvxFontWorkChildWindow::RegisterChildWindow(false, pMod);
+    SvxColorChildWindow::RegisterChildWindow(false, pMod, SfxChildWindowFlags::TASK);
+    SvxSearchDialogWrapper::RegisterChildWindow(false, pMod);
+    SvxBmpMaskChildWindow::RegisterChildWindow(false, pMod);
+    SvxIMapDlgChildWindow::RegisterChildWindow(false, pMod);
+    SvxHlinkDlgWrapper::RegisterChildWindow(false, pMod);
+    ::sd::SpellDialogChildWindow::RegisterChildWindow(
+        false, pMod, comphelper::LibreOfficeKit::isActive() ? SfxChildWindowFlags::NEVERCLONE
+                                                            : SfxChildWindowFlags::NONE);
+#if HAVE_FEATURE_AVMEDIA
+    ::avmedia::MediaPlayer::RegisterChildWindow(false, pMod);
+#endif
+    ::sd::LeftPaneImpressChildWindow::RegisterChildWindow(false, pMod);
+    ::sd::LeftPaneDrawChildWindow::RegisterChildWindow(false, pMod);
+    ::sfx2::sidebar::SidebarChildWindow::RegisterChildWindow(false, pMod);
+    DevelopmentToolChildWindow::RegisterChildWindow(false, pMod);
+
+    ::sd::SdNavigatorWrapper::RegisterChildWindow(false, pMod, SfxChildWindowFlags::NEVERHIDE);
+
+    SvxFillToolBoxControl::RegisterControl(0, pMod);
+    SvxLineWidthToolBoxControl::RegisterControl(0, pMod);
+
+    SvxGrafModeToolBoxControl::RegisterControl( SID_ATTR_GRAF_MODE, pMod );
+    SvxGrafRedToolBoxControl::RegisterControl( SID_ATTR_GRAF_RED, pMod );
+    SvxGrafGreenToolBoxControl::RegisterControl( SID_ATTR_GRAF_GREEN, pMod );
+    SvxGrafBlueToolBoxControl::RegisterControl( SID_ATTR_GRAF_BLUE, pMod );
+    SvxGrafLuminanceToolBoxControl::RegisterControl( SID_ATTR_GRAF_LUMINANCE, pMod );
+    SvxGrafContrastToolBoxControl::RegisterControl( SID_ATTR_GRAF_CONTRAST, pMod );
+    SvxGrafGammaToolBoxControl::RegisterControl( SID_ATTR_GRAF_GAMMA, pMod );
+    SvxGrafTransparenceToolBoxControl::RegisterControl( SID_ATTR_GRAF_TRANSPARENCE, pMod );
+
+    // register StatusBarControls
+    SvxZoomPageStatusBarControl::RegisterControl( SID_ZOOM_ENTIRE_PAGE, pMod );
+    SvxZoomStatusBarControl::RegisterControl( SID_ATTR_ZOOM, pMod );
+    SvxPosSizeStatusBarControl::RegisterControl( SID_ATTR_SIZE, pMod );
+    SvxModifyControl::RegisterControl( SID_DOC_MODIFIED, pMod );
+    SvxZoomSliderControl::RegisterControl( SID_ATTR_ZOOMSLIDER, pMod );
+
+    svx::FormatPaintBrushToolBoxControl::RegisterControl(SID_FORMATPAINTBRUSH, pMod );
+
+    SvxClipBoardControl::RegisterControl( SID_PASTE, pMod );
+    SvxClipBoardControl::RegisterControl( SID_PASTE_UNFORMATTED, pMod );
+
+#if HAVE_FEATURE_AVMEDIA
+    ::avmedia::MediaToolBoxControl::RegisterControl( SID_AVMEDIA_TOOLBOX, pMod );
+#endif
+    XmlSecStatusBarControl::RegisterControl( SID_SIGNATURE, pMod );
+    SdTemplateControl::RegisterControl( SID_STATUS_LAYOUT, pMod );
+    SdScaleControl::RegisterControl( SID_SCALE, pMod );
+    SvxTbxCtlDraw::RegisterControl(SID_INSERT_DRAW, pMod );
+}
+
+void SdDLL::Init()
+{
+    if ( SfxApplication::GetModule(SfxToolsModule::Draw) )    // Module already active
+        return;
+
+    SfxObjectFactory* pDrawFact = nullptr;
+    SfxObjectFactory* pImpressFact = nullptr;
+
+    if (utl::ConfigManager::IsFuzzing() || SvtModuleOptions().IsImpress())
+        pImpressFact = &::sd::DrawDocShell::Factory();
+
+    if (!utl::ConfigManager::IsFuzzing() && SvtModuleOptions().IsDraw())
+        pDrawFact = &::sd::GraphicDocShell::Factory();
+
+    auto pUniqueModule = std::make_unique<SdModule>(pImpressFact, pDrawFact);
+    SdModule* pModule = pUniqueModule.get();
+    SfxApplication::SetModule(SfxToolsModule::Draw, std::move(pUniqueModule));
+
+    if (!utl::ConfigManager::IsFuzzing() && SvtModuleOptions().IsImpress())
+    {
+        // Register the Impress shape types in order to make the shapes accessible.
+        ::accessibility::RegisterImpressShapeTypes ();
+        ::sd::DrawDocShell::Factory().SetDocumentServiceName( "com.sun.star.presentation.PresentationDocument" );
+    }
+
+    if (!utl::ConfigManager::IsFuzzing() && SvtModuleOptions().IsDraw())
+    {
+        ::sd::GraphicDocShell::Factory().SetDocumentServiceName( "com.sun.star.drawing.DrawingDocument" );
+    }
+
+    // register your view-factories here
+    RegisterFactorys();
+
+    // register your shell-interfaces here
+    RegisterInterfaces(pModule);
+
+    // register your controllers here
+    RegisterControllers(pModule);
+
+    // register 3D-object-factory
+    E3dObjFactory();
+
+    // register css::form::component::Form-Object-Factory
+    FmFormObjFactory();
+
+    // register your exotic remote controls here
+#ifdef ENABLE_SDREMOTE
+    if (!utl::ConfigManager::IsFuzzing() && !Application::IsHeadlessModeEnabled())
+        RegisterRemotes();
+#endif
+}
+
+#ifndef DISABLE_DYNLOADING
+
+extern "C" SAL_DLLPUBLIC_EXPORT
+void lok_preload_hook()
+{
+    SdFilter::Preload();
+    SdAbstractDialogFactory::Create();
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/sdmod.cxx b/sd/source/ui/app/sdmod.cxx
new file mode 100644
index 000000000..c7d56831d
--- /dev/null
+++ b/sd/source/ui/app/sdmod.cxx
@@ -0,0 +1,216 @@
+/* -*- 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 <unotools/ucbstreamhelper.hxx>
+#include <unotools/resmgr.hxx>
+#include <tools/urlobj.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/svapp.hxx>
+#include <svl/numformat.hxx>
+#include <svl/intitem.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/objface.hxx>
+#include <comphelper/processfactory.hxx>
+#include <svtools/ehdl.hxx>
+
+#include <svx/svxids.hrc>
+#include <svl/srchitem.hxx>
+#include <svx/svxerr.hxx>
+
+#include <svtools/colorcfg.hxx>
+
+#include <sdmod.hxx>
+#include <sdresid.hxx>
+#include <optsitem.hxx>
+#include <DrawDocShell.hxx>
+#include <drawdoc.hxx>
+#include <errhdl.hrc>
+
+#define ShellClass_SdModule
+#include <sdslots.hxx>
+
+SFX_IMPL_INTERFACE(SdModule, SfxModule)
+
+void SdModule::InitInterface_Impl()
+{
+    GetStaticInterface()->RegisterStatusBar(StatusBarId::DrawStatusBar);
+}
+
+// Ctor
+SdModule::SdModule(SfxObjectFactory* pFact1, SfxObjectFactory* pFact2 )
+:   SfxModule("sd", {pFact1, pFact2}),
+    pTransferClip(nullptr),
+    pTransferDrag(nullptr),
+    pTransferSelection(nullptr),
+    pImpressOptions(nullptr),
+    pDrawOptions(nullptr),
+    bWaterCan(false),
+    mbEventListenerAdded(false),
+    mpColorConfig(new svtools::ColorConfig)
+{
+    SetName( "StarDraw" );  // Do not translate!
+    pSearchItem.reset( new SvxSearchItem(SID_SEARCH_ITEM) );
+    pSearchItem->SetAppFlag(SvxSearchApp::DRAW);
+    StartListening( *SfxGetpApp() );
+    SvxErrorHandler::ensure();
+    mpErrorHdl.reset( new SfxErrorHandler(RID_SD_ERRHDL, ErrCodeArea::Sd, ErrCodeArea::Sd, GetResLocale()) );
+
+    // Create a new ref device and (by calling SetReferenceDevice())
+    // set its resolution to 600 DPI.  This leads to a visually better
+    // formatting of text in small sizes (6 point and below.)
+    mpVirtualRefDevice.reset(VclPtr<VirtualDevice>::Create());
+    mpVirtualRefDevice->SetMapMode(MapMode(MapUnit::Map100thMM));
+    mpVirtualRefDevice->SetReferenceDevice ( VirtualDevice::RefDevMode::Dpi600 );
+}
+
+OUString SdResId(TranslateId aId)
+{
+    return Translate::get(aId, SD_MOD()->GetResLocale());
+}
+
+OUString SdResId(TranslateNId aContextSingularPlural, int nCardinality)
+{
+    return Translate::nget(aContextSingularPlural, nCardinality, SD_MOD()->GetResLocale());
+}
+
+// Dtor
+SdModule::~SdModule()
+{
+    pSearchItem.reset();
+    pNumberFormatter.reset();
+
+    if (mbEventListenerAdded)
+    {
+        Application::RemoveEventListener( LINK( this, SdModule, EventListenerHdl ) );
+    }
+
+    mpErrorHdl.reset();
+    mpVirtualRefDevice.disposeAndClear();
+}
+
+void SdModule::SetSearchItem(std::unique_ptr<SvxSearchItem> pItem)
+{
+    pSearchItem = std::move(pItem);
+}
+
+/// get notifications
+void SdModule::Notify( SfxBroadcaster&, const SfxHint& rHint )
+{
+    if( rHint.GetId() == SfxHintId::Deinitializing )
+    {
+        delete pImpressOptions;
+        pImpressOptions = nullptr;
+        delete pDrawOptions;
+        pDrawOptions = nullptr;
+    }
+}
+
+/// Return options
+SdOptions* SdModule::GetSdOptions(DocumentType eDocType)
+{
+    SdOptions* pOptions = nullptr;
+
+    if (eDocType == DocumentType::Draw)
+    {
+        if (!pDrawOptions)
+            pDrawOptions = new SdOptions(false);
+
+        pOptions = pDrawOptions;
+    }
+    else if (eDocType == DocumentType::Impress)
+    {
+        if (!pImpressOptions)
+            pImpressOptions = new SdOptions(true);
+
+        pOptions = pImpressOptions;
+    }
+    if( pOptions )
+    {
+        sal_uInt16 nMetric = pOptions->GetMetric();
+
+        ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+        SdDrawDocument* pDoc = nullptr;
+        if (pDocSh)
+            pDoc = pDocSh->GetDoc();
+
+        if( nMetric != 0xffff && pDoc && eDocType == pDoc->GetDocumentType() )
+            PutItem( SfxUInt16Item( SID_ATTR_METRIC, nMetric ) );
+    }
+
+    return pOptions;
+}
+
+/**
+ * Open and return option stream for internal options;
+ * if the stream is opened for reading but does not exist, an 'empty'
+ * RefObject is returned
+ */
+tools::SvRef<SotStorageStream> SdModule::GetOptionStream( std::u16string_view rOptionName,
+                                              SdOptionStreamMode eMode )
+{
+    ::sd::DrawDocShell*     pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+    tools::SvRef<SotStorageStream>  xStm;
+
+    if( pDocSh )
+    {
+        DocumentType    eType = pDocSh->GetDoc()->GetDocumentType();
+
+        if( !xOptionStorage.is() )
+        {
+            INetURLObject aURL( SvtPathOptions().GetUserConfigPath() );
+
+            aURL.Append( u"drawing.cfg" );
+
+            std::unique_ptr<SvStream> pStm = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READWRITE );
+
+            if( pStm )
+                xOptionStorage = new SotStorage( pStm.release(), true );
+        }
+
+        OUString        aStmName;
+
+        if( DocumentType::Draw == eType )
+            aStmName = "Draw_";
+        else
+            aStmName = "Impress_";
+
+        aStmName += rOptionName;
+
+        if( SdOptionStreamMode::Store == eMode || xOptionStorage->IsContained( aStmName ) )
+            xStm = xOptionStorage->OpenSotStream( aStmName );
+    }
+
+    return xStm;
+}
+
+SvNumberFormatter* SdModule::GetNumberFormatter()
+{
+    if( !pNumberFormatter )
+        pNumberFormatter.reset( new SvNumberFormatter( ::comphelper::getProcessComponentContext(), LANGUAGE_SYSTEM ) );
+
+    return pNumberFormatter.get();
+}
+
+svtools::ColorConfig& SdModule::GetColorConfig()
+{
+    return *mpColorConfig;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/sdmod1.cxx b/sd/source/ui/app/sdmod1.cxx
new file mode 100644
index 000000000..573ee8530
--- /dev/null
+++ b/sd/source/ui/app/sdmod1.cxx
@@ -0,0 +1,638 @@
+/* -*- 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 <svl/lckbitem.hxx>
+#include <svl/intitem.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <framework/FrameworkHelper.hxx>
+#include <osl/diagnose.h>
+#include <vcl/commandevent.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/errinf.hxx>
+#include <editeng/langitem.hxx>
+#include <vcl/weld.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/templatedlg.hxx>
+#include <editeng/eeitem.hxx>
+
+#include <svx/svxids.hrc>
+#include <strings.hrc>
+
+#include <sdmod.hxx>
+#include <pres.hxx>
+#include <optsitem.hxx>
+#include <ViewShell.hxx>
+#include <DrawDocShell.hxx>
+#include <drawdoc.hxx>
+#include <sdresid.hxx>
+#include <OutlineView.hxx>
+#include <OutlineViewShell.hxx>
+#include <ViewShellBase.hxx>
+#include <FactoryIds.hxx>
+#include <memory>
+#include <slideshow.hxx>
+
+using ::sd::framework::FrameworkHelper;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::frame::XFrame;
+
+namespace {
+
+class OutlineToImpressFinalizer final
+{
+public:
+    OutlineToImpressFinalizer (
+        ::sd::ViewShellBase& rBase,
+        SdDrawDocument& rDocument,
+        SvLockBytes const & rBytes);
+    void operator() (bool bEventSeen);
+private:
+    ::sd::ViewShellBase& mrBase;
+    SdDrawDocument& mrDocument;
+    std::shared_ptr<SvMemoryStream> mpStream;
+};
+
+} //end of anonymous namespace
+
+void SdModule::Execute(SfxRequest& rReq)
+{
+    const SfxItemSet* pSet = rReq.GetArgs();
+    sal_uLong nSlotId = rReq.GetSlot();
+
+    switch ( nSlotId )
+    {
+        case SID_NEWDOC:
+        {
+            SfxGetpApp()->ExecuteSlot(rReq, SfxGetpApp()->GetInterface());
+        }
+        break;
+
+        case SID_AUTOSPELL_CHECK:
+        {
+            // automatic spell checker
+            const SfxBoolItem* pItem;
+            if( pSet && (pItem = pSet->GetItemIfSet( SID_AUTOSPELL_CHECK, false ) ) )
+            {
+                bool bOnlineSpelling = pItem->GetValue();
+                // save at document:
+                ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+                if( pDocSh )
+                {
+                    SdDrawDocument* pDoc = pDocSh->GetDoc();
+                    pDoc->SetOnlineSpell( bOnlineSpelling );
+                }
+            }
+        }
+        break;
+
+        case SID_ATTR_METRIC:
+        {
+            const SfxUInt16Item* pItem;
+            if ( pSet && (pItem = pSet->GetItemIfSet( SID_ATTR_METRIC ) ) )
+            {
+                FieldUnit eUnit = static_cast<FieldUnit>(pItem->GetValue());
+                switch( eUnit )
+                {
+                    case FieldUnit::MM:      // only the units which are also in the dialog
+                    case FieldUnit::CM:
+                    case FieldUnit::INCH:
+                    case FieldUnit::PICA:
+                    case FieldUnit::POINT:
+                        {
+                            ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+                            if(pDocSh)
+                            {
+                                DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
+
+                                PutItem( *pItem );
+                                SdOptions* pOptions = GetSdOptions( eDocType );
+                                if(pOptions)
+                                    pOptions->SetMetric( static_cast<sal_uInt16>(eUnit) );
+                                rReq.Done();
+                            }
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+        }
+        break;
+
+        case SID_ATTR_LANGUAGE:
+        case SID_ATTR_CHAR_CJK_LANGUAGE:
+        case SID_ATTR_CHAR_CTL_LANGUAGE:
+        {
+            const SfxPoolItem* pItem;
+            if( pSet &&
+                (
+                SfxItemState::SET == pSet->GetItemState(SID_ATTR_LANGUAGE, false, &pItem ) ||
+                SfxItemState::SET == pSet->GetItemState(SID_ATTR_CHAR_CJK_LANGUAGE, false, &pItem ) ||
+                SfxItemState::SET == pSet->GetItemState(SID_ATTR_CHAR_CTL_LANGUAGE, false, &pItem )
+                )
+              )
+            {
+                // save at the document:
+                ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+                if ( pDocSh )
+                {
+                    LanguageType eLanguage = static_cast<const SvxLanguageItem*>(pItem)->GetValue();
+                    SdDrawDocument* pDoc = pDocSh->GetDoc();
+
+                    if( nSlotId == sal_uInt16(SID_ATTR_CHAR_CJK_LANGUAGE) )
+                        pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CJK );
+                    else if( nSlotId == sal_uInt16(SID_ATTR_CHAR_CTL_LANGUAGE) )
+                        pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE_CTL );
+                    else
+                        pDoc->SetLanguage( eLanguage, EE_CHAR_LANGUAGE );
+
+                    if( pDoc->GetOnlineSpell() )
+                    {
+                        pDoc->StopOnlineSpelling();
+                        pDoc->StartOnlineSpelling();
+                    }
+                }
+            }
+        }
+        break;
+
+        case SID_NEWSD:
+            {
+                SfxFrame* pFrame = ExecuteNewDocument( rReq );
+                // if a frame was created, set it as return value
+                if(pFrame)
+                    rReq.SetReturnValue(SfxFrameItem(0, pFrame));
+            }
+
+            break;
+
+        case SID_OPENHYPERLINK:
+        case SID_OPENDOC:
+        {
+            bool bIntercept = false;
+            ::sd::DrawDocShell* pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+            if (pDocShell)
+            {
+                ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
+                if (pViewShell)
+                {
+                    if( sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ) )
+                    {
+                        // Prevent documents from opening while the slide
+                        // show is running, except when this request comes
+                        // from a shape interaction.
+                        if (rReq.GetArgs() == nullptr)
+                        {
+                            bIntercept = true;
+                        }
+                    }
+                }
+            }
+
+            if (!bIntercept)
+            {
+                SfxGetpApp()->ExecuteSlot(rReq, SfxGetpApp()->GetInterface());
+            }
+            else
+            {
+                std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(nullptr,
+                                                               VclMessageType::Warning, VclButtonsType::Ok, SdResId(STR_CANT_PERFORM_IN_LIVEMODE)));
+
+                xErrorBox->run();
+
+                const SfxLinkItem* pLinkItem = rReq.GetArg<SfxLinkItem>(SID_DONELINK);
+                if( pLinkItem )
+                    pLinkItem->GetValue().Call( nullptr );
+            }
+        }
+        break;
+
+        case SID_OUTLINE_TO_IMPRESS:
+            OutlineToImpress (rReq);
+            break;
+
+        default:
+        break;
+    }
+}
+
+bool SdModule::OutlineToImpress(SfxRequest const & rRequest)
+{
+    const SfxItemSet* pSet = rRequest.GetArgs();
+
+    if (pSet)
+    {
+        SvLockBytes* pBytes = static_cast<const SfxLockBytesItem&>(pSet->Get(SID_OUTLINE_TO_IMPRESS)).GetValue();
+
+        if (pBytes)
+        {
+            SfxObjectShellLock xDocShell;
+            ::sd::DrawDocShell* pDocSh;
+            xDocShell = pDocSh = new ::sd::DrawDocShell(
+                SfxObjectCreateMode::STANDARD, false, DocumentType::Impress);
+
+            pDocSh->DoInitNew();
+            SdDrawDocument* pDoc = pDocSh->GetDoc();
+            if(pDoc)
+            {
+                pDoc->CreateFirstPages();
+                pDoc->StopWorkStartupDelay();
+            }
+
+            const SfxFrameItem* pFrmItem = rRequest.GetArg<SfxFrameItem>(SID_DOCFRAME);
+            SfxViewFrame::LoadDocumentIntoFrame( *pDocSh, pFrmItem, ::sd::OUTLINE_FACTORY_ID );
+
+            ::sd::ViewShell* pViewSh = pDocSh->GetViewShell();
+
+            if (pViewSh && pDoc)
+            {
+                // AutoLayouts have to be finished
+                pDoc->StopWorkStartupDelay();
+
+                SfxViewFrame* pViewFrame = pViewSh->GetViewFrame();
+
+                // When the view frame has not been just created we have
+                // to switch synchronously to the outline view.
+                // (Otherwise the request will be ignored anyway.)
+                ::sd::ViewShellBase* pBase
+                    = dynamic_cast< ::sd::ViewShellBase*>(pViewFrame->GetViewShell());
+                if (pBase != nullptr)
+                {
+                    std::shared_ptr<FrameworkHelper> pHelper (
+                        FrameworkHelper::Instance(*pBase));
+                    pHelper->RequestView(
+                        FrameworkHelper::msOutlineViewURL,
+                        FrameworkHelper::msCenterPaneURL);
+
+                    pHelper->RunOnResourceActivation(
+                        FrameworkHelper::CreateResourceId(
+                        FrameworkHelper::msOutlineViewURL,
+                        FrameworkHelper::msCenterPaneURL),
+                        OutlineToImpressFinalizer(*pBase, *pDoc, *pBytes));
+                }
+            }
+        }
+    }
+
+    return rRequest.IsDone();
+}
+
+void SdModule::GetState(SfxItemSet& rItemSet)
+{
+    if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_METRIC ) )
+    {
+        ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+        if(pDocSh)
+        {
+            DocumentType eDocType = pDocSh->GetDoc()->GetDocumentType();
+
+            SdOptions* pOptions = GetSdOptions(eDocType);
+            rItemSet.Put( SfxUInt16Item( SID_ATTR_METRIC, pOptions->GetMetric() ) );
+        }
+    }
+
+    // state of SID_OPENDOC is determined by the base class
+    if (rItemSet.GetItemState(SID_OPENDOC) != SfxItemState::UNKNOWN)
+    {
+        const SfxPoolItem* pItem = SfxGetpApp()->GetSlotState(SID_OPENDOC, SfxGetpApp()->GetInterface());
+        if (pItem)
+            rItemSet.Put(*pItem);
+    }
+
+    // state of SID_OPENHYPERLINK is determined by the base class
+    if (rItemSet.GetItemState(SID_OPENHYPERLINK) != SfxItemState::UNKNOWN)
+    {
+        const SfxPoolItem* pItem = SfxGetpApp()->GetSlotState(SID_OPENHYPERLINK, SfxGetpApp()->GetInterface());
+        if (pItem)
+            rItemSet.Put(*pItem);
+    }
+
+    if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_AUTOSPELL_CHECK ) )
+    {
+        ::sd::DrawDocShell* pDocSh =
+              dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+        if( pDocSh )
+        {
+            SdDrawDocument* pDoc = pDocSh->GetDoc();
+            rItemSet.Put( SfxBoolItem( SID_AUTOSPELL_CHECK, pDoc->GetOnlineSpell() ) );
+        }
+    }
+
+    if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_LANGUAGE ) )
+    {
+        ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+        if( pDocSh )
+            rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ), SID_ATTR_LANGUAGE ) );
+    }
+
+    if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_CHAR_CJK_LANGUAGE ) )
+    {
+        ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+        if( pDocSh )
+            rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CJK ), SID_ATTR_CHAR_CJK_LANGUAGE ) );
+    }
+
+    if( SfxItemState::DEFAULT == rItemSet.GetItemState( SID_ATTR_CHAR_CTL_LANGUAGE ) )
+    {
+        ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+        if( pDocSh )
+            rItemSet.Put( SvxLanguageItem( pDocSh->GetDoc()->GetLanguage( EE_CHAR_LANGUAGE_CTL ), SID_ATTR_CHAR_CTL_LANGUAGE ) );
+    }
+
+    if ( mbEventListenerAdded )
+        return;
+
+    ::sd::DrawDocShell* pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+    if( pDocShell ) // Impress or Draw ?
+    {
+        ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
+
+        if( pViewShell && (pDocShell->GetDocumentType() == DocumentType::Impress) )
+        {
+            // add our event listener as soon as possible
+            Application::AddEventListener( LINK( this, SdModule, EventListenerHdl ) );
+            mbEventListenerAdded = true;
+        }
+    }
+}
+
+IMPL_STATIC_LINK( SdModule, EventListenerHdl, VclSimpleEvent&, rSimpleEvent, void )
+{
+    if( !((rSimpleEvent.GetId() == VclEventId::WindowCommand) && static_cast<VclWindowEvent*>(&rSimpleEvent)->GetData()) )
+        return;
+
+    const CommandEvent& rEvent = *static_cast<const CommandEvent*>(static_cast<VclWindowEvent*>(&rSimpleEvent)->GetData());
+
+    if( rEvent.GetCommand() != CommandEventId::Media )
+        return;
+
+    CommandMediaData* pMediaData = rEvent.GetMediaData();
+    pMediaData->SetPassThroughToOS(false);
+    switch (pMediaData->GetMediaId())
+    {
+        case MediaCommand::Play:
+        {
+            ::sd::DrawDocShell* pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+            if( pDocShell )  // Impress or Draw ?
+            {
+                ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
+
+                // #i97925# start the presentation if and only if an Impress document is focused
+                if( pViewShell && (pDocShell->GetDocumentType() == DocumentType::Impress) )
+                    pViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_PRESENTATION );
+            }
+            break;
+        }
+        default:
+            pMediaData->SetPassThroughToOS(true);
+            break;
+    }
+}
+
+
+SfxFrame* SdModule::CreateFromTemplate(const OUString& rTemplatePath, const Reference<XFrame>& i_rFrame,
+                                       const bool bReplaceable)
+{
+    SfxFrame* pFrame = nullptr;
+
+    SfxObjectShellLock xDocShell;
+
+    std::unique_ptr<SfxItemSet> pSet(new SfxAllItemSet( SfxGetpApp()->GetPool() ));
+    pSet->Put( SfxBoolItem( SID_TEMPLATE, true ) );
+
+    ErrCode lErr = SfxGetpApp()->LoadTemplate( xDocShell, rTemplatePath, std::move(pSet) );
+
+    SfxObjectShell* pDocShell = xDocShell;
+
+    if( lErr )
+    {
+        ErrorHandler::HandleError(lErr);
+    }
+    else if( pDocShell )
+    {
+        if (pDocShell->GetMedium() && pDocShell->GetMedium()->GetItemSet())
+            pDocShell->GetMedium()->GetItemSet()->Put(SfxBoolItem(SID_REPLACEABLE, bReplaceable));
+        SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pDocShell, i_rFrame );
+        OSL_ENSURE( pViewFrame, "SdModule::CreateFromTemplate: no view frame - was the document really loaded?" );
+        pFrame = pViewFrame ? &pViewFrame->GetFrame() : nullptr;
+    }
+
+    return pFrame;
+
+}
+
+SfxFrame* SdModule::ExecuteNewDocument( SfxRequest const & rReq )
+{
+    SfxFrame* pFrame = nullptr;
+    if ( SvtModuleOptions().IsImpress() )
+    {
+        Reference< XFrame > xTargetFrame;
+        const SfxUnoFrameItem* pFrmItem = rReq.GetArg<SfxUnoFrameItem>(SID_FILLFRAME);
+        if ( pFrmItem )
+            xTargetFrame = pFrmItem->GetFrame();
+
+        SdOptions* pOpt = GetSdOptions(DocumentType::Impress);
+        bool bStartWithTemplate = pOpt->IsStartWithTemplate();
+
+        bool bNewDocDirect = rReq.GetSlot() == SID_NEWSD;
+
+        if( bNewDocDirect )
+        {
+            //we start without wizard
+
+            //check whether we should load a template document
+            OUString aStandardTemplate( SfxObjectFactory::GetStandardTemplate( u"com.sun.star.presentation.PresentationDocument" ) );
+
+            if( !aStandardTemplate.isEmpty() )
+            {
+                //load a template document
+                pFrame = CreateFromTemplate(aStandardTemplate, xTargetFrame, true);
+            }
+            else
+            {
+                //create an empty document
+                pFrame = CreateEmptyDocument( xTargetFrame );
+            }
+        }
+
+        if (bStartWithTemplate)
+        {
+            //Launch TemplateSelectionDialog
+            SfxTemplateSelectionDlg aTemplDlg(SfxGetpApp()->GetTopWindow());
+            aTemplDlg.run();
+
+            //check to disable the dialog
+            pOpt->SetStartWithTemplate( aTemplDlg.IsStartWithTemplate() );
+
+            //pFrame is loaded with the desired template
+            if (!aTemplDlg.getTemplatePath().isEmpty())
+                pFrame = CreateFromTemplate(aTemplDlg.getTemplatePath(), xTargetFrame, false);
+
+            // show tip-of-the-day dialog if it was deferred because SfxTemplateSelectionDlg
+            // was open
+            if (pFrame && SfxApplication::IsTipOfTheDayDue() && !SfxApplication::IsHeadlessOrUITest())
+            {
+                if (SfxDispatcher* pDispatcher = GetDispatcher())
+                {
+                    // tdf#127946 pass in argument for dialog parent
+                    SfxUnoFrameItem aDocFrame(SID_FILLFRAME, pFrame->GetFrameInterface());
+                    pDispatcher->ExecuteList(SID_TIPOFTHEDAY, SfxCallMode::SLOT, {}, { &aDocFrame });
+                }
+            }
+        }
+    }
+
+    return pFrame;
+}
+
+SfxFrame* SdModule::CreateEmptyDocument( const Reference< XFrame >& i_rFrame )
+{
+    SfxFrame* pFrame = nullptr;
+
+    SfxObjectShellLock xDocShell;
+    ::sd::DrawDocShell* pNewDocSh;
+    xDocShell = pNewDocSh = new ::sd::DrawDocShell(SfxObjectCreateMode::STANDARD,false,DocumentType::Impress);
+    pNewDocSh->DoInitNew();
+    SdDrawDocument* pDoc = pNewDocSh->GetDoc();
+    if (pDoc)
+    {
+        pDoc->CreateFirstPages();
+        pDoc->StopWorkStartupDelay();
+    }
+    if (pNewDocSh->GetMedium() && pNewDocSh->GetMedium()->GetItemSet())
+        pNewDocSh->GetMedium()->GetItemSet()->Put(SfxBoolItem(SID_REPLACEABLE, true));
+
+    SfxViewFrame* pViewFrame = SfxViewFrame::LoadDocumentIntoFrame( *pNewDocSh, i_rFrame );
+    OSL_ENSURE( pViewFrame, "SdModule::CreateEmptyDocument: no view frame - was the document really loaded?" );
+    pFrame = pViewFrame ? &pViewFrame->GetFrame() : nullptr;
+
+    return pFrame;
+}
+
+//===== OutlineToImpressFinalize ==============================================
+
+namespace {
+
+OutlineToImpressFinalizer::OutlineToImpressFinalizer (
+    ::sd::ViewShellBase& rBase,
+    SdDrawDocument& rDocument,
+    SvLockBytes const & rBytes)
+    : mrBase(rBase),
+      mrDocument(rDocument)
+{
+    // The given stream has a lifetime shorter than this new
+    // OutlineToImpressFinalizer object.  Therefore a local copy of the
+    // stream is created.
+    const SvStream* pStream (rBytes.GetStream());
+    if (pStream == nullptr)
+        return;
+
+    // Create a memory stream and prepare to fill it with the content of
+    // the original stream.
+    mpStream = std::make_shared<SvMemoryStream>();
+    static const std::size_t nBufferSize = 4096;
+    ::std::unique_ptr<sal_Int8[]> pBuffer (new sal_Int8[nBufferSize]);
+
+    sal_uInt64 nReadPosition(0);
+    bool bLoop (true);
+    while (bLoop)
+    {
+        // Read the next part of the original stream.
+        std::size_t nReadByteCount (0);
+        const ErrCode nErrorCode (
+            rBytes.ReadAt(
+                nReadPosition,
+                pBuffer.get(),
+                nBufferSize,
+                &nReadByteCount));
+
+        // Check the error code and stop copying the stream data when an
+        // error has occurred.
+        if (nErrorCode == ERRCODE_NONE)
+        {
+            if (nReadByteCount == 0)
+                bLoop = false;
+        }
+        else if (nErrorCode == ERRCODE_IO_PENDING)
+            ;
+        else
+        {
+            bLoop = false;
+            nReadByteCount = 0;
+        }
+
+        // Append the read bytes to the end of the memory stream.
+        if (nReadByteCount > 0)
+        {
+            mpStream->WriteBytes(pBuffer.get(), nReadByteCount);
+            nReadPosition += nReadByteCount;
+        }
+    }
+
+    // Rewind the memory stream so that in the operator() method its
+    // content is properly read.
+    mpStream->Seek(STREAM_SEEK_TO_BEGIN);
+}
+
+void OutlineToImpressFinalizer::operator() (bool)
+{
+    // Fetch the new outline view shell.
+    ::sd::OutlineViewShell* pOutlineShell
+        = dynamic_cast<sd::OutlineViewShell*>(FrameworkHelper::Instance(mrBase)->GetViewShell(FrameworkHelper::msCenterPaneURL).get());
+
+    if (pOutlineShell != nullptr && mpStream != nullptr)
+    {
+        sd::OutlineView* pView = static_cast<sd::OutlineView*>(pOutlineShell->GetView());
+        // mba: the stream can't contain any relative URLs, because we don't
+        // have any information about a BaseURL!
+        pOutlineShell->ReadRtf(*mpStream);
+
+        // Call UpdatePreview once for every slide to resync the
+        // document with the outliner of the OutlineViewShell.
+        sal_uInt16 nPageCount (mrDocument.GetSdPageCount(PageKind::Standard));
+        for (sal_uInt16 nIndex=0; nIndex<nPageCount; nIndex++)
+        {
+            SdPage* pPage = mrDocument.GetSdPage(nIndex, PageKind::Standard);
+            // Make the page the actual page so that the
+            // following UpdatePreview() call accesses the
+            // correct paragraphs.
+            pView->SetActualPage(pPage);
+            pOutlineShell->UpdatePreview(pPage);
+        }
+        // Select the first slide.
+        SdPage* pPage = mrDocument.GetSdPage(0, PageKind::Standard);
+        pView->SetActualPage(pPage);
+        pOutlineShell->UpdatePreview(pPage);
+    }
+
+    // Undo-Stack needs to be cleared, else the user may remove the
+    // only drawpage and this is a state we cannot handle ATM.
+    ::sd::DrawDocShell* pDocShell = mrDocument.GetDocSh();
+    if( pDocShell )
+        pDocShell->ClearUndoBuffer();
+}
+
+} // end of anonymous namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/sdmod2.cxx b/sd/source/ui/app/sdmod2.cxx
new file mode 100644
index 000000000..cccf42517
--- /dev/null
+++ b/sd/source/ui/app/sdmod2.cxx
@@ -0,0 +1,809 @@
+/* -*- 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 <editeng/flditem.hxx>
+#include <editeng/CustomPropertyField.hxx>
+#include <sfx2/printer.hxx>
+#include <sfx2/styfitem.hxx>
+#include <svl/inethist.hxx>
+#include <svl/poolitem.hxx>
+#include <svl/flagitem.hxx>
+#include <unotools/useroptions.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/docfile.hxx>
+#include <osl/diagnose.h>
+
+#include <editeng/measfld.hxx>
+#include <editeng/editstat.hxx>
+
+#include <svx/svxids.hrc>
+#include <svx/dialogs.hrc>
+#include <svx/svdotext.hxx>
+
+#include <sfx2/sfxdlg.hxx>
+
+#include <sdmod.hxx>
+#include <app.hrc>
+#include <family.hrc>
+#include <strings.hrc>
+#include <sdattr.hrc>
+
+#include <bitmaps.hlst>
+#include <ViewShell.hxx>
+#include <FrameView.hxx>
+#include <optsitem.hxx>
+#include <DrawDocShell.hxx>
+#include <drawdoc.hxx>
+#include <Outliner.hxx>
+#include <sdresid.hxx>
+#include <pres.hxx>
+#include <OutlineViewShell.hxx>
+#include <OutlineView.hxx>
+#include <ViewShellBase.hxx>
+#include <sdpage.hxx>
+#include <sdabstdlg.hxx>
+#include <svl/intitem.hxx>
+
+/** retrieves the page that is currently painted. This will only be the master page
+    if the current drawn view only shows the master page*/
+static SdPage* GetCurrentPage( sd::ViewShell const * pViewSh, EditFieldInfo const * pInfo, bool& bMasterView )
+{
+    if( !pInfo )
+        return nullptr;
+
+    bMasterView = false;
+    SdPage* pPage = dynamic_cast< SdPage* >( pInfo->GetSdrPage() );
+    SdrOutliner* pOutliner = dynamic_cast< SdrOutliner* >( pInfo->GetOutliner() );
+
+    // special case, someone already set the current page on the EditFieldInfo
+    // This is used from the svx::UnoGraphicsExporter f.e.
+    if( pPage )
+    {
+        bMasterView = false;
+        return pPage;
+    }
+
+    // first try to check if we are inside the outline view
+    sd::OutlineView* pSdView = nullptr;
+    if( auto pOutlineViewShell = dynamic_cast<const sd::OutlineViewShell* >(pViewSh) )
+        pSdView = static_cast<sd::OutlineView*>(pOutlineViewShell->GetView());
+
+    if (pSdView != nullptr && (pOutliner ==  &pSdView->GetOutliner()))
+    {
+        // outline mode
+        int nPgNum = 0;
+        Outliner& rOutl = pSdView->GetOutliner();
+        tools::Long nPos = pInfo->GetPara();
+        sal_Int32 nParaPos = 0;
+
+        for( Paragraph* pPara = rOutl.GetParagraph( 0 ); pPara && nPos >= 0; pPara = rOutl.GetParagraph( ++nParaPos ), nPos-- )
+        {
+            if( Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE ) )
+                nPgNum++;
+        }
+
+        pPage = pViewSh->GetDoc()->GetSdPage( static_cast<sal_uInt16>(nPgNum), PageKind::Standard );
+    }
+    else
+    {
+        // draw mode, slide mode and preview. Get the processed page from the outliner
+        if(pOutliner)
+        {
+            pPage = dynamic_cast< SdPage* >(const_cast< SdrPage* >(pOutliner->getVisualizedPage()));
+        }
+
+        // The path using GetPaintingPageView() and GetCurrentPaintingDisplayInfo()
+        // is no longer needed. I debugged and checked all usages of PageNumber decompositions
+        // which all use the new possibility of setting the visualized page at the SdrOutliner.
+
+        // if all else failed, geht the current page from the object that is
+        // currently formatted from the document
+        if(!pPage)
+        {
+            const SdrTextObj* pTextObj = (pViewSh && pViewSh->GetDoc()) ? pViewSh->GetDoc()->GetFormattingTextObj() : nullptr;
+
+            if( pTextObj )
+            {
+                pPage = dynamic_cast< SdPage* >( pTextObj->getSdrPageFromSdrObject() );
+            }
+        }
+
+        if(pPage)
+        {
+            bMasterView = pPage->IsMasterPage();
+        }
+    }
+
+    return pPage;
+}
+
+/**
+ * Link for CalcFieldValue of Outliners
+ */
+IMPL_LINK(SdModule, CalcFieldValueHdl, EditFieldInfo*, pInfo, void)
+{
+    if (!pInfo)
+        return;
+
+    const SvxFieldData* pField = pInfo->GetField().GetField();
+    ::sd::DrawDocShell*     pDocShell = nullptr;
+    SdDrawDocument* pDoc = nullptr;
+
+    SdrOutliner* pSdrOutliner = dynamic_cast< SdrOutliner* >( pInfo->GetOutliner() );
+    if( pSdrOutliner )
+    {
+        const SdrTextObj* pTextObj = pSdrOutliner->GetTextObj();
+
+        if( pTextObj )
+            pDoc = dynamic_cast< SdDrawDocument* >( &pTextObj->getSdrModelFromSdrObject() );
+
+        if( pDoc )
+            pDocShell = pDoc->GetDocSh();
+    }
+
+    if( !pDocShell )
+        pDocShell = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+
+    const SvxDateField* pDateField = nullptr;
+    const SvxExtTimeField* pExtTimeField = nullptr;
+    const SvxExtFileField* pExtFileField = nullptr;
+    const SvxAuthorField* pAuthorField = nullptr;
+    const SvxURLField* pURLField = nullptr;
+
+    const editeng::CustomPropertyField* pCustomPropertyField = nullptr;
+
+    if( (pDateField = dynamic_cast< const SvxDateField* >(pField)) != nullptr )
+    {
+        LanguageType eLang = pInfo->GetOutliner()->GetLanguage( pInfo->GetPara(), pInfo->GetPos() );
+        pInfo->SetRepresentation( pDateField->GetFormatted( *GetNumberFormatter(), eLang ) );
+    }
+    else if( (pExtTimeField = dynamic_cast< const SvxExtTimeField *>(pField)) != nullptr )
+    {
+        LanguageType eLang = pInfo->GetOutliner()->GetLanguage( pInfo->GetPara(), pInfo->GetPos() );
+        pInfo->SetRepresentation( pExtTimeField->GetFormatted( *GetNumberFormatter(), eLang ) );
+    }
+    else if( (pExtFileField = dynamic_cast< const SvxExtFileField * >(pField)) != nullptr )
+    {
+        if( pDocShell && (pExtFileField->GetType() != SvxFileType::Fix) )
+        {
+            OUString aName;
+            if( pDocShell->HasName() )
+                aName = pDocShell->GetMedium()->GetName();
+            else
+                aName = pDocShell->GetName();
+
+            const_cast< SvxExtFileField* >(pExtFileField)->SetFile( aName );
+        }
+        pInfo->SetRepresentation( pExtFileField->GetFormatted() );
+
+    }
+    else if( (pAuthorField = dynamic_cast< const SvxAuthorField* >( pField )) != nullptr  )
+    {
+        if( pAuthorField->GetType() != SvxAuthorType::Fix )
+        {
+            SvtUserOptions aUserOptions;
+            SvxAuthorField aAuthorField(
+                    aUserOptions.GetFirstName(), aUserOptions.GetLastName(), aUserOptions.GetID(),
+                    pAuthorField->GetType(), pAuthorField->GetFormat() );
+
+            *const_cast< SvxAuthorField* >(pAuthorField) = aAuthorField;
+        }
+        pInfo->SetRepresentation( pAuthorField->GetFormatted() );
+
+    }
+    else if( dynamic_cast< const SvxPageField*  >(pField) )
+    {
+        OUString aRepresentation(" ");
+
+        ::sd::ViewShell* pViewSh = pDocShell ? pDocShell->GetViewShell() : nullptr;
+        if(pViewSh == nullptr)
+        {
+            ::sd::ViewShellBase* pBase = dynamic_cast< ::sd::ViewShellBase *>( SfxViewShell::Current() );
+            if(pBase)
+                pViewSh = pBase->GetMainViewShell().get();
+        }
+        if( !pDoc && pViewSh )
+            pDoc = pViewSh->GetDoc();
+
+        bool bMasterView;
+        SdPage* pPage = GetCurrentPage( pViewSh, pInfo, bMasterView );
+
+        if( pPage && pDoc && !bMasterView )
+        {
+            int nPgNum;
+
+            if( (pPage->GetPageKind() == PageKind::Handout) && pViewSh )
+            {
+                nPgNum = pViewSh->GetPrintedHandoutPageNum();
+            }
+            else
+            {
+                nPgNum = (pPage->GetPageNum() - 1) / 2 + 1;
+            }
+            aRepresentation = pDoc->CreatePageNumValue(static_cast<sal_uInt16>(nPgNum));
+        }
+        else
+            aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_NUMBER);
+
+        pInfo->SetRepresentation( aRepresentation );
+    }
+    else if( dynamic_cast< const SvxPageTitleField*  >(pField) )
+    {
+        OUString aRepresentation(" ");
+
+        ::sd::ViewShell* pViewSh = pDocShell ? pDocShell->GetViewShell() : nullptr;
+        if(pViewSh == nullptr)
+        {
+            ::sd::ViewShellBase* pBase = dynamic_cast< ::sd::ViewShellBase *>( SfxViewShell::Current() );
+            if(pBase)
+                pViewSh = pBase->GetMainViewShell().get();
+        }
+        if( !pDoc && pViewSh )
+            pDoc = pViewSh->GetDoc();
+
+        bool bMasterView;
+        SdPage* pPage = GetCurrentPage( pViewSh, pInfo, bMasterView );
+
+        if( pPage && pDoc && !bMasterView )
+        {
+            aRepresentation = pPage->GetName();
+        }
+        else
+        {
+            DocumentType eDocType = pDoc ? pDoc->GetDocumentType() : DocumentType::Impress;
+            aRepresentation = ( ( eDocType == DocumentType::Impress )
+                                ? SdResId(STR_FIELD_PLACEHOLDER_SLIDENAME)
+                                : SdResId(STR_FIELD_PLACEHOLDER_PAGENAME) );
+        }
+
+        pInfo->SetRepresentation( aRepresentation );
+    }
+    else if( dynamic_cast< const SvxPagesField*  >(pField) )
+    {
+        OUString aRepresentation(" ");
+
+        ::sd::ViewShell* pViewSh = pDocShell ? pDocShell->GetViewShell() : nullptr;
+        if(pViewSh == nullptr)
+        {
+            ::sd::ViewShellBase* pBase = dynamic_cast< ::sd::ViewShellBase *>( SfxViewShell::Current() );
+            if(pBase)
+                pViewSh = pBase->GetMainViewShell().get();
+        }
+        if( !pDoc && pViewSh )
+            pDoc = pViewSh->GetDoc();
+
+        bool bMasterView;
+        SdPage* pPage = GetCurrentPage( pViewSh, pInfo, bMasterView );
+
+        sal_uInt16 nPageCount = 0;
+
+        if( !bMasterView )
+        {
+            if( pPage && (pPage->GetPageKind() == PageKind::Handout) && pViewSh )
+            {
+                nPageCount = pViewSh->GetPrintedHandoutPageCount();
+            }
+            else if( pDoc )
+            {
+                nPageCount = pDoc->GetActiveSdPageCount();
+            }
+        }
+
+        if( nPageCount > 0 )
+            aRepresentation = pDoc->CreatePageNumValue(nPageCount);
+        else
+            aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_COUNT);
+
+        pInfo->SetRepresentation( aRepresentation );
+    }
+    else if( (pURLField = dynamic_cast< const SvxURLField* >(pField)) != nullptr )
+    {
+        switch ( pURLField->GetFormat() )
+        {
+            case SvxURLFormat::AppDefault: //!!! adjustable at App???
+            case SvxURLFormat::Repr:
+                pInfo->SetRepresentation( pURLField->GetRepresentation() );
+                break;
+
+            case SvxURLFormat::Url:
+                pInfo->SetRepresentation( pURLField->GetURL() );
+                break;
+        }
+
+        const OUString& aURL = pURLField->GetURL();
+
+        svtools::ColorConfig aConfig;
+        svtools::ColorConfigEntry eEntry =
+            INetURLHistory::GetOrCreate()->QueryUrl( aURL ) ? svtools::LINKSVISITED : svtools::LINKS;
+        pInfo->SetTextColor( aConfig.GetColorValue(eEntry).nColor );
+    }
+    else if ( dynamic_cast< const SdrMeasureField* >(pField))
+    {
+        pInfo->SetFieldColor(std::optional<Color>()); // clear the field color
+    }
+    else if ((pCustomPropertyField = dynamic_cast<const editeng::CustomPropertyField*>(pField)) != nullptr)
+    {
+        try
+        {
+            SfxObjectShell* pObjSh = SfxObjectShell::Current();
+            if (pObjSh && pObjSh->IsLoadingFinished())
+            {
+                auto pNonConstCustomPropertyField = const_cast<editeng::CustomPropertyField*>(pCustomPropertyField);
+                OUString sCurrent = pNonConstCustomPropertyField->GetFormatted(pObjSh->getDocProperties());
+                pInfo->SetRepresentation(sCurrent);
+            }
+            else
+                pInfo->SetRepresentation(pCustomPropertyField->GetCurrentPresentation());
+        }
+        catch (...)
+        {
+            pInfo->SetRepresentation(pCustomPropertyField->GetCurrentPresentation());
+        }
+    }
+    else
+    {
+        OUString aRepresentation;
+
+        bool bHeaderField = dynamic_cast< const SvxHeaderField* >( pField ) != nullptr;
+        bool bFooterField = !bHeaderField && (dynamic_cast< const SvxFooterField* >( pField ) != nullptr );
+        bool bDateTimeField = !bHeaderField && !bFooterField && (dynamic_cast< const SvxDateTimeField* >( pField ) != nullptr);
+
+        if( bHeaderField || bFooterField || bDateTimeField )
+        {
+            sd::ViewShell* pViewSh = pDocShell ? pDocShell->GetViewShell() : nullptr;
+            bool bMasterView = false;
+            SdPage* pPage = GetCurrentPage( pViewSh, pInfo, bMasterView );
+
+            if( (pPage == nullptr) || bMasterView )
+            {
+                if( bHeaderField )
+                    aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_HEADER);
+                else if (bFooterField )
+                    aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_FOOTER);
+                else if (bDateTimeField )
+                    aRepresentation = SdResId(STR_FIELD_PLACEHOLDER_DATETIME);
+            }
+            else
+            {
+                const sd::HeaderFooterSettings &rSettings = pPage->getHeaderFooterSettings();
+
+                if( bHeaderField )
+                {
+                    aRepresentation = rSettings.maHeaderText;
+                }
+                else if( bFooterField )
+                {
+                    aRepresentation = rSettings.maFooterText;
+                }
+                else if( bDateTimeField )
+                {
+                    if( rSettings.mbDateTimeIsFixed )
+                    {
+                        aRepresentation = rSettings.maDateTimeText;
+                    }
+                    else
+                    {
+                        DateTime aDateTime( DateTime::SYSTEM );
+                        LanguageType eLang = pInfo->GetOutliner()->GetLanguage( pInfo->GetPara(), pInfo->GetPos() );
+                        aRepresentation = SvxDateTimeField::GetFormatted( aDateTime, aDateTime,
+                                              rSettings.meDateFormat, rSettings.meTimeFormat, *GetNumberFormatter(), eLang );
+                    }
+                }
+            }
+        }
+        else
+        {
+            OSL_FAIL("sd::SdModule::CalcFieldValueHdl(), unknown field type!");
+        }
+
+        if( aRepresentation.isEmpty() )                // TODO: Edit engine doesn't handle empty fields?
+            aRepresentation = " ";
+        pInfo->SetRepresentation( aRepresentation );
+    }
+}
+
+/**
+ * virtual methods for option dialog
+ */
+std::optional<SfxItemSet> SdModule::CreateItemSet( sal_uInt16 nSlot )
+{
+    ::sd::FrameView* pFrameView = nullptr;
+    ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+    SdDrawDocument* pDoc = nullptr;
+
+    // Here we set the DocType of the option dialog (not document!)
+    DocumentType eDocType = DocumentType::Impress;
+    if( nSlot == SID_SD_GRAPHIC_OPTIONS )
+        eDocType = DocumentType::Draw;
+
+    if (pDocSh)
+    {
+        pDoc = pDocSh->GetDoc();
+
+        // If the option dialog is identical to the document type,
+        // we can pass the FrameView too:
+        if( pDoc && eDocType == pDoc->GetDocumentType() )
+            pFrameView = pDocSh->GetFrameView();
+
+        ::sd::ViewShell* pViewShell = pDocSh->GetViewShell();
+        if (pViewShell != nullptr)
+            pViewShell->WriteFrameViewData();
+    }
+
+    SdOptions* pOptions = GetSdOptions(eDocType);
+
+    // Pool has by default MapUnit Twips (Awgh!)
+    SfxItemPool& rPool = GetPool();
+    rPool.SetDefaultMetric( MapUnit::Map100thMM );
+
+    SfxItemSetFixed<
+            SID_ATTR_GRID_OPTIONS, SID_ATTR_GRID_OPTIONS,
+            SID_ATTR_METRIC, SID_ATTR_METRIC,
+            SID_ATTR_DEFTABSTOP, SID_ATTR_DEFTABSTOP,
+            ATTR_OPTIONS_LAYOUT, ATTR_OPTIONS_SCALE_END>  aRet(rPool);
+
+    // TP_OPTIONS_LAYOUT:
+    aRet.Put( SdOptionsLayoutItem( pOptions, pFrameView ) );
+
+    sal_uInt16 nDefTab = 0;
+    if( pFrameView)
+        nDefTab = pDoc->GetDefaultTabulator();
+    else
+        nDefTab = pOptions->GetDefTab();
+    aRet.Put( SfxUInt16Item( SID_ATTR_DEFTABSTOP, nDefTab ) );
+
+    FieldUnit nMetric = FieldUnit(0xffff);
+    if( pFrameView)
+        nMetric = pDoc->GetUIUnit();
+    else
+        nMetric = static_cast<FieldUnit>(pOptions->GetMetric());
+
+    if( nMetric == FieldUnit(0xffff) )
+        nMetric = GetFieldUnit();
+
+    aRet.Put( SfxUInt16Item( SID_ATTR_METRIC, static_cast<sal_uInt16>(nMetric) ) );
+
+    // TP_OPTIONS_MISC:
+    SdOptionsMiscItem aSdOptionsMiscItem( pOptions, pFrameView );
+    if ( pFrameView )
+    {
+        aSdOptionsMiscItem.GetOptionsMisc().SetSummationOfParagraphs( pDoc->IsSummationOfParagraphs() );
+        aSdOptionsMiscItem.GetOptionsMisc().SetPrinterIndependentLayout (
+            static_cast<sal_uInt16>(pDoc->GetPrinterIndependentLayout()));
+    }
+    aRet.Put( aSdOptionsMiscItem );
+
+    // TP_OPTIONS_SNAP:
+    aRet.Put( SdOptionsSnapItem( pOptions, pFrameView ) );
+
+    // TP_SCALE:
+    sal_uInt32 nW = 10;
+    sal_uInt32 nH = 10;
+    sal_Int32  nX;
+    sal_Int32  nY;
+    if( pDocSh )
+    {
+        SdrPage* pPage = pDoc->GetSdPage(0, PageKind::Standard);
+        Size aSize(pPage->GetSize());
+        nW = aSize.Width();
+        nH = aSize.Height();
+    }
+
+    if(pFrameView)
+    {
+        const Fraction& rFraction =  pDoc->GetUIScale();
+        nX=rFraction.GetNumerator();
+        nY=rFraction.GetDenominator();
+    }
+    else
+    {
+        // Get options from configuration file
+        pOptions->GetScale( nX, nY );
+    }
+
+    aRet.Put( SfxInt32Item( ATTR_OPTIONS_SCALE_X, nX ) );
+    aRet.Put( SfxInt32Item( ATTR_OPTIONS_SCALE_Y, nY ) );
+    aRet.Put( SfxUInt32Item( ATTR_OPTIONS_SCALE_WIDTH, nW ) );
+    aRet.Put( SfxUInt32Item( ATTR_OPTIONS_SCALE_HEIGHT, nH ) );
+
+    // TP_OPTIONS_PRINT:
+    aRet.Put( SdOptionsPrintItem( pOptions ) );
+
+    // RID_SVXPAGE_GRID:
+    aRet.Put( SdOptionsGridItem( pOptions ) );
+
+    return aRet;
+}
+
+void SdModule::ApplyItemSet( sal_uInt16 nSlot, const SfxItemSet& rSet )
+{
+    bool bNewDefTab = false;
+    bool bNewPrintOptions = false;
+    bool bMiscOptions = false;
+
+    ::sd::DrawDocShell* pDocSh = dynamic_cast< ::sd::DrawDocShell *>( SfxObjectShell::Current() );
+    SdDrawDocument* pDoc = nullptr;
+    // Here we set the DocType of the option dialog (not document!)
+    DocumentType eDocType = DocumentType::Impress;
+    if( nSlot == SID_SD_GRAPHIC_OPTIONS )
+        eDocType = DocumentType::Draw;
+
+    ::sd::ViewShell* pViewShell = nullptr;
+
+    if (pDocSh)
+    {
+        pDoc = pDocSh->GetDoc();
+
+        pViewShell = pDocSh->GetViewShell();
+        if (pViewShell != nullptr)
+            pViewShell->WriteFrameViewData();
+    }
+    SdOptions* pOptions = GetSdOptions(eDocType);
+    // Grid
+    if( const SdOptionsGridItem* pGridItem = static_cast<const SdOptionsGridItem*>(rSet.GetItemIfSet( SID_ATTR_GRID_OPTIONS, false )) )
+    {
+        pGridItem->SetOptions( pOptions );
+    }
+
+    // Layout
+    if( const SdOptionsLayoutItem* pLayoutItem = rSet.GetItemIfSet( ATTR_OPTIONS_LAYOUT, false ))
+    {
+        pLayoutItem->SetOptions( pOptions );
+    }
+
+    // Metric
+    if( const SfxUInt16Item* pItem = rSet.GetItemIfSet( SID_ATTR_METRIC, false ) )
+    {
+        if( pDoc && eDocType == pDoc->GetDocumentType() )
+            PutItem( *pItem );
+        pOptions->SetMetric( pItem->GetValue() );
+    }
+    sal_uInt16 nDefTab = pOptions->GetDefTab();
+    // Default-Tabulator
+    if( const SfxUInt16Item* pItem = rSet.GetItemIfSet( SID_ATTR_DEFTABSTOP, false ) )
+    {
+        nDefTab = pItem->GetValue();
+        pOptions->SetDefTab( nDefTab );
+
+        bNewDefTab = true;
+    }
+
+    // Scale
+    if( const SfxInt32Item* pItem = rSet.GetItemIfSet( ATTR_OPTIONS_SCALE_X, false ) )
+    {
+        sal_Int32 nX = pItem->GetValue();
+        pItem = rSet.GetItemIfSet( ATTR_OPTIONS_SCALE_Y, false );
+        if( pItem )
+        {
+            sal_Int32 nY = pItem->GetValue();
+            pOptions->SetScale( nX, nY );
+
+            // Apply to document only if doc type match
+            if( pDocSh && pDoc && eDocType == pDoc->GetDocumentType() )
+            {
+                pDoc->SetUIScale( Fraction( nX, nY ) );
+                if( pViewShell )
+                    pViewShell->SetRuler( pViewShell->HasRuler() );
+            }
+        }
+    }
+
+    // Misc
+    const SdOptionsMiscItem* pMiscItem = rSet.GetItemIfSet( ATTR_OPTIONS_MISC, false);
+    if( pMiscItem )
+    {
+        pMiscItem->SetOptions( pOptions );
+        bMiscOptions = true;
+    }
+
+    // Snap
+    const SdOptionsSnapItem* pSnapItem = rSet.GetItemIfSet( ATTR_OPTIONS_SNAP, false );
+    if( pSnapItem )
+    {
+        pSnapItem->SetOptions( pOptions );
+    }
+
+    SfxItemSetFixed<SID_PRINTER_NOTFOUND_WARN,  SID_PRINTER_NOTFOUND_WARN,
+                    SID_PRINTER_CHANGESTODOC,   SID_PRINTER_CHANGESTODOC,
+                    ATTR_OPTIONS_PRINT,         ATTR_OPTIONS_PRINT>  aPrintSet( GetPool() );
+
+    // Print
+    const SdOptionsPrintItem* pPrintItem = rSet.GetItemIfSet( ATTR_OPTIONS_PRINT, false);
+    if( pPrintItem )
+    {
+        pPrintItem->SetOptions( pOptions );
+
+        // set PrintOptionsSet
+        SdOptionsPrintItem aPrintItem( pOptions );
+        SfxFlagItem aFlagItem( SID_PRINTER_CHANGESTODOC );
+        SfxPrinterChangeFlags nFlags =
+                (aPrintItem.GetOptionsPrint().IsWarningSize() ? SfxPrinterChangeFlags::CHG_SIZE : SfxPrinterChangeFlags::NONE) |
+                (aPrintItem.GetOptionsPrint().IsWarningOrientation() ? SfxPrinterChangeFlags::CHG_ORIENTATION : SfxPrinterChangeFlags::NONE);
+        aFlagItem.SetValue( static_cast<int>(nFlags) );
+
+        aPrintSet.Put( aPrintItem );
+        aPrintSet.Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, aPrintItem.GetOptionsPrint().IsWarningPrinter() ) );
+        aPrintSet.Put( aFlagItem );
+
+        bNewPrintOptions = true;
+    }
+
+    // Only if also the document type matches...
+    if( pDocSh && pDoc && eDocType == pDoc->GetDocumentType() )
+    {
+        if( bNewPrintOptions )
+        {
+            pDocSh->GetPrinter(true)->SetOptions( aPrintSet );
+        }
+
+        // set DefTab at Model
+        if( bNewDefTab )
+        {
+            SdDrawDocument* pDocument = pDocSh->GetDoc();
+            pDocument->SetDefaultTabulator( nDefTab );
+
+            SdOutliner* pOutl = pDocument->GetOutliner( false );
+            if( pOutl )
+                pOutl->SetDefTab( nDefTab );
+
+            SdOutliner* pInternalOutl = pDocument->GetInternalOutliner( false );
+            if( pInternalOutl )
+                pInternalOutl->SetDefTab( nDefTab );
+        }
+        if ( bMiscOptions )
+        {
+            pDoc->SetSummationOfParagraphs( pMiscItem->GetOptionsMisc().IsSummationOfParagraphs() );
+            EEControlBits nSum = pMiscItem->GetOptionsMisc().IsSummationOfParagraphs() ? EEControlBits::ULSPACESUMMATION : EEControlBits::NONE;
+            EEControlBits nCntrl;
+
+            SdDrawDocument* pDocument = pDocSh->GetDoc();
+            SdrOutliner& rOutl = pDocument->GetDrawOutliner();
+            nCntrl = rOutl.GetControlWord() &~ EEControlBits::ULSPACESUMMATION;
+            rOutl.SetControlWord( nCntrl | nSum );
+            SdOutliner* pOutl = pDocument->GetOutliner( false );
+            if( pOutl )
+            {
+                nCntrl = pOutl->GetControlWord() &~ EEControlBits::ULSPACESUMMATION;
+                pOutl->SetControlWord( nCntrl | nSum );
+            }
+            pOutl = pDocument->GetInternalOutliner( false );
+            if( pOutl )
+            {
+                nCntrl = pOutl->GetControlWord() &~ EEControlBits::ULSPACESUMMATION;
+                pOutl->SetControlWord( nCntrl | nSum );
+            }
+
+            // Set printer independent layout mode.
+            if( pDoc->GetPrinterIndependentLayout() != pMiscItem->GetOptionsMisc().GetPrinterIndependentLayout() )
+                pDoc->SetPrinterIndependentLayout (pMiscItem->GetOptionsMisc().GetPrinterIndependentLayout());
+        }
+    }
+
+    pOptions->StoreConfig();
+
+    // Only if also the document type matches...
+    if( pDocSh && pDoc && eDocType == pDoc->GetDocumentType() )
+    {
+        FieldUnit eUIUnit = static_cast<FieldUnit>(pOptions->GetMetric());
+        pDoc->SetUIUnit(eUIUnit);
+
+        if (pViewShell)
+        {
+            // make sure no one is in text edit mode, cause there
+            // are some pointers remembered else (!)
+            if(pViewShell->GetView())
+                pViewShell->GetView()->SdrEndTextEdit();
+
+            ::sd::FrameView* pFrame = pViewShell->GetFrameView();
+            pFrame->Update(pOptions);
+            pViewShell->ReadFrameViewData(pFrame);
+            pViewShell->SetUIUnit(eUIUnit);
+            pViewShell->SetDefTabHRuler( nDefTab );
+        }
+    }
+
+    if( pViewShell && pViewShell->GetViewFrame() )
+        pViewShell->GetViewFrame()->GetBindings().InvalidateAll( true );
+}
+
+std::unique_ptr<SfxTabPage> SdModule::CreateTabPage( sal_uInt16 nId, weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet )
+{
+    std::unique_ptr<SfxTabPage> xRet;
+    SfxAllItemSet aSet(*(rSet.GetPool()));
+    SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create();
+
+    switch(nId)
+    {
+        case SID_SD_TP_CONTENTS:
+        case SID_SI_TP_CONTENTS:
+        {
+            ::CreateTabPage fnCreatePage = pFact->GetSdOptionsContentsTabPageCreatorFunc();
+            if( fnCreatePage )
+                xRet = (*fnCreatePage)( pPage, pController, &rSet );
+        }
+        break;
+        case SID_SD_TP_SNAP:
+        case SID_SI_TP_SNAP:
+        {
+            ::CreateTabPage fnCreatePage = pFact->GetSdOptionsSnapTabPageCreatorFunc();
+            if( fnCreatePage )
+                xRet = (*fnCreatePage)( pPage, pController, &rSet );
+        }
+        break;
+        case SID_SD_TP_PRINT:
+        case SID_SI_TP_PRINT:
+        {
+            ::CreateTabPage fnCreatePage = pFact->GetSdPrintOptionsTabPageCreatorFunc();
+            if( fnCreatePage )
+            {
+                xRet = (*fnCreatePage)( pPage, pController, &rSet );
+                if(SID_SD_TP_PRINT == nId)
+                    aSet.Put (SfxUInt32Item(SID_SDMODE_FLAG,SD_DRAW_MODE));
+                xRet->PageCreated(aSet);
+            }
+        }
+        break;
+        case SID_SI_TP_MISC:
+        case SID_SD_TP_MISC:
+        {
+            ::CreateTabPage fnCreatePage = pFact->GetSdOptionsMiscTabPageCreatorFunc();
+            if( fnCreatePage )
+            {
+                xRet = (*fnCreatePage)( pPage, pController, &rSet );
+                if(SID_SD_TP_MISC == nId)
+                    aSet.Put (SfxUInt32Item(SID_SDMODE_FLAG,SD_DRAW_MODE));
+                else
+                    aSet.Put (SfxUInt32Item(SID_SDMODE_FLAG,SD_IMPRESS_MODE));
+                xRet->PageCreated(aSet);
+            }
+        }
+        break;
+        case RID_SVXPAGE_TEXTANIMATION :
+        {
+            SfxAbstractDialogFactory* pSfxFact = SfxAbstractDialogFactory::Create();
+            ::CreateTabPage fnCreatePage = pSfxFact->GetTabPageCreatorFunc( nId );
+            if ( fnCreatePage )
+                xRet = (*fnCreatePage)( pPage, pController, &rSet );
+        }
+        break;
+    }
+    DBG_ASSERT( xRet, "SdModule::CreateTabPage(): no valid ID for TabPage!" );
+
+    return xRet;
+}
+
+std::optional<SfxStyleFamilies> SdModule::CreateStyleFamilies()
+{
+    SfxStyleFamilies aStyleFamilies;
+
+    aStyleFamilies.emplace_back(SfxStyleFamily::Para,
+                                 SdResId(STR_GRAPHICS_STYLE_FAMILY),
+                                 BMP_STYLES_FAMILY_GRAPHICS,
+                                 RID_GRAPHICSTYLEFAMILY, SD_MOD()->GetResLocale());
+
+    aStyleFamilies.emplace_back(SfxStyleFamily::Pseudo,
+                                 SdResId(STR_PRESENTATIONS_STYLE_FAMILY),
+                                 BMP_STYLES_FAMILY_PRESENTATIONS,
+                                 RID_PRESENTATIONSTYLEFAMILY, SD_MOD()->GetResLocale());
+
+    return aStyleFamilies;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/sdpopup.cxx b/sd/source/ui/app/sdpopup.cxx
new file mode 100644
index 000000000..4aafd2848
--- /dev/null
+++ b/sd/source/ui/app/sdpopup.cxx
@@ -0,0 +1,318 @@
+/* -*- 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 <string_view>
+
+#include <editeng/flditem.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/docfile.hxx>
+#include <unotools/useroptions.hxx>
+#include <vcl/svapp.hxx>
+
+#include <strings.hrc>
+#include <sdpopup.hxx>
+#include <sdresid.hxx>
+#include <sdmod.hxx>
+#include <DrawDocShell.hxx>
+
+/*
+ * Popup menu for editing of field command
+ */
+SdFieldPopup::SdFieldPopup(const SvxFieldData* pInField, LanguageType eLanguage)
+    : m_xBuilder(Application::CreateBuilder(nullptr, "modules/simpress/ui/fieldmenu.ui"))
+    , m_xPopup(m_xBuilder->weld_menu("menu"))
+    , m_pField(pInField)
+{
+    Fill(eLanguage);
+}
+
+SdFieldPopup::~SdFieldPopup()
+{
+}
+
+void SdFieldPopup::Fill( LanguageType eLanguage )
+{
+    sal_uInt16 nID = 1;
+    m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_FIX));
+    m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_VAR));
+    m_xPopup->append_separator("separator1");
+
+    if( auto pDateField = dynamic_cast< const SvxDateField *>( m_pField ) )
+    {
+        SvxDateField aDateField( *pDateField );
+
+        if (pDateField->GetType() == SvxDateType::Fix)
+            m_xPopup->set_active("1", true);
+        else
+            m_xPopup->set_active("2", true);
+
+        //SvxDateFormat::AppDefault,     // is not used
+        //SvxDateFormat::System,         // is not used
+        m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_STANDARD_SMALL));
+        m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_STANDARD_BIG));
+
+        SvNumberFormatter* pNumberFormatter = SD_MOD()->GetNumberFormatter();
+        aDateField.SetFormat( SvxDateFormat::A );    // 13.02.96
+        m_xPopup->append_radio(OUString::number(nID++), aDateField.GetFormatted(*pNumberFormatter, eLanguage));
+        aDateField.SetFormat( SvxDateFormat::B );    // 13.02.1996
+        m_xPopup->append_radio(OUString::number(nID++), aDateField.GetFormatted(*pNumberFormatter, eLanguage));
+        aDateField.SetFormat( SvxDateFormat::C );    // 13.Feb 1996
+        m_xPopup->append_radio(OUString::number(nID++), aDateField.GetFormatted(*pNumberFormatter, eLanguage));
+
+        aDateField.SetFormat( SvxDateFormat::D );    // 13.Februar 1996
+        m_xPopup->append_radio(OUString::number(nID++), aDateField.GetFormatted(*pNumberFormatter, eLanguage));
+        aDateField.SetFormat( SvxDateFormat::E );    // Die, 13.Februar 1996
+        m_xPopup->append_radio(OUString::number(nID++), aDateField.GetFormatted(*pNumberFormatter, eLanguage));
+        aDateField.SetFormat( SvxDateFormat::F );    // Dienstag, 13.Februar 1996
+        m_xPopup->append_radio(OUString::number(nID++), aDateField.GetFormatted(*pNumberFormatter, eLanguage));
+
+        m_xPopup->set_active(OString::number(static_cast<sal_uInt16>( pDateField->GetFormat() ) + 1), true); // - 2 + 3 !
+    }
+    else if( auto pTimeField = dynamic_cast< const SvxExtTimeField *>( m_pField ) )
+    {
+        SvxExtTimeField aTimeField( *pTimeField );
+
+        if( pTimeField->GetType() == SvxTimeType::Fix )
+            m_xPopup->set_active("1", true);
+        else
+            m_xPopup->set_active("2", true);
+
+        //SvxTimeFormat::AppDefault,     // is not used
+        //SvxTimeFormat::System,         // is not used
+        m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_STANDARD_NORMAL));
+
+        SvNumberFormatter* pNumberFormatter = SD_MOD()->GetNumberFormatter();
+        aTimeField.SetFormat( SvxTimeFormat::HH24_MM );    // 13:49
+        m_xPopup->append_radio(OUString::number(nID++), aTimeField.GetFormatted(*pNumberFormatter, eLanguage));
+        aTimeField.SetFormat( SvxTimeFormat::HH24_MM_SS );   // 13:49:38
+        m_xPopup->append_radio(OUString::number(nID++), aTimeField.GetFormatted(*pNumberFormatter, eLanguage));
+        aTimeField.SetFormat( SvxTimeFormat::HH24_MM_SS_00 );  // 13:49:38.78
+        m_xPopup->append_radio(OUString::number(nID++), aTimeField.GetFormatted(*pNumberFormatter, eLanguage));
+
+        aTimeField.SetFormat( SvxTimeFormat::HH12_MM );    // 01:49
+        m_xPopup->append_radio(OUString::number(nID++), aTimeField.GetFormatted(*pNumberFormatter, eLanguage));
+        aTimeField.SetFormat( SvxTimeFormat::HH12_MM_SS );   // 01:49:38
+        m_xPopup->append_radio(OUString::number(nID++), aTimeField.GetFormatted(*pNumberFormatter, eLanguage));
+        aTimeField.SetFormat( SvxTimeFormat::HH12_MM_SS_00 );  // 01:49:38.78
+        m_xPopup->append_radio(OUString::number(nID++), aTimeField.GetFormatted(*pNumberFormatter, eLanguage));
+        //SvxTimeFormat::HH12_MM_AMPM,  // 01:49 PM
+        //SvxTimeFormat::HH12_MM_SS_AMPM, // 01:49:38 PM
+        //SvxTimeFormat::HH12_MM_SS_00_AMPM // 01:49:38.78 PM
+
+        m_xPopup->set_active(OString::number(static_cast<sal_uInt16>( pTimeField->GetFormat() ) + 1), true); // - 2 + 3 !
+    }
+    else if( auto pFileField = dynamic_cast< const SvxExtFileField *>( m_pField ) )
+    {
+        //SvxExtFileField aFileField( *pFileField );
+
+        if( pFileField->GetType() == SvxFileType::Fix )
+            m_xPopup->set_active("1", true);
+        else
+            m_xPopup->set_active("2", true);
+
+        m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_FILEFORMAT_NAME_EXT));
+        m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_FILEFORMAT_FULLPATH));
+        m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_FILEFORMAT_PATH));
+        m_xPopup->append_radio(OUString::number(nID++), SdResId(STR_FILEFORMAT_NAME));
+
+        m_xPopup->set_active(OString::number(static_cast<sal_uInt16>( pFileField->GetFormat() ) + 3), true);
+    }
+    else if( auto pAuthorField = dynamic_cast< const SvxAuthorField *>( m_pField ) )
+    {
+        SvxAuthorField aAuthorField( *pAuthorField );
+
+        if( pAuthorField->GetType() == SvxAuthorType::Fix )
+            m_xPopup->set_active("1", true);
+        else
+            m_xPopup->set_active("2", true);
+
+        for( sal_uInt16 i = 0; i < 4; i++ )
+        {
+            aAuthorField.SetFormat( static_cast<SvxAuthorFormat>(i) );
+            m_xPopup->append_radio(OUString::number(nID++), aAuthorField.GetFormatted());
+        }
+        m_xPopup->set_active(OString::number(static_cast<sal_uInt16>( pAuthorField->GetFormat() ) + 3), true);
+    }
+}
+
+void SdFieldPopup::Execute(weld::Window* pParent, const tools::Rectangle& rRect)
+{
+    OString sIdent = m_xPopup->popup_at_rect(pParent, rRect);
+    if (sIdent.isEmpty())
+        return;
+
+    if (sIdent == "1" || sIdent == "2")
+    {
+        m_xPopup->set_active("1", sIdent == "1");
+        m_xPopup->set_active("2", sIdent == "2");
+    }
+    else
+    {
+        int nCount = m_xPopup->n_children();
+        for (int i = 3; i < nCount; i++)
+            m_xPopup->set_active(
+                OString::number(i), sIdent == std::string_view(OString::number(i)));
+    }
+}
+
+/**
+ * Returns a new field, owned by caller.
+ * Returns NULL if nothing changed.
+ */
+SvxFieldData* SdFieldPopup::GetField()
+{
+    SvxFieldData* pNewField = nullptr;
+
+    sal_uInt16 nCount = m_xPopup->n_children();
+
+    if( auto pDateField = dynamic_cast< const SvxDateField *>( m_pField ) )
+    {
+        SvxDateType   eType;
+        SvxDateFormat eFormat;
+        sal_uInt16 i;
+
+        if (m_xPopup->get_active("1"))
+            eType = SvxDateType::Fix;
+        else
+            eType = SvxDateType::Var;
+
+        for( i = 3; i < nCount; i++ )
+        {
+            if (m_xPopup->get_active(OString::number(i)))
+                break;
+        }
+        eFormat = static_cast<SvxDateFormat>( i - 1 );
+
+        if( pDateField->GetFormat() != eFormat ||
+            pDateField->GetType() != eType )
+        {
+            pNewField = new SvxDateField( *pDateField );
+            static_cast<SvxDateField*>( pNewField )->SetType( eType );
+            static_cast<SvxDateField*>( pNewField )->SetFormat( eFormat );
+
+            if( (pDateField->GetType() == SvxDateType::Var) && (eType == SvxDateType::Fix) )
+            {
+                Date aDate( Date::SYSTEM );
+                static_cast<SvxDateField*>( pNewField )->SetFixDate( aDate );
+            }
+        }
+    }
+    else if( auto pTimeField = dynamic_cast< const SvxExtTimeField *>( m_pField ) )
+    {
+        SvxTimeType   eType;
+        SvxTimeFormat eFormat;
+        sal_uInt16 i;
+
+        if (m_xPopup->get_active("1"))
+            eType = SvxTimeType::Fix;
+        else
+            eType = SvxTimeType::Var;
+
+        for( i = 3; i < nCount; i++ )
+        {
+            if (m_xPopup->get_active(OString::number(i)))
+                break;
+        }
+        eFormat = static_cast<SvxTimeFormat>( i - 1 );
+
+        if( pTimeField->GetFormat() != eFormat ||
+            pTimeField->GetType() != eType )
+        {
+            pNewField = new SvxExtTimeField( *pTimeField );
+            static_cast<SvxExtTimeField*>( pNewField )->SetType( eType );
+            static_cast<SvxExtTimeField*>( pNewField )->SetFormat( eFormat );
+
+            if( (pTimeField->GetType() == SvxTimeType::Var) && (eType == SvxTimeType::Fix) )
+            {
+                tools::Time aTime( tools::Time::SYSTEM );
+                static_cast<SvxExtTimeField*>( pNewField )->SetFixTime( aTime );
+            }
+
+        }
+    }
+    else if( auto pFileField = dynamic_cast< const SvxExtFileField *>( m_pField ) )
+    {
+        SvxFileType   eType;
+        SvxFileFormat eFormat;
+        sal_uInt16 i;
+
+        if (m_xPopup->get_active("1"))
+            eType = SvxFileType::Fix;
+        else
+            eType = SvxFileType::Var;
+
+        for( i = 3; i < nCount; i++ )
+        {
+            if (m_xPopup->get_active(OString::number(i)))
+                break;
+        }
+        eFormat = static_cast<SvxFileFormat>( i - 3 );
+
+        if( pFileField->GetFormat() != eFormat ||
+            pFileField->GetType() != eType )
+        {
+            ::sd::DrawDocShell* pDocSh = dynamic_cast<::sd::DrawDocShell* >( SfxObjectShell::Current() );
+
+            if( pDocSh )
+            {
+                OUString aName;
+                if( pDocSh->HasName() )
+                    aName = pDocSh->GetMedium()->GetName();
+
+                // Get current filename, not the one stored in the old field
+                pNewField = new SvxExtFileField( aName );
+                static_cast<SvxExtFileField*>( pNewField )->SetType( eType );
+                static_cast<SvxExtFileField*>( pNewField )->SetFormat( eFormat );
+            }
+        }
+    }
+    else if( auto pAuthorField = dynamic_cast< const SvxAuthorField *>( m_pField ) )
+    {
+        SvxAuthorType   eType;
+        SvxAuthorFormat eFormat;
+        sal_uInt16 i;
+
+        if (m_xPopup->get_active("1"))
+            eType = SvxAuthorType::Fix;
+        else
+            eType = SvxAuthorType::Var;
+
+        for( i = 3; i < nCount; i++ )
+        {
+            if (m_xPopup->get_active(OString::number(i)))
+                break;
+        }
+        eFormat = static_cast<SvxAuthorFormat>( i - 3 );
+
+        if( pAuthorField->GetFormat() != eFormat ||
+            pAuthorField->GetType() != eType )
+        {
+            // Get current state of address, not the old one
+            SvtUserOptions aUserOptions;
+            pNewField = new SvxAuthorField( aUserOptions.GetFirstName(), aUserOptions.GetLastName(), aUserOptions.GetID() );
+            static_cast<SvxAuthorField*>( pNewField )->SetType( eType );
+            static_cast<SvxAuthorField*>( pNewField )->SetFormat( eFormat );
+        }
+    }
+    return pNewField;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/sdxfer.cxx b/sd/source/ui/app/sdxfer.cxx
new file mode 100644
index 000000000..67016fd19
--- /dev/null
+++ b/sd/source/ui/app/sdxfer.cxx
@@ -0,0 +1,807 @@
+/* -*- 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/embed/XEmbeddedObject.hpp>
+#include <com/sun/star/embed/XTransactedObject.hpp>
+#include <com/sun/star/embed/XEmbedPersist.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <comphelper/fileformat.h>
+#include <unotools/ucbstreamhelper.hxx>
+#include <unotools/tempfile.hxx>
+#include <editeng/flditem.hxx>
+#include <svx/svdpagv.hxx>
+#include <svx/svdoole2.hxx>
+#include <svx/svdograf.hxx>
+#include <svx/svdotext.hxx>
+#include <editeng/outlobj.hxx>
+#include <sot/storage.hxx>
+#include <editeng/editobj.hxx>
+#include <o3tl/safeint.hxx>
+#include <svx/svdobjkind.hxx>
+#include <svx/svdouno.hxx>
+#include <svx/ImageMapInfo.hxx>
+#include <sot/formats.hxx>
+#include <svl/urlbmk.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <com/sun/star/form/FormButtonType.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <unotools/streamwrap.hxx>
+
+#include <svx/svdotable.hxx>
+#include <svx/unomodel.hxx>
+#include <svx/svditer.hxx>
+#include <sfx2/docfile.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <svtools/embedtransfer.hxx>
+#include <DrawDocShell.hxx>
+#include <View.hxx>
+#include <sdmod.hxx>
+#include <sdpage.hxx>
+#include <drawdoc.hxx>
+#include <stlpool.hxx>
+#include <sdxfer.hxx>
+#include <unomodel.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/svapp.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::io;
+using namespace ::com::sun::star::datatransfer;
+using namespace ::com::sun::star::datatransfer::clipboard;
+
+constexpr sal_uInt32 SDTRANSFER_OBJECTTYPE_DRAWMODEL = 1;
+constexpr sal_uInt32 SDTRANSFER_OBJECTTYPE_DRAWOLE   = 2;
+
+SdTransferable::SdTransferable( SdDrawDocument* pSrcDoc, ::sd::View* pWorkView, bool bInitOnGetData )
+:   mpPageDocShell( nullptr )
+,   mpSdView( pWorkView )
+,   mpSdViewIntern( pWorkView )
+,   mpSdDrawDocument( nullptr )
+,   mpSdDrawDocumentIntern( nullptr )
+,   mpSourceDoc( pSrcDoc )
+,   mpVDev( nullptr )
+,   mbInternalMove( false )
+,   mbOwnDocument( false )
+,   mbOwnView( false )
+,   mbLateInit( bInitOnGetData )
+,   mbPageTransferable( false )
+,   mbPageTransferablePersistent( false )
+{
+    if( mpSourceDoc )
+        StartListening( *mpSourceDoc );
+
+    if( pWorkView )
+        StartListening( *pWorkView );
+
+    if( !mbLateInit )
+        CreateData();
+}
+
+SdTransferable::~SdTransferable()
+{
+    SolarMutexGuard g;
+
+    if( mpSourceDoc )
+        EndListening( *mpSourceDoc );
+
+    if( mpSdView )
+        EndListening( *const_cast< sd::View *>( mpSdView) );
+
+    ObjectReleased();
+
+    if( mbOwnView )
+        delete mpSdViewIntern;
+
+    mpOLEDataHelper.reset();
+
+    if( maDocShellRef.is() )
+    {
+        SfxObjectShell* pObj = maDocShellRef.get();
+        ::sd::DrawDocShell* pDocSh = static_cast< ::sd::DrawDocShell*>(pObj);
+        pDocSh->DoClose();
+    }
+
+    maDocShellRef.clear();
+
+    if( mbOwnDocument )
+        delete mpSdDrawDocumentIntern;
+
+    mpGraphic.reset();
+    mpBookmark.reset();
+    mpImageMap.reset();
+
+    mpVDev.disposeAndClear();
+    mpObjDesc.reset();
+
+    //call explicitly at end of dtor to be covered by above SolarMutex
+    maUserData.clear();
+}
+
+void SdTransferable::CreateObjectReplacement( SdrObject* pObj )
+{
+    if( !pObj )
+        return;
+
+    mpOLEDataHelper.reset();
+    mpGraphic.reset();
+    mpBookmark.reset();
+    mpImageMap.reset();
+
+    if( auto pOleObj = dynamic_cast< SdrOle2Obj* >( pObj ) )
+    {
+        try
+        {
+            uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef();
+            uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY );
+            if( xObj.is() && xPersist.is() && xPersist->hasEntry() )
+            {
+                mpOLEDataHelper.reset( new TransferableDataHelper( new SvEmbedTransferHelper( xObj, pOleObj->GetGraphic(), pOleObj->GetAspect() ) ) );
+
+                // TODO/LATER: the standalone handling of the graphic should not be used any more in future
+                // The EmbedDataHelper should bring the graphic in future
+                const Graphic* pObjGr = pOleObj->GetGraphic();
+                if ( pObjGr )
+                    mpGraphic.reset( new Graphic( *pObjGr ) );
+            }
+        }
+        catch( uno::Exception& )
+        {}
+    }
+    else if( dynamic_cast< const SdrGrafObj *>( pObj ) !=  nullptr && (mpSourceDoc && !SdDrawDocument::GetAnimationInfo( pObj )) )
+    {
+        mpGraphic.reset( new Graphic( static_cast< SdrGrafObj* >( pObj )->GetTransformedGraphic() ) );
+    }
+    else if( pObj->IsUnoObj() && SdrInventor::FmForm == pObj->GetObjInventor() && ( pObj->GetObjIdentifier() == SdrObjKind::FormButton ) )
+    {
+        SdrUnoObj* pUnoCtrl = static_cast< SdrUnoObj* >( pObj );
+
+        if (SdrInventor::FmForm == pUnoCtrl->GetObjInventor())
+        {
+            const Reference< css::awt::XControlModel >& xControlModel( pUnoCtrl->GetUnoControlModel() );
+
+            if( !xControlModel.is() )
+                return;
+
+            Reference< css::beans::XPropertySet > xPropSet( xControlModel, UNO_QUERY );
+
+            if( !xPropSet.is() )
+                return;
+
+            css::form::FormButtonType  eButtonType;
+            Any                                     aTmp( xPropSet->getPropertyValue( "ButtonType" ) );
+
+            if( aTmp >>= eButtonType )
+            {
+                OUString aLabel, aURL;
+
+                xPropSet->getPropertyValue( "Label" ) >>= aLabel;
+                xPropSet->getPropertyValue( "TargetURL" ) >>= aURL;
+
+                mpBookmark.reset( new INetBookmark( aURL, aLabel ) );
+            }
+        }
+    }
+    else if( auto pTextObj = dynamic_cast< SdrTextObj *>( pObj ) )
+    {
+        const OutlinerParaObject* pPara;
+
+        if( (pPara = pTextObj->GetOutlinerParaObject()) != nullptr )
+        {
+            const SvxFieldItem* pField;
+
+            if( (pField = pPara->GetTextObject().GetField()) != nullptr )
+            {
+                const SvxFieldData* pData = pField->GetField();
+
+                if( auto pURL = dynamic_cast< const SvxURLField *>( pData ) )
+                {
+                    // #i63399# This special code identifies TextFrames which have just a URL
+                    // as content and directly add this to the clipboard, probably to avoid adding
+                    // an unnecessary DrawObject to the target where paste may take place. This is
+                    // wanted only for SdrObjects with no fill and no line, else it is necessary to
+                    // use the whole SdrObject. Test here for Line/FillStyle and take shortcut only
+                    // when both are unused
+                    if(!pObj->HasFillStyle() && !pObj->HasLineStyle())
+                    {
+                        mpBookmark.reset( new INetBookmark( pURL->GetURL(), pURL->GetRepresentation() ) );
+                    }
+                }
+            }
+        }
+    }
+
+    SvxIMapInfo* pInfo = SvxIMapInfo::GetIMapInfo( pObj );
+
+    if( pInfo )
+        mpImageMap.reset( new ImageMap( pInfo->GetImageMap() ) );
+}
+
+void SdTransferable::CreateData()
+{
+    if( mpSdDrawDocument && !mpSdViewIntern )
+    {
+        mbOwnView = true;
+
+        SdPage* pPage = mpSdDrawDocument->GetSdPage(0, PageKind::Standard);
+
+        if( pPage && 1 == pPage->GetObjCount() )
+            CreateObjectReplacement( pPage->GetObj( 0 ) );
+
+        mpVDev = VclPtr<VirtualDevice>::Create( *Application::GetDefaultDevice() );
+        mpVDev->SetMapMode( MapMode( mpSdDrawDocumentIntern->GetScaleUnit(), Point(), mpSdDrawDocumentIntern->GetScaleFraction(), mpSdDrawDocumentIntern->GetScaleFraction() ) );
+        mpSdViewIntern = new ::sd::View( *mpSdDrawDocumentIntern, mpVDev );
+        mpSdViewIntern->EndListening(*mpSdDrawDocumentIntern );
+        mpSdViewIntern->hideMarkHandles();
+        SdrPageView* pPageView = mpSdViewIntern->ShowSdrPage(pPage);
+        mpSdViewIntern->MarkAllObj(pPageView);
+    }
+    else if( mpSdView && !mpSdDrawDocumentIntern )
+    {
+        const SdrMarkList& rMarkList = mpSdView->GetMarkedObjectList();
+
+        if( rMarkList.GetMarkCount() == 1 )
+            CreateObjectReplacement( rMarkList.GetMark( 0 )->GetMarkedSdrObj() );
+
+        if( mpSourceDoc )
+            mpSourceDoc->CreatingDataObj(this);
+        mpSdDrawDocumentIntern = static_cast<SdDrawDocument*>( mpSdView->CreateMarkedObjModel().release() );
+        if( mpSourceDoc )
+            mpSourceDoc->CreatingDataObj(nullptr);
+
+        if( !maDocShellRef.is() && mpSdDrawDocumentIntern->GetDocSh() )
+            maDocShellRef = mpSdDrawDocumentIntern->GetDocSh();
+
+        if( !maDocShellRef.is() )
+        {
+            OSL_FAIL( "SdTransferable::CreateData(), failed to create a model with persist, clipboard operation will fail for OLE objects!" );
+            mbOwnDocument = true;
+        }
+
+        // Use dimension of source page
+        SdrPageView*        pPgView = mpSdView->GetSdrPageView();
+        SdPage*             pOldPage = static_cast<SdPage*>( pPgView->GetPage() );
+        SdrModel*           pOldModel = mpSdView->GetModel();
+        SdStyleSheetPool*   pOldStylePool = static_cast<SdStyleSheetPool*>( pOldModel->GetStyleSheetPool() );
+        SdStyleSheetPool*   pNewStylePool = static_cast<SdStyleSheetPool*>( mpSdDrawDocumentIntern->GetStyleSheetPool() );
+        SdPage*             pPage = mpSdDrawDocumentIntern->GetSdPage( 0, PageKind::Standard );
+        OUString            aOldLayoutName( pOldPage->GetLayoutName() );
+
+        pPage->SetSize( pOldPage->GetSize() );
+        pPage->SetLayoutName( aOldLayoutName );
+        pNewStylePool->CopyGraphicSheets( *pOldStylePool );
+        pNewStylePool->CopyCellSheets( *pOldStylePool );
+        pNewStylePool->CopyTableStyles( *pOldStylePool );
+        sal_Int32 nPos = aOldLayoutName.indexOf( SD_LT_SEPARATOR );
+        if( nPos != -1 )
+            aOldLayoutName = aOldLayoutName.copy( 0, nPos );
+        StyleSheetCopyResultVector aCreatedSheets;
+        pNewStylePool->CopyLayoutSheets( aOldLayoutName, *pOldStylePool, aCreatedSheets );
+    }
+
+    // set VisArea and adjust objects if necessary
+    if( !(maVisArea.IsEmpty() &&
+        mpSdDrawDocumentIntern && mpSdViewIntern &&
+        mpSdDrawDocumentIntern->GetPageCount()) )
+        return;
+
+    SdPage* pPage = mpSdDrawDocumentIntern->GetSdPage( 0, PageKind::Standard );
+
+    if( 1 == mpSdDrawDocumentIntern->GetPageCount() )
+    {
+        // #112978# need to use GetAllMarkedBoundRect instead of GetAllMarkedRect to get
+        // fat lines correctly
+        maVisArea = mpSdViewIntern->GetAllMarkedBoundRect();
+        Point   aOrigin( maVisArea.TopLeft() );
+        Size    aVector( -aOrigin.X(), -aOrigin.Y() );
+
+        for( size_t nObj = 0, nObjCount = pPage->GetObjCount(); nObj < nObjCount; ++nObj )
+        {
+            SdrObject* pObj = pPage->GetObj( nObj );
+            pObj->NbcMove( aVector );
+        }
+    }
+    else
+        maVisArea.SetSize( pPage->GetSize() );
+
+    // output is at the zero point
+    maVisArea.SetPos( Point() );
+}
+
+static bool lcl_HasOnlyControls( SdrModel* pModel )
+{
+    bool bOnlyControls = false;         // default if there are no objects
+
+    if ( pModel )
+    {
+        SdrPage* pPage = pModel->GetPage(0);
+        if (pPage)
+        {
+            SdrObjListIter aIter( pPage, SdrIterMode::DeepNoGroups );
+            SdrObject* pObj = aIter.Next();
+            if ( pObj )
+            {
+                bOnlyControls = true;   // only set if there are any objects at all
+                while ( pObj )
+                {
+                    if (dynamic_cast< const SdrUnoObj *>( pObj ) ==  nullptr)
+                    {
+                        bOnlyControls = false;
+                        break;
+                    }
+                    pObj = aIter.Next();
+                }
+            }
+        }
+    }
+
+    return bOnlyControls;
+}
+
+static bool lcl_HasOnlyOneTable( SdrModel* pModel )
+{
+    if ( pModel )
+    {
+        SdrPage* pPage = pModel->GetPage(0);
+        if (pPage && pPage->GetObjCount() == 1 )
+        {
+            if( dynamic_cast< sdr::table::SdrTableObj* >( pPage->GetObj(0) ) != nullptr )
+                return true;
+        }
+    }
+    return false;
+}
+
+void SdTransferable::AddSupportedFormats()
+{
+    if( mbPageTransferable && !mbPageTransferablePersistent )
+        return;
+
+    if( !mbLateInit )
+        CreateData();
+
+    if( mpObjDesc )
+        AddFormat( SotClipboardFormatId::OBJECTDESCRIPTOR );
+
+    if( mpOLEDataHelper )
+    {
+        AddFormat( SotClipboardFormatId::EMBED_SOURCE );
+
+        DataFlavorExVector              aVector( mpOLEDataHelper->GetDataFlavorExVector() );
+
+        for( const auto& rItem : aVector )
+            AddFormat( rItem );
+    }
+    else if( mpGraphic )
+    {
+        // #i25616#
+        AddFormat( SotClipboardFormatId::DRAWING );
+
+        AddFormat( SotClipboardFormatId::SVXB );
+
+        if( mpGraphic->GetType() == GraphicType::Bitmap )
+        {
+            AddFormat( SotClipboardFormatId::PNG );
+            AddFormat( SotClipboardFormatId::BITMAP );
+            AddFormat( SotClipboardFormatId::GDIMETAFILE );
+        }
+        else
+        {
+            AddFormat( SotClipboardFormatId::GDIMETAFILE );
+            AddFormat( SotClipboardFormatId::PNG );
+            AddFormat( SotClipboardFormatId::BITMAP );
+        }
+    }
+    else if( mpBookmark )
+    {
+        AddFormat( SotClipboardFormatId::NETSCAPE_BOOKMARK );
+        AddFormat( SotClipboardFormatId::STRING );
+    }
+    else
+    {
+        AddFormat( SotClipboardFormatId::EMBED_SOURCE );
+        AddFormat( SotClipboardFormatId::DRAWING );
+        if( !mpSdDrawDocument || !lcl_HasOnlyControls( mpSdDrawDocument ) )
+        {
+            AddFormat( SotClipboardFormatId::GDIMETAFILE );
+            AddFormat( SotClipboardFormatId::PNG );
+            AddFormat( SotClipboardFormatId::BITMAP );
+        }
+
+        if( lcl_HasOnlyOneTable( mpSdDrawDocument ) ) {
+            AddFormat( SotClipboardFormatId::RTF );
+            AddFormat( SotClipboardFormatId::RICHTEXT );
+        }
+    }
+
+    if( mpImageMap )
+        AddFormat( SotClipboardFormatId::SVIM );
+}
+
+bool SdTransferable::GetData( const DataFlavor& rFlavor, const OUString& rDestDoc )
+{
+    if (SD_MOD()==nullptr)
+        return false;
+
+    SotClipboardFormatId nFormat = SotExchange::GetFormat( rFlavor );
+    bool        bOK = false;
+
+    CreateData();
+
+    if( nFormat == SotClipboardFormatId::RTF && lcl_HasOnlyOneTable( mpSdDrawDocument ) )
+    {
+        bOK = SetTableRTF( mpSdDrawDocument );
+    }
+    else if( mpOLEDataHelper && mpOLEDataHelper->HasFormat( rFlavor ) )
+    {
+        // TODO/LATER: support all the graphical formats, the embedded object scenario should not have separated handling
+        if( nFormat == SotClipboardFormatId::GDIMETAFILE && mpGraphic )
+            bOK = SetGDIMetaFile( mpGraphic->GetGDIMetaFile() );
+        else
+            bOK = SetAny( mpOLEDataHelper->GetAny(rFlavor, rDestDoc) );
+    }
+    else if( HasFormat( nFormat ) )
+    {
+        if( ( nFormat == SotClipboardFormatId::LINKSRCDESCRIPTOR || nFormat == SotClipboardFormatId::OBJECTDESCRIPTOR ) && mpObjDesc )
+        {
+            bOK = SetTransferableObjectDescriptor( *mpObjDesc );
+        }
+        else if( nFormat == SotClipboardFormatId::DRAWING )
+        {
+            SfxObjectShellRef aOldRef( maDocShellRef );
+
+            maDocShellRef.clear();
+
+            if( mpSdViewIntern )
+            {
+                SdDrawDocument& rInternDoc = mpSdViewIntern->GetDoc();
+                rInternDoc.CreatingDataObj(this);
+                SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( mpSdViewIntern->CreateMarkedObjModel().release() );
+                rInternDoc.CreatingDataObj(nullptr);
+
+                bOK = SetObject( pDoc, SDTRANSFER_OBJECTTYPE_DRAWMODEL, rFlavor );
+
+                if( maDocShellRef.is() )
+                {
+                    maDocShellRef->DoClose();
+                }
+                else
+                {
+                    delete pDoc;
+                }
+            }
+
+            maDocShellRef = aOldRef;
+        }
+        else if( nFormat == SotClipboardFormatId::GDIMETAFILE )
+        {
+            if (mpSdViewIntern)
+            {
+                const bool bToggleOnlineSpell = mpSdDrawDocumentIntern && mpSdDrawDocumentIntern->GetOnlineSpell();
+                if (bToggleOnlineSpell)
+                    mpSdDrawDocumentIntern->SetOnlineSpell(false);
+                bOK = SetGDIMetaFile( mpSdViewIntern->GetMarkedObjMetaFile( true ) );
+                if (bToggleOnlineSpell)
+                    mpSdDrawDocumentIntern->SetOnlineSpell(true);
+            }
+        }
+        else if( SotClipboardFormatId::BITMAP == nFormat || SotClipboardFormatId::PNG == nFormat )
+        {
+            if (mpSdViewIntern)
+            {
+                const bool bToggleOnlineSpell = mpSdDrawDocumentIntern && mpSdDrawDocumentIntern->GetOnlineSpell();
+                if (bToggleOnlineSpell)
+                    mpSdDrawDocumentIntern->SetOnlineSpell(false);
+                bOK = SetBitmapEx( mpSdViewIntern->GetMarkedObjBitmapEx(true), rFlavor );
+                if (bToggleOnlineSpell)
+                    mpSdDrawDocumentIntern->SetOnlineSpell(true);
+            }
+        }
+        else if( ( nFormat == SotClipboardFormatId::STRING ) && mpBookmark )
+        {
+            bOK = SetString( mpBookmark->GetURL() );
+        }
+        else if( ( nFormat == SotClipboardFormatId::SVXB ) && mpGraphic )
+        {
+            bOK = SetGraphic( *mpGraphic );
+        }
+        else if( ( nFormat == SotClipboardFormatId::SVIM ) && mpImageMap )
+        {
+            bOK = SetImageMap( *mpImageMap );
+        }
+        else if( mpBookmark )
+        {
+            bOK = SetINetBookmark( *mpBookmark, rFlavor );
+        }
+        else if( nFormat == SotClipboardFormatId::EMBED_SOURCE )
+        {
+            if( mpSdDrawDocumentIntern )
+            {
+                if( !maDocShellRef.is() )
+                {
+                    maDocShellRef = new ::sd::DrawDocShell(
+                        mpSdDrawDocumentIntern,
+                        SfxObjectCreateMode::EMBEDDED,
+                        true,
+                        mpSdDrawDocumentIntern->GetDocumentType());
+                    mbOwnDocument = false;
+                    maDocShellRef->DoInitNew();
+                }
+
+                maDocShellRef->SetVisArea( maVisArea );
+                bOK = SetObject( maDocShellRef.get(), SDTRANSFER_OBJECTTYPE_DRAWOLE, rFlavor );
+            }
+        }
+    }
+
+    return bOK;
+}
+
+bool SdTransferable::WriteObject( tools::SvRef<SotTempStream>& rxOStm, void* pObject, sal_uInt32 nObjectType, const DataFlavor& )
+{
+    bool bRet = false;
+
+    switch( nObjectType )
+    {
+        case SDTRANSFER_OBJECTTYPE_DRAWMODEL:
+        {
+            try
+            {
+                static const bool bDontBurnInStyleSheet = ( getenv( "AVOID_BURN_IN_FOR_GALLERY_THEME" ) != nullptr );
+                SdDrawDocument* pDoc = static_cast<SdDrawDocument*>(pObject);
+                if ( !bDontBurnInStyleSheet )
+                    pDoc->BurnInStyleSheetAttributes();
+                rxOStm->SetBufferSize( 16348 );
+
+                Reference< XComponent > xComponent( new SdXImpressDocument( pDoc, true ) );
+                pDoc->setUnoModel( Reference< XInterface >::query( xComponent ) );
+
+                {
+                    css::uno::Reference<css::io::XOutputStream> xDocOut( new utl::OOutputStreamWrapper( *rxOStm ) );
+                    SvxDrawingLayerExport( pDoc, xDocOut, xComponent, (pDoc->GetDocumentType() == DocumentType::Impress) ? "com.sun.star.comp.Impress.XMLClipboardExporter" : "com.sun.star.comp.DrawingLayer.XMLExporter" );
+                }
+
+                xComponent->dispose();
+                bRet = ( rxOStm->GetError() == ERRCODE_NONE );
+            }
+            catch( Exception& )
+            {
+                TOOLS_WARN_EXCEPTION( "sd", "sd::SdTransferable::WriteObject()" );
+                bRet = false;
+            }
+        }
+        break;
+
+        case SDTRANSFER_OBJECTTYPE_DRAWOLE:
+        {
+            SfxObjectShell*   pEmbObj = static_cast<SfxObjectShell*>(pObject);
+            ::utl::TempFile     aTempFile;
+            aTempFile.EnableKillingFile();
+
+            try
+            {
+                uno::Reference< embed::XStorage > xWorkStore =
+                    ::comphelper::OStorageHelper::GetStorageFromURL( aTempFile.GetURL(), embed::ElementModes::READWRITE );
+
+                // write document storage
+                pEmbObj->SetupStorage( xWorkStore, SOFFICE_FILEFORMAT_CURRENT, false );
+                // mba: no relative URLs for clipboard!
+                SfxMedium aMedium( xWorkStore, OUString() );
+                pEmbObj->DoSaveObjectAs( aMedium, false );
+                pEmbObj->DoSaveCompleted();
+
+                uno::Reference< embed::XTransactedObject > xTransact( xWorkStore, uno::UNO_QUERY );
+                if ( xTransact.is() )
+                    xTransact->commit();
+
+                std::unique_ptr<SvStream> pSrcStm = ::utl::UcbStreamHelper::CreateStream( aTempFile.GetURL(), StreamMode::READ );
+                if( pSrcStm )
+                {
+                    rxOStm->SetBufferSize( 0xff00 );
+                    rxOStm->WriteStream( *pSrcStm );
+                    pSrcStm.reset();
+                }
+
+                bRet = true;
+            }
+            catch ( Exception& )
+            {}
+        }
+
+        break;
+
+        default:
+        break;
+    }
+
+    return bRet;
+}
+
+void SdTransferable::DragFinished( sal_Int8 nDropAction )
+{
+    if( mpSdView )
+        const_cast< ::sd::View* >(mpSdView)->DragFinished( nDropAction );
+}
+
+void SdTransferable::ObjectReleased()
+{
+    SdModule *pModule = SD_MOD();
+    if (!pModule)
+        return;
+
+    if( this == pModule->pTransferClip )
+        pModule->pTransferClip = nullptr;
+
+    if( this == pModule->pTransferDrag )
+        pModule->pTransferDrag = nullptr;
+
+    if( this == pModule->pTransferSelection )
+        pModule->pTransferSelection = nullptr;
+}
+
+void SdTransferable::SetObjectDescriptor( std::unique_ptr<TransferableObjectDescriptor> pObjDesc )
+{
+    mpObjDesc = std::move(pObjDesc);
+    PrepareOLE( *mpObjDesc );
+}
+
+void SdTransferable::SetPageBookmarks( std::vector<OUString> && rPageBookmarks, bool bPersistent )
+{
+    if( !mpSourceDoc )
+        return;
+
+    if( mpSdViewIntern )
+        mpSdViewIntern->HideSdrPage();
+
+    mpSdDrawDocument->ClearModel(false);
+
+    mpPageDocShell = nullptr;
+
+    maPageBookmarks.clear();
+
+    if( bPersistent )
+    {
+        mpSdDrawDocument->CreateFirstPages(mpSourceDoc);
+        mpSdDrawDocument->InsertBookmarkAsPage( rPageBookmarks, nullptr, false, true, 1, true,
+                                                mpSourceDoc->GetDocSh(), true, true, false );
+    }
+    else
+    {
+        mpPageDocShell = mpSourceDoc->GetDocSh();
+        maPageBookmarks = std::move(rPageBookmarks);
+    }
+
+    if( mpSdViewIntern )
+    {
+        SdPage* pPage = mpSdDrawDocument->GetSdPage( 0, PageKind::Standard );
+
+        if( pPage )
+        {
+            mpSdViewIntern->MarkAllObj( mpSdViewIntern->ShowSdrPage( pPage ) );
+        }
+    }
+
+    // set flags for page transferable; if ( mbPageTransferablePersistent == sal_False ),
+    // don't offer any formats => it's just for internal purposes
+    mbPageTransferable = true;
+    mbPageTransferablePersistent = bPersistent;
+}
+
+sal_Int64 SAL_CALL SdTransferable::getSomething( const css::uno::Sequence< sal_Int8 >& rId )
+{
+    return comphelper::getSomethingImpl(rId, this);
+}
+
+void SdTransferable::AddUserData (const std::shared_ptr<UserData>& rpData)
+{
+    maUserData.push_back(rpData);
+}
+
+sal_Int32 SdTransferable::GetUserDataCount() const
+{
+    return maUserData.size();
+}
+
+std::shared_ptr<SdTransferable::UserData> SdTransferable::GetUserData (const sal_Int32 nIndex) const
+{
+    if (nIndex>=0 && o3tl::make_unsigned(nIndex)<maUserData.size())
+        return maUserData[nIndex];
+    else
+        return std::shared_ptr<UserData>();
+}
+
+const css::uno::Sequence< sal_Int8 >& SdTransferable::getUnoTunnelId()
+{
+    static const comphelper::UnoIdInit theSdTransferableUnoTunnelId;
+    return theSdTransferableUnoTunnelId.getSeq();
+}
+
+SdTransferable* SdTransferable::getImplementation( const Reference< XInterface >& rxData ) noexcept
+{
+    try
+    {
+        return comphelper::getFromUnoTunnel<SdTransferable>(rxData);
+    }
+    catch( const css::uno::Exception& )
+    {
+    }
+    return nullptr;
+}
+
+void SdTransferable::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
+{
+    if (rHint.GetId() == SfxHintId::ThisIsAnSdrHint)
+    {
+        const SdrHint* pSdrHint = static_cast< const SdrHint* >( &rHint );
+        if( SdrHintKind::ModelCleared == pSdrHint->GetKind() )
+        {
+            EndListening(*mpSourceDoc);
+            mpSourceDoc = nullptr;
+        }
+    }
+    else
+    {
+        if( rHint.GetId() == SfxHintId::Dying )
+        {
+            if( &rBC == mpSourceDoc )
+                mpSourceDoc = nullptr;
+            if( &rBC == mpSdViewIntern )
+                mpSdViewIntern = nullptr;
+            if( &rBC == mpSdView )
+                mpSdView = nullptr;
+        }
+    }
+}
+
+void SdTransferable::SetView(const ::sd::View* pView)
+{
+    if (mpSdView)
+        EndListening(*const_cast<sd::View*>(mpSdView));
+    mpSdView = pView;
+    if (mpSdView)
+        StartListening(*const_cast<sd::View*>(mpSdView));
+}
+
+bool SdTransferable::SetTableRTF( SdDrawDocument* pModel )
+{
+    if ( pModel )
+    {
+        SdrPage* pPage = pModel->GetPage(0);
+        if (pPage && pPage->GetObjCount() == 1 )
+        {
+            sdr::table::SdrTableObj* pTableObj = dynamic_cast< sdr::table::SdrTableObj* >( pPage->GetObj(0) );
+            if( pTableObj )
+            {
+                SvMemoryStream aMemStm( 65535, 65535 );
+                sdr::table::ExportAsRTF( aMemStm, *pTableObj );
+                return SetAny( Any( Sequence< sal_Int8 >( static_cast< const sal_Int8* >( aMemStm.GetData() ), aMemStm.TellEnd() ) ) );
+            }
+        }
+    }
+
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sd/source/ui/app/tmplctrl.cxx b/sd/source/ui/app/tmplctrl.cxx
new file mode 100644
index 000000000..1f645bf66
--- /dev/null
+++ b/sd/source/ui/app/tmplctrl.cxx
@@ -0,0 +1,110 @@
+/* -*- 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 <vcl/commandevent.hxx>
+#include <vcl/status.hxx>
+#include <vcl/weldutils.hxx>
+#include <svl/stritem.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+
+#include <tmplctrl.hxx>
+#include <ViewShellBase.hxx>
+#include <drawdoc.hxx>
+#include <sdpage.hxx>
+#include <sdattr.hrc>
+#include <app.hrc>
+#include <sdresid.hxx>
+#include <strings.hrc>
+
+SFX_IMPL_STATUSBAR_CONTROL( SdTemplateControl, SfxStringItem );
+
+// class SdTemplateControl ------------------------------------------
+SdTemplateControl::SdTemplateControl( sal_uInt16 _nSlotId,
+                                      sal_uInt16 _nId,
+                                      StatusBar& rStb ) :
+    SfxStatusBarControl( _nSlotId, _nId, rStb )
+{
+    GetStatusBar().SetQuickHelpText(GetId(), SdResId(STR_STATUSBAR_MASTERPAGE));
+}
+
+SdTemplateControl::~SdTemplateControl()
+{
+}
+
+void SdTemplateControl::StateChangedAtStatusBarControl(
+    sal_uInt16 /*nSID*/, SfxItemState eState, const SfxPoolItem* pState )
+{
+    if( eState != SfxItemState::DEFAULT || pState->IsVoidItem() )
+        GetStatusBar().SetItemText( GetId(), OUString() );
+    else if ( auto pStringItem = dynamic_cast< const SfxStringItem *>( pState ) )
+    {
+        msTemplate = pStringItem->GetValue();
+        GetStatusBar().SetItemText( GetId(), msTemplate );
+    }
+}
+
+void SdTemplateControl::Paint( const UserDrawEvent&  )
+{
+}
+
+void SdTemplateControl::Command( const CommandEvent& rCEvt )
+{
+    if ( rCEvt.GetCommand() != CommandEventId::ContextMenu || GetStatusBar().GetItemText( GetId() ).isEmpty() )
+        return;
+
+    SfxViewFrame* pViewFrame = SfxViewFrame::Current();
+
+    sd::ViewShellBase* pViewShellBase = sd::ViewShellBase::GetViewShellBase( pViewFrame );
+    if( !pViewShellBase )
+        return;
+
+    SdDrawDocument* pDoc = pViewShellBase->GetDocument();
+    if( !pDoc )
+        return;
+
+    std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(nullptr, "modules/simpress/ui/masterpagemenu.ui"));
+    std::unique_ptr<weld::Menu> xPopup(xBuilder->weld_menu("menu"));
+
+    const sal_uInt16 nMasterCount = pDoc->GetMasterSdPageCount(PageKind::Standard);
+
+    for (sal_uInt16 nPage = 0; nPage < nMasterCount; ++nPage)
+    {
+        SdPage* pMaster = pDoc->GetMasterSdPage(nPage, PageKind::Standard);
+        if (!pMaster)
+            continue;
+        xPopup->append(OUString::number(nPage), pMaster->GetName());
+    }
+
+    ::tools::Rectangle aRect(rCEvt.GetMousePosPixel(), Size(1, 1));
+    weld::Window* pParent = weld::GetPopupParent(GetStatusBar(), aRect);
+    OString sResult = xPopup->popup_at_rect(pParent, aRect);
+    if (!sResult.isEmpty())
+    {
+        sal_uInt16 nCurrId = sResult.toUInt32();
+        SdPage* pMaster = pDoc->GetMasterSdPage(nCurrId, PageKind::Standard);
+        SfxStringItem aStyle( ATTR_PRESLAYOUT_NAME, pMaster->GetName() );
+        pViewFrame->GetDispatcher()->ExecuteList(
+            SID_PRESENTATION_LAYOUT, SfxCallMode::SLOT, { &aStyle });
+        pViewFrame->GetBindings().Invalidate(SID_PRESENTATION_LAYOUT);
+        pViewFrame->GetBindings().Invalidate(SID_STATUS_LAYOUT);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */