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

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

49 files changed, 23421 insertions, 0 deletions

diff --git a/sfx2/source/appl/app.cxx b/sfx2/source/appl/app.cxx
new file mode 100644
index 000000000..6844f919c
--- /dev/null
+++ b/sfx2/source/appl/app.cxx
@@ -0,0 +1,516 @@
+/* -*- 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_feature_desktop.h>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+
+#include <sfx2/app.hxx>
+#include <sfx2/frame.hxx>
+#include <basic/sberrors.hxx>
+#include <tools/svlibrary.h>
+
+#include <svl/svdde.hxx>
+#include <unotools/configmgr.hxx>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <comphelper/processfactory.hxx>
+#include <com/sun/star/uri/UriReferenceFactory.hpp>
+#include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
+#include <basic/basmgr.hxx>
+#include <vcl/svapp.hxx>
+#include <sfx2/sfxhelp.hxx>
+#include <sfx2/progress.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <appdata.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/event.hxx>
+#include <workwin.hxx>
+#include <sfx2/sidebar/Theme.hxx>
+#include <sfx2/tbxctrl.hxx>
+#include <sfx2/sfxdlg.hxx>
+#include <sfx2/stbitem.hxx>
+#include <sfx2/dockwin.hxx>
+#include <shellimpl.hxx>
+
+#include <svtools/helpopt.hxx>
+#include <unotools/viewoptions.hxx>
+#include <rtl/instance.hxx>
+#include <rtl/strbuf.hxx>
+#include <memory>
+#include <framework/sfxhelperfunctions.hxx>
+#include <fwkhelper.hxx>
+
+#include "getbasctlfunction.hxx"
+
+using namespace ::com::sun::star;
+
+static SfxApplication* g_pSfxApplication = nullptr;
+
+#if HAVE_FEATURE_DESKTOP
+static SfxHelp*        pSfxHelp = nullptr;
+#endif
+
+namespace
+{
+    class theApplicationMutex
+        : public rtl::Static<osl::Mutex, theApplicationMutex> {};
+}
+
+SfxApplication* SfxApplication::Get()
+{
+    return g_pSfxApplication;
+}
+
+void SfxApplication::SetModule(SfxToolsModule nSharedLib, std::unique_ptr<SfxModule> pModule)
+{
+    assert(g_pSfxApplication != nullptr);
+
+    g_pSfxApplication->pImpl->aModules[nSharedLib] = std::move(pModule);
+}
+
+SfxModule* SfxApplication::GetModule(SfxToolsModule nSharedLib)
+{
+    if (!g_pSfxApplication) // It is possible GetModule is called before SfxApplication is initialised via GetOrCreate()
+        return nullptr;
+    return g_pSfxApplication->pImpl->aModules[nSharedLib].get();
+}
+
+SfxApplication* SfxApplication::GetOrCreate()
+{
+    // SFX on demand
+    ::osl::MutexGuard aGuard(theApplicationMutex::get());
+    if (!g_pSfxApplication)
+    {
+        SAL_INFO( "sfx.appl", "SfxApplication::SetApp" );
+
+        g_pSfxApplication = new SfxApplication;
+
+        // at the moment a bug may occur when Initialize_Impl returns FALSE,
+        // but this is only temporary because all code that may cause such
+        // a fault will be moved outside the SFX
+        g_pSfxApplication->Initialize_Impl();
+
+        ::framework::SetRefreshToolbars( RefreshToolbars );
+        ::framework::SetToolBoxControllerCreator( SfxToolBoxControllerFactory );
+        ::framework::SetStatusBarControllerCreator( SfxStatusBarControllerFactory );
+        ::framework::SetDockingWindowCreator( SfxDockingWindowFactory );
+        ::framework::SetIsDockingWindowVisible( IsDockingWindowVisible );
+#if HAVE_FEATURE_DESKTOP
+        Application::SetHelp( pSfxHelp );
+        if (!utl::ConfigManager::IsFuzzing() && SvtHelpOptions().IsHelpTips())
+            Help::EnableQuickHelp();
+        else
+            Help::DisableQuickHelp();
+        if (!utl::ConfigManager::IsFuzzing() && SvtHelpOptions().IsHelpTips() && SvtHelpOptions().IsExtendedHelp())
+            Help::EnableBalloonHelp();
+        else
+            Help::DisableBalloonHelp();
+#endif
+    }
+    return g_pSfxApplication;
+}
+
+SfxApplication::SfxApplication()
+    : pImpl( new SfxAppData_Impl )
+{
+    SetName( "StarOffice" );
+    if (!utl::ConfigManager::IsFuzzing())
+        SvtViewOptions::AcquireOptions();
+
+    SAL_INFO( "sfx.appl", "{ initialize DDE" );
+
+    bool bOk = InitializeDde();
+
+#ifdef DBG_UTIL
+    if( !bOk )
+    {
+        OStringBuffer aStr("No DDE-Service possible. Error: ");
+        if( GetDdeService() )
+            aStr.append(static_cast<sal_Int32>(GetDdeService()->GetError()));
+        else
+            aStr.append('?');
+        SAL_WARN( "sfx.appl", aStr.getStr() );
+    }
+#else
+    (void)bOk;
+#endif
+
+#if HAVE_FEATURE_DESKTOP
+    pSfxHelp = new SfxHelp;
+#endif
+
+#if HAVE_FEATURE_SCRIPTING
+    StarBASIC::SetGlobalErrorHdl( LINK( this, SfxApplication, GlobalBasicErrorHdl_Impl ) );
+#endif
+
+    SAL_INFO( "sfx.appl", "} initialize DDE" );
+}
+
+SfxApplication::~SfxApplication()
+{
+    SAL_WARN_IF(GetObjectShells_Impl().size() != 0, "sfx.appl", "Memory leak: some object shells were not removed!");
+
+    Broadcast( SfxHint(SfxHintId::Dying) );
+
+    for (auto &module : pImpl->aModules)    // Clear modules
+        module.reset();
+
+#if HAVE_FEATURE_DESKTOP
+    delete pSfxHelp;
+    Application::SetHelp();
+#endif
+
+    // delete global options
+    if (!utl::ConfigManager::IsFuzzing())
+        SvtViewOptions::ReleaseOptions();
+
+    if ( !pImpl->bDowning )
+        Deinitialize();
+
+    g_pSfxApplication = nullptr;
+}
+
+
+const OUString& SfxApplication::GetLastDir_Impl() const
+
+/*  [Description]
+
+    Internal method by which the last set directory with the method
+    <SfxApplication::SetLastDir_Impl()> in SFX is returned.
+
+    This is usually the most recently addressed by the
+    SfxFileDialog directory.
+
+    [Cross-reference]
+    <SfxApplication::SetLastDir_Impl()>
+*/
+
+{
+    return pImpl->aLastDir;
+}
+
+void SfxApplication::SetLastDir_Impl
+(
+    const OUString&   rNewDir     /* Complete directory path as a string */
+)
+
+/*  [Description]
+
+    Internal Method, by which a directory path is set that was last addressed
+    (eg by the SfxFileDialog).
+
+    [Cross-reference]
+    <SfxApplication::GetLastDir_Impl()>
+*/
+
+{
+    pImpl->aLastDir = rNewDir;
+}
+
+
+void SfxApplication::ResetLastDir()
+{
+    pImpl->aLastDir.clear();
+}
+
+
+SfxDispatcher* SfxApplication::GetDispatcher_Impl()
+{
+    return pImpl->pViewFrame? pImpl->pViewFrame->GetDispatcher(): pImpl->pAppDispat;
+}
+
+
+void SfxApplication::SetViewFrame_Impl( SfxViewFrame *pFrame )
+{
+    if ( pFrame != pImpl->pViewFrame )
+    {
+        SfxViewFrame *pOldFrame = pImpl->pViewFrame;
+
+        // DocWinActivate : both frames belong to the same TopWindow
+        // TopWinActivate : both frames belong to different TopWindows
+
+        bool bTaskActivate = pOldFrame != pFrame;
+
+        if ( pOldFrame )
+        {
+            if ( bTaskActivate )
+                NotifyEvent( SfxViewEventHint( SfxEventHintId::DeactivateDoc, GlobalEventConfig::GetEventName(GlobalEventId::DEACTIVATEDOC), pOldFrame->GetObjectShell(), pOldFrame->GetFrame().GetController() ) );
+            pOldFrame->DoDeactivate( bTaskActivate, pFrame );
+
+            if( pOldFrame->GetProgress() )
+                pOldFrame->GetProgress()->Suspend();
+        }
+
+        pImpl->pViewFrame = pFrame;
+
+        if( pFrame )
+        {
+            pFrame->DoActivate( bTaskActivate );
+            if ( bTaskActivate && pFrame->GetObjectShell() )
+            {
+                pFrame->GetObjectShell()->PostActivateEvent_Impl( pFrame );
+                NotifyEvent(SfxViewEventHint(SfxEventHintId::ActivateDoc, GlobalEventConfig::GetEventName(GlobalEventId::ACTIVATEDOC), pFrame->GetObjectShell(), pFrame->GetFrame().GetController() ) );
+            }
+
+            SfxProgress *pProgress = pFrame->GetProgress();
+            if ( pProgress )
+            {
+                if( pProgress->IsSuspended() )
+                    pProgress->Resume();
+                else
+                    pProgress->SetState( pProgress->GetState() );
+            }
+
+            if ( pImpl->pViewFrame->GetViewShell() )
+            {
+                SfxDispatcher* pDisp = pImpl->pViewFrame->GetDispatcher();
+                pDisp->Flush();
+                pDisp->Update_Impl(true);
+            }
+        }
+    }
+
+    // even if the frame actually didn't change, ensure its document is forwarded
+    // to SfxObjectShell::SetCurrentComponent.
+    // Otherwise, the CurrentComponent might not be correct, in case it has meanwhile
+    // been reset to some other document, by some non-SFX component. #i49133#
+    if ( pFrame && pFrame->GetViewShell() )
+        pFrame->GetViewShell()->SetCurrentDocument();
+}
+
+void SfxApplication::SetProgress_Impl
+(
+    SfxProgress *pProgress
+)
+{
+    DBG_ASSERT( ( !pImpl->pProgress && pProgress ) ||
+                ( pImpl->pProgress && !pProgress ),
+                "Progress activation/deactivation mismatch" );
+
+    if ( pImpl->pProgress && pProgress )
+    {
+        pImpl->pProgress->Suspend();
+        delete pImpl->pProgress;
+    }
+
+    pImpl->pProgress = pProgress;
+}
+
+
+sal_uInt16 SfxApplication::GetFreeIndex()
+{
+    return pImpl->aIndexBitSet.GetFreeIndex()+1;
+}
+
+
+void SfxApplication::ReleaseIndex(sal_uInt16 i)
+{
+    pImpl->aIndexBitSet.ReleaseIndex(i-1);
+}
+
+
+vcl::Window* SfxApplication::GetTopWindow() const
+{
+    SfxWorkWindow* pWork = GetWorkWindow_Impl( SfxViewFrame::Current() );
+    return pWork ? pWork->GetWindow() : nullptr;
+}
+
+SfxTbxCtrlFactArr_Impl&     SfxApplication::GetTbxCtrlFactories_Impl() const
+{
+    return *pImpl->pTbxCtrlFac;
+}
+
+SfxStbCtrlFactArr_Impl&     SfxApplication::GetStbCtrlFactories_Impl() const
+{
+    return *pImpl->pStbCtrlFac;
+}
+
+SfxViewFrameArr_Impl&       SfxApplication::GetViewFrames_Impl() const
+{
+    return *pImpl->pViewFrames;
+}
+
+SfxViewShellArr_Impl&       SfxApplication::GetViewShells_Impl() const
+{
+    return *pImpl->pViewShells;
+}
+
+SfxObjectShellArr_Impl&     SfxApplication::GetObjectShells_Impl() const
+{
+    return *pImpl->pObjShells;
+}
+
+void SfxApplication::Invalidate( sal_uInt16 nId )
+{
+    for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst(); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame ) )
+        Invalidate_Impl( pFrame->GetBindings(), nId );
+}
+
+#if HAVE_FEATURE_SCRIPTING
+
+#ifndef DISABLE_DYNLOADING
+
+typedef long (*basicide_handle_basic_error)(void const *);
+typedef void (*basicide_macro_organizer)(void *, sal_Int16);
+
+#else
+
+extern "C" long basicide_handle_basic_error(void const*);
+extern "C" void basicide_macro_organizer(void*, sal_Int16);
+
+#endif
+
+#endif
+
+IMPL_STATIC_LINK( SfxApplication, GlobalBasicErrorHdl_Impl, StarBASIC*, pStarBasic, bool )
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) pStarBasic;
+    return false;
+#else
+
+#ifndef DISABLE_DYNLOADING
+    basicide_handle_basic_error pSymbol = reinterpret_cast<basicide_handle_basic_error>(sfx2::getBasctlFunction("basicide_handle_basic_error"));
+
+    // call basicide_handle_basic_error in basctl
+    bool bRet = pSymbol( pStarBasic );
+
+#else
+
+    bool bRet = basicide_handle_basic_error( pStarBasic );
+
+#endif
+
+    return bRet;
+
+#endif
+}
+
+bool SfxApplication::IsXScriptURL( const OUString& rScriptURL )
+{
+    bool result = false;
+
+#if !HAVE_FEATURE_SCRIPTING
+    (void) rScriptURL;
+#else
+    css::uno::Reference< css::uno::XComponentContext > xContext =
+            ::comphelper::getProcessComponentContext();
+
+    css::uno::Reference< css::uri::XUriReferenceFactory >
+            xFactory = css::uri::UriReferenceFactory::create( xContext );
+
+    try
+    {
+        css::uno::Reference< css::uri::XVndSunStarScriptUrl >
+                xUrl( xFactory->parse( rScriptURL ),  css::uno::UNO_QUERY );
+
+        if ( xUrl.is() )
+        {
+            result = true;
+        }
+    }
+    catch (const css::uno::RuntimeException&)
+    {
+        // ignore, will just return FALSE
+    }
+#endif
+    return result;
+}
+
+OUString
+SfxApplication::ChooseScript(weld::Window *pParent)
+{
+    OUString aScriptURL;
+
+#if HAVE_FEATURE_SCRIPTING
+    SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+    SAL_INFO( "sfx.appl", "create selector dialog");
+
+    const SfxViewFrame* pViewFrame = SfxViewFrame::Current();
+    const SfxFrame* pFrame = pViewFrame ? &pViewFrame->GetFrame() : nullptr;
+    uno::Reference< frame::XFrame > xFrame( pFrame ? pFrame->GetFrameInterface() : uno::Reference< frame::XFrame >() );
+
+    ScopedVclPtr<AbstractScriptSelectorDialog> pDlg(pFact->CreateScriptSelectorDialog(pParent, xFrame));
+
+    SAL_INFO( "sfx.appl", "done, now exec it");
+
+    sal_uInt16 nRet = pDlg->Execute();
+
+    SAL_INFO( "sfx.appl", "has returned");
+
+    if ( nRet == RET_OK )
+    {
+        aScriptURL = pDlg->GetScriptURL();
+    }
+#else
+    (void) pParent;
+#endif
+    return aScriptURL;
+}
+
+void SfxApplication::MacroOrganizer(weld::Window* pParent, sal_Int16 nTabId)
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) pParent;
+    (void) nTabId;
+#else
+
+#ifndef DISABLE_DYNLOADING
+    basicide_macro_organizer pSymbol = reinterpret_cast<basicide_macro_organizer>(sfx2::getBasctlFunction("basicide_macro_organizer"));
+
+    // call basicide_macro_organizer in basctl
+    pSymbol(pParent, nTabId);
+
+#else
+
+    basicide_macro_organizer(pParent, nTabId);
+
+#endif
+
+#endif
+}
+
+ErrCode SfxApplication::CallBasic( const OUString& rCode, BasicManager* pMgr, SbxArray* pArgs, SbxValue* pRet )
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) rCode;
+    (void) pMgr;
+    (void) pArgs;
+    (void) pRet;
+    return ERRCODE_BASIC_CANNOT_LOAD;
+#else
+    (void) ERRCODE_BASIC_CANNOT_LOAD; // So that the !HAVE_FEATURE_SCRIPTING case isn't broken again by IWYU
+    return pMgr->ExecuteMacro( rCode, pArgs, pRet);
+#endif
+}
+
+sfx2::sidebar::Theme & SfxApplication::GetSidebarTheme()
+{
+    if (!pImpl->m_pSidebarTheme.is())
+    {
+        pImpl->m_pSidebarTheme.set(new sfx2::sidebar::Theme);
+        pImpl->m_pSidebarTheme->InitializeTheme();
+    }
+    return *pImpl->m_pSidebarTheme;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appbas.cxx b/sfx2/source/appl/appbas.cxx
new file mode 100644
index 000000000..1dec99095
--- /dev/null
+++ b/sfx2/source/appl/appbas.cxx
@@ -0,0 +1,154 @@
+/* -*- 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 <sal/config.h>
+
+#include <cassert>
+
+#include <com/sun/star/script/XLibraryContainer.hpp>
+#include <officecfg/Office/Common.hxx>
+#include <svl/intitem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/whiter.hxx>
+#include <basic/sbstar.hxx>
+
+#include <sfx2/frame.hxx>
+#include <sfx2/dinfdlg.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <appdata.hxx>
+#include <basic/basmgr.hxx>
+#include <unotools/configmgr.hxx>
+#include <sorgitm.hxx>
+#include <appbaslib.hxx>
+#include <basic/basicmanagerrepository.hxx>
+
+#define SFX_TYPEMAP
+#include <sfxslots.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::script;
+
+using ::basic::BasicManagerRepository;
+
+
+void SfxApplication::SaveBasicAndDialogContainer() const
+{
+    if ( pImpl->pBasicManager->isValid() )
+        pImpl->pBasicManager->storeAllLibraries();
+}
+
+BasicManager* SfxApplication::GetBasicManager()
+{
+#if !HAVE_FEATURE_SCRIPTING
+    return 0;
+#else
+    if (utl::ConfigManager::IsFuzzing())
+        return nullptr;
+    return BasicManagerRepository::getApplicationBasicManager();
+#endif
+}
+
+XLibraryContainer * SfxApplication::GetDialogContainer()
+{
+#if !HAVE_FEATURE_SCRIPTING
+    return NULL;
+#else
+    if (utl::ConfigManager::IsFuzzing())
+        return nullptr;
+    if ( !pImpl->pBasicManager->isValid() )
+        GetBasicManager();
+    return pImpl->pBasicManager->getLibraryContainer( SfxBasicManagerHolder::DIALOGS );
+#endif
+}
+
+
+XLibraryContainer * SfxApplication::GetBasicContainer()
+{
+#if !HAVE_FEATURE_SCRIPTING
+    return NULL;
+#else
+    if (utl::ConfigManager::IsFuzzing())
+        return nullptr;
+    if ( !pImpl->pBasicManager->isValid() )
+        GetBasicManager();
+    return pImpl->pBasicManager->getLibraryContainer( SfxBasicManagerHolder::SCRIPTS );
+#endif
+}
+
+StarBASIC* SfxApplication::GetBasic()
+{
+#if !HAVE_FEATURE_SCRIPTING
+    return 0;
+#else
+    if (utl::ConfigManager::IsFuzzing())
+        return nullptr;
+    return GetBasicManager()->GetLib(0);
+#endif
+}
+
+void SfxApplication::PropExec_Impl( SfxRequest const &rReq )
+{
+    sal_uInt16 nSID = rReq.GetSlot();
+    switch ( nSID )
+    {
+        case SID_ATTR_UNDO_COUNT:
+        {
+            if (const SfxUInt16Item* pCountItem = rReq.GetArg<SfxUInt16Item>(nSID))
+            {
+                std::shared_ptr< comphelper::ConfigurationChanges > batch(
+                    comphelper::ConfigurationChanges::create());
+                officecfg::Office::Common::Undo::Steps::set(
+                    pCountItem->GetValue(), batch);
+                batch->commit();
+            }
+            break;
+        }
+
+        default:
+            assert(false);
+    }
+}
+
+void SfxApplication::PropState_Impl( SfxItemSet &rSet )
+{
+    SfxWhichIter aIter(rSet);
+    for ( sal_uInt16 nSID = aIter.FirstWhich(); nSID; nSID = aIter.NextWhich() )
+    {
+        switch ( nSID )
+        {
+            case SID_ATTR_UNDO_COUNT:
+                rSet.Put(
+                    SfxUInt16Item(
+                        SID_ATTR_UNDO_COUNT,
+                        officecfg::Office::Common::Undo::Steps::get()));
+                break;
+
+            default:
+                assert(false);
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appbaslib.cxx b/sfx2/source/appl/appbaslib.cxx
new file mode 100644
index 000000000..f05afecdd
--- /dev/null
+++ b/sfx2/source/appl/appbaslib.cxx
@@ -0,0 +1,188 @@
+/* -*- 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 <appbaslib.hxx>
+
+#include <sfx2/app.hxx>
+
+#include <basic/basmgr.hxx>
+#include <tools/diagnose_ex.h>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::script;
+using namespace ::com::sun::star::embed;
+
+
+SfxBasicManagerHolder::SfxBasicManagerHolder()
+    :mpBasicManager( nullptr )
+{
+}
+
+void SfxBasicManagerHolder::Notify(SfxBroadcaster& rBC, SfxHint const& rHint)
+{
+    if (!mpBasicManager || &rBC != mpBasicManager)
+        return;
+    if (SfxHintId::Dying == rHint.GetId())
+    {
+        mpBasicManager = nullptr;
+        mxBasicContainer.clear();
+        mxDialogContainer.clear();
+    }
+}
+
+void SfxBasicManagerHolder::reset( BasicManager* _pBasicManager )
+{
+    impl_releaseContainers();
+
+#if !HAVE_FEATURE_SCRIPTING
+    (void) _pBasicManager;
+#else
+    // Note: we do not delete the old BasicManager. BasicManager instances are
+    // nowadays obtained from the BasicManagerRepository, and the ownership is with
+    // the repository.
+    // @see basic::BasicManagerRepository::getApplicationBasicManager
+    // @see basic::BasicManagerRepository::getDocumentBasicManager
+    mpBasicManager = _pBasicManager;
+
+    if ( !mpBasicManager )
+        return;
+
+    StartListening(*mpBasicManager);
+    try
+    {
+        mxBasicContainer.set( mpBasicManager->GetScriptLibraryContainer(), UNO_QUERY_THROW );
+        mxDialogContainer.set( mpBasicManager->GetDialogLibraryContainer(), UNO_QUERY_THROW  );
+    }
+    catch( const Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION("sfx.appl");
+    }
+#endif
+}
+
+void SfxBasicManagerHolder::storeAllLibraries()
+{
+#if HAVE_FEATURE_SCRIPTING
+    OSL_PRECOND( isValid(), "SfxBasicManagerHolder::storeAllLibraries: not initialized!" );
+    try
+    {
+        if ( mxBasicContainer.is() )
+            mxBasicContainer->storeLibraries();
+        if ( mxDialogContainer.is() )
+            mxDialogContainer->storeLibraries();
+    }
+    catch( const Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION("sfx.appl");
+    }
+#endif
+}
+
+void SfxBasicManagerHolder::setStorage( const Reference< XStorage >& _rxStorage )
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) _rxStorage;
+#else
+    try
+    {
+        if ( mxBasicContainer.is() )
+            mxBasicContainer->setRootStorage( _rxStorage );
+        if ( mxDialogContainer.is() )
+            mxDialogContainer->setRootStorage( _rxStorage );
+    }
+    catch( const Exception& )
+    {
+        DBG_UNHANDLED_EXCEPTION("sfx.appl");
+    }
+#endif
+}
+
+void SfxBasicManagerHolder::storeLibrariesToStorage( const Reference< XStorage >& _rxStorage )
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) _rxStorage;
+#else
+    OSL_PRECOND( isValid(), "SfxBasicManagerHolder::storeLibrariesToStorage: not initialized!" );
+
+    if ( mxBasicContainer.is() )
+        mxBasicContainer->storeLibrariesToStorage( _rxStorage );
+    if ( mxDialogContainer.is() )
+        mxDialogContainer->storeLibrariesToStorage( _rxStorage );
+#endif
+}
+
+XLibraryContainer * SfxBasicManagerHolder::getLibraryContainer( ContainerType _eType )
+{
+    OSL_PRECOND( isValid(), "SfxBasicManagerHolder::getLibraryContainer: not initialized!" );
+
+    switch ( _eType )
+    {
+    case SCRIPTS:   return mxBasicContainer.get();
+    case DIALOGS:   return mxDialogContainer.get();
+    }
+    OSL_FAIL( "SfxBasicManagerHolder::getLibraryContainer: illegal container type!" );
+    return nullptr;
+}
+
+void SfxBasicManagerHolder::impl_releaseContainers()
+{
+    mxBasicContainer.clear();
+    mxDialogContainer.clear();
+}
+
+bool SfxBasicManagerHolder::LegacyPsswdBinaryLimitExceeded( std::vector< OUString >& sModules )
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) sModules;
+#else
+    if ( mpBasicManager )
+        return mpBasicManager->LegacyPsswdBinaryLimitExceeded( sModules );
+#endif
+    return true;
+}
+
+// Service for application library container
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_sfx2_ApplicationDialogLibraryContainer_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    SfxApplication::GetBasicManager();
+    css::uno::XInterface* pRet = SfxGetpApp()->GetDialogContainer();
+    pRet->acquire();
+    return pRet;
+}
+
+// Service for application library container
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_sfx2_ApplicationScriptLibraryContainer_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    SfxApplication::GetBasicManager();
+    css::uno::XInterface* pRet = SfxGetpApp()->GetBasicContainer();
+    pRet->acquire();
+    return pRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appcfg.cxx b/sfx2/source/appl/appcfg.cxx
new file mode 100644
index 000000000..0e72b08f5
--- /dev/null
+++ b/sfx2/source/appl/appcfg.cxx
@@ -0,0 +1,820 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <comphelper/sequence.hxx>
+#include <osl/file.hxx>
+
+#include <rtl/ustring.hxx>
+#include <svl/itempool.hxx>
+#include <svl/itemset.hxx>
+#include <svl/aeitem.hxx>
+#include <svl/slstitm.hxx>
+#include <svl/stritem.hxx>
+#include <svl/intitem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/undo.hxx>
+
+#include <sfx2/sfxsids.hrc>
+
+#include <svl/isethint.hxx>
+
+#include <officecfg/Inet.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <unotools/saveopt.hxx>
+#include <svtools/helpopt.hxx>
+#include <unotools/securityoptions.hxx>
+#include <unotools/pathoptions.hxx>
+#include <svtools/miscopt.hxx>
+#include <svtools/imgdef.hxx>
+#include <vcl/toolbox.hxx>
+#include <sal/log.hxx>
+#include <vcl/idle.hxx>
+
+#include <sfx2/app.hxx>
+#include <sfx2/event.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/objsh.hxx>
+#include <objshimp.hxx>
+#include "shutdownicon.hxx"
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::beans;
+
+namespace {
+
+class SfxEventAsyncer_Impl : public SfxListener
+{
+    SfxEventHint           aHint;
+    std::unique_ptr<Idle>  pIdle;
+
+public:
+
+    virtual void        Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
+    explicit SfxEventAsyncer_Impl(const SfxEventHint& rHint);
+    DECL_LINK( IdleHdl, Timer*, void );
+};
+
+}
+
+void SfxEventAsyncer_Impl::Notify( SfxBroadcaster&, const SfxHint& rHint )
+{
+    if( rHint.GetId() == SfxHintId::Dying && pIdle->IsActive() )
+    {
+        pIdle->Stop();
+        delete this;
+    }
+}
+
+
+SfxEventAsyncer_Impl::SfxEventAsyncer_Impl( const SfxEventHint& rHint )
+ : aHint( rHint )
+{
+    if( rHint.GetObjShell() )
+        StartListening( *rHint.GetObjShell() );
+    pIdle.reset( new Idle("SfxEventASyncer") );
+    pIdle->SetInvokeHandler( LINK(this, SfxEventAsyncer_Impl, IdleHdl) );
+    pIdle->SetPriority( TaskPriority::HIGH_IDLE );
+    pIdle->SetDebugName( "sfx::SfxEventAsyncer_Impl pIdle" );
+    pIdle->Start();
+}
+
+
+IMPL_LINK(SfxEventAsyncer_Impl, IdleHdl, Timer*, pAsyncIdle, void)
+{
+    SfxObjectShellRef xRef( aHint.GetObjShell() );
+    pAsyncIdle->Stop();
+    SAL_INFO_IF(!xRef.is(), "sfx.appl", "SfxEvent: " << aHint.GetEventName());
+    SfxGetpApp()->Broadcast( aHint );
+    if ( xRef.is() )
+        xRef->Broadcast( aHint );
+    delete this;
+}
+
+
+void SfxApplication::GetOptions( SfxItemSet& rSet )
+{
+    bool bRet = false;
+    SfxItemPool &rPool = GetPool();
+
+    const sal_uInt16 *pRanges = rSet.GetRanges();
+    SvtSaveOptions aSaveOptions;
+    SvtHelpOptions aHelpOptions;
+    SvtSecurityOptions  aSecurityOptions;
+    SvtMiscOptions aMiscOptions;
+
+    while ( *pRanges )
+    {
+        for(sal_uInt16 nWhich = *pRanges++; nWhich <= *pRanges; ++nWhich)
+        {
+            switch(nWhich)
+            {
+                case SID_ATTR_BUTTON_OUTSTYLE3D :
+                    if(rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_BUTTON_OUTSTYLE3D ),
+                              aMiscOptions.GetToolboxStyle() != TOOLBOX_STYLE_FLAT)))
+                        bRet = true;
+                    break;
+                case SID_ATTR_BUTTON_BIGSIZE :
+                {
+                    if( rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_BUTTON_BIGSIZE ), aMiscOptions.AreCurrentSymbolsLarge() ) ) )
+                        bRet = true;
+                    break;
+                }
+                case SID_ATTR_BACKUP :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::Backup))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_BACKUP ),aSaveOptions.IsBackup())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_PRETTYPRINTING:
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::DoPrettyPrinting))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_PRETTYPRINTING ), aSaveOptions.IsPrettyPrinting())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_WARNALIENFORMAT:
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::WarnAlienFormat))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_WARNALIENFORMAT ), aSaveOptions.IsWarnAlienFormat())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_AUTOSAVE :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::AutoSave))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_AUTOSAVE ), aSaveOptions.IsAutoSave())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_AUTOSAVEPROMPT :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::AutoSavePrompt))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_AUTOSAVEPROMPT ), aSaveOptions.IsAutoSavePrompt())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_AUTOSAVEMINUTE :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::AutoSaveTime))
+                            if (!rSet.Put( SfxUInt16Item( rPool.GetWhich( SID_ATTR_AUTOSAVEMINUTE ), static_cast<sal_uInt16>(aSaveOptions.GetAutoSaveTime()))))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_USERAUTOSAVE :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::UserAutoSave))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_USERAUTOSAVE ), aSaveOptions.IsUserAutoSave())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_DOCINFO :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::DocInfSave))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_DOCINFO ), aSaveOptions.IsDocInfoSave())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_WORKINGSET :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::SaveWorkingSet))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_WORKINGSET ), aSaveOptions.IsSaveWorkingSet())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_SAVEDOCVIEW :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::SaveDocView))
+                            if (!rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_SAVEDOCVIEW ), aSaveOptions.IsSaveDocView())))
+                                bRet = false;
+                    }
+                    break;
+                case SID_ATTR_METRIC :
+                    break;
+                case SID_HELPBALLOONS :
+                    if(rSet.Put( SfxBoolItem ( rPool.GetWhich( SID_HELPBALLOONS ),
+                               aHelpOptions.IsExtendedHelp() ) ) )
+                        bRet = true;
+                    break;
+                case SID_HELPTIPS :
+                    if(rSet.Put( SfxBoolItem ( rPool.GetWhich( SID_HELPTIPS ),
+                               aHelpOptions.IsHelpTips() ) ) )
+                        bRet = true;
+                    break;
+                case SID_HELP_STYLESHEET :
+                    if(rSet.Put( SfxStringItem ( rPool.GetWhich( SID_HELP_STYLESHEET ),
+                               aHelpOptions.GetHelpStyleSheet() ) ) )
+                        bRet = true;
+                break;
+                case SID_ATTR_UNDO_COUNT :
+                    if (rSet.Put(
+                            SfxUInt16Item (
+                                rPool.GetWhich(SID_ATTR_UNDO_COUNT),
+                                officecfg::Office::Common::Undo::Steps::get())))
+                    {
+                        bRet = true;
+                    }
+                    break;
+                case SID_ATTR_QUICKLAUNCHER :
+                {
+                    if ( ShutdownIcon::IsQuickstarterInstalled() )
+                    {
+                        if ( rSet.Put( SfxBoolItem( rPool.GetWhich( SID_ATTR_QUICKLAUNCHER ),
+                                                    ShutdownIcon::GetAutostart() ) ) )
+                            bRet = true;
+                    }
+                    else
+                    {
+                        rSet.DisableItem( rPool.GetWhich( SID_ATTR_QUICKLAUNCHER ) );
+                        bRet = true;
+                    }
+                    break;
+                }
+                case SID_SAVEREL_INET :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::SaveRelInet))
+                            if (!rSet.Put( SfxBoolItem ( rPool.GetWhich( SID_SAVEREL_INET ), aSaveOptions.IsSaveRelINet() )))
+                                bRet = false;
+                    }
+                    break;
+                case SID_SAVEREL_FSYS :
+                    {
+                        bRet = true;
+                        if (!aSaveOptions.IsReadOnly(SvtSaveOptions::EOption::SaveRelFsys))
+                            if (!rSet.Put( SfxBoolItem ( rPool.GetWhich( SID_SAVEREL_FSYS ), aSaveOptions.IsSaveRelFSys() )))
+                                bRet = false;
+                    }
+                    break;
+                case SID_BASIC_ENABLED :
+                    {
+                        bRet = true;
+                        if (!aSecurityOptions.IsReadOnly(SvtSecurityOptions::EOption::BasicMode))
+                        {
+                            if ( !rSet.Put( SfxUInt16Item( rPool.GetWhich( SID_BASIC_ENABLED ), sal::static_int_cast< sal_uInt16 >(aSecurityOptions.GetBasicMode()))))
+                                bRet = false;
+                        }
+                    }
+                    break;
+                case SID_INET_EXE_PLUGIN  :
+                    {
+                        bRet = true;
+                        if (!aSecurityOptions.IsReadOnly(SvtSecurityOptions::EOption::ExecutePlugins))
+                        {
+                            if ( !rSet.Put( SfxBoolItem( SID_INET_EXE_PLUGIN, aSecurityOptions.IsExecutePlugins() ) ) )
+                                bRet = false;
+                        }
+                    }
+                    break;
+                case SID_MACRO_WARNING :
+                    {
+                        bRet = true;
+                        if (!aSecurityOptions.IsReadOnly(SvtSecurityOptions::EOption::Warning))
+                        {
+                            if ( !rSet.Put( SfxBoolItem( SID_MACRO_WARNING, aSecurityOptions.IsWarningEnabled() ) ) )
+                                bRet = false;
+                        }
+                    }
+                    break;
+                case SID_MACRO_CONFIRMATION :
+                    {
+                        bRet = true;
+                        if (!aSecurityOptions.IsReadOnly(SvtSecurityOptions::EOption::Confirmation))
+                        {
+                            if ( !rSet.Put( SfxBoolItem( SID_MACRO_CONFIRMATION, aSecurityOptions.IsConfirmationEnabled() ) ) )
+                                bRet = false;
+                        }
+                    }
+                    break;
+                case SID_SECURE_URL :
+                    {
+                        bRet = true;
+                        if (!aSecurityOptions.IsReadOnly(SvtSecurityOptions::EOption::SecureUrls))
+                        {
+                            css::uno::Sequence< OUString > seqURLs = aSecurityOptions.GetSecureURLs();
+                            auto aList = comphelper::sequenceToContainer<std::vector<OUString>>(seqURLs);
+
+                            if( !rSet.Put( SfxStringListItem( rPool.GetWhich(SID_SECURE_URL), &aList ) ) )
+                                bRet = false;
+                        }
+                    }
+                    break;
+                case SID_INET_PROXY_TYPE :
+                    if (rSet.Put(
+                            SfxUInt16Item(
+                                rPool.GetWhich(SID_INET_PROXY_TYPE),
+                                (officecfg::Inet::Settings::ooInetProxyType::
+                                 get().value_or(0)))))
+                    {
+                        bRet = true;
+                    }
+                    break;
+                case SID_INET_HTTP_PROXY_NAME :
+                    if (rSet.Put(
+                            SfxStringItem(
+                                rPool.GetWhich(SID_INET_HTTP_PROXY_NAME),
+                                officecfg::Inet::Settings::ooInetHTTPProxyName::
+                                get())))
+                    {
+                        bRet = true;
+                    }
+                    break;
+                case SID_INET_HTTP_PROXY_PORT :
+                    if (rSet.Put(
+                            SfxInt32Item(
+                                rPool.GetWhich(SID_INET_HTTP_PROXY_PORT),
+                                (officecfg::Inet::Settings::
+                                 ooInetHTTPProxyPort::get().value_or(0)))))
+                    {
+                        bRet = true;
+                    }
+                    break;
+                case SID_INET_FTP_PROXY_NAME :
+                    if (rSet.Put(
+                            SfxStringItem(
+                                rPool.GetWhich(SID_INET_FTP_PROXY_NAME),
+                                officecfg::Inet::Settings::ooInetFTPProxyName::
+                                get())))
+                    {
+                        bRet = true;
+                    }
+                    break;
+                case SID_INET_FTP_PROXY_PORT :
+                    if (rSet.Put(
+                            SfxInt32Item(
+                                rPool.GetWhich(SID_INET_FTP_PROXY_PORT),
+                                (officecfg::Inet::Settings::ooInetFTPProxyPort::
+                                 get().value_or(0)))))
+                    {
+                        bRet = true;
+                    }
+                    break;
+                case SID_INET_NOPROXY :
+                    if (rSet.Put(
+                            SfxStringItem(
+                                rPool.GetWhich( SID_INET_NOPROXY),
+                                (officecfg::Inet::Settings::ooInetNoProxy::
+                                 get()))))
+                    {
+                        bRet = true;
+                    }
+                    break;
+                case SID_ATTR_PATHNAME :
+                {
+                    SfxAllEnumItem aValues(rPool.GetWhich(SID_ATTR_PATHNAME));
+                    SvtPathOptions aPathCfg;
+                    for ( sal_uInt16 nProp = SvtPathOptions::PATH_ADDIN;
+                          nProp <= SvtPathOptions::PATH_WORK; nProp++ )
+                    {
+                        OUString aValue;
+                        switch ( nProp )
+                        {
+                            case SvtPathOptions::PATH_ADDIN:        osl::FileBase::getFileURLFromSystemPath( aPathCfg.GetAddinPath(), aValue ); break;
+                            case SvtPathOptions::PATH_AUTOCORRECT:  aValue = aPathCfg.GetAutoCorrectPath(); break;
+                            case SvtPathOptions::PATH_AUTOTEXT:     aValue = aPathCfg.GetAutoTextPath(); break;
+                            case SvtPathOptions::PATH_BACKUP:       aValue = aPathCfg.GetBackupPath(); break;
+                            case SvtPathOptions::PATH_BASIC:        aValue = aPathCfg.GetBasicPath(); break;
+                            case SvtPathOptions::PATH_BITMAP:       aValue = aPathCfg.GetBitmapPath(); break;
+                            case SvtPathOptions::PATH_CONFIG:       aValue = aPathCfg.GetConfigPath(); break;
+                            case SvtPathOptions::PATH_DICTIONARY:   aValue = aPathCfg.GetDictionaryPath(); break;
+                            case SvtPathOptions::PATH_FAVORITES:    aValue = aPathCfg.GetFavoritesPath(); break;
+                            case SvtPathOptions::PATH_FILTER:       osl::FileBase::getFileURLFromSystemPath( aPathCfg.GetFilterPath(), aValue ); break;
+                            case SvtPathOptions::PATH_GALLERY:      aValue = aPathCfg.GetGalleryPath(); break;
+                            case SvtPathOptions::PATH_GRAPHIC:      aValue = aPathCfg.GetGraphicPath(); break;
+                            case SvtPathOptions::PATH_HELP:         osl::FileBase::getFileURLFromSystemPath( aPathCfg.GetHelpPath(), aValue ); break;
+                            case SvtPathOptions::PATH_LINGUISTIC:   aValue = aPathCfg.GetLinguisticPath(); break;
+                            case SvtPathOptions::PATH_MODULE:       osl::FileBase::getFileURLFromSystemPath( aPathCfg.GetModulePath(), aValue ); break;
+                            case SvtPathOptions::PATH_PALETTE:      aValue = aPathCfg.GetPalettePath(); break;
+                            case SvtPathOptions::PATH_PLUGIN:       osl::FileBase::getFileURLFromSystemPath( aPathCfg.GetPluginPath(), aValue ); break;
+                            case SvtPathOptions::PATH_STORAGE:      osl::FileBase::getFileURLFromSystemPath( aPathCfg.GetStoragePath(), aValue ); break;
+                            case SvtPathOptions::PATH_TEMP:         aValue = aPathCfg.GetTempPath(); break;
+                            case SvtPathOptions::PATH_TEMPLATE:     aValue = aPathCfg.GetTemplatePath(); break;
+                            case SvtPathOptions::PATH_USERCONFIG:   aValue = aPathCfg.GetUserConfigPath(); break;
+                            case SvtPathOptions::PATH_WORK:         aValue = aPathCfg.GetWorkPath(); break;
+                        }
+                        aValues.SetTextByPos( nProp, aValue );
+                    }
+
+                    if (rSet.Put(aValues))
+                        bRet = true;
+                }
+                break;
+
+                default:
+                    SAL_INFO( "sfx.appl", "W1:Wrong ID while getting Options!" );
+                    break;
+            }
+            SAL_WARN_IF(!bRet, "sfx.appl", "Putting options failed!");
+        }
+        pRanges++;
+    }
+}
+
+// TODO/CLEANUP: Why two SetOptions Methods?
+void SfxApplication::SetOptions_Impl( const SfxItemSet& rSet )
+{
+    const SfxPoolItem *pItem = nullptr;
+    SfxItemPool &rPool = GetPool();
+
+    SvtSaveOptions aSaveOptions;
+    SvtHelpOptions aHelpOptions;
+    SvtSecurityOptions aSecurityOptions;
+    SvtMiscOptions aMiscOptions;
+    std::shared_ptr< comphelper::ConfigurationChanges > batch(
+        comphelper::ConfigurationChanges::create());
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_BUTTON_OUTSTYLE3D), true, &pItem) )
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        sal_uInt16 nOutStyle =
+            static_cast<const SfxBoolItem *>(pItem)->GetValue() ? 0 : TOOLBOX_STYLE_FLAT;
+        aMiscOptions.SetToolboxStyle( nOutStyle );
+    }
+
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_BUTTON_BIGSIZE), true, &pItem) )
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        bool bBigSize = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        aMiscOptions.SetSymbolsSize(
+            sal::static_int_cast< sal_Int16 >(
+                bBigSize ? SFX_SYMBOLS_SIZE_LARGE : SFX_SYMBOLS_SIZE_SMALL ) );
+        SfxViewFrame* pCurrViewFrame = SfxViewFrame::GetFirst();
+        while ( pCurrViewFrame )
+        {
+            // update all "final" dispatchers
+            pCurrViewFrame->GetDispatcher()->Update_Impl(true);
+            pCurrViewFrame = SfxViewFrame::GetNext(*pCurrViewFrame);
+        }
+    }
+
+    // Backup
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_BACKUP), true, &pItem) )
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetBackup( static_cast<const SfxBoolItem*>(pItem)->GetValue() );
+    }
+
+    // PrettyPrinting
+    if ( SfxItemState::SET == rSet.GetItemState( rPool.GetWhich( SID_ATTR_PRETTYPRINTING ), true, &pItem ) )
+    {
+        DBG_ASSERT( dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected" );
+        aSaveOptions.SetPrettyPrinting( static_cast< const SfxBoolItem*> ( pItem )->GetValue() );
+    }
+
+    // WarnAlienFormat
+    if ( SfxItemState::SET == rSet.GetItemState( rPool.GetWhich( SID_ATTR_WARNALIENFORMAT ), true, &pItem ) )
+    {
+        DBG_ASSERT( dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected" );
+        aSaveOptions.SetWarnAlienFormat( static_cast< const SfxBoolItem*> ( pItem )->GetValue() );
+    }
+
+    // AutoSave
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_AUTOSAVE), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetAutoSave( static_cast<const SfxBoolItem*>(pItem)->GetValue() );
+    }
+
+    // AutoSave-Prompt
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_AUTOSAVEPROMPT), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetAutoSavePrompt(static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    // AutoSave-Time
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_AUTOSAVEMINUTE), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxUInt16Item *>( pItem ) !=  nullptr, "UInt16Item expected");
+        aSaveOptions.SetAutoSaveTime(static_cast<const SfxUInt16Item *>(pItem)->GetValue());
+    }
+
+    // UserAutoSave
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_USERAUTOSAVE), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetUserAutoSave( static_cast<const SfxBoolItem*>(pItem)->GetValue() );
+    }
+
+    // DocInfo
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_DOCINFO), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetDocInfoSave(static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    // Mark open Documents
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_WORKINGSET), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetSaveWorkingSet(static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    // Save window settings
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_SAVEDOCVIEW), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetSaveDocView(static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    // Metric
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_METRIC), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxUInt16Item *>( pItem ) !=  nullptr, "UInt16Item expected");
+    }
+
+    // HelpBalloons
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_HELPBALLOONS), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aHelpOptions.SetExtendedHelp(static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    // HelpTips
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_HELPTIPS), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aHelpOptions.SetHelpTips( static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_HELP_STYLESHEET ), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxStringItem *>( pItem ) !=  nullptr, "StringItem expected");
+        aHelpOptions.SetHelpStyleSheet( static_cast<const SfxStringItem *>(pItem)->GetValue() );
+    }
+
+    // SaveRelINet
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_SAVEREL_INET), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetSaveRelINet(static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    // SaveRelFSys
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_SAVEREL_FSYS), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        aSaveOptions.SetSaveRelFSys(static_cast<const SfxBoolItem *>(pItem)->GetValue());
+    }
+
+    // Undo-Count
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_UNDO_COUNT), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxUInt16Item *>( pItem ) !=  nullptr, "UInt16Item expected");
+        sal_uInt16 nUndoCount = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
+        officecfg::Office::Common::Undo::Steps::set(nUndoCount, batch);
+
+        // To catch all Undo-Managers: Iterate over all Frames
+        for ( SfxViewFrame *pFrame = SfxViewFrame::GetFirst();
+              pFrame;
+              pFrame = SfxViewFrame::GetNext(*pFrame) )
+        {
+            // Get the Dispatcher of the Frames
+            SfxDispatcher *pDispat = pFrame->GetDispatcher();
+            pDispat->Flush();
+
+            // Iterate over all SfxShells on the Dispatchers Stack
+            sal_uInt16 nIdx = 0;
+            for ( SfxShell *pSh = pDispat->GetShell(nIdx);
+                  pSh;
+                  ++nIdx, pSh = pDispat->GetShell(nIdx) )
+            {
+                SfxUndoManager *pShUndoMgr = pSh->GetUndoManager();
+                if ( pShUndoMgr )
+                    pShUndoMgr->SetMaxUndoActionCount( nUndoCount );
+            }
+        }
+    }
+
+    // Office autostart
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_QUICKLAUNCHER), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "BoolItem expected");
+        ShutdownIcon::SetAutostart( static_cast<const SfxBoolItem*>( pItem )->GetValue() );
+    }
+
+    // StarBasic Enable
+    if ( SfxItemState::SET == rSet.GetItemState(SID_BASIC_ENABLED, true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxUInt16Item *>( pItem ) !=  nullptr, "SfxInt16Item expected");
+        aSecurityOptions.SetBasicMode( static_cast<EBasicSecurityMode>(static_cast<const SfxUInt16Item*>( pItem )->GetValue()) );
+    }
+
+    // Execute PlugIns
+    if ( SfxItemState::SET == rSet.GetItemState(SID_INET_EXE_PLUGIN, true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "SfxBoolItem expected");
+        aSecurityOptions.SetExecutePlugins( static_cast<const SfxBoolItem *>( pItem )->GetValue() );
+    }
+
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_INET_PROXY_TYPE), true, &pItem))
+    {
+        DBG_ASSERT( dynamic_cast< const SfxUInt16Item *>( pItem ) !=  nullptr, "UInt16Item expected" );
+        officecfg::Inet::Settings::ooInetProxyType::set(
+            static_cast< SfxUInt16Item const * >(pItem)->GetValue(), batch);
+    }
+
+    if ( SfxItemState::SET == rSet.GetItemState( rPool.GetWhich( SID_INET_HTTP_PROXY_NAME ), true, &pItem ) )
+    {
+        DBG_ASSERT( dynamic_cast< const SfxStringItem *>( pItem ) !=  nullptr, "StringItem expected" );
+        officecfg::Inet::Settings::ooInetHTTPProxyName::set(
+            static_cast< SfxStringItem const * >(pItem)->GetValue(), batch);
+    }
+    if ( SfxItemState::SET == rSet.GetItemState( rPool.GetWhich( SID_INET_HTTP_PROXY_PORT ), true, &pItem ) )
+    {
+        DBG_ASSERT( dynamic_cast< const SfxInt32Item *>( pItem ) !=  nullptr, "Int32Item expected" );
+        officecfg::Inet::Settings::ooInetHTTPProxyPort::set(
+            static_cast< SfxInt32Item const * >(pItem)->GetValue(), batch);
+    }
+    if ( SfxItemState::SET == rSet.GetItemState( rPool.GetWhich( SID_INET_FTP_PROXY_NAME ), true, &pItem ) )
+    {
+        DBG_ASSERT( dynamic_cast< const SfxStringItem *>( pItem ) !=  nullptr, "StringItem expected" );
+        officecfg::Inet::Settings::ooInetFTPProxyName::set(
+            static_cast< SfxStringItem const * >(pItem)->GetValue(), batch);
+    }
+    if ( SfxItemState::SET == rSet.GetItemState( rPool.GetWhich( SID_INET_FTP_PROXY_PORT ), true, &pItem ) )
+    {
+        DBG_ASSERT( dynamic_cast< const SfxInt32Item *>( pItem ) !=  nullptr, "Int32Item expected" );
+        officecfg::Inet::Settings::ooInetFTPProxyPort::set(
+            static_cast< SfxInt32Item const * >(pItem)->GetValue(), batch);
+    }
+    if ( SfxItemState::SET == rSet.GetItemState(SID_INET_NOPROXY, true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxStringItem *>( pItem ) !=  nullptr, "StringItem expected");
+        officecfg::Inet::Settings::ooInetNoProxy::set(
+            static_cast< SfxStringItem const * >(pItem)->GetValue(), batch);
+    }
+
+    // Secure-Referrer
+    if ( SfxItemState::SET == rSet.GetItemState(SID_SECURE_URL, true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxStringListItem *>( pItem ) !=  nullptr, "StringListItem expected");
+        css::uno::Sequence< OUString > seqURLs;
+        static_cast<const SfxStringListItem*>(pItem)->GetStringList(seqURLs);
+        aSecurityOptions.SetSecureURLs( seqURLs );
+    }
+
+    if ( SfxItemState::SET == rSet.GetItemState(SID_MACRO_WARNING, true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "SfxBoolItem expected");
+        aSecurityOptions.SetWarningEnabled( static_cast<const SfxBoolItem *>(pItem)->GetValue() );
+    }
+    if ( SfxItemState::SET == rSet.GetItemState(SID_MACRO_CONFIRMATION, true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxBoolItem *>( pItem ) !=  nullptr, "SfxBoolItem expected");
+        aSecurityOptions.SetConfirmationEnabled( static_cast<const SfxBoolItem *>(pItem)->GetValue() );
+    }
+
+    // Store changed data
+    batch->commit();
+}
+
+
+void SfxApplication::SetOptions(const SfxItemSet &rSet)
+{
+    SvtPathOptions aPathOptions;
+
+    // Data is saved in DocInfo and IniManager
+    const SfxPoolItem *pItem = nullptr;
+    SfxItemPool &rPool = GetPool();
+
+    SfxAllItemSet aSendSet( rSet );
+
+    // PathName
+    if ( SfxItemState::SET == rSet.GetItemState(rPool.GetWhich(SID_ATTR_PATHNAME), true, &pItem))
+    {
+        DBG_ASSERT(dynamic_cast< const SfxAllEnumItem *>( pItem ) !=  nullptr, "AllEnumItem expected");
+        const SfxAllEnumItem* pEnumItem = static_cast<const SfxAllEnumItem *>(pItem);
+        sal_uInt32 nCount = pEnumItem->GetTextCount();
+        OUString aNoChangeStr( ' ' );
+        for( sal_uInt32 nPath=0; nPath<nCount; ++nPath )
+        {
+            const OUString& sValue = pEnumItem->GetTextByPos(static_cast<sal_uInt16>(nPath));
+            if ( sValue != aNoChangeStr )
+            {
+                switch( nPath )
+                {
+                    case SvtPathOptions::PATH_ADDIN:
+                    {
+                        OUString aTmp;
+                        if( osl::FileBase::getSystemPathFromFileURL( sValue, aTmp ) == osl::FileBase::E_None )
+                            aPathOptions.SetAddinPath( aTmp );
+                        break;
+                    }
+
+                    case SvtPathOptions::PATH_AUTOCORRECT:  aPathOptions.SetAutoCorrectPath( sValue );break;
+                    case SvtPathOptions::PATH_AUTOTEXT:     aPathOptions.SetAutoTextPath( sValue );break;
+                    case SvtPathOptions::PATH_BACKUP:       aPathOptions.SetBackupPath( sValue );break;
+                    case SvtPathOptions::PATH_BASIC:        aPathOptions.SetBasicPath( sValue );break;
+                    case SvtPathOptions::PATH_BITMAP:       aPathOptions.SetBitmapPath( sValue );break;
+                    case SvtPathOptions::PATH_CONFIG:       aPathOptions.SetConfigPath( sValue );break;
+                    case SvtPathOptions::PATH_DICTIONARY:   aPathOptions.SetDictionaryPath( sValue );break;
+                    case SvtPathOptions::PATH_FAVORITES:    aPathOptions.SetFavoritesPath( sValue );break;
+                    case SvtPathOptions::PATH_FILTER:
+                    {
+                        OUString aTmp;
+                        if( osl::FileBase::getSystemPathFromFileURL( sValue, aTmp ) == osl::FileBase::E_None )
+                            aPathOptions.SetFilterPath( aTmp );
+                        break;
+                    }
+                    case SvtPathOptions::PATH_GALLERY:      aPathOptions.SetGalleryPath( sValue );break;
+                    case SvtPathOptions::PATH_GRAPHIC:      aPathOptions.SetGraphicPath( sValue );break;
+                    case SvtPathOptions::PATH_HELP:
+                    {
+                        OUString aTmp;
+                        if( osl::FileBase::getSystemPathFromFileURL( sValue, aTmp ) == osl::FileBase::E_None )
+                            aPathOptions.SetHelpPath( aTmp );
+                        break;
+                    }
+
+                    case SvtPathOptions::PATH_LINGUISTIC:   aPathOptions.SetLinguisticPath( sValue );break;
+                    case SvtPathOptions::PATH_MODULE:
+                    {
+                        OUString aTmp;
+                        if( osl::FileBase::getSystemPathFromFileURL( sValue, aTmp ) == osl::FileBase::E_None )
+                            aPathOptions.SetModulePath( aTmp );
+                        break;
+                    }
+
+                    case SvtPathOptions::PATH_PALETTE:      aPathOptions.SetPalettePath( sValue );break;
+                    case SvtPathOptions::PATH_PLUGIN:
+                    {
+                        OUString aTmp;
+                        if( osl::FileBase::getSystemPathFromFileURL( sValue, aTmp ) == osl::FileBase::E_None )
+                            aPathOptions.SetPluginPath( aTmp );
+                        break;
+                    }
+
+                    case SvtPathOptions::PATH_STORAGE:
+                    {
+                        OUString aTmp;
+                        if( osl::FileBase::getSystemPathFromFileURL( sValue, aTmp ) == osl::FileBase::E_None )
+                            aPathOptions.SetStoragePath( aTmp );
+                        break;
+                    }
+
+                    case SvtPathOptions::PATH_TEMP:         aPathOptions.SetTempPath( sValue );break;
+                    case SvtPathOptions::PATH_TEMPLATE:     aPathOptions.SetTemplatePath( sValue );break;
+                    case SvtPathOptions::PATH_USERCONFIG:   aPathOptions.SetUserConfigPath( sValue );break;
+                    case SvtPathOptions::PATH_WORK:         aPathOptions.SetWorkPath( sValue );break;
+                    default: SAL_WARN( "sfx.appl", "SfxApplication::SetOptions_Impl() Invalid path number found for set directories!" );
+                }
+            }
+        }
+
+        aSendSet.ClearItem( rPool.GetWhich( SID_ATTR_PATHNAME ) );
+    }
+
+    SetOptions_Impl( rSet );
+
+    // Undo-Count
+    Broadcast( SfxItemSetHint( rSet ) );
+}
+
+
+void SfxApplication::NotifyEvent( const SfxEventHint& rEventHint, bool bSynchron )
+{
+    SfxObjectShell *pDoc = rEventHint.GetObjShell();
+    if ( pDoc && ( pDoc->IsPreview() || !pDoc->Get_Impl()->bInitialized ) )
+        return;
+
+    if ( bSynchron )
+    {
+        SAL_INFO_IF(!pDoc, "sfx.appl", "SfxEvent: " << rEventHint.GetEventName());
+        Broadcast(rEventHint);
+        if ( pDoc )
+            pDoc->Broadcast( rEventHint );
+    }
+    else
+        new SfxEventAsyncer_Impl( rEventHint );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appchild.cxx b/sfx2/source/appl/appchild.cxx
new file mode 100644
index 000000000..0aaf722ba
--- /dev/null
+++ b/sfx2/source/appl/appchild.cxx
@@ -0,0 +1,138 @@
+/* -*- 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 <osl/diagnose.h>
+#include <tools/debug.hxx>
+
+#include <sfx2/app.hxx>
+#include <appdata.hxx>
+#include <workwin.hxx>
+#include <childwinimpl.hxx>
+#include <sfx2/childwin.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/viewfrm.hxx>
+
+
+void SfxApplication::RegisterChildWindow_Impl( SfxModule *pMod, std::unique_ptr<SfxChildWinFactory> pFact )
+{
+    if ( pMod )
+    {
+        pMod->RegisterChildWindow( std::move(pFact) );
+        return;
+    }
+
+    if (!pImpl->pFactArr)
+        pImpl->pFactArr = new SfxChildWinFactArr_Impl;
+
+    for (size_t nFactory=0; nFactory<pImpl->pFactArr->size(); ++nFactory)
+    {
+        if (pFact->nId ==  (*pImpl->pFactArr)[nFactory].nId)
+        {
+            pImpl->pFactArr->erase( pImpl->pFactArr->begin() + nFactory );
+        }
+    }
+
+    pImpl->pFactArr->push_back( std::move(pFact) );
+}
+
+void SfxApplication::RegisterChildWindowContext_Impl( SfxModule *pMod, sal_uInt16 nId,
+        std::unique_ptr<SfxChildWinContextFactory> pFact)
+{
+    SfxChildWinFactArr_Impl *pFactories;
+    SfxChildWinFactory *pF = nullptr;
+    if ( pMod )
+    {
+        // Abandon Module, search there for ChildwindowFactory
+        pFactories = pMod->GetChildWinFactories_Impl();
+        if ( pFactories )
+        {
+            sal_uInt16 nCount = pFactories->size();
+            for (sal_uInt16 nFactory=0; nFactory<nCount; ++nFactory)
+            {
+                SfxChildWinFactory *pFac = &(*pFactories)[nFactory];
+                if ( nId == pFac->nId )
+                {
+                    // Factory found, register Context here.
+                    pF = pFac;
+                    break;
+                }
+            }
+        }
+    }
+
+    if ( !pF )
+    {
+        // Search for Factory in the Application
+        DBG_ASSERT( pImpl, "No AppData!" );
+        DBG_ASSERT( pImpl->pFactArr, "No Factories!" );
+
+        pFactories = pImpl->pFactArr;
+        sal_uInt16 nCount = pFactories->size();
+        for (sal_uInt16 nFactory=0; nFactory<nCount; ++nFactory)
+        {
+            SfxChildWinFactory *pFac = &(*pFactories)[nFactory];
+            if ( nId == pFac->nId )
+            {
+                if ( pMod )
+                {
+                    // If the context of a module has been registered, then the
+                    // ChildWindowFactory must also be available there,
+                    // else the ContextFactory would have be unsubscribed on
+                    // DLL-exit
+                    pF = new SfxChildWinFactory( pFac->pCtor, pFac->nId,
+                            pFac->nPos );
+                    pMod->RegisterChildWindow( std::unique_ptr<SfxChildWinFactory>(pF) );
+                }
+                else
+                    pF = pFac;
+                break;
+            }
+        }
+    }
+
+    if ( pF )
+    {
+        if ( !pF->pArr )
+            pF->pArr.reset( new SfxChildWinContextArr_Impl );
+        pF->pArr->push_back( std::move(pFact) );
+        return;
+    }
+
+    OSL_FAIL( "No ChildWindow for this Context!" );
+}
+
+
+SfxChildWinFactArr_Impl& SfxApplication::GetChildWinFactories_Impl() const
+{
+    return ( *(pImpl->pFactArr));
+}
+
+
+SfxWorkWindow* SfxApplication::GetWorkWindow_Impl(const SfxViewFrame *pFrame) const
+{
+    if ( pFrame )
+        return pFrame->GetFrame().GetWorkWindow_Impl();
+    else if ( pImpl->pViewFrame )
+        return pImpl->pViewFrame->GetFrame().GetWorkWindow_Impl();
+    else
+        return nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appdata.cxx b/sfx2/source/appl/appdata.cxx
new file mode 100644
index 000000000..fdc3f0304
--- /dev/null
+++ b/sfx2/source/appl/appdata.cxx
@@ -0,0 +1,140 @@
+/* -*- 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 <appdata.hxx>
+#include <sfxpicklist.hxx>
+#include <sfx2/doctempl.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/sidebar/Theme.hxx>
+#include <sfx2/objsh.hxx>
+#include <unoctitm.hxx>
+#include <appbaslib.hxx>
+#include <svl/svdde.hxx>
+
+#include <basic/basicmanagerrepository.hxx>
+#include <basic/basmgr.hxx>
+#include <basic/basrdll.hxx>
+
+using ::basic::BasicManagerRepository;
+using ::basic::BasicManagerCreationListener;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::frame::XModel;
+using ::com::sun::star::uno::XInterface;
+
+static BasicDLL* pBasic = nullptr;
+
+class SfxBasicManagerCreationListener : public ::basic::BasicManagerCreationListener
+{
+private:
+    SfxAppData_Impl& m_rAppData;
+
+public:
+    explicit SfxBasicManagerCreationListener(SfxAppData_Impl& _rAppData)
+        : m_rAppData(_rAppData)
+    {
+    }
+
+    virtual ~SfxBasicManagerCreationListener();
+
+    virtual void onBasicManagerCreated( const Reference< XModel >& _rxForDocument, BasicManager& _rBasicManager ) override;
+};
+
+SfxBasicManagerCreationListener::~SfxBasicManagerCreationListener()
+{
+}
+
+void SfxBasicManagerCreationListener::onBasicManagerCreated( const Reference< XModel >& _rxForDocument, BasicManager& _rBasicManager )
+{
+    if ( _rxForDocument == nullptr )
+        m_rAppData.OnApplicationBasicManagerCreated( _rBasicManager );
+}
+
+SfxAppData_Impl::SfxAppData_Impl()
+    : pFactArr(nullptr)
+    , pMatcher( nullptr )
+    , m_pToolsErrorHdl(nullptr)
+    , m_pSoErrorHdl(nullptr)
+#if HAVE_FEATURE_SCRIPTING
+    , m_pSbxErrorHdl(nullptr)
+#endif
+    , pTemplates( nullptr )
+    , pPool(nullptr)
+    , pProgress(nullptr)
+    , nDocModalMode(0)
+    , nRescheduleLocks(0)
+    , pTbxCtrlFac(nullptr)
+    , pStbCtrlFac(nullptr)
+    , pViewFrames(nullptr)
+    , pViewShells(nullptr)
+    , pObjShells(nullptr)
+    , pBasicManager( new SfxBasicManagerHolder )
+    , pBasMgrListener( new SfxBasicManagerCreationListener( *this ) )
+    , pViewFrame( nullptr )
+    , pSlotPool( nullptr )
+    , pAppDispat( nullptr )
+    , bDowning( true )
+    , bInQuit( false )
+
+{
+    pBasic = new BasicDLL;
+
+#if HAVE_FEATURE_SCRIPTING
+    BasicManagerRepository::registerCreationListener( *pBasMgrListener );
+#endif
+}
+
+SfxAppData_Impl::~SfxAppData_Impl()
+{
+    DeInitDDE();
+    pBasicManager.reset();
+
+#if HAVE_FEATURE_SCRIPTING
+    BasicManagerRepository::revokeCreationListener( *pBasMgrListener );
+    pBasMgrListener.reset();
+#endif
+
+    delete pBasic;
+}
+
+SfxDocumentTemplates* SfxAppData_Impl::GetDocumentTemplates()
+{
+    if ( !pTemplates )
+        pTemplates = new SfxDocumentTemplates;
+    else
+        pTemplates->ReInitFromComponent();
+    return pTemplates;
+}
+
+void SfxAppData_Impl::OnApplicationBasicManagerCreated( BasicManager& _rBasicManager )
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) _rBasicManager;
+#else
+    pBasicManager->reset( &_rBasicManager );
+
+    // global constants, additionally to the ones already added by createApplicationBasicManager:
+    // ThisComponent
+    Reference< XInterface > xCurrentComponent = SfxObjectShell::GetCurrentComponent();
+    _rBasicManager.SetGlobalUNOConstant( "ThisComponent", makeAny( xCurrentComponent ) );
+#endif
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appdde.cxx b/sfx2/source/appl/appdde.cxx
new file mode 100644
index 000000000..9c2e21dcc
--- /dev/null
+++ b/sfx2/source/appl/appdde.cxx
@@ -0,0 +1,567 @@
+/* -*- 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 <rtl/character.hxx>
+#include <rtl/malformeduriexception.hxx>
+#include <rtl/uri.hxx>
+#include <sot/exchange.hxx>
+#include <svl/eitem.hxx>
+#include <basic/sbstar.hxx>
+#include <svl/stritem.hxx>
+#include <svl/svdde.hxx>
+#include <sfx2/lnkbase.hxx>
+#include <sfx2/linkmgr.hxx>
+
+#include <tools/debug.hxx>
+#include <tools/urlobj.hxx>
+#include <tools/diagnose_ex.h>
+#include <unotools/pathoptions.hxx>
+#include <vcl/svapp.hxx>
+
+#include <sfx2/app.hxx>
+#include <appdata.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/docfile.hxx>
+#include <ucbhelper/content.hxx>
+#include <comphelper/processfactory.hxx>
+
+#if defined(_WIN32)
+
+static OUString SfxDdeServiceName_Impl( const OUString& sIn )
+{
+    OUStringBuffer sReturn(sIn.getLength());
+
+    for ( sal_uInt16 n = sIn.getLength(); n; --n )
+    {
+        sal_Unicode cChar = sIn[n-1];
+        if (rtl::isAsciiAlphanumeric(cChar))
+            sReturn.append(cChar);
+    }
+
+    return sReturn.makeStringAndClear();
+}
+
+namespace {
+
+class ImplDdeService : public DdeService
+{
+public:
+    explicit ImplDdeService( const OUString& rNm )
+        : DdeService( rNm )
+    {}
+    virtual bool MakeTopic( const OUString& );
+
+    virtual OUString  Topics();
+
+    virtual bool SysTopicExecute( const OUString* pStr );
+};
+
+    bool lcl_IsDocument( const OUString& rContent )
+    {
+        using namespace com::sun::star;
+
+        bool bRet = false;
+        INetURLObject aObj( rContent );
+        DBG_ASSERT( aObj.GetProtocol() != INetProtocol::NotValid, "Invalid URL!" );
+
+        try
+        {
+            ::ucbhelper::Content aCnt( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), uno::Reference< ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
+            bRet = aCnt.isDocument();
+        }
+        catch( const uno::Exception& )
+        {
+            TOOLS_WARN_EXCEPTION( "sfx.appl", "" );
+        }
+
+        return bRet;
+    }
+}
+
+bool ImplDdeService::MakeTopic( const OUString& rNm )
+{
+    // Workaround for Event after Main() under OS/2
+    // happens when exiting starts the App again
+    if ( !Application::IsInExecute() )
+        return false;
+
+    // The Topic rNm is sought, do we have it?
+    // First only loop over the ObjectShells to find those
+    // with the specific name:
+    bool bRet = false;
+    OUString sNm( rNm.toAsciiLowerCase() );
+    SfxObjectShell* pShell = SfxObjectShell::GetFirst();
+    while( pShell )
+    {
+        OUString sTmp( pShell->GetTitle(SFX_TITLE_FULLNAME) );
+        if( sNm == sTmp.toAsciiLowerCase() )
+        {
+            SfxGetpApp()->AddDdeTopic( pShell );
+            bRet = true;
+            break;
+        }
+        pShell = SfxObjectShell::GetNext( *pShell );
+    }
+
+    if( !bRet )
+    {
+        bool abs;
+        OUString url;
+        try {
+            url = rtl::Uri::convertRelToAbs(SvtPathOptions().GetWorkPath(), rNm);
+            abs = true;
+        } catch (rtl::MalformedUriException &) {
+            abs = false;
+        }
+        if ( abs && lcl_IsDocument( url ) )
+        {
+            // File exists? then try to load it:
+            SfxStringItem aName( SID_FILE_NAME, url );
+            SfxBoolItem aNewView(SID_OPEN_NEW_VIEW, true);
+
+            SfxBoolItem aSilent(SID_SILENT, true);
+            SfxDispatcher* pDispatcher = SfxGetpApp()->GetDispatcher_Impl();
+            const SfxPoolItem* pRet = pDispatcher->ExecuteList(SID_OPENDOC,
+                    SfxCallMode::SYNCHRON,
+                    { &aName, &aNewView, &aSilent });
+
+            if( dynamic_cast< const SfxViewFrameItem *>( pRet ) &&
+                static_cast<SfxViewFrameItem const *>(pRet)->GetFrame() &&
+                nullptr != ( pShell = static_cast<SfxViewFrameItem const *>(pRet)
+                    ->GetFrame()->GetObjectShell() ) )
+            {
+                SfxGetpApp()->AddDdeTopic( pShell );
+                bRet = true;
+            }
+        }
+    }
+    return bRet;
+}
+
+OUString ImplDdeService::Topics()
+{
+    OUString sRet;
+    if( GetSysTopic() )
+        sRet += GetSysTopic()->GetName();
+
+    SfxObjectShell* pShell = SfxObjectShell::GetFirst();
+    while( pShell )
+    {
+        if( SfxViewFrame::GetFirst( pShell ) )
+        {
+            if( !sRet.isEmpty() )
+                sRet += "\t";
+            sRet += pShell->GetTitle(SFX_TITLE_FULLNAME);
+        }
+        pShell = SfxObjectShell::GetNext( *pShell );
+    }
+    if( !sRet.isEmpty() )
+        sRet += "\r\n";
+    return sRet;
+}
+
+bool ImplDdeService::SysTopicExecute( const OUString* pStr )
+{
+    return SfxApplication::DdeExecute( *pStr );
+}
+#endif
+
+class SfxDdeDocTopic_Impl : public DdeTopic
+{
+#if defined(_WIN32)
+public:
+    SfxObjectShell* pSh;
+    DdeData aData;
+    css::uno::Sequence< sal_Int8 > aSeq;
+
+    explicit SfxDdeDocTopic_Impl( SfxObjectShell* pShell )
+        : DdeTopic( pShell->GetTitle(SFX_TITLE_FULLNAME) ), pSh( pShell )
+    {}
+
+    virtual DdeData* Get( SotClipboardFormatId ) override;
+    virtual bool Put( const DdeData* ) override;
+    virtual bool Execute( const OUString* ) override;
+    virtual bool StartAdviseLoop() override;
+    virtual bool MakeItem( const OUString& rItem ) override;
+#endif
+};
+
+
+#if defined(_WIN32)
+
+namespace {
+
+/*  [Description]
+
+    Checks if 'rCmd' of the event 'rEvent' is (without '(') and then assemble
+    this data into a <ApplicationEvent>, which is then executed through
+    <Application::AppEvent()>. If 'rCmd' is the given event 'rEvent', then
+    TRUE is returned, otherwise FALSE.
+
+    [Example]
+
+    rCmd = "Open(\"d:\doc\doc.sdw\")"
+    rEvent = "Open"
+*/
+bool SfxAppEvent_Impl( const OUString& rCmd, const OUString& rEvent,
+                           ApplicationEvent::Type eType )
+{
+    OUString sEvent(rEvent + "(");
+    if (rCmd.startsWithIgnoreAsciiCase(sEvent))
+    {
+        sal_Int32 start = sEvent.getLength();
+        if ( rCmd.getLength() - start >= 2 )
+        {
+            // Transform into the ApplicationEvent Format
+            //TODO: I /assume/ that rCmd should match the syntax of
+            // <http://msdn.microsoft.com/en-us/library/ms648995.aspx>
+            // "WM_DDE_EXECUTE message" but does not (handle commands enclosed
+            // in [...]; handle commas separating multiple arguments; handle
+            // double "", ((, )), [[, ]] in quoted arguments); see also the mail
+            // thread starting at <http://lists.freedesktop.org/archives/
+            // libreoffice/2013-July/054779.html> "DDE on Windows."
+            std::vector<OUString> aData;
+            for ( sal_Int32 n = start; n < rCmd.getLength() - 1; )
+            {
+                // Resiliently read arguments either starting with " and
+                // spanning to the next " (if any; TODO: do we need to undo any
+                // escaping within the string?) or with neither " nor SPC and
+                // spanning to the next SPC (if any; TODO: is this from not
+                // wrapped in "..." relevant? it would have been parsed by the
+                // original code even if that was only by accident, so I left it
+                // in), with runs of SPCs treated like single ones:
+                switch ( rCmd[n] )
+                {
+                case '"':
+                    {
+                        sal_Int32 i = rCmd.indexOf('"', ++n);
+                        if (i < 0 || i > rCmd.getLength() - 1) {
+                            i = rCmd.getLength() - 1;
+                        }
+                        aData.push_back(rCmd.copy(n, i - n));
+                        n = i + 1;
+                        break;
+                    }
+                case ' ':
+                    ++n;
+                    break;
+                default:
+                    {
+                        sal_Int32 i = rCmd.indexOf(' ', n);
+                        if (i < 0 || i > rCmd.getLength() - 1) {
+                            i = rCmd.getLength() - 1;
+                        }
+                        aData.push_back(rCmd.copy(n, i - n));
+                        n = i + 1;
+                        break;
+                    }
+                }
+            }
+
+            GetpApp()->AppEvent( ApplicationEvent(eType, aData) );
+            return true;
+        }
+    }
+
+    return false;
+}
+
+}
+
+/*  Description]
+
+    This method can be overridden by application developers, to receive
+    DDE-commands directed to their SfxApplication subclass.
+
+    The base implementation understands the API functionality of the
+    relevant SfxApplication subclass in BASIC syntax. Return values can
+    not be transferred, unfortunately.
+*/
+long SfxApplication::DdeExecute( const OUString&   rCmd )  // Expressed in our BASIC-Syntax
+{
+    // Print or Open-Event?
+    if ( !( SfxAppEvent_Impl( rCmd, "Print", ApplicationEvent::Type::Print ) ||
+            SfxAppEvent_Impl( rCmd, "Open", ApplicationEvent::Type::Open ) ) )
+    {
+        // all others are BASIC
+        StarBASIC* pBasic = GetBasic();
+        DBG_ASSERT( pBasic, "Where is the Basic???" );
+        SbxVariable* pRet = pBasic->Execute( rCmd );
+        if( !pRet )
+        {
+            SbxBase::ResetError();
+            return 0;
+        }
+    }
+    return 1;
+}
+
+/*  [Description]
+
+    This method can be overridden by application developers, to receive
+    DDE-commands directed to the their SfxApplication subclass.
+
+    The base implementation does nothing and returns 0.
+*/
+long SfxObjectShell::DdeExecute( const OUString&   rCmd )  // Expressed in our BASIC-Syntax
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) rCmd;
+#else
+    StarBASIC* pBasic = GetBasic();
+    DBG_ASSERT( pBasic, "Where is the Basic???" ) ;
+    SbxVariable* pRet = pBasic->Execute( rCmd );
+    if( !pRet )
+    {
+        SbxBase::ResetError();
+        return 0;
+    }
+#endif
+    return 1;
+}
+
+/*  [Description]
+
+    This method can be overridden by application developers, to receive
+    DDE-data-requests directed to their SfxApplication subclass.
+
+    The base implementation provides no data and returns false.
+*/
+bool SfxObjectShell::DdeGetData( const OUString&,              // the Item to be addressed
+                                 const OUString&,              // in: Format
+                                 css::uno::Any& )// out: requested data
+{
+    return false;
+}
+
+
+/*  [Description]
+
+    This method can be overridden by application developers, to receive
+    DDE-data directed to their SfxApplication subclass.
+
+    The base implementation is not receiving any data and returns false.
+*/
+bool SfxObjectShell::DdeSetData( const OUString&,                    // the Item to be addressed
+                                 const OUString&,                    // in: Format
+                                 const css::uno::Any& )// out: requested data
+{
+    return false;
+}
+
+#endif
+
+/*  [Description]
+
+    This method can be overridden by application developers, to establish
+    a DDE-hotlink to their SfxApplication subclass.
+
+    The base implementation is not generate a link and returns 0.
+*/
+::sfx2::SvLinkSource* SfxObjectShell::DdeCreateLinkSource( const OUString& ) // the Item to be addressed
+{
+    return nullptr;
+}
+
+void SfxObjectShell::ReconnectDdeLink(SfxObjectShell& /*rServer*/)
+{
+}
+
+void SfxObjectShell::ReconnectDdeLinks(SfxObjectShell& rServer)
+{
+    SfxObjectShell* p = GetFirst(nullptr, false);
+    while (p)
+    {
+        if (&rServer != p)
+            p->ReconnectDdeLink(rServer);
+
+        p = GetNext(*p, nullptr, false);
+    }
+}
+
+bool SfxApplication::InitializeDde()
+{
+    int nError = 0;
+#if defined(_WIN32)
+    DBG_ASSERT( !pImpl->pDdeService,
+                "Dde can not be initialized multiple times" );
+
+    pImpl->pDdeService.reset(new ImplDdeService( Application::GetAppName() ));
+    nError = pImpl->pDdeService->GetError();
+    if( !nError )
+    {
+        pImpl->pDocTopics.reset(new SfxDdeDocTopics_Impl);
+
+        // we certainly want to support RTF!
+        pImpl->pDdeService->AddFormat( SotClipboardFormatId::RTF );
+        pImpl->pDdeService->AddFormat( SotClipboardFormatId::RICHTEXT );
+
+        // Config path as a topic because of multiple starts
+        INetURLObject aOfficeLockFile( SvtPathOptions().GetUserConfigPath() );
+        aOfficeLockFile.insertName( "soffice.lck" );
+        OUString aService( SfxDdeServiceName_Impl(
+                    aOfficeLockFile.GetMainURL(INetURLObject::DecodeMechanism::ToIUri) ) );
+        aService = aService.toAsciiUpperCase();
+        pImpl->pDdeService2.reset( new ImplDdeService( aService ));
+        pImpl->pTriggerTopic.reset(new SfxDdeTriggerTopic_Impl);
+        pImpl->pDdeService2->AddTopic( *pImpl->pTriggerTopic );
+    }
+#endif
+    return !nError;
+}
+
+void SfxAppData_Impl::DeInitDDE()
+{
+    pTriggerTopic.reset();
+    pDdeService2.reset();
+    pDocTopics.reset();
+    pDdeService.reset();
+}
+
+#if defined(_WIN32)
+void SfxApplication::AddDdeTopic( SfxObjectShell* pSh )
+{
+    //OV: DDE is disconnected in server mode!
+    if( !pImpl->pDocTopics )
+        return;
+
+    // prevent double submit
+    OUString sShellNm;
+    bool bFnd = false;
+    for (size_t n = pImpl->pDocTopics->size(); n;)
+    {
+        if( (*pImpl->pDocTopics)[ --n ]->pSh == pSh )
+        {
+            // If the document is untitled, is still a new Topic is created!
+            if( !bFnd )
+            {
+                bFnd = true;
+                sShellNm = pSh->GetTitle(SFX_TITLE_FULLNAME).toAsciiLowerCase();
+            }
+            OUString sNm( (*pImpl->pDocTopics)[ n ]->GetName() );
+            if( sShellNm == sNm.toAsciiLowerCase() )
+                return ;
+        }
+    }
+
+    SfxDdeDocTopic_Impl *const pTopic = new SfxDdeDocTopic_Impl(pSh);
+    pImpl->pDocTopics->push_back(pTopic);
+    pImpl->pDdeService->AddTopic( *pTopic );
+}
+#endif
+
+void SfxApplication::RemoveDdeTopic( SfxObjectShell const * pSh )
+{
+#if defined(_WIN32)
+    //OV: DDE is disconnected in server mode!
+    if( !pImpl->pDocTopics )
+        return;
+
+    for (size_t n = pImpl->pDocTopics->size(); n; )
+    {
+        SfxDdeDocTopic_Impl *const pTopic = (*pImpl->pDocTopics)[ --n ];
+        if (pTopic->pSh == pSh)
+        {
+            pImpl->pDdeService->RemoveTopic( *pTopic );
+            delete pTopic;
+            pImpl->pDocTopics->erase( pImpl->pDocTopics->begin() + n );
+        }
+    }
+#else
+    (void) pSh;
+#endif
+}
+
+const DdeService* SfxApplication::GetDdeService() const
+{
+    return pImpl->pDdeService.get();
+}
+
+DdeService* SfxApplication::GetDdeService()
+{
+    return pImpl->pDdeService.get();
+}
+
+#if defined(_WIN32)
+
+DdeData* SfxDdeDocTopic_Impl::Get(SotClipboardFormatId nFormat)
+{
+    OUString sMimeType( SotExchange::GetFormatMimeType( nFormat ));
+    css::uno::Any aValue;
+    bool bRet = pSh->DdeGetData( GetCurItem(), sMimeType, aValue );
+    if( bRet && aValue.hasValue() && ( aValue >>= aSeq ) )
+    {
+        aData = DdeData( aSeq.getConstArray(), aSeq.getLength(), nFormat );
+        return &aData;
+    }
+    aSeq.realloc( 0 );
+    return nullptr;
+}
+
+bool SfxDdeDocTopic_Impl::Put( const DdeData* pData )
+{
+    aSeq = css::uno::Sequence< sal_Int8 >(
+                            static_cast<sal_Int8 const *>(pData->getData()), pData->getSize() );
+    bool bRet;
+    if( aSeq.getLength() )
+    {
+        css::uno::Any aValue;
+        aValue <<= aSeq;
+        OUString sMimeType( SotExchange::GetFormatMimeType( pData->GetFormat() ));
+        bRet = pSh->DdeSetData( GetCurItem(), sMimeType, aValue );
+    }
+    else
+        bRet = false;
+    return bRet;
+}
+
+bool SfxDdeDocTopic_Impl::Execute( const OUString* pStr )
+{
+    long nRet = pStr ? pSh->DdeExecute( *pStr ) : 0;
+    return 0 != nRet;
+}
+
+bool SfxDdeDocTopic_Impl::MakeItem( const OUString& rItem )
+{
+    AddItem( DdeItem( rItem ) );
+    return true;
+}
+
+bool SfxDdeDocTopic_Impl::StartAdviseLoop()
+{
+    bool bRet = false;
+    ::sfx2::SvLinkSource* pNewObj = pSh->DdeCreateLinkSource( GetCurItem() );
+    if( pNewObj )
+    {
+        // then we also establish a corresponding SvBaseLink
+        OUString sNm, sTmp( Application::GetAppName() );
+        ::sfx2::MakeLnkName( sNm, &sTmp, pSh->GetTitle(SFX_TITLE_FULLNAME), GetCurItem() );
+        new ::sfx2::SvBaseLink( sNm, sfx2::SvBaseLinkObjectType::DdeExternal, pNewObj );
+        bRet = true;
+    }
+    return bRet;
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appdispatchprovider.cxx b/sfx2/source/appl/appdispatchprovider.cxx
new file mode 100644
index 000000000..2cec473fc
--- /dev/null
+++ b/sfx2/source/appl/appdispatchprovider.cxx
@@ -0,0 +1,232 @@
+/* -*- 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/frame/XAppDispatchProvider.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/frame/DispatchDescriptor.hpp>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/util/URL.hpp>
+
+#include <comphelper/sequence.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/msgpool.hxx>
+#include <sfx2/sfxbasecontroller.hxx>
+#include <unoctitm.hxx>
+#include <vcl/svapp.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::uno;
+
+namespace {
+
+class SfxAppDispatchProvider : public ::cppu::WeakImplHelper< css::frame::XAppDispatchProvider,
+                                                               css::lang::XServiceInfo,
+                                                               css::lang::XInitialization >
+{
+    css::uno::WeakReference < css::frame::XFrame > m_xFrame;
+public:
+    SfxAppDispatchProvider() {}
+
+    virtual void SAL_CALL initialize(
+        css::uno::Sequence<css::uno::Any> const & aArguments) override;
+
+    virtual OUString SAL_CALL getImplementationName() override;
+
+    virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override;
+
+    virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
+
+    virtual css::uno::Reference < css::frame::XDispatch > SAL_CALL queryDispatch(
+            const css::util::URL& aURL, const OUString& sTargetFrameName,
+            sal_Int32 eSearchFlags ) override;
+
+    virtual css::uno::Sequence< css::uno::Reference < css::frame::XDispatch > > SAL_CALL queryDispatches(
+            const css::uno::Sequence < css::frame::DispatchDescriptor >& seqDescriptor ) override;
+
+    virtual css::uno::Sequence< sal_Int16 > SAL_CALL getSupportedCommandGroups() override;
+
+    virtual css::uno::Sequence< css::frame::DispatchInformation > SAL_CALL getConfigurableDispatchInformation( sal_Int16 ) override;
+};
+
+void SfxAppDispatchProvider::initialize(
+    css::uno::Sequence<css::uno::Any> const & aArguments)
+{
+    css::uno::Reference<css::frame::XFrame> f;
+    if (aArguments.getLength() != 1 || !(aArguments[0] >>= f)) {
+        throw css::lang::IllegalArgumentException(
+            "SfxAppDispatchProvider::initialize expects one XFrame argument",
+            static_cast<OWeakObject *>(this), 0);
+    }
+    m_xFrame = f;
+}
+
+OUString SAL_CALL SfxAppDispatchProvider::getImplementationName()
+{
+    return "com.sun.star.comp.sfx2.AppDispatchProvider";
+}
+
+sal_Bool SAL_CALL SfxAppDispatchProvider::supportsService( const OUString& sServiceName )
+{
+    return cppu::supportsService(this, sServiceName);
+}
+
+css::uno::Sequence< OUString > SAL_CALL SfxAppDispatchProvider::getSupportedServiceNames()
+{
+    return { "com.sun.star.frame.ProtocolHandler", "com.sun.star.frame.AppDispatchProvider" };
+}
+
+Reference < XDispatch > SAL_CALL SfxAppDispatchProvider::queryDispatch(
+    const util::URL& aURL,
+    const OUString& /*sTargetFrameName*/,
+    sal_Int32 /*eSearchFlags*/ )
+{
+    SolarMutexGuard guard;
+
+    sal_uInt16                  nId( 0 );
+    bool                bMasterCommand( false );
+    Reference < XDispatch > xDisp;
+    const SfxSlot* pSlot = nullptr;
+    SfxApplication* pApp = SfxGetpApp();
+    if ( !pApp )
+        return xDisp;
+    SfxDispatcher* pAppDisp = pApp->GetAppDispatcher_Impl();
+    if ( aURL.Protocol == "slot:" || aURL.Protocol == "commandId:" )
+    {
+        nId = static_cast<sal_uInt16>(aURL.Path.toInt32());
+        SfxShell* pShell;
+        pAppDisp->GetShellAndSlot_Impl( nId, &pShell, &pSlot, true, true );
+    }
+    else if ( aURL.Protocol == ".uno:" )
+    {
+        // Support ".uno" commands. Map commands to slotid
+        bMasterCommand = SfxOfficeDispatch::IsMasterUnoCommand( aURL );
+        if ( bMasterCommand )
+            pSlot = pAppDisp->GetSlot( SfxOfficeDispatch::GetMasterUnoCommand( aURL ) );
+        else
+            pSlot = pAppDisp->GetSlot( aURL.Main );
+    }
+
+    if ( pSlot )
+    {
+        SfxOfficeDispatch* pDispatch = new SfxOfficeDispatch( pAppDisp, pSlot, aURL ) ;
+        pDispatch->SetFrame(m_xFrame);
+        pDispatch->SetMasterUnoCommand( bMasterCommand );
+        xDisp = pDispatch;
+    }
+
+    return xDisp;
+}
+
+Sequence< Reference < XDispatch > > SAL_CALL SfxAppDispatchProvider::queryDispatches( const Sequence < DispatchDescriptor >& seqDescriptor )
+{
+    sal_Int32 nCount = seqDescriptor.getLength();
+    uno::Sequence< uno::Reference < frame::XDispatch > > lDispatcher(nCount);
+    std::transform(seqDescriptor.begin(), seqDescriptor.end(), lDispatcher.begin(),
+        [this](const DispatchDescriptor& rDescr) -> uno::Reference<frame::XDispatch> {
+            return queryDispatch(rDescr.FeatureURL, rDescr.FrameName, rDescr.SearchFlags); });
+    return lDispatcher;
+}
+
+Sequence< sal_Int16 > SAL_CALL SfxAppDispatchProvider::getSupportedCommandGroups()
+{
+    SolarMutexGuard aGuard;
+
+    std::vector< sal_Int16 > aGroupList;
+    SfxSlotPool& rAppSlotPool = SfxGetpApp()->GetAppSlotPool_Impl();
+
+    const SfxSlotMode nMode( SfxSlotMode::TOOLBOXCONFIG|SfxSlotMode::ACCELCONFIG|SfxSlotMode::MENUCONFIG );
+
+    // Select group ( group 0 is internal )
+    for (sal_uInt16 i=0; i< rAppSlotPool.GetGroupCount(); ++i)
+    {
+        rAppSlotPool.SeekGroup(i);
+        const SfxSlot* pSfxSlot = rAppSlotPool.FirstSlot();
+        while ( pSfxSlot )
+        {
+            if ( pSfxSlot->GetMode() & nMode )
+            {
+                sal_Int16 nCommandGroup = MapGroupIDToCommandGroup( pSfxSlot->GetGroupId() );
+                aGroupList.push_back( nCommandGroup );
+                break;
+            }
+            pSfxSlot = rAppSlotPool.NextSlot();
+        }
+    }
+
+    return comphelper::containerToSequence( aGroupList );
+}
+
+Sequence< frame::DispatchInformation > SAL_CALL SfxAppDispatchProvider::getConfigurableDispatchInformation( sal_Int16 nCmdGroup )
+{
+    std::vector< frame::DispatchInformation > aCmdVector;
+
+    SolarMutexGuard aGuard;
+    SfxSlotPool& rAppSlotPool = SfxGetpApp()->GetAppSlotPool_Impl();
+
+    const SfxSlotMode nMode( SfxSlotMode::TOOLBOXCONFIG|SfxSlotMode::ACCELCONFIG|SfxSlotMode::MENUCONFIG );
+
+    // Select group ( group 0 is internal )
+    for (sal_uInt16 i=0; i< rAppSlotPool.GetGroupCount(); ++i)
+    {
+        rAppSlotPool.SeekGroup(i);
+        const SfxSlot* pSfxSlot = rAppSlotPool.FirstSlot();
+        if ( pSfxSlot )
+        {
+            sal_Int16 nCommandGroup = MapGroupIDToCommandGroup( pSfxSlot->GetGroupId() );
+            if ( nCommandGroup == nCmdGroup )
+            {
+                while ( pSfxSlot )
+                {
+                    if ( pSfxSlot->GetMode() & nMode )
+                    {
+                        frame::DispatchInformation aCmdInfo;
+                        aCmdInfo.Command = ".uno:" + OUString::createFromAscii(pSfxSlot->GetUnoName());
+                        aCmdInfo.GroupId = nCommandGroup;
+                        aCmdVector.push_back( aCmdInfo );
+                    }
+                    pSfxSlot = rAppSlotPool.NextSlot();
+                }
+            }
+        }
+    }
+
+    return comphelper::containerToSequence( aCmdVector );
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_sfx2_AppDispatchProvider_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new SfxAppDispatchProvider);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appinit.cxx b/sfx2/source/appl/appinit.cxx
new file mode 100644
index 000000000..3ebc6a83b
--- /dev/null
+++ b/sfx2/source/appl/appinit.cxx
@@ -0,0 +1,244 @@
+/* -*- 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 <sfx2/app.hxx>
+#include <com/sun/star/frame/XTerminateListener.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/frame/theGlobalEventBroadcaster.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+
+#include <basic/sbdef.hxx>
+#include <tools/svlibrary.h>
+#include <svtools/soerr.hxx>
+#include <unotools/configmgr.hxx>
+#include <svtools/ehdl.hxx>
+#include <comphelper/processfactory.hxx>
+#include <osl/module.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include <vcl/specialchars.hxx>
+#include <vcl/help.hxx>
+#include <vcl/svapp.hxx>
+
+#include <unoctitm.hxx>
+#include <appdata.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/msgpool.hxx>
+#include <nochaos.hxx>
+#include <sfxpicklist.hxx>
+#include <ctrlfactoryimpl.hxx>
+#include <shellimpl.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star;
+
+namespace {
+
+class SfxTerminateListener_Impl : public ::cppu::WeakImplHelper< XTerminateListener, XServiceInfo >
+{
+public:
+
+    // XTerminateListener
+    virtual void SAL_CALL queryTermination( const EventObject& aEvent ) override;
+    virtual void SAL_CALL notifyTermination( const EventObject& aEvent ) override;
+    virtual void SAL_CALL disposing( const EventObject& Source ) override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& sServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+}
+
+void SAL_CALL SfxTerminateListener_Impl::disposing( const EventObject& )
+{
+}
+
+void SAL_CALL SfxTerminateListener_Impl::queryTermination( const EventObject& )
+{
+}
+
+void SAL_CALL SfxTerminateListener_Impl::notifyTermination( const EventObject& aEvent )
+{
+    Reference< XDesktop > xDesktop( aEvent.Source, UNO_QUERY );
+    if( xDesktop.is() )
+        xDesktop->removeTerminateListener( this );
+
+    SolarMutexGuard aGuard;
+    utl::ConfigManager::storeConfigItems();
+
+    SfxApplication* pApp = SfxGetpApp();
+    pApp->Broadcast( SfxHint( SfxHintId::Deinitializing ) );
+    pApp->Get_Impl()->mxAppDispatch->ReleaseAll();
+    pApp->Get_Impl()->mxAppDispatch.clear();
+
+    css::uno::Reference< css::uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+    css::uno::Reference< css::document::XDocumentEventListener > xGlobalBroadcaster(css::frame::theGlobalEventBroadcaster::get(xContext), css::uno::UNO_QUERY_THROW);
+
+    css::document::DocumentEvent aEvent2;
+    aEvent2.EventName = "OnCloseApp";
+    xGlobalBroadcaster->documentEventOccured(aEvent2);
+
+    delete pApp;
+    Application::Quit();
+}
+
+OUString SAL_CALL SfxTerminateListener_Impl::getImplementationName()
+{
+    return "com.sun.star.comp.sfx2.SfxTerminateListener";
+}
+
+sal_Bool SAL_CALL SfxTerminateListener_Impl::supportsService( const OUString& sServiceName )
+{
+    return cppu::supportsService(this, sServiceName);
+}
+
+Sequence< OUString > SAL_CALL SfxTerminateListener_Impl::getSupportedServiceNames()
+{
+    // Note: That service  does not really exists .-)
+    // But this implementation is not thought to be registered really within our service.rdb.
+    // At least we need the implementation name only to identify these service at the global desktop instance.
+    // The desktop must know, which listener will terminate the SfxApplication in real !
+    // It must call this special listener as last one ... otherwise we shutdown the SfxApplication BEFORE other listener
+    // can react ...
+    return { "com.sun.star.frame.TerminateListener" };
+}
+
+
+typedef bool (*PFunc_getSpecialCharsForEdit)(weld::Widget* i_pParent, const vcl::Font& i_rFont, OUString& o_rOutString);
+
+
+// Lazy binding of the GetSpecialCharsForEdit function as it resides in
+// a library above us.
+
+
+#ifndef DISABLE_DYNLOADING
+
+extern "C" { static void thisModule() {} }
+
+#else
+
+extern "C" bool GetSpecialCharsForEdit(weld::Widget* i_pParent, const vcl::Font& i_rFont, OUString& o_rOutString);
+
+#endif
+
+static OUString SfxGetSpecialCharsForEdit(weld::Widget* pParent, const vcl::Font& rFont)
+{
+    static bool bDetermineFunction = false;
+    static PFunc_getSpecialCharsForEdit pfunc_getSpecialCharsForEdit = nullptr;
+
+    SolarMutexGuard aGuard;
+    if ( !bDetermineFunction )
+    {
+        bDetermineFunction = true;
+
+#ifndef DISABLE_DYNLOADING
+        osl::Module aMod;
+        aMod.loadRelative(&thisModule, SVLIBRARY("cui"));
+
+        // get symbol
+        pfunc_getSpecialCharsForEdit = reinterpret_cast<PFunc_getSpecialCharsForEdit>(aMod.getFunctionSymbol("GetSpecialCharsForEdit"));
+        DBG_ASSERT( pfunc_getSpecialCharsForEdit, "GetSpecialCharsForEdit() not found!" );
+        aMod.release();
+#else
+        pfunc_getSpecialCharsForEdit = GetSpecialCharsForEdit;
+#endif
+    }
+
+    OUString aRet;
+    if ( pfunc_getSpecialCharsForEdit )
+        (*pfunc_getSpecialCharsForEdit)( pParent, rFont, aRet );
+    return aRet;
+}
+
+
+void SfxApplication::Initialize_Impl()
+{
+#ifdef TLX_VALIDATE
+    StgIo::SetErrorLink( LINK( this, SfxStorageErrHdl, Error ) );
+#endif
+
+    Reference < XDesktop2 > xDesktop = Desktop::create ( ::comphelper::getProcessComponentContext() );
+    xDesktop->addTerminateListener( new SfxTerminateListener_Impl );
+
+    pImpl->mxAppDispatch = new SfxStatusDispatcher;
+
+    // SV-Look
+    Help::EnableContextHelp();
+    Help::EnableExtHelp();
+
+    pImpl->m_pToolsErrorHdl = new SfxErrorHandler(
+        RID_ERRHDL, ErrCodeArea::Io, ErrCodeArea::Vcl);
+
+    pImpl->m_pSoErrorHdl = new SfxErrorHandler(
+        RID_SO_ERROR_HANDLER, ErrCodeArea::So, ErrCodeArea::So, SvtResLocale());
+#if HAVE_FEATURE_SCRIPTING
+    pImpl->m_pSbxErrorHdl = new SfxErrorHandler(
+        RID_BASIC_START, ErrCodeArea::Sbx, ErrCodeArea::Sbx, BasResLocale());
+#endif
+
+    if (!utl::ConfigManager::IsFuzzing())
+    {
+        SolarMutexGuard aGuard;
+        //ensure instantiation of listener that manages the internal recently-used
+        //list
+        pImpl->mxAppPickList.reset(new SfxPickList(*this));
+    }
+
+    DBG_ASSERT( !pImpl->pAppDispat, "AppDispatcher already exists" );
+    pImpl->pAppDispat = new SfxDispatcher;
+    pImpl->pSlotPool = new SfxSlotPool;
+    pImpl->pTbxCtrlFac = new SfxTbxCtrlFactArr_Impl;
+    pImpl->pStbCtrlFac = new SfxStbCtrlFactArr_Impl;
+    pImpl->pViewFrames = new SfxViewFrameArr_Impl;
+    pImpl->pViewShells = new SfxViewShellArr_Impl;
+    pImpl->pObjShells = new SfxObjectShellArr_Impl;
+
+    Registrations_Impl();
+
+    // initialize the subclass
+    pImpl->bDowning = false;
+
+    // get CHAOS item pool...
+    pImpl->pPool = NoChaos::GetItemPool();
+    SetPool( pImpl->pPool );
+
+    if ( pImpl->bDowning )
+        return;
+
+    // build the app dispatcher
+    pImpl->pAppDispat->Push(*this);
+    pImpl->pAppDispat->Flush();
+    pImpl->pAppDispat->DoActivate_Impl( true );
+
+    {
+        SolarMutexGuard aGuard;
+        // Set special characters callback on vcl edit control
+        vcl::SetGetSpecialCharsFunction(&SfxGetSpecialCharsForEdit);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appmain.cxx b/sfx2/source/appl/appmain.cxx
new file mode 100644
index 000000000..31295cd0f
--- /dev/null
+++ b/sfx2/source/appl/appmain.cxx
@@ -0,0 +1,38 @@
+/* -*- 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/urihelper.hxx>
+
+#include <appdata.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/fcontnr.hxx>
+
+
+SfxFilterMatcher& SfxApplication::GetFilterMatcher()
+{
+    if( !pImpl->pMatcher )
+    {
+        pImpl->pMatcher = new SfxFilterMatcher();
+        URIHelper::SetMaybeFileHdl( LINK(
+            pImpl->pMatcher, SfxFilterMatcher, MaybeFileHdl_Impl ) );
+    }
+    return *pImpl->pMatcher;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appmisc.cxx b/sfx2/source/appl/appmisc.cxx
new file mode 100644
index 000000000..ada8f86ee
--- /dev/null
+++ b/sfx2/source/appl/appmisc.cxx
@@ -0,0 +1,210 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_folders.h>
+#include <ucbhelper/content.hxx>
+
+#include <vcl/canvastools.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <com/sun/star/rendering/XIntegerReadOnlyBitmap.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/graphic/Primitive2DTools.hpp>
+#include <com/sun/star/uno/Reference.h>
+#include <unotools/configmgr.hxx>
+#include <comphelper/processfactory.hxx>
+#include <rtl/bootstrap.hxx>
+#include <svl/stritem.hxx>
+#include <tools/urlobj.hxx>
+
+#include <sfx2/app.hxx>
+#include <appdata.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/msgpool.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/objface.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+
+#define ShellClass_SfxApplication
+#include <sfxslots.hxx>
+
+SFX_IMPL_INTERFACE(SfxApplication,SfxShell)
+
+void SfxApplication::InitInterface_Impl()
+{
+    GetStaticInterface()->RegisterStatusBar(StatusBarId::GenericStatusBar);
+
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_0);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_1);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_2);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_3);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_4);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_5);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_6);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_7);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_8);
+    GetStaticInterface()->RegisterChildWindow(SID_DOCKWIN_9);
+}
+
+/** Returns the running SfxProgress for the entire application or 0 if
+    none is running for the entire application.
+
+    [Cross-reference]
+
+    <SfxProgress::GetActiveProgress(SfxViewFrame*)>
+    <SfxViewFrame::GetProgress()const>
+*/
+SfxProgress* SfxApplication::GetProgress() const
+{
+    return pImpl->pProgress;
+}
+
+SfxModule* SfxApplication::GetModule_Impl()
+{
+    SfxModule* pModule = SfxModule::GetActiveModule();
+    if ( !pModule )
+        pModule = SfxModule::GetActiveModule( SfxViewFrame::GetFirst( nullptr, false ) );
+    if( pModule )
+        return pModule;
+    else
+    {
+        OSL_FAIL( "No module!" );
+        return nullptr;
+    }
+}
+
+bool  SfxApplication::IsDowning() const { return pImpl->bDowning; }
+SfxDispatcher* SfxApplication::GetAppDispatcher_Impl() { return pImpl->pAppDispat; }
+SfxSlotPool& SfxApplication::GetAppSlotPool_Impl() const { return *pImpl->pSlotPool; }
+
+static bool FileExists( const INetURLObject& rURL )
+{
+    bool bRet = false;
+
+    if( rURL.GetProtocol() != INetProtocol::NotValid )
+    {
+        try
+        {
+            ::ucbhelper::Content  aCnt( rURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), uno::Reference< ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
+            OUString aTitle;
+
+            aCnt.getPropertyValue("Title") >>= aTitle;
+            bRet = ( !aTitle.isEmpty() );
+        }
+        catch(const Exception&)
+        {
+            return false;
+        }
+    }
+
+    return bRet;
+}
+
+bool SfxApplication::loadBrandSvg(const char *pName, BitmapEx &rBitmap, int nWidth)
+{
+    // Load from disk
+
+    OUString aBaseName = "/" + OUString::createFromAscii( pName );
+
+    OUString uri = "$BRAND_BASE_DIR/" LIBO_ETC_FOLDER + aBaseName + ".svg";
+    rtl::Bootstrap::expandMacros( uri );
+
+    INetURLObject aObj( uri );
+    if ( !FileExists(aObj) )
+        return false;
+
+    VectorGraphicData aVectorGraphicData(aObj.PathToFileName(), VectorGraphicDataType::Svg);
+
+    // transform into [0,0,width,width*aspect] std dimensions
+
+    basegfx::B2DRange aRange(aVectorGraphicData.getRange());
+    const double fAspectRatio(
+        aRange.getHeight() == 0.0 ? 1.0 : aRange.getWidth()/aRange.getHeight());
+    basegfx::B2DHomMatrix aTransform(
+        basegfx::utils::createTranslateB2DHomMatrix(
+            -aRange.getMinX(),
+            -aRange.getMinY()));
+    aTransform.scale(
+        aRange.getWidth() == 0.0 ? 1.0 : nWidth / aRange.getWidth(),
+        (aRange.getHeight() == 0.0
+         ? 1.0 : nWidth / fAspectRatio / aRange.getHeight()));
+    const drawinglayer::primitive2d::Primitive2DReference xTransformRef(
+        new drawinglayer::primitive2d::TransformPrimitive2D(
+            aTransform,
+            aVectorGraphicData.getPrimitive2DSequence()));
+
+    // UNO dance to render from drawinglayer
+
+    uno::Reference< uno::XComponentContext > xContext(::comphelper::getProcessComponentContext());
+
+    try
+    {
+        const uno::Reference< graphic::XPrimitive2DRenderer > xPrimitive2DRenderer =
+            graphic::Primitive2DTools::create( xContext );
+
+        // cancel out rasterize's mm2pixel conversion
+        // see fFactor100th_mmToInch in
+        // drawinglayer/source/drawinglayeruno/xprimitive2drenderer.cxx
+        const double fFakeDPI=2.54 * 1000.0;
+
+        geometry::RealRectangle2D aRealRect(
+            0, 0,
+            nWidth, nWidth / fAspectRatio);
+
+        const uno::Reference< rendering::XBitmap > xBitmap(
+            xPrimitive2DRenderer->rasterize(
+                drawinglayer::primitive2d::Primitive2DSequence(&xTransformRef, 1),
+                uno::Sequence< beans::PropertyValue >(),
+                fFakeDPI,
+                fFakeDPI,
+                aRealRect,
+                500000));
+
+        if(xBitmap.is())
+        {
+            const uno::Reference< rendering::XIntegerReadOnlyBitmap> xIntBmp(xBitmap, uno::UNO_QUERY_THROW);
+            rBitmap = vcl::unotools::bitmapExFromXBitmap(xIntBmp);
+            return true;
+        }
+    }
+    catch(const uno::Exception&)
+    {
+        OSL_ENSURE(false, "Got no graphic::XPrimitive2DRenderer (!)" );
+    }
+    return false;
+}
+
+/** loads the application logo as used in the impress slideshow pause screen */
+BitmapEx SfxApplication::GetApplicationLogo(long nWidth)
+{
+    BitmapEx aBitmap;
+    SfxApplication::loadBrandSvg("shell/about", aBitmap, nWidth);
+    return aBitmap;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appopen.cxx b/sfx2/source/appl/appopen.cxx
new file mode 100644
index 000000000..4ecc4cf88
--- /dev/null
+++ b/sfx2/source/appl/appopen.cxx
@@ -0,0 +1,1133 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/frame/FrameSearchFlag.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/util/URL.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <com/sun/star/system/SystemShellExecuteException.hpp>
+#include <com/sun/star/document/XTypeDetection.hpp>
+#include <com/sun/star/document/MacroExecMode.hpp>
+#include <com/sun/star/document/UpdateDocMode.hpp>
+#include <com/sun/star/task/ErrorCodeRequest.hpp>
+#include <com/sun/star/task/InteractionHandler.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/packages/WrongPasswordException.hpp>
+#include <com/sun/star/uno/Sequence.h>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <rtl/ustring.hxx>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/sequence.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <comphelper/synchronousdispatch.hxx>
+
+#include <svl/intitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/eitem.hxx>
+#include <sfx2/doctempl.hxx>
+#include <svtools/sfxecode.hxx>
+#include <preventduplicateinteraction.hxx>
+#include <svtools/ehdl.hxx>
+#include <unotools/pathoptions.hxx>
+#include <unotools/securityoptions.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <unotools/extendedsecurityoptions.hxx>
+#include <comphelper/docpasswordhelper.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+
+#include <sfx2/app.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <sfx2/objitem.hxx>
+#include <sfx2/objsh.hxx>
+#include <svl/slstitm.hxx>
+#include <appopen.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/sfxuno.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <sfx2/templatedlg.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <openuriexternally.hxx>
+
+#include <officecfg/Office/ProtocolHandler.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::task;
+using namespace ::com::sun::star::container;
+using namespace ::cppu;
+using namespace ::sfx2;
+
+void SetTemplate_Impl( const OUString &rFileName,
+                        const OUString &rLongName,
+                        SfxObjectShell *pDoc)
+{
+    // write TemplateName to DocumentProperties of document
+    // TemplateDate stays as default (=current date)
+    pDoc->ResetFromTemplate( rLongName, rFileName );
+}
+
+namespace {
+
+class SfxDocPasswordVerifier : public ::comphelper::IDocPasswordVerifier
+{
+public:
+    explicit     SfxDocPasswordVerifier( const Reference< embed::XStorage >& rxStorage ) :
+                            mxStorage( rxStorage ) {}
+
+    virtual ::comphelper::DocPasswordVerifierResult
+                        verifyPassword( const OUString& rPassword, uno::Sequence< beans::NamedValue >& o_rEncryptionData ) override;
+    virtual ::comphelper::DocPasswordVerifierResult
+                        verifyEncryptionData( const uno::Sequence< beans::NamedValue >& rEncryptionData ) override;
+
+
+private:
+    Reference< embed::XStorage > mxStorage;
+};
+
+}
+
+::comphelper::DocPasswordVerifierResult SfxDocPasswordVerifier::verifyPassword( const OUString& rPassword, uno::Sequence< beans::NamedValue >& o_rEncryptionData )
+{
+    o_rEncryptionData = ::comphelper::OStorageHelper::CreatePackageEncryptionData( rPassword );
+    return verifyEncryptionData( o_rEncryptionData );
+}
+
+
+::comphelper::DocPasswordVerifierResult SfxDocPasswordVerifier::verifyEncryptionData( const uno::Sequence< beans::NamedValue >& rEncryptionData )
+{
+    ::comphelper::DocPasswordVerifierResult eResult = ::comphelper::DocPasswordVerifierResult::WrongPassword;
+    try
+    {
+        // check the encryption data
+        // if the data correct is the stream will be opened successfully
+        // and immediately closed
+        ::comphelper::OStorageHelper::SetCommonStorageEncryptionData( mxStorage, rEncryptionData );
+
+        mxStorage->openStreamElement(
+                "content.xml",
+                embed::ElementModes::READ | embed::ElementModes::NOCREATE );
+
+        // no exception -> success
+        eResult = ::comphelper::DocPasswordVerifierResult::OK;
+    }
+    catch( const packages::WrongPasswordException& )
+    {
+        eResult = ::comphelper::DocPasswordVerifierResult::WrongPassword;
+    }
+    catch( const uno::Exception& )
+    {
+        // unknown error, report it as wrong password
+        // TODO/LATER: we need an additional way to report unknown problems in this case
+        eResult = ::comphelper::DocPasswordVerifierResult::WrongPassword;
+    }
+    return eResult;
+}
+
+
+ErrCode CheckPasswd_Impl
+(
+    SfxObjectShell*  pDoc,
+    SfxMedium*       pFile      // the Medium and its Password should be obtained
+)
+
+/*  [Description]
+
+    Ask for the password for a medium, only works if it concerns storage.
+    If the password flag is set in the Document Info, then the password is
+    requested through a user dialogue and the set at the Set of the medium.
+    If the set does not exist the it is created.
+*/
+{
+    ErrCode nRet = ERRCODE_NONE;
+
+    if( !pFile->GetFilter() || pFile->IsStorage() )
+    {
+        uno::Reference< embed::XStorage > xStorage = pFile->GetStorage();
+        if( xStorage.is() )
+        {
+            uno::Reference< beans::XPropertySet > xStorageProps( xStorage, uno::UNO_QUERY );
+            if ( xStorageProps.is() )
+            {
+                bool bIsEncrypted = false;
+                uno::Sequence< uno::Sequence< beans::NamedValue > > aGpgProperties;
+                try {
+                    xStorageProps->getPropertyValue("HasEncryptedEntries")
+                        >>= bIsEncrypted;
+                    xStorageProps->getPropertyValue("EncryptionGpGProperties")
+                        >>= aGpgProperties;
+                } catch( uno::Exception& )
+                {
+                    // TODO/LATER:
+                    // the storage either has no encrypted elements or it's just
+                    // does not allow to detect it, probably it should be implemented later
+                }
+
+                if ( bIsEncrypted )
+                {
+                    vcl::Window* pWin = pDoc ? pDoc->GetDialogParent( pFile ) : nullptr;
+                    if ( pWin )
+                        pWin->Show();
+
+                    nRet = ERRCODE_SFX_CANTGETPASSWD;
+
+                    SfxItemSet *pSet = pFile->GetItemSet();
+                    if( pSet )
+                    {
+                        Reference< css::task::XInteractionHandler > xInteractionHandler = pFile->GetInteractionHandler();
+                        if( xInteractionHandler.is() )
+                        {
+                            // use the comphelper password helper to request a password
+                            OUString aPassword;
+                            const SfxStringItem* pPasswordItem = SfxItemSet::GetItem<SfxStringItem>(pSet, SID_PASSWORD, false);
+                            if ( pPasswordItem )
+                                aPassword = pPasswordItem->GetValue();
+
+                            uno::Sequence< beans::NamedValue > aEncryptionData;
+                            const SfxUnoAnyItem* pEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pSet, SID_ENCRYPTIONDATA, false);
+                            if ( pEncryptionDataItem )
+                                pEncryptionDataItem->GetValue() >>= aEncryptionData;
+
+                            // try if one of the public key entries is
+                            // decryptable, then extract session key
+                            // from it
+                            if ( !aEncryptionData.hasElements() && aGpgProperties.hasElements() )
+                                aEncryptionData = ::comphelper::DocPasswordHelper::decryptGpgSession(aGpgProperties);
+
+                            // tdf#93389: if recovering a document, encryption data should contain
+                            // entries for the real filter, not only for recovery ODF, to keep it
+                            // encrypted. Pass this in encryption data.
+                            // TODO: pass here the real filter (from AutoRecovery::implts_openDocs)
+                            // to marshal this to requestAndVerifyDocPassword
+                            if (pSet->GetItemState(SID_DOC_SALVAGE, false) == SfxItemState::SET)
+                            {
+                                aEncryptionData = comphelper::concatSequences(
+                                    aEncryptionData, std::initializer_list<beans::NamedValue>{
+                                                         { "ForSalvage", css::uno::Any(true) } });
+                            }
+
+                            SfxDocPasswordVerifier aVerifier( xStorage );
+                            aEncryptionData = ::comphelper::DocPasswordHelper::requestAndVerifyDocPassword(
+                                aVerifier, aEncryptionData, aPassword, xInteractionHandler, pFile->GetOrigURL(), comphelper::DocPasswordRequestType::Standard );
+
+                            pSet->ClearItem( SID_PASSWORD );
+                            pSet->ClearItem( SID_ENCRYPTIONDATA );
+
+                            if ( aEncryptionData.hasElements() )
+                            {
+                                pSet->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::makeAny( aEncryptionData ) ) );
+
+                                try
+                                {
+                                    // update the version list of the medium using the new password
+                                    pFile->GetVersionList();
+                                }
+                                catch( uno::Exception& )
+                                {
+                                    // TODO/LATER: set the error code
+                                }
+
+                                nRet = ERRCODE_NONE;
+                            }
+                            else
+                                nRet = ERRCODE_IO_ABORT;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                OSL_FAIL( "A storage must implement XPropertySet interface!" );
+                nRet = ERRCODE_SFX_CANTGETPASSWD;
+            }
+        }
+    }
+
+    return nRet;
+}
+
+
+ErrCode SfxApplication::LoadTemplate( SfxObjectShellLock& xDoc, const OUString &rFileName, std::unique_ptr<SfxItemSet> pSet )
+{
+    std::shared_ptr<const SfxFilter> pFilter;
+    SfxMedium aMedium( rFileName,  ( StreamMode::READ | StreamMode::SHARE_DENYNONE ) );
+
+    if ( !aMedium.GetStorage( false ).is() )
+        aMedium.GetInStream();
+
+    if ( aMedium.GetError() )
+    {
+        return aMedium.GetErrorCode();
+    }
+
+    aMedium.UseInteractionHandler( true );
+    ErrCode nErr = GetFilterMatcher().GuessFilter( aMedium, pFilter, SfxFilterFlags::TEMPLATE, SfxFilterFlags::NONE );
+    if ( ERRCODE_NONE != nErr)
+    {
+        return ERRCODE_SFX_NOTATEMPLATE;
+    }
+
+    if( !pFilter || !pFilter->IsAllowedAsTemplate() )
+    {
+        return ERRCODE_SFX_NOTATEMPLATE;
+    }
+
+    if ( pFilter->GetFilterFlags() & SfxFilterFlags::STARONEFILTER )
+    {
+        DBG_ASSERT( !xDoc.Is(), "Sorry, not implemented!" );
+        SfxStringItem aName( SID_FILE_NAME, rFileName );
+        SfxStringItem aReferer( SID_REFERER, "private:user" );
+        SfxStringItem aFlags( SID_OPTIONS, "T" );
+        SfxBoolItem aHidden( SID_HIDDEN, true );
+        const SfxPoolItem *pRet = GetDispatcher_Impl()->ExecuteList(
+            SID_OPENDOC, SfxCallMode::SYNCHRON,
+            { &aName, &aHidden, &aReferer, &aFlags } );
+        const SfxObjectItem *pObj = dynamic_cast<const SfxObjectItem*>( pRet  );
+        if ( pObj )
+            xDoc = dynamic_cast<SfxObjectShell*>( pObj->GetShell()  );
+        else
+        {
+            const SfxViewFrameItem *pView = dynamic_cast<const SfxViewFrameItem*>( pRet  );
+            if ( pView )
+            {
+                SfxViewFrame *pFrame = pView->GetFrame();
+                if ( pFrame )
+                    xDoc = pFrame->GetObjectShell();
+            }
+        }
+
+        if ( !xDoc.Is() )
+            return ERRCODE_SFX_DOLOADFAILED;
+    }
+    else
+    {
+        if ( !xDoc.Is() )
+            xDoc = SfxObjectShell::CreateObject( pFilter->GetServiceName() );
+
+        //pMedium takes ownership of pSet
+        SfxMedium *pMedium = new SfxMedium( rFileName, StreamMode::STD_READ, pFilter, std::move(pSet) );
+        if(!xDoc->DoLoad(pMedium))
+        {
+            ErrCode nErrCode = xDoc->GetErrorCode();
+            xDoc->DoClose();
+            xDoc.Clear();
+            return nErrCode;
+        }
+    }
+
+    try
+    {
+        // TODO: introduce error handling
+
+        uno::Reference< embed::XStorage > xTempStorage = ::comphelper::OStorageHelper::GetTemporaryStorage();
+        if( !xTempStorage.is() )
+            throw uno::RuntimeException();
+
+        xDoc->GetStorage()->copyToStorage( xTempStorage );
+
+        if ( !xDoc->DoSaveCompleted( new SfxMedium( xTempStorage, OUString() ) ) )
+            throw uno::RuntimeException();
+    }
+    catch( uno::Exception& )
+    {
+        xDoc->DoClose();
+        xDoc.Clear();
+
+        // TODO: transfer correct error outside
+        return ERRCODE_SFX_GENERAL;
+    }
+
+    SetTemplate_Impl( rFileName, OUString(), xDoc );
+
+    xDoc->SetNoName();
+    xDoc->InvalidateName();
+    xDoc->SetModified(false);
+    xDoc->ResetError();
+
+    css::uno::Reference< css::frame::XModel >  xModel = xDoc->GetModel();
+    if ( xModel.is() )
+    {
+        std::unique_ptr<SfxItemSet> pNew = xDoc->GetMedium()->GetItemSet()->Clone();
+        pNew->ClearItem( SID_PROGRESS_STATUSBAR_CONTROL );
+        pNew->ClearItem( SID_FILTER_NAME );
+        css::uno::Sequence< css::beans::PropertyValue > aArgs;
+        TransformItems( SID_OPENDOC, *pNew, aArgs );
+        sal_Int32 nLength = aArgs.getLength();
+        aArgs.realloc( nLength + 1 );
+        aArgs[nLength].Name = "Title";
+        aArgs[nLength].Value <<= xDoc->GetTitle( SFX_TITLE_DETECT );
+        xModel->attachResource( OUString(), aArgs );
+    }
+
+    return xDoc->GetErrorCode();
+}
+
+
+void SfxApplication::NewDocDirectExec_Impl( SfxRequest& rReq )
+{
+    const SfxStringItem* pFactoryItem = rReq.GetArg<SfxStringItem>(SID_NEWDOCDIRECT);
+    OUString aFactName;
+    if ( pFactoryItem )
+        aFactName = pFactoryItem->GetValue();
+    else
+        aFactName = SvtModuleOptions().GetDefaultModuleName();
+
+    SfxRequest aReq( SID_OPENDOC, SfxCallMode::SYNCHRON, GetPool() );
+    aReq.AppendItem( SfxStringItem( SID_FILE_NAME, "private:factory/" + aFactName ) );
+    aReq.AppendItem( SfxFrameItem( SID_DOCFRAME, GetFrame() ) );
+    aReq.AppendItem( SfxStringItem( SID_TARGETNAME, "_default" ) );
+
+    // TODO/LATER: Should the other arguments be transferred as well?
+    const SfxStringItem* pDefaultPathItem = rReq.GetArg<SfxStringItem>(SID_DEFAULTFILEPATH);
+    if ( pDefaultPathItem )
+        aReq.AppendItem( *pDefaultPathItem );
+    const SfxStringItem* pDefaultNameItem = rReq.GetArg<SfxStringItem>(SID_DEFAULTFILENAME);
+    if ( pDefaultNameItem )
+        aReq.AppendItem( *pDefaultNameItem );
+
+    SfxGetpApp()->ExecuteSlot( aReq );
+    const SfxViewFrameItem* pItem = dynamic_cast<const SfxViewFrameItem*>( aReq.GetReturnValue()  );
+    if ( pItem )
+        rReq.SetReturnValue( SfxFrameItem( 0, pItem->GetFrame() ) );
+}
+
+
+void SfxApplication::NewDocExec_Impl( SfxRequest& rReq )
+{
+    // No Parameter from BASIC only Factory given?
+    const SfxStringItem* pTemplNameItem = rReq.GetArg<SfxStringItem>(SID_TEMPLATE_NAME);
+    const SfxStringItem* pTemplFileNameItem = rReq.GetArg<SfxStringItem>(SID_FILE_NAME);
+    const SfxStringItem* pTemplRegionNameItem = rReq.GetArg<SfxStringItem>(SID_TEMPLATE_REGIONNAME);
+
+    SfxObjectShellLock xDoc;
+
+    OUString  aTemplateRegion, aTemplateName, aTemplateFileName;
+    bool    bDirect = false; // through FileName instead of Region/Template
+    SfxErrorContext aEc(ERRCTX_SFX_NEWDOC);
+    if ( !pTemplNameItem && !pTemplFileNameItem )
+    {
+        bool bNewWin = false;
+        vcl::Window* pTopWin = GetTopWindow();
+
+        SfxObjectShell* pCurrentShell = SfxObjectShell::Current();
+        Reference<XModel> xModel;
+        if(pCurrentShell)
+            xModel = pCurrentShell->GetModel();
+
+        SfxTemplateManagerDlg aTemplDlg(rReq.GetFrameWeld());
+
+        if (xModel.is())
+            aTemplDlg.setDocumentModel(xModel);
+
+        int nRet = aTemplDlg.run();
+        if ( nRet == RET_OK )
+        {
+            rReq.Done();
+            if ( pTopWin != GetTopWindow() )
+            {
+                // the dialogue opens a document -> a new TopWindow appears
+                pTopWin = GetTopWindow();
+                bNewWin = true;
+            }
+        }
+
+        if ( bNewWin && pTopWin )
+            // after the destruction of the dialogue its parent comes to top,
+            // but we want that the new document is on top
+            pTopWin->ToTop();
+
+        return;
+    }
+    else
+    {
+        // Template-Name
+        if ( pTemplNameItem )
+            aTemplateName = pTemplNameItem->GetValue();
+
+        // Template-Region
+        if ( pTemplRegionNameItem )
+            aTemplateRegion = pTemplRegionNameItem->GetValue();
+
+        // Template-File-Name
+        if ( pTemplFileNameItem )
+        {
+            aTemplateFileName = pTemplFileNameItem->GetValue();
+            bDirect = true;
+        }
+    }
+
+    ErrCode lErr = ERRCODE_NONE;
+    SfxItemSet* pSet = new SfxAllItemSet( GetPool() );
+    pSet->Put( SfxBoolItem( SID_TEMPLATE, true ) );
+    if ( !bDirect )
+    {
+        SfxDocumentTemplates aTmpFac;
+        if( aTemplateFileName.isEmpty() )
+            aTmpFac.GetFull( aTemplateRegion, aTemplateName, aTemplateFileName );
+
+        if( aTemplateFileName.isEmpty() )
+            lErr = ERRCODE_SFX_TEMPLATENOTFOUND;
+    }
+
+    INetURLObject aObj( aTemplateFileName );
+    SfxErrorContext aEC( ERRCTX_SFX_LOADTEMPLATE, aObj.PathToFileName() );
+
+    if ( lErr != ERRCODE_NONE )
+    {
+        ErrCode lFatalErr = lErr.IgnoreWarning();
+        if ( lFatalErr )
+            ErrorHandler::HandleError(lErr);
+    }
+    else
+    {
+        SfxCallMode eMode = SfxCallMode::SYNCHRON;
+
+        const SfxPoolItem *pRet=nullptr;
+        SfxStringItem aReferer( SID_REFERER, "private:user" );
+        SfxStringItem aTarget( SID_TARGETNAME, "_default" );
+        if ( !aTemplateFileName.isEmpty() )
+        {
+            DBG_ASSERT( aObj.GetProtocol() != INetProtocol::NotValid, "Illegal URL!" );
+
+            SfxStringItem aName( SID_FILE_NAME, aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+            SfxStringItem aTemplName( SID_TEMPLATE_NAME, aTemplateName );
+            SfxStringItem aTemplRegionName( SID_TEMPLATE_REGIONNAME, aTemplateRegion );
+            pRet = GetDispatcher_Impl()->ExecuteList(SID_OPENDOC, eMode,
+                {&aName, &aTarget, &aReferer, &aTemplName, &aTemplRegionName});
+        }
+        else
+        {
+            SfxStringItem aName( SID_FILE_NAME, "private:factory" );
+            pRet = GetDispatcher_Impl()->ExecuteList(SID_OPENDOC, eMode,
+                    { &aName, &aTarget, &aReferer } );
+        }
+
+        if ( pRet )
+            rReq.SetReturnValue( *pRet );
+    }
+}
+
+
+namespace {
+
+/**
+ * Check if a given filter type should open the hyperlinked document
+ * natively.
+ *
+ * @param rFilter filter object
+ */
+bool lcl_isFilterNativelySupported(const SfxFilter& rFilter)
+{
+    if (rFilter.IsOwnFormat())
+        return true;
+
+    const OUString& aName = rFilter.GetFilterName();
+    // We can handle all Excel variants natively.
+    return aName.startsWith("MS Excel");
+}
+
+}
+
+void SfxApplication::OpenDocExec_Impl( SfxRequest& rReq )
+{
+    OUString aDocService;
+    const SfxStringItem* pDocSrvItem = rReq.GetArg<SfxStringItem>(SID_DOC_SERVICE);
+    if (pDocSrvItem)
+        aDocService = pDocSrvItem->GetValue();
+
+    sal_uInt16 nSID = rReq.GetSlot();
+    const SfxStringItem* pFileNameItem = rReq.GetArg<SfxStringItem>(SID_FILE_NAME);
+    if ( pFileNameItem )
+    {
+        OUString aCommand( pFileNameItem->GetValue() );
+        const SfxSlot* pSlot = GetInterface()->GetSlot( aCommand );
+        if ( pSlot )
+        {
+            pFileNameItem = nullptr;
+        }
+        else
+        {
+            if ( aCommand.startsWith("slot:") )
+            {
+                sal_uInt16 nSlotId = static_cast<sal_uInt16>(aCommand.copy(5).toInt32());
+                if ( nSlotId == SID_OPENDOC )
+                    pFileNameItem = nullptr;
+            }
+        }
+    }
+
+    if ( !pFileNameItem )
+    {
+        // get FileName from dialog
+        std::vector<OUString> aURLList;
+        OUString aFilter;
+        std::unique_ptr<SfxItemSet> pSet;
+        OUString aPath;
+        const SfxStringItem* pFolderNameItem = rReq.GetArg<SfxStringItem>(SID_PATH);
+        if ( pFolderNameItem )
+            aPath = pFolderNameItem->GetValue();
+        else if ( nSID == SID_OPENTEMPLATE )
+        {
+            aPath = SvtPathOptions().GetTemplatePath();
+            if (!aPath.isEmpty())                             // if not empty then get last token
+                aPath = aPath.copy(aPath.lastIndexOf(';')+1); // lastIndexOf+copy works whether separator (';') is there or not
+        }
+
+        sal_Int16 nDialog = SFX2_IMPL_DIALOG_CONFIG;
+        const SfxBoolItem* pSystemDialogItem = rReq.GetArg<SfxBoolItem>(SID_FILE_DIALOG);
+        if ( pSystemDialogItem )
+            nDialog = pSystemDialogItem->GetValue() ? SFX2_IMPL_DIALOG_SYSTEM : SFX2_IMPL_DIALOG_OOO;
+
+        const SfxBoolItem* pRemoteDialogItem = rReq.GetArg<SfxBoolItem>(SID_REMOTE_DIALOG);
+        if ( pRemoteDialogItem && pRemoteDialogItem->GetValue())
+            nDialog = SFX2_IMPL_DIALOG_REMOTE;
+
+        sal_Int16 nDialogType = ui::dialogs::TemplateDescription::FILEOPEN_READONLY_VERSION;
+        FileDialogFlags eDialogFlags = FileDialogFlags::MultiSelection;
+        const SfxBoolItem* pSignPDFItem = rReq.GetArg<SfxBoolItem>(SID_SIGNPDF);
+        if (pSignPDFItem && pSignPDFItem->GetValue())
+        {
+            eDialogFlags |= FileDialogFlags::SignPDF;
+            nDialogType = ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE;
+        }
+
+        OUString sStandardDir;
+
+        const SfxStringItem* pStandardDirItem = rReq.GetArg<SfxStringItem>(SID_STANDARD_DIR);
+        if ( pStandardDirItem )
+            sStandardDir = pStandardDirItem->GetValue();
+
+        css::uno::Sequence< OUString >  aBlackList;
+
+        const SfxStringListItem* pBlackListItem = rReq.GetArg<SfxStringListItem>(SID_BLACK_LIST);
+        if ( pBlackListItem )
+            pBlackListItem->GetStringList( aBlackList );
+
+        vcl::Window* pTopWindow = GetTopWindow();
+        ErrCode nErr = sfx2::FileOpenDialog_Impl(pTopWindow ? pTopWindow->GetFrameWeld() : nullptr,
+                nDialogType,
+                eDialogFlags, aURLList,
+                aFilter, pSet, &aPath, nDialog, sStandardDir, aBlackList);
+
+        if ( nErr == ERRCODE_ABORT )
+        {
+            aURLList.clear();
+            return;
+        }
+
+        rReq.SetArgs( *static_cast<SfxAllItemSet*>(pSet.get()) );
+        if ( !aFilter.isEmpty() )
+            rReq.AppendItem( SfxStringItem( SID_FILTER_NAME, aFilter ) );
+        rReq.AppendItem( SfxStringItem( SID_TARGETNAME, "_default" ) );
+        rReq.AppendItem( SfxStringItem( SID_REFERER, "private:user" ) );
+        pSet.reset();
+
+        if(!aURLList.empty())
+        {
+            if ( nSID == SID_OPENTEMPLATE )
+                rReq.AppendItem( SfxBoolItem( SID_TEMPLATE, false ) );
+
+            // This helper wraps an existing (or may new created InteractionHandler)
+            // intercept all incoming interactions and provide useful information
+            // later if the following transaction was finished.
+
+            sfx2::PreventDuplicateInteraction* pHandler = new sfx2::PreventDuplicateInteraction(comphelper::getProcessComponentContext());
+            uno::Reference<task::XInteractionHandler> xHandler(static_cast< css::task::XInteractionHandler* >(pHandler), css::uno::UNO_QUERY);
+            uno::Reference<task::XInteractionHandler> xWrappedHandler;
+
+            // wrap existing handler or create new UUI handler
+            const SfxUnoAnyItem* pInteractionItem = rReq.GetArg<SfxUnoAnyItem>(SID_INTERACTIONHANDLER);
+            if (pInteractionItem)
+            {
+                pInteractionItem->GetValue() >>= xWrappedHandler;
+                rReq.RemoveItem( SID_INTERACTIONHANDLER );
+            }
+            if (xWrappedHandler.is())
+                pHandler->setHandler(xWrappedHandler);
+            else
+                pHandler->useDefaultUUIHandler();
+            rReq.AppendItem( SfxUnoAnyItem(SID_INTERACTIONHANDLER,css::uno::makeAny(xHandler)) );
+
+            // define rules for this handler
+            css::uno::Type aInteraction = ::cppu::UnoType<css::task::ErrorCodeRequest>::get();
+            ::sfx2::PreventDuplicateInteraction::InteractionInfo aRule(aInteraction);
+            pHandler->addInteractionRule(aRule);
+
+            if (!aDocService.isEmpty())
+            {
+                rReq.RemoveItem(SID_DOC_SERVICE);
+                rReq.AppendItem(SfxStringItem(SID_DOC_SERVICE, aDocService));
+            }
+
+            for (auto const& url : aURLList)
+            {
+                rReq.RemoveItem( SID_FILE_NAME );
+                rReq.AppendItem( SfxStringItem( SID_FILE_NAME, url ) );
+
+                // Run synchronous, so that not the next document is loaded
+                // when rescheduling
+                // TODO/LATER: use URLList argument and always remove one document after another, each step in asynchronous execution, until finished
+                // but only if reschedule is a problem
+                GetDispatcher_Impl()->Execute( SID_OPENDOC, SfxCallMode::SYNCHRON, *rReq.GetArgs() );
+
+                // check for special interaction "NO MORE DOCUMENTS ALLOWED" and
+                // break loop then. Otherwise we risk showing the same interaction more than once.
+                if ( pHandler->getInteractionInfo(aInteraction, &aRule) )
+                {
+                    if (aRule.m_nCallCount > 0)
+                    {
+                        if (aRule.m_xRequest.is())
+                        {
+                            css::task::ErrorCodeRequest aRequest;
+                            if (aRule.m_xRequest->getRequest() >>= aRequest)
+                            {
+                                if (aRequest.ErrCode == sal_Int32(sal_uInt32(ERRCODE_SFX_NOMOREDOCUMENTSALLOWED)))
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            aURLList.clear();
+            return;
+        }
+        aURLList.clear();
+    }
+
+    bool bHyperlinkUsed = false;
+
+    if ( SID_OPENURL == nSID )
+    {
+        // SID_OPENURL does the same as SID_OPENDOC!
+        rReq.SetSlot( SID_OPENDOC );
+    }
+    else if ( nSID == SID_OPENTEMPLATE )
+    {
+        rReq.AppendItem( SfxBoolItem( SID_TEMPLATE, false ) );
+    }
+    // pass URL to OS by using ShellExecuter or open it internal
+    // if it seems to be an own format.
+    /* Attention!
+            There exist two possibilities to open hyperlinks:
+            a) using SID_OPENHYPERLINK (new)
+            b) using SID_BROWSE        (old)
+     */
+    else if ( nSID == SID_OPENHYPERLINK )
+    {
+        rReq.SetSlot( SID_OPENDOC );
+        bHyperlinkUsed = true;
+    }
+
+    // no else here! It's optional ...
+    if (!bHyperlinkUsed)
+    {
+        const SfxBoolItem* pHyperLinkUsedItem = rReq.GetArg<SfxBoolItem>(SID_BROWSE);
+        if ( pHyperLinkUsedItem )
+            bHyperlinkUsed = pHyperLinkUsedItem->GetValue();
+        // no "official" item, so remove it from ItemSet before using UNO-API
+        rReq.RemoveItem( SID_BROWSE );
+    }
+
+    const SfxStringItem* pFileName = rReq.GetArg<SfxStringItem>(SID_FILE_NAME);
+    OUString aFileName = pFileName->GetValue();
+
+    OUString aReferer;
+    const SfxStringItem* pRefererItem = rReq.GetArg<SfxStringItem>(SID_REFERER);
+    if ( pRefererItem )
+        aReferer = pRefererItem->GetValue();
+
+    const SfxStringItem* pFileFlagsItem = rReq.GetArg<SfxStringItem>(SID_OPTIONS);
+    if ( pFileFlagsItem )
+    {
+        const OUString aFileFlags = pFileFlagsItem->GetValue().toAsciiUpperCase();
+        if ( aFileFlags.indexOf('T') >= 0 )
+        {
+            rReq.RemoveItem( SID_TEMPLATE );
+            rReq.AppendItem( SfxBoolItem( SID_TEMPLATE, true ) );
+        }
+
+        if ( aFileFlags.indexOf('H') >= 0 )
+        {
+            rReq.RemoveItem( SID_HIDDEN );
+            rReq.AppendItem( SfxBoolItem( SID_HIDDEN, true ) );
+        }
+
+        if ( aFileFlags.indexOf('R') >= 0 )
+        {
+            rReq.RemoveItem( SID_DOC_READONLY );
+            rReq.AppendItem( SfxBoolItem( SID_DOC_READONLY, true ) );
+        }
+
+        if ( aFileFlags.indexOf('B') >= 0 )
+        {
+            rReq.RemoveItem( SID_PREVIEW );
+            rReq.AppendItem( SfxBoolItem( SID_PREVIEW, true ) );
+        }
+
+        rReq.RemoveItem( SID_OPTIONS );
+    }
+
+    // Mark without URL cannot be handled by hyperlink code
+    if ( bHyperlinkUsed && !aFileName.isEmpty() && aFileName[0] != '#' )
+    {
+        uno::Reference<document::XTypeDetection> xTypeDetection(
+            comphelper::getProcessServiceFactory()->createInstance("com.sun.star.document.TypeDetection"), UNO_QUERY);
+
+        if ( xTypeDetection.is() )
+        {
+            URL             aURL;
+
+            aURL.Complete = aFileName;
+            Reference< util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+            xTrans->parseStrict( aURL );
+
+            INetProtocol aINetProtocol = INetURLObject( aURL.Complete ).GetProtocol();
+            SvtExtendedSecurityOptions aExtendedSecurityOptions;
+            SvtExtendedSecurityOptions::OpenHyperlinkMode eMode = aExtendedSecurityOptions.GetOpenHyperlinkMode();
+
+            if ( eMode == SvtExtendedSecurityOptions::OPEN_NEVER && aINetProtocol != INetProtocol::VndSunStarHelp )
+            {
+                SolarMutexGuard aGuard;
+                vcl::Window *pWindow = SfxGetpApp()->GetTopWindow();
+
+                std::unique_ptr<weld::MessageDialog> xSecurityWarningBox(Application::CreateMessageDialog(pWindow ? pWindow->GetFrameWeld() : nullptr,
+                                                                         VclMessageType::Warning, VclButtonsType::Ok, SfxResId(STR_SECURITY_WARNING_NO_HYPERLINKS)));
+                xSecurityWarningBox->set_title(SfxResId(RID_SECURITY_WARNING_TITLE));
+                xSecurityWarningBox->run();
+                return;
+            }
+
+            const OUString aTypeName { xTypeDetection->queryTypeByURL( aURL.Main ) };
+            SfxFilterMatcher& rMatcher = SfxGetpApp()->GetFilterMatcher();
+            std::shared_ptr<const SfxFilter> pFilter = rMatcher.GetFilter4EA( aTypeName );
+            if (!pFilter || !lcl_isFilterNativelySupported(*pFilter))
+            {
+                // hyperlink does not link to own type => special handling (http, ftp) browser and (other external protocols) OS
+                if ( aINetProtocol == INetProtocol::Mailto )
+                {
+                    // don't dispatch mailto hyperlink to desktop dispatcher
+                    rReq.RemoveItem( SID_TARGETNAME );
+                    rReq.AppendItem( SfxStringItem( SID_TARGETNAME, "_self" ) );
+                }
+                else if ( aINetProtocol == INetProtocol::Ftp ||
+                     aINetProtocol == INetProtocol::Http ||
+                     aINetProtocol == INetProtocol::Https )
+                {
+                    sfx2::openUriExternally(aURL.Complete, true);
+                    return;
+                }
+                else
+                {
+                    // check for "internal" protocols that should not be forwarded to the system
+                    std::vector < OUString > aProtocols(2);
+
+                    // add special protocols that always should be treated as internal
+                    aProtocols[0] = "private:*";
+                    aProtocols[1] = "vnd.sun.star.*";
+
+                    // get registered protocol handlers from configuration
+                    Reference < XNameAccess > xAccess(officecfg::Office::ProtocolHandler::HandlerSet::get());
+                    const Sequence < OUString > aNames = xAccess->getElementNames();
+                    for ( const auto& rName : aNames )
+                    {
+                        Reference < XPropertySet > xSet;
+                        Any aRet = xAccess->getByName( rName );
+                        aRet >>= xSet;
+                        if ( xSet.is() )
+                        {
+                            // copy protocols
+                            aRet = xSet->getPropertyValue("Protocols");
+                            Sequence < OUString > aTmp;
+                            aRet >>= aTmp;
+
+                            aProtocols.insert(aProtocols.end(),aTmp.begin(),aTmp.end());
+                        }
+                    }
+
+                    bool bFound = false;
+                    for (const OUString & rProtocol : aProtocols)
+                    {
+                        WildCard aPattern(rProtocol);
+                        if ( aPattern.Matches( aURL.Complete ) )
+                        {
+                            bFound = true;
+                            break;
+                        }
+                    }
+
+                    if ( !bFound )
+                    {
+                        bool bLoadInternal = false;
+                        try
+                        {
+                            sfx2::openUriExternally(
+                                aURL.Complete, pFilter == nullptr);
+                        }
+                        catch ( css::system::SystemShellExecuteException& )
+                        {
+                            rReq.RemoveItem( SID_TARGETNAME );
+                            rReq.AppendItem( SfxStringItem( SID_TARGETNAME, "_default" ) );
+                            bLoadInternal = true;
+                        }
+                        if ( !bLoadInternal )
+                            return;
+                    }
+                }
+            }
+            else
+            {
+                // hyperlink document must be loaded into a new frame
+                rReq.RemoveItem( SID_TARGETNAME );
+                rReq.AppendItem( SfxStringItem( SID_TARGETNAME, "_default" ) );
+            }
+        }
+    }
+
+    if (!SvtSecurityOptions().isSecureMacroUri(aFileName, aReferer))
+    {
+        SfxErrorContext aCtx( ERRCTX_SFX_OPENDOC, aFileName );
+        ErrorHandler::HandleError( ERRCODE_IO_ACCESSDENIED );
+        return;
+    }
+
+    SfxFrame* pTargetFrame = nullptr;
+    Reference< XFrame > xTargetFrame;
+
+    const SfxFrameItem* pFrameItem = rReq.GetArg<SfxFrameItem>(SID_DOCFRAME);
+    if ( pFrameItem )
+        pTargetFrame = pFrameItem->GetFrame();
+
+    if ( !pTargetFrame )
+    {
+        const SfxUnoFrameItem* pUnoFrameItem = rReq.GetArg<SfxUnoFrameItem>(SID_FILLFRAME);
+        if ( pUnoFrameItem )
+            xTargetFrame = pUnoFrameItem->GetFrame();
+    }
+
+    if ( !pTargetFrame && !xTargetFrame.is() && SfxViewFrame::Current() )
+        pTargetFrame = &SfxViewFrame::Current()->GetFrame();
+
+    // check if caller has set a callback
+    std::unique_ptr<SfxLinkItem> pLinkItem;
+
+    // remove from Itemset, because it confuses the parameter transformation
+    if (auto pParamLinkItem = rReq.GetArg<SfxLinkItem>(SID_DONELINK))
+        pLinkItem.reset(pParamLinkItem->Clone());
+
+    rReq.RemoveItem( SID_DONELINK );
+
+    // check if the view must be hidden
+    bool bHidden = false;
+    const SfxBoolItem* pHidItem = rReq.GetArg<SfxBoolItem>(SID_HIDDEN);
+    if ( pHidItem )
+        bHidden = pHidItem->GetValue();
+
+    // This request is a UI call. We have to set the right values inside the MediaDescriptor
+    // for: InteractionHandler, StatusIndicator, MacroExecutionMode and DocTemplate.
+    // But we have to look for already existing values or for real hidden requests.
+    const SfxBoolItem* pPreviewItem = rReq.GetArg<SfxBoolItem>(SID_PREVIEW);
+    if (!bHidden && ( !pPreviewItem || !pPreviewItem->GetValue() ) )
+    {
+        const SfxUnoAnyItem* pInteractionItem = rReq.GetArg<SfxUnoAnyItem>(SID_INTERACTIONHANDLER);
+        const SfxUInt16Item* pMacroExecItem = rReq.GetArg<SfxUInt16Item>(SID_MACROEXECMODE);
+        const SfxUInt16Item* pDocTemplateItem = rReq.GetArg<SfxUInt16Item>(SID_UPDATEDOCMODE);
+
+        if (!pInteractionItem)
+        {
+            Reference < task::XInteractionHandler2 > xHdl = task::InteractionHandler::createWithParent( ::comphelper::getProcessComponentContext(), nullptr );
+            rReq.AppendItem( SfxUnoAnyItem(SID_INTERACTIONHANDLER,css::uno::makeAny(xHdl)) );
+        }
+        if (!pMacroExecItem)
+            rReq.AppendItem( SfxUInt16Item(SID_MACROEXECMODE,css::document::MacroExecMode::USE_CONFIG) );
+        if (!pDocTemplateItem)
+            rReq.AppendItem( SfxUInt16Item(SID_UPDATEDOCMODE,css::document::UpdateDocMode::ACCORDING_TO_CONFIG) );
+    }
+
+    // extract target name
+    OUString aTarget;
+    const SfxStringItem* pTargetItem = rReq.GetArg<SfxStringItem>(SID_TARGETNAME);
+    if ( pTargetItem )
+        aTarget = pTargetItem->GetValue();
+    else
+    {
+        const SfxBoolItem* pNewViewItem = rReq.GetArg<SfxBoolItem>(SID_OPEN_NEW_VIEW);
+        if ( pNewViewItem && pNewViewItem->GetValue() )
+            aTarget = "_blank" ;
+    }
+
+    if ( bHidden )
+    {
+        aTarget = "_blank";
+        DBG_ASSERT( rReq.IsSynchronCall() || pLinkItem, "Hidden load process must be done synchronously!" );
+    }
+
+    Reference < XController > xController;
+    // if a frame is given, it must be used for the starting point of the targeting mechanism
+    // this code is also used if asynchronous loading is possible, because loadComponent always is synchron
+    if ( !xTargetFrame.is() )
+    {
+        if ( pTargetFrame )
+        {
+            xTargetFrame = pTargetFrame->GetFrameInterface();
+        }
+        else
+        {
+            xTargetFrame = Desktop::create(::comphelper::getProcessComponentContext());
+        }
+    }
+
+    // make URL ready
+    const SfxStringItem* pURLItem = rReq.GetArg<SfxStringItem>(SID_FILE_NAME);
+    aFileName = pURLItem->GetValue();
+    if( aFileName.startsWith("#") ) // Mark without URL
+    {
+        SfxViewFrame *pView = pTargetFrame ? pTargetFrame->GetCurrentViewFrame() : nullptr;
+        if ( !pView )
+            pView = SfxViewFrame::Current();
+        pView->GetViewShell()->JumpToMark( aFileName.copy(1) );
+        rReq.SetReturnValue( SfxViewFrameItem( pView ) );
+        return;
+    }
+
+    // convert items to properties for framework API calls
+    Sequence < PropertyValue > aArgs;
+    TransformItems( SID_OPENDOC, *rReq.GetArgs(), aArgs );
+    // Any Referer (that was relevant in the above call to
+    // SvtSecurityOptions::isSecureMacroUri) is no longer relevant, assuming
+    // this "open" request is initiated directly by the user:
+    auto pArg = std::find_if(aArgs.begin(), aArgs.end(),
+        [](const PropertyValue& rArg) { return rArg.Name == "Referer"; });
+    if (pArg != aArgs.end())
+    {
+        auto nIndex = static_cast<sal_Int32>(std::distance(aArgs.begin(), pArg));
+        comphelper::removeElementAt(aArgs, nIndex);
+    }
+
+    // TODO/LATER: either remove LinkItem or create an asynchronous process for it
+    if( bHidden || pLinkItem || rReq.IsSynchronCall() )
+    {
+        // if loading must be done synchron, we must wait for completion to get a return value
+        // find frame by myself; I must know the exact frame to get the controller for the return value from it
+        Reference < XComponent > xComp;
+
+        try
+        {
+            xComp = ::comphelper::SynchronousDispatch::dispatch( xTargetFrame, aFileName, aTarget, aArgs );
+        }
+        catch(const RuntimeException&)
+        {
+            throw;
+        }
+        catch(const css::uno::Exception&)
+        {
+        }
+
+        Reference < XModel > xModel( xComp, UNO_QUERY );
+        if ( xModel.is() )
+            xController = xModel->getCurrentController();
+        else
+            xController.set( xComp, UNO_QUERY );
+
+    }
+    else
+    {
+        URL aURL;
+        aURL.Complete = aFileName;
+        Reference< util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+        xTrans->parseStrict( aURL );
+
+        Reference < XDispatchProvider > xProv( xTargetFrame, UNO_QUERY );
+        Reference < XDispatch > xDisp = xProv.is() ? xProv->queryDispatch( aURL, aTarget, FrameSearchFlag::ALL ) : Reference < XDispatch >();
+        if ( xDisp.is() )
+            xDisp->dispatch( aURL, aArgs );
+    }
+
+    if ( xController.is() )
+    {
+        // try to find the SfxFrame for the controller
+        SfxFrame* pCntrFrame = nullptr;
+        for ( SfxViewShell* pShell = SfxViewShell::GetFirst( false ); pShell; pShell = SfxViewShell::GetNext( *pShell, false ) )
+        {
+            if ( pShell->GetController() == xController )
+            {
+                pCntrFrame = &pShell->GetViewFrame()->GetFrame();
+                break;
+            }
+        }
+
+        if ( pCntrFrame )
+        {
+            SfxObjectShell* pSh = pCntrFrame->GetCurrentDocument();
+            DBG_ASSERT( pSh, "Controller without ObjectShell ?!" );
+
+            rReq.SetReturnValue( SfxViewFrameItem( pCntrFrame->GetCurrentViewFrame() ) );
+
+            if ( bHidden )
+                pSh->RestoreNoDelete();
+        }
+    }
+
+    if (pLinkItem)
+    {
+        const SfxPoolItem* pRetValue = rReq.GetReturnValue();
+        if (pRetValue)
+        {
+            pLinkItem->GetValue().Call(pRetValue);
+        }
+    }
+}
+
+void SfxApplication::OpenRemoteExec_Impl( SfxRequest& rReq )
+{
+    rReq.AppendItem( SfxBoolItem( SID_REMOTE_DIALOG, true ) );
+    GetDispatcher_Impl()->Execute( SID_OPENDOC, SfxCallMode::SYNCHRON, *rReq.GetArgs() );
+}
+
+void SfxApplication::SignPDFExec_Impl(SfxRequest& rReq)
+{
+    rReq.AppendItem(SfxBoolItem(SID_SIGNPDF, true));
+    GetDispatcher_Impl()->Execute(SID_OPENDOC, SfxCallMode::SYNCHRON, *rReq.GetArgs());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appquit.cxx b/sfx2/source/appl/appquit.cxx
new file mode 100644
index 000000000..7b17c538c
--- /dev/null
+++ b/sfx2/source/appl/appquit.cxx
@@ -0,0 +1,111 @@
+/* -*- 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 <basic/sbstar.hxx>
+#include <tools/solar.h>
+#include <tools/debug.hxx>
+
+#include <sfx2/app.hxx>
+#include <appdata.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/msgpool.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <nochaos.hxx>
+#include <sfx2/doctempl.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/objsh.hxx>
+#include <appbaslib.hxx>
+#include <childwinimpl.hxx>
+#include <ctrlfactoryimpl.hxx>
+#include <shellimpl.hxx>
+#include <basic/basicmanagerrepository.hxx>
+
+using ::basic::BasicManagerRepository;
+
+void SfxApplication::Deinitialize()
+{
+    if ( pImpl->bDowning )
+        return;
+
+#if HAVE_FEATURE_SCRIPTING
+    StarBASIC::Stop();
+
+    SaveBasicAndDialogContainer();
+#endif
+
+    pImpl->bDowning = true; // due to Timer from DecAliveCount and QueryExit
+
+    DELETEZ( pImpl->pTemplates );
+
+    // By definition there shouldn't be any open view frames when we reach
+    // this method. Therefore this call makes no sense and is the source of
+    // some stack traces, which we don't understand.
+    // For more information see:
+    pImpl->bDowning = false;
+    DBG_ASSERT( !SfxViewFrame::GetFirst(),
+                "existing SfxViewFrame after Execute" );
+    DBG_ASSERT( !SfxObjectShell::GetFirst(),
+                "existing SfxObjectShell after Execute" );
+    pImpl->pAppDispat->Pop( *this, SfxDispatcherPopFlags::POP_UNTIL );
+    pImpl->pAppDispat->Flush();
+    pImpl->bDowning = true;
+    pImpl->pAppDispat->DoDeactivate_Impl( true, nullptr );
+
+    // Release Controller and others
+    // then the remaining components should also disappear ( Beamer! )
+
+#if HAVE_FEATURE_SCRIPTING
+    BasicManagerRepository::resetApplicationBasicManager();
+    pImpl->pBasicManager->reset(nullptr);
+        // this will also delete pBasMgr
+#endif
+
+    DBG_ASSERT( pImpl->pViewFrame == nullptr, "active foreign ViewFrame" );
+
+    // free administration managers
+    DELETEZ(pImpl->pAppDispat);
+
+    // from here no SvObjects have to exists
+    DELETEZ(pImpl->pMatcher);
+
+    DELETEZ(pImpl->pSlotPool);
+    DELETEZ(pImpl->pFactArr);
+
+    DELETEZ(pImpl->pTbxCtrlFac);
+    DELETEZ(pImpl->pStbCtrlFac);
+    DELETEZ(pImpl->pViewFrames);
+    DELETEZ(pImpl->pViewShells);
+    DELETEZ(pImpl->pObjShells);
+
+    //TODO/CLEANUP
+    //ReleaseArgs could be used instead!
+    pImpl->pPool = nullptr;
+    NoChaos::ReleaseItemPool();
+
+#if HAVE_FEATURE_SCRIPTING
+    delete pImpl->m_pSbxErrorHdl;
+#endif
+    delete pImpl->m_pSoErrorHdl;
+    delete pImpl->m_pToolsErrorHdl;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appreg.cxx b/sfx2/source/appl/appreg.cxx
new file mode 100644
index 000000000..4e74737d3
--- /dev/null
+++ b/sfx2/source/appl/appreg.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 <sal/log.hxx>
+
+#include <sfx2/app.hxx>
+#include <appdata.hxx>
+#include <inettbc.hxx>
+#include <sfx2/stbitem.hxx>
+#include <sfx2/infobar.hxx>
+#include <sfx2/navigat.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <partwnd.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <recfloat.hxx>
+#include <ctrlfactoryimpl.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/viewsh.hxx>
+
+
+void SfxApplication::Registrations_Impl()
+{
+    // Interfaces
+    SfxApplication::RegisterInterface();
+    SfxModule::RegisterInterface();
+    SfxViewFrame::RegisterInterface();
+    SfxObjectShell::RegisterInterface();
+    SfxViewShell::RegisterInterface();
+
+    // ChildWindows
+    SfxRecordingFloatWrapper_Impl::RegisterChildWindow();
+    SfxNavigatorWrapper::RegisterChildWindow( false, nullptr, SfxChildWindowFlags::NEVERHIDE );
+    SfxPartChildWnd_Impl::RegisterChildWindow();
+    SfxDockingWrapper::RegisterChildWindow();
+    SfxInfoBarContainerChild::RegisterChildWindow( true, nullptr, SfxChildWindowFlags::NEVERHIDE );
+
+    // Controller
+    SfxToolBoxControl::RegisterControl(SID_REPEAT);
+    SfxURLToolBoxControl_Impl::RegisterControl(SID_OPENURL);
+}
+
+
+void SfxApplication::RegisterToolBoxControl_Impl( SfxModule *pMod, const SfxTbxCtrlFactory& rFact )
+{
+    if ( pMod )
+    {
+        pMod->RegisterToolBoxControl( rFact );
+        return;
+    }
+
+#ifdef DBG_UTIL
+    for ( size_t n=0; n<pImpl->pTbxCtrlFac->size(); n++ )
+    {
+        SfxTbxCtrlFactory *pF = &(*pImpl->pTbxCtrlFac)[n];
+        if ( pF->nTypeId == rFact.nTypeId &&
+            (pF->nSlotId == rFact.nSlotId || pF->nSlotId == 0) )
+        {
+            SAL_INFO("sfx", "TbxController registration is not clearly defined!");
+        }
+    }
+#endif
+
+    pImpl->pTbxCtrlFac->push_back( rFact );
+}
+
+
+void SfxApplication::RegisterStatusBarControl_Impl( SfxModule *pMod, const SfxStbCtrlFactory& rFact )
+{
+    if ( pMod )
+    {
+        pMod->RegisterStatusBarControl( rFact );
+        return;
+    }
+
+#ifdef DBG_UTIL
+    for ( size_t n=0; n<pImpl->pStbCtrlFac->size(); n++ )
+    {
+        SfxStbCtrlFactory *pF = &(*pImpl->pStbCtrlFac)[n];
+        if ( pF->nTypeId == rFact.nTypeId &&
+            (pF->nSlotId == rFact.nSlotId || pF->nSlotId == 0) )
+        {
+            SAL_INFO("sfx", "StbController registration is not clearly defined!");
+        }
+    }
+#endif
+
+    pImpl->pStbCtrlFac->push_back( rFact );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appserv.cxx b/sfx2/source/appl/appserv.cxx
new file mode 100644
index 000000000..6dd813fdf
--- /dev/null
+++ b/sfx2/source/appl/appserv.cxx
@@ -0,0 +1,1666 @@
+/* -*- 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 <com/sun/star/document/XEmbeddedScripts.hpp>
+#include <com/sun/star/drawing/ModuleDispatcher.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/DispatchResultEvent.hpp>
+#include <com/sun/star/frame/DispatchResultState.hpp>
+#include <com/sun/star/frame/DispatchHelper.hpp>
+#include <com/sun/star/frame/UnknownModuleException.hpp>
+#include <com/sun/star/frame/XLayoutManager.hpp>
+#include <com/sun/star/frame/XSynchronousFrameLoader.hpp>
+#include <com/sun/star/sdbc/DriverManager.hpp>
+#include <com/sun/star/system/SystemShellExecute.hpp>
+#include <com/sun/star/system/SystemShellExecuteFlags.hpp>
+#include <com/sun/star/text/ModuleDispatcher.hpp>
+#include <com/sun/star/task/OfficeRestartManager.hpp>
+#include <com/sun/star/task/XInteractionHandler.hpp>
+#include <com/sun/star/ui/dialogs/AddressBookSourcePilot.hpp>
+#include <com/sun/star/ui/UIElementType.hpp>
+#include <com/sun/star/ui/XUIElement.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/util/XCloseable.hpp>
+#include <com/sun/star/util/CloseVetoException.hpp>
+#include <org/freedesktop/PackageKit/SyncDbusSessionHelper.hpp>
+
+#include <comphelper/lok.hxx>
+#include <comphelper/namedvaluecollection.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/sequence.hxx>
+
+#include <svtools/addresstemplate.hxx>
+#include <svtools/miscopt.hxx>
+#include <svtools/restartdialog.hxx>
+#include <svl/visitem.hxx>
+
+#include <unotools/configmgr.hxx>
+#include <tools/svlibrary.h>
+#include <tools/diagnose_ex.h>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <svl/intitem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/stritem.hxx>
+#include <basic/sbstar.hxx>
+#include <basic/basrdll.hxx>
+#include <basic/sberrors.hxx>
+#include <vcl/help.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <osl/file.hxx>
+#include <vcl/EnumContext.hxx>
+
+#include <unotools/moduleoptions.hxx>
+#include <svtools/helpopt.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <rtl/bootstrap.hxx>
+
+#include <com/sun/star/frame/ModuleManager.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+
+#include <sfx2/app.hxx>
+#include <sfx2/request.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/docfac.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+#include <appdata.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/sfxdlg.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sorgitm.hxx>
+#include <sfx2/sfxhelp.hxx>
+#include <sfx2/zoomitem.hxx>
+#include <sfx2/templatedlg.hxx>
+#include <sfx2/notebookbar/SfxNotebookBar.hxx>
+#include <sfx2/sidebar/SidebarController.hxx>
+#include <sfx2/safemode.hxx>
+#include <sfx2/sfxuno.hxx>
+
+#include <comphelper/types.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <unotools/confignode.hxx>
+#include <officecfg/Setup.hxx>
+#include <memory>
+
+#include <openuriexternally.hxx>
+
+#include "getbasctlfunction.hxx"
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::script;
+using namespace ::com::sun::star::system;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::document;
+using namespace ::com::sun::star::ui;
+
+namespace
+{
+    OUString lcl_getAppName( vcl::EnumContext::Application eApp )
+    {
+        switch ( eApp )
+        {
+            case vcl::EnumContext::Application::Writer:
+                return "Writer";
+                break;
+            case vcl::EnumContext::Application::Calc:
+                return "Calc";
+                break;
+            case vcl::EnumContext::Application::Impress:
+                return "Impress";
+                break;
+            case vcl::EnumContext::Application::Draw:
+                return "Draw";
+                break;
+            case vcl::EnumContext::Application::Formula:
+                return "Formula";
+                break;
+            case vcl::EnumContext::Application::Base:
+                return "Base";
+                break;
+            default:
+                return OUString();
+                break;
+        }
+    }
+
+    // lp#527938, debian#602953, fdo#33266, i#105408
+    bool lcl_isBaseAvailable()
+    {
+        try
+        {
+            // if we get css::sdbc::DriverManager, libsdbc2 is there
+            // and the bibliography is assumed to work
+            return css::sdbc::DriverManager::create(comphelper::getProcessComponentContext()).is();
+        }
+        catch (const Exception &)
+        {
+            TOOLS_INFO_EXCEPTION("sfx.appl", "assuming Base to be missing");
+            return false;
+        }
+    }
+    void lcl_tryLoadBibliography()
+    {
+        // lp#527938, debian#602953, fdo#33266, i#105408
+        // make sure we actually can instantiate services from base first
+        if(!lcl_isBaseAvailable())
+        {
+            if (officecfg::Office::Common::PackageKit::EnableBaseInstallation::get())
+            {
+                try
+                {
+                    using namespace org::freedesktop::PackageKit;
+                    using namespace svtools;
+                    Reference< XSyncDbusSessionHelper > xSyncDbusSessionHelper(SyncDbusSessionHelper::create(comphelper::getProcessComponentContext()));
+                    Sequence< OUString > vPackages { "libreoffice-base" };
+                    xSyncDbusSessionHelper->InstallPackageNames(vPackages, OUString());
+                    // I'll be back (hopefully)!
+                    SolarMutexGuard aGuard;
+                    executeRestartDialog(comphelper::getProcessComponentContext(), nullptr, RESTART_REASON_BIBLIOGRAPHY_INSTALL);
+                }
+                catch (const Exception &)
+                {
+                    TOOLS_INFO_EXCEPTION("sfx.appl", "trying to install LibreOffice Base");
+                }
+            }
+            return;
+        }
+
+        try // fdo#48775
+        {
+            SfxStringItem aURL(SID_FILE_NAME, ".component:Bibliography/View1");
+            SfxStringItem aRef(SID_REFERER, "private:user");
+            SfxStringItem aTarget(SID_TARGETNAME, "_blank");
+            SfxViewFrame::Current()->GetDispatcher()->ExecuteList(SID_OPENDOC,
+                SfxCallMode::ASYNCHRON, { &aURL, &aRef, &aTarget });
+        }
+        catch (const Exception &)
+        {
+            TOOLS_INFO_EXCEPTION( "sfx.appl", "trying to load bibliography database");
+        }
+    }
+}
+/// Find the correct location of the document (CREDITS.fodt, etc.), and return
+/// it in rURL if found.
+static bool checkURL( const char *pName, const char *pExt, OUString &rURL )
+{
+    using namespace osl;
+    DirectoryItem aDirItem;
+
+#ifdef MACOSX
+    rURL = "$BRAND_BASE_DIR/Resources/" + OUString::createFromAscii( pName ) +
+           OUString::createFromAscii( pExt );
+#else
+    rURL = "$BRAND_BASE_DIR/" + OUString::createFromAscii( pName ) +
+           OUString::createFromAscii( pExt );
+#endif
+    rtl::Bootstrap::expandMacros( rURL );
+
+    if (!rURL.isEmpty())
+        return DirectoryItem::get( rURL, aDirItem ) == DirectoryItem::E_None;
+    else
+        return false;
+}
+
+/// Displays CREDITS or LICENSE in any of the available version
+static void showDocument( const char* pBaseName )
+{
+    try {
+        Reference < XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
+        auto args(::comphelper::InitPropertySequence({
+            {"ViewOnly",    makeAny(true)},
+            {"ReadOnly",    makeAny(true)}
+        }));
+
+        OUString aURL;
+        if ( checkURL ( pBaseName, ".fodt", aURL ) ||
+             checkURL ( pBaseName, ".html", aURL ) ||
+             checkURL ( pBaseName, "", aURL ) ) {
+            xDesktop->loadComponentFromURL( aURL, "_blank", 0, args );
+        }
+    } catch (const css::uno::Exception &) {
+    }
+}
+
+namespace
+{
+    Reference<XFrame> GetRequestFrame(const SfxRequest& rReq)
+    {
+        const SfxItemSet* pArgs = rReq.GetInternalArgs_Impl();
+        const SfxPoolItem* pItem = nullptr;
+        Reference <XFrame> xFrame;
+        if (pArgs && pArgs->GetItemState(SID_FILLFRAME, false, &pItem) == SfxItemState::SET)
+        {
+            OSL_ENSURE( dynamic_cast< const SfxUnoFrameItem *>( pItem ) !=  nullptr, "SfxApplication::OfaExec_Impl: XFrames are to be transported via SfxUnoFrameItem by now!" );
+            xFrame = static_cast< const SfxUnoFrameItem*>( pItem )->GetFrame();
+        }
+        return xFrame;
+    }
+
+    vcl::Window* getFrameWindow(const Reference<XFrame>& rFrame)
+    {
+        if (rFrame.is())
+        {
+            try
+            {
+                Reference< awt::XWindow > xContainerWindow(rFrame->getContainerWindow(), UNO_SET_THROW);
+                VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(xContainerWindow);
+                return pWindow;
+            }
+            catch (const Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION("sfx.appl");
+            }
+        }
+
+        SAL_WARN( "sfx.appl", "no parent for dialogs" );
+        return nullptr;
+    }
+
+    class LicenseDialog : public weld::GenericDialogController
+    {
+    public:
+        LicenseDialog(weld::Window* pParent)
+            : GenericDialogController(pParent, "sfx/ui/licensedialog.ui",  "LicenseDialog")
+        {
+        }
+
+        virtual short run() override
+        {
+            short nRet = GenericDialogController::run();
+            if (nRet == RET_OK)
+                showDocument("LICENSE");
+            return nRet;
+        }
+    };
+
+    class SafeModeQueryDialog : public weld::MessageDialogController
+    {
+    public:
+        SafeModeQueryDialog(weld::Window* pParent)
+            : MessageDialogController(pParent, "sfx/ui/safemodequerydialog.ui", "SafeModeQueryDialog")
+        {
+        }
+
+        virtual short run() override
+        {
+            short nRet = MessageDialogController::run();
+            if (nRet == RET_OK)
+            {
+                sfx2::SafeMode::putFlag();
+                uno::Reference< uno::XComponentContext > xContext = comphelper::getProcessComponentContext();
+                css::task::OfficeRestartManager::get(xContext)->requestRestart(
+                    css::uno::Reference< css::task::XInteractionHandler >());
+            }
+            return nRet;
+        }
+    };
+}
+
+vcl::Window* SfxRequest::GetFrameWindow() const
+{
+    return getFrameWindow(GetRequestFrame(*this));
+}
+
+weld::Window* SfxRequest::GetFrameWeld() const
+{
+    const SfxItemSet* pIntArgs = GetInternalArgs_Impl();
+    const SfxPoolItem* pItem = nullptr;
+    if (pIntArgs && pIntArgs->GetItemState(SID_DIALOG_PARENT, false, &pItem) == SfxItemState::SET)
+    {
+        assert(dynamic_cast<const SfxUnoAnyItem*>(pItem));
+        auto aAny = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        Reference<awt::XWindow> xWindow;
+        aAny >>= xWindow;
+        return Application::GetFrameWeld(xWindow);
+    }
+
+    vcl::Window* pWin = GetFrameWindow();
+    return pWin ? pWin->GetFrameWeld() : nullptr;
+}
+
+void SfxApplication::MiscExec_Impl( SfxRequest& rReq )
+{
+    bool bDone = false;
+    switch ( rReq.GetSlot() )
+    {
+        case SID_SETOPTIONS:
+        {
+            if( rReq.GetArgs() )
+                SetOptions_Impl( *rReq.GetArgs() );
+            break;
+        }
+
+        case SID_QUITAPP:
+        case SID_LOGOUT:
+        {
+            // protect against reentrant calls
+            if ( pImpl->bInQuit )
+                return;
+
+            if ( rReq.GetSlot() == SID_LOGOUT )
+            {
+                for ( SfxObjectShell *pObjSh = SfxObjectShell::GetFirst();
+                    pObjSh; pObjSh = SfxObjectShell::GetNext( *pObjSh ) )
+                {
+                    if ( !pObjSh->IsModified() )
+                        continue;
+
+                    SfxViewFrame* pFrame = SfxViewFrame::GetFirst( pObjSh );
+                    if ( !pFrame || !pFrame->GetWindow().IsReallyVisible() )
+                        continue;
+
+                    if (pObjSh->PrepareClose())
+                        pObjSh->SetModified( false );
+                    else
+                        return;
+                }
+
+                SfxStringItem aNameItem( SID_FILE_NAME, "vnd.sun.star.cmd:logout" );
+                SfxStringItem aReferer( SID_REFERER, "private/user" );
+                pImpl->pAppDispat->ExecuteList(SID_OPENDOC,
+                        SfxCallMode::SLOT, { &aNameItem, &aReferer });
+                return;
+            }
+
+            // try from nested requests again after 100ms
+            if( Application::GetDispatchLevel() > 1 )
+            {
+                /* Don't save the request for closing the application and try it later
+                   again. This is an UI bound functionality ... and the user will  try it again
+                   if the dialog is closed. But we should not close the application automatically
+                   if this dialog is closed by the user ...
+                   So we ignore this request now and wait for a new user decision.
+                */
+                SAL_INFO("sfx.appl", "QueryExit => sal_False, DispatchLevel == " << Application::GetDispatchLevel() );
+                return;
+            }
+
+            // block reentrant calls
+            pImpl->bInQuit = true;
+            Reference < XDesktop2 > xDesktop = Desktop::create ( ::comphelper::getProcessComponentContext() );
+
+            rReq.ForgetAllArgs();
+
+            // if terminate() failed, pImpl->bInQuit will now be sal_False, allowing further calls of SID_QUITAPP
+            bool bTerminated = xDesktop->terminate();
+            if (!bTerminated)
+                // if terminate() was successful, SfxApplication is now dead!
+                pImpl->bInQuit = false;
+
+            // Set return value, terminate if possible
+            rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), bTerminated ) );
+            return;
+        }
+
+        case SID_CONFIG:
+        case SID_TOOLBOXOPTIONS:
+        case SID_CONFIGSTATUSBAR:
+        case SID_CONFIGMENU:
+        case SID_CONFIGACCEL:
+        case SID_CONFIGEVENT:
+        {
+            SfxAbstractDialogFactory* pFact =
+                SfxAbstractDialogFactory::Create();
+
+            const SfxStringItem* pStringItem = rReq.GetArg<SfxStringItem>(SID_CONFIG);
+
+            SfxItemSet aSet(
+                GetPool(), svl::Items<SID_CONFIG, SID_CONFIG>{} );
+
+            if ( pStringItem )
+            {
+                aSet.Put( SfxStringItem(
+                    SID_CONFIG, pStringItem->GetValue() ) );
+            }
+
+            Reference <XFrame> xFrame(GetRequestFrame(rReq));
+            ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateCustomizeTabDialog(rReq.GetFrameWeld(),
+                &aSet, xFrame ));
+
+            const short nRet = pDlg->Execute();
+
+            if ( nRet )
+                bDone = true;
+            break;
+        }
+
+        case SID_CLOSEDOCS:
+        {
+
+            Reference < XDesktop2 > xDesktop  = Desktop::create( ::comphelper::getProcessComponentContext() );
+            Reference< XIndexAccess > xTasks = xDesktop->getFrames();
+            if ( !xTasks.is() )
+                break;
+
+            sal_Int32 n=0;
+            do
+            {
+                if ( xTasks->getCount() <= n )
+                    break;
+
+                Any aAny = xTasks->getByIndex(n);
+                Reference < XCloseable > xTask;
+                aAny >>= xTask;
+                try
+                {
+                    xTask->close(true);
+                    n++;
+                }
+                catch( CloseVetoException& )
+                {
+                }
+            }
+            while( true );
+
+            bool bOk = ( n == 0);
+            rReq.SetReturnValue( SfxBoolItem( 0, bOk ) );
+            bDone = true;
+            break;
+        }
+
+        case SID_SAVEDOCS:
+        {
+            bool bOK = true;
+            for ( SfxObjectShell *pObjSh = SfxObjectShell::GetFirst();
+                  pObjSh;
+                  pObjSh = SfxObjectShell::GetNext( *pObjSh ) )
+            {
+                SfxRequest aReq( SID_SAVEDOC, SfxCallMode::SLOT, pObjSh->GetPool() );
+                if ( pObjSh->IsModified() )
+                {
+                    pObjSh->ExecuteSlot( aReq );
+                    const SfxBoolItem *pItem = dynamic_cast<const SfxBoolItem*>( aReq.GetReturnValue()  );
+                    if ( !pItem || !pItem->GetValue() )
+                        bOK = false;
+                }
+            }
+
+            rReq.SetReturnValue( SfxBoolItem( 0, bOK ) );
+            rReq.Done();
+            break;
+        }
+
+        case SID_SEND_FEEDBACK:
+        {
+            OUString module = SfxHelp::GetCurrentModuleIdentifier();
+            OUString sURL(officecfg::Office::Common::Menus::SendFeedbackURL::get() + //officecfg/registry/data/org/openoffice/Office/Common.xcu => https://hub.libreoffice.org/send-feedback/
+                "?LOversion=" + utl::ConfigManager::getAboutBoxProductVersion() +
+                "&LOlocale=" + utl::ConfigManager::getUILocale() +
+                "&LOmodule=" + module.copy(module.lastIndexOf('.') + 1 )  );
+            sfx2::openUriExternally(sURL, false);
+            break;
+        }
+
+        case SID_Q_AND_A:
+        {
+            // Askbot has URL's normalized to languages, not locales
+            // Get language from locale: ll or lll or ll-CC or lll-CC
+
+            OUString sURL(officecfg::Office::Common::Menus::QA_URL::get() + //https://hub.libreoffice.org/forum/
+                "?LOlocale=" + utl::ConfigManager::getUILocale());
+            sfx2::openUriExternally(sURL, false);
+            break;
+        }
+        case SID_DOCUMENTATION:
+        {
+            // Open documentation page based on locales
+            OUString sURL(officecfg::Office::Common::Menus::DocumentationURL::get() + //https://hub.libreoffice.org/documentation/
+                "?LOlocale=" + utl::ConfigManager::getUILocale());
+            sfx2::openUriExternally(sURL, false);
+            break;
+        }
+        case SID_GETINVOLVED:
+        {
+            // Open get involved/join us page based on locales
+            OUString sURL(officecfg::Office::Common::Menus::GetInvolvedURL::get() + //https://hub.libreoffice.org/joinus/
+                "?LOlocale=" + utl::ConfigManager::getUILocale());
+            sfx2::openUriExternally(sURL, false);
+            break;
+        }
+        case SID_DONATION:
+        {
+            // Open donation page based on language + script (BCP47) with language as fall back.
+            OUString aLang = LanguageTag(utl::ConfigManager::getUILocale()).getLanguage();
+            OUString aBcp47 = LanguageTag(utl::ConfigManager::getUILocale()).getBcp47();
+            OUString sURL(officecfg::Office::Common::Menus::DonationURL::get() + //https://hub.libreoffice.org/donation/
+                "?BCP47=" + aBcp47 + "&LOlang=" + aLang );
+            sfx2::openUriExternally(sURL, false);
+            break;
+        }
+        case SID_WHATSNEW:
+        {
+            // Open release notes depending on version and locale
+            OUString sURL(officecfg::Office::Common::Menus::ReleaseNotesURL::get() + //https://hub.libreoffice.org/ReleaseNotes/
+                "?LOvers=" + utl::ConfigManager::getProductVersion() +
+                "&LOlocale=" + LanguageTag(utl::ConfigManager::getUILocale()).getBcp47() );
+            sfx2::openUriExternally(sURL, false);
+            break;
+        }
+        case SID_SHOW_LICENSE:
+        {
+            LicenseDialog aDialog(rReq.GetFrameWeld());
+            aDialog.run();
+            break;
+        }
+
+        case SID_SHOW_CREDITS:
+        {
+            showDocument( "CREDITS" );
+            break;
+        }
+
+        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        case SID_HELPINDEX:
+        {
+            Help* pHelp = Application::GetHelp();
+            if ( pHelp )
+            {
+                pHelp->Start(".uno:HelpIndex", Application::GetDefDialogParent()); // show start page
+                bDone = true;
+            }
+            break;
+        }
+
+        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        case SID_HELPTIPS:
+        {
+            // Evaluate Parameter
+            const SfxBoolItem* pOnItem = rReq.GetArg<SfxBoolItem>(SID_HELPTIPS);
+            bool bOn = pOnItem
+                            ? pOnItem->GetValue()
+                            : !Help::IsQuickHelpEnabled();
+
+            if ( bOn )
+                Help::EnableQuickHelp();
+            else
+                Help::DisableQuickHelp();
+            SvtHelpOptions().SetHelpTips( bOn );
+            Invalidate(SID_HELPTIPS);
+            bDone = true;
+
+            // Record if possible
+            if ( !rReq.IsAPI() )
+                rReq.AppendItem( SfxBoolItem( SID_HELPTIPS, bOn) );
+            break;
+        }
+        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        case SID_EXTENDEDHELP:
+        {
+            Help::StartExtHelp();
+            break;
+        }
+        case SID_HELPBALLOONS:
+        {
+            // Evaluate Parameter
+            const SfxBoolItem* pOnItem = rReq.GetArg<SfxBoolItem>(SID_HELPBALLOONS);
+            bool bOn = pOnItem
+                            ? pOnItem->GetValue()
+                            : !Help::IsBalloonHelpEnabled();
+
+            if ( bOn )
+                Help::EnableBalloonHelp();
+            else
+                Help::DisableBalloonHelp();
+            SvtHelpOptions().SetExtendedHelp( bOn );
+            Invalidate(SID_HELPBALLOONS);
+            bDone = true;
+
+            // Record if possible
+            if ( !rReq.IsAPI() )
+                rReq.AppendItem( SfxBoolItem( SID_HELPBALLOONS, bOn) );
+            break;
+        }
+        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        case SID_TIPOFTHEDAY:
+        {
+            VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
+            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateTipOfTheDayDialog(rReq.GetFrameWeld()));
+            pDlg->Execute();
+            bDone = true;
+            break;
+        }
+
+        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+        case SID_ABOUT:
+        {
+            VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
+            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateAboutDialog(rReq.GetFrameWeld()));
+            pDlg->Execute();
+            bDone = true;
+            break;
+        }
+
+        case SID_TEMPLATE_MANAGER:
+        {
+            SfxTemplateManagerDlg aDialog(rReq.GetFrameWeld());
+            aDialog.run();
+            bDone = true;
+            break;
+        }
+
+        case SID_TEMPLATE_ADDRESSBOKSOURCE:
+        {
+            svt::AddressBookSourceDialog aDialog(rReq.GetFrameWeld(), ::comphelper::getProcessComponentContext());
+            aDialog.run();
+            bDone = true;
+            break;
+        }
+
+#if HAVE_FEATURE_SCRIPTING
+        case SID_BASICSTOP:
+            StarBASIC::Stop();
+            break;
+
+        case SID_BASICBREAK :
+            BasicDLL::BasicBreak();
+            break;
+#endif
+
+        case SID_ZOOM_50_PERCENT:
+        case SID_ZOOM_75_PERCENT:
+        case SID_ZOOM_100_PERCENT:
+        case SID_ZOOM_150_PERCENT:
+        case SID_ZOOM_200_PERCENT:
+        case SID_ZOOM_OPTIMAL:
+        case SID_ZOOM_ENTIRE_PAGE:
+        case SID_ZOOM_PAGE_WIDTH:
+        {
+            SfxObjectShell* pCurrentShell = SfxObjectShell::Current();
+            if (!pCurrentShell)
+                return;
+
+            // make sure aZoom is initialized with a proper value if SetType
+            // doesn't work
+            SvxZoomItem aZoom( SvxZoomType::PERCENT, 100 );
+
+            switch (rReq.GetSlot())
+            {
+                case SID_ZOOM_50_PERCENT:
+                    aZoom.SetValue(50);
+                    break;
+                case SID_ZOOM_75_PERCENT:
+                    aZoom.SetValue(75);
+                    break;
+                case SID_ZOOM_100_PERCENT:
+                    aZoom.SetValue(100);
+                    break;
+                case SID_ZOOM_150_PERCENT:
+                    aZoom.SetValue(150);
+                    break;
+                case SID_ZOOM_200_PERCENT:
+                    aZoom.SetValue(200);
+                    break;
+                case SID_ZOOM_OPTIMAL:
+                    aZoom.SetType( SvxZoomType::OPTIMAL );
+                    break;
+                case SID_ZOOM_ENTIRE_PAGE:
+                    aZoom.SetType( SvxZoomType::WHOLEPAGE );
+                    break;
+                case SID_ZOOM_PAGE_WIDTH:
+                    aZoom.SetType( SvxZoomType::PAGEWIDTH );
+                    break;
+            }
+
+            pCurrentShell->GetDispatcher()->ExecuteList(SID_ATTR_ZOOM, SfxCallMode::ASYNCHRON, { &aZoom });
+
+            break;
+        }
+        case SID_TOOLBAR_MODE:
+        {
+            const SfxStringItem* pModeName = rReq.GetArg<SfxStringItem>( SID_TOOLBAR_MODE );
+
+            if ( !pModeName )
+            {
+                bDone = true;
+                break;
+            }
+
+            OUString aNewName(pModeName->GetValue());
+            uno::Reference< uno::XComponentContext > xContext =
+                    ::comphelper::getProcessComponentContext();
+
+            // Get information about current frame and module
+            Reference<XFrame> xCurrentFrame;
+            vcl::EnumContext::Application eCurrentApp = vcl::EnumContext::Application::NONE;
+            OUString aCurrentMode;
+
+            SfxViewFrame* pViewFrame = SfxViewFrame::Current();
+            if( pViewFrame )
+            {
+                xCurrentFrame = pViewFrame->GetFrame().GetFrameInterface();
+
+                const Reference<frame::XModuleManager> xModuleManager  = frame::ModuleManager::create( xContext );
+                eCurrentApp = vcl::EnumContext::GetApplicationEnum( xModuleManager->identify( xCurrentFrame ) );
+
+                OUStringBuffer aPath("org.openoffice.Office.UI.ToolbarMode/Applications/");
+                aPath.append( lcl_getAppName( eCurrentApp ) );
+
+                const utl::OConfigurationTreeRoot aAppNode(
+                                                    xContext,
+                                                    aPath.makeStringAndClear(),
+                                                    true);
+                if ( !aAppNode.isValid() )
+                {
+                    bDone = true;
+                    break;
+                }
+
+                aCurrentMode = comphelper::getString( aAppNode.getNodeValue( "Active" ) );
+
+                if ( aCurrentMode == aNewName )
+                {
+                    bDone = true;
+                    break;
+                }
+
+                // Save new toolbar mode for a current module
+                aAppNode.setNodeValue( "Active", makeAny( aNewName ) );
+                aAppNode.commit();
+            }
+
+            // Apply settings for all frames
+            pViewFrame = SfxViewFrame::GetFirst();
+            while( pViewFrame )
+            {
+                Reference<XFrame> xFrame = pViewFrame->GetFrame().GetFrameInterface();
+
+                // We want to change mode only for a current app module, ignore other apps
+                const Reference<frame::XModuleManager> xModuleManager  = frame::ModuleManager::create( xContext );
+                vcl::EnumContext::Application eApp = vcl::EnumContext::GetApplicationEnum( xModuleManager->identify( xFrame ) );
+                if ( eApp != eCurrentApp )
+                {
+                    pViewFrame = SfxViewFrame::GetNext( *pViewFrame );
+                    continue;
+                }
+
+                Reference<css::beans::XPropertySet> xPropSet( xFrame, UNO_QUERY );
+                Reference<css::frame::XLayoutManager> xLayoutManager;
+                if ( xPropSet.is() )
+                {
+                    try
+                    {
+                        Any aValue = xPropSet->getPropertyValue( "LayoutManager" );
+                        aValue >>= xLayoutManager;
+                    }
+                    catch ( const css::uno::RuntimeException& )
+                    {
+                        throw;
+                    }
+                    catch ( css::uno::Exception& )
+                    {
+                    }
+                }
+
+                if ( xLayoutManager.is() )
+                {
+                    css::uno::Sequence<OUString> aMandatoryToolbars;
+                    css::uno::Sequence<OUString> aUserToolbars;
+                    std::vector<OUString> aBackupList;
+                    OUString aSidebarMode;
+
+                    OUStringBuffer aPath( "org.openoffice.Office.UI.ToolbarMode/Applications/" );
+                    aPath.append( lcl_getAppName( eApp ) );
+                    aPath.append( "/Modes" );
+
+                    // Read mode settings
+                    const utl::OConfigurationTreeRoot aModesNode(
+                                            xContext,
+                                            aPath.makeStringAndClear(),
+                                            true);
+                    if ( !aModesNode.isValid() )
+                    {
+                        bDone = true;
+                        break;
+                    }
+
+                    const Sequence<OUString> aModeNodeNames( aModesNode.getNodeNames() );
+
+                    for ( const auto& rModeNodeName : aModeNodeNames )
+                    {
+                        const utl::OConfigurationNode aModeNode( aModesNode.openNode( rModeNodeName ) );
+                        if ( !aModeNode.isValid() )
+                            continue;
+
+                        OUString aCommandArg = comphelper::getString( aModeNode.getNodeValue( "CommandArg" ) );
+
+                        if ( aCommandArg == aNewName )
+                        {
+                            aMandatoryToolbars = aModeNode.getNodeValue( "Toolbars" ).get< uno::Sequence<OUString> >();
+                            aUserToolbars = aModeNode.getNodeValue( "UserToolbars" ).get< uno::Sequence<OUString> >();
+                            aSidebarMode = comphelper::getString( aModeNode.getNodeValue( "Sidebar" ) );
+                            break;
+                        }
+                    }
+
+                    // Backup visible toolbar list and hide all toolbars
+                    const Sequence<Reference<XUIElement>> aUIElements = xLayoutManager->getElements();
+                    for ( const Reference< XUIElement >& xUIElement : aUIElements )
+                    {
+                        Reference< XPropertySet > xPropertySet( xUIElement, UNO_QUERY );
+                        if ( xPropertySet.is() && xUIElement.is() )
+                        {
+                            try
+                            {
+                                OUString aResName;
+                                sal_Int16 nType( -1 );
+                                xPropertySet->getPropertyValue( "Type" ) >>= nType;
+                                xPropertySet->getPropertyValue( "ResourceURL" ) >>= aResName;
+
+                                if (( nType == css::ui::UIElementType::TOOLBAR ) &&
+                                    !aResName.isEmpty() )
+                                {
+                                    if ( xLayoutManager->isElementVisible( aResName ) )
+                                    {
+                                        aBackupList.push_back( aResName );
+                                    }
+                                    xLayoutManager->hideElement( aResName );
+                                }
+                            }
+                            catch ( const Exception& )
+                            {
+                            }
+                        }
+                    }
+
+                    // Show toolbars
+                    for ( const OUString& rName : std::as_const(aMandatoryToolbars) )
+                    {
+                        xLayoutManager->createElement( rName );
+                        xLayoutManager->showElement( rName );
+                    }
+
+                    for ( const OUString& rName : std::as_const(aUserToolbars) )
+                    {
+                        xLayoutManager->createElement( rName );
+                        xLayoutManager->showElement( rName );
+                    }
+
+                    // Sidebar
+                    pViewFrame->ShowChildWindow( SID_SIDEBAR );
+
+                    sfx2::sidebar::SidebarController* pSidebar =
+                            sfx2::sidebar::SidebarController::GetSidebarControllerForFrame( xFrame );
+                    if ( pSidebar )
+                    {
+                        if ( aSidebarMode == "Arrow" )
+                        {
+                            pSidebar->FadeOut();
+                        }
+                        else if ( aSidebarMode == "Tabs" )
+                        {
+                            pSidebar->FadeIn();
+                            pSidebar->RequestOpenDeck();
+                            pSidebar->RequestCloseDeck();
+                        }
+                        else if ( aSidebarMode == "Opened" )
+                        {
+                            pSidebar->FadeIn();
+                            pSidebar->RequestOpenDeck();
+                        }
+                    }
+
+                    // Show/Hide the Notebookbar
+                    const SfxPoolItem* pItem;
+                    pViewFrame->GetDispatcher()->QueryState( SID_NOTEBOOKBAR, pItem );
+
+                    // Save settings
+                    if ( pViewFrame == SfxViewFrame::Current() )
+                    {
+                        css::uno::Sequence<OUString> aBackup( comphelper::containerToSequence(aBackupList) );
+
+                        for ( const auto& rModeNodeName : aModeNodeNames )
+                        {
+                            const utl::OConfigurationNode aModeNode( aModesNode.openNode( rModeNodeName ) );
+                            if ( !aModeNode.isValid() )
+                                continue;
+
+                            OUString aCommandArg = comphelper::getString( aModeNode.getNodeValue( "CommandArg" ) );
+
+                            if ( aCommandArg == aCurrentMode )
+                            {
+                                aModeNode.setNodeValue( "UserToolbars", makeAny( aBackup ) );
+                                break;
+                            }
+                        }
+                        aModesNode.commit();
+                    }
+                }
+
+                pViewFrame = SfxViewFrame::GetNext(*pViewFrame);
+            }
+
+            bDone = true;
+            break;
+        }
+        case SID_AVAILABLE_TOOLBARS:
+        {
+            const SfxStringItem* pToolbarName = rReq.GetArg<SfxStringItem>(SID_AVAILABLE_TOOLBARS);
+
+            if ( pToolbarName )
+            {
+                Reference < XDesktop2 > xDesktop = Desktop::create ( ::comphelper::getProcessComponentContext() );
+                Reference< XFrame > xFrame = xDesktop->getActiveFrame();
+
+                Reference< css::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
+                Reference< css::frame::XLayoutManager > xLayoutManager;
+                if ( xPropSet.is() )
+                {
+                    try
+                    {
+                        Any aValue = xPropSet->getPropertyValue("LayoutManager");
+                        aValue >>= xLayoutManager;
+                    }
+                    catch ( const css::uno::RuntimeException& )
+                    {
+                        throw;
+                    }
+                    catch ( css::uno::Exception& )
+                    {
+                    }
+                }
+
+                if ( xLayoutManager.is() )
+                {
+                    OUStringBuffer aBuf( "private:resource/toolbar/" );
+                    aBuf.append( pToolbarName->GetValue() );
+
+                    // Evaluate Parameter
+                    OUString aToolbarName( aBuf.makeStringAndClear() );
+                    bool bShow( !xLayoutManager->isElementVisible( aToolbarName ));
+
+                    if ( bShow )
+                    {
+                        xLayoutManager->createElement( aToolbarName );
+                        xLayoutManager->showElement( aToolbarName );
+                    }
+                    else
+                        xLayoutManager->hideElement( aToolbarName );
+                }
+            }
+
+            bDone = true;
+            break;
+        }
+        case SID_MENUBAR:
+        {
+            sfx2::SfxNotebookBar::ToggleMenubar();
+            bDone = true;
+            break;
+        }
+        case SID_SAFE_MODE:
+        {
+            SafeModeQueryDialog aDialog(rReq.GetFrameWeld());
+            aDialog.run();
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    if ( bDone )
+        rReq.Done();
+}
+
+void SfxApplication::MiscState_Impl(SfxItemSet &rSet)
+{
+    const sal_uInt16 *pRanges = rSet.GetRanges();
+    DBG_ASSERT(pRanges && *pRanges, "Set without range");
+    while ( *pRanges )
+    {
+        for(sal_uInt16 nWhich = *pRanges++; nWhich <= *pRanges; ++nWhich)
+        {
+            switch(nWhich)
+            {
+                case SID_TEMPLATE_ADDRESSBOKSOURCE:
+                    if ( !SvtModuleOptions().IsModuleInstalled(SvtModuleOptions::EModule::DATABASE) )
+                        rSet.Put(SfxVisibilityItem(nWhich, false));
+                    break;
+                case SID_QUITAPP:
+                {
+                    if ( pImpl->nDocModalMode )
+                        rSet.DisableItem(nWhich);
+                    else
+                        rSet.Put(SfxStringItem(nWhich, SfxResId(STR_QUITAPP)));
+                    break;
+                }
+
+                case SID_CONFIG:
+                case SID_TOOLBOXOPTIONS:
+                case SID_CONFIGSTATUSBAR:
+                case SID_CONFIGMENU:
+                case SID_CONFIGACCEL:
+                case SID_CONFIGEVENT:
+                {
+                    if( SvtMiscOptions().DisableUICustomization() )
+                        rSet.DisableItem(nWhich);
+                    break;
+                }
+
+#if HAVE_FEATURE_SCRIPTING
+                case SID_BASICSTOP:
+                    if ( !StarBASIC::IsRunning() )
+                        rSet.DisableItem(nWhich);
+                    break;
+#endif
+
+                case SID_HELPTIPS:
+                {
+                    rSet.Put( SfxBoolItem( SID_HELPTIPS, Help::IsQuickHelpEnabled() ) );
+                }
+                break;
+                case SID_HELPBALLOONS:
+                {
+                    rSet.Put( SfxBoolItem( SID_HELPBALLOONS, Help::IsBalloonHelpEnabled() ) );
+                }
+                break;
+
+                case SID_EXTENDEDHELP:
+                {
+                }
+                break;
+
+                case SID_CLOSEDOCS:
+                {
+                    Reference < XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
+                    Reference< XIndexAccess > xTasks = xDesktop->getFrames();
+                    if ( !xTasks.is() || !xTasks->getCount() )
+                        rSet.DisableItem(nWhich);
+                    break;
+                }
+
+                case SID_SAVEDOCS:
+                {
+                    bool bModified = false;
+                    for ( SfxObjectShell *pObjSh = SfxObjectShell::GetFirst();
+                          pObjSh;
+                          pObjSh = SfxObjectShell::GetNext( *pObjSh ) )
+                    {
+                        if ( pObjSh->IsModified() )
+                        {
+                            bModified = true;
+                            break;
+                        }
+                    }
+
+                    if ( !bModified )
+                        rSet.DisableItem( nWhich );
+                    break;
+                }
+
+                case SID_TEMPLATE_MANAGER:
+                    {
+                        SvtMiscOptions aMiscOptions;
+                        if ( !aMiscOptions.IsExperimentalMode() )
+                        {
+                           rSet.DisableItem( nWhich );
+                           rSet.Put( SfxVisibilityItem( nWhich, false ) );
+                        }
+                    }
+                    break;
+
+                case SID_ZOOM_50_PERCENT:
+                case SID_ZOOM_75_PERCENT:
+                case SID_ZOOM_100_PERCENT:
+                case SID_ZOOM_150_PERCENT:
+                case SID_ZOOM_200_PERCENT:
+                case SID_ZOOM_OPTIMAL:
+                case SID_ZOOM_ENTIRE_PAGE:
+                case SID_ZOOM_PAGE_WIDTH:
+                    {
+                        SfxObjectShell* pCurrentShell = SfxObjectShell::Current();
+
+                        const SfxPoolItem *pItem;
+                        SfxItemState aState = pCurrentShell ?
+                            pCurrentShell->GetDispatcher()->QueryState(SID_ATTR_ZOOM, pItem) : SfxItemState::DISABLED;
+                        if ( aState == SfxItemState::DISABLED )
+                            rSet.DisableItem( nWhich );
+                    }
+                    break;
+
+                case SID_MENUBAR:
+                {
+                    Reference < XDesktop2 > xDesktop = Desktop::create ( ::comphelper::getProcessComponentContext() );
+                    Reference< XFrame > xFrame = xDesktop->getActiveFrame();
+
+                    Reference< css::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
+                    Reference< css::frame::XLayoutManager > xLayoutManager;
+                    if ( xPropSet.is() )
+                    {
+                        try
+                        {
+                            Any aValue = xPropSet->getPropertyValue("LayoutManager");
+                            aValue >>= xLayoutManager;
+                        }
+                        catch ( const css::uno::RuntimeException& )
+                        {
+                            throw;
+                        }
+                        catch ( css::uno::Exception& )
+                        {
+                        }
+                    }
+
+                    if ( xLayoutManager.is() )
+                    {
+                        const bool bState
+                            = xLayoutManager->getElement("private:resource/menubar/menubar").is()
+                              && xLayoutManager->isElementVisible(
+                                     "private:resource/menubar/menubar");
+
+                        SfxBoolItem aItem( SID_MENUBAR, bState );
+                        rSet.Put( aItem );
+                    }
+                    break;
+                }
+                case SID_SAFE_MODE:
+                {
+                    // no restart in safe mode when already in safe mode
+                    if ( Application::IsSafeModeEnabled() )
+                       rSet.DisableItem( SID_SAFE_MODE );
+                    break;
+                }
+
+                default:
+                    break;
+            }
+        }
+
+        ++pRanges;
+    }
+}
+
+#if HAVE_FEATURE_SCRIPTING
+
+#ifndef DISABLE_DYNLOADING
+
+typedef rtl_uString* (*basicide_choose_macro)(void*, void*, void*, sal_Bool);
+
+#else
+
+extern "C" rtl_uString* basicide_choose_macro(void*, void*, void*, sal_Bool);
+
+#endif
+
+static OUString ChooseMacro(weld::Window* pParent, const Reference<XModel>& rxLimitToDocument, const Reference<XFrame>& xDocFrame, bool bChooseOnly)
+{
+#ifndef DISABLE_DYNLOADING
+    basicide_choose_macro pSymbol = reinterpret_cast<basicide_choose_macro>(sfx2::getBasctlFunction("basicide_choose_macro"));
+#else
+#define pSymbol basicide_choose_macro
+#endif
+
+    // call basicide_choose_macro in basctl
+    rtl_uString* pScriptURL = pSymbol(pParent, rxLimitToDocument.get(), xDocFrame.get(), bChooseOnly);
+    OUString aScriptURL( pScriptURL );
+    rtl_uString_release( pScriptURL );
+    return aScriptURL;
+
+#ifdef DISABLE_DYNLOADING
+#undef pSymbol
+#endif
+}
+
+#endif
+
+namespace
+{
+#if HAVE_FEATURE_SCRIPTING
+    weld::Window* lcl_getDialogParent(const Reference<XFrame>& rxFrame)
+    {
+        Reference<awt::XWindow> xContainerWindow;
+        if (rxFrame.is())
+            xContainerWindow = rxFrame->getContainerWindow();
+        return Application::GetFrameWeld(xContainerWindow);
+    }
+
+    SfxViewFrame* lcl_getBasicIDEViewFrame( SfxObjectShell const * i_pBasicIDE )
+    {
+        SfxViewFrame* pView = SfxViewFrame::GetFirst( i_pBasicIDE );
+        while ( pView )
+        {
+            if ( pView->GetObjectShell()->GetFactory().GetDocumentServiceName() == "com.sun.star.script.BasicIDE" )
+                break;
+            pView = SfxViewFrame::GetNext( *pView, i_pBasicIDE );
+        }
+        return pView;
+    }
+    Reference< XFrame > lcl_findStartModuleFrame( const Reference<XComponentContext> & rxContext )
+    {
+        try
+        {
+            Reference < XDesktop2 > xDesktop = Desktop::create( rxContext );
+            Reference < XIndexAccess > xContainer( xDesktop->getFrames(), UNO_QUERY_THROW );
+
+            Reference< XModuleManager2 > xCheck = ModuleManager::create(rxContext);
+
+            sal_Int32 nCount = xContainer->getCount();
+            for ( sal_Int32 i=0; i<nCount; ++i )
+            {
+                try
+                {
+                    Reference < XFrame > xFrame( xContainer->getByIndex(i), UNO_QUERY_THROW );
+                    OUString sModule = xCheck->identify( xFrame );
+                    if ( sModule == "com.sun.star.frame.StartModule" )
+                        return xFrame;
+                }
+                catch( const UnknownModuleException& )
+                {
+                    // silence
+                }
+                catch(const Exception&)
+                {
+                    // re-throw, caught below
+                    throw;
+                }
+            }
+        }
+        catch( const Exception& )
+        {
+               DBG_UNHANDLED_EXCEPTION("sfx.appl");
+        }
+        return nullptr;
+    }
+#endif // HAVE_FEATURE_SCRIPTING
+}
+
+void SfxApplication::OfaExec_Impl( SfxRequest& rReq )
+{
+    switch ( rReq.GetSlot() )
+    {
+        case SID_OPTIONS_TREEDIALOG:
+        {
+            OUString sPageURL;
+            const SfxStringItem* pURLItem = rReq.GetArg<SfxStringItem>(SID_OPTIONS_PAGEURL);
+            if ( pURLItem )
+                sPageURL = pURLItem->GetValue();
+            Reference <XFrame> xFrame(GetRequestFrame(rReq));
+            SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+            VclPtr<VclAbstractDialog> pDlg =
+                pFact->CreateFrameDialog(rReq.GetFrameWeld(), xFrame, rReq.GetSlot(), sPageURL );
+            short nRet = pDlg->Execute();
+            pDlg.disposeAndClear();
+            SfxViewFrame* pView = SfxViewFrame::GetFirst();
+            while ( pView )
+            {
+                if (nRet == RET_OK)
+                {
+                    SfxObjectShell* pObjSh = pView->GetObjectShell();
+                    if (pObjSh)
+                        pObjSh->SetConfigOptionsChecked(false);
+                }
+                pView->GetBindings().InvalidateAll(false);
+                pView = SfxViewFrame::GetNext( *pView );
+            }
+            break;
+        }
+
+        case SID_MORE_DICTIONARIES:
+        {
+            try
+            {
+                uno::Reference< uno::XComponentContext > xContext =
+                    ::comphelper::getProcessComponentContext();
+                uno::Reference< css::system::XSystemShellExecute > xSystemShell(
+                    css::system::SystemShellExecute::create(xContext) );
+
+                // read repository URL from configuration
+                OUString sTemplRepoURL(officecfg::Office::Common::Dictionaries::RepositoryURL::get());
+
+                if ( xSystemShell.is() && !sTemplRepoURL.isEmpty() )
+                {
+                    // read locale from configuration
+                    OUString sLocale(officecfg::Setup::L10N::ooLocale::get());
+                    if (sLocale.isEmpty())
+                        sLocale = "en-US";
+
+                    OUString aURLBuf =  sTemplRepoURL + "?lang=" + sLocale;
+                    xSystemShell->execute(
+                        aURLBuf,
+                        OUString(),
+                        css::system::SystemShellExecuteFlags::URIS_ONLY );
+                }
+            }
+            catch( const css::uno::Exception& )
+            {
+                TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxApplication::OfaExec_Impl(SID_MORE_DICTIONARIES)" );
+            }
+            break;
+        }
+#if HAVE_FEATURE_SCRIPTING
+        case SID_BASICIDE_APPEAR:
+        {
+            SfxViewFrame* pView = lcl_getBasicIDEViewFrame( nullptr );
+            if ( !pView )
+            {
+                SfxObjectShell* pBasicIDE = SfxObjectShell::CreateObject( "com.sun.star.script.BasicIDE" );
+                pBasicIDE->DoInitNew();
+                pBasicIDE->SetModified( false );
+                try
+                {
+                    // load the Basic IDE via direct access to the SFX frame loader. A generic loadComponentFromURL
+                    // (which could be done via SfxViewFrame::LoadDocumentIntoFrame) is not feasible here, since the Basic IDE
+                    // does not really play nice with the framework's concept. For instance, it is a "singleton document",
+                    // which conflicts, at the latest, with the framework's concept of loading into _blank frames.
+                    // So, since we know that our frame loader can handle it, we skip the generic framework loader
+                    // mechanism, and the type detection (which doesn't know about the Basic IDE).
+                    Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
+                    Reference< XSynchronousFrameLoader > xLoader(
+                        xContext->getServiceManager()->createInstanceWithContext("com.sun.star.comp.office.FrameLoader", xContext),
+                        UNO_QUERY_THROW );
+                    ::comphelper::NamedValueCollection aLoadArgs;
+                    aLoadArgs.put( "Model", pBasicIDE->GetModel() );
+                    aLoadArgs.put( "URL", OUString( "private:factory/sbasic"  ) );
+
+                    Reference< XFrame > xTargetFrame( lcl_findStartModuleFrame( xContext ) );
+                    if ( !xTargetFrame.is() )
+                        xTargetFrame = SfxFrame::CreateBlankFrame();
+                    ENSURE_OR_THROW( xTargetFrame.is(), "could not obtain a frameto load the Basic IDE into!" );
+
+                    xLoader->load( aLoadArgs.getPropertyValues(), xTargetFrame );
+                }
+                catch( const Exception& )
+                {
+                    DBG_UNHANDLED_EXCEPTION("sfx.appl");
+                }
+
+                pView = lcl_getBasicIDEViewFrame( pBasicIDE );
+                if ( pView )
+                    pView->SetName( "BASIC:1" );
+            }
+
+            if ( pView )
+                pView->GetFrame().Appear();
+
+            const SfxItemSet* pArgs = rReq.GetArgs();
+            if ( pArgs && pView )
+            {
+                SfxViewShell* pViewShell = pView->GetViewShell();
+                SfxObjectShell* pObjShell = pView->GetObjectShell();
+                if ( pViewShell && pObjShell )
+                {
+                    SfxRequest aReq( SID_BASICIDE_SHOWWINDOW, SfxCallMode::SYNCHRON, pObjShell->GetPool() );
+                    aReq.SetArgs( *pArgs );
+                    pViewShell->ExecuteSlot( aReq );
+                }
+            }
+
+            rReq.Done();
+        }
+        break;
+
+        case SID_BASICCHOOSER:
+        {
+            const SfxItemSet* pArgs = rReq.GetArgs();
+            const SfxPoolItem* pItem;
+            bool bChooseOnly = false;
+            Reference< XModel > xLimitToModel;
+            if(pArgs && SfxItemState::SET == pArgs->GetItemState(SID_RECORDMACRO, false, &pItem) )
+            {
+                bool bRecord = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+                if ( bRecord )
+                {
+                    // !Hack
+                    bChooseOnly = false;
+                    SfxObjectShell* pCurrentShell = SfxObjectShell::Current();
+                    OSL_ENSURE( pCurrentShell, "macro recording outside an SFX document?" );
+                    if ( pCurrentShell )
+                        xLimitToModel = pCurrentShell->GetModel();
+                }
+            }
+
+            Reference <XFrame> xFrame(GetRequestFrame(rReq));
+            rReq.SetReturnValue(SfxStringItem(rReq.GetSlot(), ChooseMacro(rReq.GetFrameWeld(), xLimitToModel, xFrame, bChooseOnly)));
+            rReq.Done();
+        }
+        break;
+
+        case SID_MACROORGANIZER:
+        {
+            SAL_INFO("sfx.appl", "handling SID_MACROORGANIZER");
+            const SfxItemSet* pArgs = rReq.GetArgs();
+            const SfxPoolItem* pItem;
+            sal_Int16 nTabId = 0;
+            if(pArgs && SfxItemState::SET == pArgs->GetItemState(SID_MACROORGANIZER, false, &pItem) )
+            {
+                nTabId = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
+            }
+
+            SfxApplication::MacroOrganizer(rReq.GetFrameWeld(), nTabId);
+            rReq.Done();
+        }
+        break;
+
+        case SID_RUNMACRO:
+        {
+            SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+            SAL_INFO("sfx.appl", "SfxApplication::OfaExec_Impl: case ScriptOrg");
+
+            Reference <XFrame> xFrame(GetRequestFrame(rReq));
+            if ( !xFrame.is() )
+            {
+                const SfxViewFrame* pViewFrame = SfxViewFrame::Current();
+                if ( pViewFrame )
+                    xFrame = pViewFrame->GetFrame().GetFrameInterface();
+            }
+
+            do  // artificial loop for flow control
+            {
+                ScopedVclPtr<AbstractScriptSelectorDialog> pDlg(pFact->CreateScriptSelectorDialog(lcl_getDialogParent(xFrame), xFrame));
+                OSL_ENSURE( pDlg, "SfxApplication::OfaExec_Impl( SID_RUNMACRO ): no dialog!" );
+                if ( !pDlg )
+                    break;
+                pDlg->SetRunLabel();
+
+                short nDialogResult = pDlg->Execute();
+                if ( !nDialogResult )
+                    break;
+
+                Sequence< Any > args;
+                Sequence< sal_Int16 > outIndex;
+                Sequence< Any > outArgs;
+                Any ret;
+
+                Reference< XInterface > xScriptContext;
+
+                Reference< XController > xController;
+                if ( xFrame.is() )
+                    xController = xFrame->getController();
+                if ( xController.is() )
+                    xScriptContext = xController->getModel();
+                if ( !xScriptContext.is() )
+                    xScriptContext = xController;
+
+                SfxObjectShell::CallXScript( xScriptContext, pDlg->GetScriptURL(), args, ret, outIndex, outArgs );
+            }
+            while ( false );
+            rReq.Done();
+        }
+        break;
+
+        case SID_SCRIPTORGANIZER:
+        {
+            SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+            SAL_INFO("sfx.appl", "SfxApplication::OfaExec_Impl: case ScriptOrg");
+            const SfxItemSet* pArgs = rReq.GetArgs();
+            const SfxPoolItem* pItem;
+            OUString aLanguage;
+            if(pArgs && SfxItemState::SET == pArgs->GetItemState(SID_SCRIPTORGANIZER, false, &pItem) )
+            {
+                aLanguage = static_cast<const SfxScriptOrganizerItem*>(pItem)->getLanguage();
+            }
+
+            OUString aLang( aLanguage );
+            SAL_INFO("sfx.appl", "SfxApplication::OfaExec_Impl: about to create dialog for: " << aLang);
+            ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateSvxScriptOrgDialog(rReq.GetFrameWeld(), aLanguage));
+            if( pDlg )
+            {
+                pDlg->Execute();
+            }
+            else
+            {
+                SAL_WARN("sfx.appl", "no dialog!!!");
+            }
+            rReq.Done();
+        }
+        break;
+#endif // HAVE_FEATURE_SCRIPTING
+
+        case SID_OFFICE_CHECK_PLZ:
+        {
+            bool bRet = false;
+            const SfxStringItem* pStringItem = rReq.GetArg<SfxStringItem>(rReq.GetSlot());
+
+            if ( pStringItem )
+            {
+                bRet = true /*!!!SfxIniManager::CheckPLZ( aPLZ )*/;
+            }
+#if HAVE_FEATURE_SCRIPTING
+            else
+                SbxBase::SetError( ERRCODE_BASIC_WRONG_ARGS );
+#endif
+            rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), bRet ) );
+        }
+        break;
+
+        case SID_AUTO_CORRECT_DLG:
+        {
+            SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+            SfxItemSet aSet(GetPool(), svl::Items<SID_AUTO_CORRECT_DLG, SID_AUTO_CORRECT_DLG>{});
+            const SfxPoolItem* pItem=nullptr;
+            const SfxItemSet* pSet = rReq.GetArgs();
+            SfxItemPool* pSetPool = pSet ? pSet->GetPool() : nullptr;
+            if ( pSet && pSet->GetItemState( pSetPool->GetWhich( SID_AUTO_CORRECT_DLG ), false, &pItem ) == SfxItemState::SET )
+                aSet.Put( *pItem );
+
+            const SfxViewFrame* pViewFrame = SfxViewFrame::Current();
+            ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateAutoCorrTabDialog(pViewFrame ? pViewFrame->GetWindow().GetFrameWeld() : nullptr, &aSet));
+            pDlg->Execute();
+
+            break;
+        }
+
+        case SID_NEWSD :
+        {
+            SvtModuleOptions aModuleOpt;
+            if ( !aModuleOpt.IsImpress() )
+            {
+                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(nullptr,
+                                                                         VclMessageType::Warning, VclButtonsType::Ok,
+                                                                         SfxResId(STR_MODULENOTINSTALLED)));
+                xBox->run();
+                return;
+            }
+
+            Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+            Reference< frame::XDispatchProvider > xProv = drawing::ModuleDispatcher::create( xContext );
+
+            OUString aCmd = OUString::createFromAscii( GetInterface()->GetSlot( rReq.GetSlot() )->GetUnoName() );
+            Reference< frame::XDispatchHelper > xHelper( frame::DispatchHelper::create(xContext) );
+            Sequence < beans::PropertyValue > aSeq;
+            if ( rReq.GetArgs() )
+                TransformItems( rReq.GetSlot(), *rReq.GetArgs(), aSeq );
+            Any aResult = xHelper->executeDispatch( xProv, aCmd, OUString(), 0, aSeq );
+            frame::DispatchResultEvent aEvent;
+            bool bSuccess = (aResult >>= aEvent) &&
+                                (aEvent.State == frame::DispatchResultState::SUCCESS);
+            rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), bSuccess ) );
+        }
+        break;
+
+        case FN_LABEL :
+        case FN_BUSINESS_CARD :
+        case FN_XFORMS_INIT :
+        {
+            Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+            Reference< frame::XDispatchProvider > xProv = text::ModuleDispatcher::create( xContext );
+
+            OUString aCmd = OUString::createFromAscii( GetInterface()->GetSlot( rReq.GetSlot() )->GetUnoName() );
+            Reference< frame::XDispatchHelper > xHelper( frame::DispatchHelper::create(xContext) );
+            Sequence < beans::PropertyValue > aSeq;
+            if ( rReq.GetArgs() )
+                TransformItems( rReq.GetSlot(), *rReq.GetArgs(), aSeq );
+            Any aResult = xHelper->executeDispatch( xProv, aCmd, OUString(), 0, aSeq );
+            frame::DispatchResultEvent aEvent;
+            bool bSuccess = (aResult >>= aEvent) &&
+                                (aEvent.State == frame::DispatchResultState::SUCCESS);
+            rReq.SetReturnValue( SfxBoolItem( rReq.GetSlot(), bSuccess ) );
+        }
+        break;
+
+        case SID_ADDRESS_DATA_SOURCE:
+        {
+            try
+            {
+                Reference< uno::XComponentContext > xORB = ::comphelper::getProcessComponentContext();
+                Reference< ui::dialogs::XExecutableDialog > xDialog = ui::dialogs::AddressBookSourcePilot::createWithParent(xORB, nullptr);
+                xDialog->execute();
+            }
+            catch(const css::uno::Exception&)
+            {
+                DBG_UNHANDLED_EXCEPTION("sfx.appl");
+            }
+        }
+        break;
+
+        case SID_COMP_BIBLIOGRAPHY:
+            lcl_tryLoadBibliography();
+        break;
+    }
+}
+
+void SfxApplication::OfaState_Impl(SfxItemSet &rSet)
+{
+    SvtModuleOptions aModuleOpt;
+
+    if( !aModuleOpt.IsWriter())
+    {
+        rSet.DisableItem( FN_LABEL );
+        rSet.DisableItem( FN_BUSINESS_CARD );
+        rSet.DisableItem( FN_XFORMS_INIT );
+    }
+    if ( comphelper::LibreOfficeKit::isActive() )
+        rSet.DisableItem( SID_AUTO_CORRECT_DLG );
+
+    bool bMacrosDisabled
+        = officecfg::Office::Common::Security::Scripting::DisableMacrosExecution::get();
+    if (bMacrosDisabled)
+    {
+        rSet.DisableItem(SID_RUNMACRO);
+        rSet.DisableItem(SID_MACROORGANIZER);
+        rSet.DisableItem(SID_SCRIPTORGANIZER);
+        rSet.DisableItem(SID_BASICIDE_APPEAR);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/appuno.cxx b/sfx2/source/appl/appuno.cxx
new file mode 100644
index 000000000..1bdb0c0e9
--- /dev/null
+++ b/sfx2/source/appl/appuno.cxx
@@ -0,0 +1,1843 @@
+/* -*- 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 <fltoptint.hxx>
+#include <sfx2/brokenpackageint.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/msg.hxx>
+#include <sfx2/msgpool.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/sfxuno.hxx>
+#include <sfxslots.hxx>
+
+#include <sal/config.h>
+#include <sal/log.hxx>
+#include <comphelper/interaction.hxx>
+#include <osl/diagnose.h>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <svl/itempool.hxx>
+#include <svl/slstitm.hxx>
+#include <svl/stritem.hxx>
+#include <tools/debug.hxx>
+#include <cppuhelper/implbase.hxx>
+
+#include <com/sun/star/document/BrokenPackageRequest.hpp>
+#include <com/sun/star/document/FilterOptionsRequest.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/task/XInteractionHandler.hpp>
+#include <com/sun/star/task/XStatusIndicator.hpp>
+#include <com/sun/star/ucb/XContent.hpp>
+
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::io;
+
+// needs to be converted to a better data structure
+SfxFormalArgument const aFormalArgs[] = {
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "SuggestedSaveAsName", SID_DEFAULTFILENAME },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "SuggestedSaveAsDir", SID_DEFAULTFILEPATH },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "VersionAuthor", SID_DOCINFO_AUTHOR },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "VersionComment", SID_DOCINFO_COMMENTS },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "DontTerminateEdit", FN_PARAM_1 },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "VersionMajor", SID_DOCINFO_MAJOR },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "FilterOptions", SID_FILE_FILTEROPTIONS },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "FilterName", SID_FILTER_NAME },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Margin1", SID_RULER_MARGIN1 },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Margin2", SID_RULER_MARGIN2 },
+//    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "FileName", SID_FILE_NAME },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "URL", SID_FILE_NAME },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "OpenFlags", SID_OPTIONS },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "Overwrite", SID_OVERWRITE },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Password", SID_PASSWORD },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "PasswordInteraction", SID_PASSWORDINTERACTION },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Referer", SID_REFERER },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "SaveTo", SID_SAVETO },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "TemplateName", SID_TEMPLATE_NAME },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "TemplateRegion", SID_TEMPLATE_REGIONNAME },
+//    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Region", SID_TEMPLATE_REGIONNAME },
+//    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "Name", SID_TEMPLATE_NAME },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "Unpacked", SID_UNPACK },
+    { reinterpret_cast<SfxType*>(&aSfxInt16Item_Impl), "Version", SID_VERSION },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "SaveACopy", SID_SAVEACOPYITEM },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "NoFileSync", SID_NO_FILE_SYNC },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "NoThumbnail", SID_NO_THUMBNAIL },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "NoEmbDataSet", SID_NO_EMBEDDED_DS },
+    { reinterpret_cast<SfxType*>(&aSfxBoolItem_Impl), "IsRedactMode", SID_IS_REDACT_MODE },
+    { reinterpret_cast<SfxType*>(&aSfxStringItem_Impl), "RedactionStyle", SID_REDACTION_STYLE },
+};
+
+static sal_uInt16 const nMediaArgsCount = SAL_N_ELEMENTS(aFormalArgs);
+
+static char const sTemplateRegionName[] = "TemplateRegionName";
+static char const sTemplateName[] = "TemplateName";
+static char const sAsTemplate[] = "AsTemplate";
+static char const sOpenNewView[] = "OpenNewView";
+static char const sViewId[] = "ViewId";
+static char const sPluginMode[] = "PluginMode";
+static char const sReadOnly[] = "ReadOnly";
+static char const sDdeReconnect[] = "DDEReconnect";
+static char const sStartPresentation[] = "StartPresentation";
+static char const sFrameName[] = "FrameName";
+static char const sMediaType[] = "MediaType";
+static char const sPostData[] = "PostData";
+static char const sCharacterSet[] = "CharacterSet";
+static char const sInputStream[] = "InputStream";
+static char const sStream[] = "Stream";
+static char const sOutputStream[] = "OutputStream";
+static char const sHidden[] = "Hidden";
+static char const sPreview[] = "Preview";
+static char const sViewOnly[] = "ViewOnly";
+static char const sDontEdit[] = "DontEdit";
+static char const sSilent[] = "Silent";
+static char const sJumpMark[] = "JumpMark";
+static char const sSalvagedFile[] = "SalvagedFile";
+static char const sStatusInd[] = "StatusIndicator";
+static char const sModel[] = "Model";
+static char const sFrame[] = "Frame";
+static char const sViewData[] = "ViewData";
+static char const sFilterData[] = "FilterData";
+static char const sSelectionOnly[] = "SelectionOnly";
+static char const sMacroExecMode[] = "MacroExecutionMode";
+static char const sUpdateDocMode[] = "UpdateDocMode";
+static char const sMinimized[] = "Minimized";
+static char const sInteractionHdl[] = "InteractionHandler";
+static char const sUCBContent[] = "UCBContent";
+static char const sRepairPackage[] = "RepairPackage";
+static char const sDocumentTitle[] = "DocumentTitle";
+static char const sComponentData[] = "ComponentData";
+static char const sComponentContext[] = "ComponentContext";
+static char const sDocumentBaseURL[] = "DocumentBaseURL";
+static char const sHierarchicalDocumentName[] = "HierarchicalDocumentName";
+static char const sCopyStreamIfPossible[] = "CopyStreamIfPossible";
+static char const sNoAutoSave[] = "NoAutoSave";
+static char const sFolderName[] = "FolderName";
+static char const sUseSystemDialog[] = "UseSystemDialog";
+static char const sStandardDir[] = "StandardDir";
+static char const sBlackList[] = "BlackList";
+static char const sModifyPasswordInfo[] = "ModifyPasswordInfo";
+static char const sSuggestedSaveAsDir[] = "SuggestedSaveAsDir";
+static char const sSuggestedSaveAsName[] = "SuggestedSaveAsName";
+static char const sEncryptionData[] = "EncryptionData";
+static char const sFailOnWarning[] = "FailOnWarning";
+static char const sDocumentService[] = "DocumentService";
+static char const sFilterProvider[] = "FilterProvider";
+static char const sImageFilter[] = "ImageFilter";
+static char const sLockContentExtraction[] = "LockContentExtraction";
+static char const sLockExport[] = "LockExport";
+static char const sLockPrint[] = "LockPrint";
+static char const sLockSave[] = "LockSave";
+static char const sLockEditDoc[] = "LockEditDoc";
+static char const sReplaceable[] = "Replaceable";
+
+static bool isMediaDescriptor( sal_uInt16 nSlotId )
+{
+    return ( nSlotId == SID_OPENDOC || nSlotId == SID_EXPORTDOC ||
+             nSlotId == SID_SAVEASDOC || nSlotId == SID_SAVEDOC ||
+             nSlotId == SID_SAVETO || nSlotId == SID_SAVEACOPY ||
+             nSlotId == SID_EXPORTDOCASPDF || nSlotId == SID_DIRECTEXPORTDOCASPDF ||
+             nSlotId == SID_EXPORTDOCASEPUB || nSlotId == SID_DIRECTEXPORTDOCASEPUB ||
+             nSlotId == SID_REDACTDOC || nSlotId == SID_AUTOREDACTDOC ||
+             nSlotId == SID_SAVEACOPYITEM);
+}
+
+void TransformParameters( sal_uInt16 nSlotId, const uno::Sequence<beans::PropertyValue>& rArgs, SfxAllItemSet& rSet, const SfxSlot* pSlot )
+{
+    if ( !pSlot )
+        pSlot = SFX_SLOTPOOL().GetSlot( nSlotId );
+
+    if ( !pSlot )
+        return;
+
+    if ( nSlotId == SID_OPENURL )
+        nSlotId = SID_OPENDOC;
+
+    const sal_Int32 nCount = rArgs.getLength();
+    if ( !nCount )
+        return;
+
+    const beans::PropertyValue* pPropsVal = rArgs.getConstArray();
+    if ( !pSlot->IsMode(SfxSlotMode::METHOD) )
+    {
+        // slot is a property
+        const SfxType* pType = pSlot->GetType();
+        std::unique_ptr<SfxPoolItem> pItem(pType->CreateItem());
+
+        if ( !pItem )
+        {
+            SAL_WARN( "sfx", "No creator method for item: " << nSlotId );
+            return;
+        }
+
+        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(nSlotId);
+        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
+        pItem->SetWhich( nWhich );
+        sal_uInt16 nSubCount = pType->nAttribs;
+
+        const beans::PropertyValue& rProp = pPropsVal[0];
+        const OUString& rName = rProp.Name;
+        if ( nCount == 1 && rName == OUString( pSlot->pUnoName, strlen( pSlot->pUnoName ), RTL_TEXTENCODING_UTF8 ) )
+        {
+            // there is only one parameter and its name matches the name of the property,
+            // so it's either a simple property or a complex property in one single UNO struct
+            if( pItem->PutValue( rProp.Value, bConvertTwips ? CONVERT_TWIPS : 0 ) )
+                // only use successfully converted items
+                rSet.Put( *pItem );
+            else
+            {
+                SAL_WARN( "sfx", "Property not convertible: " << pSlot->pUnoName );
+            }
+        }
+#ifdef DBG_UTIL
+        else if ( nSubCount == 0 )
+        {
+            // for a simple property there can be only one parameter and its name *must* match
+            SAL_WARN("sfx.appl", "Property name does not match: " << rName);
+        }
+#endif
+        else
+        {
+            // there is more than one parameter and the property is a complex one
+#ifdef DBG_UTIL
+            // if the dispatch API is used for UI purposes or from the testtool,
+            // it is possible to skip some or all arguments,
+            // but it indicates an error for macro recording;
+            // so this should be notified as a warning only
+            if ( nCount != nSubCount )
+            {
+                SAL_INFO("sfx.appl", "MacroPlayer: wrong number of parameters for slot: " << nSlotId );
+            }
+#endif
+            // complex property; collect sub items from the parameter set and reconstruct complex item
+            sal_uInt16 nFound=0;
+            for ( const beans::PropertyValue& rPropValue : rArgs )
+            {
+                sal_uInt16 nSub;
+                for ( nSub=0; nSub<nSubCount; nSub++ )
+                {
+                    // search sub item by name
+                    OString aStr = rtl::OStringView(pSlot->pUnoName) + "." + pType->aAttrib[nSub].pName;
+                    if ( rPropValue.Name.equalsAsciiL(aStr.getStr(), aStr.getLength()) )
+                    {
+                        sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(pType->aAttrib[nSub].nAID));
+                        if ( bConvertTwips )
+                            nSubId |= CONVERT_TWIPS;
+                        if ( pItem->PutValue( rPropValue.Value, nSubId ) )
+                            nFound++;
+                        else
+                        {
+                            SAL_WARN( "sfx.appl", "Property not convertible: " << pSlot->pUnoName);
+                        }
+                        break;
+                    }
+                }
+
+                // there was a parameter with a name that didn't match to any of the members
+                SAL_WARN_IF( nSub >= nSubCount, "sfx.appl", "Property name does not match: " << rPropValue.Name );
+            }
+
+            // at least one part of the complex item must be present; other parts can have default values
+            if ( nFound > 0 )
+                rSet.Put( *pItem );
+        }
+
+        return;
+    }
+
+#ifdef DBG_UTIL
+    // detect parameters that don't match to any formal argument or one of its members
+    sal_Int32 nFoundArgs = 0;
+#endif
+    // slot is a method
+    bool bIsMediaDescriptor = isMediaDescriptor( nSlotId );
+    sal_uInt16 nMaxArgs = bIsMediaDescriptor ? nMediaArgsCount : pSlot->nArgDefCount;
+    for ( sal_uInt16 nArgs=0; nArgs<nMaxArgs; nArgs++ )
+    {
+        const SfxFormalArgument &rArg = bIsMediaDescriptor ? aFormalArgs[nArgs] : pSlot->GetFormalArgument( nArgs );
+        std::unique_ptr<SfxPoolItem> pItem(rArg.CreateItem());
+        if ( !pItem )
+        {
+            SAL_WARN( "sfx", "No creator method for argument: " << rArg.pName );
+            return;
+        }
+
+        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(rArg.nSlotId);
+        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
+        pItem->SetWhich( nWhich );
+        const SfxType* pType = rArg.pType;
+        sal_uInt16 nSubCount = pType->nAttribs;
+        if ( nSubCount == 0 )
+        {
+            // "simple" (base type) argument
+            auto pProp = std::find_if(rArgs.begin(), rArgs.end(),
+                [&rArg](const beans::PropertyValue& rProp) { return rProp.Name.equalsAscii(rArg.pName); });
+            if (pProp != rArgs.end())
+            {
+#ifdef DBG_UTIL
+                ++nFoundArgs;
+#endif
+                if( pItem->PutValue( pProp->Value, 0 ) )
+                    // only use successfully converted items
+                    rSet.Put( *pItem );
+                else
+                {
+                    SAL_WARN( "sfx", "Property not convertible: " << rArg.pName );
+                }
+            }
+        }
+        else
+        {
+            // complex argument, could be passed in one struct
+            bool bAsWholeItem = false;
+            for ( const beans::PropertyValue& rProp : rArgs )
+            {
+                const OUString& rName = rProp.Name;
+                if ( rName == OUString(rArg.pName, strlen(rArg.pName), RTL_TEXTENCODING_UTF8) )
+                {
+                    bAsWholeItem = true;
+#ifdef DBG_UTIL
+                    ++nFoundArgs;
+#endif
+                    if( pItem->PutValue( rProp.Value, 0 ) )
+                        // only use successfully converted items
+                        rSet.Put( *pItem );
+                    else
+                    {
+                        SAL_WARN( "sfx", "Property not convertible: " << rArg.pName );
+                    }
+                }
+            }
+
+            if ( !bAsWholeItem )
+            {
+                // complex argument; collect sub items from argument array and reconstruct complex item
+                // only put item if at least one member was found and had the correct type
+                // (is this a good idea?! Should we ask for *all* members?)
+                bool bRet = false;
+                for ( const beans::PropertyValue& rProp : rArgs )
+                {
+                    for ( sal_uInt16 nSub=0; nSub<nSubCount; nSub++ )
+                    {
+                        // search sub item by name
+                        OString aStr = rtl::OStringView(rArg.pName) + "." + pType->aAttrib[nSub].pName;
+                        if ( rProp.Name.equalsAsciiL(aStr.getStr(), aStr.getLength()) )
+                        {
+                            // at least one member found ...
+                            bRet = true;
+#ifdef DBG_UTIL
+                            ++nFoundArgs;
+#endif
+                            sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(pType->aAttrib[nSub].nAID));
+                            if ( bConvertTwips )
+                                nSubId |= CONVERT_TWIPS;
+                            if (!pItem->PutValue( rProp.Value, nSubId ) )
+                            {
+                                // ... but it was not convertible
+                                bRet = false;
+                                SAL_WARN( "sfx", "Property not convertible: " << rArg.pName );
+                            }
+
+                            break;
+                        }
+                    }
+                }
+
+                if ( bRet )
+                    // only use successfully converted items
+                    rSet.Put( *pItem );
+
+            }
+        }
+    }
+
+    // special additional parameters for some slots not seen in the slot definitions
+    // Some of these slots are not considered to be used for macro recording, because they shouldn't be recorded as slots,
+    // but as dispatching or factory or arbitrary URLs to the frame
+    // Some also can use additional arguments that are not recordable (will be changed later,
+    // f.e. "SaveAs" shouldn't support parameters not in the slot definition!)
+    if ( nSlotId == SID_NEWWINDOW )
+    {
+        for ( const beans::PropertyValue& rProp : rArgs )
+        {
+            const OUString& rName = rProp.Name;
+            if ( rName == sFrame )
+            {
+                Reference< XFrame > xFrame;
+                OSL_VERIFY( rProp.Value >>= xFrame );
+                rSet.Put( SfxUnoFrameItem( SID_FILLFRAME, xFrame ) );
+            }
+            else
+            if ( rName == sHidden )
+            {
+                bool bVal = false;
+                if (rProp.Value >>= bVal)
+                    rSet.Put( SfxBoolItem( SID_HIDDEN, bVal ) );
+            }
+        }
+    }
+    else if ( bIsMediaDescriptor )
+    {
+        for ( const beans::PropertyValue& rProp : rArgs )
+        {
+#ifdef DBG_UTIL
+            ++nFoundArgs;
+#endif
+            const OUString& aName = rProp.Name;
+            if ( aName == sModel )
+                rSet.Put( SfxUnoAnyItem( SID_DOCUMENT, rProp.Value ) );
+            else if ( aName == sComponentData )
+            {
+                rSet.Put( SfxUnoAnyItem( SID_COMPONENTDATA, rProp.Value ) );
+            }
+            else if ( aName == sComponentContext )
+            {
+                rSet.Put( SfxUnoAnyItem( SID_COMPONENTCONTEXT, rProp.Value ) );
+            }
+            else if ( aName == sStatusInd )
+            {
+                Reference<task::XStatusIndicator> xVal;
+                bool bOK = (rProp.Value >>= xVal);
+                DBG_ASSERT( bOK, "invalid type for StatusIndicator" );
+                if (bOK && xVal.is())
+                    rSet.Put( SfxUnoAnyItem( SID_PROGRESS_STATUSBAR_CONTROL, rProp.Value ) );
+            }
+            else if ( aName == sInteractionHdl )
+            {
+                Reference<task::XInteractionHandler> xVal;
+                bool bOK = (rProp.Value >>= xVal);
+                DBG_ASSERT( bOK, "invalid type for InteractionHandler" );
+                if (bOK && xVal.is())
+                    rSet.Put( SfxUnoAnyItem( SID_INTERACTIONHANDLER, rProp.Value ) );
+            }
+            else if ( aName == sViewData )
+                rSet.Put( SfxUnoAnyItem( SID_VIEW_DATA, rProp.Value ) );
+            else if ( aName == sFilterData )
+                rSet.Put( SfxUnoAnyItem( SID_FILTER_DATA, rProp.Value ) );
+            else if ( aName == sInputStream )
+            {
+                Reference< XInputStream > xVal;
+                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
+                DBG_ASSERT( bOK, "invalid type for InputStream" );
+                if (bOK)
+                    rSet.Put( SfxUnoAnyItem( SID_INPUTSTREAM, rProp.Value ) );
+            }
+            else if ( aName == sStream )
+            {
+                Reference< XInputStream > xVal;
+                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
+                DBG_ASSERT( bOK, "invalid type for Stream" );
+                if (bOK)
+                    rSet.Put( SfxUnoAnyItem( SID_STREAM, rProp.Value ) );
+            }
+            else if ( aName == sUCBContent )
+            {
+                Reference< XContent > xVal;
+                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
+                DBG_ASSERT( bOK, "invalid type for UCBContent" );
+                if (bOK)
+                    rSet.Put( SfxUnoAnyItem( SID_CONTENT, rProp.Value ) );
+            }
+            else if ( aName == sOutputStream )
+            {
+                Reference< XOutputStream > xVal;
+                bool bOK = ((rProp.Value >>= xVal) && xVal.is());
+                DBG_ASSERT( bOK, "invalid type for OutputStream" );
+                if (bOK)
+                    rSet.Put( SfxUnoAnyItem( SID_OUTPUTSTREAM, rProp.Value ) );
+            }
+            else if ( aName == sPostData )
+            {
+                Reference< XInputStream > xVal;
+                bool bOK = (rProp.Value >>= xVal);
+                DBG_ASSERT( bOK, "invalid type for PostData" );
+                if (bOK)
+                    rSet.Put( SfxUnoAnyItem( SID_POSTDATA, rProp.Value ) );
+            }
+            else if ( aName == sFrame )
+            {
+                Reference< XFrame > xFrame;
+                bool bOK = (rProp.Value >>= xFrame);
+                DBG_ASSERT( bOK, "invalid type for Frame" );
+                if (bOK)
+                    rSet.Put( SfxUnoFrameItem( SID_FILLFRAME, xFrame ) );
+            }
+            else if ( aName == sAsTemplate )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for AsTemplate" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_TEMPLATE, bVal ) );
+            }
+            else if ( aName == sOpenNewView )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for OpenNewView" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_OPEN_NEW_VIEW, bVal ) );
+            }
+            else if ( aName == sFailOnWarning )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for FailOnWarning" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_FAIL_ON_WARNING, bVal ) );
+            }
+            else if ( aName == sViewId )
+            {
+                sal_Int16 nVal = -1;
+                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
+                DBG_ASSERT( bOK, "invalid type for ViewId" );
+                if (bOK)
+                    rSet.Put( SfxUInt16Item( SID_VIEW_ID, nVal ) );
+            }
+            else if ( aName == sPluginMode )
+            {
+                sal_Int16 nVal = -1;
+                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
+                DBG_ASSERT( bOK, "invalid type for PluginMode" );
+                if (bOK)
+                    rSet.Put( SfxUInt16Item( SID_PLUGIN_MODE, nVal ) );
+            }
+            else if ( aName == sReadOnly )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for ReadOnly" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_DOC_READONLY, bVal ) );
+            }
+            else if ( aName == sDdeReconnect )
+            {
+                bool bVal = true;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for DDEReconnect" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_DDE_RECONNECT_ONLOAD, bVal ) );
+            }
+            else if ( aName == sStartPresentation )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for StartPresentation" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_DOC_STARTPRESENTATION, bVal ) );
+            }
+            else if ( aName == sSelectionOnly )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for SelectionOnly" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_SELECTION, bVal ) );
+            }
+            else if ( aName == sHidden )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for Hidden" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_HIDDEN, bVal ) );
+            }
+            else if ( aName == sMinimized )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for Minimized" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_MINIMIZED, bVal ) );
+            }
+            else if ( aName == sSilent )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for Silent" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_SILENT, bVal ) );
+            }
+            else if ( aName == sPreview )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for Preview" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_PREVIEW, bVal ) );
+            }
+            else if ( aName == sViewOnly )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for ViewOnly" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_VIEWONLY, bVal ) );
+            }
+            else if ( aName == sDontEdit )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for ViewOnly" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_EDITDOC, !bVal ) );
+            }
+            else if ( aName == sUseSystemDialog )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for ViewOnly" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_FILE_DIALOG, bVal ) );
+            }
+            else if ( aName == sStandardDir )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for StandardDir" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_STANDARD_DIR, sVal ) );
+            }
+            else if ( aName == sBlackList )
+            {
+                uno::Sequence<OUString> xVal;
+                bool bOK = (rProp.Value >>= xVal);
+                DBG_ASSERT( bOK, "invalid type or value for BlackList" );
+                if (bOK)
+                {
+                    SfxStringListItem stringList(SID_BLACK_LIST);
+                    stringList.SetStringList( xVal );
+                    rSet.Put( stringList );
+                }
+            }
+            else if ( aName == "FileName" )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for FileName" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_FILE_NAME, sVal ) );
+            }
+            else if ( aName == sSalvagedFile )
+            {
+                OUString sVal;
+                bool bOK = (rProp.Value >>= sVal);
+                DBG_ASSERT( bOK, "invalid type or value for SalvagedFile" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_DOC_SALVAGE, sVal ) );
+            }
+            else if ( aName == sFolderName )
+            {
+                OUString sVal;
+                bool bOK = (rProp.Value >>= sVal);
+                DBG_ASSERT( bOK, "invalid type or value for FolderName" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_PATH, sVal ) );
+            }
+            else if ( aName == sFrameName )
+            {
+                OUString sVal;
+                bool bOK = (rProp.Value >>= sVal);
+                DBG_ASSERT( bOK, "invalid type for FrameName" );
+                if (bOK && !sVal.isEmpty())
+                    rSet.Put( SfxStringItem( SID_TARGETNAME, sVal ) );
+            }
+            else if ( aName == sMediaType )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for MediaType" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_CONTENTTYPE, sVal ) );
+            }
+            else if ( aName == sTemplateName )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for TemplateName" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_TEMPLATE_NAME, sVal ) );
+            }
+            else if ( aName == sTemplateRegionName )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for TemplateRegionName" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_TEMPLATE_REGIONNAME, sVal ) );
+            }
+            else if ( aName == sJumpMark )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for JumpMark" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_JUMPMARK, sVal ) );
+            }
+            else if ( aName == sCharacterSet )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for CharacterSet" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_CHARSET, sVal ) );
+            }
+            else if ( aName == "FilterFlags" )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for FilterFlags" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_FILE_FILTEROPTIONS, sVal ) );
+            }
+            else if ( aName == sImageFilter )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for FilterFlags" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_CONVERT_IMAGES, sVal ) );
+            }
+            else if ( aName == sMacroExecMode )
+            {
+                sal_Int16 nVal =-1;
+                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
+                DBG_ASSERT( bOK, "invalid type for MacroExecMode" );
+                if (bOK)
+                    rSet.Put( SfxUInt16Item( SID_MACROEXECMODE, nVal ) );
+            }
+            else if ( aName == sUpdateDocMode )
+            {
+                sal_Int16 nVal =-1;
+                bool bOK = ((rProp.Value >>= nVal) && (nVal != -1));
+                DBG_ASSERT( bOK, "invalid type for UpdateDocMode" );
+                if (bOK)
+                    rSet.Put( SfxUInt16Item( SID_UPDATEDOCMODE, nVal ) );
+            }
+            else if ( aName == sRepairPackage )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for RepairPackage" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_REPAIRPACKAGE, bVal ) );
+            }
+            else if ( aName == sDocumentTitle )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for DocumentTitle" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_DOCINFO_TITLE, sVal ) );
+            }
+            else if ( aName == sDocumentBaseURL )
+            {
+                OUString sVal;
+                // the base url can be set to empty ( for embedded objects for example )
+                bool bOK = (rProp.Value >>= sVal);
+                DBG_ASSERT( bOK, "invalid type or value for DocumentBaseURL" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_DOC_BASEURL, sVal ) );
+            }
+            else if ( aName == sHierarchicalDocumentName )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for HierarchicalDocumentName" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_DOC_HIERARCHICALNAME, sVal ) );
+            }
+            else if ( aName == sCopyStreamIfPossible )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for CopyStreamIfPossible" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_COPY_STREAM_IF_POSSIBLE, bVal ) );
+            }
+            else if ( aName == sNoAutoSave )
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for NoAutoSave" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_NOAUTOSAVE, bVal ) );
+            }
+            else if ( aName == sModifyPasswordInfo )
+            {
+                rSet.Put( SfxUnoAnyItem( SID_MODIFYPASSWORDINFO, rProp.Value ) );
+            }
+            else if ( aName == sEncryptionData )
+            {
+                rSet.Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, rProp.Value ) );
+            }
+            else if ( aName == sSuggestedSaveAsDir )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for SuggestedSaveAsDir" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_SUGGESTEDSAVEASDIR, sVal ) );
+            }
+            else if ( aName == sSuggestedSaveAsName )
+            {
+                OUString sVal;
+                bool bOK = ((rProp.Value >>= sVal) && !sVal.isEmpty());
+                DBG_ASSERT( bOK, "invalid type or value for SuggestedSaveAsName" );
+                if (bOK)
+                    rSet.Put( SfxStringItem( SID_SUGGESTEDSAVEASNAME, sVal ) );
+            }
+            else if (aName == sDocumentService)
+            {
+                OUString aVal;
+                bool bOK = ((rProp.Value >>= aVal) && !aVal.isEmpty());
+                if (bOK)
+                    rSet.Put(SfxStringItem(SID_DOC_SERVICE, aVal));
+            }
+            else if (aName == sFilterProvider)
+            {
+                OUString aVal;
+                bool bOK = ((rProp.Value >>= aVal) && !aVal.isEmpty());
+                if (bOK)
+                    rSet.Put(SfxStringItem(SID_FILTER_PROVIDER, aVal));
+            }
+            else if (aName == sLockContentExtraction)
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for LockContentExtraction" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_LOCK_CONTENT_EXTRACTION, bVal ) );
+            }
+            else if (aName == sLockExport)
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for LockExport" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_LOCK_EXPORT, bVal ) );
+            }
+            else if (aName == sLockPrint)
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for LockPrint" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_LOCK_PRINT, bVal ) );
+            }
+            else if (aName == sLockSave)
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for LockSave" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_LOCK_SAVE, bVal ) );
+            }
+            else if (aName == sLockEditDoc)
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT( bOK, "invalid type for LockEditDoc" );
+                if (bOK)
+                    rSet.Put( SfxBoolItem( SID_LOCK_EDITDOC, bVal ) );
+            }
+            else if (aName == sReplaceable)
+            {
+                bool bVal = false;
+                bool bOK = (rProp.Value >>= bVal);
+                DBG_ASSERT(bOK, "invalid type for Replaceable");
+                if (bOK)
+                    rSet.Put(SfxBoolItem(SID_REPLACEABLE, bVal));
+            }
+#ifdef DBG_UTIL
+            else
+                --nFoundArgs;
+#endif
+        }
+    }
+    // API to raise options dialog with a specified options ab page (#i83757#)
+    else
+    {
+        // transform parameter "OptionsPageURL" of slot "OptionsTreeDialog"
+        if ( "OptionsTreeDialog" == OUString( pSlot->pUnoName, strlen(pSlot->pUnoName), RTL_TEXTENCODING_UTF8 ) )
+        {
+            auto pProp = std::find_if(rArgs.begin(), rArgs.end(),
+                [](const PropertyValue& rProp) { return rProp.Name == "OptionsPageURL"; });
+            if (pProp != rArgs.end())
+            {
+                OUString sURL;
+                if ( pProp->Value >>= sURL )
+                    rSet.Put( SfxStringItem( SID_OPTIONS_PAGEURL, sURL ) );
+            }
+        }
+    }
+#ifdef DBG_UTIL
+    if ( nFoundArgs == nCount )
+    {
+        // except for the "special" slots: assure that every argument was convertible
+        SAL_INFO( "sfx.appl", "MacroPlayer: Some properties didn't match to any formal argument for slot: "<< pSlot->pUnoName );
+    }
+#endif
+}
+
+void TransformItems( sal_uInt16 nSlotId, const SfxItemSet& rSet, uno::Sequence<beans::PropertyValue>& rArgs, const SfxSlot* pSlot )
+{
+    if ( !pSlot )
+        pSlot = SFX_SLOTPOOL().GetSlot( nSlotId );
+
+    if ( !pSlot)
+        return;
+
+    if ( nSlotId == SID_OPENURL )
+        nSlotId = SID_OPENDOC;
+    if ( nSlotId == SID_SAVEASREMOTE )
+        nSlotId = SID_SAVEASDOC;
+
+    // find number of properties to avoid permanent reallocations in the sequence
+    sal_Int32 nProps=0;
+
+#ifdef DBG_UTIL
+    // trace number of items and compare with number of properties for debugging purposes
+    sal_Int32 nItems=0;
+#endif
+
+    const SfxType *pType = pSlot->GetType();
+    if ( !pSlot->IsMode(SfxSlotMode::METHOD) )
+    {
+        // slot is a property
+        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(nSlotId);
+        if ( rSet.GetItemState( nWhich ) == SfxItemState::SET ) //???
+        {
+            sal_uInt16 nSubCount = pType->nAttribs;
+            if ( nSubCount )
+                // it's a complex property, we want it split into simple types
+                // so we expect to get as many items as we have (sub) members
+                nProps = nSubCount;
+            else
+                // simple property: we expect to get exactly one item
+                nProps++;
+        }
+        else
+        {
+            // we will not rely on the "toggle" ability of some property slots
+            SAL_WARN( "sfx", "Processing property slot without argument: " << nSlotId );
+        }
+
+#ifdef DBG_UTIL
+        nItems++;
+#endif
+    }
+    else
+    {
+        // slot is a method
+        bool bIsMediaDescriptor = isMediaDescriptor( nSlotId );
+        sal_uInt16 nFormalArgs = bIsMediaDescriptor ? nMediaArgsCount : pSlot->GetFormalArgumentCount();
+        for ( sal_uInt16 nArg=0; nArg<nFormalArgs; ++nArg )
+        {
+            // check every formal argument of the method
+            const SfxFormalArgument &rArg = bIsMediaDescriptor ? aFormalArgs[nArg] : pSlot->GetFormalArgument( nArg );
+
+            sal_uInt16 nWhich = rSet.GetPool()->GetWhich( rArg.nSlotId );
+            if ( rSet.GetItemState( nWhich ) == SfxItemState::SET ) //???
+            {
+                sal_uInt16 nSubCount = rArg.pType->nAttribs;
+                if ( nSubCount )
+                    // argument has a complex type, we want it split into simple types
+                    // so for this argument we expect to get as many items as we have (sub) members
+                    nProps += nSubCount;
+                else
+                    // argument of simple type: we expect to get exactly one item for it
+                    nProps++;
+#ifdef DBG_UTIL
+                nItems++;
+#endif
+            }
+        }
+
+        // special treatment for slots that are *not* meant to be recorded as slots (except SaveAs/To)
+        if ( bIsMediaDescriptor )
+        {
+            sal_Int32 nAdditional=0;
+            if ( rSet.GetItemState( SID_PROGRESS_STATUSBAR_CONTROL ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_INTERACTIONHANDLER ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOC_SALVAGE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_PATH ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_FILE_DIALOG ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_STANDARD_DIR ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_BLACK_LIST ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_CONTENT ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_INPUTSTREAM ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_STREAM ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_OUTPUTSTREAM ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_TEMPLATE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_OPEN_NEW_VIEW ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_FAIL_ON_WARNING ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_VIEW_ID ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_VIEW_DATA ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_FILTER_DATA ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_PLUGIN_MODE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOC_READONLY ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DDE_RECONNECT_ONLOAD ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOC_STARTPRESENTATION ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_SELECTION ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_CONTENTTYPE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_POSTDATA ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_FILLFRAME ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_CHARSET ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_TARGETNAME ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_TEMPLATE_NAME ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_TEMPLATE_REGIONNAME ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_HIDDEN ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_MINIMIZED ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_PREVIEW ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_VIEWONLY ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_EDITDOC ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_SILENT ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_JUMPMARK ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOCUMENT ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_MACROEXECMODE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_UPDATEDOCMODE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_REPAIRPACKAGE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOCINFO_TITLE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_COMPONENTDATA ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_COMPONENTCONTEXT ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOC_BASEURL ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOC_HIERARCHICALNAME ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_COPY_STREAM_IF_POSSIBLE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_NOAUTOSAVE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_MODIFYPASSWORDINFO ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_SUGGESTEDSAVEASDIR ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_ENCRYPTIONDATA ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_SUGGESTEDSAVEASNAME ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_DOC_SERVICE ) == SfxItemState::SET )
+                nAdditional++;
+            if (rSet.HasItem(SID_FILTER_PROVIDER))
+                ++nAdditional;
+            if ( rSet.GetItemState( SID_CONVERT_IMAGES ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_LOCK_CONTENT_EXTRACTION ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_LOCK_EXPORT ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_LOCK_PRINT ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_LOCK_SAVE ) == SfxItemState::SET )
+                nAdditional++;
+            if ( rSet.GetItemState( SID_LOCK_EDITDOC ) == SfxItemState::SET )
+                nAdditional++;
+            if (rSet.GetItemState(SID_REPLACEABLE) == SfxItemState::SET)
+                nAdditional++;
+
+            // consider additional arguments
+            nProps += nAdditional;
+#ifdef DBG_UTIL
+            nItems += nAdditional;
+#endif
+        }
+    }
+
+#ifdef DBG_UTIL
+    // now check the itemset: is there any item that is not convertible using the list of formal arguments
+    // or the table of additional items?!
+    if ( rSet.Count() != nItems )
+    {
+        // detect unknown item and present error message
+        const sal_uInt16 *pRanges = rSet.GetRanges();
+        while ( *pRanges )
+        {
+            sal_uInt16 nStartWhich = *pRanges++;
+            sal_uInt16 nEndWhich = *pRanges++;
+            for(sal_uInt16 nId = nStartWhich; nId <= nEndWhich; ++nId)
+            {
+                if ( rSet.GetItemState(nId) < SfxItemState::SET ) //???
+                    // not really set
+                    continue;
+
+                if ( !pSlot->IsMode(SfxSlotMode::METHOD) && nId == rSet.GetPool()->GetWhich( pSlot->GetSlotId() ) )
+                    continue;
+
+                bool bIsMediaDescriptor = isMediaDescriptor( nSlotId );
+                sal_uInt16 nFormalArgs = bIsMediaDescriptor ? nMediaArgsCount : pSlot->nArgDefCount;
+                sal_uInt16 nArg;
+                for ( nArg=0; nArg<nFormalArgs; ++nArg )
+                {
+                    const SfxFormalArgument &rArg = bIsMediaDescriptor ? aFormalArgs[nArg] : pSlot->GetFormalArgument( nArg );
+                    sal_uInt16 nWhich = rSet.GetPool()->GetWhich( rArg.nSlotId );
+                    if ( nId == nWhich )
+                        break;
+                }
+
+                if ( nArg<nFormalArgs )
+                    continue;
+
+                if ( bIsMediaDescriptor )
+                {
+                    if ( nId == SID_DOCFRAME )
+                        continue;
+                    if ( nId == SID_PROGRESS_STATUSBAR_CONTROL )
+                        continue;
+                    if ( nId == SID_INTERACTIONHANDLER )
+                        continue;
+                    if ( nId == SID_VIEW_DATA )
+                        continue;
+                    if ( nId == SID_FILTER_DATA )
+                        continue;
+                    if ( nId == SID_DOCUMENT )
+                        continue;
+                    if ( nId == SID_CONTENT )
+                        continue;
+                    if ( nId == SID_INPUTSTREAM )
+                        continue;
+                    if ( nId == SID_STREAM )
+                        continue;
+                    if ( nId == SID_OUTPUTSTREAM )
+                        continue;
+                    if ( nId == SID_POSTDATA )
+                        continue;
+                    if ( nId == SID_FILLFRAME )
+                        continue;
+                    if ( nId == SID_TEMPLATE )
+                        continue;
+                    if ( nId == SID_OPEN_NEW_VIEW )
+                        continue;
+                    if ( nId == SID_VIEW_ID )
+                        continue;
+                    if ( nId == SID_PLUGIN_MODE )
+                        continue;
+                    if ( nId == SID_DOC_READONLY )
+                        continue;
+                    if ( nId == SID_DOC_STARTPRESENTATION )
+                        continue;
+                    if ( nId == SID_SELECTION )
+                        continue;
+                    if ( nId == SID_HIDDEN )
+                        continue;
+                    if ( nId == SID_MINIMIZED )
+                        continue;
+                    if ( nId == SID_SILENT )
+                        continue;
+                    if ( nId == SID_PREVIEW )
+                        continue;
+                    if ( nId == SID_VIEWONLY )
+                        continue;
+                    if ( nId == SID_EDITDOC )
+                        continue;
+                    if ( nId == SID_TARGETNAME )
+                        continue;
+                    if ( nId == SID_DOC_SALVAGE )
+                        continue;
+                    if ( nId == SID_PATH )
+                        continue;
+                    if ( nId == SID_FILE_DIALOG )
+                        continue;
+                    if ( nId == SID_STANDARD_DIR )
+                        continue;
+                    if ( nId == SID_BLACK_LIST )
+                        continue;
+                    if ( nId == SID_CONTENTTYPE )
+                        continue;
+                    if ( nId == SID_TEMPLATE_NAME )
+                        continue;
+                    if ( nId == SID_TEMPLATE_REGIONNAME )
+                        continue;
+                    if ( nId == SID_JUMPMARK )
+                        continue;
+                    if ( nId == SID_CHARSET )
+                        continue;
+                    if ( nId == SID_MACROEXECMODE )
+                        continue;
+                    if ( nId == SID_UPDATEDOCMODE )
+                        continue;
+                    if ( nId == SID_REPAIRPACKAGE )
+                        continue;
+                    if ( nId == SID_DOCINFO_TITLE )
+                        continue;
+                    if ( nId == SID_COMPONENTDATA )
+                        continue;
+                    if ( nId == SID_COMPONENTCONTEXT )
+                        continue;
+                    if ( nId == SID_DOC_BASEURL )
+                        continue;
+                    if ( nId == SID_DOC_HIERARCHICALNAME )
+                        continue;
+                    if ( nId == SID_COPY_STREAM_IF_POSSIBLE )
+                        continue;
+                    if ( nId == SID_NOAUTOSAVE )
+                        continue;
+                    if ( nId == SID_ENCRYPTIONDATA )
+                        continue;
+                    if ( nId == SID_DOC_SERVICE )
+                        continue;
+                    if (nId == SID_FILTER_PROVIDER)
+                        continue;
+                    if ( nId == SID_CONVERT_IMAGES )
+                        continue;
+
+                    // used only internally
+                    if ( nId == SID_SAVETO )
+                        continue;
+                    if ( nId == SID_SAVEACOPYITEM )
+                        continue;
+                    if ( nId == SID_MODIFYPASSWORDINFO )
+                        continue;
+                    if ( nId == SID_SUGGESTEDSAVEASDIR )
+                        continue;
+                    if ( nId == SID_SUGGESTEDSAVEASNAME )
+                        continue;
+                    if ( nId == SID_LOCK_CONTENT_EXTRACTION )
+                        continue;
+                    if ( nId == SID_LOCK_EXPORT )
+                        continue;
+                    if ( nId == SID_LOCK_PRINT )
+                        continue;
+                    if ( nId == SID_LOCK_SAVE )
+                        continue;
+                    if ( nId == SID_LOCK_EDITDOC )
+                        continue;
+                    if (nId == SID_REPLACEABLE)
+                        continue;
+               }
+
+                OString aDbg = "Unknown item detected: " + OString::number(static_cast<sal_Int32>(nId));
+                DBG_ASSERT(nArg<nFormalArgs, aDbg.getStr());
+            }
+        }
+    }
+#endif
+
+    if ( !nProps )
+        return;
+
+    // convert every item into a property
+    uno::Sequence<beans::PropertyValue> aSequ(nProps);
+    beans::PropertyValue *pValue = aSequ.getArray();
+
+    sal_Int32 nActProp=0;
+    if ( !pSlot->IsMode(SfxSlotMode::METHOD) )
+    {
+        // slot is a property
+        sal_uInt16 nWhich = rSet.GetPool()->GetWhich(nSlotId);
+        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
+        const SfxPoolItem* pItem = rSet.GetItem<SfxPoolItem>(nWhich, false);
+        if ( pItem ) //???
+        {
+            sal_uInt16 nSubCount = pType->nAttribs;
+            if ( !nSubCount )
+            {
+                pValue[nActProp].Name = OUString::createFromAscii(pSlot->pUnoName) ;
+                if ( !pItem->QueryValue( pValue[nActProp].Value ) )
+                {
+                    SAL_WARN( "sfx", "Item not convertible: " << nSlotId );
+                }
+            }
+            else
+            {
+                // complex type, add a property value for every member of the struct
+                for ( sal_uInt16 n=1; n<=nSubCount; ++n )
+                {
+                    sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(pType->aAttrib[n-1].nAID));
+                    if ( bConvertTwips )
+                        nSubId |= CONVERT_TWIPS;
+
+                    DBG_ASSERT(( pType->aAttrib[n-1].nAID ) <= 127, "Member ID out of range" );
+                    pValue[nActProp].Name = OUString::createFromAscii( pSlot->pUnoName ) +
+                        "." +
+                        OUString::createFromAscii( pType->aAttrib[n-1].pName );
+                    if ( !pItem->QueryValue( pValue[nActProp++].Value, nSubId ) )
+                    {
+                        SAL_WARN( "sfx", "Sub item " << pType->aAttrib[n-1].nAID
+                                    << " not convertible in slot: " << nSlotId );
+                    }
+                }
+            }
+        }
+
+        rArgs = aSequ;
+        return;
+    }
+
+    // slot is a method
+    sal_uInt16 nFormalArgs = pSlot->GetFormalArgumentCount();
+    for ( sal_uInt16 nArg=0; nArg<nFormalArgs; ++nArg )
+    {
+        const SfxFormalArgument &rArg = pSlot->GetFormalArgument( nArg );
+        sal_uInt16 nWhich = rSet.GetPool()->GetWhich( rArg.nSlotId );
+        bool bConvertTwips = ( rSet.GetPool()->GetMetric( nWhich ) == MapUnit::MapTwip );
+        const SfxPoolItem* pItem = rSet.GetItem<SfxPoolItem>(nWhich, false);
+        if ( pItem ) //???
+        {
+            sal_uInt16 nSubCount = rArg.pType->nAttribs;
+            if ( !nSubCount )
+            {
+                pValue[nActProp].Name = OUString::createFromAscii( rArg.pName ) ;
+                if ( !pItem->QueryValue( pValue[nActProp++].Value ) )
+                {
+                    SAL_WARN( "sfx", "Item not convertible: " << rArg.nSlotId );
+                }
+            }
+            else
+            {
+                // complex type, add a property value for every member of the struct
+                for ( sal_uInt16 n = 1; n <= nSubCount; ++n )
+                {
+                    sal_uInt8 nSubId = static_cast<sal_uInt8>(static_cast<sal_Int8>(rArg.pType->aAttrib[n-1].nAID));
+                    if ( bConvertTwips )
+                        nSubId |= CONVERT_TWIPS;
+
+                    DBG_ASSERT((rArg.pType->aAttrib[n-1].nAID) <= 127, "Member ID out of range" );
+                    pValue[nActProp].Name = OUString::createFromAscii( rArg.pName ) +
+                        "." +
+                        OUString::createFromAscii( rArg.pType->aAttrib[n-1].pName ) ;
+                    if ( !pItem->QueryValue( pValue[nActProp++].Value, nSubId ) )
+                    {
+                        SAL_WARN( "sfx", "Sub item "
+                                    << rArg.pType->aAttrib[n-1].nAID
+                                    << " not convertible in slot: "
+                                    << rArg.nSlotId );
+                    }
+                }
+            }
+        }
+    }
+
+    if ( nSlotId == SID_OPENDOC || nSlotId == SID_EXPORTDOC || nSlotId == SID_SAVEASDOC ||  nSlotId == SID_SAVEDOC ||
+         nSlotId == SID_SAVETO || nSlotId == SID_EXPORTDOCASPDF || nSlotId == SID_DIRECTEXPORTDOCASPDF ||
+         nSlotId == SID_EXPORTDOCASEPUB || nSlotId == SID_DIRECTEXPORTDOCASEPUB ||
+         nSlotId == SID_REDACTDOC || nSlotId == SID_AUTOREDACTDOC || nSlotId == SID_SAVEACOPY )
+    {
+        const SfxPoolItem *pItem=nullptr;
+        if ( rSet.GetItemState( SID_COMPONENTDATA, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sComponentData;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_COMPONENTCONTEXT, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sComponentContext;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_PROGRESS_STATUSBAR_CONTROL, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sStatusInd;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_INTERACTIONHANDLER, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sInteractionHdl;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_VIEW_DATA, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sViewData;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_FILTER_DATA, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sFilterData;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_DOCUMENT, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sModel;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_CONTENT, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sUCBContent;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_INPUTSTREAM, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sInputStream;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_STREAM, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sStream;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_OUTPUTSTREAM, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sOutputStream;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_POSTDATA, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sPostData;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_FILLFRAME, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sFrame;
+            if ( auto pUsrAnyItem = dynamic_cast< const SfxUnoAnyItem *>( pItem ) )
+            {
+                OSL_FAIL( "TransformItems: transporting an XFrame via an SfxUnoAnyItem is not deprecated!" );
+                pValue[nActProp++].Value = pUsrAnyItem->GetValue();
+            }
+            else if ( auto pUnoFrameItem = dynamic_cast< const SfxUnoFrameItem *>( pItem ) )
+                pValue[nActProp++].Value <<= pUnoFrameItem->GetFrame();
+            else
+                OSL_FAIL( "TransformItems: invalid item type for SID_FILLFRAME!" );
+        }
+        if ( rSet.GetItemState( SID_TEMPLATE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sAsTemplate;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_OPEN_NEW_VIEW, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sOpenNewView;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_FAIL_ON_WARNING, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sFailOnWarning;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_VIEW_ID, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sViewId;
+            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+        }
+        if ( rSet.GetItemState( SID_PLUGIN_MODE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sPluginMode;
+            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+        }
+        if ( rSet.GetItemState( SID_DOC_READONLY, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sReadOnly;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_DDE_RECONNECT_ONLOAD, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sDdeReconnect;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_DOC_STARTPRESENTATION, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sStartPresentation;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_SELECTION, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sSelectionOnly;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_HIDDEN, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sHidden;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_MINIMIZED, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sMinimized;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_SILENT, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sSilent;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_PREVIEW, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sPreview;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_VIEWONLY, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sViewOnly;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_EDITDOC, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sDontEdit;
+            pValue[nActProp++].Value <<= !static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_FILE_DIALOG, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sUseSystemDialog;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_STANDARD_DIR, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sStandardDir;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_BLACK_LIST, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sBlackList;
+
+            css::uno::Sequence< OUString > aList;
+            static_cast<const SfxStringListItem*>(pItem)->GetStringList( aList );
+            pValue[nActProp++].Value <<= aList ;
+        }
+        if ( rSet.GetItemState( SID_TARGETNAME, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sFrameName;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_DOC_SALVAGE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sSalvagedFile;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_PATH, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sFolderName;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_CONTENTTYPE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sMediaType;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_TEMPLATE_NAME, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sTemplateName;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_TEMPLATE_REGIONNAME, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sTemplateRegionName;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_JUMPMARK, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sJumpMark;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+
+        if ( rSet.GetItemState( SID_CHARSET, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sCharacterSet;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_MACROEXECMODE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sMacroExecMode;
+            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+        }
+        if ( rSet.GetItemState( SID_UPDATEDOCMODE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sUpdateDocMode;
+            pValue[nActProp++].Value <<= static_cast<sal_Int16>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+        }
+        if ( rSet.GetItemState( SID_REPAIRPACKAGE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sRepairPackage;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
+        }
+        if ( rSet.GetItemState( SID_DOCINFO_TITLE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sDocumentTitle;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_DOC_BASEURL, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sDocumentBaseURL;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_DOC_HIERARCHICALNAME, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sHierarchicalDocumentName;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_COPY_STREAM_IF_POSSIBLE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sCopyStreamIfPossible;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_NOAUTOSAVE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sNoAutoSave;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
+        }
+        if ( rSet.GetItemState( SID_MODIFYPASSWORDINFO, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sModifyPasswordInfo;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_ENCRYPTIONDATA, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sEncryptionData;
+            pValue[nActProp++].Value = static_cast<const SfxUnoAnyItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_SUGGESTEDSAVEASDIR, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sSuggestedSaveAsDir;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_SUGGESTEDSAVEASNAME, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sSuggestedSaveAsName;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_DOC_SERVICE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sDocumentService;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if (rSet.HasItem(SID_FILTER_PROVIDER, &pItem))
+        {
+            pValue[nActProp].Name = sFilterProvider;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if (rSet.HasItem(SID_CONVERT_IMAGES, &pItem))
+        {
+            pValue[nActProp].Name = sImageFilter;
+            pValue[nActProp++].Value <<= static_cast<const SfxStringItem*>(pItem)->GetValue();
+        }
+        if ( rSet.GetItemState( SID_LOCK_CONTENT_EXTRACTION, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sLockContentExtraction;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
+        }
+        if ( rSet.GetItemState( SID_LOCK_EXPORT, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sLockExport;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
+        }
+        if ( rSet.GetItemState( SID_LOCK_PRINT, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sLockPrint;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
+        }
+        if ( rSet.GetItemState( SID_LOCK_SAVE, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sLockSave;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue() ;
+        }
+        if ( rSet.GetItemState( SID_LOCK_EDITDOC, false, &pItem ) == SfxItemState::SET )
+        {
+            pValue[nActProp].Name = sLockEditDoc;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+        if (rSet.GetItemState(SID_REPLACEABLE, false, &pItem) == SfxItemState::SET)
+        {
+            pValue[nActProp].Name = sReplaceable;
+            pValue[nActProp++].Value <<= static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+    }
+
+    rArgs = aSequ;
+}
+
+void SAL_CALL FilterOptionsContinuation::setFilterOptions(
+                const uno::Sequence<beans::PropertyValue>& rProps )
+{
+    rProperties = rProps;
+}
+
+uno::Sequence< beans::PropertyValue > SAL_CALL
+    FilterOptionsContinuation::getFilterOptions()
+{
+    return rProperties;
+}
+
+
+RequestFilterOptions::RequestFilterOptions( uno::Reference< frame::XModel > const & rModel,
+                              const uno::Sequence< beans::PropertyValue >& rProperties )
+{
+    uno::Reference< uno::XInterface > temp2;
+    document::FilterOptionsRequest aOptionsRequest( OUString(),
+                                                    temp2,
+                                                    rModel,
+                                                    rProperties );
+
+    m_aRequest <<= aOptionsRequest;
+
+    m_xAbort  = new comphelper::OInteractionAbort;
+    m_xOptions = new FilterOptionsContinuation;
+}
+
+uno::Any SAL_CALL RequestFilterOptions::getRequest()
+{
+    return m_aRequest;
+}
+
+uno::Sequence< uno::Reference< task::XInteractionContinuation > >
+    SAL_CALL RequestFilterOptions::getContinuations()
+{
+    return { m_xAbort.get(), m_xOptions.get() };
+}
+
+
+class RequestPackageReparation_Impl : public ::cppu::WeakImplHelper< task::XInteractionRequest >
+{
+    uno::Any m_aRequest;
+    rtl::Reference<comphelper::OInteractionApprove> m_xApprove;
+    rtl::Reference<comphelper::OInteractionDisapprove>  m_xDisapprove;
+
+public:
+    explicit RequestPackageReparation_Impl( const OUString& aName );
+    bool    isApproved() const;
+    virtual uno::Any SAL_CALL getRequest() override;
+    virtual uno::Sequence< uno::Reference< task::XInteractionContinuation > > SAL_CALL getContinuations() override;
+};
+
+RequestPackageReparation_Impl::RequestPackageReparation_Impl( const OUString& aName )
+{
+    uno::Reference< uno::XInterface > temp2;
+    document::BrokenPackageRequest aBrokenPackageRequest( OUString(), temp2, aName );
+    m_aRequest <<= aBrokenPackageRequest;
+    m_xApprove = new comphelper::OInteractionApprove;
+    m_xDisapprove = new comphelper::OInteractionDisapprove;
+}
+
+bool RequestPackageReparation_Impl::isApproved() const
+{
+    return m_xApprove->wasSelected();
+}
+
+uno::Any SAL_CALL RequestPackageReparation_Impl::getRequest()
+{
+    return m_aRequest;
+}
+
+uno::Sequence< uno::Reference< task::XInteractionContinuation > >
+    SAL_CALL RequestPackageReparation_Impl::getContinuations()
+{
+    return { m_xApprove.get(), m_xDisapprove.get() };
+}
+
+RequestPackageReparation::RequestPackageReparation( const OUString& aName )
+    : mxImpl(new RequestPackageReparation_Impl( aName ))
+{
+}
+
+RequestPackageReparation::~RequestPackageReparation()
+{
+}
+
+bool RequestPackageReparation::isApproved() const
+{
+    return mxImpl->isApproved();
+}
+
+css::uno::Reference < task::XInteractionRequest > RequestPackageReparation::GetRequest()
+{
+    return mxImpl.get();
+}
+
+
+class NotifyBrokenPackage_Impl : public ::cppu::WeakImplHelper< task::XInteractionRequest >
+{
+    uno::Any m_aRequest;
+    rtl::Reference<comphelper::OInteractionAbort>  m_xAbort;
+
+public:
+    explicit NotifyBrokenPackage_Impl(const OUString& rName);
+    virtual uno::Any SAL_CALL getRequest() override;
+    virtual uno::Sequence< uno::Reference< task::XInteractionContinuation > > SAL_CALL getContinuations() override;
+};
+
+NotifyBrokenPackage_Impl::NotifyBrokenPackage_Impl( const OUString& aName )
+{
+    uno::Reference< uno::XInterface > temp2;
+    document::BrokenPackageRequest aBrokenPackageRequest( OUString(), temp2, aName );
+    m_aRequest <<= aBrokenPackageRequest;
+    m_xAbort = new comphelper::OInteractionAbort;
+}
+
+uno::Any SAL_CALL NotifyBrokenPackage_Impl::getRequest()
+{
+    return m_aRequest;
+}
+
+uno::Sequence< uno::Reference< task::XInteractionContinuation > >
+    SAL_CALL NotifyBrokenPackage_Impl::getContinuations()
+{
+    return { m_xAbort.get() };
+}
+
+NotifyBrokenPackage::NotifyBrokenPackage( const OUString& aName )
+    : mxImpl(new NotifyBrokenPackage_Impl( aName ))
+{
+}
+
+NotifyBrokenPackage::~NotifyBrokenPackage()
+{
+}
+
+css::uno::Reference < task::XInteractionRequest > NotifyBrokenPackage::GetRequest()
+{
+    return mxImpl.get();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/childwin.cxx b/sfx2/source/appl/childwin.cxx
new file mode 100644
index 000000000..9c2ee6687
--- /dev/null
+++ b/sfx2/source/appl/childwin.cxx
@@ -0,0 +1,739 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <unotools/viewoptions.hxx>
+#include <com/sun/star/frame/XController.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/util/XCloseable.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <comphelper/string.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+
+#include <vcl/svapp.hxx>
+#include <sfx2/childwin.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/dockwin.hxx>
+#include <sfx2/dispatch.hxx>
+#include <workwin.hxx>
+#include <childwinimpl.hxx>
+
+static const sal_uInt16 nVersion = 2;
+
+SfxChildWinFactory::SfxChildWinFactory( SfxChildWinCtor pTheCtor, sal_uInt16 nID,
+        sal_uInt16 n )
+    : pCtor(pTheCtor)
+    , nId( nID )
+    , nPos(n)
+{}
+
+SfxChildWinFactory::~SfxChildWinFactory()
+{
+}
+
+struct SfxChildWindow_Impl
+{
+    css::uno::Reference< css::frame::XFrame >             xFrame;
+    css::uno::Reference< css::lang::XEventListener >      xListener;
+    SfxChildWinFactory* pFact;
+    bool                bHideNotDelete;
+    bool                bVisible;
+    bool                bWantsFocus;
+    SfxModule*          pContextModule;
+    SfxWorkWindow*      pWorkWin;
+};
+
+namespace {
+
+class DisposeListener : public ::cppu::WeakImplHelper< css::lang::XEventListener >
+{
+    public:
+        DisposeListener( SfxChildWindow*      pOwner ,
+                         SfxChildWindow_Impl* pData  )
+            :   m_pOwner( pOwner )
+            ,   m_pData ( pData  )
+        {}
+
+        virtual void SAL_CALL disposing( const css::lang::EventObject& aSource ) override
+        {
+            css::uno::Reference< css::lang::XEventListener > xSelfHold( this );
+
+            css::uno::Reference< css::lang::XComponent > xComp( aSource.Source, css::uno::UNO_QUERY );
+            if( xComp.is() )
+                xComp->removeEventListener( this );
+
+            if( !m_pOwner || !m_pData )
+                return;
+
+            m_pData->xListener.clear();
+
+            if ( m_pData->pWorkWin )
+            {
+                // m_pOwner and m_pData will be killed
+                m_pData->xFrame.clear();
+                m_pData->pWorkWin->GetBindings().Execute( m_pOwner->GetType() );
+            }
+            else
+            {
+                delete m_pOwner;
+            }
+
+            m_pOwner = nullptr;
+            m_pData  = nullptr;
+        }
+
+    private:
+        SfxChildWindow*      m_pOwner;
+        SfxChildWindow_Impl* m_pData ;
+};
+
+}
+
+bool GetPosSizeFromString( const OUString& rStr, Point& rPos, Size& rSize )
+{
+    if ( comphelper::string::getTokenCount(rStr, '/') != 4 )
+        return false;
+
+    sal_Int32 nIdx = 0;
+    rPos.setX( rStr.getToken(0, '/', nIdx).toInt32() );
+    rPos.setY( rStr.getToken(0, '/', nIdx).toInt32() );
+    rSize.setWidth( rStr.getToken(0, '/', nIdx).toInt32() );
+    rSize.setHeight( rStr.getToken(0, '/', nIdx).toInt32() );
+
+    // negative sizes are invalid
+    return !(rSize.Width() < 0 || rSize.Height() < 0);
+}
+
+bool GetSplitSizeFromString( const OUString& rStr, Size& rSize )
+{
+    sal_Int32 nIndex = rStr.indexOf( ',' );
+    if ( nIndex != -1 )
+    {
+        OUString aStr = rStr.copy( nIndex+1 );
+
+        sal_Int32 nCount = comphelper::string::getTokenCount(aStr, ';');
+        if ( nCount != 2 )
+            return false;
+
+        sal_Int32 nIdx{ 0 };
+        rSize.setWidth( aStr.getToken(0, ';', nIdx ).toInt32() );
+        rSize.setHeight( aStr.getToken(0, ';', nIdx ).toInt32() );
+
+        // negative sizes are invalid
+        return !(rSize.Width() < 0 || rSize.Height() < 0);
+    }
+
+    return false;
+}
+
+
+SfxChildWindow::SfxChildWindow(vcl::Window *pParentWindow, sal_uInt16 nId)
+    : pParent(pParentWindow)
+    , nType(nId)
+    , eChildAlignment(SfxChildAlignment::NOALIGNMENT)
+    , pImpl(new SfxChildWindow_Impl)
+{
+    pImpl->pFact = nullptr;
+    pImpl->bHideNotDelete = false;
+    pImpl->bWantsFocus = true;
+    pImpl->bVisible = true;
+    pImpl->pContextModule = nullptr;
+    pImpl->pWorkWin = nullptr;
+
+    pContext = nullptr;
+}
+
+void SfxChildWindow::Destroy()
+{
+    if ( GetFrame().is() )
+    {
+        ClearWorkwin();
+        try
+        {
+            css::uno::Reference < css::util::XCloseable > xClose( GetFrame(), css::uno::UNO_QUERY );
+            if ( xClose.is() )
+                xClose->close( true );
+            else
+                GetFrame()->dispose();
+        }
+        catch (const css::uno::Exception&)
+        {
+        }
+    }
+    else
+        delete this;
+}
+
+void SfxChildWindow::ClearWorkwin()
+{
+    if (pImpl->pWorkWin)
+    {
+        if (pImpl->pWorkWin->GetActiveChild_Impl() == pWindow)
+            pImpl->pWorkWin->SetActiveChild_Impl(nullptr);
+        pImpl->pWorkWin = nullptr;
+    }
+}
+
+SfxChildWindow::~SfxChildWindow()
+{
+    pContext.reset();
+    ClearWorkwin();
+    if (xController)
+    {
+        xController->ChildWinDispose();
+        xController.reset();
+    }
+    pWindow.disposeAndClear();
+}
+
+std::unique_ptr<SfxChildWindow> SfxChildWindow::CreateChildWindow( sal_uInt16 nId,
+        vcl::Window *pParent, SfxBindings* pBindings, SfxChildWinInfo const & rInfo)
+{
+    std::unique_ptr<SfxChildWindow> pChild;
+    SfxChildWinFactory* pFact=nullptr;
+    SystemWindowFlags nOldMode = Application::GetSystemWindowMode();
+
+    // First search for ChildWindow in SDT; Overlay windows are realized
+    // by using ChildWindowContext
+    SfxApplication *pApp = SfxGetpApp();
+    {
+        SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
+        for ( size_t nFactory = 0; nFactory < rFactories.size(); ++nFactory )
+        {
+            pFact = &rFactories[nFactory];
+            if ( pFact->nId == nId )
+            {
+                SfxChildWinInfo& rFactInfo = pFact->aInfo;
+                if ( rInfo.bVisible )
+                {
+                    if ( pBindings )
+                        pBindings->ENTERREGISTRATIONS();
+                    SfxChildWinInfo aInfo = rFactInfo;
+                    Application::SetSystemWindowMode( SystemWindowFlags::NOAUTOMODE );
+                    pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo );
+                    Application::SetSystemWindowMode( nOldMode );
+                    if ( pBindings )
+                        pBindings->LEAVEREGISTRATIONS();
+                }
+
+                break;
+            }
+        }
+    }
+
+    SfxDispatcher *pDisp = pBindings ? pBindings->GetDispatcher_Impl() : nullptr;
+    SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) : nullptr;
+    if (!pChild && pMod)
+    {
+        SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
+        if ( pFactories )
+        {
+            SfxChildWinFactArr_Impl &rFactories = *pFactories;
+            for ( size_t nFactory = 0; nFactory < rFactories.size(); ++nFactory )
+            {
+                pFact = &rFactories[nFactory];
+                if ( pFact->nId == nId )
+                {
+                    SfxChildWinInfo& rFactInfo = pFact->aInfo;
+                    if ( rInfo.bVisible )
+                    {
+                        if ( pBindings )
+                            pBindings->ENTERREGISTRATIONS();
+                        SfxChildWinInfo aInfo = rFactInfo;
+                        Application::SetSystemWindowMode( SystemWindowFlags::NOAUTOMODE );
+                        pChild = pFact->pCtor( pParent, nId, pBindings, &aInfo );
+                        Application::SetSystemWindowMode( nOldMode );
+                        if ( pBindings )
+                            pBindings->LEAVEREGISTRATIONS();
+                    }
+
+                    break;
+                }
+            }
+        }
+    }
+
+    if ( pChild )
+        pChild->SetFactory_Impl( pFact );
+
+    DBG_ASSERT(pFact && (pChild || !rInfo.bVisible), "ChildWindow-Typ not registered!");
+
+    if (pChild && (!pChild->pWindow && !pChild->xController))
+    {
+        pChild.reset();
+        SAL_INFO("sfx.appl", "ChildWindow has no Window!");
+    }
+
+    return pChild;
+}
+
+
+void SfxChildWindow::SaveStatus(const SfxChildWinInfo& rInfo)
+{
+    sal_uInt16 nID = GetType();
+
+    OUString aInfoVisible = rInfo.bVisible ? OUString("V") : OUString("H");
+
+    OUString aWinData = "V"
+                      + OUString::number(static_cast<sal_Int32>(nVersion))
+                      + ","
+                      + aInfoVisible
+                      + ","
+                      + OUString::number(static_cast<sal_Int32>(rInfo.nFlags));
+
+    if ( !rInfo.aExtraString.isEmpty() )
+        aWinData += "," + rInfo.aExtraString;
+
+    OUString sName(OUString::number(nID));
+    //Try and save window state per-module, e.g. sidebar on in one application
+    //but off in another
+    if (!rInfo.aModule.isEmpty())
+        sName = rInfo.aModule + "/" + sName;
+    SvtViewOptions aWinOpt(EViewType::Window, sName);
+    aWinOpt.SetWindowState(OStringToOUString(rInfo.aWinState, RTL_TEXTENCODING_UTF8));
+
+    css::uno::Sequence < css::beans::NamedValue > aSeq
+        { { "Data", css::uno::makeAny(aWinData) } };
+    aWinOpt.SetUserData( aSeq );
+
+    // ... but save status at runtime!
+    pImpl->pFact->aInfo = rInfo;
+}
+
+void SfxChildWindow::SetAlignment(SfxChildAlignment eAlign)
+{
+    eChildAlignment = eAlign;
+}
+
+SfxChildWinInfo SfxChildWindow::GetInfo() const
+{
+    SfxChildWinInfo aInfo(pImpl->pFact->aInfo);
+    if (xController)
+    {
+        weld::Dialog* pDialog = xController->getDialog();
+        aInfo.aPos  = pDialog->get_position();
+        aInfo.aSize = pDialog->get_size();
+        WindowStateMask nMask = WindowStateMask::Pos | WindowStateMask::State;
+        if (pDialog->get_resizable())
+            nMask |= WindowStateMask::Width | WindowStateMask::Height;
+        aInfo.aWinState = pDialog->get_window_state(nMask);
+    }
+    else if (pWindow)
+    {
+        aInfo.aPos  = pWindow->GetPosPixel();
+        aInfo.aSize = pWindow->GetSizePixel();
+        if ( pWindow->IsSystemWindow() )
+        {
+            WindowStateMask nMask = WindowStateMask::Pos | WindowStateMask::State;
+            if ( pWindow->GetStyle() & WB_SIZEABLE )
+                nMask |= WindowStateMask::Width | WindowStateMask::Height;
+            aInfo.aWinState = static_cast<SystemWindow*>(pWindow.get())->GetWindowState( nMask );
+        }
+        else if (DockingWindow* pDockingWindow = dynamic_cast<DockingWindow*>(pWindow.get()))
+        {
+            if (pDockingWindow->GetFloatingWindow())
+                aInfo.aWinState = pDockingWindow->GetFloatingWindow()->GetWindowState();
+            else if (SfxDockingWindow* pSfxDockingWindow = dynamic_cast<SfxDockingWindow*>(pDockingWindow))
+            {
+                SfxChildWinInfo aTmpInfo;
+                pSfxDockingWindow->FillInfo( aTmpInfo );
+                aInfo.aExtraString = aTmpInfo.aExtraString;
+            }
+        }
+    }
+
+    aInfo.bVisible = pImpl->bVisible;
+    aInfo.nFlags = SfxChildWindowFlags::NONE;
+    return aInfo;
+}
+
+sal_uInt16 SfxChildWindow::GetPosition() const
+{
+    return pImpl->pFact->nPos;
+}
+
+void SfxChildWindow::InitializeChildWinFactory_Impl(sal_uInt16 nId, SfxChildWinInfo& rInfo)
+{
+    // load configuration
+
+    std::unique_ptr<SvtViewOptions> xWinOpt;
+    // first see if a module specific id exists
+    if (rInfo.aModule.getLength())
+        xWinOpt.reset(new SvtViewOptions(EViewType::Window, rInfo.aModule + "/" + OUString::number(nId)));
+
+    // if not then try the generic id
+    if (!xWinOpt || !xWinOpt->Exists())
+        xWinOpt.reset(new SvtViewOptions(EViewType::Window, OUString::number(nId)));
+
+    if (xWinOpt->Exists() && xWinOpt->HasVisible() )
+        rInfo.bVisible  = xWinOpt->IsVisible(); // set state from configuration. Can be overwritten by UserData, see below
+
+    css::uno::Sequence < css::beans::NamedValue > aSeq = xWinOpt->GetUserData();
+
+    OUString aTmp;
+    if ( aSeq.hasElements() )
+        aSeq[0].Value >>= aTmp;
+
+    OUString aWinData( aTmp );
+    rInfo.aWinState = OUStringToOString(xWinOpt->GetWindowState(), RTL_TEXTENCODING_UTF8);
+
+    if ( aWinData.isEmpty() )
+        return;
+
+    // Search for version ID
+    if ( aWinData[0] != 0x0056 ) // 'V' = 56h
+        // A version ID, so do not use
+        return;
+
+    // Delete 'V'
+    aWinData = aWinData.copy(1);
+
+    // Read version
+    char cToken = ',';
+    sal_Int32 nPos = aWinData.indexOf( cToken );
+    sal_uInt16 nActVersion = static_cast<sal_uInt16>(aWinData.copy( 0, nPos + 1 ).toInt32());
+    if ( nActVersion != nVersion )
+        return;
+
+    aWinData = aWinData.copy(nPos+1);
+
+    // Load Visibility: is coded as a char
+    rInfo.bVisible = (aWinData[0] == 0x0056); // 'V' = 56h
+    aWinData = aWinData.copy(1);
+    nPos = aWinData.indexOf( cToken );
+    if (nPos == -1)
+        return;
+
+    sal_Int32 nNextPos = aWinData.indexOf( cToken, 2 );
+    if ( nNextPos != -1 )
+    {
+        // there is extra information
+        rInfo.nFlags = static_cast<SfxChildWindowFlags>(static_cast<sal_uInt16>(aWinData.copy( nPos+1, nNextPos - nPos - 1 ).toInt32()));
+        aWinData = aWinData.replaceAt( nPos, nNextPos-nPos+1, "" );
+        rInfo.aExtraString = aWinData;
+    }
+    else
+        rInfo.nFlags = static_cast<SfxChildWindowFlags>(static_cast<sal_uInt16>(aWinData.copy( nPos+1 ).toInt32()));
+}
+
+void SfxChildWindow::CreateContext( sal_uInt16 nContextId, SfxBindings& rBindings )
+{
+    std::unique_ptr<SfxChildWindowContext> pCon;
+    SfxChildWinFactory* pFact=nullptr;
+    SfxApplication *pApp = SfxGetpApp();
+    SfxDispatcher *pDisp = rBindings.GetDispatcher_Impl();
+    SfxModule *pMod = pDisp ? SfxModule::GetActiveModule( pDisp->GetFrame() ) :nullptr;
+    if ( pMod )
+    {
+        SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
+        if ( pFactories )
+        {
+            SfxChildWinFactArr_Impl &rFactories = *pFactories;
+            for ( size_t nFactory = 0; nFactory < rFactories.size(); ++nFactory )
+            {
+                pFact = &rFactories[nFactory];
+                if ( pFact->nId == GetType() )
+                {
+                    DBG_ASSERT( pFact->pArr, "No context registered!" );
+                    if ( !pFact->pArr )
+                        break;
+
+                    for ( size_t n=0; n<pFact->pArr->size(); ++n )
+                    {
+                        SfxChildWinContextFactory *pConFact = &(*pFact->pArr)[n];
+                        rBindings.ENTERREGISTRATIONS();
+                        if ( pConFact->nContextId == nContextId )
+                        {
+                            SfxChildWinInfo aInfo = pFact->aInfo;
+                            pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo );
+                            pCon->nContextId = pConFact->nContextId;
+                            pImpl->pContextModule = pMod;
+                        }
+                        rBindings.LEAVEREGISTRATIONS();
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    if ( !pCon )
+    {
+        SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
+        for ( size_t nFactory = 0; nFactory < rFactories.size(); ++nFactory )
+        {
+            pFact = &rFactories[nFactory];
+            if ( pFact->nId == GetType() )
+            {
+                DBG_ASSERT( pFact->pArr, "No context registered!" );
+                if ( !pFact->pArr )
+                    break;
+
+                for ( size_t n=0; n<pFact->pArr->size(); ++n )
+                {
+                    SfxChildWinContextFactory *pConFact = &(*pFact->pArr)[n];
+                    rBindings.ENTERREGISTRATIONS();
+                    if ( pConFact->nContextId == nContextId )
+                    {
+                        SfxChildWinInfo aInfo = pFact->aInfo;
+                        pCon = pConFact->pCtor( GetWindow(), &rBindings, &aInfo );
+                        pCon->nContextId = pConFact->nContextId;
+                        pImpl->pContextModule = nullptr;
+                    }
+                    rBindings.LEAVEREGISTRATIONS();
+                }
+                break;
+            }
+        }
+    }
+
+    if ( !pCon )
+    {
+        OSL_FAIL( "No suitable context found! ");
+        return;
+    }
+
+    pContext = std::move(pCon);
+    pContext->GetWindow()->SetSizePixel( pWindow->GetOutputSizePixel() );
+    pContext->GetWindow()->Show();
+}
+
+SfxChildWindowContext::SfxChildWindowContext( sal_uInt16 nId )
+    : nContextId( nId )
+{
+}
+
+SfxChildWindowContext::~SfxChildWindowContext()
+{
+    pWindow.disposeAndClear();
+}
+
+FloatingWindow* SfxChildWindowContext::GetFloatingWindow(vcl::Window *pParent)
+{
+    if (pParent->GetType() == WindowType::DOCKINGWINDOW || pParent->GetType() == WindowType::TOOLBOX)
+    {
+        return static_cast<DockingWindow*>(pParent)->GetFloatingWindow();
+    }
+    if (pParent->GetType() == WindowType::FLOATINGWINDOW)
+    {
+        return static_cast<FloatingWindow*>(pParent);
+    }
+    return nullptr;
+}
+
+void SfxChildWindow::SetFactory_Impl( SfxChildWinFactory *pF )
+{
+    pImpl->pFact = pF;
+}
+
+void SfxChildWindow::SetHideNotDelete( bool bOn )
+{
+    pImpl->bHideNotDelete = bOn;
+}
+
+bool SfxChildWindow::IsHideNotDelete() const
+{
+    return pImpl->bHideNotDelete;
+}
+
+void SfxChildWindow::SetWantsFocus( bool bSet )
+{
+    pImpl->bWantsFocus = bSet;
+}
+
+bool SfxChildWindow::WantsFocus() const
+{
+    return pImpl->bWantsFocus;
+}
+
+bool SfxChildWinInfo::GetExtraData_Impl
+(
+    SfxChildAlignment   *pAlign
+)   const
+{
+    // invalid?
+    if ( aExtraString.isEmpty() )
+        return false;
+    OUString aStr;
+    sal_Int32 nPos = aExtraString.indexOf("AL:");
+    if ( nPos == -1 )
+        return false;
+
+    // Try to read the alignment string "ALIGN :(...)", but if
+    // it is not present, then use an older version
+    sal_Int32 n1 = aExtraString.indexOf('(', nPos);
+    if ( n1 != -1 )
+    {
+        sal_Int32 n2 = aExtraString.indexOf(')', n1);
+        if ( n2 != -1 )
+        {
+            // Cut out Alignment string
+            aStr = aExtraString.copy(nPos, n2 - nPos + 1);
+            aStr = aStr.replaceAt(nPos, n1-nPos+1, "");
+        }
+    }
+
+    // First extract the Alignment
+    if ( aStr.isEmpty() )
+        return false;
+    if ( pAlign )
+        *pAlign = static_cast<SfxChildAlignment>(static_cast<sal_uInt16>(aStr.toInt32()));
+
+    // then the LastAlignment
+    nPos = aStr.indexOf(',');
+    if ( nPos == -1 )
+        return false;
+    aStr = aStr.copy(nPos+1);
+
+    // Then the splitting information
+    nPos = aStr.indexOf(',');
+    if ( nPos == -1 )
+        // No docking in a Splitwindow
+        return true;
+    aStr = aStr.copy(nPos+1);
+    Point aChildPos;
+    Size aChildSize;
+    return GetPosSizeFromString( aStr, aChildPos, aChildSize );
+}
+
+bool SfxChildWindow::IsVisible() const
+{
+    return pImpl->bVisible;
+}
+
+void SfxChildWindow::SetVisible_Impl( bool bVis )
+{
+    pImpl->bVisible = bVis;
+}
+
+void SfxChildWindow::Hide()
+{
+    if (xController)
+        xController->EndDialog();
+    else
+        pWindow->Hide();
+}
+
+void SfxChildWindow::Show( ShowFlags nFlags )
+{
+    if (xController)
+    {
+        if (!xController->getDialog()->get_visible())
+        {
+            weld::DialogController::runAsync(xController,
+                [this](sal_Int32 /*nResult*/){ xController->Close(); });
+        }
+    }
+    else
+        pWindow->Show(true, nFlags);
+}
+
+vcl::Window* SfxChildWindow::GetContextWindow( SfxModule const *pModule ) const
+{
+    return pModule == pImpl->pContextModule && pContext ? pContext->GetWindow(): nullptr;
+}
+
+void SfxChildWindow::SetWorkWindow_Impl( SfxWorkWindow* pWin )
+{
+    pImpl->pWorkWin = pWin;
+    if (pWin)
+    {
+        if ( (xController && xController->getDialog()->has_toplevel_focus()) ||
+             (pWindow && pWindow->HasChildPathFocus()) )
+        {
+            pImpl->pWorkWin->SetActiveChild_Impl( pWindow );
+        }
+    }
+}
+
+void SfxChildWindow::Activate_Impl()
+{
+    if(pImpl->pWorkWin!=nullptr)
+        pImpl->pWorkWin->SetActiveChild_Impl( pWindow );
+}
+
+bool SfxChildWindow::QueryClose()
+{
+    bool bAllow = true;
+
+    if ( pImpl->xFrame.is() )
+    {
+        css::uno::Reference< css::frame::XController >  xCtrl = pImpl->xFrame->getController();
+        if ( xCtrl.is() )
+            bAllow = xCtrl->suspend( true );
+    }
+
+    if ( bAllow )
+    {
+        if (GetController())
+        {
+            weld::Dialog* pDialog = GetController()->getDialog();
+            bAllow = !pDialog->get_visible() || !pDialog->get_modal();
+        }
+        else if (GetWindow())
+            bAllow = !GetWindow()->IsInModalMode();
+    }
+
+    return bAllow;
+}
+
+const css::uno::Reference< css::frame::XFrame >&  SfxChildWindow::GetFrame() const
+{
+    return pImpl->xFrame;
+}
+
+void SfxChildWindow::SetFrame( const css::uno::Reference< css::frame::XFrame > & rFrame )
+{
+    // Do nothing if nothing will be changed ...
+    if( pImpl->xFrame == rFrame )
+        return;
+
+    // ... but stop listening on old frame, if connection exist!
+    if( pImpl->xFrame.is() )
+        pImpl->xFrame->removeEventListener( pImpl->xListener );
+
+    // If new frame is not NULL -> we must guarantee valid listener for disposing events.
+    // Use already existing or create new one.
+    if( rFrame.is() )
+        if( !pImpl->xListener.is() )
+            pImpl->xListener.set( new DisposeListener( this, pImpl.get() ) );
+
+    // Set new frame in data container
+    // and build new listener connection, if necessary.
+    pImpl->xFrame = rFrame;
+    if( pImpl->xFrame.is() )
+        pImpl->xFrame->addEventListener( pImpl->xListener );
+}
+
+void SfxChildWindowContext::RegisterChildWindowContext(SfxModule* pMod, sal_uInt16 nId, std::unique_ptr<SfxChildWinContextFactory> pFact)
+{
+    SfxGetpApp()->RegisterChildWindowContext_Impl( pMod, nId, std::move(pFact) );
+}
+
+void SfxChildWindow::RegisterChildWindow(SfxModule* pMod, std::unique_ptr<SfxChildWinFactory> pFact)
+{
+    SfxGetpApp()->RegisterChildWindow_Impl( pMod, std::move(pFact) );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/childwinimpl.cxx b/sfx2/source/appl/childwinimpl.cxx
new file mode 100644
index 000000000..d04f0c2b4
--- /dev/null
+++ b/sfx2/source/appl/childwinimpl.cxx
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <childwinimpl.hxx>
+
+size_t SfxChildWinContextArr_Impl::size() const
+{
+    return maData.size();
+}
+
+const SfxChildWinContextFactory& SfxChildWinContextArr_Impl::operator []( size_t i ) const
+{
+    return *maData[i];
+}
+
+SfxChildWinContextFactory& SfxChildWinContextArr_Impl::operator []( size_t i )
+{
+    return *maData[i];
+}
+
+void SfxChildWinContextArr_Impl::push_back( std::unique_ptr<SfxChildWinContextFactory> p )
+{
+    maData.push_back(std::move(p));
+}
+
+size_t SfxChildWinFactArr_Impl::size() const
+{
+    return maData.size();
+}
+
+const SfxChildWinFactory& SfxChildWinFactArr_Impl::operator []( size_t i ) const
+{
+    return *maData[i];
+}
+
+SfxChildWinFactory& SfxChildWinFactArr_Impl::operator []( size_t i )
+{
+    return *maData[i];
+}
+
+void SfxChildWinFactArr_Impl::push_back( std::unique_ptr<SfxChildWinFactory> p )
+{
+    maData.push_back(std::move(p));
+}
+
+void SfxChildWinFactArr_Impl::erase( const iterator& it )
+{
+    maData.erase(it);
+}
+
+SfxChildWinFactArr_Impl::iterator SfxChildWinFactArr_Impl::begin()
+{
+    return maData.begin();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/fileobj.cxx b/sfx2/source/appl/fileobj.cxx
new file mode 100644
index 000000000..ebfe57edf
--- /dev/null
+++ b/sfx2/source/appl/fileobj.cxx
@@ -0,0 +1,434 @@
+/* -*- 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 <tools/urlobj.hxx>
+#include <tools/stream.hxx>
+#include <sot/formats.hxx>
+#include <sal/log.hxx>
+#include <sfx2/lnkbase.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <sot/exchange.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <sfx2/docfac.hxx>
+#include <com/sun/star/document/XTypeDetection.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <unotools/mediadescriptor.hxx>
+#include <comphelper/processfactory.hxx>
+#include <sfx2/linkmgr.hxx>
+#include <sfx2/opengrf.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/objsh.hxx>
+#include "fileobj.hxx"
+#include <sfx2/strings.hrc>
+#include <vcl/svapp.hxx>
+
+enum class SvFileObjectType
+{
+    Text = 1, Graphic = 2, Object = 3
+};
+
+SvFileObject::SvFileObject()
+    : nPostUserEventId(nullptr)
+    , mxDelMed()
+    , nType(SvFileObjectType::Text)
+    , bLoadAgain(true)
+    , bSynchron(false)
+    , bLoadError(false)
+    , bWaitForData(false)
+    , bDataReady(false)
+    , bClearMedium(false)
+    , bStateChangeCalled(false)
+{
+}
+
+SvFileObject::~SvFileObject()
+{
+    if (xMed.is())
+    {
+        xMed->SetDoneLink( Link<void*,void>() );
+        xMed.clear();
+    }
+    if (nPostUserEventId)
+        Application::RemoveUserEvent(nPostUserEventId);
+}
+
+bool SvFileObject::GetData( css::uno::Any & rData,
+                                const OUString & rMimeType,
+                                bool /*bGetSynchron*/ )
+{
+    SotClipboardFormatId nFmt = SotExchange::RegisterFormatMimeType( rMimeType );
+    switch( nType )
+    {
+    case SvFileObjectType::Text:
+        if( SotClipboardFormatId::SIMPLE_FILE == nFmt )
+        {
+            // The media in the application must be opened to lookup the
+            // relative file links!! This is done through the link manager
+            // of the Storage.
+            rData <<= sFileNm;
+        }
+        break;
+
+    case SvFileObjectType::Graphic:
+        if (SotClipboardFormatId::GDIMETAFILE == nFmt
+         || SotClipboardFormatId::BITMAP == nFmt
+         || SotClipboardFormatId::SVXB == nFmt)
+        {
+            rData <<= sFileNm;
+        }
+        break;
+    case SvFileObjectType::Object:
+        // TODO/LATER: possibility to insert a new object
+        rData <<= sFileNm;
+        break;
+    }
+    return true/*0 != aTypeList.Count()*/;
+}
+
+bool SvFileObject::Connect( sfx2::SvBaseLink* pLink )
+{
+    if( !pLink || !pLink->GetLinkManager() )
+        return false;
+
+    // Test if not another link of the same connection already exists
+    sfx2::LinkManager::GetDisplayNames( pLink, nullptr, &sFileNm, nullptr, &sFilter );
+
+    if( sfx2::SvBaseLinkObjectType::ClientGraphic == pLink->GetObjType() )
+    {
+        SfxObjectShellRef pShell = pLink->GetLinkManager()->GetPersist();
+        if( pShell.is() )
+        {
+            if( pShell->IsAbortingImport() )
+                return false;
+
+            if( pShell->GetMedium() )
+                sReferer = pShell->GetMedium()->GetName();
+        }
+    }
+
+    switch( pLink->GetObjType() )
+    {
+    case sfx2::SvBaseLinkObjectType::ClientGraphic:
+        nType = SvFileObjectType::Graphic;
+        bSynchron = pLink->IsSynchron();
+        break;
+
+    case sfx2::SvBaseLinkObjectType::ClientFile:
+        nType = SvFileObjectType::Text;
+        break;
+
+    case sfx2::SvBaseLinkObjectType::ClientOle:
+        nType = SvFileObjectType::Object;
+        // TODO/LATER: introduce own type to be used for exchanging
+        break;
+
+    default:
+        return false;
+    }
+
+    SetUpdateTimeout( 0 );
+
+    // and now register by this or other found Pseudo-Object
+    AddDataAdvise( pLink, SotExchange::GetFormatMimeType( pLink->GetContentType()), 0 );
+    return true;
+}
+
+bool SvFileObject::LoadFile_Impl()
+{
+    // We are still at Loading!!
+    if( bWaitForData || !bLoadAgain || xMed.is() )
+        return false;
+
+    // at the moment on the current DocShell
+    xMed = new SfxMedium( sFileNm, sReferer, StreamMode::STD_READ );
+    SvLinkSource::StreamToLoadFrom aStreamToLoadFrom =
+        getStreamToLoadFrom();
+    xMed->setStreamToLoadFrom(
+        aStreamToLoadFrom.m_xInputStreamToLoadFrom,
+        aStreamToLoadFrom.m_bIsReadOnly);
+
+    if( !bSynchron )
+    {
+        bLoadAgain = bDataReady = false;
+        bWaitForData = true;
+
+        tools::SvRef<SfxMedium> xTmpMed = xMed;
+        xMed->Download( LINK( this, SvFileObject, LoadGrfReady_Impl ) );
+
+        bClearMedium = !xMed.is();
+        if( bClearMedium )
+            xMed = xTmpMed;  // If already finished in Download
+        return bDataReady;
+    }
+
+    bWaitForData = true;
+    bDataReady = false;
+    xMed->Download();
+    bLoadAgain = !xMed->IsRemote();
+    bWaitForData = false;
+
+    // Graphic is finished, also send DataChanged of the Status change:
+    SendStateChg_Impl( xMed->GetInStream() && xMed->GetInStream()->GetError()
+                        ? sfx2::LinkManager::STATE_LOAD_ERROR : sfx2::LinkManager::STATE_LOAD_OK );
+    return true;
+}
+
+
+/** detect the filter of the given file
+
+    @param _rURL
+        specifies the URL of the file which filter is to detected.<br/>
+        If the URL doesn't denote a valid (existent and accessible) file, the
+        request is silently dropped.
+*/
+static OUString impl_getFilter( const OUString& _rURL )
+{
+    OUString sFilter;
+    if ( _rURL.isEmpty() )
+        return sFilter;
+
+    try
+    {
+        css::uno::Reference< css::document::XTypeDetection > xTypeDetection(
+            ::comphelper::getProcessServiceFactory()->createInstance( "com.sun.star.document.TypeDetection" ),
+            css::uno::UNO_QUERY );
+        if ( xTypeDetection.is() )
+        {
+            utl::MediaDescriptor aDescr;
+            aDescr[ utl::MediaDescriptor::PROP_URL() ] <<= _rURL;
+            css::uno::Sequence< css::beans::PropertyValue > aDescrList =
+                aDescr.getAsConstPropertyValueList();
+            OUString sType = xTypeDetection->queryTypeByDescriptor( aDescrList, true );
+            if ( !sType.isEmpty() )
+            {
+                // Honor a selected/detected filter.
+                for (const auto& rDescr : std::as_const(aDescrList))
+                {
+                    if (rDescr.Name == "FilterName")
+                    {
+                        if (rDescr.Value >>= sFilter)
+                            break;
+                    }
+                }
+                if (sFilter.isEmpty())
+                {
+                    css::uno::Reference< css::container::XNameAccess > xTypeCont( xTypeDetection,
+                            css::uno::UNO_QUERY );
+                    if ( xTypeCont.is() )
+                    {
+                        /* XXX: for fdo#69948 scenario the sequence returned by
+                         * getByName() contains an empty PreferredFilter
+                         * property value (since? expected?) */
+                        ::comphelper::SequenceAsHashMap lTypeProps( xTypeCont->getByName( sType ) );
+                        sFilter = lTypeProps.getUnpackedValueOrDefault(
+                                "PreferredFilter", OUString() );
+                    }
+                }
+            }
+        }
+    }
+    catch( const css::uno::Exception& )
+    {
+    }
+
+    return sFilter;
+}
+
+void SvFileObject::Edit(weld::Window* pParent, sfx2::SvBaseLink* pLink, const Link<const OUString&, void>& rEndEditHdl)
+{
+    aEndEditLink = rEndEditHdl;
+    OUString sFile, sRange, sTmpFilter;
+    if( !pLink || !pLink->GetLinkManager() )
+        return;
+
+    sfx2::LinkManager::GetDisplayNames( pLink, nullptr, &sFile, &sRange, &sTmpFilter );
+
+    switch( pLink->GetObjType() )
+    {
+        case sfx2::SvBaseLinkObjectType::ClientGraphic:
+        {
+            nType = SvFileObjectType::Graphic;       // If not set already
+
+            SvxOpenGraphicDialog aDlg(SfxResId(RID_SVXSTR_EDITGRFLINK), pParent);
+            aDlg.EnableLink(false);
+            aDlg.SetPath( sFile, true );
+            aDlg.SetCurrentFilter( sTmpFilter );
+
+            if( !aDlg.Execute() )
+            {
+                sFile = aDlg.GetPath()
+                    + OUStringChar(sfx2::cTokenSeparator)
+                    + OUStringChar(sfx2::cTokenSeparator)
+                    + aDlg.GetDetectedFilter();
+
+                aEndEditLink.Call( sFile );
+            }
+            else
+                sFile.clear();
+        }
+        break;
+
+        case sfx2::SvBaseLinkObjectType::ClientOle:
+        {
+            nType = SvFileObjectType::Object; // if not set already
+
+            ::sfx2::FileDialogHelper & rFileDlg =
+                pLink->GetInsertFileDialog( OUString() );
+            rFileDlg.StartExecuteModal(
+                    LINK( this, SvFileObject, DialogClosedHdl ) );
+        }
+        break;
+
+        case sfx2::SvBaseLinkObjectType::ClientFile:
+        {
+            nType = SvFileObjectType::Text; // if not set already
+
+            OUString sFactory;
+            SfxObjectShell* pShell = pLink->GetLinkManager()->GetPersist();
+            if ( pShell )
+                sFactory = pShell->GetFactory().GetFactoryName();
+
+            ::sfx2::FileDialogHelper & rFileDlg =
+                pLink->GetInsertFileDialog(sFactory);
+            rFileDlg.StartExecuteModal(
+                    LINK( this, SvFileObject, DialogClosedHdl ) );
+        }
+        break;
+
+        default:
+            sFile.clear();
+    }
+}
+
+IMPL_LINK_NOARG( SvFileObject, LoadGrfReady_Impl, void*, void )
+{
+    // When we come from here there it can not be an error no more.
+    bLoadError = false;
+    bWaitForData = false;
+
+    if( !bDataReady )
+    {
+        // Graphic is finished, also send DataChanged from Status change
+        bDataReady = true;
+        SendStateChg_Impl( sfx2::LinkManager::STATE_LOAD_OK );
+
+        // and then send the data again
+        NotifyDataChanged();
+    }
+
+    if( bDataReady )
+    {
+        bLoadAgain = true;
+        if( xMed.is() )
+        {
+            xMed->SetDoneLink( Link<void*,void>() );
+            mxDelMed = xMed;
+            nPostUserEventId = Application::PostUserEvent(
+                        LINK( this, SvFileObject, DelMedium_Impl ));
+            xMed.clear();
+        }
+    }
+}
+
+IMPL_LINK_NOARG( SvFileObject, DelMedium_Impl, void*, void )
+{
+    nPostUserEventId = nullptr;
+    mxDelMed.clear();
+}
+
+IMPL_LINK( SvFileObject, DialogClosedHdl, sfx2::FileDialogHelper*, _pFileDlg, void )
+{
+    OUString sFile;
+
+    if ( SvFileObjectType::Text == nType || SvFileObjectType::Object == nType )
+    {
+        if ( _pFileDlg && _pFileDlg->GetError() == ERRCODE_NONE )
+        {
+            OUString sURL( _pFileDlg->GetPath() );
+            sFile = sURL + OUStringChar(sfx2::cTokenSeparator)
+                + OUStringChar(sfx2::cTokenSeparator)
+                + impl_getFilter( sURL );
+        }
+    }
+    else
+    {
+        SAL_WARN( "sfx.appl", "SvFileObject::DialogClosedHdl(): wrong file type" );
+    }
+
+    aEndEditLink.Call( sFile );
+}
+
+/*
+    The method determines whether the data-object can be read from a DDE.
+*/
+bool SvFileObject::IsPending() const
+{
+    return SvFileObjectType::Graphic == nType && !bLoadError && bWaitForData;
+}
+
+bool SvFileObject::IsDataComplete() const
+{
+    bool bRet = false;
+    if( SvFileObjectType::Graphic != nType )
+        bRet = true;
+    else if( !bLoadError && !bWaitForData )
+    {
+        SvFileObject* pThis = const_cast<SvFileObject*>(this);
+        if( bDataReady ||
+            ( bSynchron && pThis->LoadFile_Impl() && xMed.is() ) )
+            bRet = true;
+        else
+        {
+            INetURLObject aUrl( sFileNm );
+            if( aUrl.HasError() ||
+                INetProtocol::NotValid == aUrl.GetProtocol() )
+                bRet = true;
+        }
+    }
+    return bRet;
+}
+
+
+void SvFileObject::CancelTransfers()
+{
+    // unsubscribe from the cache if in the middle of loading
+    if( !bDataReady )
+    {
+        // Do not set-up again
+        bLoadAgain = false;
+        bDataReady = bLoadError = bWaitForData = true;
+        SendStateChg_Impl( sfx2::LinkManager::STATE_LOAD_ABORT );
+    }
+}
+
+
+void SvFileObject::SendStateChg_Impl( sfx2::LinkManager::LinkState nState )
+{
+    if( !bStateChangeCalled && HasDataLinks() )
+    {
+        DataChanged( SotExchange::GetFormatName(
+                        sfx2::LinkManager::RegisterStatusInfoId()), css::uno::makeAny(OUString::number( nState )) );
+        bStateChangeCalled = true;
+    }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/fileobj.hxx b/sfx2/source/appl/fileobj.hxx
new file mode 100644
index 000000000..7362f6b1a
--- /dev/null
+++ b/sfx2/source/appl/fileobj.hxx
@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SFX2_SOURCE_APPL_FILEOBJ_HXX
+#define INCLUDED_SFX2_SOURCE_APPL_FILEOBJ_HXX
+
+#include <sfx2/linksrc.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/linkmgr.hxx>
+
+class Graphic;
+struct ImplSVEvent;
+namespace sfx2 { class FileDialogHelper; }
+
+enum class SvFileObjectType;
+
+class SvFileObject : public sfx2::SvLinkSource
+{
+    OUString                    sFileNm;
+    OUString                    sFilter;
+    OUString                    sReferer;
+    Link<const OUString&, void> aEndEditLink;
+    tools::SvRef<SfxMedium>     xMed;
+    ImplSVEvent*                nPostUserEventId;
+    tools::SvRef<SfxMedium>     mxDelMed;
+
+    SvFileObjectType nType;
+
+    bool bLoadAgain : 1;
+    bool bSynchron : 1;
+    bool bLoadError : 1;
+    bool bWaitForData : 1;
+    bool bDataReady : 1;
+    bool bClearMedium : 1;
+    bool bStateChangeCalled : 1;
+
+    bool LoadFile_Impl();
+    void SendStateChg_Impl( sfx2::LinkManager::LinkState nState );
+
+    DECL_LINK( DelMedium_Impl, void*, void );
+    DECL_LINK( LoadGrfReady_Impl, void*, void );
+    DECL_LINK( DialogClosedHdl, sfx2::FileDialogHelper*, void );
+
+protected:
+    virtual ~SvFileObject() override;
+
+public:
+    SvFileObject();
+
+    virtual bool GetData( css::uno::Any & rData /*out param*/,
+                            const OUString & rMimeType,
+                            bool bSynchron = false ) override;
+
+    virtual bool Connect( sfx2::SvBaseLink* ) override;
+    virtual void Edit(weld::Window *, sfx2::SvBaseLink *, const Link<const OUString&, void>& rEndEditHdl) override;
+
+    // Ask whether you can access data directly or whether it has to be triggered
+    virtual bool IsPending() const override;
+    virtual bool IsDataComplete() const override;
+
+    void CancelTransfers();
+};
+
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/flatpak.cxx b/sfx2/source/appl/flatpak.cxx
new file mode 100644
index 000000000..14411dafc
--- /dev/null
+++ b/sfx2/source/appl/flatpak.cxx
@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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/.
+ */
+
+#include <sal/config.h>
+
+#include <cassert>
+#include <cstdlib>
+#include <cstring>
+
+#include <osl/file.hxx>
+#include <osl/thread.h>
+#include <rtl/textcvt.h>
+#include <rtl/ustring.h>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+#include <sfx2/flatpak.hxx>
+#include <tools/debug.hxx>
+#include <unotools/tempfile.hxx>
+#include <unotools/ucbhelper.hxx>
+
+bool flatpak::isFlatpak() {
+    static auto const flatpak = [] { return std::getenv("LIBO_FLATPAK") != nullptr; }();
+    return flatpak;
+}
+
+namespace {
+
+// Must only be accessed with SolarMutex locked:
+struct {
+    bool created = false;
+    OUString url;
+} temporaryHtmlDirectoryStatus;
+
+}
+
+bool flatpak::createTemporaryHtmlDirectory(OUString ** url) {
+    assert(url != nullptr);
+    DBG_TESTSOLARMUTEX();
+    if (!temporaryHtmlDirectoryStatus.created) {
+        auto const env = std::getenv("XDG_CACHE_HOME");
+        if (env == nullptr) {
+            SAL_WARN("sfx.appl", "LIBO_FLATPAK mode but unset XDG_CACHE_HOME");
+            return false;
+        }
+        OUString path;
+        if (!rtl_convertStringToUString(
+                &path.pData, env, std::strlen(env), osl_getThreadTextEncoding(),
+                (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
+                 | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
+        {
+            SAL_WARN(
+                "sfx.appl",
+                "LIBO_FLATPAK mode failure converting XDG_CACHE_HOME \"" << env << "\" encoding");
+            return false;
+        }
+        OUString parent;
+        auto const err = osl::FileBase::getFileURLFromSystemPath(path, parent);
+        if (err != osl::FileBase::E_None) {
+            SAL_WARN(
+                "sfx.appl",
+                "LIBO_FLATPAK mode failure converting XDG_CACHE_HOME \"" << path << "\" to URL: "
+                    << err);
+            return false;
+        }
+        if (!parent.endsWith("/")) {
+            parent += "/";
+        }
+        auto const tmp = utl::TempFile(&parent, true);
+        if (!tmp.IsValid()) {
+            SAL_WARN(
+                "sfx.appl", "LIBO_FLATPAK mode failure creating temp dir at <" << parent << ">");
+            return false;
+        }
+        temporaryHtmlDirectoryStatus.url = tmp.GetURL();
+        temporaryHtmlDirectoryStatus.created = true;
+    }
+    *url = &temporaryHtmlDirectoryStatus.url;
+    return true;
+}
+
+void flatpak::removeTemporaryHtmlDirectory() {
+    DBG_TESTSOLARMUTEX();
+    if (temporaryHtmlDirectoryStatus.created) {
+        if (!utl::UCBContentHelper::Kill(temporaryHtmlDirectoryStatus.url)) {
+            SAL_INFO(
+                "sfx.appl",
+                "LIBO_FLATPAK mode failure removing directory <"
+                    << temporaryHtmlDirectoryStatus.url << ">");
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/sfx2/source/appl/fwkhelper.cxx b/sfx2/source/appl/fwkhelper.cxx
new file mode 100644
index 000000000..6a7eee8fb
--- /dev/null
+++ b/sfx2/source/appl/fwkhelper.cxx
@@ -0,0 +1,52 @@
+/* -*- 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/uno/Reference.hxx>
+#include <com/sun/star/frame/XFrame.hpp>
+
+#include <vcl/svapp.hxx>
+
+#include <fwkhelper.hxx>
+#include <workwin.hxx>
+#include <sfx2/frame.hxx>
+
+void RefreshToolbars( css::uno::Reference< css::frame::XFrame > const & xFrame )
+{
+    SolarMutexGuard aGuard;
+    if ( !xFrame.is() )
+        return;
+
+    SfxFrame* pFrame=nullptr;
+    for ( pFrame = SfxFrame::GetFirst(); pFrame; pFrame = SfxFrame::GetNext( *pFrame ) )
+    {
+        if ( pFrame->GetFrameInterface() == xFrame )
+            break;
+    }
+
+    if ( pFrame )
+    {
+        SfxWorkWindow* pWrkWin = pFrame->GetWorkWindow_Impl();
+        if ( pWrkWin )
+            pWrkWin->UpdateObjectBars_Impl();
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/getbasctlfunction.cxx b/sfx2/source/appl/getbasctlfunction.cxx
new file mode 100644
index 000000000..fd7f48730
--- /dev/null
+++ b/sfx2/source/appl/getbasctlfunction.cxx
@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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 <cassert>
+
+#include <config_features.h>
+#include <config_options.h>
+#include <osl/module.h>
+#include <osl/module.hxx>
+#include <tools/svlibrary.h>
+
+#include "getbasctlfunction.hxx"
+
+#if HAVE_FEATURE_SCRIPTING
+#ifndef DISABLE_DYNLOADING
+
+extern "C" { static void thisModule() {} }
+
+oslGenericFunction sfx2::getBasctlFunction(char const* name)
+{
+    osl::Module aMod;
+
+    // load basctl module
+    auto const ok = aMod.loadRelative(
+        &thisModule,
+#if ENABLE_MERGELIBS
+        SVLIBRARY("merged")
+#else
+        SVLIBRARY("basctl")
+#endif
+        );
+    assert(ok);
+    (void) ok;
+
+    // get symbol
+    auto pSymbol = aMod.getFunctionSymbol(name);
+    assert(pSymbol);
+    aMod.release();
+
+    return pSymbol;
+}
+
+#endif
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/sfx2/source/appl/getbasctlfunction.hxx b/sfx2/source/appl/getbasctlfunction.hxx
new file mode 100644
index 000000000..5fa4bc557
--- /dev/null
+++ b/sfx2/source/appl/getbasctlfunction.hxx
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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 .
+ */
+
+#pragma once
+
+#include <sal/config.h>
+#include <config_features.h>
+
+#include <osl/module.h>
+
+#ifndef DISABLE_DYNLOADING
+#if HAVE_FEATURE_SCRIPTING
+
+namespace sfx2
+{
+oslGenericFunction getBasctlFunction(char const* name);
+}
+
+#endif
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/sfx2/source/appl/helpdispatch.cxx b/sfx2/source/appl/helpdispatch.cxx
new file mode 100644
index 000000000..7b2467a34
--- /dev/null
+++ b/sfx2/source/appl/helpdispatch.cxx
@@ -0,0 +1,105 @@
+/* -*- 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 "helpdispatch.hxx"
+#include "newhelp.hxx"
+#include <tools/debug.hxx>
+
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+
+// class HelpInterceptor_Impl --------------------------------------------
+
+HelpDispatch_Impl::HelpDispatch_Impl( HelpInterceptor_Impl& _rInterceptor,
+                                      const css::uno::Reference< css::frame::XDispatch >& _xDisp ) :
+
+    m_rInterceptor  ( _rInterceptor ),
+    m_xRealDispatch ( _xDisp )
+
+{
+}
+
+
+HelpDispatch_Impl::~HelpDispatch_Impl()
+{
+}
+
+
+// XDispatch
+
+void SAL_CALL HelpDispatch_Impl::dispatch(
+
+    const URL& aURL, const Sequence< PropertyValue >& aArgs )
+
+{
+    DBG_ASSERT( m_xRealDispatch.is(), "invalid dispatch" );
+
+    // search for a keyword (dispatch from the basic ide)
+    bool bHasKeyword = false;
+    OUString sKeyword;
+    for ( const PropertyValue& rArg : aArgs )
+    {
+        if ( rArg.Name == "HelpKeyword" )
+        {
+            OUString sHelpKeyword;
+            if ( ( rArg.Value >>= sHelpKeyword ) && !sHelpKeyword.isEmpty() )
+            {
+                sKeyword = sHelpKeyword;
+                bHasKeyword = !sKeyword.isEmpty();
+                break;
+            }
+        }
+    }
+
+    // if a keyword was found, then open it
+    SfxHelpWindow_Impl* pHelpWin = m_rInterceptor.GetHelpWindow();
+    DBG_ASSERT( pHelpWin, "invalid HelpWindow" );
+    if ( bHasKeyword )
+    {
+        pHelpWin->OpenKeyword( sKeyword );
+        return;
+    }
+
+    pHelpWin->loadHelpContent(aURL.Complete);
+}
+
+
+void SAL_CALL HelpDispatch_Impl::addStatusListener(
+
+    const Reference< XStatusListener >& xControl, const URL& aURL )
+
+{
+    DBG_ASSERT( m_xRealDispatch.is(), "invalid dispatch" );
+    m_xRealDispatch->addStatusListener( xControl, aURL );
+}
+
+
+void SAL_CALL HelpDispatch_Impl::removeStatusListener(
+
+    const Reference< XStatusListener >& xControl, const URL& aURL )
+
+{
+    DBG_ASSERT( m_xRealDispatch.is(), "invalid dispatch" );
+    m_xRealDispatch->removeStatusListener( xControl, aURL );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/helpdispatch.hxx b/sfx2/source/appl/helpdispatch.hxx
new file mode 100644
index 000000000..b0494c6d0
--- /dev/null
+++ b/sfx2/source/appl/helpdispatch.hxx
@@ -0,0 +1,47 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SFX2_SOURCE_APPL_HELPDISPATCH_HXX
+#define INCLUDED_SFX2_SOURCE_APPL_HELPDISPATCH_HXX
+
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <cppuhelper/implbase.hxx>
+
+#include "helpinterceptor.hxx"
+
+class HelpDispatch_Impl : public ::cppu::WeakImplHelper< css::frame::XDispatch >
+{
+private:
+    HelpInterceptor_Impl&       m_rInterceptor;
+    css::uno::Reference< css::frame::XDispatch >
+                                m_xRealDispatch;
+
+public:
+    HelpDispatch_Impl( HelpInterceptor_Impl& _rInterceptor,
+                       const css::uno::Reference< css::frame::XDispatch >& _xDisp );
+    virtual ~HelpDispatch_Impl() override;
+
+    // XDispatch
+    virtual void SAL_CALL   dispatch( const css::util::URL& aURL, const css::uno::Sequence< css::beans::PropertyValue >& aArgs ) override;
+    virtual void SAL_CALL   addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xControl, const css::util::URL& aURL ) override;
+    virtual void SAL_CALL   removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xControl, const css::util::URL& aURL ) override;
+};
+
+#endif // INCLUDED_SFX2_SOURCE_APPL_HELPDISPATCH_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/helpinterceptor.cxx b/sfx2/source/appl/helpinterceptor.cxx
new file mode 100644
index 000000000..54cf5cf06
--- /dev/null
+++ b/sfx2/source/appl/helpinterceptor.cxx
@@ -0,0 +1,265 @@
+/* -*- 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 "helpinterceptor.hxx"
+#include "helpdispatch.hxx"
+#include "newhelp.hxx"
+#include <tools/urlobj.hxx>
+#include <tools/debug.hxx>
+#include <limits.h>
+
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::lang;
+
+HelpInterceptor_Impl::HelpInterceptor_Impl() :
+
+    m_pWindow  ( nullptr ),
+    m_nCurPos   ( 0 )
+
+{
+}
+
+
+HelpInterceptor_Impl::~HelpInterceptor_Impl()
+{
+}
+
+
+void HelpInterceptor_Impl::addURL( const OUString& rURL )
+{
+    size_t nCount = m_vHistoryUrls.size();
+    if ( nCount && m_nCurPos < ( nCount - 1 ) )
+    {
+        for ( size_t i = nCount - 1; i > m_nCurPos; i-- )
+        {
+            m_vHistoryUrls.erase( m_vHistoryUrls.begin() + i );
+        }
+    }
+    Reference<XFrame> xFrame(m_xIntercepted, UNO_QUERY);
+    Reference<XController> xController;
+    if(xFrame.is())
+        xController = xFrame->getController();
+
+    m_aCurrentURL = rURL;
+    m_vHistoryUrls.emplace_back( rURL );
+    m_nCurPos = m_vHistoryUrls.size() - 1;
+// TODO ?
+    if ( m_xListener.is() )
+    {
+        css::frame::FeatureStateEvent aEvent;
+        URL aURL;
+        aURL.Complete = rURL;
+        aEvent.FeatureURL = aURL;
+        aEvent.Source = static_cast<css::frame::XDispatch*>(this);
+        m_xListener->statusChanged( aEvent );
+    }
+
+    m_pWindow->UpdateToolbox();
+}
+
+
+void HelpInterceptor_Impl::setInterception( const Reference< XFrame >& xFrame )
+{
+    m_xIntercepted.set( xFrame, UNO_QUERY );
+
+    if ( m_xIntercepted.is() )
+        m_xIntercepted->registerDispatchProviderInterceptor( static_cast<XDispatchProviderInterceptor*>(this) );
+}
+
+
+bool HelpInterceptor_Impl::HasHistoryPred() const
+{
+    return m_nCurPos > 0;
+}
+
+bool HelpInterceptor_Impl::HasHistorySucc() const
+{
+    return m_nCurPos < ( m_vHistoryUrls.size() - 1 );
+}
+
+
+// XDispatchProvider
+
+Reference< XDispatch > SAL_CALL HelpInterceptor_Impl::queryDispatch(
+
+    const URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags )
+
+{
+    Reference< XDispatch > xResult;
+    if ( m_xSlaveDispatcher.is() )
+        xResult = m_xSlaveDispatcher->queryDispatch( aURL, aTargetFrameName, nSearchFlags );
+
+    bool bHelpURL = aURL.Complete.toAsciiLowerCase().match("vnd.sun.star.help",0);
+
+    if ( bHelpURL )
+    {
+        DBG_ASSERT( xResult.is(), "invalid dispatch" );
+        HelpDispatch_Impl* pHelpDispatch = new HelpDispatch_Impl( *this, xResult );
+        xResult.set( static_cast< ::cppu::OWeakObject* >(pHelpDispatch), UNO_QUERY );
+    }
+
+    return xResult;
+}
+
+
+Sequence < Reference < XDispatch > > SAL_CALL HelpInterceptor_Impl::queryDispatches(
+
+    const Sequence< DispatchDescriptor >& aDescripts )
+
+{
+    Sequence< Reference< XDispatch > > aReturn( aDescripts.getLength() );
+    std::transform(aDescripts.begin(), aDescripts.end(), aReturn.begin(),
+        [this](const DispatchDescriptor& rDescr) -> Reference<XDispatch> {
+            return queryDispatch(rDescr.FeatureURL, rDescr.FrameName, rDescr.SearchFlags); });
+    return aReturn;
+}
+
+
+// XDispatchProviderInterceptor
+
+Reference< XDispatchProvider > SAL_CALL HelpInterceptor_Impl::getSlaveDispatchProvider()
+
+{
+    return m_xSlaveDispatcher;
+}
+
+
+void SAL_CALL HelpInterceptor_Impl::setSlaveDispatchProvider( const Reference< XDispatchProvider >& xNewSlave )
+
+{
+    m_xSlaveDispatcher = xNewSlave;
+}
+
+
+Reference< XDispatchProvider > SAL_CALL HelpInterceptor_Impl::getMasterDispatchProvider()
+
+{
+    return m_xMasterDispatcher;
+}
+
+
+void SAL_CALL HelpInterceptor_Impl::setMasterDispatchProvider( const Reference< XDispatchProvider >& xNewMaster )
+
+{
+    m_xMasterDispatcher = xNewMaster;
+}
+
+
+// XInterceptorInfo
+
+Sequence< OUString > SAL_CALL HelpInterceptor_Impl::getInterceptedURLs()
+
+{
+    Sequence<OUString> aURLList { "vnd.sun.star.help://*" };
+    return aURLList;
+}
+
+
+// XDispatch
+
+void SAL_CALL HelpInterceptor_Impl::dispatch(
+    const URL& aURL, const Sequence< css::beans::PropertyValue >& )
+{
+    bool bBack = aURL.Complete == ".uno:Backward";
+    if ( !bBack && aURL.Complete != ".uno:Forward" )
+        return;
+
+    if ( m_vHistoryUrls.empty() )
+        return;
+
+    sal_uIntPtr nPos = ( bBack && m_nCurPos > 0 ) ? --m_nCurPos
+                                            : ( !bBack && m_nCurPos < m_vHistoryUrls.size() - 1 )
+                                            ? ++m_nCurPos
+                                            : ULONG_MAX;
+
+    if ( nPos < ULONG_MAX )
+    {
+        m_pWindow->loadHelpContent(m_vHistoryUrls[nPos], false); // false => don't add item to history again!
+    }
+
+    m_pWindow->UpdateToolbox();
+}
+
+
+void SAL_CALL HelpInterceptor_Impl::addStatusListener(
+    const Reference< XStatusListener >& xControl, const URL& )
+{
+    DBG_ASSERT( !m_xListener.is(), "listener already exists" );
+    m_xListener = xControl;
+}
+
+
+void SAL_CALL HelpInterceptor_Impl::removeStatusListener(
+    const Reference< XStatusListener >&, const URL&)
+{
+    m_xListener = nullptr;
+}
+
+// HelpListener_Impl -----------------------------------------------------
+
+HelpListener_Impl::HelpListener_Impl( HelpInterceptor_Impl* pInter )
+{
+    pInterceptor = pInter;
+    pInterceptor->addStatusListener( this, css::util::URL() );
+}
+
+
+void SAL_CALL HelpListener_Impl::statusChanged( const css::frame::FeatureStateEvent& Event )
+{
+    INetURLObject aObj( Event.FeatureURL.Complete );
+    aFactory = aObj.GetHost();
+    aChangeLink.Call( *this );
+}
+
+
+void SAL_CALL HelpListener_Impl::disposing( const css::lang::EventObject& )
+{
+    pInterceptor->removeStatusListener( this, css::util::URL() );
+    pInterceptor = nullptr;
+}
+
+HelpStatusListener_Impl::HelpStatusListener_Impl(
+        Reference < XDispatch > const & aDispatch, URL const & rURL)
+{
+    aDispatch->addStatusListener(this, rURL);
+}
+
+HelpStatusListener_Impl::~HelpStatusListener_Impl()
+{
+    if(xDispatch.is())
+        xDispatch->removeStatusListener(this, css::util::URL());
+}
+
+void HelpStatusListener_Impl::statusChanged(
+    const FeatureStateEvent& rEvent )
+{
+    aStateEvent = rEvent;
+}
+
+void HelpStatusListener_Impl::disposing( const EventObject& )
+{
+    xDispatch->removeStatusListener(this, css::util::URL());
+    xDispatch = nullptr;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/helpinterceptor.hxx b/sfx2/source/appl/helpinterceptor.hxx
new file mode 100644
index 000000000..8d66cedf4
--- /dev/null
+++ b/sfx2/source/appl/helpinterceptor.hxx
@@ -0,0 +1,141 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SFX2_SOURCE_APPL_HELPINTERCEPTOR_HXX
+#define INCLUDED_SFX2_SOURCE_APPL_HELPINTERCEPTOR_HXX
+
+#include <com/sun/star/frame/XDispatchProviderInterceptor.hpp>
+#include <com/sun/star/frame/XInterceptorInfo.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XDispatchProviderInterception.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <com/sun/star/frame/XStatusListener.hpp>
+#include <tools/link.hxx>
+#include <vcl/vclptr.hxx>
+#include "newhelp.hxx"
+#include <vector>
+
+class SfxHelpWindow_Impl;
+class HelpInterceptor_Impl : public ::cppu::WeakImplHelper<
+        css::frame::XDispatchProviderInterceptor,
+        css::frame::XInterceptorInfo,
+        css::frame::XDispatch >
+
+{
+private:
+friend class HelpDispatch_Impl;
+friend class SfxHelpWindow_Impl;
+
+    // the component which's dispatches we're intercepting
+    css::uno::Reference< css::frame::XDispatchProviderInterception > m_xIntercepted;
+
+    // chaining
+    css::uno::Reference< css::frame::XDispatchProvider > m_xSlaveDispatcher;
+    css::uno::Reference< css::frame::XDispatchProvider > m_xMasterDispatcher;
+
+    css::uno::Reference< css::frame::XStatusListener > m_xListener;
+
+    std::vector<OUString>       m_vHistoryUrls;
+    VclPtr<SfxHelpWindow_Impl>  m_pWindow;
+    sal_uIntPtr                 m_nCurPos;
+    OUString                    m_aCurrentURL;
+
+    void                        addURL( const OUString& rURL );
+
+public:
+    HelpInterceptor_Impl();
+    virtual ~HelpInterceptor_Impl() override;
+
+    void                    setInterception( const css::uno::Reference< css::frame::XFrame >& xFrame );
+    const OUString&         GetCurrentURL() const { return m_aCurrentURL; }
+
+    bool                HasHistoryPred() const;     // is there a predecessor for the current in the history
+    bool                HasHistorySucc() const;     // is there a successor for the current in the history
+
+    // XDispatchProvider
+    virtual css::uno::Reference< css::frame::XDispatch > SAL_CALL
+                            queryDispatch( const css::util::URL& aURL, const OUString& aTargetFrameName, sal_Int32 nSearchFlags ) override;
+    virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL
+                            queryDispatches( const css::uno::Sequence< css::frame::DispatchDescriptor >& aDescripts ) override;
+
+    // XDispatchProviderInterceptor
+    virtual css::uno::Reference< css::frame::XDispatchProvider > SAL_CALL
+                            getSlaveDispatchProvider(  ) override;
+    virtual void SAL_CALL   setSlaveDispatchProvider( const css::uno::Reference< css::frame::XDispatchProvider >& xNewSlave ) override;
+    virtual css::uno::Reference< css::frame::XDispatchProvider > SAL_CALL
+                            getMasterDispatchProvider(  ) override;
+    virtual void SAL_CALL   setMasterDispatchProvider( const css::uno::Reference< css::frame::XDispatchProvider >& xNewMaster ) override;
+
+    // XInterceptorInfo
+    virtual css::uno::Sequence< OUString > SAL_CALL
+                            getInterceptedURLs(  ) override;
+
+    // XDispatch
+    virtual void SAL_CALL   dispatch( const css::util::URL& aURL, const css::uno::Sequence< css::beans::PropertyValue >& aArgs ) override;
+    virtual void SAL_CALL   addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xControl, const css::util::URL& aURL ) override;
+    virtual void SAL_CALL   removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xControl, const css::util::URL& aURL ) override;
+
+    // extras
+    void                    InitWaiter( SfxHelpWindow_Impl* pWindow )
+                                { m_pWindow = pWindow; }
+    SfxHelpWindow_Impl*     GetHelpWindow() const { return m_pWindow; }
+};
+
+// HelpListener_Impl -----------------------------------------------------
+
+class HelpListener_Impl : public ::cppu::WeakImplHelper< css::frame::XStatusListener >
+{
+private:
+    HelpInterceptor_Impl*   pInterceptor;
+    Link<HelpListener_Impl&,void> aChangeLink;
+    OUString                aFactory;
+
+public:
+    explicit HelpListener_Impl( HelpInterceptor_Impl* pInter );
+
+    virtual void SAL_CALL   statusChanged( const css::frame::FeatureStateEvent& Event ) override;
+    virtual void SAL_CALL   disposing( const css::lang::EventObject& obj ) override;
+
+    void                    SetChangeHdl( const Link<HelpListener_Impl&,void>& rLink ) { aChangeLink = rLink; }
+    const OUString&         GetFactory() const { return aFactory; }
+};
+// HelpStatusListener_Impl -----------------------------------------------------
+
+class HelpStatusListener_Impl : public cppu::WeakImplHelper< css::frame::XStatusListener >
+{
+private:
+    css::uno::Reference < css::frame::XDispatch > xDispatch;
+    css::frame::FeatureStateEvent                 aStateEvent;
+
+public:
+    HelpStatusListener_Impl(
+        css::uno::Reference < css::frame::XDispatch > const & xDispatch,
+        css::util::URL const & rURL);
+    virtual ~HelpStatusListener_Impl() override;
+
+    virtual void SAL_CALL   statusChanged( const css::frame::FeatureStateEvent& Event ) override;
+    virtual void SAL_CALL   disposing( const css::lang::EventObject& obj ) override;
+    const css::frame::FeatureStateEvent&
+                            GetStateEvent() const {return aStateEvent;}
+};
+
+
+#endif // INCLUDED_SFX2_SOURCE_APPL_HELPINTERCEPTOR_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/impldde.cxx b/sfx2/source/appl/impldde.cxx
new file mode 100644
index 000000000..5a42eadc8
--- /dev/null
+++ b/sfx2/source/appl/impldde.cxx
@@ -0,0 +1,348 @@
+/* -*- 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 .
+ */
+
+
+#if defined(_WIN32)
+#include <prewin.h>
+#include <postwin.h>
+#endif
+
+#include "impldde.hxx"
+
+#include <vcl/weld.hxx>
+#include <sot/exchange.hxx>
+#include <rtl/ustring.hxx>
+
+#include <sfx2/lnkbase.hxx>
+#include <sfx2/linkmgr.hxx>
+
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+
+#include <svl/svdde.hxx>
+#include <sot/formats.hxx>
+
+using namespace ::com::sun::star::uno;
+
+namespace sfx2
+{
+
+namespace {
+
+class SvDDELinkEditDialog : public weld::GenericDialogController
+{
+    std::unique_ptr<weld::Entry> m_xEdDdeApp;
+    std::unique_ptr<weld::Entry> m_xEdDdeTopic;
+    std::unique_ptr<weld::Entry> m_xEdDdeItem;
+    std::unique_ptr<weld::Button> m_xOKButton;
+
+    DECL_LINK(EditHdl_Impl, weld::Entry&, void);
+public:
+    SvDDELinkEditDialog(weld::Window* pParent, SvBaseLink const*);
+    OUString GetCmd() const;
+};
+
+}
+
+SvDDELinkEditDialog::SvDDELinkEditDialog(weld::Window* pParent, SvBaseLink const * pLink)
+    : GenericDialogController(pParent, "sfx/ui/linkeditdialog.ui", "LinkEditDialog")
+    , m_xEdDdeApp(m_xBuilder->weld_entry("app"))
+    , m_xEdDdeTopic(m_xBuilder->weld_entry("file"))
+    , m_xEdDdeItem(m_xBuilder->weld_entry("category"))
+    , m_xOKButton(m_xBuilder->weld_button("ok"))
+{
+    OUString sServer, sTopic, sItem;
+    sfx2::LinkManager::GetDisplayNames( pLink, &sServer, &sTopic, &sItem );
+
+    m_xEdDdeApp->set_text( sServer );
+    m_xEdDdeTopic->set_text( sTopic );
+    m_xEdDdeItem->set_text( sItem );
+
+    m_xEdDdeApp->connect_changed( LINK( this, SvDDELinkEditDialog, EditHdl_Impl));
+    m_xEdDdeTopic->connect_changed( LINK( this, SvDDELinkEditDialog, EditHdl_Impl));
+    m_xEdDdeItem->connect_changed( LINK( this, SvDDELinkEditDialog, EditHdl_Impl));
+
+    m_xOKButton->set_sensitive(!sServer.isEmpty() && !sTopic.isEmpty() && !sItem.isEmpty());
+}
+
+OUString SvDDELinkEditDialog::GetCmd() const
+{
+    OUString sCmd( m_xEdDdeApp->get_text() ), sRet;
+    ::sfx2::MakeLnkName( sRet, &sCmd, m_xEdDdeTopic->get_text(), m_xEdDdeItem->get_text() );
+    return sRet;
+}
+
+IMPL_LINK_NOARG( SvDDELinkEditDialog, EditHdl_Impl, weld::Entry&, void)
+{
+    m_xOKButton->set_sensitive(!m_xEdDdeApp->get_text().isEmpty() &&
+                               !m_xEdDdeTopic->get_text().isEmpty() &&
+                               !m_xEdDdeItem->get_text().isEmpty() );
+}
+
+SvDDEObject::SvDDEObject()
+    :  pGetData( nullptr )
+{
+    SetUpdateTimeout( 100 );
+    bWaitForData = false;
+}
+
+SvDDEObject::~SvDDEObject()
+{
+    pLink.reset();
+    pRequest.reset();
+    pConnection.reset();
+}
+
+bool SvDDEObject::GetData( css::uno::Any & rData /*out param*/,
+                            const OUString & rMimeType,
+                            bool bSynchron )
+{
+    if( !pConnection )
+        return false;
+
+    if( pConnection->GetError() )  // then we try once more
+    {
+        OUString sServer( pConnection->GetServiceName() );
+        OUString sTopic( pConnection->GetTopicName() );
+
+        pConnection.reset( new DdeConnection( sServer, sTopic ) );
+    }
+
+    if( bWaitForData ) // we are in a recursive loop, get out again
+        return false;
+
+    // Lock against Reentrance
+    bWaitForData = true;
+
+    // if you want to print, we'll wait until the data is available
+    if( bSynchron )
+    {
+        DdeRequest aReq( *pConnection, sItem, 5000 );
+        aReq.SetDataHdl( LINK( this, SvDDEObject, ImplGetDDEData ) );
+        aReq.SetFormat( SotExchange::GetFormatIdFromMimeType( rMimeType ));
+
+        pGetData = &rData;
+
+        do {
+            aReq.Execute();
+        } while( aReq.GetError() && ImplHasOtherFormat( aReq ) );
+
+        bWaitForData = false;
+    }
+    else
+    {
+        // otherwise it will be executed asynchronously
+        {
+            pRequest.reset( new DdeRequest( *pConnection, sItem ) );
+            pRequest->SetDataHdl( LINK( this, SvDDEObject, ImplGetDDEData ) );
+            pRequest->SetDoneHdl( LINK( this, SvDDEObject, ImplDoneDDEData ) );
+            pRequest->SetFormat( SotExchange::GetFormatIdFromMimeType(
+                                    rMimeType ) );
+            pRequest->Execute();
+        }
+
+        rData <<= OUString();
+    }
+    return 0 == pConnection->GetError();
+}
+
+
+bool SvDDEObject::Connect( SvBaseLink * pSvLink )
+{
+    SfxLinkUpdateMode nLinkType = pSvLink->GetUpdateMode();
+    if( pConnection )           // Connection is already made
+    {
+        // well, then just add it as dependent
+        AddDataAdvise( pSvLink,
+                SotExchange::GetFormatMimeType( pSvLink->GetContentType()),
+                SfxLinkUpdateMode::ONCALL == nLinkType
+                        ? ADVISEMODE_ONLYONCE
+                        : 0 );
+        AddConnectAdvise( pSvLink );
+
+        return true;
+    }
+
+    if( !pSvLink->GetLinkManager() )
+        return false;
+
+    OUString sServer, sTopic;
+    sfx2::LinkManager::GetDisplayNames( pSvLink, &sServer, &sTopic, &sItem );
+
+    if( sServer.isEmpty() || sTopic.isEmpty() || sItem.isEmpty() )
+        return false;
+
+    pConnection.reset( new DdeConnection( sServer, sTopic ) );
+    if( pConnection->GetError() )
+    {
+        // check if the DDE server knows the "SYSTEM" topic
+        bool bSysTopic = false;
+        if (!sTopic.equalsIgnoreAsciiCase("SYSTEM"))
+        {
+            DdeConnection aTmp(sServer, "SYSTEM");
+            bSysTopic = !aTmp.GetError();
+        }
+
+        if( bSysTopic )
+        {
+            // if the system topic works then the server is up but just doesn't know the original topic
+            return false;
+        }
+    }
+
+    if( SfxLinkUpdateMode::ALWAYS == nLinkType && !pLink && !pConnection->GetError() )
+    {
+        // Setting up Hot Link, Data will be available at some point later on
+        pLink.reset( new DdeHotLink( *pConnection, sItem ) );
+        pLink->SetDataHdl( LINK( this, SvDDEObject, ImplGetDDEData ) );
+        pLink->SetDoneHdl( LINK( this, SvDDEObject, ImplDoneDDEData ) );
+        pLink->SetFormat( pSvLink->GetContentType() );
+        pLink->Execute();
+    }
+
+    if( pConnection->GetError() )
+        return false;
+
+    AddDataAdvise( pSvLink,
+                SotExchange::GetFormatMimeType( pSvLink->GetContentType()),
+                SfxLinkUpdateMode::ONCALL == nLinkType
+                        ? ADVISEMODE_ONLYONCE
+                        : 0 );
+    AddConnectAdvise( pSvLink );
+    SetUpdateTimeout( 0 );
+    return true;
+}
+
+void SvDDEObject::Edit(weld::Window* pParent, sfx2::SvBaseLink* pBaseLink, const Link<const OUString&, void>& rEndEditHdl)
+{
+    SvDDELinkEditDialog aDlg(pParent, pBaseLink);
+    if (RET_OK == aDlg.run() && rEndEditHdl.IsSet())
+    {
+        OUString sCommand = aDlg.GetCmd();
+        rEndEditHdl.Call( sCommand );
+    }
+}
+
+bool SvDDEObject::ImplHasOtherFormat( DdeTransaction& rReq )
+{
+    SotClipboardFormatId nFmt = SotClipboardFormatId::NONE;
+    switch( rReq.GetFormat() )
+    {
+    case SotClipboardFormatId::RTF:
+        nFmt = SotClipboardFormatId::STRING;
+        break;
+
+    case SotClipboardFormatId::HTML_SIMPLE:
+    case SotClipboardFormatId::HTML:
+        nFmt = SotClipboardFormatId::RTF;
+        break;
+
+    case SotClipboardFormatId::GDIMETAFILE:
+        nFmt = SotClipboardFormatId::BITMAP;
+        break;
+
+    case SotClipboardFormatId::SVXB:
+        nFmt = SotClipboardFormatId::GDIMETAFILE;
+        break;
+
+    // something else?
+    default: break;
+    }
+    if( nFmt != SotClipboardFormatId::NONE )
+        rReq.SetFormat( nFmt );         // try it once more
+    return SotClipboardFormatId::NONE != nFmt;
+}
+
+bool SvDDEObject::IsPending() const
+/*
+    The method determines whether the data-object can be read from a DDE.
+*/
+{
+    return bWaitForData;
+}
+
+bool SvDDEObject::IsDataComplete() const
+{
+    return bWaitForData;
+}
+
+IMPL_LINK( SvDDEObject, ImplGetDDEData, const DdeData*, pData, void )
+{
+    SotClipboardFormatId nFmt = pData->GetFormat();
+    switch( nFmt )
+    {
+    case SotClipboardFormatId::GDIMETAFILE:
+        break;
+
+    case SotClipboardFormatId::BITMAP:
+        break;
+
+    default:
+        {
+            const char* p = static_cast<char const *>(pData->getData());
+            long nLen = SotClipboardFormatId::STRING == nFmt ? (p ? strlen( p ) : 0) : pData->getSize();
+
+            Sequence< sal_Int8 > aSeq( reinterpret_cast<const sal_Int8*>(p), nLen );
+            if( pGetData )
+            {
+                *pGetData <<= aSeq;  // Copy Data
+                pGetData = nullptr;        // reset the pointer here
+            }
+            else
+            {
+                Any aVal;
+                aVal <<= aSeq;
+                DataChanged( SotExchange::GetFormatMimeType(
+                                                pData->GetFormat() ), aVal );
+                bWaitForData = false;
+            }
+        }
+    }
+}
+
+IMPL_LINK( SvDDEObject, ImplDoneDDEData, bool, bValid, void )
+{
+    if( !bValid && ( pRequest || pLink ))
+    {
+        DdeTransaction* pReq = nullptr;
+        if( !pLink || ( pLink && pLink->IsBusy() ))
+            pReq = pRequest.get();  // only the one that is ready
+        else if( pRequest && pRequest->IsBusy() )
+            pReq = pLink.get();  // only the one that is ready
+
+        if( pReq )
+        {
+            if( ImplHasOtherFormat( *pReq ) )
+            {
+                pReq->Execute();
+            }
+            else if( pReq == pRequest.get() )
+            {
+                bWaitForData = false;
+            }
+        }
+    }
+    else
+        // End waiting
+        bWaitForData = false;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/impldde.hxx b/sfx2/source/appl/impldde.hxx
new file mode 100644
index 000000000..ee2f2ecb9
--- /dev/null
+++ b/sfx2/source/appl/impldde.hxx
@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SFX2_SOURCE_APPL_IMPLDDE_HXX
+#define INCLUDED_SFX2_SOURCE_APPL_IMPLDDE_HXX
+
+#include <rtl/ustring.hxx>
+#include <sfx2/linksrc.hxx>
+#include <tools/link.hxx>
+
+class DdeConnection;
+class DdeData;
+class DdeLink;
+class DdeRequest;
+class DdeTransaction;
+
+namespace sfx2
+{
+
+class SvDDEObject : public SvLinkSource
+{
+    OUString sItem;
+
+    std::unique_ptr<DdeConnection> pConnection;
+    std::unique_ptr<DdeLink> pLink;
+    std::unique_ptr<DdeRequest> pRequest;
+    css::uno::Any * pGetData;
+
+    bool bWaitForData;  // waiting for data?
+
+
+    static bool ImplHasOtherFormat( DdeTransaction& );
+    DECL_LINK( ImplGetDDEData, const DdeData*, void );
+    DECL_LINK( ImplDoneDDEData, bool, void );
+
+protected:
+    virtual ~SvDDEObject() override;
+
+public:
+    SvDDEObject();
+
+    virtual bool    GetData( css::uno::Any & rData /*out param*/,
+                                const OUString & aMimeType,
+                                bool bSynchron = false ) override;
+
+    virtual bool    Connect( SvBaseLink * ) override;
+    virtual void    Edit(weld::Window* pParent, sfx2::SvBaseLink* pBaseLink, const Link<const OUString&, void>& rEndEditHdl) override;
+
+    virtual bool    IsPending() const override;
+    virtual bool    IsDataComplete() const override;
+};
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/linkmgr2.cxx b/sfx2/source/appl/linkmgr2.cxx
new file mode 100644
index 000000000..8245f6da6
--- /dev/null
+++ b/sfx2/source/appl/linkmgr2.cxx
@@ -0,0 +1,710 @@
+/* -*- 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 <comphelper/string.hxx>
+#include <sfx2/linkmgr.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <com/sun/star/document/UpdateDocMode.hpp>
+#include <osl/file.hxx>
+#include <sfx2/objsh.hxx>
+#include <svl/urihelper.hxx>
+#include <sot/formats.hxx>
+#include <tools/urlobj.hxx>
+#include <sot/exchange.hxx>
+#include <tools/debug.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/gdimtf.hxx>
+#include <sfx2/lnkbase.hxx>
+#include <sfx2/app.hxx>
+#include <vcl/graph.hxx>
+#include <svl/stritem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <vcl/dibtools.hxx>
+#include <unotools/charclass.hxx>
+#include <unotools/securityoptions.hxx>
+#include <vcl/GraphicLoader.hxx>
+
+#include "fileobj.hxx"
+#include "impldde.hxx"
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/util/XCloseable.hpp>
+
+using ::com::sun::star::uno::UNO_QUERY;
+using ::com::sun::star::uno::Reference;
+using ::com::sun::star::lang::XComponent;
+using ::com::sun::star::util::XCloseable;
+
+namespace sfx2
+{
+
+namespace {
+
+class SvxInternalLink : public sfx2::SvLinkSource
+{
+public:
+    SvxInternalLink() {}
+
+    virtual bool Connect( sfx2::SvBaseLink* ) override;
+};
+
+}
+
+LinkManager::LinkManager(SfxObjectShell* p)
+    : pPersist( p )
+{
+}
+
+LinkManager::~LinkManager()
+{
+    for(tools::SvRef<SvBaseLink> & rTmp : aLinkTbl)
+    {
+        if( rTmp.is() )
+        {
+            rTmp->Disconnect();
+            rTmp->SetLinkManager( nullptr );
+        }
+    }
+}
+
+void LinkManager::InsertCachedComp(const Reference<XComponent>& xComp)
+{
+    maCachedComps.push_back(xComp);
+}
+
+void LinkManager::CloseCachedComps()
+{
+    for (const auto& rxCachedComp : maCachedComps)
+    {
+        Reference<XCloseable> xCloseable(rxCachedComp, UNO_QUERY);
+        if (!xCloseable.is())
+            continue;
+
+        xCloseable->close(true);
+    }
+    maCachedComps.clear();
+}
+
+void LinkManager::Remove( SvBaseLink const *pLink )
+{
+    // No duplicate links inserted
+    bool bFound = false;
+    for( size_t n = 0; n < aLinkTbl.size(); )
+    {
+        tools::SvRef<SvBaseLink>& rTmp = aLinkTbl[ n ];
+        if( pLink == rTmp.get() )
+        {
+            rTmp->Disconnect();
+            rTmp->SetLinkManager( nullptr );
+            rTmp.clear();
+            bFound = true;
+        }
+
+        // Remove empty ones if they exist
+        if( !rTmp.is() )
+        {
+            aLinkTbl.erase( aLinkTbl.begin() + n );
+            if( bFound )
+                return ;
+        }
+        else
+            ++n;
+    }
+}
+
+void LinkManager::Remove( size_t nPos, size_t nCnt )
+{
+    if( !nCnt || nPos >= aLinkTbl.size() )
+        return;
+
+    if (sal::static_int_cast<size_t>(nPos + nCnt) > aLinkTbl.size())
+        nCnt = aLinkTbl.size() - nPos;
+
+    for( size_t n = nPos; n < nPos + nCnt; ++n)
+    {
+        tools::SvRef<SvBaseLink>& rTmp = aLinkTbl[ n ];
+        if( rTmp.is() )
+        {
+            rTmp->Disconnect();
+            rTmp->SetLinkManager( nullptr );
+        }
+    }
+    aLinkTbl.erase( aLinkTbl.begin() + nPos, aLinkTbl.begin() + nPos + nCnt );
+}
+
+bool LinkManager::Insert( SvBaseLink* pLink )
+{
+    for( size_t n = 0; n < aLinkTbl.size(); ++n )
+    {
+        tools::SvRef<SvBaseLink>& rTmp = aLinkTbl[ n ];
+        if( !rTmp.is() )
+        {
+            aLinkTbl.erase( aLinkTbl.begin() + n-- );
+        }
+        else if( pLink == rTmp.get() )
+            return false; // No duplicate links inserted
+    }
+
+    pLink->SetLinkManager( this );
+    aLinkTbl.emplace_back(pLink );
+    return true;
+}
+
+bool LinkManager::InsertLink( SvBaseLink * pLink,
+                                SvBaseLinkObjectType nObjType,
+                                SfxLinkUpdateMode nUpdateMode,
+                                const OUString* pName )
+{
+    // This First
+    pLink->SetObjType( nObjType );
+    if( pName )
+        pLink->SetName( *pName );
+    pLink->SetUpdateMode( nUpdateMode );
+    return Insert( pLink );
+}
+
+void LinkManager::InsertDDELink( SvBaseLink * pLink,
+                                    const OUString& rServer,
+                                    const OUString& rTopic,
+                                    const OUString& rItem )
+{
+    if( !isClientType( pLink->GetObjType() ) )
+        return;
+
+    OUString sCmd;
+    ::sfx2::MakeLnkName( sCmd, &rServer, rTopic, rItem );
+
+    pLink->SetObjType( SvBaseLinkObjectType::ClientDde );
+    pLink->SetName( sCmd );
+    Insert( pLink );
+}
+
+void LinkManager::InsertDDELink( SvBaseLink * pLink )
+{
+    DBG_ASSERT( isClientType(pLink->GetObjType()), "no OBJECT_CLIENT_SO" );
+    if( !isClientType( pLink->GetObjType() ) )
+        return;
+
+    if( pLink->GetObjType() == SvBaseLinkObjectType::ClientSo )
+        pLink->SetObjType( SvBaseLinkObjectType::ClientDde );
+
+    Insert( pLink );
+}
+
+// Obtain the string for the dialog
+bool LinkManager::GetDisplayNames( const SvBaseLink * pLink,
+                                        OUString* pType,
+                                        OUString* pFile,
+                                        OUString* pLinkStr,
+                                        OUString* pFilter )
+{
+    bool bRet = false;
+    const OUString& sLNm( pLink->GetLinkSourceName() );
+    if( !sLNm.isEmpty() )
+    {
+        switch( pLink->GetObjType() )
+        {
+            case SvBaseLinkObjectType::ClientFile:
+            case SvBaseLinkObjectType::ClientGraphic:
+            case SvBaseLinkObjectType::ClientOle:
+                {
+                    sal_Int32 nPos = 0;
+                    OUString sFile( sLNm.getToken( 0, ::sfx2::cTokenSeparator, nPos ) );
+                    OUString sRange( sLNm.getToken( 0, ::sfx2::cTokenSeparator, nPos ) );
+
+                    if( pFile )
+                        *pFile = sFile;
+                    if( pLinkStr )
+                        *pLinkStr = sRange;
+                    if( pFilter )
+                        *pFilter = nPos == -1 ? OUString() : sLNm.copy(nPos);
+
+                    if( pType )
+                    {
+                        SvBaseLinkObjectType nObjType = pLink->GetObjType();
+                        *pType = SfxResId(
+                                    ( SvBaseLinkObjectType::ClientFile == nObjType || SvBaseLinkObjectType::ClientOle == nObjType )
+                                            ? RID_SVXSTR_FILELINK
+                                            : RID_SVXSTR_GRAFIKLINK);
+                    }
+                    bRet = true;
+                }
+                break;
+            case SvBaseLinkObjectType::ClientDde:
+                {
+                    sal_Int32 nTmp = 0;
+                    OUString sServer( sLNm.getToken( 0, cTokenSeparator, nTmp ) );
+                    OUString sTopic( sLNm.getToken( 0, cTokenSeparator, nTmp ) );
+
+                    if( pType )
+                        *pType = sServer;
+                    if( pFile )
+                        *pFile = sTopic;
+                    if( pLinkStr )
+                        *pLinkStr = nTmp != -1 ? sLNm.copy(nTmp) : OUString();
+                    bRet = true;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    return bRet;
+}
+
+void LinkManager::UpdateAllLinks(
+    bool bAskUpdate,
+    bool bUpdateGrfLinks,
+    weld::Window* pParentWin )
+{
+    // First make a copy of the array in order to update links
+    // links in ... no contact between them!
+    std::vector<SvBaseLink*> aTmpArr;
+    for( size_t n = 0; n < aLinkTbl.size(); ++n )
+    {
+        tools::SvRef<SvBaseLink>& rLink = aLinkTbl[ n ];
+        if( !rLink.is() )
+        {
+            Remove( n-- );
+            continue;
+        }
+        aTmpArr.push_back( rLink.get() );
+    }
+
+    for(SvBaseLink* pLink : aTmpArr)
+    {
+        // search first in the array after the entry
+        bool bFound = false;
+        for(const tools::SvRef<SvBaseLink> & i : aLinkTbl)
+            if( pLink == i.get() )
+            {
+                bFound = true;
+                break;
+            }
+
+        if( !bFound )
+            continue;  // was not available!
+
+        // Graphic-Links not to update yet
+        if( !pLink->IsVisible() ||
+            ( !bUpdateGrfLinks && SvBaseLinkObjectType::ClientGraphic == pLink->GetObjType() ))
+            continue;
+
+        if( bAskUpdate )
+        {
+            OUString aMsg = SfxResId(STR_QUERY_UPDATE_LINKS);
+            INetURLObject aURL(pPersist->getDocumentBaseURL());
+            aMsg = aMsg.replaceFirst("%{filename}", aURL.GetLastName());
+
+            std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(pParentWin,
+                                                           VclMessageType::Question, VclButtonsType::YesNo, aMsg));
+            xQueryBox->set_default_response(RET_YES);
+
+            int nRet = xQueryBox->run();
+            if( RET_YES != nRet )
+            {
+                SfxObjectShell* pShell = pLink->GetLinkManager()->GetPersist();
+
+                if(pShell)
+                {
+                    comphelper::EmbeddedObjectContainer& rEmbeddedObjectContainer = pShell->getEmbeddedObjectContainer();
+                    rEmbeddedObjectContainer.setUserAllowsLinkUpdate(false);
+                }
+
+                return ;        // nothing should be updated
+            }
+            bAskUpdate = false;  // once is enough
+        }
+
+        pLink->Update();
+    }
+    CloseCachedComps();
+}
+
+SvLinkSourceRef LinkManager::CreateObj( SvBaseLink const * pLink )
+{
+    switch( pLink->GetObjType() )
+    {
+        case SvBaseLinkObjectType::ClientFile:
+        case SvBaseLinkObjectType::ClientGraphic:
+        case SvBaseLinkObjectType::ClientOle:
+            return new SvFileObject;
+        case SvBaseLinkObjectType::Internal:
+            return new SvxInternalLink;
+        case SvBaseLinkObjectType::ClientDde:
+            return new SvDDEObject;
+        default:
+            return SvLinkSourceRef();
+       }
+}
+
+bool LinkManager::InsertServer( SvLinkSource* pObj )
+{
+    // no duplicate inserts
+    if( !pObj )
+        return false;
+
+    return aServerTbl.insert( pObj ).second;
+}
+
+void LinkManager::RemoveServer( SvLinkSource* pObj )
+{
+    aServerTbl.erase( pObj );
+}
+
+void MakeLnkName( OUString& rName, const OUString* pType, const OUString& rFile,
+                    const OUString& rLink, const OUString* pFilter )
+{
+    if( pType )
+    {
+        rName = comphelper::string::strip(*pType, ' ')
+            + OUStringChar(cTokenSeparator);
+    }
+    else
+        rName.clear();
+
+    rName += rFile;
+
+    rName = comphelper::string::strip(rName, ' ')
+        + OUStringChar(cTokenSeparator);
+    rName = comphelper::string::strip(rName, ' ') + rLink;
+    if( pFilter )
+    {
+        rName += OUStringChar(cTokenSeparator) + *pFilter;
+        rName = comphelper::string::strip(rName, ' ');
+    }
+}
+
+void LinkManager::ReconnectDdeLink(SfxObjectShell& rServer)
+{
+    SfxMedium* pMed = rServer.GetMedium();
+    if (!pMed)
+        return;
+
+    const ::sfx2::SvBaseLinks& rLinks = GetLinks();
+    size_t n = rLinks.size();
+
+    for (size_t i = 0; i < n; ++i)
+    {
+        ::sfx2::SvBaseLink* p = rLinks[i].get();
+        OUString aType, aFile, aLink, aFilter;
+        if (!GetDisplayNames(p, &aType, &aFile, &aLink, &aFilter))
+            continue;
+
+        if (aType != "soffice")
+            // DDE connections between OOo apps are always named 'soffice'.
+            continue;
+
+        OUString aTmp;
+        OUString aURL = aFile;
+        if (osl::FileBase::getFileURLFromSystemPath(aFile, aTmp)
+            == osl::FileBase::E_None)
+            aURL = aTmp;
+
+        if (!aURL.equalsIgnoreAsciiCase(pMed->GetName()))
+            // This DDE link is not associated with this server shell...  Skip it.
+            continue;
+
+        if (aLink.isEmpty())
+            continue;
+
+        LinkServerShell(aLink, rServer, *p);
+    }
+}
+
+void LinkManager::LinkServerShell(const OUString& rPath, SfxObjectShell& rServer, ::sfx2::SvBaseLink& rLink)
+{
+    ::sfx2::SvLinkSource* pSrvSrc = rServer.DdeCreateLinkSource(rPath);
+    if (pSrvSrc)
+    {
+        css::datatransfer::DataFlavor aFl;
+        SotExchange::GetFormatDataFlavor(rLink.GetContentType(), aFl);
+        rLink.SetObj(pSrvSrc);
+        pSrvSrc->AddDataAdvise(
+            &rLink, aFl.MimeType,
+            SfxLinkUpdateMode::ONCALL == rLink.GetUpdateMode() ? ADVISEMODE_ONLYONCE : 0);
+    }
+}
+
+void LinkManager::InsertFileLink(
+    sfx2::SvBaseLink& rLink, SvBaseLinkObjectType nFileType, const OUString& rFileNm,
+    const OUString* pFilterNm, const OUString* pRange)
+{
+    if (!isClientType(rLink.GetObjType()))
+        return;
+
+    OUStringBuffer aBuf(64);
+    aBuf.append(rFileNm);
+    aBuf.append(sfx2::cTokenSeparator);
+
+    if (pRange)
+        aBuf.append(*pRange);
+
+    if (pFilterNm)
+    {
+        aBuf.append(sfx2::cTokenSeparator);
+        aBuf.append(*pFilterNm);
+    }
+
+    OUString aCmd = aBuf.makeStringAndClear();
+    InsertLink(&rLink, nFileType, SfxLinkUpdateMode::ONCALL, &aCmd);
+}
+
+// A transfer is aborted, so cancel all download media
+// (for now this is only of interest for the file links!)
+void LinkManager::CancelTransfers()
+{
+
+    const sfx2::SvBaseLinks& rLnks = GetLinks();
+    for( size_t n = rLnks.size(); n; )
+    {
+        const sfx2::SvBaseLink& rLnk = *rLnks[--n];
+        if (isClientFileType(rLnk.GetObjType()))
+        {
+            if (SvFileObject* pFileObj = static_cast<SvFileObject*>(rLnk.GetObj()))
+                pFileObj->CancelTransfers();
+        }
+    }
+}
+
+// For the purpose of sending Status information from the file object to
+// the base link, there exist a dedicated ClipBoardId. The SvData-object
+// gets the appropriate information as a string
+// For now this is required for file object in conjunction with JavaScript
+// - needs information about Load/Abort/Error
+SotClipboardFormatId LinkManager::RegisterStatusInfoId()
+{
+    static SotClipboardFormatId nFormat = SotClipboardFormatId::NONE;
+
+    if( nFormat == SotClipboardFormatId::NONE )
+    {
+        nFormat = SotExchange::RegisterFormatName(
+                    "StatusInfo from SvxInternalLink");
+    }
+    return nFormat;
+}
+
+bool LinkManager::GetGraphicFromAny(const OUString& rMimeType,
+                                    const css::uno::Any & rValue,
+                                    Graphic& rGraphic,
+                                    weld::Window* pParentWin)
+{
+    bool bRet = false;
+
+    if (!rValue.hasValue())
+        return bRet;
+
+    if (rValue.has<OUString>())
+    {
+        OUString sReferer;
+        SfxObjectShell* sh = GetPersist();
+        if (sh && sh->HasName())
+            sReferer = sh->GetMedium()->GetName();
+
+        OUString sURL = rValue.get<OUString>();
+        if (!SvtSecurityOptions().isUntrustedReferer(sReferer))
+            rGraphic = vcl::graphic::loadFromURL(sURL, pParentWin);
+        if (rGraphic.IsNone())
+            rGraphic.SetDefaultType();
+        rGraphic.setOriginURL(sURL);
+        return true;
+    }
+    else if (rValue.has<css::uno::Sequence<sal_Int8>>())
+    {
+        auto aSeq = rValue.get<css::uno::Sequence<sal_Int8>>();
+
+        SvMemoryStream aMemStm( const_cast<sal_Int8 *>(aSeq.getConstArray()), aSeq.getLength(),
+                                StreamMode::READ );
+        aMemStm.Seek( 0 );
+
+        switch( SotExchange::GetFormatIdFromMimeType( rMimeType ) )
+        {
+        case SotClipboardFormatId::SVXB:
+            {
+                ReadGraphic( aMemStm, rGraphic );
+                bRet = true;
+            }
+            break;
+        case SotClipboardFormatId::GDIMETAFILE:
+            {
+                GDIMetaFile aMtf;
+                aMtf.Read( aMemStm );
+                rGraphic = aMtf;
+                bRet = true;
+            }
+            break;
+        case SotClipboardFormatId::BITMAP:
+            {
+                Bitmap aBmp;
+                ReadDIB(aBmp, aMemStm, true);
+                rGraphic = aBmp;
+                bRet = true;
+            }
+            break;
+        default: break;
+        }
+    }
+    return bRet;
+}
+
+static OUString lcl_DDE_RelToAbs( const OUString& rTopic, const OUString& rBaseURL )
+{
+    OUString sRet;
+    INetURLObject aURL( rTopic );
+    if( INetProtocol::NotValid == aURL.GetProtocol() )
+        osl::FileBase::getFileURLFromSystemPath(rTopic, sRet);
+    if( sRet.isEmpty() )
+        sRet = URIHelper::SmartRel2Abs( INetURLObject(rBaseURL), rTopic, URIHelper::GetMaybeFileHdl() );
+    return sRet;
+}
+
+bool SvxInternalLink::Connect( sfx2::SvBaseLink* pLink )
+{
+    SfxObjectShell* pFndShell = nullptr;
+    sal_uInt16 nUpdateMode = css::document::UpdateDocMode::NO_UPDATE;
+    OUString sTopic, sItem, sReferer;
+    LinkManager* pLinkMgr = pLink->GetLinkManager();
+    if (pLinkMgr && sfx2::LinkManager::GetDisplayNames(pLink, nullptr, &sTopic, &sItem) && !sTopic.isEmpty())
+    {
+        // first only loop over the DocumentShells the shells and find those
+        // with the name:
+        CharClass aCC( LanguageTag( LANGUAGE_SYSTEM) );
+
+        bool bFirst = true;
+        SfxObjectShell* pShell = pLinkMgr->GetPersist();
+        if( pShell && pShell->GetMedium() )
+        {
+            sReferer = pShell->GetMedium()->GetBaseURL();
+            const SfxUInt16Item* pItem = SfxItemSet::GetItem<SfxUInt16Item>(pShell->GetMedium()->GetItemSet(), SID_UPDATEDOCMODE, false);
+            if ( pItem )
+                nUpdateMode = pItem->GetValue();
+        }
+
+        OUString sNmURL(aCC.lowercase(lcl_DDE_RelToAbs(sTopic, sReferer)));
+
+        if ( !pShell )
+        {
+            bFirst = false;
+            pShell = SfxObjectShell::GetFirst( nullptr, false );
+        }
+
+        OUString sTmp;
+        while( pShell )
+        {
+            if( sTmp.isEmpty() )
+            {
+                sTmp = pShell->GetTitle( SFX_TITLE_FULLNAME );
+                sTmp = lcl_DDE_RelToAbs(sTmp, sReferer );
+            }
+
+
+            sTmp = aCC.lowercase( sTmp );
+            if( sTmp == sNmURL )  // we want these
+            {
+                pFndShell = pShell;
+                break;
+            }
+
+            if( bFirst )
+            {
+                bFirst = false;
+                pShell = SfxObjectShell::GetFirst( nullptr, false );
+            }
+            else
+                pShell = SfxObjectShell::GetNext( *pShell, nullptr, false );
+
+            sTmp.clear();
+        }
+    }
+
+    // empty topics are not allowed - which document is it
+    if( sTopic.isEmpty() )
+        return false;
+
+    if (pFndShell)
+    {
+        sfx2::SvLinkSource* pNewSrc = pFndShell->DdeCreateLinkSource( sItem );
+        if( pNewSrc )
+        {
+            css::datatransfer::DataFlavor aFl;
+            SotExchange::GetFormatDataFlavor( pLink->GetContentType(), aFl );
+
+            pLink->SetObj( pNewSrc );
+            pNewSrc->AddDataAdvise( pLink, aFl.MimeType,
+                                SfxLinkUpdateMode::ONCALL == pLink->GetUpdateMode()
+                                    ? ADVISEMODE_ONLYONCE
+                                    : 0 );
+            return true;
+        }
+    }
+    else
+    {
+        // then try to download the file:
+        INetURLObject aURL( sTopic );
+        INetProtocol eOld = aURL.GetProtocol();
+        sTopic = lcl_DDE_RelToAbs( sTopic, sReferer );
+        aURL.SetURL( sTopic );
+        if( INetProtocol::NotValid != eOld ||
+            INetProtocol::Http != aURL.GetProtocol() )
+        {
+            SfxStringItem aName( SID_FILE_NAME, sTopic );
+            SfxBoolItem aMinimized(SID_MINIMIZED, true);
+            SfxBoolItem aHidden(SID_HIDDEN, true);
+            SfxStringItem aTarget( SID_TARGETNAME, "_blank" );
+            SfxStringItem aReferer( SID_REFERER, sReferer );
+            SfxUInt16Item aUpdate( SID_UPDATEDOCMODE, nUpdateMode );
+            SfxBoolItem aReadOnly(SID_DOC_READONLY, false);
+
+            // Disable automatic re-connection to avoid this link instance
+            // being destroyed at re-connection.
+            SfxBoolItem aDdeConnect(SID_DDE_RECONNECT_ONLOAD, false);
+
+            // #i14200# (DDE-link crashes wordprocessor)
+            SfxAllItemSet aArgs( SfxGetpApp()->GetPool() );
+            aArgs.Put(aReferer);
+            aArgs.Put(aTarget);
+            aArgs.Put(aHidden);
+            aArgs.Put(aMinimized);
+            aArgs.Put(aName);
+            aArgs.Put(aUpdate);
+            aArgs.Put(aReadOnly);
+            aArgs.Put(aDdeConnect);
+            Reference<XComponent> xComp = SfxObjectShell::CreateAndLoadComponent(aArgs);
+            pFndShell = SfxObjectShell::GetShellFromComponent(xComp);
+            if (xComp.is() && pFndShell)
+            {
+                pLinkMgr->InsertCachedComp(xComp);
+                sfx2::LinkManager::LinkServerShell(sItem, *pFndShell, *pLink);
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/linksrc.cxx b/sfx2/source/appl/linksrc.cxx
new file mode 100644
index 000000000..d249f8e28
--- /dev/null
+++ b/sfx2/source/appl/linksrc.cxx
@@ -0,0 +1,416 @@
+/* -*- 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 <sfx2/linksrc.hxx>
+#include <sfx2/lnkbase.hxx>
+#include <com/sun/star/uno/Any.hxx>
+
+#include <vcl/timer.hxx>
+#include <memory>
+#include <vector>
+#include <algorithm>
+
+
+using namespace ::com::sun::star::uno;
+
+namespace sfx2
+{
+
+namespace {
+
+class SvLinkSourceTimer : public Timer
+{
+    SvLinkSource *  pOwner;
+    virtual void    Invoke() override;
+public:
+    explicit SvLinkSourceTimer( SvLinkSource * pOwn );
+};
+
+}
+
+SvLinkSourceTimer::SvLinkSourceTimer( SvLinkSource * pOwn )
+    : pOwner( pOwn )
+{
+}
+
+void SvLinkSourceTimer::Invoke()
+{
+    // Secure against being destroyed in Handler
+    SvLinkSourceRef xHoldAlive( pOwner );
+    pOwner->SendDataChanged();
+}
+
+static void StartTimer( std::unique_ptr<SvLinkSourceTimer>& pTimer, SvLinkSource * pOwner,
+                        sal_uInt64 nTimeout )
+{
+    if( !pTimer )
+    {
+        pTimer.reset( new SvLinkSourceTimer( pOwner ) );
+        pTimer->SetTimeout( nTimeout );
+        pTimer->Start();
+    }
+}
+
+namespace {
+
+struct SvLinkSource_Entry_Impl
+{
+    tools::SvRef<SvBaseLink>  xSink;
+    OUString                  aDataMimeType;
+    sal_uInt16                nAdviseModes;
+    bool                      bIsDataSink;
+
+    SvLinkSource_Entry_Impl( SvBaseLink* pLink, const OUString& rMimeType,
+                                sal_uInt16 nAdvMode )
+        : xSink( pLink ), aDataMimeType( rMimeType ),
+            nAdviseModes( nAdvMode ), bIsDataSink( true )
+    {}
+
+    explicit SvLinkSource_Entry_Impl( SvBaseLink* pLink )
+        : xSink( pLink ), nAdviseModes( 0 ), bIsDataSink( false )
+    {}
+};
+
+class SvLinkSource_Array_Impl
+{
+friend class SvLinkSource_EntryIter_Impl;
+private:
+    std::vector<std::unique_ptr<SvLinkSource_Entry_Impl>> mvData;
+
+public:
+    SvLinkSource_Array_Impl() : mvData() {}
+
+    size_t size() const { return mvData.size(); }
+    SvLinkSource_Entry_Impl *operator[](size_t idx) const { return mvData[idx].get(); }
+    void push_back(SvLinkSource_Entry_Impl* rData) { mvData.emplace_back(rData); }
+
+    void DeleteAndDestroy(SvLinkSource_Entry_Impl const * p)
+    {
+        auto it = std::find_if(mvData.begin(), mvData.end(),
+            [&p](const std::unique_ptr<SvLinkSource_Entry_Impl>& rxData) { return rxData.get() == p; });
+        if (it != mvData.end())
+            mvData.erase(it);
+    }
+};
+
+class SvLinkSource_EntryIter_Impl
+{
+    std::vector<SvLinkSource_Entry_Impl*> aArr;
+    const SvLinkSource_Array_Impl& rOrigArr;
+    sal_uInt16 nPos;
+public:
+    explicit SvLinkSource_EntryIter_Impl( const SvLinkSource_Array_Impl& rArr );
+    SvLinkSource_Entry_Impl* Curr()
+                            { return nPos < aArr.size() ? aArr[ nPos ] : nullptr; }
+    SvLinkSource_Entry_Impl* Next();
+    bool IsValidCurrValue( SvLinkSource_Entry_Impl const * pEntry );
+};
+
+}
+
+SvLinkSource_EntryIter_Impl::SvLinkSource_EntryIter_Impl(
+        const SvLinkSource_Array_Impl& rArr )
+    : rOrigArr( rArr ), nPos( 0 )
+{
+    for (auto const & i : rArr.mvData)
+        aArr.push_back(i.get());
+}
+
+bool SvLinkSource_EntryIter_Impl::IsValidCurrValue( SvLinkSource_Entry_Impl const * pEntry )
+{
+    if ( nPos >= aArr.size() )
+        return false;
+    if (aArr[nPos] != pEntry)
+        return false;
+    for (auto const & i : rOrigArr.mvData)
+        if (i.get() == pEntry)
+            return true;
+    return false;
+}
+
+SvLinkSource_Entry_Impl* SvLinkSource_EntryIter_Impl::Next()
+{
+    SvLinkSource_Entry_Impl* pRet = nullptr;
+    if( nPos + 1 < static_cast<sal_uInt16>(aArr.size()) )
+    {
+        ++nPos;
+        if( rOrigArr.size() == aArr.size() &&
+            rOrigArr[ nPos ] == aArr[ nPos ] )
+            pRet = aArr[ nPos ];
+        else
+        {
+            // then we must search the current (or the next) in the orig
+            do {
+                pRet = aArr[ nPos ];
+                for (auto const & i : rOrigArr.mvData)
+                    if (i.get() == pRet)
+                        return pRet;
+                pRet = nullptr;
+                ++nPos;
+            } while( nPos < aArr.size() );
+
+            if( nPos >= aArr.size() )
+                pRet = nullptr;
+        }
+    }
+    return pRet;
+}
+
+struct SvLinkSource_Impl
+{
+    SvLinkSource_Array_Impl aArr;
+    OUString                aDataMimeType;
+    std::unique_ptr<SvLinkSourceTimer>
+                            pTimer;
+    sal_uInt64              nTimeout;
+    css::uno::Reference<css::io::XInputStream>
+                            m_xInputStreamToLoadFrom;
+    bool                    m_bIsReadOnly;
+
+    SvLinkSource_Impl()
+        : nTimeout(3000)
+        , m_bIsReadOnly(false)
+    {
+    }
+};
+
+SvLinkSource::SvLinkSource()
+     : pImpl( new SvLinkSource_Impl )
+{
+}
+
+SvLinkSource::~SvLinkSource()
+{
+}
+
+
+SvLinkSource::StreamToLoadFrom SvLinkSource::getStreamToLoadFrom()
+{
+    return StreamToLoadFrom(
+        pImpl->m_xInputStreamToLoadFrom,
+        pImpl->m_bIsReadOnly);
+}
+
+void SvLinkSource::setStreamToLoadFrom(const css::uno::Reference<css::io::XInputStream>& xInputStream, bool bIsReadOnly )
+{
+    pImpl->m_xInputStreamToLoadFrom = xInputStream;
+    pImpl->m_bIsReadOnly = bIsReadOnly;
+}
+
+// #i88291#
+void SvLinkSource::clearStreamToLoadFrom()
+{
+    pImpl->m_xInputStreamToLoadFrom.clear();
+}
+
+void  SvLinkSource::Closed()
+{
+    SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
+    for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
+        if( !p->bIsDataSink )
+            p->xSink->Closed();
+}
+
+sal_uInt64 SvLinkSource::GetUpdateTimeout() const
+{
+    return pImpl->nTimeout;
+}
+
+void SvLinkSource::SetUpdateTimeout( sal_uInt64 nTimeout )
+{
+    pImpl->nTimeout = nTimeout;
+    if( pImpl->pTimer )
+        pImpl->pTimer->SetTimeout( nTimeout );
+}
+
+void SvLinkSource::SendDataChanged()
+{
+    SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
+    for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
+    {
+        if( p->bIsDataSink )
+        {
+            OUString sDataMimeType( pImpl->aDataMimeType );
+            if( sDataMimeType.isEmpty() )
+                sDataMimeType = p->aDataMimeType;
+
+            Any aVal;
+            if( ( p->nAdviseModes & ADVISEMODE_NODATA ) ||
+                GetData( aVal, sDataMimeType, true ) )
+            {
+                p->xSink->DataChanged( sDataMimeType, aVal );
+
+                if ( !aIter.IsValidCurrValue( p ) )
+                    continue;
+
+                if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
+                {
+                    pImpl->aArr.DeleteAndDestroy( p );
+                }
+
+            }
+        }
+    }
+    pImpl->pTimer.reset();
+    pImpl->aDataMimeType.clear();
+}
+
+void SvLinkSource::NotifyDataChanged()
+{
+    if( pImpl->nTimeout )
+        StartTimer( pImpl->pTimer, this, pImpl->nTimeout ); // New timeout
+    else
+    {
+        SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
+        for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
+            if( p->bIsDataSink )
+            {
+                Any aVal;
+                if( ( p->nAdviseModes & ADVISEMODE_NODATA ) ||
+                    GetData( aVal, p->aDataMimeType, true ) )
+                {
+                    p->xSink->DataChanged( p->aDataMimeType, aVal );
+
+                    if ( !aIter.IsValidCurrValue( p ) )
+                        continue;
+
+                    if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
+                    {
+                        pImpl->aArr.DeleteAndDestroy( p );
+                    }
+                }
+            }
+
+        pImpl->pTimer.reset();
+    }
+}
+
+// notify the sink, the mime type is not
+// a selection criterion
+void SvLinkSource::DataChanged( const OUString & rMimeType,
+                                const css::uno::Any & rVal )
+{
+    if( pImpl->nTimeout && !rVal.hasValue() )
+    {   // only when no data was included
+        // fire all data to the sink, independent of the requested format
+        pImpl->aDataMimeType = rMimeType;
+        StartTimer( pImpl->pTimer, this, pImpl->nTimeout ); // New timeout
+    }
+    else
+    {
+        SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
+        for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
+        {
+            if( p->bIsDataSink )
+            {
+                p->xSink->DataChanged( rMimeType, rVal );
+
+                if ( !aIter.IsValidCurrValue( p ) )
+                    continue;
+
+                if( p->nAdviseModes & ADVISEMODE_ONLYONCE )
+                {
+                    pImpl->aArr.DeleteAndDestroy( p );
+                }
+            }
+        }
+
+        pImpl->pTimer.reset();
+    }
+}
+
+
+// only one link is correct
+void SvLinkSource::AddDataAdvise( SvBaseLink * pLink, const OUString& rMimeType,
+                                    sal_uInt16 nAdviseModes )
+{
+    SvLinkSource_Entry_Impl* pNew = new SvLinkSource_Entry_Impl(
+                    pLink, rMimeType, nAdviseModes );
+    pImpl->aArr.push_back( pNew );
+}
+
+void SvLinkSource::RemoveAllDataAdvise( SvBaseLink const * pLink )
+{
+    SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
+    for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
+        if( p->bIsDataSink && p->xSink.get() == pLink )
+        {
+            pImpl->aArr.DeleteAndDestroy( p );
+        }
+}
+
+// only one link is correct
+void SvLinkSource::AddConnectAdvise( SvBaseLink * pLink )
+{
+    SvLinkSource_Entry_Impl* pNew = new SvLinkSource_Entry_Impl( pLink );
+    pImpl->aArr.push_back( pNew );
+}
+
+void SvLinkSource::RemoveConnectAdvise( SvBaseLink const * pLink )
+{
+    SvLinkSource_EntryIter_Impl aIter( pImpl->aArr );
+    for( SvLinkSource_Entry_Impl* p = aIter.Curr(); p; p = aIter.Next() )
+        if( !p->bIsDataSink && p->xSink.get() == pLink )
+        {
+            pImpl->aArr.DeleteAndDestroy( p );
+        }
+}
+
+bool SvLinkSource::HasDataLinks() const
+{
+    bool bRet = false;
+    for( sal_uInt16 n = 0, nEnd = pImpl->aArr.size(); n < nEnd; ++n )
+        if( pImpl->aArr[ n ]->bIsDataSink )
+        {
+            bRet = true;
+            break;
+        }
+    return bRet;
+}
+
+// sal_True => waitinmg for data
+bool SvLinkSource::IsPending() const
+{
+    return false;
+}
+
+// sal_True => data complete loaded
+bool SvLinkSource::IsDataComplete() const
+{
+    return true;
+}
+
+bool SvLinkSource::Connect( SvBaseLink* )
+{
+    return true;
+}
+
+bool SvLinkSource::GetData( css::uno::Any &, const OUString &, bool )
+{
+    return false;
+}
+
+void SvLinkSource::Edit(weld::Window *, SvBaseLink *, const Link<const OUString&, void>&)
+{
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/lnkbase2.cxx b/sfx2/source/appl/lnkbase2.cxx
new file mode 100644
index 000000000..8df00b9bd
--- /dev/null
+++ b/sfx2/source/appl/lnkbase2.cxx
@@ -0,0 +1,612 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <memory>
+#include <sfx2/lnkbase.hxx>
+#include <sot/exchange.hxx>
+#include <com/sun/star/uno/Any.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <sfx2/linkmgr.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <tools/debug.hxx>
+#include <svl/svdde.hxx>
+#include <osl/diagnose.h>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+namespace sfx2
+{
+
+namespace {
+
+class  ImplDdeItem;
+
+}
+
+struct BaseLink_Impl
+{
+    Link<SvBaseLink&,void> m_aEndEditLink;
+    LinkManager*        m_pLinkMgr;
+    weld::Window*       m_pParentWin;
+    std::unique_ptr<FileDialogHelper>
+                        m_pFileDlg;
+    bool                m_bIsConnect;
+
+    BaseLink_Impl() :
+          m_pLinkMgr( nullptr )
+        , m_pParentWin( nullptr )
+        , m_bIsConnect( false )
+        {}
+};
+
+// only for internal management
+struct ImplBaseLinkData
+{
+    struct tClientType
+    {
+        // applies for all links
+        SotClipboardFormatId nCntntType; // Update Format
+        // Not Ole-Links
+        bool                 bIntrnlLnk;  // It is an internal link
+        SfxLinkUpdateMode    nUpdateMode; // UpdateMode
+    };
+
+    struct tDDEType
+    {
+        ImplDdeItem* pItem;
+    };
+
+    union {
+        tClientType ClientType;
+        tDDEType DDEType;
+    };
+    ImplBaseLinkData()
+    {
+        ClientType.nCntntType = SotClipboardFormatId::NONE;
+        ClientType.bIntrnlLnk = false;
+        ClientType.nUpdateMode = SfxLinkUpdateMode::NONE;
+        DDEType.pItem = nullptr;
+    }
+};
+
+namespace {
+
+class ImplDdeItem : public DdeGetPutItem
+{
+    SvBaseLink* pLink;
+    DdeData aData;
+    Sequence< sal_Int8 > aSeq;  // Datacontainer for DdeData !!!
+    bool bIsValidData : 1;
+    bool bIsInDTOR : 1;
+public:
+#if defined(_WIN32)
+    ImplDdeItem( SvBaseLink& rLink, const OUString& rStr )
+        : DdeGetPutItem( rStr ), pLink( &rLink ), bIsValidData( false ),
+        bIsInDTOR( false )
+    {}
+#endif
+    virtual ~ImplDdeItem() override;
+
+    virtual DdeData* Get( SotClipboardFormatId ) override;
+    virtual bool     Put( const DdeData* ) override;
+    virtual void     AdviseLoop( bool ) override;
+
+    void Notify()
+    {
+        bIsValidData = false;
+        DdeGetPutItem::NotifyClient();
+    }
+
+    bool IsInDTOR() const { return bIsInDTOR; }
+};
+
+}
+
+SvBaseLink::SvBaseLink()
+    : pImpl ( new BaseLink_Impl ),
+      m_bIsReadOnly(false)
+{
+    mnObjType = SvBaseLinkObjectType::ClientSo;
+    pImplData.reset( new ImplBaseLinkData );
+    bVisible = bSynchron = true;
+    bWasLastEditOK = false;
+}
+
+
+SvBaseLink::SvBaseLink( SfxLinkUpdateMode nUpdateMode, SotClipboardFormatId nContentType )
+   : pImpl( new BaseLink_Impl ),
+     m_bIsReadOnly(false)
+{
+    mnObjType = SvBaseLinkObjectType::ClientSo;
+    pImplData.reset( new ImplBaseLinkData );
+    bVisible = bSynchron = true;
+    bWasLastEditOK = false;
+
+    // It is going to be an OLE-Link,
+    pImplData->ClientType.nUpdateMode = nUpdateMode;
+    pImplData->ClientType.nCntntType = nContentType;
+    pImplData->ClientType.bIntrnlLnk = false;
+}
+
+#if defined(_WIN32)
+
+static DdeTopic* FindTopic( const OUString & rLinkName, sal_uInt16* pItemStt )
+{
+    if( rLinkName.isEmpty() )
+        return nullptr;
+
+    OUString sNm( rLinkName );
+    sal_Int32 nTokenPos = 0;
+    OUString sService( sNm.getToken( 0, cTokenSeparator, nTokenPos ) );
+
+    DdeServices& rSvc = DdeService::GetServices();
+    for (auto const& elem : rSvc)
+    {
+        if(elem->GetName() == sService)
+        {
+            // then we search for the Topic
+            OUString sTopic( sNm.getToken( 0, cTokenSeparator, nTokenPos ) );
+            if( pItemStt )
+                *pItemStt = nTokenPos;
+
+            std::vector<DdeTopic*>& rTopics = elem->GetTopics();
+
+            for (auto const& topic : rTopics)
+                if( topic->GetName() == sTopic )
+                    return topic;
+            break;
+        }
+    }
+    return nullptr;
+}
+
+SvBaseLink::SvBaseLink( const OUString& rLinkName, SvBaseLinkObjectType nObjectType, SvLinkSource* pObj )
+    : pImpl()
+    , m_bIsReadOnly(false)
+{
+    bVisible = bSynchron = true;
+    bWasLastEditOK = false;
+    aLinkName = rLinkName;
+    pImplData.reset( new ImplBaseLinkData );
+    mnObjType = nObjectType;
+
+    if( !pObj )
+    {
+        DBG_ASSERT( pObj, "Where is my left-most object" );
+        return;
+    }
+
+    if( SvBaseLinkObjectType::DdeExternal == mnObjType )
+    {
+        sal_uInt16 nItemStt = 0;
+        DdeTopic* pTopic = FindTopic( aLinkName, &nItemStt );
+        if( pTopic )
+        {
+            // then we have it all together
+            // MM_TODO how do I get the name
+            OUString aStr = aLinkName; // xLinkName->GetDisplayName();
+            aStr = aStr.copy( nItemStt );
+            pImplData->DDEType.pItem = new ImplDdeItem( *this, aStr );
+            pTopic->InsertItem( pImplData->DDEType.pItem );
+
+            // store the Advice
+            xObj = pObj;
+        }
+    }
+    else if( pObj->Connect( this ) )
+        xObj = pObj;
+}
+
+#endif
+
+SvBaseLink::~SvBaseLink()
+{
+    Disconnect();
+
+    if( mnObjType == SvBaseLinkObjectType::DdeExternal )
+    {
+        if( !pImplData->DDEType.pItem->IsInDTOR() )
+            delete pImplData->DDEType.pItem;
+    }
+
+    pImplData.reset();
+}
+
+IMPL_LINK( SvBaseLink, EndEditHdl, const OUString&, _rNewName, void )
+{
+    OUString sNewName = _rNewName;
+    if ( !ExecuteEdit( sNewName ) )
+        sNewName.clear();
+    bWasLastEditOK = !sNewName.isEmpty();
+    pImpl->m_aEndEditLink.Call( *this );
+}
+
+
+void SvBaseLink::SetObjType( SvBaseLinkObjectType mnObjTypeP )
+{
+    DBG_ASSERT( mnObjType != SvBaseLinkObjectType::ClientDde, "type already set" );
+    DBG_ASSERT( !xObj.is(), "object exist" );
+
+    mnObjType = mnObjTypeP;
+}
+
+
+void SvBaseLink::SetName( const OUString & rNm )
+{
+    aLinkName = rNm;
+}
+
+
+void SvBaseLink::SetObj( SvLinkSource * pObj )
+{
+    DBG_ASSERT( (isClientType(mnObjType) &&
+                 pImplData->ClientType.bIntrnlLnk) ||
+                mnObjType == SvBaseLinkObjectType::ClientGraphic,
+                "no intern link" );
+    xObj = pObj;
+}
+
+
+void SvBaseLink::SetLinkSourceName( const OUString & rLnkNm )
+{
+    if( aLinkName == rLnkNm )
+        return;
+
+    AddNextRef(); // should be superfluous
+    // remove old connection
+    Disconnect();
+
+    aLinkName = rLnkNm;
+
+    // New Connection
+    GetRealObject_();
+    ReleaseRef(); // should be superfluous
+}
+
+
+void SvBaseLink::SetUpdateMode( SfxLinkUpdateMode nMode )
+{
+    if( isClientType(mnObjType) &&
+        pImplData->ClientType.nUpdateMode != nMode )
+    {
+        AddNextRef();
+        Disconnect();
+
+        pImplData->ClientType.nUpdateMode = nMode;
+        GetRealObject_();
+        ReleaseRef();
+    }
+}
+
+// #i88291#
+void SvBaseLink::clearStreamToLoadFrom()
+{
+    m_xInputStreamToLoadFrom.clear();
+    if( xObj.is() )
+    {
+        xObj->clearStreamToLoadFrom();
+    }
+}
+
+bool SvBaseLink::Update()
+{
+    if( isClientType(mnObjType) )
+    {
+        AddNextRef();
+        Disconnect();
+
+        GetRealObject_();
+        ReleaseRef();
+        if( xObj.is() )
+        {
+            xObj->setStreamToLoadFrom(m_xInputStreamToLoadFrom,m_bIsReadOnly);
+            OUString sMimeType( SotExchange::GetFormatMimeType(
+                            pImplData->ClientType.nCntntType ));
+            Any aData;
+
+            if( xObj->GetData( aData, sMimeType ) )
+            {
+                UpdateResult eRes = DataChanged(sMimeType, aData);
+                bool bSuccess = eRes == SUCCESS;
+                //for manual Updates there is no need to hold the ServerObject
+                if( SvBaseLinkObjectType::ClientDde == mnObjType &&
+                    SfxLinkUpdateMode::ONCALL == GetUpdateMode() && xObj.is() )
+                    xObj->RemoveAllDataAdvise( this );
+                return bSuccess;
+            }
+            if( xObj.is() )
+            {
+                // should be asynchronous?
+                if( xObj->IsPending() )
+                    return true;
+
+                // we do not need the object anymore
+                AddNextRef();
+                Disconnect();
+                ReleaseRef();
+            }
+        }
+    }
+    return false;
+}
+
+
+SfxLinkUpdateMode SvBaseLink::GetUpdateMode() const
+{
+    return isClientType(mnObjType)
+            ? pImplData->ClientType.nUpdateMode
+            : SfxLinkUpdateMode::ONCALL;
+}
+
+
+void SvBaseLink::GetRealObject_( bool bConnect)
+{
+    if( !pImpl->m_pLinkMgr )
+        return;
+
+    DBG_ASSERT( !xObj.is(), "object already exist" );
+
+    if( SvBaseLinkObjectType::ClientDde == mnObjType )
+    {
+        OUString sServer;
+        if( sfx2::LinkManager::GetDisplayNames( this, &sServer ) &&
+            sServer == Application::GetAppName() )  // internal Link !!!
+        {
+            // so that the Internal link can be created!
+            mnObjType = SvBaseLinkObjectType::Internal;
+            xObj = sfx2::LinkManager::CreateObj( this );
+
+            pImplData->ClientType.bIntrnlLnk = true;
+            mnObjType = SvBaseLinkObjectType::ClientDde;  // so we know what it once was!
+        }
+        else
+        {
+            pImplData->ClientType.bIntrnlLnk = false;
+            xObj = sfx2::LinkManager::CreateObj( this );
+        }
+    }
+    else if( isClientType(mnObjType) )
+        xObj = sfx2::LinkManager::CreateObj( this );
+
+    if( bConnect && ( !xObj.is() || !xObj->Connect( this ) ) )
+        Disconnect();
+}
+
+SotClipboardFormatId SvBaseLink::GetContentType() const
+{
+    if( isClientType(mnObjType) )
+        return pImplData->ClientType.nCntntType;
+
+    return SotClipboardFormatId::NONE;  // all Formats ?
+}
+
+
+void SvBaseLink::SetContentType( SotClipboardFormatId nType )
+{
+    if( isClientType(mnObjType) )
+    {
+        pImplData->ClientType.nCntntType = nType;
+    }
+}
+
+LinkManager* SvBaseLink::GetLinkManager()
+{
+    return pImpl->m_pLinkMgr;
+}
+
+const LinkManager* SvBaseLink::GetLinkManager() const
+{
+    return pImpl->m_pLinkMgr;
+}
+
+void SvBaseLink::SetLinkManager( LinkManager* _pMgr )
+{
+    pImpl->m_pLinkMgr = _pMgr;
+}
+
+void SvBaseLink::Disconnect()
+{
+    if( xObj.is() )
+    {
+        xObj->RemoveAllDataAdvise( this );
+        xObj->RemoveConnectAdvise( this );
+        xObj.clear();
+    }
+}
+
+SvBaseLink::UpdateResult SvBaseLink::DataChanged( const OUString &, const css::uno::Any & )
+{
+    if ( mnObjType == SvBaseLinkObjectType::DdeExternal )
+    {
+        if( pImplData->DDEType.pItem )
+            pImplData->DDEType.pItem->Notify();
+    }
+    return SUCCESS;
+}
+
+void SvBaseLink::Edit(weld::Window* pParent, const Link<SvBaseLink&,void>& rEndEditHdl )
+{
+    pImpl->m_pParentWin = pParent;
+    pImpl->m_aEndEditLink = rEndEditHdl;
+    pImpl->m_bIsConnect = xObj.is();
+    if( !pImpl->m_bIsConnect )
+        GetRealObject_( xObj.is() );
+
+    bool bAsync = false;
+    Link<const OUString&, void> aLink = LINK( this, SvBaseLink, EndEditHdl );
+
+    if( isClientType(mnObjType) && pImplData->ClientType.bIntrnlLnk )
+    {
+        if( pImpl->m_pLinkMgr )
+        {
+            SvLinkSourceRef ref = sfx2::LinkManager::CreateObj( this );
+            if( ref.is() )
+            {
+                ref->Edit( pParent, this, aLink );
+                bAsync = true;
+            }
+        }
+    }
+    else
+    {
+        xObj->Edit( pParent, this, aLink );
+        bAsync = true;
+    }
+
+    if ( !bAsync )
+    {
+        ExecuteEdit( OUString() );
+        bWasLastEditOK = false;
+        pImpl->m_aEndEditLink.Call( *this );
+    }
+}
+
+bool SvBaseLink::ExecuteEdit( const OUString& _rNewName )
+{
+    if( !_rNewName.isEmpty() )
+    {
+        SetLinkSourceName( _rNewName );
+        if( !Update() )
+        {
+            OUString sApp, sTopic, sItem, sError;
+            sfx2::LinkManager::GetDisplayNames( this, &sApp, &sTopic, &sItem );
+            if( mnObjType == SvBaseLinkObjectType::ClientDde )
+            {
+                sError = SfxResId(STR_DDE_ERROR);
+
+                sal_Int32 nFndPos = sError.indexOf( "%1" );
+                if( -1 != nFndPos )
+                {
+                    sError = sError.replaceAt( nFndPos, 2, sApp );
+                    nFndPos = nFndPos + sApp.getLength();
+
+                    if( -1 != ( nFndPos = sError.indexOf( "%2", nFndPos )))
+                    {
+                        sError = sError.replaceAt( nFndPos, 2, sTopic );
+                        nFndPos = nFndPos + sTopic.getLength();
+
+                        if( -1 != ( nFndPos = sError.indexOf( "%3", nFndPos )))
+                            sError = sError.replaceAt( nFndPos, 2, sItem );
+                    }
+                }
+            }
+            else
+                return false;
+
+            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pImpl->m_pParentWin,
+                                                                     VclMessageType::Warning, VclButtonsType::Ok, sError));
+            xBox->run();
+        }
+    }
+    else if( !pImpl->m_bIsConnect )
+        Disconnect();
+    pImpl->m_bIsConnect = false;
+    return true;
+}
+
+void SvBaseLink::Closed()
+{
+    if( xObj.is() )
+        xObj->RemoveAllDataAdvise( this );
+}
+
+FileDialogHelper & SvBaseLink::GetInsertFileDialog(const OUString& rFactory) const
+{
+    pImpl->m_pFileDlg.reset( new FileDialogHelper(
+            ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE,
+            FileDialogFlags::Insert, rFactory, SfxFilterFlags::NONE, SfxFilterFlags::NONE, pImpl->m_pParentWin) );
+    return *pImpl->m_pFileDlg;
+}
+
+ImplDdeItem::~ImplDdeItem()
+{
+    bIsInDTOR = true;
+    // So that no-one gets the idea to delete the pointer when Disconnecting!
+    tools::SvRef<SvBaseLink> aRef( pLink );
+    aRef->Disconnect();
+}
+
+DdeData* ImplDdeItem::Get( SotClipboardFormatId nFormat )
+{
+    if( pLink->GetObj() )
+    {
+        // is it still valid?
+        if( bIsValidData && nFormat == aData.GetFormat() )
+            return &aData;
+
+        Any aValue;
+        OUString sMimeType( SotExchange::GetFormatMimeType( nFormat ));
+        if( pLink->GetObj()->GetData( aValue, sMimeType ) )
+        {
+            if( aValue >>= aSeq )
+            {
+                aData = DdeData( aSeq.getConstArray(), aSeq.getLength(), nFormat );
+
+                bIsValidData = true;
+                return &aData;
+            }
+        }
+    }
+    aSeq.realloc( 0 );
+    bIsValidData = false;
+    return nullptr;
+}
+
+
+bool ImplDdeItem::Put( const DdeData*  )
+{
+    OSL_FAIL( "ImplDdeItem::Put not implemented" );
+    return false;
+}
+
+
+void ImplDdeItem::AdviseLoop( bool bOpen )
+{
+    // Connection is closed, so also unsubscribe link
+    if( !pLink->GetObj() )
+        return;
+
+    if( bOpen )
+    {
+        // A connection is re-established
+        if( SvBaseLinkObjectType::DdeExternal == pLink->GetObjType() )
+        {
+            pLink->GetObj()->AddDataAdvise( pLink, "text/plain;charset=utf-16",  ADVISEMODE_NODATA );
+            pLink->GetObj()->AddConnectAdvise( pLink );
+        }
+    }
+    else
+    {
+        // So that no-one gets the idea to delete the pointer
+        // when Disconnecting!
+        tools::SvRef<SvBaseLink> aRef( pLink );
+        aRef->Disconnect();
+    }
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/macroloader.cxx b/sfx2/source/appl/macroloader.cxx
new file mode 100644
index 000000000..46090f712
--- /dev/null
+++ b/sfx2/source/appl/macroloader.cxx
@@ -0,0 +1,338 @@
+/* -*- 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 <macroloader.hxx>
+
+#include <com/sun/star/frame/DispatchResultState.hpp>
+#include <basic/basmgr.hxx>
+#include <basic/sbuno.hxx>
+#include <basic/sberrors.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <cppuhelper/weak.hxx>
+#include <cppuhelper/weakref.hxx>
+#include <framework/documentundoguard.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/objsh.hxx>
+#include <tools/urlobj.hxx>
+#include <vcl/svapp.hxx>
+
+#include <memory>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+
+SfxMacroLoader::SfxMacroLoader(const css::uno::Sequence< css::uno::Any >& aArguments)
+{
+    Reference < XFrame > xFrame;
+    if ( aArguments.hasElements() )
+    {
+        aArguments[0] >>= xFrame;
+        m_xFrame = xFrame;
+    }
+}
+
+OUString SAL_CALL SfxMacroLoader::getImplementationName()
+{
+    return "com.sun.star.comp.sfx2.SfxMacroLoader";
+}
+
+sal_Bool SAL_CALL SfxMacroLoader::supportsService(OUString const & ServiceName)
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+css::uno::Sequence<OUString> SAL_CALL SfxMacroLoader::getSupportedServiceNames()
+{
+    return { "com.sun.star.frame.ProtocolHandler" };
+}
+
+SfxObjectShell* SfxMacroLoader::GetObjectShell_Impl()
+{
+    SfxObjectShell* pDocShell = nullptr;
+    Reference < XFrame > xFrame( m_xFrame.get(), UNO_QUERY );
+    if ( xFrame.is() )
+    {
+        SfxFrame* pFrame=nullptr;
+        for ( pFrame = SfxFrame::GetFirst(); pFrame; pFrame = SfxFrame::GetNext( *pFrame ) )
+        {
+            if ( pFrame->GetFrameInterface() == xFrame )
+                break;
+        }
+
+        if ( pFrame )
+            pDocShell = pFrame->GetCurrentDocument();
+    }
+
+    return pDocShell;
+}
+
+
+uno::Reference<frame::XDispatch> SAL_CALL SfxMacroLoader::queryDispatch(
+    const util::URL&   aURL            ,
+    const OUString&               /*sTargetFrameName*/,
+    sal_Int32                            /*nSearchFlags*/    )
+{
+    uno::Reference<frame::XDispatch> xDispatcher;
+    if(aURL.Complete.startsWith("macro:"))
+        xDispatcher = this;
+    return xDispatcher;
+}
+
+
+uno::Sequence< uno::Reference<frame::XDispatch> > SAL_CALL
+                SfxMacroLoader::queryDispatches( const uno::Sequence < frame::DispatchDescriptor >& seqDescriptor )
+{
+    sal_Int32 nCount = seqDescriptor.getLength();
+    uno::Sequence< uno::Reference<frame::XDispatch> > lDispatcher(nCount);
+    std::transform(seqDescriptor.begin(), seqDescriptor.end(), lDispatcher.begin(),
+        [this](const frame::DispatchDescriptor& rDescr) -> uno::Reference<frame::XDispatch> {
+            return queryDispatch(rDescr.FeatureURL, rDescr.FrameName, rDescr.SearchFlags); });
+    return lDispatcher;
+}
+
+
+void SAL_CALL SfxMacroLoader::dispatchWithNotification(
+    const util::URL& aURL, const uno::Sequence<beans::PropertyValue>& /*lArgs*/,
+    const uno::Reference<frame::XDispatchResultListener>& xListener )
+{
+    SolarMutexGuard aGuard;
+
+    uno::Any aAny;
+    ErrCode nErr = loadMacro( aURL.Complete, aAny, GetObjectShell_Impl() );
+    if( !xListener.is() )
+        return;
+
+    // always call dispatchFinished(), because we didn't load a document but
+    // executed a macro instead!
+    frame::DispatchResultEvent aEvent;
+
+    aEvent.Source = static_cast< ::cppu::OWeakObject* >(this);
+    if( nErr == ERRCODE_NONE )
+        aEvent.State = frame::DispatchResultState::SUCCESS;
+    else
+        aEvent.State = frame::DispatchResultState::FAILURE;
+
+    xListener->dispatchFinished( aEvent ) ;
+}
+
+uno::Any SAL_CALL SfxMacroLoader::dispatchWithReturnValue(
+    const util::URL& aURL, const uno::Sequence<beans::PropertyValue>& )
+{
+    uno::Any aRet;
+    ErrCode nErr = loadMacro( aURL.Complete, aRet, GetObjectShell_Impl() );
+
+    // aRet gets set to a different value only if nErr == ERRCODE_NONE
+    // Return it in such case to preserve the original behaviour
+
+    // In all other cases (nErr != ERRCODE_NONE), the calling code gets
+    // the actual error code back
+    if ( nErr != ERRCODE_NONE )
+    {
+        beans::PropertyValue aErrorCode;
+
+        aErrorCode.Name = "ErrorCode";
+        aErrorCode.Value <<= sal_uInt32(nErr);
+
+        aRet <<= aErrorCode;
+    }
+
+    return aRet;
+}
+
+void SAL_CALL SfxMacroLoader::dispatch(
+    const util::URL& aURL, const uno::Sequence<beans::PropertyValue>& /*lArgs*/ )
+{
+    SolarMutexGuard aGuard;
+
+    uno::Any aAny;
+    loadMacro( aURL.Complete, aAny, GetObjectShell_Impl() );
+}
+
+void SAL_CALL SfxMacroLoader::addStatusListener(
+    const uno::Reference< frame::XStatusListener >& ,
+    const util::URL&                                                    )
+{
+    /* TODO
+            How we can handle different listener for further coming or currently running dispatch() jobs
+            without any inconsistency!
+     */
+}
+
+
+void SAL_CALL SfxMacroLoader::removeStatusListener(
+    const uno::Reference< frame::XStatusListener >&,
+    const util::URL&                                                  )
+{
+}
+
+ErrCode SfxMacroLoader::loadMacro( const OUString& rURL, css::uno::Any& rRetval, SfxObjectShell* pSh )
+{
+#if !HAVE_FEATURE_SCRIPTING
+    (void) rURL;
+    (void) rRetval;
+    (void) pSh;
+    return ERRCODE_BASIC_PROC_UNDEFINED;
+#else
+    SfxObjectShell* pCurrent = pSh;
+    if ( !pCurrent )
+        // all not full qualified names use the BASIC of the given or current document
+        pCurrent = SfxObjectShell::Current();
+
+    // 'macro:///lib.mod.proc(args)' => macro of App-BASIC
+    // 'macro://[docname|.]/lib.mod.proc(args)' => macro of current or qualified document
+    // 'macro://obj.method(args)' => direct API call, execute it via App-BASIC
+    const OUString& aMacro( rURL );
+    sal_Int32 nThirdSlashPos = aMacro.indexOf( '/', 8 );
+    sal_Int32 nArgsPos = aMacro.indexOf( '(' );
+    BasicManager *pAppMgr = SfxApplication::GetBasicManager();
+    BasicManager *pBasMgr = nullptr;
+    ErrCode nErr = ERRCODE_NONE;
+
+    // should a macro function be executed ( no direct API call)?
+    if ( -1 != nThirdSlashPos && ( -1 == nArgsPos || nThirdSlashPos < nArgsPos ) )
+    {
+        // find BasicManager
+        SfxObjectShell* pDoc = nullptr;
+        OUString aBasMgrName( INetURLObject::decode(aMacro.copy( 8, nThirdSlashPos-8 ), INetURLObject::DecodeMechanism::WithCharset) );
+        if ( aBasMgrName.isEmpty() )
+            pBasMgr = pAppMgr;
+        else if ( aBasMgrName == "." )
+        {
+            // current/actual document
+            pDoc = pCurrent;
+            if (pDoc)
+                pBasMgr = pDoc->GetBasicManager();
+        }
+        else
+        {
+            // full qualified name, find document by name
+            for ( SfxObjectShell *pObjSh = SfxObjectShell::GetFirst();
+                    pObjSh && !pBasMgr;
+                    pObjSh = SfxObjectShell::GetNext(*pObjSh) )
+                if ( aBasMgrName == pObjSh->GetTitle(SFX_TITLE_APINAME) )
+                {
+                    pDoc = pObjSh;
+                    pBasMgr = pDoc->GetBasicManager();
+                }
+        }
+
+        if ( pBasMgr )
+        {
+            const bool bIsAppBasic = ( pBasMgr == pAppMgr );
+            const bool bIsDocBasic = ( pBasMgr != pAppMgr );
+
+            if ( pDoc )
+            {
+                // security check for macros from document basic if an SFX doc is given
+                if ( !pDoc->AdjustMacroMode() )
+                    // check forbids execution
+                    return ERRCODE_IO_ACCESSDENIED;
+            }
+
+            // find BASIC method
+            OUString aQualifiedMethod( INetURLObject::decode(aMacro.copy( nThirdSlashPos+1 ), INetURLObject::DecodeMechanism::WithCharset) );
+            OUString aArgs;
+            if ( -1 != nArgsPos )
+            {
+                // remove arguments from macro name
+                aArgs = aQualifiedMethod.copy( nArgsPos - nThirdSlashPos - 1 );
+                aQualifiedMethod = aQualifiedMethod.copy( 0, nArgsPos - nThirdSlashPos - 1 );
+            }
+
+            if ( pBasMgr->HasMacro( aQualifiedMethod ) )
+            {
+                Any aOldThisComponent;
+                const bool bSetDocMacroMode = ( pDoc != nullptr ) && bIsDocBasic;
+                const bool bSetGlobalThisComponent = ( pDoc != nullptr ) && bIsAppBasic;
+                if ( bSetDocMacroMode )
+                {
+                    // mark document: it executes an own macro, so it's in a modal mode
+                    pDoc->SetMacroMode_Impl();
+                }
+
+                if ( bSetGlobalThisComponent )
+                {
+                    // document is executed via AppBASIC, adjust ThisComponent variable
+                    aOldThisComponent = pAppMgr->SetGlobalUNOConstant( "ThisComponent", makeAny( pDoc->GetModel() ) );
+                }
+
+                // just to let the shell be alive
+                SfxObjectShellRef xKeepDocAlive = pDoc;
+
+                {
+                    // attempt to protect the document against the script tampering with its Undo Context
+                    std::unique_ptr< ::framework::DocumentUndoGuard > pUndoGuard;
+                    if ( bIsDocBasic )
+                        pUndoGuard.reset( new ::framework::DocumentUndoGuard( pDoc->GetModel() ) );
+
+                    // execute the method
+                    SbxVariableRef retValRef = new SbxVariable;
+                    nErr = pBasMgr->ExecuteMacro( aQualifiedMethod, aArgs, retValRef.get() );
+                    if ( nErr == ERRCODE_NONE )
+                        rRetval = sbxToUnoValue( retValRef.get() );
+                }
+
+                if ( bSetGlobalThisComponent )
+                {
+                    pAppMgr->SetGlobalUNOConstant( "ThisComponent", aOldThisComponent );
+                }
+
+                if ( bSetDocMacroMode )
+                {
+                    // remove flag for modal mode
+                    pDoc->SetMacroMode_Impl( false );
+                }
+            }
+            else
+                nErr = ERRCODE_BASIC_PROC_UNDEFINED;
+        }
+        else
+            nErr = ERRCODE_IO_NOTEXISTS;
+    }
+    else
+    {
+        // direct API call on a specified object
+        OUStringBuffer aCall;
+        aCall.append('[').append(INetURLObject::decode(aMacro.copy(6),
+            INetURLObject::DecodeMechanism::WithCharset));
+        aCall.append(']');
+        pAppMgr->GetLib(0)->Execute(aCall.makeStringAndClear());
+        nErr = SbxBase::GetError();
+    }
+
+    SbxBase::ResetError();
+    return nErr;
+#endif
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_sfx2_SfxMacroLoader_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &arguments)
+{
+    return cppu::acquire(new SfxMacroLoader(arguments));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/module.cxx b/sfx2/source/appl/module.cxx
new file mode 100644
index 000000000..0825c2430
--- /dev/null
+++ b/sfx2/source/appl/module.cxx
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sfx2/module.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/msgpool.hxx>
+#include <sfx2/tbxctrl.hxx>
+#include <sfx2/stbitem.hxx>
+#include <sfx2/childwin.hxx>
+#include <sfx2/docfac.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/tabdlg.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <svl/intitem.hxx>
+#include <tools/diagnose_ex.h>
+#include <unotools/resmgr.hxx>
+#include <sal/log.hxx>
+
+#define ShellClass_SfxModule
+#include <sfxslots.hxx>
+#include <childwinimpl.hxx>
+#include <ctrlfactoryimpl.hxx>
+
+class SfxModule_Impl
+{
+public:
+
+    std::unique_ptr<SfxSlotPool>              pSlotPool;
+    std::unique_ptr<SfxTbxCtrlFactArr_Impl>   pTbxCtrlFac;
+    std::unique_ptr<SfxStbCtrlFactArr_Impl>   pStbCtrlFac;
+    std::unique_ptr<SfxChildWinFactArr_Impl>  pFactArr;
+    OString                     maResName;
+
+                                SfxModule_Impl();
+                                ~SfxModule_Impl();
+};
+
+SfxModule_Impl::SfxModule_Impl()
+{
+}
+
+SfxModule_Impl::~SfxModule_Impl()
+{
+    pSlotPool.reset();
+    pTbxCtrlFac.reset();
+    pStbCtrlFac.reset();
+    pFactArr.reset();
+}
+
+SFX_IMPL_SUPERCLASS_INTERFACE(SfxModule, SfxShell)
+
+SfxModule::SfxModule(const OString& rResName, std::initializer_list<SfxObjectFactory*> pFactoryList)
+    : pImpl(nullptr)
+{
+    Construct_Impl(rResName);
+    for (auto pFactory : pFactoryList)
+    {
+        if (pFactory)
+            pFactory->SetModule_Impl( this );
+    }
+}
+
+void SfxModule::Construct_Impl(const OString& rResName)
+{
+    SfxApplication *pApp = SfxApplication::GetOrCreate();
+    pImpl = new SfxModule_Impl;
+    pImpl->pSlotPool.reset( new SfxSlotPool(&pApp->GetAppSlotPool_Impl()) );
+    pImpl->maResName = rResName;
+
+    SetPool( &pApp->GetPool() );
+}
+
+SfxModule::~SfxModule()
+{
+    //TODO how to silence useuniqueptr
+    if (true)
+    {
+        delete pImpl;
+    }
+}
+
+std::locale SfxModule::GetResLocale() const
+{
+    return Translate::Create(pImpl->maResName.getStr());
+}
+
+SfxSlotPool* SfxModule::GetSlotPool() const
+{
+    return pImpl->pSlotPool.get();
+}
+
+
+void SfxModule::RegisterChildWindow(std::unique_ptr<SfxChildWinFactory> pFact)
+{
+    DBG_ASSERT( pImpl, "No real Module!" );
+
+    if (!pImpl->pFactArr)
+        pImpl->pFactArr.reset( new SfxChildWinFactArr_Impl );
+
+    for (size_t nFactory=0; nFactory<pImpl->pFactArr->size(); ++nFactory)
+    {
+        if (pFact->nId ==  (*pImpl->pFactArr)[nFactory].nId)
+        {
+            pImpl->pFactArr->erase( pImpl->pFactArr->begin() + nFactory );
+            SAL_WARN("sfx.appl", "ChildWindow registered multiple times!");
+            return;
+        }
+    }
+
+    pImpl->pFactArr->push_back( std::move(pFact) );
+}
+
+
+void SfxModule::RegisterToolBoxControl( const SfxTbxCtrlFactory& rFact )
+{
+    if (!pImpl->pTbxCtrlFac)
+        pImpl->pTbxCtrlFac.reset( new SfxTbxCtrlFactArr_Impl );
+
+#ifdef DBG_UTIL
+    for ( size_t n=0; n<pImpl->pTbxCtrlFac->size(); n++ )
+    {
+        SfxTbxCtrlFactory *pF = &(*pImpl->pTbxCtrlFac)[n];
+        if ( pF->nTypeId == rFact.nTypeId &&
+            (pF->nSlotId == rFact.nSlotId || pF->nSlotId == 0) )
+        {
+            SAL_INFO("sfx.appl", "TbxController-Registering is not clearly defined!");
+        }
+    }
+#endif
+
+    pImpl->pTbxCtrlFac->push_back( rFact );
+}
+
+
+void SfxModule::RegisterStatusBarControl( const SfxStbCtrlFactory& rFact )
+{
+    if (!pImpl->pStbCtrlFac)
+        pImpl->pStbCtrlFac.reset( new SfxStbCtrlFactArr_Impl );
+
+#ifdef DBG_UTIL
+    for ( size_t n=0; n<pImpl->pStbCtrlFac->size(); n++ )
+    {
+        SfxStbCtrlFactory *pF = &(*pImpl->pStbCtrlFac)[n];
+        if ( pF->nTypeId == rFact.nTypeId &&
+            (pF->nSlotId == rFact.nSlotId || pF->nSlotId == 0) )
+        {
+            SAL_INFO("sfx.appl", "TbxController-Registering is not clearly defined!");
+        }
+    }
+#endif
+
+    pImpl->pStbCtrlFac->push_back( rFact );
+}
+
+
+SfxTbxCtrlFactArr_Impl*  SfxModule::GetTbxCtrlFactories_Impl() const
+{
+    return pImpl->pTbxCtrlFac.get();
+}
+
+
+SfxStbCtrlFactArr_Impl*  SfxModule::GetStbCtrlFactories_Impl() const
+{
+    return pImpl->pStbCtrlFac.get();
+}
+
+SfxChildWinFactArr_Impl* SfxModule::GetChildWinFactories_Impl() const
+{
+    return pImpl->pFactArr.get();
+}
+
+std::unique_ptr<SfxTabPage> SfxModule::CreateTabPage(sal_uInt16, weld::Container*, weld::DialogController*, const SfxItemSet&)
+{
+    return nullptr;
+}
+
+void SfxModule::Invalidate( sal_uInt16 nId )
+{
+    for( SfxViewFrame* pFrame = SfxViewFrame::GetFirst(); pFrame; pFrame = SfxViewFrame::GetNext( *pFrame ) )
+        if ( pFrame->GetObjectShell()->GetModule() == this )
+            Invalidate_Impl( pFrame->GetBindings(), nId );
+}
+
+SfxModule* SfxModule::GetActiveModule( SfxViewFrame* pFrame )
+{
+    if ( !pFrame )
+        pFrame = SfxViewFrame::Current();
+    SfxObjectShell* pSh = nullptr;
+    if( pFrame )
+        pSh = pFrame->GetObjectShell();
+    return pSh ? pSh->GetModule() : nullptr;
+}
+
+FieldUnit SfxModule::GetModuleFieldUnit( css::uno::Reference< css::frame::XFrame > const & i_frame )
+{
+    ENSURE_OR_RETURN( i_frame.is(), "SfxModule::GetModuleFieldUnit: invalid frame!", FieldUnit::MM_100TH );
+
+    // find SfxViewFrame for the given XFrame
+    SfxViewFrame* pViewFrame = SfxViewFrame::GetFirst();
+    while ( pViewFrame != nullptr )
+    {
+        if ( pViewFrame->GetFrame().GetFrameInterface() == i_frame )
+            break;
+        pViewFrame = SfxViewFrame::GetNext( *pViewFrame );
+    }
+    ENSURE_OR_RETURN(
+        pViewFrame != nullptr,
+        "SfxModule::GetModuleFieldUnit: unable to find an SfxViewFrame for the given XFrame",
+        FieldUnit::MM_100TH);
+
+    // find the module
+    SfxModule const * pModule = GetActiveModule( pViewFrame );
+    ENSURE_OR_RETURN(pModule != nullptr,
+                     "SfxModule::GetModuleFieldUnit: no SfxModule for the given frame!",
+                     FieldUnit::MM_100TH);
+    return pModule->GetFieldUnit();
+}
+
+FieldUnit SfxModule::GetCurrentFieldUnit()
+{
+    FieldUnit eUnit = FieldUnit::INCH;
+    SfxModule* pModule = GetActiveModule();
+    if ( pModule )
+    {
+        const SfxPoolItem* pItem = pModule->GetItem( SID_ATTR_METRIC );
+        if ( pItem )
+            eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+    }
+    else
+        SAL_WARN( "sfx.appl", "GetModuleFieldUnit(): no module found" );
+    return eUnit;
+}
+
+FieldUnit SfxModule::GetFieldUnit() const
+{
+    FieldUnit eUnit = FieldUnit::INCH;
+    const SfxPoolItem* pItem = GetItem( SID_ATTR_METRIC );
+    if ( pItem )
+        eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+    return eUnit;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/newhelp.cxx b/sfx2/source/appl/newhelp.cxx
new file mode 100644
index 000000000..9160c231f
--- /dev/null
+++ b/sfx2/source/appl/newhelp.cxx
@@ -0,0 +1,2701 @@
+/* -*- 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 "newhelp.hxx"
+#include <sfx2/sfxresid.hxx>
+#include "helpinterceptor.hxx"
+#include <helper.hxx>
+#include <srchdlg.hxx>
+#include <sfx2/sfxhelp.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <tools/debug.hxx>
+#include <tools/diagnose_ex.h>
+
+#include <sfx2/strings.hrc>
+#include <helpids.h>
+#include <bitmaps.hlst>
+
+#include <rtl/ustrbuf.hxx>
+#include <comphelper/configurationhelper.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/string.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <com/sun/star/awt/PosSize.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/XPropertySetInfo.hpp>
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/frame/XComponentLoader.hpp>
+#include <com/sun/star/frame/XTitle.hpp>
+#include <com/sun/star/frame/XLayoutManager.hpp>
+#include <com/sun/star/frame/XController.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/Frame.hpp>
+#include <com/sun/star/i18n/XBreakIterator.hpp>
+#include <com/sun/star/i18n/WordType.hpp>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/text/XText.hpp>
+#include <com/sun/star/text/XTextCursor.hpp>
+#include <com/sun/star/text/XTextDocument.hpp>
+#include <com/sun/star/text/XTextViewCursor.hpp>
+#include <com/sun/star/text/XTextViewCursorSupplier.hpp>
+#include <com/sun/star/ucb/CommandAbortedException.hpp>
+#include <com/sun/star/util/URL.hpp>
+#include <com/sun/star/util/XSearchable.hpp>
+#include <com/sun/star/util/XSearchDescriptor.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <com/sun/star/util/XModifiable.hpp>
+#include <com/sun/star/util/XCloseable.hpp>
+#include <com/sun/star/util/CloseVetoException.hpp>
+#include <com/sun/star/view/XSelectionSupplier.hpp>
+#include <com/sun/star/view/XViewSettingsSupplier.hpp>
+#include <unotools/historyoptions.hxx>
+#include <svtools/menuoptions.hxx>
+#include <unotools/viewoptions.hxx>
+#include <tools/urlobj.hxx>
+#include <svtools/imagemgr.hxx>
+#include <svtools/miscopt.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/event.hxx>
+#include <vcl/i18nhelp.hxx>
+#include <vcl/layout.hxx>
+#include <vcl/taskpanelist.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/unohelp.hxx>
+#include <vcl/weld.hxx>
+
+#include <ucbhelper/content.hxx>
+#include <unotools/ucbhelper.hxx>
+
+#include <unordered_map>
+#include <vector>
+
+using namespace ::ucbhelper;
+using namespace ::com::sun::star::ucb;
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::i18n;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::view;
+using namespace ::com::sun::star::ui;
+
+using namespace ::comphelper;
+
+// defines ---------------------------------------------------------------
+
+#define CONFIGNAME_HELPWIN      "OfficeHelp"
+#define CONFIGNAME_INDEXWIN     "OfficeHelpIndex"
+#define CONFIGNAME_SEARCHPAGE   "OfficeHelpSearch"
+#define IMAGE_URL               "private:factory/"
+
+#define PROPERTY_KEYWORDLIST    "KeywordList"
+#define PROPERTY_KEYWORDREF     "KeywordRef"
+#define PROPERTY_ANCHORREF      "KeywordAnchorForRef"
+#define PROPERTY_TITLEREF       "KeywordTitleForRef"
+#define PROPERTY_TITLE          "Title"
+#define HELP_URL                "vnd.sun.star.help://"
+#define HELP_SEARCH_TAG         "/?Query="
+#define USERITEM_NAME           "UserItem"
+
+#define PACKAGE_SETUP           "/org.openoffice.Setup"
+#define PATH_OFFICE_FACTORIES   "Office/Factories/"
+#define KEY_HELP_ON_OPEN        "ooSetupFactoryHelpOnOpen"
+#define KEY_UI_NAME             "ooSetupFactoryUIName"
+
+namespace sfx2
+{
+
+
+    /** Prepare a search string for searching or selecting.
+        For searching every search word needs the postfix '*' and the delimiter ' ' if necessary.
+        For selecting the delimiter '|' is required to search with regular expressions.
+        Samples:
+        search string | output for searching | output for selecting
+        -----------------------------------------------------------
+        "text"        | "text*"              | "text"
+        "text*"       | "text*"              | "text"
+        "text menu"   | "text* menu*"        | "text|menu"
+    */
+    static OUString PrepareSearchString( const OUString& rSearchString,
+                                const Reference< XBreakIterator >& xBreak, bool bForSearch )
+    {
+        OUStringBuffer sSearchStr;
+        sal_Int32 nStartPos = 0;
+        const lang::Locale aLocale = Application::GetSettings().GetUILanguageTag().getLocale();
+        Boundary aBoundary = xBreak->getWordBoundary(
+            rSearchString, nStartPos, aLocale, WordType::ANYWORD_IGNOREWHITESPACES, true );
+
+        while ( aBoundary.startPos < aBoundary.endPos )
+        {
+            nStartPos = aBoundary.endPos;
+            OUString sSearchToken( rSearchString.copy(
+                static_cast<sal_uInt16>(aBoundary.startPos), static_cast<sal_uInt16>(aBoundary.endPos) - static_cast<sal_uInt16>(aBoundary.startPos) ) );
+            if ( !sSearchToken.isEmpty() && ( sSearchToken.getLength() > 1 || sSearchToken[0] != '.' ) )
+            {
+                if ( bForSearch && sSearchToken[ sSearchToken.getLength() - 1 ] != '*' )
+                    sSearchToken += "*";
+
+                if ( sSearchToken.getLength() > 1 ||
+                     ( sSearchToken.getLength() > 0 && sSearchToken[ 0 ] != '*' ) )
+                {
+                    if ( !sSearchStr.isEmpty() )
+                    {
+                        if ( bForSearch )
+                            sSearchStr.append(" ");
+                        else
+                            sSearchStr.append("|");
+                    }
+                    sSearchStr.append(sSearchToken);
+                }
+            }
+            aBoundary = xBreak->nextWord( rSearchString, nStartPos,
+                                          aLocale, WordType::ANYWORD_IGNOREWHITESPACES );
+        }
+
+        return sSearchStr.makeStringAndClear();
+    }
+
+// namespace sfx2
+}
+
+
+// struct IndexEntry_Impl ------------------------------------------------
+
+namespace {
+
+struct IndexEntry_Impl
+{
+    bool            m_bSubEntry;
+    OUString        m_aURL;
+
+    IndexEntry_Impl( const OUString& rURL, bool bSubEntry ) :
+        m_bSubEntry( bSubEntry ), m_aURL( rURL ) {}
+};
+
+// struct ContentEntry_Impl ----------------------------------------------
+
+struct ContentEntry_Impl
+{
+    OUString    aURL;
+    bool        bIsFolder;
+
+    ContentEntry_Impl( const OUString& rURL, bool bFolder ) :
+        aURL( rURL ), bIsFolder( bFolder ) {}
+};
+
+}
+
+void ContentTabPage_Impl::InitRoot()
+{
+    std::vector< OUString > aList =
+        SfxContentHelper::GetHelpTreeViewContents( "vnd.sun.star.hier://com.sun.star.help.TreeView/" );
+
+    for (const OUString & aRow : aList)
+    {
+        sal_Int32 nIdx = 0;
+        OUString aTitle = aRow.getToken( 0, '\t', nIdx );
+        OUString aURL = aRow.getToken( 0, '\t', nIdx );
+        sal_Unicode cFolder = aRow.getToken( 0, '\t', nIdx )[0];
+        bool bIsFolder = ( '1' == cFolder );
+        OUString sId;
+        if (bIsFolder)
+            sId = OUString::number(reinterpret_cast<sal_Int64>(new ContentEntry_Impl(aURL, true)));
+        m_xContentBox->insert(nullptr, -1, &aTitle, &sId, nullptr, nullptr, &aClosedBookImage, true, nullptr);
+    }
+}
+
+void ContentTabPage_Impl::ClearChildren(weld::TreeIter* pParent)
+{
+    std::unique_ptr<weld::TreeIter> xEntry = m_xContentBox->make_iterator(pParent);
+    bool bEntry = m_xContentBox->iter_children(*xEntry);
+    while (bEntry)
+    {
+        ClearChildren(xEntry.get());
+        delete reinterpret_cast<ContentEntry_Impl*>(m_xContentBox->get_id(*xEntry).toInt64());
+        bEntry = m_xContentBox->iter_next_sibling(*xEntry);
+    }
+
+}
+
+IMPL_LINK(ContentTabPage_Impl, ExpandingHdl, const weld::TreeIter&, rIter, bool)
+{
+    ContentEntry_Impl* pContentEntry = reinterpret_cast<ContentEntry_Impl*>(m_xContentBox->get_id(rIter).toInt64());
+    if (!m_xContentBox->iter_has_child(rIter))
+    {
+        try
+        {
+            if (pContentEntry)
+            {
+                std::vector<OUString > aList = SfxContentHelper::GetHelpTreeViewContents(pContentEntry->aURL);
+
+                for (const OUString & aRow : aList)
+                {
+                    sal_Int32 nIdx = 0;
+                    OUString aTitle = aRow.getToken( 0, '\t', nIdx );
+                    OUString aURL = aRow.getToken( 0, '\t', nIdx );
+                    sal_Unicode cFolder = aRow.getToken( 0, '\t', nIdx )[0];
+                    bool bIsFolder = ( '1' == cFolder );
+                    if ( bIsFolder )
+                    {
+                        OUString sId = OUString::number(reinterpret_cast<sal_Int64>(new ContentEntry_Impl(aURL, true)));
+                        m_xContentBox->insert(&rIter, -1, &aTitle, &sId, nullptr, nullptr, &aClosedBookImage, true, nullptr);
+                    }
+                    else
+                    {
+                        Any aAny( ::utl::UCBContentHelper::GetProperty( aURL, "TargetURL" ) );
+                        OUString sId;
+                        OUString aTargetURL;
+                        if ( aAny >>= aTargetURL )
+                            sId = OUString::number(reinterpret_cast<sal_Int64>(new ContentEntry_Impl(aTargetURL, false)));
+                        m_xContentBox->insert(&rIter, -1, &aTitle, &sId, nullptr, nullptr, &aDocumentImage, false, nullptr);
+                    }
+                }
+            }
+        }
+        catch (const Exception&)
+        {
+            OSL_FAIL( "ContentListBox_Impl::RequestingChildren(): unexpected exception" );
+        }
+    }
+
+    if (!pContentEntry || pContentEntry->bIsFolder)
+        m_xContentBox->set_image(rIter, aOpenBookImage);
+
+    return true;
+}
+
+IMPL_LINK(ContentTabPage_Impl, CollapsingHdl, const weld::TreeIter&, rIter, bool)
+{
+    ContentEntry_Impl* pContentEntry = reinterpret_cast<ContentEntry_Impl*>(m_xContentBox->get_id(rIter).toInt64());
+    if (!pContentEntry || pContentEntry->bIsFolder)
+        m_xContentBox->set_image(rIter, aClosedBookImage);
+
+    return true;
+}
+
+OUString ContentTabPage_Impl::GetSelectedEntry() const
+{
+    OUString aRet;
+    ContentEntry_Impl* pEntry = reinterpret_cast<ContentEntry_Impl*>(m_xContentBox->get_selected_id().toInt64());
+    if (pEntry && !pEntry->bIsFolder)
+        aRet = pEntry->aURL;
+    return aRet;
+}
+
+// class HelpTabPage_Impl ------------------------------------------------
+HelpTabPage_Impl::HelpTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* pIdxWin,
+    const OString& rID, const OUString& rUIXMLDescription)
+    : BuilderPage(pParent, nullptr, rUIXMLDescription, rID)
+    , m_pIdxWin(pIdxWin)
+{
+}
+
+HelpTabPage_Impl::~HelpTabPage_Impl()
+{
+}
+
+// class ContentTabPage_Impl ---------------------------------------------
+ContentTabPage_Impl::ContentTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* pIdxWin)
+    : HelpTabPage_Impl(pParent, pIdxWin, "HelpContentPage",
+        "sfx/ui/helpcontentpage.ui")
+    , m_xContentBox(m_xBuilder->weld_tree_view("content"))
+    , aOpenBookImage(BMP_HELP_CONTENT_BOOK_OPEN)
+    , aClosedBookImage(BMP_HELP_CONTENT_BOOK_CLOSED)
+    , aDocumentImage(BMP_HELP_CONTENT_DOC)
+{
+    m_xContentBox->set_size_request(m_xContentBox->get_approximate_digit_width() * 30,
+                                    m_xContentBox->get_height_rows(20));
+    m_xContentBox->connect_row_activated(LINK(this, ContentTabPage_Impl, DoubleClickHdl));
+    m_xContentBox->connect_expanding(LINK(this, ContentTabPage_Impl, ExpandingHdl));
+    m_xContentBox->connect_collapsing(LINK(this, ContentTabPage_Impl, CollapsingHdl));
+
+    InitRoot();
+}
+
+IMPL_LINK_NOARG(ContentTabPage_Impl, DoubleClickHdl, weld::TreeView&, bool)
+{
+    aDoubleClickHdl.Call(nullptr);
+    return false;
+}
+
+void ContentTabPage_Impl::SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink)
+{
+    aDoubleClickHdl = rLink;
+}
+
+ContentTabPage_Impl::~ContentTabPage_Impl()
+{
+    std::unique_ptr<weld::TreeIter> xEntry = m_xContentBox->make_iterator();
+    bool bEntry = m_xContentBox->get_iter_first(*xEntry);
+    while (bEntry)
+    {
+        ClearChildren(xEntry.get());
+        delete reinterpret_cast<ContentEntry_Impl*>(m_xContentBox->get_id(*xEntry).toInt64());
+        bEntry = m_xContentBox->iter_next_sibling(*xEntry);
+    }
+}
+
+weld::Widget* ContentTabPage_Impl::GetLastFocusControl()
+{
+    return m_xContentBox.get();
+}
+
+void IndexTabPage_Impl::SelectExecutableEntry()
+{
+    sal_Int32 nPos = m_xIndexList->find_text(m_xIndexEntry->get_text());
+    if (nPos == -1)
+        return;
+
+    sal_Int32 nOldPos = nPos;
+    OUString aEntryText;
+    IndexEntry_Impl* pEntry = reinterpret_cast<IndexEntry_Impl*>(m_xIndexList->get_id(nPos).toInt64());
+    sal_Int32 nCount = m_xIndexList->n_children();
+    while ( nPos < nCount && ( !pEntry || pEntry->m_aURL.isEmpty() ) )
+    {
+        pEntry = reinterpret_cast<IndexEntry_Impl*>(m_xIndexList->get_id(++nPos).toInt64());
+        aEntryText = m_xIndexList->get_text(nPos);
+    }
+
+    if ( nOldPos != nPos )
+        m_xIndexEntry->set_text(aEntryText);
+}
+
+// class IndexTabPage_Impl -----------------------------------------------
+IndexTabPage_Impl::IndexTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* pIdxWin)
+    : HelpTabPage_Impl(pParent, pIdxWin, "HelpIndexPage", "sfx/ui/helpindexpage.ui")
+    , m_xIndexEntry(m_xBuilder->weld_entry("termentry"))
+    , m_xIndexList(m_xBuilder->weld_tree_view("termlist"))
+    , m_xOpenBtn(m_xBuilder->weld_button("display"))
+    , aFactoryIdle("sfx2 appl IndexTabPage_Impl Factory")
+    , aAutoCompleteIdle("sfx2 appl IndexTabPage_Impl AutoComplete")
+    , bIsActivated(false)
+    , nRowHeight(m_xIndexList->get_height_rows(1))
+    , nAllHeight(0)
+{
+    m_xIndexList->set_size_request(m_xIndexList->get_approximate_digit_width() * 30, -1);
+
+    m_xOpenBtn->connect_clicked(LINK(this, IndexTabPage_Impl, OpenHdl));
+    aFactoryIdle.SetInvokeHandler( LINK(this, IndexTabPage_Impl, IdleHdl ));
+    aAutoCompleteIdle.SetInvokeHandler( LINK(this, IndexTabPage_Impl, AutoCompleteHdl ));
+    aKeywordTimer.SetInvokeHandler( LINK( this, IndexTabPage_Impl, TimeoutHdl ) );
+    m_xIndexList->connect_row_activated(LINK(this, IndexTabPage_Impl, DoubleClickHdl));
+    m_xIndexList->connect_changed(LINK(this, IndexTabPage_Impl, TreeChangeHdl));
+    m_xIndexList->connect_custom_get_size(LINK(this, IndexTabPage_Impl, CustomGetSizeHdl));
+    m_xIndexList->connect_custom_render(LINK(this, IndexTabPage_Impl, CustomRenderHdl));
+    m_xIndexList->set_column_custom_renderer(0, true);
+    m_xIndexList->connect_size_allocate(LINK(this, IndexTabPage_Impl, ResizeHdl));
+    m_xIndexEntry->connect_key_press(LINK(this, IndexTabPage_Impl, KeyInputHdl));
+    m_xIndexEntry->connect_changed(LINK(this, IndexTabPage_Impl, EntryChangeHdl));
+    m_xIndexEntry->connect_activate(LINK(this, IndexTabPage_Impl, ActivateHdl));
+}
+
+IMPL_LINK(IndexTabPage_Impl, ResizeHdl, const Size&, rSize, void)
+{
+    nAllHeight = rSize.Height();
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, CustomGetSizeHdl, weld::TreeView::get_size_args, Size)
+{
+    return Size(m_xIndexList->get_size_request().Width(), nRowHeight);
+}
+
+IMPL_LINK(IndexTabPage_Impl, CustomRenderHdl, weld::TreeView::render_args, aPayload, void)
+{
+    vcl::RenderContext& rRenderContext = std::get<0>(aPayload);
+    const ::tools::Rectangle& rRect = std::get<1>(aPayload);
+    bool bSelected = std::get<2>(aPayload);
+    const OUString& rId = std::get<3>(aPayload);
+
+    rRenderContext.Push(PushFlags::TEXTCOLOR);
+    const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
+    if (bSelected)
+        rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor());
+    else
+        rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor());
+
+    Point aPos(rRect.TopLeft());
+    aPos.AdjustY((rRect.GetHeight() - rRenderContext.GetTextHeight()) / 2);
+
+    int nIndex = m_xIndexList->find_id(rId);
+    OUString aEntry(m_xIndexList->get_text(nIndex));
+
+    IndexEntry_Impl* pEntry = reinterpret_cast<IndexEntry_Impl*>(rId.toInt64());
+    if (pEntry && pEntry->m_bSubEntry)
+    {
+        // indent sub entries
+        aPos.AdjustX(8);
+        sal_Int32 nPos = aEntry.indexOf(';');
+        rRenderContext.DrawText(aPos, (nPos !=-1) ? aEntry.copy(nPos + 1) : aEntry);
+    }
+    else
+        rRenderContext.DrawText(aPos, aEntry);
+
+    rRenderContext.Pop();
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, TreeChangeHdl, weld::TreeView&, void)
+{
+    m_xIndexEntry->set_text(m_xIndexList->get_selected_text());
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, EntryChangeHdl, weld::Entry&, void)
+{
+    aAutoCompleteIdle.Start();
+}
+
+IMPL_LINK(IndexTabPage_Impl, KeyInputHdl, const KeyEvent&, rKEvt, bool)
+{
+    const vcl::KeyCode& rKCode = rKEvt.GetKeyCode();
+    if (rKCode.GetModifier()) // only with no modifiers held
+        return false;
+
+    sal_uInt16 nCode = rKCode.GetCode();
+
+    if (nCode == KEY_UP || nCode == KEY_PAGEUP ||
+        nCode == KEY_DOWN || nCode == KEY_PAGEDOWN)
+    {
+//        disable_notify_events();
+        sal_Int32 nIndex = m_xIndexList->get_selected_index();
+        sal_Int32 nOrigIndex = nIndex;
+        sal_Int32 nCount = m_xIndexList->n_children();
+        if (nIndex == -1)
+        {
+            m_xIndexList->set_cursor(0);
+            m_xIndexList->select(0);
+            m_xIndexEntry->set_text(m_xIndexList->get_selected_text());
+        }
+        else
+        {
+            if (nCode == KEY_UP)
+                --nIndex;
+            else if (nCode == KEY_DOWN)
+                ++nIndex;
+            else if (nCode == KEY_PAGEUP)
+            {
+                int nVisRows = nAllHeight / nRowHeight;
+                nIndex -= nVisRows;
+            }
+            else if (nCode == KEY_PAGEDOWN)
+            {
+                int nVisRows = nAllHeight / nRowHeight;
+                nIndex += nVisRows;
+            }
+
+            if (nIndex < 0)
+                nIndex = 0;
+            if (nIndex >= nCount)
+                nIndex = nCount - 1;
+
+            if (nIndex != nOrigIndex)
+            {
+                m_xIndexList->set_cursor(nIndex);
+                m_xIndexList->select(nIndex);
+                m_xIndexEntry->set_text(m_xIndexList->get_selected_text());
+            }
+
+//            m_xIndexList->grab_focus();
+//            g_signal_emit_by_name(pWidget, "key-press-event", pEvent, &ret);
+//            m_xIndexEntry->set_text(m_xIndexList->get_selected_text());
+//            m_xIndexEntry->grab_focus();
+        }
+        m_xIndexEntry->select_region(0, -1);
+//        enable_notify_events();
+//        m_bTreeChange = true;
+//        m_pEntry->fire_signal_changed();
+//        m_bTreeChange = false;
+        return true;
+    }
+    return false;
+}
+
+IndexTabPage_Impl::~IndexTabPage_Impl()
+{
+    ClearIndex();
+}
+
+namespace sfx2 {
+
+    typedef std::unordered_map< OUString, int > KeywordInfo;
+}
+
+void IndexTabPage_Impl::InitializeIndex()
+{
+    weld::WaitObject aWaitCursor(m_pIdxWin->GetFrameWeld());
+
+    // By now more than 256 equal entries are not allowed
+    sal_Unicode append[256];
+    for(sal_Unicode & k : append)
+        k =  ' ';
+
+    sfx2::KeywordInfo aInfo;
+    m_xIndexList->freeze();
+
+    try
+    {
+        OUStringBuffer aURL = HELP_URL;
+        aURL.append(sFactory);
+        AppendConfigToken(aURL, true);
+
+        Content aCnt( aURL.makeStringAndClear(), Reference< css::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
+        css::uno::Reference< css::beans::XPropertySetInfo > xInfo = aCnt.getProperties();
+        if ( xInfo->hasPropertyByName( PROPERTY_ANCHORREF ) )
+        {
+            css::uno::Sequence< OUString > aPropSeq( 4 );
+            aPropSeq[0] = PROPERTY_KEYWORDLIST;
+            aPropSeq[1] = PROPERTY_KEYWORDREF;
+            aPropSeq[2] = PROPERTY_ANCHORREF;
+            aPropSeq[3] = PROPERTY_TITLEREF;
+
+            // abi: use one possibly remote call only
+            css::uno::Sequence< css::uno::Any > aAnySeq =
+                  aCnt.getPropertyValues( aPropSeq );
+
+            css::uno::Sequence< OUString > aKeywordList;
+            css::uno::Sequence< css::uno::Sequence< OUString > > aKeywordRefList;
+            css::uno::Sequence< css::uno::Sequence< OUString > > aAnchorRefList;
+            css::uno::Sequence< css::uno::Sequence< OUString > > aTitleRefList;
+
+            if ( ( aAnySeq[0] >>= aKeywordList ) && ( aAnySeq[1] >>= aKeywordRefList ) &&
+                 ( aAnySeq[2] >>= aAnchorRefList ) && ( aAnySeq[3] >>= aTitleRefList ) )
+            {
+                int ndx,tmp;
+                OUString aIndex, aTempString;
+                OUStringBuffer aData( 128 );            // Capacity of up to 128 characters
+                sfx2::KeywordInfo::iterator it;
+
+                for ( int i = 0; i < aKeywordList.getLength(); ++i )
+                {
+                    // abi: Do not copy, but use references
+                    const OUString& aKeywordPair = aKeywordList[i];
+                    DBG_ASSERT( !aKeywordPair.isEmpty(), "invalid help index" );
+                    const css::uno::Sequence< OUString >& aRefList = aKeywordRefList[i];
+                    const css::uno::Sequence< OUString >& aAnchorList = aAnchorRefList[i];
+                    const css::uno::Sequence< OUString >& aTitleList = aTitleRefList[i];
+
+                    DBG_ASSERT( aRefList.getLength() == aAnchorList.getLength(),"reference list and title list of different length" );
+
+                    ndx = aKeywordPair.indexOf( ';' );
+                    const bool insert = ndx != -1;
+
+                    OUString sId;
+
+                    if ( insert )
+                    {
+                        aTempString = aKeywordPair.copy( 0, ndx );
+                        if ( aIndex != aTempString )
+                        {
+                            aIndex = aTempString;
+                            it = aInfo.emplace(aTempString, 0).first;
+                            sId = OUString::number(reinterpret_cast<sal_Int64>(new IndexEntry_Impl(OUString(), false)));
+                            if ( (tmp = it->second++) != 0)
+                                m_xIndexList->append(sId, aTempString + OUString(append, tmp));
+                            else
+                                m_xIndexList->append(sId, aTempString);
+                        }
+                    }
+                    else
+                        aIndex.clear();
+
+                    sal_uInt32 nRefListLen = aRefList.getLength();
+
+                    DBG_ASSERT( aAnchorList.hasElements(), "*IndexTabPage_Impl::InitializeIndex(): AnchorList is empty!" );
+                    DBG_ASSERT( nRefListLen, "*IndexTabPage_Impl::InitializeIndex(): RefList is empty!" );
+
+                    if ( aAnchorList.hasElements() && nRefListLen )
+                    {
+                        if ( aAnchorList[0].getLength() > 0 )
+                        {
+                            aData.append( aRefList[0] ).append( '#' ).append( aAnchorList[0] );
+                            sId = OUString::number(reinterpret_cast<sal_Int64>(new IndexEntry_Impl(aData.makeStringAndClear(), insert)));
+                        }
+                        else
+                            sId = OUString::number(reinterpret_cast<sal_Int64>(new IndexEntry_Impl(aRefList[0], insert)));
+                    }
+
+                    // Assume the token is trimmed
+                    it = aInfo.emplace(aKeywordPair, 0).first;
+                    if ((tmp = it->second++) != 0)
+                        m_xIndexList->append(sId, aKeywordPair + OUString(append, tmp));
+                    else
+                        m_xIndexList->append(sId, aKeywordPair);
+
+                    for ( sal_uInt32 j = 1; j < nRefListLen ; ++j )
+                    {
+                        aData
+                            .append( aKeywordPair )
+                            .append( ' ' )
+                            .append( '-' )
+                            .append( ' ' )
+                            .append( aTitleList[j] );
+
+                        aTempString = aData.makeStringAndClear();
+
+                        if ( aAnchorList[j].getLength() > 0 )
+                        {
+                            aData.append( aRefList[j] ).append( '#' ).append( aAnchorList[j] );
+                            sId = OUString::number(reinterpret_cast<sal_Int64>(new IndexEntry_Impl(aData.makeStringAndClear(), insert)));
+                        }
+                        else
+                            sId = OUString::number(reinterpret_cast<sal_Int64>(new IndexEntry_Impl(aRefList[j], insert)));
+
+                        it = aInfo.emplace(aTempString, 0).first;
+                        if ( (tmp = it->second++) != 0 )
+                            m_xIndexList->append(sId, aTempString + OUString(append, tmp));
+                        else
+                            m_xIndexList->append(sId, aTempString);
+                    }
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+        OSL_FAIL( "IndexTabPage_Impl::InitializeIndex(): unexpected exception" );
+    }
+
+    m_xIndexList->thaw();
+
+    if ( !sKeyword.isEmpty() )
+        aKeywordLink.Call( *this );
+}
+
+void IndexTabPage_Impl::ClearIndex()
+{
+    const sal_Int32 nCount = m_xIndexList->n_children();
+    for ( sal_Int32 i = 0; i < nCount; ++i )
+        delete reinterpret_cast<IndexEntry_Impl*>(m_xIndexList->get_id(i).toInt64());
+    m_xIndexList->clear();
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, OpenHdl, weld::Button&, void)
+{
+    aDoubleClickHdl.Call(nullptr);
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, ActivateHdl, weld::Entry&, bool)
+{
+    aDoubleClickHdl.Call(nullptr);
+    return true;
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, DoubleClickHdl, weld::TreeView&, bool)
+{
+    aDoubleClickHdl.Call(nullptr);
+    return true;
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, IdleHdl, Timer*, void)
+{
+    InitializeIndex();
+}
+
+int IndexTabPage_Impl::starts_with(const OUString& rStr, int nStartRow, bool bCaseSensitive)
+{
+    const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
+
+    int nRet = nStartRow;
+    int nCount = m_xIndexList->n_children();
+    while (nRet < nCount)
+    {
+        OUString aStr(m_xIndexList->get_text(nRet));
+        const bool bMatch = !bCaseSensitive ? rI18nHelper.MatchString(rStr, aStr) : aStr.startsWith(rStr);
+        if (bMatch)
+            return nRet;
+        ++nRet;
+    }
+
+    return -1;
+}
+
+IMPL_LINK_NOARG(IndexTabPage_Impl, AutoCompleteHdl, Timer*, void)
+{
+    OUString aStartText = m_xIndexEntry->get_text();
+    int nStartPos, nEndPos;
+    m_xIndexEntry->get_selection_bounds(nStartPos, nEndPos);
+    int nMaxSelection = std::max(nStartPos, nEndPos);
+    if (nMaxSelection != aStartText.getLength())
+        return;
+
+    int nActive = m_xIndexList->get_selected_index();
+    int nStart = nActive;
+
+    if (nStart == -1)
+        nStart = 0;
+
+    // Try match case insensitive from current position
+    int nPos = starts_with(aStartText, nStart, false);
+    if (nPos == -1 && nStart != 0)
+    {
+        // Try match case insensitive, but from start
+        nPos = starts_with(aStartText, 0, false);
+    }
+
+    if (nPos == -1)
+    {
+        // Try match case sensitive from current position
+        nPos = starts_with(aStartText, nStart, true);
+        if (nPos == -1 && nStart != 0)
+        {
+            // Try match case sensitive, but from start
+            nPos = starts_with(aStartText, 0, true);
+        }
+    }
+
+    if (nPos != -1)
+    {
+        m_xIndexList->set_cursor(nPos);
+        m_xIndexList->select(nPos);
+        OUString aText = m_xIndexList->get_text(nPos);
+        if (aText != aStartText)
+            m_xIndexEntry->set_text(aText);
+        m_xIndexEntry->select_region(aText.getLength(), aStartText.getLength());
+    }
+}
+
+IMPL_LINK( IndexTabPage_Impl, TimeoutHdl, Timer*, pTimer, void)
+{
+    if(&aKeywordTimer == pTimer && !sKeyword.isEmpty())
+        aKeywordLink.Call(*this);
+}
+
+void IndexTabPage_Impl::Activate()
+{
+    if ( !bIsActivated )
+    {
+        bIsActivated = true;
+        aFactoryIdle.Start();
+    }
+}
+
+weld::Widget* IndexTabPage_Impl::GetLastFocusControl()
+{
+    return m_xOpenBtn.get();
+}
+
+void IndexTabPage_Impl::SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink)
+{
+    aDoubleClickHdl = rLink;
+}
+
+void IndexTabPage_Impl::SetFactory( const OUString& rFactory )
+{
+    OUString sNewFactory( rFactory );
+    DBG_ASSERT( !sNewFactory.isEmpty(), "empty factory" );
+    bool bValid = m_pIdxWin->IsValidFactory( rFactory );
+
+    if ( sFactory.isEmpty() && !bValid )
+    {
+        sNewFactory = SfxHelp::GetDefaultHelpModule();
+        bValid = true;
+    }
+
+    if ( sNewFactory != sFactory && bValid )
+    {
+        sFactory = sNewFactory;
+        ClearIndex();
+        if ( bIsActivated )
+            aFactoryIdle.Start();
+    }
+}
+
+OUString IndexTabPage_Impl::GetSelectedEntry() const
+{
+    OUString aRet;
+    IndexEntry_Impl* pEntry = reinterpret_cast<IndexEntry_Impl*>(m_xIndexList->get_id(m_xIndexList->find_text(m_xIndexEntry->get_text())).toInt64());
+    if (pEntry)
+        aRet = pEntry->m_aURL;
+    return aRet;
+}
+
+void IndexTabPage_Impl::SetKeyword( const OUString& rKeyword )
+{
+    sKeyword = rKeyword;
+
+    if (m_xIndexList->n_children() > 0)
+        aKeywordTimer.Start();
+    else if ( !bIsActivated )
+        aFactoryIdle.Start();
+}
+
+
+bool IndexTabPage_Impl::HasKeyword() const
+{
+    bool bRet = false;
+    if ( !sKeyword.isEmpty() )
+    {
+        sal_Int32 nPos = m_xIndexList->find_text( sKeyword );
+        bRet = nPos != -1;
+    }
+
+    return bRet;
+}
+
+
+bool IndexTabPage_Impl::HasKeywordIgnoreCase()
+{
+    bool bRet = false;
+    if ( !sKeyword.isEmpty() )
+    {
+        sal_Int32 nEntries = m_xIndexList->n_children();
+        const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetLocaleI18nHelper();
+        for ( sal_Int32 n = 0; n < nEntries; n++)
+        {
+            const OUString sIndexItem {m_xIndexList->get_text(n)};
+            if (rI18nHelper.MatchString( sIndexItem, sKeyword ))
+            {
+                sKeyword = sIndexItem;
+                bRet = true;
+            }
+        }
+    }
+
+    return bRet;
+}
+
+void IndexTabPage_Impl::OpenKeyword()
+{
+    if ( !sKeyword.isEmpty() )
+    {
+        m_xIndexEntry->set_text(sKeyword);
+        aDoubleClickHdl.Call(nullptr);
+        sKeyword.clear();
+    }
+}
+
+IMPL_LINK_NOARG(SearchTabPage_Impl, ActivateHdl, weld::ComboBox&, bool)
+{
+    Search();
+    return true;
+}
+
+// class SearchTabPage_Impl ----------------------------------------------
+
+SearchTabPage_Impl::SearchTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* pIdxWin)
+    : HelpTabPage_Impl(pParent, pIdxWin, "HelpSearchPage",
+        "sfx/ui/helpsearchpage.ui")
+    , m_xSearchED(m_xBuilder->weld_combo_box("search"))
+    , m_xSearchBtn(m_xBuilder->weld_button("find"))
+    , m_xFullWordsCB(m_xBuilder->weld_check_button("completewords"))
+    , m_xScopeCB(m_xBuilder->weld_check_button("headings"))
+    , m_xResultsLB(m_xBuilder->weld_tree_view("results"))
+    , m_xOpenBtn(m_xBuilder->weld_button("display"))
+    , xBreakIterator(vcl::unohelper::CreateBreakIterator())
+{
+    m_xResultsLB->set_size_request(m_xResultsLB->get_approximate_digit_width() * 30,
+                                   m_xResultsLB->get_height_rows(15));
+
+    m_xSearchBtn->connect_clicked(LINK(this, SearchTabPage_Impl, ClickHdl));
+    m_xSearchED->connect_changed(LINK(this, SearchTabPage_Impl, ModifyHdl));
+    m_xSearchED->connect_entry_activate(LINK(this, SearchTabPage_Impl, ActivateHdl));
+    m_xOpenBtn->connect_clicked(LINK(this, SearchTabPage_Impl, OpenHdl));
+    m_xResultsLB->connect_row_activated(LINK(this, SearchTabPage_Impl, DoubleClickHdl));
+
+    SvtViewOptions aViewOpt( EViewType::TabPage, CONFIGNAME_SEARCHPAGE );
+    if ( aViewOpt.Exists() )
+    {
+        OUString aUserData;
+        Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME );
+        if ( aUserItem >>= aUserData )
+        {
+            sal_Int32 nIdx {0};
+            bool bChecked = aUserData.getToken(0, ';', nIdx).toInt32() == 1;
+            m_xFullWordsCB->set_active(bChecked);
+            bChecked = aUserData.getToken(0, ';', nIdx).toInt32() == 1;
+            m_xScopeCB->set_active(bChecked);
+
+            while ( nIdx > 0 )
+            {
+                m_xSearchED->append_text( INetURLObject::decode(
+                    aUserData.getToken(0, ';', nIdx),
+                    INetURLObject::DecodeMechanism::WithCharset ) );
+            }
+        }
+    }
+
+    ModifyHdl(*m_xSearchED);
+}
+
+SearchTabPage_Impl::~SearchTabPage_Impl()
+{
+    SvtViewOptions aViewOpt( EViewType::TabPage, CONFIGNAME_SEARCHPAGE );
+    OUStringBuffer aUserData;
+    aUserData.append(OUString::number(m_xFullWordsCB->get_active() ? 1 : 0))
+        .append(";")
+        .append(OUString::number( m_xScopeCB->get_active() ? 1 : 0 ));
+    sal_Int32 nCount = std::min(m_xSearchED->get_count(), 10);  // save only 10 entries
+
+    for ( sal_Int32 i = 0; i < nCount; ++i )
+    {
+        aUserData.append(";").append(INetURLObject::encode(
+            m_xSearchED->get_text(i),
+            INetURLObject::PART_UNO_PARAM_VALUE,
+            INetURLObject::EncodeMechanism::All ));
+    }
+
+    Any aUserItem = makeAny( aUserData.makeStringAndClear() );
+    aViewOpt.SetUserItem( USERITEM_NAME, aUserItem );
+
+    m_xSearchED.reset();
+    m_xSearchBtn.reset();
+    m_xFullWordsCB.reset();
+    m_xScopeCB.reset();
+    m_xResultsLB.reset();
+    m_xOpenBtn.reset();
+}
+
+void SearchTabPage_Impl::ClearSearchResults()
+{
+    m_xResultsLB->clear();
+}
+
+void SearchTabPage_Impl::RememberSearchText( const OUString& rSearchText )
+{
+    for (sal_Int32 i = 0, nEntryCount = m_xSearchED->get_count(); i < nEntryCount; ++i)
+    {
+        if (rSearchText == m_xSearchED->get_text(i))
+        {
+            m_xSearchED->remove(i);
+            break;
+        }
+    }
+
+    m_xSearchED->insert_text(0, rSearchText);
+}
+
+IMPL_LINK_NOARG(SearchTabPage_Impl, ClickHdl, weld::Button&, void)
+{
+    Search();
+}
+
+void SearchTabPage_Impl::Search()
+{
+    OUString aSearchText = comphelper::string::strip(m_xSearchED->get_active_text(), ' ');
+    if ( aSearchText.isEmpty() )
+        return;
+
+    std::unique_ptr<weld::WaitObject> xWaitCursor(new weld::WaitObject(m_pIdxWin->GetFrameWeld()));
+    ClearSearchResults();
+    RememberSearchText( aSearchText );
+    OUStringBuffer aSearchURL(HELP_URL);
+    aSearchURL.append(aFactory);
+    aSearchURL.append(HELP_SEARCH_TAG);
+    if (!m_xFullWordsCB->get_active())
+        aSearchText = sfx2::PrepareSearchString( aSearchText, xBreakIterator, true );
+    aSearchURL.append(aSearchText);
+    AppendConfigToken(aSearchURL, false);
+    if (m_xScopeCB->get_active())
+        aSearchURL.append("&Scope=Heading");
+    std::vector< OUString > aFactories = SfxContentHelper::GetResultSet(aSearchURL.makeStringAndClear());
+    for (const OUString & rRow : aFactories)
+    {
+        sal_Int32 nIdx = 0;
+        OUString aTitle = rRow.getToken(0, '\t', nIdx);
+        OUString sURL(rRow.getToken(1, '\t', nIdx));
+        m_xResultsLB->append(sURL, aTitle);
+    }
+    xWaitCursor.reset();
+
+    if ( aFactories.empty() )
+    {
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xContainer.get(),
+                                                                 VclMessageType::Info, VclButtonsType::Ok,
+                                                                 SfxResId(STR_INFO_NOSEARCHRESULTS)));
+        xBox->run();
+    }
+}
+
+IMPL_LINK_NOARG(SearchTabPage_Impl, OpenHdl, weld::Button&, void)
+{
+    aDoubleClickHdl.Call(nullptr);
+}
+
+IMPL_LINK(SearchTabPage_Impl, ModifyHdl, weld::ComboBox&, rComboBox, void)
+{
+    OUString aSearchText = comphelper::string::strip(m_xSearchED->get_active_text(), ' ');
+    m_xSearchBtn->set_sensitive(!aSearchText.isEmpty());
+
+    if (rComboBox.changed_by_direct_pick())
+        Search();
+}
+
+weld::Widget* SearchTabPage_Impl::GetLastFocusControl()
+{
+    return m_xOpenBtn.get();
+}
+
+IMPL_LINK_NOARG(SearchTabPage_Impl, DoubleClickHdl, weld::TreeView&, bool)
+{
+    aDoubleClickHdl.Call(nullptr);
+    return true;
+}
+
+void SearchTabPage_Impl::SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink)
+{
+    aDoubleClickHdl = rLink;
+}
+
+OUString SearchTabPage_Impl::GetSelectedEntry() const
+{
+    return m_xResultsLB->get_selected_id();
+}
+
+void SearchTabPage_Impl::ClearPage()
+{
+    ClearSearchResults();
+    m_xSearchED->set_entry_text(OUString());
+}
+
+bool SearchTabPage_Impl::OpenKeyword( const OUString& rKeyword )
+{
+    bool bRet = false;
+    m_xSearchED->set_entry_text(rKeyword);
+    Search();
+    if (m_xResultsLB->n_children() > 0)
+    {
+        // found keyword -> open it
+        m_xResultsLB->select(0);
+        OpenHdl(*m_xOpenBtn);
+        bRet = true;
+    }
+    return bRet;
+}
+
+// class BookmarksTabPage_Impl -------------------------------------------
+static void GetBookmarkEntry_Impl
+(
+    const Sequence< PropertyValue >& aBookmarkEntry,
+    OUString& rTitle,
+    OUString& rURL
+)
+{
+    for ( const PropertyValue& aValue : aBookmarkEntry )
+    {
+        if ( aValue.Name == HISTORY_PROPERTYNAME_URL )
+            aValue.Value >>= rURL;
+        else if ( aValue.Name == HISTORY_PROPERTYNAME_TITLE )
+            aValue.Value >>= rTitle;
+    }
+}
+
+void BookmarksTabPage_Impl::DoAction(const OString& rAction)
+{
+    if (rAction == "display")
+        aDoubleClickHdl.Call(nullptr);
+    else if (rAction == "rename")
+    {
+        sal_Int32 nPos = m_xBookmarksBox->get_selected_index();
+        if (nPos != -1)
+        {
+            SfxAddHelpBookmarkDialog_Impl aDlg(m_xBookmarksBox.get(), true);
+            aDlg.SetTitle(m_xBookmarksBox->get_text(nPos));
+            if (aDlg.run() == RET_OK)
+            {
+                OUString sURL = m_xBookmarksBox->get_id(nPos);
+                m_xBookmarksBox->remove(nPos);
+                m_xBookmarksBox->append(sURL, aDlg.GetTitle(), SvFileInformationManager::GetImageId(INetURLObject(IMAGE_URL+INetURLObject(sURL).GetHost())));
+                m_xBookmarksBox->select(m_xBookmarksBox->n_children() - 1);
+            }
+        }
+    }
+    else if (rAction == "delete")
+    {
+        sal_Int32 nPos = m_xBookmarksBox->get_selected_index();
+        if (nPos != -1)
+        {
+            m_xBookmarksBox->remove(nPos);
+            const sal_Int32 nCount = m_xBookmarksBox->n_children();
+            if (nCount)
+            {
+                if (nPos >= nCount)
+                    nPos = nCount - 1;
+                m_xBookmarksBox->select(nPos);
+            }
+        }
+    }
+}
+
+IMPL_LINK(BookmarksTabPage_Impl, CommandHdl, const CommandEvent&, rCEvt, bool)
+{
+    if (rCEvt.GetCommand() != CommandEventId::ContextMenu)
+        return false;
+
+    std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xBookmarksBox.get(), "sfx/ui/bookmarkmenu.ui"));
+    std::unique_ptr<weld::Menu> xMenu = xBuilder->weld_menu("menu");
+
+    OString sIdent = xMenu->popup_at_rect(m_xBookmarksBox.get(), ::tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1)));
+    if (!sIdent.isEmpty())
+        DoAction(sIdent);
+    return true;
+}
+
+IMPL_LINK(BookmarksTabPage_Impl, KeyInputHdl, const KeyEvent&, rKEvt, bool)
+{
+    bool bHandled = false;
+    sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
+    if (KEY_DELETE == nCode && m_xBookmarksBox->n_children() > 0)
+    {
+        DoAction("delete");
+        bHandled = true;
+    }
+    return bHandled;
+}
+
+// class BookmarksTabPage_Impl -------------------------------------------
+BookmarksTabPage_Impl::BookmarksTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* _pIdxWin)
+    : HelpTabPage_Impl(pParent, _pIdxWin, "HelpBookmarkPage",
+        "sfx/ui/helpbookmarkpage.ui")
+    , m_xBookmarksBox(m_xBuilder->weld_tree_view("bookmarks"))
+    , m_xBookmarksPB(m_xBuilder->weld_button("display"))
+{
+    m_xBookmarksBox->set_size_request(m_xBookmarksBox->get_approximate_digit_width() * 30,
+                                      m_xBookmarksBox->get_height_rows(20));
+
+    m_xBookmarksPB->connect_clicked( LINK(this, BookmarksTabPage_Impl, OpenHdl));
+    m_xBookmarksBox->connect_row_activated(LINK(this, BookmarksTabPage_Impl, DoubleClickHdl));
+    m_xBookmarksBox->connect_popup_menu(LINK(this, BookmarksTabPage_Impl, CommandHdl));
+    m_xBookmarksBox->connect_key_press(LINK(this, BookmarksTabPage_Impl, KeyInputHdl));
+
+    // load bookmarks from configuration
+    const Sequence< Sequence< PropertyValue > > aBookmarkSeq = SvtHistoryOptions().GetList( eHELPBOOKMARKS );
+
+    OUString aTitle;
+    OUString aURL;
+
+    for ( const auto& rBookmark : aBookmarkSeq )
+    {
+        GetBookmarkEntry_Impl( rBookmark, aTitle, aURL );
+        AddBookmarks( aTitle, aURL );
+    }
+}
+
+BookmarksTabPage_Impl::~BookmarksTabPage_Impl()
+{
+    // save bookmarks to configuration
+    SvtHistoryOptions aHistOpt;
+    aHistOpt.Clear( eHELPBOOKMARKS );
+    const sal_Int32 nCount = m_xBookmarksBox->n_children();
+    for (sal_Int32 i = 0; i < nCount; ++i)
+        aHistOpt.AppendItem(eHELPBOOKMARKS, m_xBookmarksBox->get_id(i), "", m_xBookmarksBox->get_text(i), std::nullopt);
+
+    m_xBookmarksBox.reset();
+    m_xBookmarksPB.reset();
+}
+
+IMPL_LINK_NOARG(BookmarksTabPage_Impl, OpenHdl, weld::Button&, void)
+{
+    aDoubleClickHdl.Call(nullptr);
+}
+
+weld::Widget* BookmarksTabPage_Impl::GetLastFocusControl()
+{
+    return m_xBookmarksPB.get();
+}
+
+IMPL_LINK_NOARG(BookmarksTabPage_Impl, DoubleClickHdl, weld::TreeView&, bool)
+{
+    aDoubleClickHdl.Call(nullptr);
+    return true;
+}
+
+void BookmarksTabPage_Impl::SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink)
+{
+    aDoubleClickHdl = rLink;
+}
+
+OUString BookmarksTabPage_Impl::GetSelectedEntry() const
+{
+    return m_xBookmarksBox->get_selected_id();
+}
+
+void BookmarksTabPage_Impl::AddBookmarks(const OUString& rTitle, const OUString& rURL)
+{
+    const OUString aImageURL {IMAGE_URL + INetURLObject(rURL).GetHost()};
+    m_xBookmarksBox->append(rURL, rTitle, SvFileInformationManager::GetImageId(INetURLObject(aImageURL)));
+}
+
+OUString SfxHelpWindow_Impl::buildHelpURL(const OUString& sFactory        ,
+                                          const OUString& sContent        ,
+                                          const OUString& sAnchor)
+{
+    OUStringBuffer sHelpURL(256);
+    sHelpURL.append(HELP_URL);
+    sHelpURL.append(sFactory);
+    sHelpURL.append(sContent);
+    AppendConfigToken(sHelpURL, true/*bUseQuestionMark*/);
+    if (!sAnchor.isEmpty())
+        sHelpURL.append(sAnchor);
+    return sHelpURL.makeStringAndClear();
+}
+
+void SfxHelpWindow_Impl::loadHelpContent(const OUString& sHelpURL, bool bAddToHistory)
+{
+    Reference< XComponentLoader > xLoader(getTextFrame(), UNO_QUERY);
+    if (!xLoader.is())
+        return;
+
+    // If a print job runs do not open a new page
+    Reference< XFrame2 >     xTextFrame      = pTextWin->getFrame();
+    Reference< XController > xTextController ;
+    if (xTextFrame.is())
+        xTextController = xTextFrame->getController ();
+    if ( xTextController.is() && !xTextController->suspend( true ) )
+    {
+        xTextController->suspend( false );
+        return;
+    }
+
+    // save url to history
+    if (bAddToHistory)
+        pHelpInterceptor->addURL(sHelpURL);
+
+    if ( !IsWait() )
+        EnterWait();
+    bool bSuccess = false;
+// TODO implement locale fallback ... see below    while(true)
+    {
+        try
+        {
+            Reference< XComponent > xContent = xLoader->loadComponentFromURL(sHelpURL, "_self", 0, Sequence< PropertyValue >());
+            if (xContent.is())
+            {
+                bSuccess = true;
+            }
+        }
+        catch(const RuntimeException&)
+            { throw; }
+        catch(const Exception&)
+            { /*break;*/ }
+
+        /* TODO try next locale ...
+                no further locale available? => break loop and show error page
+        */
+    }
+    openDone(sHelpURL, bSuccess);
+    if ( IsWait() )
+        LeaveWait();
+}
+
+IMPL_LINK(SfxHelpIndexWindow_Impl, ActivatePageHdl, const OString&, rPage, void)
+{
+    GetPage(rPage)->Activate();
+}
+
+SfxHelpIndexWindow_Impl::SfxHelpIndexWindow_Impl(SfxHelpWindow_Impl* _pParent, weld::Container* pContainer)
+    : m_xBuilder(Application::CreateBuilder(pContainer, "sfx/ui/helpcontrol.ui"))
+    , m_xContainer(m_xBuilder->weld_container("HelpControl"))
+    , m_xActiveLB(m_xBuilder->weld_combo_box("active"))
+    , m_xTabCtrl(m_xBuilder->weld_notebook("tabcontrol"))
+    , aIdle("sfx2 appl SfxHelpIndexWindow_Impl")
+    , aIndexKeywordLink(LINK(this, SfxHelpIndexWindow_Impl, KeywordHdl))
+    , pParentWin(_pParent)
+    , bIsInitDone(false)
+{
+    // create the pages
+    GetContentPage();
+    GetIndexPage();
+    GetSearchPage();
+    GetBookmarksPage();
+
+    OString sPageId("index");
+    SvtViewOptions aViewOpt( EViewType::TabDialog, CONFIGNAME_INDEXWIN );
+    if ( aViewOpt.Exists() )
+        sPageId = aViewOpt.GetPageID();
+    m_xTabCtrl->set_current_page(sPageId);
+    ActivatePageHdl(sPageId);
+    m_xActiveLB->connect_changed(LINK(this, SfxHelpIndexWindow_Impl, SelectHdl));
+
+    m_xTabCtrl->connect_enter_page(LINK(this, SfxHelpIndexWindow_Impl, ActivatePageHdl));
+
+    aIdle.SetInvokeHandler( LINK( this, SfxHelpIndexWindow_Impl, InitHdl ) );
+    aIdle.Start();
+
+    m_xContainer->show();
+}
+
+SfxHelpIndexWindow_Impl::~SfxHelpIndexWindow_Impl()
+{
+    SvtViewOptions aViewOpt(EViewType::TabDialog, CONFIGNAME_INDEXWIN);
+    aViewOpt.SetPageID(m_xTabCtrl->get_current_page_ident());
+
+    xCPage.reset();
+    xIPage.reset();
+    xSPage.reset();
+    xBPage.reset();
+}
+
+void SfxHelpIndexWindow_Impl::Initialize()
+{
+    OUStringBuffer aHelpURL(HELP_URL);
+    AppendConfigToken(aHelpURL, true);
+    std::vector<OUString> aFactories = SfxContentHelper::GetResultSet(aHelpURL.makeStringAndClear());
+    for (const OUString & rRow : aFactories)
+    {
+        sal_Int32 nIdx = 0;
+        OUString aTitle = rRow.getToken( 0, '\t', nIdx ); // token 0
+        OUString aURL = rRow.getToken( 1, '\t', nIdx ); // token 2
+        OUString aFactory(INetURLObject(aURL).GetHost());
+        m_xActiveLB->append(aFactory, aTitle);
+    }
+
+    if (m_xActiveLB->get_active() == -1)
+        SetActiveFactory();
+}
+
+void SfxHelpIndexWindow_Impl::SetActiveFactory()
+{
+    DBG_ASSERT( xIPage, "index page not initialized" );
+    if (!bIsInitDone && !m_xActiveLB->get_count())
+    {
+        aIdle.Stop();
+        InitHdl( nullptr );
+    }
+
+    for (sal_Int32 i = 0, nEntryCount = m_xActiveLB->get_count(); i < nEntryCount; ++i)
+    {
+        OUString aFactory = m_xActiveLB->get_id(i);
+        aFactory = aFactory.toAsciiLowerCase();
+        if (aFactory == xIPage->GetFactory())
+        {
+            if (m_xActiveLB->get_active() != i)
+            {
+                m_xActiveLB->set_active(i);
+                aSelectFactoryLink.Call(nullptr);
+            }
+            break;
+        }
+    }
+}
+
+HelpTabPage_Impl* SfxHelpIndexWindow_Impl::GetPage(const OString& rName)
+{
+    HelpTabPage_Impl* pPage = nullptr;
+
+    if (rName == "contents")
+        pPage = GetContentPage();
+    else if (rName == "index")
+        pPage = GetIndexPage();
+    else if (rName == "find")
+        pPage = GetSearchPage();
+    else if (rName == "bookmarks")
+        pPage = GetBookmarksPage();
+
+    assert(pPage && "SfxHelpIndexWindow_Impl::GetCurrentPage(): no current page");
+
+    return pPage;
+}
+
+IMPL_LINK_NOARG(SfxHelpIndexWindow_Impl, SelectHdl, weld::ComboBox&, void)
+{
+    aIdle.Start();
+}
+
+IMPL_LINK_NOARG(SfxHelpIndexWindow_Impl, InitHdl, Timer *, void)
+{
+    bIsInitDone = true;
+    Initialize();
+
+    // now use the timer for selection
+    aIdle.SetInvokeHandler( LINK( this, SfxHelpIndexWindow_Impl, SelectFactoryHdl ) );
+    aIdle.SetPriority( TaskPriority::LOWEST );
+}
+
+IMPL_LINK_NOARG(SfxHelpIndexWindow_Impl, SelectFactoryHdl, Timer *, void)
+{
+    OUString aFactory = m_xActiveLB->get_active_id();
+    if (!aFactory.isEmpty())
+    {
+        SetFactory(aFactory.toAsciiLowerCase(), false);
+        aSelectFactoryLink.Call(this);
+    }
+}
+
+IMPL_LINK_NOARG(SfxHelpIndexWindow_Impl, KeywordHdl, IndexTabPage_Impl&, void)
+{
+    // keyword found on index?
+    bool bIndex = xIPage->HasKeyword();
+
+    if( !bIndex)
+        bIndex = xIPage->HasKeywordIgnoreCase();
+    // then set index or search page as current.
+    OString sPageId = bIndex ? "index" : "find";
+    if (sPageId != m_xTabCtrl->get_current_page_ident())
+        m_xTabCtrl->set_current_page(sPageId);
+
+    // at last we open the keyword
+    if ( bIndex )
+        xIPage->OpenKeyword();
+    else if ( !xSPage->OpenKeyword( sKeyword ) )
+        pParentWin->ShowStartPage();
+}
+
+IMPL_LINK_NOARG(SfxHelpIndexWindow_Impl, IndexTabPageDoubleClickHdl, LinkParamNone*, void)
+{
+    aPageDoubleClickLink.Call(nullptr);
+}
+
+void SfxHelpIndexWindow_Impl::SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink)
+{
+    aPageDoubleClickLink = rLink;
+}
+
+IMPL_LINK_NOARG(SfxHelpIndexWindow_Impl, ContentTabPageDoubleClickHdl, LinkParamNone*, void)
+{
+    aPageDoubleClickLink.Call(nullptr);
+}
+
+IMPL_LINK_NOARG(SfxHelpIndexWindow_Impl, TabPageDoubleClickHdl, LinkParamNone*, void)
+{
+    aPageDoubleClickLink.Call(nullptr);
+}
+
+void SfxHelpIndexWindow_Impl::SetFactory( const OUString& rFactory, bool bActive )
+{
+    if ( !rFactory.isEmpty() )
+    {
+        GetIndexPage()->SetFactory( rFactory );
+        // the index page made a check if rFactory is valid,
+        // so the index page always returns a valid factory
+        GetSearchPage()->SetFactory( GetIndexPage()->GetFactory() );
+        if ( bActive )
+            SetActiveFactory();
+    }
+}
+
+OUString SfxHelpIndexWindow_Impl::GetSelectedEntry() const
+{
+    OUString sRet;
+
+    OString sName(m_xTabCtrl->get_current_page_ident());
+
+    if (sName == "contents")
+    {
+        sRet = xCPage->GetSelectedEntry();
+    }
+    else if (sName == "index")
+    {
+        sRet = xIPage->GetSelectedEntry();
+    }
+    else if (sName == "find")
+    {
+        sRet = xSPage->GetSelectedEntry();
+    }
+    else if (sName == "bookmarks")
+    {
+        sRet = xBPage->GetSelectedEntry();
+    }
+
+    return sRet;
+}
+
+void SfxHelpIndexWindow_Impl::AddBookmarks( const OUString& rTitle, const OUString& rURL )
+{
+    GetBookmarksPage()->AddBookmarks( rTitle, rURL );
+}
+
+bool SfxHelpIndexWindow_Impl::IsValidFactory( const OUString& _rFactory )
+{
+    bool bValid = false;
+    for (sal_Int32 i = 0, nEntryCount = m_xActiveLB->get_count(); i < nEntryCount; ++i)
+    {
+        OUString aFactory = m_xActiveLB->get_id(i);
+        if (aFactory == _rFactory)
+        {
+            bValid = true;
+            break;
+        }
+    }
+    return bValid;
+}
+
+void SfxHelpIndexWindow_Impl::ClearSearchPage()
+{
+    if ( xSPage )
+        xSPage->ClearPage();
+}
+
+void SfxHelpIndexWindow_Impl::GrabFocusBack()
+{
+    OString sName(m_xTabCtrl->get_current_page_ident());
+
+    if (sName == "contents" && xCPage)
+        xCPage->SetFocusOnBox();
+    else if (sName == "index" && xIPage)
+        xIPage->SetFocusOnBox();
+    else if (sName == "find" && xSPage)
+        xSPage->SetFocusOnBox();
+    else if (sName == "bookmarks" && xBPage)
+        xBPage->SetFocusOnBox();
+}
+
+bool SfxHelpIndexWindow_Impl::HasFocusOnEdit() const
+{
+    bool bRet = false;
+    OString sName(m_xTabCtrl->get_current_page_ident());
+    if (sName == "index" && xIPage)
+        bRet = xIPage->HasFocusOnEdit();
+    else if (sName == "find" && xSPage)
+        bRet = xSPage->HasFocusOnEdit();
+    return bRet;
+}
+
+OUString SfxHelpIndexWindow_Impl::GetSearchText() const
+{
+    OUString sRet;
+    OString sName(m_xTabCtrl->get_current_page_ident());
+    if (sName == "find" && xSPage)
+        sRet = xSPage->GetSearchText();
+    return sRet;
+}
+
+bool SfxHelpIndexWindow_Impl::IsFullWordSearch() const
+{
+    bool bRet = false;
+    OString sName(m_xTabCtrl->get_current_page_ident());
+    if (sName == "find" && xSPage)
+        bRet = xSPage->IsFullWordSearch();
+    return bRet;
+}
+
+void SfxHelpIndexWindow_Impl::OpenKeyword( const OUString& rKeyword )
+{
+    sKeyword = rKeyword;
+    DBG_ASSERT( xIPage, "invalid index page" );
+    xIPage->SetKeyword( sKeyword );
+}
+
+void SfxHelpIndexWindow_Impl::SelectExecutableEntry()
+{
+    OString sName(m_xTabCtrl->get_current_page_ident());
+    if (sName == "index" && xIPage )
+        xIPage->SelectExecutableEntry();
+}
+
+weld::Window* SfxHelpIndexWindow_Impl::GetFrameWeld() const
+{
+    return pParentWin->GetFrameWeld();
+}
+
+// class TextWin_Impl ----------------------------------------------------
+TextWin_Impl::TextWin_Impl( vcl::Window* p ) : DockingWindow( p, 0 )
+{
+}
+
+bool TextWin_Impl::EventNotify( NotifyEvent& rNEvt )
+{
+    if( ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT ) && rNEvt.GetKeyEvent()->GetKeyCode().GetCode() == KEY_TAB )
+        return GetParent()->EventNotify( rNEvt );
+    else
+        return DockingWindow::EventNotify( rNEvt );
+}
+
+
+// remove docking area acceptor from layoutmanager, so it will not layout anything further .-)
+static void lcl_disableLayoutOfFrame(const Reference< XFrame2 >& xFrame)
+{
+    xFrame->setLayoutManager( Reference< XLayoutManager >() );
+}
+
+// class SfxHelpTextWindow_Impl ------------------------------------------
+
+SfxHelpTextWindow_Impl::SfxHelpTextWindow_Impl(SfxHelpWindow_Impl* pHelpWin, weld::Builder& rBuilder, vcl::Window* pParent) :
+
+    Window( pParent, WB_CLIPCHILDREN | WB_TABSTOP | WB_DIALOGCONTROL ),
+
+    xToolBox            ( rBuilder.weld_toolbar("toolbar") ),
+    xOnStartupCB        ( rBuilder.weld_check_button("checkbutton") ),
+    xMenu               ( rBuilder.weld_menu("menu") ),
+    aSelectIdle         ( "sfx2 appl SfxHelpTextWindow_Impl Select" ),
+    aIndexOnImage       ( BMP_HELP_TOOLBOX_INDEX_ON ),
+    aIndexOffImage      ( BMP_HELP_TOOLBOX_INDEX_OFF ),
+    aIndexOnText        ( SfxResId( STR_HELP_BUTTON_INDEX_ON ) ),
+    aIndexOffText       ( SfxResId( STR_HELP_BUTTON_INDEX_OFF ) ),
+    aOnStartupText      ( SfxResId( RID_HELP_ONSTARTUP_TEXT ) ),
+    xHelpWin            ( pHelpWin ),
+    pTextWin            ( VclPtr<TextWin_Impl>::Create( this ) ),
+    bIsDebug            ( false ),
+    bIsIndexOn          ( false ),
+    bIsInClose          ( false ),
+    bIsFullWordSearch   ( false )
+{
+    xFrame = Frame::create( ::comphelper::getProcessComponentContext() );
+    xFrame->initialize( VCLUnoHelper::GetInterface ( pTextWin ) );
+    xFrame->setName( "OFFICE_HELP" );
+    lcl_disableLayoutOfFrame(xFrame);
+
+    xToolBox->set_help_id(HID_HELP_TOOLBOX);
+
+    xToolBox->set_item_tooltip_text("index", aIndexOffText );
+    xToolBox->set_item_help_id("index", HID_HELP_TOOLBOXITEM_INDEX);
+    xToolBox->set_item_help_id("backward", HID_HELP_TOOLBOXITEM_BACKWARD);
+    xToolBox->set_item_help_id("forward", HID_HELP_TOOLBOXITEM_FORWARD);
+    xToolBox->set_item_help_id("start", HID_HELP_TOOLBOXITEM_START);
+    xToolBox->set_item_help_id("print", HID_HELP_TOOLBOXITEM_PRINT);
+    xToolBox->set_item_help_id("bookmarks", HID_HELP_TOOLBOXITEM_BOOKMARKS );
+    xToolBox->set_item_help_id("searchdialog", HID_HELP_TOOLBOXITEM_SEARCHDIALOG);
+
+    InitToolBoxImages();
+    InitOnStartupBox();
+    xOnStartupCB->connect_clicked(LINK(this, SfxHelpTextWindow_Impl, CheckHdl));
+
+    aSelectIdle.SetInvokeHandler( LINK( this, SfxHelpTextWindow_Impl, SelectHdl ) );
+    aSelectIdle.SetPriority( TaskPriority::LOWEST );
+
+    char* pEnv = getenv( "help_debug" );
+    if ( pEnv )
+        bIsDebug = true;
+
+    SvtMiscOptions().AddListenerLink( LINK( this, SfxHelpTextWindow_Impl, NotifyHdl ) );
+}
+
+SfxHelpTextWindow_Impl::~SfxHelpTextWindow_Impl()
+{
+    disposeOnce();
+}
+
+void SfxHelpTextWindow_Impl::dispose()
+{
+    bIsInClose = true;
+    SvtMiscOptions().RemoveListenerLink( LINK( this, SfxHelpTextWindow_Impl, NotifyHdl ) );
+    m_xSrchDlg.reset();
+    xToolBox.reset();
+    xOnStartupCB.reset();
+    xHelpWin.clear();
+    pTextWin.disposeAndClear();
+    vcl::Window::dispose();
+}
+
+bool SfxHelpTextWindow_Impl::HasSelection() const
+{
+    // is there any selection in the text and not only a cursor?
+    bool bRet = false;
+    Reference < XTextRange > xRange = getCursor();
+    if ( xRange.is() )
+    {
+        Reference < XText > xText = xRange->getText();
+        Reference < XTextCursor > xCursor = xText->createTextCursorByRange( xRange );
+        bRet = !xCursor->isCollapsed();
+    }
+
+    return bRet;
+}
+
+void SfxHelpTextWindow_Impl::InitToolBoxImages()
+{
+    xToolBox->set_item_icon_name("index", bIsIndexOn ? aIndexOffImage : aIndexOnImage);
+}
+
+void SfxHelpTextWindow_Impl::InitOnStartupBox()
+{
+    sCurrentFactory = SfxHelp::GetCurrentModuleIdentifier();
+
+    Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+    const OUString sPath { PATH_OFFICE_FACTORIES + sCurrentFactory };
+
+    // Attention: This check boy knows two states:
+    // 1) Reading of the config key fails with an exception or by getting an empty Any (!) => check box must be hidden
+    // 2) We read sal_True/sal_False => check box must be shown and enabled/disabled
+
+    bool bHideBox = true;
+    bool bHelpAtStartup = false;
+    try
+    {
+        xConfiguration = ConfigurationHelper::openConfig(
+            xContext, PACKAGE_SETUP, EConfigurationModes::Standard );
+        if ( xConfiguration.is() )
+        {
+            Any aAny = ConfigurationHelper::readRelativeKey( xConfiguration, sPath, KEY_HELP_ON_OPEN );
+            if (aAny >>= bHelpAtStartup)
+                bHideBox = false;
+        }
+    }
+    catch( Exception& )
+    {
+        bHideBox = true;
+    }
+
+    if ( bHideBox )
+        xOnStartupCB->hide();
+    else
+    {
+        // detect module name
+        OUString sModuleName;
+
+        if ( xConfiguration.is() )
+        {
+            OUString sTemp;
+            try
+            {
+                Any aAny = ConfigurationHelper::readRelativeKey( xConfiguration, sPath, KEY_UI_NAME );
+                aAny >>= sTemp;
+            }
+            catch( Exception const & )
+            {
+                TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxHelpTextWindow_Impl::InitOnStartupBox()" );
+            }
+            sModuleName = sTemp;
+        }
+
+        if ( !sModuleName.isEmpty() )
+        {
+            // set module name in checkbox text
+            xOnStartupCB->set_label(aOnStartupText.replaceFirst("%MODULENAME", sModuleName));
+            // and show it
+            xOnStartupCB->show();
+            // set check state
+            xOnStartupCB->set_active(bHelpAtStartup);
+            xOnStartupCB->save_state();
+        }
+    }
+}
+
+Reference< XBreakIterator > const & SfxHelpTextWindow_Impl::GetBreakIterator()
+{
+    if ( !xBreakIterator.is() )
+        xBreakIterator = vcl::unohelper::CreateBreakIterator();
+    DBG_ASSERT( xBreakIterator.is(), "Could not create BreakIterator" );
+    return xBreakIterator;
+}
+
+Reference< XTextRange > SfxHelpTextWindow_Impl::getCursor() const
+{
+    // return the current cursor
+    Reference< XTextRange > xCursor;
+
+    try
+    {
+        Reference < XSelectionSupplier > xSelSup( xFrame->getController(), UNO_QUERY );
+        if ( xSelSup.is() )
+        {
+            Any aAny = xSelSup->getSelection();
+            Reference < XIndexAccess > xSelection;
+            if ( aAny >>= xSelection )
+            {
+                if ( xSelection->getCount() == 1 )
+                {
+                    aAny = xSelection->getByIndex(0);
+                    aAny >>= xCursor;
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+        OSL_FAIL( "SfxHelpTextWindow_Impl::getCursor(): unexpected exception" );
+    }
+
+    return xCursor;
+}
+
+
+bool SfxHelpTextWindow_Impl::isHandledKey( const vcl::KeyCode& _rKeyCode )
+{
+    bool bRet = false;
+    sal_uInt16 nCode = _rKeyCode.GetCode();
+
+    // the keys <CTRL><A> (select all), <CTRL><C> (copy),
+    //          <CTRL><F> (find), <CTRL><P> (print) and <CTRL><W> (close window)
+    // were handled in help
+    if ( _rKeyCode.IsMod1() &&
+         ( KEY_A == nCode || KEY_C == nCode || KEY_F == nCode || KEY_P == nCode || KEY_W == nCode ) )
+    {
+        if ( KEY_F == nCode )
+            DoSearch();
+        else
+            bRet = true;
+    }
+
+    return bRet;
+}
+
+
+IMPL_LINK_NOARG(SfxHelpTextWindow_Impl, SelectHdl, Timer *, void)
+{
+    try
+    {
+        // select the words, which are equal to the search text of the search page
+        Reference < XController > xController = xFrame->getController();
+        if ( xController.is() )
+        {
+            // get document
+            Reference < XSearchable > xSearchable( xController->getModel(), UNO_QUERY );
+            if ( xSearchable.is() )
+            {
+                // create descriptor, set string and find all words
+                Reference < XSearchDescriptor > xSrchDesc = xSearchable->createSearchDescriptor();
+                xSrchDesc->setPropertyValue( "SearchRegularExpression", makeAny( true ) );
+                if ( bIsFullWordSearch )
+                    xSrchDesc->setPropertyValue( "SearchWords", makeAny( true ) );
+
+                xSrchDesc->setSearchString( sfx2::PrepareSearchString( aSearchText, GetBreakIterator(), false ) );
+                Reference< XIndexAccess > xSelection = xSearchable->findAll( xSrchDesc );
+
+                // then select all found words
+                Reference < XSelectionSupplier > xSelectionSup( xController, UNO_QUERY );
+                if ( xSelectionSup.is() )
+                {
+                    xSelectionSup->select( Any(xSelection) );
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+        OSL_FAIL( "SfxHelpTextWindow_Impl::SelectHdl(): unexpected exception" );
+    }
+}
+
+
+IMPL_LINK_NOARG( SfxHelpTextWindow_Impl, NotifyHdl, LinkParamNone*, void )
+{
+    InitToolBoxImages();
+    Resize();
+}
+
+IMPL_LINK( SfxHelpTextWindow_Impl, FindHdl, sfx2::SearchDialog&, rDlg, void )
+{
+    FindHdl(&rDlg);
+}
+void SfxHelpTextWindow_Impl::FindHdl(sfx2::SearchDialog* pDlg)
+{
+    bool bWrapAround = ( nullptr == pDlg );
+    if ( bWrapAround )
+        pDlg = m_xSrchDlg.get();
+    DBG_ASSERT( pDlg, "invalid search dialog" );
+    try
+    {
+        // select the words, which are equal to the search text of the search page
+        Reference < XController > xController = xFrame->getController();
+        if ( xController.is() )
+        {
+            // get document
+            Reference < XSearchable > xSearchable( xController->getModel(), UNO_QUERY );
+            if ( xSearchable.is() )
+            {
+                // create descriptor, set string and find all words
+                Reference < XSearchDescriptor > xSrchDesc = xSearchable->createSearchDescriptor();
+                xSrchDesc->setPropertyValue( "SearchWords", makeAny(pDlg->IsOnlyWholeWords()) );
+                xSrchDesc->setPropertyValue( "SearchCaseSensitive", makeAny(pDlg->IsMarchCase()) );
+                xSrchDesc->setPropertyValue( "SearchBackwards", makeAny(pDlg->IsSearchBackwards()) );
+                xSrchDesc->setSearchString( pDlg->GetSearchText() );
+                Reference< XInterface > xSelection;
+                Reference< XTextRange > xCursor = getCursor();
+
+                if ( xCursor.is() )
+                {
+                    if ( pDlg->IsSearchBackwards() )
+                        xCursor = xCursor->getStart();
+                    xSelection = xSearchable->findNext( xCursor, xSrchDesc );
+                }
+                else
+                    xSelection = xSearchable->findFirst( xSrchDesc );
+
+                // then select the found word
+                if ( xSelection.is() )
+                {
+                    Reference < XSelectionSupplier > xSelectionSup( xController, UNO_QUERY );
+                    if ( xSelectionSup.is() )
+                    {
+                        xSelectionSup->select( Any(xSelection) );
+                    }
+                }
+                else if ( pDlg->IsWrapAround() && !bWrapAround )
+                {
+                    Reference < text::XTextViewCursorSupplier > xCrsrSupp( xController, uno::UNO_QUERY );
+                    Reference < text::XTextViewCursor > xTVCrsr = xCrsrSupp->getViewCursor();
+                    if ( xTVCrsr.is() )
+                    {
+                        Reference < text::XTextDocument > xDoc( xController->getModel(), uno::UNO_QUERY );
+                        Reference < text::XText > xText = xDoc->getText();
+                        if ( xText.is() )
+                        {
+                            if ( pDlg->IsSearchBackwards() )
+                                xTVCrsr->gotoRange( xText->getEnd(), false );
+                            else
+                                xTVCrsr->gotoRange( xText->getStart(), false );
+                            FindHdl( nullptr );
+                        }
+                    }
+                }
+                else
+                {
+                    assert(m_xSrchDlg && "no search dialog");
+                    std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xSrchDlg->getDialog(),
+                                                              VclMessageType::Info, VclButtonsType::Ok, SfxResId(STR_INFO_NOSEARCHTEXTFOUND)));
+                    xBox->run();
+                    m_xSrchDlg->SetFocusOnEdit();
+                }
+            }
+        }
+    }
+    catch( Exception& )
+    {
+        OSL_FAIL( "SfxHelpTextWindow_Impl::SelectHdl(): unexpected exception" );
+    }
+}
+
+IMPL_LINK_NOARG(SfxHelpTextWindow_Impl, CloseHdl, LinkParamNone*, void)
+{
+    m_xSrchDlg.reset();
+}
+
+IMPL_LINK_NOARG(SfxHelpTextWindow_Impl, CheckHdl, weld::Button&, void)
+{
+    if ( !xConfiguration.is() )
+        return;
+
+    bool bChecked = xOnStartupCB->get_active();
+    try
+    {
+        ConfigurationHelper::writeRelativeKey(
+            xConfiguration, PATH_OFFICE_FACTORIES + sCurrentFactory, KEY_HELP_ON_OPEN, makeAny( bChecked ) );
+        ConfigurationHelper::flush( xConfiguration );
+    }
+    catch( Exception const & )
+    {
+        TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxHelpTextWindow_Impl::CheckHdl()" );
+    }
+}
+
+void SfxHelpTextWindow_Impl::Resize()
+{
+    Size aSize = GetOutputSizePixel();
+    pTextWin->SetPosSizePixel( Point(0, 0), aSize );
+}
+
+bool SfxHelpTextWindow_Impl::PreNotify( NotifyEvent& rNEvt )
+{
+    bool bDone = false;
+    MouseNotifyEvent nType = rNEvt.GetType();
+    if ( MouseNotifyEvent::COMMAND == nType && rNEvt.GetCommandEvent() )
+    {
+        const CommandEvent* pCmdEvt = rNEvt.GetCommandEvent();
+        vcl::Window* pCmdWin = rNEvt.GetWindow();
+
+        if ( pCmdEvt->GetCommand() == CommandEventId::ContextMenu && pCmdWin != this )
+        {
+            Point aPos;
+            if ( pCmdEvt->IsMouseEvent() )
+                aPos = pCmdEvt->GetMousePosPixel();
+            else
+                aPos = Point( pTextWin->GetPosPixel().X() + 20, 20 );
+
+            xMenu->clear();
+
+            if (bIsIndexOn)
+                xMenu->append("index", aIndexOffText, BMP_HELP_TOOLBOX_INDEX_OFF);
+            else
+                xMenu->append("index", aIndexOnText, BMP_HELP_TOOLBOX_INDEX_ON);
+
+            xMenu->append_separator("separator1");
+            xMenu->append("backward", SfxResId(STR_HELP_BUTTON_PREV), BMP_HELP_TOOLBOX_PREV);
+            xMenu->set_sensitive("backward", xHelpWin->HasHistoryPredecessor());
+            xMenu->append("forward", SfxResId(STR_HELP_BUTTON_NEXT), BMP_HELP_TOOLBOX_NEXT);
+            xMenu->set_sensitive("forward", xHelpWin->HasHistorySuccessor());
+            xMenu->append("start", SfxResId(STR_HELP_BUTTON_START), BMP_HELP_TOOLBOX_START);
+            xMenu->append_separator("separator2");
+            xMenu->append("print", SfxResId(STR_HELP_BUTTON_PRINT), BMP_HELP_TOOLBOX_PRINT);
+            xMenu->append("bookmarks", SfxResId(STR_HELP_BUTTON_ADDBOOKMARK), BMP_HELP_TOOLBOX_BOOKMARKS);
+            xMenu->append("searchdialog", SfxResId(STR_HELP_BUTTON_SEARCHDIALOG), BMP_HELP_TOOLBOX_SEARCHDIALOG);
+            xMenu->append_separator("separator3");
+            xMenu->append_check("selectionmode", SfxResId(STR_HELP_MENU_TEXT_SELECTION_MODE));
+            URL aURL;
+            aURL.Complete = ".uno:SelectTextMode";
+            Reference< util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+            xTrans->parseStrict(aURL);
+            Reference < XDispatch > xDisp = xFrame->queryDispatch( aURL, OUString(), 0 );
+            if(xDisp.is())
+            {
+                rtl::Reference<HelpStatusListener_Impl> pStateListener =
+                                        new HelpStatusListener_Impl(xDisp, aURL );
+                FeatureStateEvent rEvent = pStateListener->GetStateEvent();
+                bool bCheck = false;
+                rEvent.State >>= bCheck;
+                xMenu->set_active("selectionmode", bCheck);
+            }
+            xMenu->append_separator("separator4");
+            xMenu->append("copy", SfxResId(STR_HELP_MENU_TEXT_COPY), BMP_HELP_TOOLBOX_COPY);
+            xMenu->set_sensitive("copy", HasSelection());
+
+            if ( bIsDebug )
+            {
+                xMenu->append_separator("separator5");
+                xMenu->append("sourceview", SfxResId(STR_HELP_BUTTON_SOURCEVIEW));
+            }
+
+            int x, y, width, height;
+            weld::Window* pTopLevel = GetFrameWeld();
+            xHelpWin->GetContainer()->get_extents_relative_to(*pTopLevel, x, y, width, height);
+            aPos.AdjustX(x);
+            aPos.AdjustY(y);
+
+            xHelpWin->DoAction(xMenu->popup_at_rect(pTopLevel, tools::Rectangle(aPos, Size(1,1))));
+            bDone = true;
+        }
+    }
+    else if ( MouseNotifyEvent::KEYINPUT == nType && rNEvt.GetKeyEvent() )
+    {
+        const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
+        const vcl::KeyCode& rKeyCode = pKEvt->GetKeyCode();
+        sal_uInt16 nKeyGroup = rKeyCode.GetGroup();
+        sal_uInt16 nKey = rKeyCode.GetCode();
+        if ( KEYGROUP_ALPHA == nKeyGroup &&  !isHandledKey( rKeyCode ) )
+        {
+            // do nothing disables the writer accelerators
+            bDone = true;
+         }
+        else if ( rKeyCode.IsMod1() && ( KEY_F4 == nKey || KEY_W == nKey ) )
+        {
+            // <CTRL><F4> or <CTRL><W> -> close top frame
+            xHelpWin->CloseWindow();
+            bDone = true;
+        }
+        else if ( KEY_TAB == nKey && xOnStartupCB->has_focus() )
+        {
+            xToolBox->grab_focus();
+            bDone = true;
+        }
+    }
+
+    return bDone || Window::PreNotify( rNEvt );
+}
+
+
+void SfxHelpTextWindow_Impl::GetFocus()
+{
+    if ( bIsInClose )
+        return;
+
+    try
+    {
+        if( xFrame.is() )
+        {
+            Reference< css::awt::XWindow > xWindow = xFrame->getComponentWindow();
+            if( xWindow.is() )
+                xWindow->setFocus();
+        }
+    }
+    catch( Exception const & )
+    {
+        TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxHelpTextWindow_Impl::GetFocus()" );
+    }
+}
+
+
+void SfxHelpTextWindow_Impl::DataChanged( const DataChangedEvent& rDCEvt )
+{
+    Window::DataChanged( rDCEvt );
+
+    if ( ( ( rDCEvt.GetType() == DataChangedEventType::SETTINGS ) ||
+           ( rDCEvt.GetType() == DataChangedEventType::DISPLAY ) ) &&
+         ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE ) )
+    {
+        SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFaceColor() ) );
+        InitToolBoxImages();
+    }
+}
+
+void SfxHelpTextWindow_Impl::ToggleIndex( bool bOn )
+{
+    bIsIndexOn = bOn;
+    if ( bIsIndexOn )
+    {
+        xToolBox->set_item_icon_name("index", aIndexOffImage);
+        xToolBox->set_item_tooltip_text("index", aIndexOffText);
+    }
+    else
+    {
+        xToolBox->set_item_icon_name("index", aIndexOnImage);
+        xToolBox->set_item_tooltip_text("index", aIndexOnText);
+    }
+}
+
+void SfxHelpTextWindow_Impl::SelectSearchText( const OUString& rSearchText, bool _bIsFullWordSearch )
+{
+    aSearchText = rSearchText;
+    bIsFullWordSearch = _bIsFullWordSearch;
+    aSelectIdle.Start();
+}
+
+
+void SfxHelpTextWindow_Impl::SetPageStyleHeaderOff() const
+{
+    bool bSetOff = false;
+    // set off the pagestyle header to prevent print output of the help URL
+    try
+    {
+        Reference < XController > xController = xFrame->getController();
+        Reference < XSelectionSupplier > xSelSup( xController, UNO_QUERY );
+        if ( xSelSup.is() )
+        {
+            Reference < XIndexAccess > xSelection;
+            if ( xSelSup->getSelection() >>= xSelection )
+            {
+                Reference < XTextRange > xRange;
+                if ( xSelection->getByIndex(0) >>= xRange )
+                {
+                    Reference < XText > xText = xRange->getText();
+                    Reference < XPropertySet > xProps( xText->createTextCursorByRange( xRange ), UNO_QUERY );
+                    OUString sStyleName;
+                    if ( xProps->getPropertyValue( "PageStyleName" ) >>= sStyleName )
+                    {
+                        Reference < XStyleFamiliesSupplier > xStyles( xController->getModel(), UNO_QUERY );
+                        Reference < XNameContainer > xContainer;
+                        if ( xStyles->getStyleFamilies()->getByName( "PageStyles" )
+                             >>= xContainer )
+                        {
+                            Reference < XStyle > xStyle;
+                            if ( xContainer->getByName( sStyleName ) >>= xStyle )
+                            {
+                                Reference < XPropertySet > xPropSet( xStyle, UNO_QUERY );
+                                xPropSet->setPropertyValue( "HeaderIsOn",  makeAny( false ) );
+
+                                Reference< XModifiable > xReset(xStyles, UNO_QUERY);
+                                xReset->setModified(false);
+                                bSetOff = true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch( Exception const & )
+    {
+        TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxHelpTextWindow_Impl::SetPageStyleHeaderOff()" );
+    }
+
+    SAL_WARN_IF( !bSetOff, "sfx.appl", "SfxHelpTextWindow_Impl::SetPageStyleHeaderOff(): set off failed" );
+}
+
+
+void SfxHelpTextWindow_Impl::CloseFrame()
+{
+    bIsInClose = true;
+    try
+    {
+        css::uno::Reference< css::util::XCloseable > xCloseable  ( xFrame, css::uno::UNO_QUERY );
+        if (xCloseable.is())
+            xCloseable->close(true);
+    }
+    catch( css::util::CloseVetoException& )
+    {
+    }
+}
+
+
+void SfxHelpTextWindow_Impl::DoSearch()
+{
+    if (m_xSrchDlg)
+        return;
+
+    // create the search dialog
+    m_xSrchDlg = std::make_shared<sfx2::SearchDialog>(pTextWin->GetFrameWeld(), "HelpSearchDialog");
+    // set handler
+    m_xSrchDlg->SetFindHdl( LINK( this, SfxHelpTextWindow_Impl, FindHdl ) );
+    m_xSrchDlg->SetCloseHdl( LINK( this, SfxHelpTextWindow_Impl, CloseHdl ) );
+    // get selected text of the help page to set it as the search text
+    Reference< XTextRange > xCursor = getCursor();
+    if ( xCursor.is() )
+    {
+        OUString sText = xCursor->getString();
+        if ( !sText.isEmpty() )
+            m_xSrchDlg->SetSearchText( sText );
+    }
+    sfx2::SearchDialog::runAsync(m_xSrchDlg);
+}
+
+void SfxHelpWindow_Impl::GetFocus()
+{
+    if (pTextWin)
+        pTextWin->GrabFocus();
+    else
+        DockingWindow::GetFocus();
+}
+
+void SfxHelpWindow_Impl::MakeLayout()
+{
+    Split();
+
+    m_xHelpPaneWindow->set_visible(bIndex);
+}
+
+IMPL_LINK(SfxHelpWindow_Impl, ResizeHdl, const Size&, rSize, void)
+{
+    int nNewWidth = rSize.Width();
+    if (!nNewWidth)
+        return;
+    if (bSplit)
+        nIndexSize = round(m_xContainer->get_position() * 100.0 / nNewWidth);
+    nWidth = nNewWidth;
+    Split();
+    nIndexSize = round(m_xContainer->get_position() * 100.0 / nWidth);
+}
+
+void SfxHelpWindow_Impl::Split()
+{
+    if (!nWidth)
+        return;
+    m_xContainer->set_position(nWidth * nIndexSize / 100);
+    bSplit = true;
+}
+
+void SfxHelpWindow_Impl::LoadConfig()
+{
+    SvtViewOptions aViewOpt( EViewType::Window, CONFIGNAME_HELPWIN );
+    if ( !aViewOpt.Exists() )
+        return;
+    bIndex = aViewOpt.IsVisible();
+
+    Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME );
+    OUString aUserData;
+    if ( aUserItem >>= aUserData )
+    {
+        DBG_ASSERT( comphelper::string::getTokenCount(aUserData, ';') == 6, "invalid user data" );
+        sal_Int32 nIdx = 0;
+        nIndexSize = aUserData.getToken( 0, ';', nIdx ).toInt32();
+        aUserData.getToken(0, ';', nIdx); // ignore nTextSize
+        sal_Int32 nOldWidth = aUserData.getToken( 0, ';', nIdx ).toInt32();
+        sal_Int32 nOldHeight = aUserData.getToken( 0, ';', nIdx ).toInt32();
+        aWinSize = Size(nOldWidth, nOldHeight);
+        aWinPos.setX( aUserData.getToken( 0, ';', nIdx ).toInt32() );
+        aWinPos.setY( aUserData.getToken( 0, ';', nIdx ).toInt32() );
+    }
+
+    pTextWin->ToggleIndex( bIndex );
+}
+
+void SfxHelpWindow_Impl::SaveConfig()
+{
+    SvtViewOptions aViewOpt( EViewType::Window, CONFIGNAME_HELPWIN );
+    sal_Int32 nW = 0, nH = 0;
+
+    if ( xWindow.is() )
+    {
+        css::awt::Rectangle aRect = xWindow->getPosSize();
+        nW = aRect.Width;
+        nH = aRect.Height;
+    }
+
+    aViewOpt.SetVisible( bIndex );
+    VclPtr<vcl::Window> pScreenWin = VCLUnoHelper::GetWindow( xWindow );
+    aWinPos = pScreenWin->GetWindowExtentsRelative( nullptr ).TopLeft();
+    if (bSplit)
+        nIndexSize = round(m_xContainer->get_position() * 100.0 / nWidth);
+    const OUString aUserData = OUString::number( nIndexSize )
+        + ";" + OUString::number( 100 - nIndexSize )
+        + ";" + OUString::number( nW )
+        + ";" + OUString::number( nH )
+        + ";" + OUString::number( aWinPos.X() )
+        + ";" + OUString::number( aWinPos.Y() );
+
+    aViewOpt.SetUserItem( USERITEM_NAME, makeAny( aUserData ) );
+}
+
+void SfxHelpWindow_Impl::ShowStartPage()
+{
+    loadHelpContent(SfxHelpWindow_Impl::buildHelpURL(xIndexWin->GetFactory(), "/start", OUString()));
+}
+
+IMPL_LINK(SfxHelpWindow_Impl, SelectHdl, const OString&, rCurItem, void)
+{
+    bGrabFocusToToolBox = pTextWin->GetToolBox().has_focus();
+    DoAction(rCurItem);
+}
+
+IMPL_LINK_NOARG(SfxHelpWindow_Impl, OpenHdl, LinkParamNone*, void)
+{
+    xIndexWin->SelectExecutableEntry();
+    OUString aEntry = xIndexWin->GetSelectedEntry();
+
+    if ( aEntry.isEmpty() )
+        return;
+
+    OUString sHelpURL;
+
+    bool bComplete = aEntry.toAsciiLowerCase().match("vnd.sun.star.help");
+
+    if (bComplete)
+        sHelpURL = aEntry;
+    else
+    {
+        OUString aId;
+        OUString aAnchor('#');
+        if ( comphelper::string::getTokenCount(aEntry, '#') == 2 )
+        {
+            sal_Int32 nIdx{ 0 };
+            aId = aEntry.getToken( 0, '#', nIdx );
+            aAnchor += aEntry.getToken( 0, '#', nIdx );
+        }
+        else
+            aId = aEntry;
+
+        sHelpURL = SfxHelpWindow_Impl::buildHelpURL(xIndexWin->GetFactory(), "/" + aId, aAnchor);
+    }
+
+    loadHelpContent(sHelpURL);
+}
+
+IMPL_LINK( SfxHelpWindow_Impl, SelectFactoryHdl, SfxHelpIndexWindow_Impl* , pWin, void )
+{
+    if ( sTitle.isEmpty() )
+        sTitle = GetParent()->GetText();
+
+    Reference< XTitle > xTitle(xFrame, UNO_QUERY);
+    if (xTitle.is ())
+        xTitle->setTitle(sTitle + " - " + xIndexWin->GetActiveFactoryTitle());
+
+    if ( pWin )
+        ShowStartPage();
+    xIndexWin->ClearSearchPage();
+}
+
+
+IMPL_LINK( SfxHelpWindow_Impl, ChangeHdl, HelpListener_Impl&, rListener, void )
+{
+    SetFactory( rListener.GetFactory() );
+}
+
+
+void SfxHelpWindow_Impl::openDone(const OUString& sURL    ,
+                                        bool         bSuccess)
+{
+    INetURLObject aObj( sURL );
+    if ( aObj.GetProtocol() == INetProtocol::VndSunStarHelp )
+        SetFactory( aObj.GetHost() );
+    if ( IsWait() )
+        LeaveWait();
+    if ( bGrabFocusToToolBox )
+    {
+        pTextWin->GetToolBox().grab_focus();
+        bGrabFocusToToolBox = false;
+    }
+    else
+        xIndexWin->GrabFocusBack();
+    if ( !bSuccess )
+        return;
+
+    // set some view settings: "prevent help tips" and "helpid == 68245"
+    try
+    {
+        Reference < XController > xController = pTextWin->getFrame()->getController();
+        if ( xController.is() )
+        {
+            Reference < XViewSettingsSupplier > xSettings( xController, UNO_QUERY );
+            Reference < XPropertySet > xViewProps = xSettings->getViewSettings();
+            Reference< XPropertySetInfo > xInfo = xViewProps->getPropertySetInfo();
+            xViewProps->setPropertyValue( "ShowContentTips", makeAny( false ) );
+            xViewProps->setPropertyValue( "ShowGraphics", makeAny( true ) );
+            xViewProps->setPropertyValue( "ShowTables", makeAny( true ) );
+            xViewProps->setPropertyValue( "HelpURL", makeAny( OUString("HID:SFX2_HID_HELP_ONHELP") ) );
+            OUString sProperty( "IsExecuteHyperlinks" );
+            if ( xInfo->hasPropertyByName( sProperty ) )
+                xViewProps->setPropertyValue( sProperty, makeAny( true ) );
+            xController->restoreViewData(Any());
+        }
+    }
+    catch( Exception& )
+    {
+        OSL_FAIL( "SfxHelpWindow_Impl::OpenDoneHdl(): unexpected exception" );
+    }
+
+    // When the SearchPage opens the help doc, then select all words, which are equal to its text
+    OUString sSearchText = comphelper::string::strip(xIndexWin->GetSearchText(), ' ');
+    if ( !sSearchText.isEmpty() )
+        pTextWin->SelectSearchText( sSearchText, xIndexWin->IsFullWordSearch() );
+
+    // no page style header -> this prevents a print output of the URL
+    pTextWin->SetPageStyleHeaderOff();
+}
+
+
+SfxHelpWindow_Impl::SfxHelpWindow_Impl(
+    const css::uno::Reference < css::frame::XFrame2 >& rFrame,
+    vcl::Window* pParent ) :
+
+    DockingWindow(pParent, "DockingWindow", "sfx/ui/dockingwindow.ui"),
+
+    xFrame              ( rFrame ),
+    pTextWin            ( nullptr ),
+    pHelpInterceptor    ( new HelpInterceptor_Impl() ),
+    pHelpListener       ( new HelpListener_Impl( pHelpInterceptor ) ),
+    bIndex              ( true ),
+    bGrabFocusToToolBox ( false ),
+    bSplit              ( false ),
+    nWidth              ( 0 ),
+    nIndexSize          ( 40 ), // % of width
+    aWinPos             ( 0, 0 ),
+    aWinSize            ( 0, 0 ),
+    sTitle              ( pParent->GetText() )
+{
+    SetStyle(GetStyle() & ~WB_DOCKABLE);
+
+    SetHelpId( HID_HELP_WINDOW );
+
+    m_xVclContentArea = VclPtr<VclVBox>::Create(this);
+    m_xVclContentArea->Show();
+    m_xBuilder.reset(Application::CreateInterimBuilder(m_xVclContentArea, "sfx/ui/helpwindow.ui"));
+    m_xContainer = m_xBuilder->weld_paned("HelpWindow");
+    m_xContainer->connect_size_allocate(LINK(this, SfxHelpWindow_Impl, ResizeHdl));
+    m_xHelpPaneWindow = m_xBuilder->weld_container("helppanewindow");
+    m_xHelpTextWindow = m_xBuilder->weld_container("helptextwindow");
+    m_xHelpTextWindow->set_size_request(m_xHelpTextWindow->get_approximate_digit_width() * 120, -1);
+    m_xHelpTextXWindow = m_xHelpTextWindow->CreateChildFrame();
+
+    pHelpInterceptor->InitWaiter( this );
+    xIndexWin.reset(new SfxHelpIndexWindow_Impl(this, m_xHelpPaneWindow.get()));
+    xIndexWin->SetDoubleClickHdl( LINK( this, SfxHelpWindow_Impl, OpenHdl ) );
+    xIndexWin->SetSelectFactoryHdl( LINK( this, SfxHelpWindow_Impl, SelectFactoryHdl ) );
+
+    pTextWin = VclPtr<SfxHelpTextWindow_Impl>::Create(this, *m_xBuilder, VCLUnoHelper::GetWindow(m_xHelpTextXWindow));
+    Reference < XFrames > xFrames = rFrame->getFrames();
+    xFrames->append( Reference<XFrame>(pTextWin->getFrame(), UNO_QUERY_THROW) );
+    pTextWin->SetSelectHdl( LINK( this, SfxHelpWindow_Impl, SelectHdl ) );
+    pTextWin->Show();
+    pHelpInterceptor->setInterception( Reference<XFrame>(pTextWin->getFrame(), UNO_QUERY_THROW) );
+    pHelpListener->SetChangeHdl( LINK( this, SfxHelpWindow_Impl, ChangeHdl ) );
+    LoadConfig();
+}
+
+SfxHelpWindow_Impl::~SfxHelpWindow_Impl()
+{
+    disposeOnce();
+}
+
+void SfxHelpWindow_Impl::dispose()
+{
+    SaveConfig();
+    xIndexWin.reset();
+    pTextWin->CloseFrame();
+    pTextWin.disposeAndClear();
+
+    m_xHelpTextXWindow->dispose();
+    m_xHelpTextXWindow.clear();
+    m_xHelpTextWindow.reset();
+    m_xHelpPaneWindow.reset();
+    m_xContainer.reset();
+    m_xBuilder.reset();
+    m_xVclContentArea.disposeAndClear();
+
+    DockingWindow::dispose();
+}
+
+bool SfxHelpWindow_Impl::PreNotify( NotifyEvent& rNEvt )
+{
+    bool bHandled = false;
+    if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
+    {
+        // Backward == <ALT><LEFT> or <BACKSPACE> Forward == <ALT><RIGHT>
+        const vcl::KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode();
+        sal_uInt16 nKey = rKeyCode.GetCode();
+        if ( ( rKeyCode.IsMod2() && ( KEY_LEFT == nKey || KEY_RIGHT == nKey ) ) ||
+             ( !rKeyCode.GetModifier() && KEY_BACKSPACE == nKey && !xIndexWin->HasFocusOnEdit() ) )
+        {
+            DoAction( rKeyCode.GetCode() == KEY_RIGHT ? "forward" : "backward" );
+            bHandled = true;
+        }
+        else if ( rKeyCode.IsMod1() && ( KEY_F4 == nKey || KEY_W == nKey ) )
+        {
+            // <CTRL><F4> or <CTRL><W> -> close top frame
+            CloseWindow();
+            bHandled = true;
+        }
+    }
+    return bHandled || Window::PreNotify( rNEvt );
+}
+
+void SfxHelpWindow_Impl::setContainerWindow( const Reference < css::awt::XWindow >& xWin )
+{
+    xWindow = xWin;
+    MakeLayout();
+    if (xWindow.is())
+    {
+        VclPtr<vcl::Window> pScreenWin = VCLUnoHelper::GetWindow(xWindow);
+        if (aWinSize.Width() && aWinSize.Height())
+            pScreenWin->SetPosSizePixel(aWinPos, aWinSize);
+        else
+            pScreenWin->SetPosPixel(aWinPos);
+    }
+}
+
+void SfxHelpWindow_Impl::SetFactory( const OUString& rFactory )
+{
+    xIndexWin->SetFactory( rFactory, true );
+}
+
+void SfxHelpWindow_Impl::SetHelpURL( const OUString& rURL )
+{
+    INetURLObject aObj( rURL );
+    if ( aObj.GetProtocol() == INetProtocol::VndSunStarHelp )
+        SetFactory( aObj.GetHost() );
+}
+
+void SfxHelpWindow_Impl::DoAction(const OString& rActionId)
+{
+    if (rActionId == "index")
+    {
+        bIndex = !bIndex;
+        MakeLayout();
+        pTextWin->ToggleIndex( bIndex );
+    }
+    else if (rActionId == "start")
+    {
+        ShowStartPage();
+    }
+    else if (rActionId == "backward" || rActionId == "forward")
+    {
+        URL aURL;
+        aURL.Complete = ".uno:Backward";
+        if (rActionId == "forward")
+            aURL.Complete = ".uno:Forward";
+        Reference< util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+        xTrans->parseStrict(aURL);
+        pHelpInterceptor->dispatch( aURL, Sequence < PropertyValue >() );
+    }
+    else if (rActionId == "searchdialog")
+    {
+        pTextWin->DoSearch();
+    }
+    else if (rActionId == "print" || rActionId == "sourceview" || rActionId == "copy" || rActionId == "selectionmode")
+    {
+        Reference < XDispatchProvider > xProv = pTextWin->getFrame();
+        if ( xProv.is() )
+        {
+            URL aURL;
+            if (rActionId == "print")
+                aURL.Complete = ".uno:Print";
+            else if (rActionId == "sourceview")
+                aURL.Complete = ".uno:SourceView";
+            else if (rActionId == "copy")
+                aURL.Complete = ".uno:Copy";
+            else // rActionId == "selectionmode"
+                aURL.Complete = ".uno:SelectTextMode";
+            Reference< util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+            xTrans->parseStrict(aURL);
+            Reference < XDispatch > xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
+            if ( xDisp.is() )
+                xDisp->dispatch( aURL, Sequence < PropertyValue >() );
+        }
+    }
+    else if (rActionId == "bookmarks")
+    {
+        OUString aURL = pHelpInterceptor->GetCurrentURL();
+        if ( !aURL.isEmpty() )
+        {
+            try
+            {
+                Content aCnt( aURL, Reference< css::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
+                css::uno::Reference< css::beans::XPropertySetInfo > xInfo = aCnt.getProperties();
+                if ( xInfo->hasPropertyByName( PROPERTY_TITLE ) )
+                {
+                    css::uno::Any aAny = aCnt.getPropertyValue( PROPERTY_TITLE );
+                    OUString aValue;
+                    if ( aAny >>= aValue )
+                    {
+                        SfxAddHelpBookmarkDialog_Impl aDlg(GetFrameWeld(), false);
+                        aDlg.SetTitle(aValue);
+                        if (aDlg.run() == RET_OK )
+                        {
+                            xIndexWin->AddBookmarks( aDlg.GetTitle(), aURL );
+                        }
+                    }
+                }
+            }
+            catch( Exception& )
+            {
+                OSL_FAIL( "SfxHelpWindow_Impl::DoAction(): unexpected exception" );
+            }
+        }
+    }
+}
+
+void SfxHelpWindow_Impl::CloseWindow()
+{
+    try
+    {
+        // search for top frame
+        Reference< XFramesSupplier > xCreator = getTextFrame()->getCreator();
+        while ( xCreator.is() && !xCreator->isTop() )
+        {
+            xCreator = xCreator->getCreator();
+        }
+
+        // when found, close it
+        if ( xCreator.is() && xCreator->isTop() )
+        {
+            Reference < XCloseable > xCloser( xCreator, UNO_QUERY );
+            if ( xCloser.is() )
+                xCloser->close( false );
+        }
+    }
+    catch( Exception const & )
+    {
+        TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxHelpWindow_Impl::CloseWindow()" );
+    }
+}
+
+
+void SfxHelpWindow_Impl::UpdateToolbox()
+{
+    pTextWin->GetToolBox().set_item_sensitive("backward", pHelpInterceptor->HasHistoryPred());
+    pTextWin->GetToolBox().set_item_sensitive("forward", pHelpInterceptor->HasHistorySucc());
+}
+
+
+bool SfxHelpWindow_Impl::HasHistoryPredecessor() const
+{
+    return pHelpInterceptor->HasHistoryPred();
+}
+
+
+bool SfxHelpWindow_Impl::HasHistorySuccessor() const
+{
+    return pHelpInterceptor->HasHistorySucc();
+}
+
+// class SfxAddHelpBookmarkDialog_Impl -----------------------------------
+
+SfxAddHelpBookmarkDialog_Impl::SfxAddHelpBookmarkDialog_Impl(weld::Widget* pParent, bool bRename)
+    : GenericDialogController(pParent, "sfx/ui/bookmarkdialog.ui", "BookmarkDialog")
+    , m_xTitleED(m_xBuilder->weld_entry("entry"))
+    , m_xAltTitle(m_xBuilder->weld_label("alttitle"))
+{
+    if (bRename)
+        m_xDialog->set_title(m_xAltTitle->get_label());
+}
+
+void SfxAddHelpBookmarkDialog_Impl::SetTitle(const OUString& rTitle)
+{
+    m_xTitleED->set_text(rTitle);
+    m_xTitleED->select_region(0, -1);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/newhelp.hxx b/sfx2/source/appl/newhelp.hxx
new file mode 100644
index 000000000..6a78b8570
--- /dev/null
+++ b/sfx2/source/appl/newhelp.hxx
@@ -0,0 +1,518 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_SFX2_SOURCE_APPL_NEWHELP_HXX
+#define INCLUDED_SFX2_SOURCE_APPL_NEWHELP_HXX
+
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/frame/XFrame2.hpp>
+
+#include <rtl/ustrbuf.hxx>
+#include <vcl/builderpage.hxx>
+#include <vcl/dockwin.hxx>
+#include <vcl/idle.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/window.hxx>
+
+#include <srchdlg.hxx>
+
+// context menu ids
+#define MID_OPEN                                1
+#define MID_RENAME                              2
+#define MID_DELETE                              3
+
+namespace com::sun::star::awt { class XWindow; }
+namespace com::sun::star::i18n { class XBreakIterator; }
+namespace com::sun::star::text { class XTextRange; }
+
+// class HelpTabPage_Impl ------------------------------------------------
+
+class SfxHelpIndexWindow_Impl;
+
+class HelpTabPage_Impl : public BuilderPage
+{
+protected:
+    SfxHelpIndexWindow_Impl*    m_pIdxWin;
+
+public:
+    HelpTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* _pIdxWin,
+        const OString& rID, const OUString& rUIXMLDescription);
+    virtual ~HelpTabPage_Impl() override;
+
+    virtual weld::Widget* GetLastFocusControl() = 0;
+};
+
+// class ContentTabPage_Impl ---------------------------------------------
+
+class ContentTabPage_Impl : public HelpTabPage_Impl
+{
+private:
+    std::unique_ptr<weld::TreeView> m_xContentBox;
+    OUString aOpenBookImage;
+    OUString aClosedBookImage;
+    OUString aDocumentImage;
+
+    Link<LinkParamNone*, void> aDoubleClickHdl;
+
+    DECL_LINK(DoubleClickHdl, weld::TreeView&, bool);
+    DECL_LINK(ExpandingHdl, const weld::TreeIter&, bool);
+    DECL_LINK(CollapsingHdl, const weld::TreeIter&, bool);
+
+    void            ClearChildren(weld::TreeIter* pParent);
+    void            InitRoot();
+public:
+    ContentTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* _pIdxWin);
+    virtual ~ContentTabPage_Impl() override;
+
+    virtual weld::Widget* GetLastFocusControl() override;
+
+    void     SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink);
+    OUString GetSelectedEntry() const;
+    void     SetFocusOnBox() { m_xContentBox->grab_focus(); }
+};
+
+class IndexTabPage_Impl : public HelpTabPage_Impl
+{
+private:
+    std::unique_ptr<weld::Entry> m_xIndexEntry;
+    std::unique_ptr<weld::TreeView> m_xIndexList;
+    std::unique_ptr<weld::Button> m_xOpenBtn;
+
+    Idle                aFactoryIdle;
+    Idle                aAutoCompleteIdle;
+    Timer               aKeywordTimer;
+    Link<IndexTabPage_Impl&,void> aKeywordLink;
+
+    OUString            sFactory;
+    OUString            sKeyword;
+
+    bool                bIsActivated;
+    int                 nRowHeight;
+    int                 nAllHeight;
+
+    void                InitializeIndex();
+    void                ClearIndex();
+
+    Link<LinkParamNone*, void> aDoubleClickHdl;
+
+    DECL_LINK(OpenHdl, weld::Button&, void);
+    DECL_LINK(IdleHdl, Timer*, void);
+    DECL_LINK(AutoCompleteHdl, Timer*, void);
+    DECL_LINK(TimeoutHdl, Timer*, void);
+    DECL_LINK(TreeChangeHdl, weld::TreeView&, void);
+    DECL_LINK(EntryChangeHdl, weld::Entry&, void);
+    DECL_LINK(ActivateHdl, weld::Entry&, bool);
+    DECL_LINK(DoubleClickHdl, weld::TreeView&, bool);
+    DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
+    DECL_LINK(CustomGetSizeHdl, weld::TreeView::get_size_args, Size);
+    DECL_LINK(CustomRenderHdl, weld::TreeView::render_args, void);
+    DECL_LINK(ResizeHdl, const Size&, void);
+
+    int starts_with(const OUString& rStr, int nStartRow, bool bCaseSensitive);
+
+public:
+    IndexTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* pIdxWin);
+    virtual ~IndexTabPage_Impl() override;
+
+    virtual void        Activate() override;
+    virtual weld::Widget* GetLastFocusControl() override;
+
+    void                SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink);
+    void                SetFactory( const OUString& rFactory );
+    const OUString&     GetFactory() const { return sFactory; }
+    OUString            GetSelectedEntry() const;
+    void                SetFocusOnBox() { m_xIndexEntry->grab_focus(); }
+    bool                HasFocusOnEdit() const { return m_xIndexEntry->has_focus(); }
+
+    void                SetKeywordHdl( const Link<IndexTabPage_Impl&,void>& rLink ) { aKeywordLink = rLink; }
+    void                SetKeyword( const OUString& rKeyword );
+    bool                HasKeyword() const;
+    bool                HasKeywordIgnoreCase();
+    void                OpenKeyword();
+
+    void         SelectExecutableEntry();
+};
+
+class SearchTabPage_Impl : public HelpTabPage_Impl
+{
+private:
+    std::unique_ptr<weld::ComboBox> m_xSearchED;
+    std::unique_ptr<weld::Button> m_xSearchBtn;
+    std::unique_ptr<weld::CheckButton> m_xFullWordsCB;
+    std::unique_ptr<weld::CheckButton> m_xScopeCB;
+    std::unique_ptr<weld::TreeView> m_xResultsLB;
+    std::unique_ptr<weld::Button> m_xOpenBtn;
+
+    Link<LinkParamNone*, void> aDoubleClickHdl;
+
+    OUString                       aFactory;
+
+    css::uno::Reference< css::i18n::XBreakIterator >
+                                   xBreakIterator;
+
+    void ClearSearchResults();
+    void RememberSearchText( const OUString& rSearchText );
+    void Search();
+
+    DECL_LINK(ClickHdl, weld::Button&, void);
+    DECL_LINK(OpenHdl, weld::Button&, void);
+    DECL_LINK(ModifyHdl, weld::ComboBox&, void);
+    DECL_LINK(DoubleClickHdl, weld::TreeView&, bool);
+    DECL_LINK(ActivateHdl, weld::ComboBox&, bool);
+
+public:
+    SearchTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* pIdxWin);
+    virtual ~SearchTabPage_Impl() override;
+
+    virtual weld::Widget* GetLastFocusControl() override;
+
+    void         SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink);
+    void         SetFactory( const OUString& rFactory ) { aFactory = rFactory; }
+    OUString     GetSelectedEntry() const;
+    void         ClearPage();
+    void         SetFocusOnBox() { m_xResultsLB->grab_focus(); }
+    bool         HasFocusOnEdit() const { return m_xSearchED->has_focus(); }
+    OUString     GetSearchText() const { return m_xSearchED->get_active_text(); }
+    bool         IsFullWordSearch() const { return m_xFullWordsCB->get_active(); }
+    bool         OpenKeyword( const OUString& rKeyword );
+};
+
+class BookmarksTabPage_Impl : public HelpTabPage_Impl
+{
+private:
+    std::unique_ptr<weld::TreeView> m_xBookmarksBox;
+    std::unique_ptr<weld::Button> m_xBookmarksPB;
+
+    Link<LinkParamNone*, void> aDoubleClickHdl;
+
+    DECL_LINK(OpenHdl, weld::Button&, void);
+    DECL_LINK(DoubleClickHdl, weld::TreeView&, bool);
+    DECL_LINK(CommandHdl, const CommandEvent&, bool);
+    DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
+
+    void DoAction(const OString& rAction);
+
+public:
+    BookmarksTabPage_Impl(weld::Widget* pParent, SfxHelpIndexWindow_Impl* pIdxWin);
+    virtual ~BookmarksTabPage_Impl() override;
+
+    virtual weld::Widget* GetLastFocusControl() override;
+
+    void                SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink);
+    OUString            GetSelectedEntry() const;
+    void                AddBookmarks( const OUString& rTitle, const OUString& rURL );
+    void                SetFocusOnBox() { m_xBookmarksBox->grab_focus(); }
+};
+
+// class SfxHelpIndexWindow_Impl -----------------------------------------
+
+class SfxHelpWindow_Impl;
+
+class SfxHelpIndexWindow_Impl
+{
+private:
+    std::unique_ptr<weld::Builder> m_xBuilder;
+    std::unique_ptr<weld::Container> m_xContainer;
+    std::unique_ptr<weld::ComboBox> m_xActiveLB;
+    std::unique_ptr<weld::Notebook> m_xTabCtrl;
+
+    Idle                aIdle;
+
+    Link<SfxHelpIndexWindow_Impl*,void> aSelectFactoryLink;
+    Link<LinkParamNone*,void>           aPageDoubleClickLink;
+    Link<IndexTabPage_Impl&,void>       aIndexKeywordLink;
+    OUString                            sKeyword;
+
+    VclPtr<SfxHelpWindow_Impl>     pParentWin;
+
+    std::unique_ptr<ContentTabPage_Impl> xCPage;
+    std::unique_ptr<IndexTabPage_Impl> xIPage;
+    std::unique_ptr<SearchTabPage_Impl> xSPage;
+    std::unique_ptr<BookmarksTabPage_Impl> xBPage;
+
+    bool                bIsInitDone;
+
+    void                Initialize();
+    void                SetActiveFactory();
+    HelpTabPage_Impl*   GetPage(const OString&);
+
+    inline ContentTabPage_Impl*     GetContentPage();
+    inline IndexTabPage_Impl*       GetIndexPage();
+    inline SearchTabPage_Impl*      GetSearchPage();
+    inline BookmarksTabPage_Impl*   GetBookmarksPage();
+
+    DECL_LINK(ActivatePageHdl, const OString&, void);
+    DECL_LINK(SelectHdl, weld::ComboBox&, void);
+    DECL_LINK(InitHdl, Timer *, void);
+    DECL_LINK(SelectFactoryHdl, Timer *, void);
+    DECL_LINK(KeywordHdl, IndexTabPage_Impl&, void);
+    DECL_LINK(ContentTabPageDoubleClickHdl, LinkParamNone*, void);
+    DECL_LINK(TabPageDoubleClickHdl, LinkParamNone*, void);
+    DECL_LINK(IndexTabPageDoubleClickHdl, LinkParamNone*, void);
+
+public:
+    explicit SfxHelpIndexWindow_Impl(SfxHelpWindow_Impl* pParent, weld::Container* pContainer);
+    ~SfxHelpIndexWindow_Impl();
+
+    void                SetDoubleClickHdl(const Link<LinkParamNone*, void>& rLink);
+    void                SetSelectFactoryHdl( const Link<SfxHelpIndexWindow_Impl*,void>& rLink ) { aSelectFactoryLink = rLink; }
+    void                SetFactory( const OUString& rFactory, bool bActive );
+    OUString const &    GetFactory() const { return xIPage->GetFactory(); }
+    OUString            GetSelectedEntry() const;
+    void                AddBookmarks( const OUString& rTitle, const OUString& rURL );
+    bool                IsValidFactory( const OUString& _rFactory );
+    OUString            GetActiveFactoryTitle() const { return m_xActiveLB->get_active_text(); }
+    void                ClearSearchPage();
+    void                GrabFocusBack();
+    bool                HasFocusOnEdit() const;
+    OUString            GetSearchText() const;
+    bool                IsFullWordSearch() const;
+    void                OpenKeyword( const OUString& rKeyword );
+    void                SelectExecutableEntry();
+
+    weld::Window*       GetFrameWeld() const;
+};
+
+// inlines ---------------------------------------------------------------
+
+ContentTabPage_Impl* SfxHelpIndexWindow_Impl::GetContentPage()
+{
+    if (!xCPage)
+    {
+        xCPage.reset(new ContentTabPage_Impl(m_xTabCtrl->get_page("contents"), this));
+        xCPage->SetDoubleClickHdl(LINK(this, SfxHelpIndexWindow_Impl, ContentTabPageDoubleClickHdl));
+    }
+    return xCPage.get();
+}
+
+IndexTabPage_Impl* SfxHelpIndexWindow_Impl::GetIndexPage()
+{
+    if (!xIPage)
+    {
+        xIPage.reset(new IndexTabPage_Impl(m_xTabCtrl->get_page("index"), this));
+        xIPage->SetDoubleClickHdl( LINK(this, SfxHelpIndexWindow_Impl, IndexTabPageDoubleClickHdl) );
+        xIPage->SetKeywordHdl( aIndexKeywordLink );
+    }
+    return xIPage.get();
+}
+
+SearchTabPage_Impl* SfxHelpIndexWindow_Impl::GetSearchPage()
+{
+    if (!xSPage)
+    {
+        xSPage.reset(new SearchTabPage_Impl(m_xTabCtrl->get_page("find"), this));
+        xSPage->SetDoubleClickHdl( LINK(this, SfxHelpIndexWindow_Impl, TabPageDoubleClickHdl) );
+    }
+    return xSPage.get();
+}
+
+BookmarksTabPage_Impl* SfxHelpIndexWindow_Impl::GetBookmarksPage()
+{
+    if (!xBPage)
+    {
+        xBPage.reset(new BookmarksTabPage_Impl(m_xTabCtrl->get_page("bookmarks"), this));
+        xBPage->SetDoubleClickHdl( LINK(this, SfxHelpIndexWindow_Impl, TabPageDoubleClickHdl) );
+    }
+    return xBPage.get();
+}
+
+// class TextWin_Impl ----------------------------------------------------
+class TextWin_Impl : public DockingWindow
+{
+public:
+    explicit                TextWin_Impl( vcl::Window* pParent );
+
+    virtual bool            EventNotify( NotifyEvent& rNEvt ) override;
+};
+
+// class SfxHelpTextWindow_Impl ------------------------------------------
+
+class SvtMiscOptions;
+class SfxHelpWindow_Impl;
+
+class SfxHelpTextWindow_Impl : public vcl::Window
+{
+private:
+    std::unique_ptr<weld::Toolbar> xToolBox;
+    std::unique_ptr<weld::CheckButton>  xOnStartupCB;
+    std::unique_ptr<weld::Menu>  xMenu;
+    Idle                    aSelectIdle;
+    OUString                aIndexOnImage;
+    OUString                aIndexOffImage;
+    OUString                aIndexOnText;
+    OUString                aIndexOffText;
+    OUString                aSearchText;
+    OUString                aOnStartupText;
+    OUString                sCurrentFactory;
+
+    VclPtr<SfxHelpWindow_Impl>     xHelpWin;
+    VclPtr<vcl::Window>            pTextWin;
+    std::shared_ptr<sfx2::SearchDialog> m_xSrchDlg;
+    css::uno::Reference < css::frame::XFrame2 >
+                            xFrame;
+    css::uno::Reference< css::i18n::XBreakIterator >
+                            xBreakIterator;
+    css::uno::Reference< css::uno::XInterface >
+                            xConfiguration;
+    bool                    bIsDebug;
+    bool                    bIsIndexOn;
+    bool                    bIsInClose;
+    bool                    bIsFullWordSearch;
+
+    bool                    HasSelection() const;
+    void                    InitToolBoxImages();
+    void                    InitOnStartupBox();
+
+    css::uno::Reference< css::i18n::XBreakIterator > const &
+                            GetBreakIterator();
+    css::uno::Reference< css::text::XTextRange >
+                            getCursor() const;
+    bool                    isHandledKey( const vcl::KeyCode& _rKeyCode );
+
+    DECL_LINK(        SelectHdl, Timer *, void);
+    DECL_LINK(        NotifyHdl, LinkParamNone*, void );
+    DECL_LINK(        FindHdl, sfx2::SearchDialog&, void );
+    DECL_LINK(        CloseHdl, LinkParamNone*, void );
+    DECL_LINK(        CheckHdl, weld::Button&, void );
+    void                    FindHdl(sfx2::SearchDialog*);
+
+public:
+    explicit SfxHelpTextWindow_Impl(SfxHelpWindow_Impl* pHelpWin, weld::Builder& rBuilder, vcl::Window* pParent);
+    virtual ~SfxHelpTextWindow_Impl() override;
+    virtual void dispose() override;
+
+    virtual void            Resize() override;
+    virtual bool            PreNotify( NotifyEvent& rNEvt ) override;
+    virtual void            GetFocus() override;
+    virtual void            DataChanged( const DataChangedEvent& rDCEvt ) override;
+
+    const css::uno::Reference < css::frame::XFrame2 >&
+                            getFrame() const { return xFrame; }
+
+    void                    SetSelectHdl(const Link<const OString&, void>& rLink) { xToolBox->connect_clicked(rLink); }
+    void                    ToggleIndex( bool bOn );
+    void                    SelectSearchText( const OUString& rSearchText, bool _bIsFullWordSearch );
+    void                    SetPageStyleHeaderOff() const;
+    weld::Toolbar&          GetToolBox() { return *xToolBox; }
+    void                    CloseFrame();
+    void                    DoSearch();
+};
+
+// class SfxHelpWindow_Impl ----------------------------------------------
+
+class HelpInterceptor_Impl;
+class HelpListener_Impl;
+class SfxHelpWindow_Impl : public DockingWindow
+{
+private:
+friend class SfxHelpIndexWindow_Impl;
+
+    std::unique_ptr<weld::Builder> m_xBuilder;
+    VclPtr<vcl::Window> m_xVclContentArea;
+    std::unique_ptr<weld::Paned> m_xContainer;
+    std::unique_ptr<weld::Container> m_xHelpPaneWindow;
+    std::unique_ptr<weld::Container> m_xHelpTextWindow;
+    css::uno::Reference<css::awt::XWindow> m_xHelpTextXWindow;
+
+    css::uno::Reference < css::awt::XWindow >
+                                xWindow;
+    css::uno::Reference < css::frame::XFrame2 >
+                                xFrame;
+
+    std::unique_ptr<SfxHelpIndexWindow_Impl> xIndexWin;
+    VclPtr<SfxHelpTextWindow_Impl>     pTextWin;
+    HelpInterceptor_Impl*       pHelpInterceptor;
+    rtl::Reference<HelpListener_Impl> pHelpListener;
+
+    bool                bIndex;
+    bool                bGrabFocusToToolBox;
+    bool                bSplit;
+    int                 nWidth;
+    int                 nIndexSize;
+    Point               aWinPos;
+    Size                aWinSize;
+    OUString            sTitle;
+
+    virtual void        GetFocus() override;
+
+    void                MakeLayout();
+    void                LoadConfig();
+    void                SaveConfig();
+    void                ShowStartPage();
+    void                Split();
+
+    DECL_LINK(SelectHdl, const OString&, void);
+    DECL_LINK(OpenHdl, LinkParamNone*, void);
+    DECL_LINK(SelectFactoryHdl, SfxHelpIndexWindow_Impl*, void);
+    DECL_LINK(ChangeHdl, HelpListener_Impl&, void);
+    DECL_LINK(ResizeHdl, const Size&, void);
+
+public:
+    SfxHelpWindow_Impl( const css::uno::Reference < css::frame::XFrame2 >& rFrame,
+                        vcl::Window* pParent );
+    virtual ~SfxHelpWindow_Impl() override;
+    virtual void dispose() override;
+
+    virtual bool        PreNotify( NotifyEvent& rNEvt ) override;
+
+    void                setContainerWindow( const css::uno::Reference < css::awt::XWindow >& xWin );
+    css::uno::Reference < css::frame::XFrame2 > const &
+                        getTextFrame() const { return pTextWin->getFrame(); }
+
+    void                SetFactory( const OUString& rFactory );
+    void                SetHelpURL( const OUString& rURL );
+    void                DoAction(const OString& rAction);
+    void                CloseWindow();
+
+    weld::Container*    GetContainer() { return m_xHelpTextWindow.get(); }
+
+    void                UpdateToolbox();
+    void                OpenKeyword( const OUString& rKeyword ) { xIndexWin->OpenKeyword( rKeyword ); }
+
+    bool                HasHistoryPredecessor() const;      // forward to interceptor
+    bool                HasHistorySuccessor() const;        // forward to interceptor
+
+    void                openDone(const OUString& sURL    ,
+                                       bool         bSuccess);
+
+    static OUString     buildHelpURL(const OUString& sFactory        ,
+                                     const OUString& sContent        ,
+                                     const OUString& sAnchor);
+
+    void                loadHelpContent(const OUString& sHelpURL                ,
+                                              bool         bAddToHistory = true);
+};
+
+class SfxAddHelpBookmarkDialog_Impl : public weld::GenericDialogController
+{
+private:
+    std::unique_ptr<weld::Entry> m_xTitleED;
+    std::unique_ptr<weld::Label> m_xAltTitle;
+public:
+    SfxAddHelpBookmarkDialog_Impl(weld::Widget* pParent, bool bRename);
+
+    void SetTitle( const OUString& rTitle );
+    OUString GetTitle() const { return m_xTitleED->get_text(); }
+};
+
+/// Appends ?Language=xy&System=abc to the help URL in rURL
+void AppendConfigToken(OUStringBuffer& rURL, bool bQuestionMark);
+
+#endif // INCLUDED_SFX2_SOURCE_APPL_NEWHELP_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/opengrf.cxx b/sfx2/source/appl/opengrf.cxx
new file mode 100644
index 000000000..fd547986d
--- /dev/null
+++ b/sfx2/source/appl/opengrf.cxx
@@ -0,0 +1,282 @@
+/* -*- 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 <tools/debug.hxx>
+#include <tools/urlobj.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
+#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
+#include <o3tl/any.hxx>
+#include <vcl/stdtext.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/opengrf.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+#include <osl/diagnose.h>
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::ui::dialogs;
+using namespace ::com::sun::star::uno;
+using namespace ::cppu;
+
+static const char* SvxOpenGrfErr2ResId( ErrCode err )
+{
+    if (err == ERRCODE_GRFILTER_OPENERROR)
+        return RID_SVXSTR_GRFILTER_OPENERROR;
+    else if (err == ERRCODE_GRFILTER_IOERROR)
+        return RID_SVXSTR_GRFILTER_IOERROR;
+    else if (err == ERRCODE_GRFILTER_VERSIONERROR)
+        return RID_SVXSTR_GRFILTER_VERSIONERROR;
+    else if (err == ERRCODE_GRFILTER_FILTERERROR)
+        return RID_SVXSTR_GRFILTER_FILTERERROR;
+    else
+        return RID_SVXSTR_GRFILTER_FORMATERROR;
+}
+
+struct SvxOpenGrf_Impl
+{
+    SvxOpenGrf_Impl(weld::Window* pPreferredParent,
+                    sal_Int16 nDialogType);
+
+    sfx2::FileDialogHelper                  aFileDlg;
+    OUString sDetectedFilter;
+    uno::Reference < XFilePickerControlAccess > xCtrlAcc;
+};
+
+
+SvxOpenGrf_Impl::SvxOpenGrf_Impl(weld::Window* pPreferredParent,
+                                 sal_Int16 nDialogType)
+    : aFileDlg(nDialogType, FileDialogFlags::Graphic, pPreferredParent)
+{
+    uno::Reference < XFilePicker3 > xFP = aFileDlg.GetFilePicker();
+    xCtrlAcc.set(xFP, UNO_QUERY);
+}
+
+
+SvxOpenGraphicDialog::SvxOpenGraphicDialog(const OUString& rTitle, weld::Window* pPreferredParent)
+    : mpImpl(new SvxOpenGrf_Impl(pPreferredParent, ui::dialogs::TemplateDescription::FILEOPEN_LINK_PREVIEW))
+{
+    mpImpl->aFileDlg.SetTitle(rTitle);
+}
+
+SvxOpenGraphicDialog::SvxOpenGraphicDialog(const OUString& rTitle, weld::Window* pPreferredParent,
+                                           sal_Int16 nDialogType)
+    : mpImpl(new SvxOpenGrf_Impl(pPreferredParent, nDialogType))
+{
+    mpImpl->aFileDlg.SetTitle(rTitle);
+}
+
+SvxOpenGraphicDialog::~SvxOpenGraphicDialog()
+{
+}
+
+ErrCode SvxOpenGraphicDialog::Execute()
+{
+    ErrCode nImpRet;
+    bool    bQuitLoop(false);
+
+    while( !bQuitLoop &&
+           mpImpl->aFileDlg.Execute() == ERRCODE_NONE )
+    {
+        if( !GetPath().isEmpty() )
+        {
+            GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
+            INetURLObject aObj( GetPath() );
+
+            // check whether we can load the graphic
+            OUString  aCurFilter( GetCurrentFilter() );
+            sal_uInt16  nFormatNum = rFilter.GetImportFormatNumber( aCurFilter );
+            sal_uInt16  nRetFormat = 0;
+            sal_uInt16  nFound = USHRT_MAX;
+
+            // non-local?
+            if ( INetProtocol::File != aObj.GetProtocol() )
+            {
+                SfxMedium aMed( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ );
+                aMed.Download();
+                SvStream* pStream = aMed.GetInStream();
+
+                if( pStream )
+                    nImpRet = rFilter.CanImportGraphic( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), *pStream, nFormatNum, &nRetFormat );
+                else
+                    nImpRet = rFilter.CanImportGraphic( aObj, nFormatNum, &nRetFormat );
+
+                if ( ERRCODE_NONE != nImpRet )
+                {
+                    if ( !pStream )
+                        nImpRet = rFilter.CanImportGraphic( aObj, GRFILTER_FORMAT_DONTKNOW, &nRetFormat );
+                    else
+                        nImpRet = rFilter.CanImportGraphic( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), *pStream,
+                                                             GRFILTER_FORMAT_DONTKNOW, &nRetFormat );
+                }
+            }
+            else
+            {
+                nImpRet = rFilter.CanImportGraphic( aObj, nFormatNum, &nRetFormat );
+                if( nImpRet != ERRCODE_NONE )
+                    nImpRet = rFilter.CanImportGraphic( aObj, GRFILTER_FORMAT_DONTKNOW, &nRetFormat );
+            }
+
+            if ( ERRCODE_NONE == nImpRet )
+                nFound = nRetFormat;
+
+            // could not load?
+            if ( nFound == USHRT_MAX )
+            {
+                std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(nullptr,
+                                                           VclMessageType::Warning, VclButtonsType::NONE,
+                                                           SfxResId(SvxOpenGrfErr2ResId(nImpRet))));
+                xWarn->add_button(GetStandardText(StandardButtonType::Retry), RET_RETRY);
+                xWarn->add_button(GetStandardText(StandardButtonType::Cancel), RET_CANCEL);
+                bQuitLoop = xWarn->run() != RET_RETRY;
+            }
+            else
+            {
+                if( rFilter.GetImportFormatCount() )
+                {
+                    // store detected appropriate filter
+                    OUString aFormatName(rFilter.GetImportFormatName(nFound));
+                    SetDetectedFilter(aFormatName);
+                }
+                else
+                {
+                    SetDetectedFilter(mpImpl->aFileDlg.GetCurrentFilter());
+                }
+
+                return nImpRet;
+            }
+        }
+    }
+
+    // cancel
+    return ErrCode(sal_uInt32(-1));
+}
+
+
+void SvxOpenGraphicDialog::SetPath( const OUString& rPath, bool bLinkState )
+{
+    mpImpl->aFileDlg.SetDisplayDirectory(rPath);
+    AsLink(bLinkState);
+}
+
+
+void SvxOpenGraphicDialog::EnableLink( bool state )
+{
+    if( !mpImpl->xCtrlAcc.is() )
+        return;
+
+    try
+    {
+        mpImpl->xCtrlAcc->enableControl( ExtendedFilePickerElementIds::CHECKBOX_LINK, state );
+    }
+    catch(const IllegalArgumentException&)
+    {
+#ifdef DBG_UTIL
+        OSL_FAIL( "Cannot enable \"link\" checkbox" );
+#endif
+    }
+}
+
+
+void SvxOpenGraphicDialog::AsLink(bool bState)
+{
+    if( !mpImpl->xCtrlAcc.is() )
+        return;
+
+    try
+    {
+        mpImpl->xCtrlAcc->setValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0, Any(bState) );
+    }
+    catch(const IllegalArgumentException&)
+    {
+#ifdef DBG_UTIL
+        OSL_FAIL( "Cannot check \"link\" checkbox" );
+#endif
+    }
+}
+
+
+bool SvxOpenGraphicDialog::IsAsLink() const
+{
+    try
+    {
+        if( mpImpl->xCtrlAcc.is() )
+        {
+            Any aVal = mpImpl->xCtrlAcc->getValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0 );
+            DBG_ASSERT(aVal.hasValue(), "Value CBX_INSERT_AS_LINK not found");
+            return aVal.hasValue() && *o3tl::doAccess<bool>(aVal);
+        }
+    }
+    catch(const IllegalArgumentException&)
+    {
+#ifdef DBG_UTIL
+        OSL_FAIL( "Cannot access \"link\" checkbox" );
+#endif
+    }
+
+    return false;
+}
+
+ErrCode SvxOpenGraphicDialog::GetGraphic(Graphic& rGraphic) const
+{
+    return mpImpl->aFileDlg.GetGraphic(rGraphic);
+}
+
+OUString SvxOpenGraphicDialog::GetPath() const
+{
+    return mpImpl->aFileDlg.GetPath();
+}
+
+OUString SvxOpenGraphicDialog::GetCurrentFilter() const
+{
+    return mpImpl->aFileDlg.GetCurrentFilter();
+}
+
+OUString const & SvxOpenGraphicDialog::GetDetectedFilter() const
+{
+    return mpImpl->sDetectedFilter;
+}
+
+void SvxOpenGraphicDialog::SetCurrentFilter(const OUString& rStr)
+{
+    mpImpl->aFileDlg.SetCurrentFilter(rStr);
+}
+
+void SvxOpenGraphicDialog::SetDetectedFilter(const OUString& rStr)
+{
+    mpImpl->sDetectedFilter = rStr;
+}
+
+Reference<ui::dialogs::XFilePickerControlAccess> const & SvxOpenGraphicDialog::GetFilePickerControlAccess() const
+{
+    return mpImpl->xCtrlAcc;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/openuriexternally.cxx b/sfx2/source/appl/openuriexternally.cxx
new file mode 100644
index 000000000..ebff4452a
--- /dev/null
+++ b/sfx2/source/appl/openuriexternally.cxx
@@ -0,0 +1,126 @@
+/* -*- 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/.
+ */
+
+#include <sal/config.h>
+
+#include <com/sun/star/lang/IllegalArgumentException.hpp>
+#include <com/sun/star/system/SystemShellExecute.hpp>
+#include <com/sun/star/system/SystemShellExecuteException.hpp>
+#include <com/sun/star/system/SystemShellExecuteFlags.hpp>
+#include <com/sun/star/uno/Reference.hxx>
+#include <com/sun/star/uno/RuntimeException.hpp>
+#include <comphelper/processfactory.hxx>
+#include <rtl/ustring.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/window.hxx>
+#include <vcl/weld.hxx>
+#include <openuriexternally.hxx>
+#include <comphelper/lok.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+
+#include <sfx2/viewsh.hxx>
+#include <sfx2/strings.hrc>
+
+namespace {
+
+class URITools
+{
+private:
+    Timer aOpenURITimer;
+    OUString msURI;
+    bool mbHandleSystemShellExecuteException;
+    DECL_LINK(onOpenURI, Timer*, void);
+
+public:
+    URITools()
+        : mbHandleSystemShellExecuteException(false)
+    {
+    }
+    void openURI(const OUString& sURI, bool bHandleSystemShellExecuteException);
+};
+
+}
+
+void URITools::openURI(const OUString& sURI, bool bHandleSystemShellExecuteException)
+{
+    if (comphelper::LibreOfficeKit::isActive())
+    {
+        if (SfxViewShell* pViewShell = SfxViewShell::Current())
+        {
+            pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_HYPERLINK_CLICKED,
+                                                   sURI.toUtf8().getStr());
+        }
+        delete this;
+        return;
+    }
+
+    mbHandleSystemShellExecuteException = bHandleSystemShellExecuteException;
+    msURI = sURI;
+
+    // tdf#116305 Workaround: Use timer to bring browsers to the front
+    aOpenURITimer.SetInvokeHandler(LINK(this, URITools, onOpenURI));
+#ifdef _WIN32
+    // 200ms seems to be the best compromise between responsiveness and success rate
+    aOpenURITimer.SetTimeout(200);
+#else
+    aOpenURITimer.SetTimeout(0);
+#endif
+    aOpenURITimer.SetDebugName("sfx2::openUriExternallyTimer");
+    aOpenURITimer.Start();
+}
+
+IMPL_LINK_NOARG(URITools, onOpenURI, Timer*, void)
+{
+    css::uno::Reference< css::system::XSystemShellExecute > exec(
+        css::system::SystemShellExecute::create(comphelper::getProcessComponentContext()));
+    try {
+        exec->execute(
+            msURI, OUString(),
+            css::system::SystemShellExecuteFlags::URIS_ONLY);
+        return;
+    } catch (css::lang::IllegalArgumentException & e) {
+        if (e.ArgumentPosition != 0) {
+            throw css::uno::RuntimeException(
+                "unexpected IllegalArgumentException: " + e.Message);
+        }
+        SolarMutexGuard g;
+        vcl::Window *pWindow = SfxGetpApp()->GetTopWindow();
+        std::unique_ptr<weld::MessageDialog> eb(Application::CreateMessageDialog(pWindow ? pWindow->GetFrameWeld() : nullptr,
+                                                                 VclMessageType::Warning, VclButtonsType::Ok,
+                                                                 SfxResId(STR_NO_ABS_URI_REF)));
+        eb->set_primary_text(eb->get_primary_text().replaceFirst("$(ARG1)", msURI));
+        eb->run();
+    } catch (css::system::SystemShellExecuteException & e) {
+        if (!mbHandleSystemShellExecuteException) {
+            throw;
+        }
+        SolarMutexGuard g;
+        vcl::Window *pWindow = SfxGetpApp()->GetTopWindow();
+        std::unique_ptr<weld::MessageDialog> eb(Application::CreateMessageDialog(pWindow ? pWindow->GetFrameWeld() : nullptr,
+                                                                 VclMessageType::Warning, VclButtonsType::Ok,
+                                                                 SfxResId(STR_NO_WEBBROWSER_FOUND)));
+        eb->set_primary_text(
+            eb->get_primary_text().replaceFirst("$(ARG1)", msURI)
+            .replaceFirst("$(ARG2)", OUString::number(e.PosixError))
+            .replaceFirst("$(ARG3)", e.Message));
+            //TODO: avoid subsequent replaceFirst acting on previous replacement
+        eb->run();
+    }
+    delete this;
+}
+
+void sfx2::openUriExternally(const OUString& sURI, bool bHandleSystemShellExecuteException)
+{
+    URITools* uriTools = new URITools;
+    uriTools->openURI(sURI, bHandleSystemShellExecuteException);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/preventduplicateinteraction.cxx b/sfx2/source/appl/preventduplicateinteraction.cxx
new file mode 100644
index 000000000..a80b05c44
--- /dev/null
+++ b/sfx2/source/appl/preventduplicateinteraction.cxx
@@ -0,0 +1,220 @@
+/* -*- 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 <preventduplicateinteraction.hxx>
+
+#include <comphelper/processfactory.hxx>
+#include <osl/diagnose.h>
+
+#include <com/sun/star/task/InteractionHandler.hpp>
+#include <com/sun/star/task/XInteractionAbort.hpp>
+
+namespace sfx2 {
+
+PreventDuplicateInteraction::PreventDuplicateInteraction(const css::uno::Reference< css::uno::XComponentContext >& rxContext)
+    : ThreadHelpBase2()
+    , m_xContext(rxContext)
+{
+}
+
+PreventDuplicateInteraction::~PreventDuplicateInteraction()
+{
+}
+
+void PreventDuplicateInteraction::setHandler(const css::uno::Reference< css::task::XInteractionHandler >& xHandler)
+{
+    // SAFE ->
+    osl::MutexGuard aLock(m_aLock);
+    m_xWarningDialogsParent.reset();
+    m_xHandler = xHandler;
+    // <- SAFE
+}
+
+void PreventDuplicateInteraction::useDefaultUUIHandler()
+{
+    //if we use the default handler, set the parent to a window belonging to this object so that the dialogs
+    //don't block unrelated windows.
+    m_xWarningDialogsParent.reset(new WarningDialogsParentScope(m_xContext));
+    css::uno::Reference<css::task::XInteractionHandler> xHandler(css::task::InteractionHandler::createWithParent(
+        m_xContext, m_xWarningDialogsParent->GetDialogParent()), css::uno::UNO_QUERY_THROW);
+
+    // SAFE ->
+    osl::MutexGuard aLock(m_aLock);
+    m_xHandler = xHandler;
+    // <- SAFE
+}
+
+css::uno::Any SAL_CALL PreventDuplicateInteraction::queryInterface( const css::uno::Type& aType )
+{
+    if ( aType.equals( cppu::UnoType<XInteractionHandler2>::get() ) )
+    {
+        osl::MutexGuard aLock(m_aLock);
+        css::uno::Reference< css::task::XInteractionHandler2 > xHandler( m_xHandler, css::uno::UNO_QUERY );
+        if ( !xHandler.is() )
+            return css::uno::Any();
+    }
+    return ::cppu::WeakImplHelper<css::lang::XInitialization, css::task::XInteractionHandler2>::queryInterface(aType);
+}
+
+void SAL_CALL PreventDuplicateInteraction::handle(const css::uno::Reference< css::task::XInteractionRequest >& xRequest)
+{
+    css::uno::Any aRequest  = xRequest->getRequest();
+    bool          bHandleIt = true;
+
+    // SAFE ->
+    osl::ClearableMutexGuard aLock(m_aLock);
+
+    auto pIt = std::find_if(m_lInteractionRules.begin(), m_lInteractionRules.end(),
+        [&aRequest](const InteractionInfo& rInfo) { return aRequest.isExtractableTo(rInfo.m_aInteraction); });
+    if (pIt != m_lInteractionRules.end())
+    {
+        InteractionInfo& rInfo = *pIt;
+
+        ++rInfo.m_nCallCount;
+        rInfo.m_xRequest = xRequest;
+        bHandleIt = (rInfo.m_nCallCount <= rInfo.m_nMaxCount);
+    }
+
+    css::uno::Reference< css::task::XInteractionHandler > xHandler = m_xHandler;
+
+    aLock.clear();
+    // <- SAFE
+
+    if ( bHandleIt && xHandler.is() )
+    {
+        xHandler->handle(xRequest);
+    }
+    else
+    {
+        const css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > lContinuations = xRequest->getContinuations();
+        for (const auto& rContinuation : lContinuations)
+        {
+            css::uno::Reference< css::task::XInteractionAbort > xAbort(rContinuation, css::uno::UNO_QUERY);
+            if (xAbort.is())
+            {
+                xAbort->select();
+                break;
+            }
+        }
+    }
+}
+
+sal_Bool SAL_CALL PreventDuplicateInteraction::handleInteractionRequest( const css::uno::Reference< css::task::XInteractionRequest >& xRequest )
+{
+    css::uno::Any aRequest  = xRequest->getRequest();
+    bool      bHandleIt = true;
+
+    // SAFE ->
+    osl::ClearableMutexGuard aLock(m_aLock);
+
+    auto pIt = std::find_if(m_lInteractionRules.begin(), m_lInteractionRules.end(),
+        [&aRequest](const InteractionInfo& rInfo) { return aRequest.isExtractableTo(rInfo.m_aInteraction); });
+    if (pIt != m_lInteractionRules.end())
+    {
+        InteractionInfo& rInfo = *pIt;
+
+        ++rInfo.m_nCallCount;
+        rInfo.m_xRequest = xRequest;
+        bHandleIt = (rInfo.m_nCallCount <= rInfo.m_nMaxCount);
+    }
+
+    css::uno::Reference< css::task::XInteractionHandler2 > xHandler( m_xHandler, css::uno::UNO_QUERY );
+    OSL_ENSURE( xHandler.is() || !m_xHandler.is(),
+        "PreventDuplicateInteraction::handleInteractionRequest: inconsistency!" );
+
+    aLock.clear();
+    // <- SAFE
+
+    if ( bHandleIt && xHandler.is() )
+    {
+        return xHandler->handleInteractionRequest(xRequest);
+    }
+    else
+    {
+        const css::uno::Sequence< css::uno::Reference< css::task::XInteractionContinuation > > lContinuations = xRequest->getContinuations();
+        for (const auto& rContinuation : lContinuations)
+        {
+            css::uno::Reference< css::task::XInteractionAbort > xAbort(rContinuation, css::uno::UNO_QUERY);
+            if (xAbort.is())
+            {
+                xAbort->select();
+                break;
+            }
+        }
+    }
+    return false;
+}
+
+void PreventDuplicateInteraction::addInteractionRule(const PreventDuplicateInteraction::InteractionInfo& aInteractionInfo)
+{
+    // SAFE ->
+    osl::MutexGuard aLock(m_aLock);
+
+    auto pIt = std::find_if(m_lInteractionRules.begin(), m_lInteractionRules.end(),
+        [&aInteractionInfo](const InteractionInfo& rInfo) { return rInfo.m_aInteraction == aInteractionInfo.m_aInteraction; });
+    if (pIt != m_lInteractionRules.end())
+    {
+        InteractionInfo& rInfo = *pIt;
+        rInfo.m_nMaxCount  = aInteractionInfo.m_nMaxCount;
+        rInfo.m_nCallCount = aInteractionInfo.m_nCallCount;
+        return;
+    }
+
+    m_lInteractionRules.push_back(aInteractionInfo);
+    // <- SAFE
+}
+
+bool PreventDuplicateInteraction::getInteractionInfo(const css::uno::Type&                               aInteraction,
+                                                           PreventDuplicateInteraction::InteractionInfo* pReturn     ) const
+{
+    // SAFE ->
+    osl::MutexGuard aLock(m_aLock);
+
+    auto pIt = std::find_if(m_lInteractionRules.begin(), m_lInteractionRules.end(),
+        [&aInteraction](const InteractionInfo& rInfo) { return rInfo.m_aInteraction == aInteraction; });
+    if (pIt != m_lInteractionRules.end())
+    {
+        *pReturn = *pIt;
+        return true;
+    }
+    // <- SAFE
+
+    return false;
+}
+
+void SAL_CALL PreventDuplicateInteraction::initialize(const css::uno::Sequence<css::uno::Any>& rArguments)
+{
+    // If we're re-initialized to set a specific new window as a parent then drop our temporary
+    // dialog parent
+    css::uno::Reference<css::lang::XInitialization> xHandler(m_xHandler, css::uno::UNO_QUERY);
+    if (xHandler.is())
+    {
+        m_xWarningDialogsParent.reset();
+        xHandler->initialize(rArguments);
+    }
+}
+
+IMPL_STATIC_LINK_NOARG(WarningDialogsParent, TerminateDesktop, void*, void)
+{
+    css::frame::Desktop::create(comphelper::getProcessComponentContext())->terminate();
+}
+
+} // namespace sfx2
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/sfxhelp.cxx b/sfx2/source/appl/sfxhelp.cxx
new file mode 100644
index 000000000..3a32e147e
--- /dev/null
+++ b/sfx2/source/appl/sfxhelp.cxx
@@ -0,0 +1,1367 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_folders.h>
+#include <sfx2/sfxhelp.hxx>
+
+#include <string_view>
+#include <algorithm>
+#include <cassert>
+#ifdef MACOSX
+#include <premac.h>
+#include <Foundation/NSString.h>
+#include <CoreFoundation/CFURL.h>
+#include <CoreServices/CoreServices.h>
+#include <postmac.h>
+#endif
+
+#include <sal/log.hxx>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/UnknownModuleException.hpp>
+#include <com/sun/star/frame/XFrame2.hpp>
+#include <comphelper/processfactory.hxx>
+#include <com/sun/star/awt/XWindow.hpp>
+#include <com/sun/star/awt/XTopWindow.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/frame/FrameSearchFlag.hpp>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <com/sun/star/frame/ModuleManager.hpp>
+#include <unotools/configmgr.hxx>
+#include <svtools/helpopt.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <tools/urlobj.hxx>
+#include <ucbhelper/content.hxx>
+#include <unotools/pathoptions.hxx>
+#include <rtl/byteseq.hxx>
+#include <rtl/ustring.hxx>
+#include <o3tl/safeint.hxx>
+#include <officecfg/Office/Common.hxx>
+#include <osl/process.h>
+#include <osl/file.hxx>
+#include <unotools/tempfile.hxx>
+#include <unotools/securityoptions.hxx>
+#include <rtl/uri.hxx>
+#include <vcl/commandinfoprovider.hxx>
+#include <vcl/keycod.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/waitobj.hxx>
+#include <vcl/weld.hxx>
+#include <openuriexternally.hxx>
+
+#include <comphelper/lok.hxx>
+#include <LibreOfficeKit/LibreOfficeKitEnums.h>
+#include <sfx2/viewsh.hxx>
+
+#include "newhelp.hxx"
+#include <sfx2/flatpak.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <helper.hxx>
+#include <sfx2/strings.hrc>
+#include <vcl/svapp.hxx>
+#include <rtl/string.hxx>
+#include <svtools/langtab.hxx>
+#include <tools/diagnose_ex.h>
+
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::lang;
+
+namespace {
+
+class NoHelpErrorBox
+{
+private:
+    std::unique_ptr<weld::MessageDialog> m_xErrBox;
+public:
+    DECL_STATIC_LINK(NoHelpErrorBox, HelpRequestHdl, weld::Widget&, bool);
+public:
+    explicit NoHelpErrorBox(weld::Widget* pParent)
+        : m_xErrBox(Application::CreateMessageDialog(pParent, VclMessageType::Error, VclButtonsType::Ok,
+                                                     SfxResId(RID_STR_HLPFILENOTEXIST)))
+    {
+        // Error message: "No help available"
+        m_xErrBox->connect_help(LINK(nullptr, NoHelpErrorBox, HelpRequestHdl));
+    }
+    void run()
+    {
+        m_xErrBox->run();
+    }
+};
+
+}
+
+IMPL_STATIC_LINK_NOARG(NoHelpErrorBox, HelpRequestHdl, weld::Widget&, bool)
+{
+    // do nothing, because no help available
+    return false;
+}
+
+static OUString const & HelpLocaleString();
+
+namespace {
+
+/// Root path of the help.
+OUString const & getHelpRootURL()
+{
+    static OUString const s_instURL = [&]()
+    {
+        OUString tmp = officecfg::Office::Common::Path::Current::Help::get(comphelper::getProcessComponentContext());
+        if (tmp.isEmpty())
+        {
+            // try to determine path from default
+            tmp = "$(instpath)/" LIBO_SHARE_HELP_FOLDER;
+        }
+
+        // replace anything like $(instpath);
+        SvtPathOptions aOptions;
+        tmp = aOptions.SubstituteVariable(tmp);
+
+        OUString url;
+        if (osl::FileBase::getFileURLFromSystemPath(tmp, url) == osl::FileBase::E_None)
+            tmp = url;
+        return tmp;
+    }();
+    return s_instURL;
+}
+
+bool impl_checkHelpLocalePath(OUString const & rpPath)
+{
+    osl::DirectoryItem directoryItem;
+    bool bOK = false;
+
+    osl::FileStatus fileStatus(osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileURL | osl_FileStatus_Mask_FileName);
+    if (osl::DirectoryItem::get(rpPath, directoryItem) == osl::FileBase::E_None &&
+        directoryItem.getFileStatus(fileStatus) == osl::FileBase::E_None &&
+        fileStatus.isDirectory())
+    {
+        bOK = true;
+    }
+    return bOK;
+}
+
+/// Check for built-in help
+/// Check if help/<lang>/err.html file exist
+bool impl_hasHelpInstalled()
+{
+    if (comphelper::LibreOfficeKit::isActive())
+        return false;
+
+        // detect installed locale
+    static OUString const aLocaleStr = HelpLocaleString();
+
+    OUString helpRootURL = getHelpRootURL() + "/" + aLocaleStr + "/err.html";
+    bool bOK = false;
+    osl::DirectoryItem directoryItem;
+    if(osl::DirectoryItem::get(helpRootURL, directoryItem) == osl::FileBase::E_None){
+        bOK=true;
+    }
+
+    SAL_INFO( "sfx.appl", "Checking old help installed " << bOK);
+    return bOK;
+}
+
+/// Check for html built-in help
+/// Check if help/lang/text folder exist. Only html has it.
+bool impl_hasHTMLHelpInstalled()
+{
+    if (comphelper::LibreOfficeKit::isActive())
+        return false;
+
+    // detect installed locale
+    static OUString const aLocaleStr = HelpLocaleString();
+
+    OUString helpRootURL = getHelpRootURL() + "/" + aLocaleStr + "/text";
+    bool bOK = impl_checkHelpLocalePath( helpRootURL );
+    SAL_INFO( "sfx.appl", "Checking new help (html) installed " << bOK);
+    return bOK;
+}
+
+} // namespace
+
+/// Return the locale we prefer for displaying help
+static OUString const & HelpLocaleString()
+{
+    if (comphelper::LibreOfficeKit::isActive())
+        return comphelper::LibreOfficeKit::getLanguageTag().getBcp47();
+
+    static OUString aLocaleStr;
+    if (!aLocaleStr.isEmpty())
+        return aLocaleStr;
+
+    const OUString aEnglish("en-US");
+    // detect installed locale
+    aLocaleStr = utl::ConfigManager::getUILocale();
+
+    if ( aLocaleStr.isEmpty() )
+    {
+        aLocaleStr = aEnglish;
+        return aLocaleStr;
+    }
+
+    // get fall-back language (country)
+    OUString sLang = aLocaleStr;
+    sal_Int32 nSepPos = sLang.indexOf( '-' );
+    if (nSepPos != -1)
+    {
+        sLang = sLang.copy( 0, nSepPos );
+    }
+    OUString sHelpPath("");
+    sHelpPath = getHelpRootURL() + "/" + utl::ConfigManager::getProductVersion() + "/" + aLocaleStr;
+    if (impl_checkHelpLocalePath(sHelpPath))
+    {
+        return aLocaleStr;
+    }
+    sHelpPath = getHelpRootURL() + "/" + utl::ConfigManager::getProductVersion() + "/" + sLang;
+    if (impl_checkHelpLocalePath(sHelpPath))
+    {
+        aLocaleStr = sLang;
+        return aLocaleStr;
+    }
+    sHelpPath = getHelpRootURL() + "/" + aLocaleStr;
+    if (impl_checkHelpLocalePath(sHelpPath))
+    {
+        return aLocaleStr;
+    }
+    sHelpPath = getHelpRootURL() + "/" + sLang;
+    if (impl_checkHelpLocalePath(sHelpPath))
+    {
+        aLocaleStr = sLang;
+        return aLocaleStr;
+    }
+    sHelpPath = getHelpRootURL() + "/" + utl::ConfigManager::getProductVersion() + "/" + aEnglish;
+    if (impl_checkHelpLocalePath(sHelpPath))
+    {
+        aLocaleStr = aEnglish;
+        return aLocaleStr;
+    }
+    sHelpPath = getHelpRootURL() + "/" + aEnglish;
+    if (impl_checkHelpLocalePath(sHelpPath))
+    {
+        aLocaleStr = aEnglish;
+        return aLocaleStr;
+    }
+    return aLocaleStr;
+}
+
+
+
+void AppendConfigToken( OUStringBuffer& rURL, bool bQuestionMark )
+{
+    OUString aLocaleStr = HelpLocaleString();
+
+    // query part exists?
+    if ( bQuestionMark )
+        // no, so start with '?'
+        rURL.append('?');
+    else
+        // yes, so only append with '&'
+        rURL.append('&');
+
+    // set parameters
+    rURL.append("Language=");
+    rURL.append(aLocaleStr);
+    rURL.append("&System=");
+    rURL.append(SvtHelpOptions().GetSystem());
+    rURL.append("&Version=");
+    rURL.append(utl::ConfigManager::getProductVersion());
+}
+
+static bool GetHelpAnchor_Impl( const OUString& _rURL, OUString& _rAnchor )
+{
+    bool bRet = false;
+    OUString sAnchor;
+
+    try
+    {
+        ::ucbhelper::Content aCnt( INetURLObject( _rURL ).GetMainURL( INetURLObject::DecodeMechanism::NONE ),
+                             Reference< css::ucb::XCommandEnvironment >(),
+                             comphelper::getProcessComponentContext() );
+        if ( aCnt.getPropertyValue("AnchorName") >>= sAnchor )
+        {
+
+            if ( !sAnchor.isEmpty() )
+            {
+                _rAnchor = sAnchor;
+                bRet = true;
+            }
+        }
+        else
+        {
+            SAL_WARN( "sfx.appl", "Property 'AnchorName' is missing" );
+        }
+    }
+    catch (const css::uno::Exception&)
+    {
+    }
+
+    return bRet;
+}
+
+namespace {
+
+class SfxHelp_Impl
+{
+public:
+    static OUString GetHelpText( const OUString& aCommandURL, const OUString& rModule );
+};
+
+}
+
+OUString SfxHelp_Impl::GetHelpText( const OUString& aCommandURL, const OUString& rModule )
+{
+    // create help url
+    OUStringBuffer aHelpURL( SfxHelp::CreateHelpURL( aCommandURL, rModule ) );
+    // added 'active' parameter
+    sal_Int32 nIndex = aHelpURL.lastIndexOf( '#' );
+    if ( nIndex < 0 )
+        nIndex = aHelpURL.getLength();
+    aHelpURL.insert( nIndex, "&Active=true" );
+    // load help string
+    return SfxContentHelper::GetActiveHelpString( aHelpURL.makeStringAndClear() );
+}
+
+SfxHelp::SfxHelp() :
+    bIsDebug( false )
+{
+    // read the environment variable "HELP_DEBUG"
+    // if it's set, you will see debug output on active help
+    OUString sHelpDebug;
+    OUString sEnvVarName( "HELP_DEBUG"  );
+    osl_getEnvironment( sEnvVarName.pData, &sHelpDebug.pData );
+    bIsDebug = !sHelpDebug.isEmpty();
+}
+
+SfxHelp::~SfxHelp()
+{
+}
+
+static OUString getDefaultModule_Impl()
+{
+    OUString sDefaultModule;
+    SvtModuleOptions aModOpt;
+    if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::WRITER ) )
+        sDefaultModule = "swriter";
+    else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::CALC ) )
+        sDefaultModule = "scalc";
+    else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::IMPRESS ) )
+        sDefaultModule = "simpress";
+    else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::DRAW ) )
+        sDefaultModule = "sdraw";
+    else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::MATH ) )
+        sDefaultModule = "smath";
+    else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::CHART ) )
+        sDefaultModule = "schart";
+    else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::BASIC ) )
+        sDefaultModule = "sbasic";
+    else if ( aModOpt.IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) )
+        sDefaultModule = "sdatabase";
+    else
+    {
+        SAL_WARN( "sfx.appl", "getDefaultModule_Impl(): no module installed" );
+    }
+    return sDefaultModule;
+}
+
+static OUString getCurrentModuleIdentifier_Impl()
+{
+    OUString sIdentifier;
+    Reference < XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+    Reference < XModuleManager2 > xModuleManager = ModuleManager::create(xContext);
+    Reference < XDesktop2 > xDesktop = Desktop::create(xContext);
+    Reference < XFrame > xCurrentFrame = xDesktop->getCurrentFrame();
+
+    if ( xCurrentFrame.is() )
+    {
+        try
+        {
+            sIdentifier = xModuleManager->identify( xCurrentFrame );
+        }
+        catch (const css::frame::UnknownModuleException&)
+        {
+            SAL_INFO( "sfx.appl", "SfxHelp::getCurrentModuleIdentifier_Impl(): unknown module (help in help?)" );
+        }
+        catch (const Exception&)
+        {
+            TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxHelp::getCurrentModuleIdentifier_Impl(): exception of XModuleManager::identify()" );
+        }
+    }
+
+    return sIdentifier;
+}
+
+namespace
+{
+    OUString MapModuleIdentifier(const OUString &rFactoryShortName)
+    {
+        OUString aFactoryShortName(rFactoryShortName);
+
+        // Map some module identifiers to their "real" help module string.
+        if ( aFactoryShortName == "chart2" )
+            aFactoryShortName = "schart" ;
+        else if ( aFactoryShortName == "BasicIDE" )
+            aFactoryShortName = "sbasic";
+        else if ( aFactoryShortName == "sweb"
+                || aFactoryShortName == "sglobal"
+                || aFactoryShortName == "swxform" )
+            aFactoryShortName = "swriter" ;
+        else if ( aFactoryShortName == "dbquery"
+                || aFactoryShortName == "dbbrowser"
+                || aFactoryShortName == "dbrelation"
+                || aFactoryShortName == "dbtable"
+                || aFactoryShortName == "dbapp"
+                || aFactoryShortName == "dbreport"
+                || aFactoryShortName == "dbtdata"
+                || aFactoryShortName == "swreport"
+                || aFactoryShortName == "swform" )
+            aFactoryShortName = "sdatabase";
+        else if ( aFactoryShortName == "sbibliography"
+                || aFactoryShortName == "sabpilot"
+                || aFactoryShortName == "scanner"
+                || aFactoryShortName == "spropctrlr"
+                || aFactoryShortName == "StartModule" )
+            aFactoryShortName.clear();
+
+        return aFactoryShortName;
+    }
+}
+
+OUString SfxHelp::GetHelpModuleName_Impl(const OUString& rHelpID)
+{
+    OUString aFactoryShortName;
+
+    //rhbz#1438876 detect preferred module for this help id, e.g. csv dialog
+    //for calc import before any toplevel is created and so context is
+    //otherwise unknown. Cosmetic, same help is shown in any case because its
+    //in the shared section, but title bar would state "Writer" when context is
+    //expected to be "Calc"
+    OUString sRemainder;
+    if (rHelpID.startsWith("modules/", &sRemainder))
+    {
+        sal_Int32 nEndModule = sRemainder.indexOf('/');
+        aFactoryShortName = nEndModule != -1 ? sRemainder.copy(0, nEndModule) : sRemainder;
+    }
+
+    if (aFactoryShortName.isEmpty())
+    {
+        OUString aModuleIdentifier = getCurrentModuleIdentifier_Impl();
+        if (!aModuleIdentifier.isEmpty())
+        {
+            try
+            {
+                Reference < XModuleManager2 > xModuleManager(
+                    ModuleManager::create(::comphelper::getProcessComponentContext()) );
+                Sequence< PropertyValue > lProps;
+                xModuleManager->getByName( aModuleIdentifier ) >>= lProps;
+                auto pProp = std::find_if(lProps.begin(), lProps.end(),
+                    [](const PropertyValue& rProp) { return rProp.Name == "ooSetupFactoryShortName"; });
+                if (pProp != lProps.end())
+                    pProp->Value >>= aFactoryShortName;
+            }
+            catch (const Exception&)
+            {
+                TOOLS_WARN_EXCEPTION( "sfx.appl", "SfxHelp::GetHelpModuleName_Impl()" );
+            }
+        }
+    }
+
+    if (!aFactoryShortName.isEmpty())
+        aFactoryShortName = MapModuleIdentifier(aFactoryShortName);
+    if (aFactoryShortName.isEmpty())
+        aFactoryShortName = getDefaultModule_Impl();
+
+    return aFactoryShortName;
+}
+
+OUString SfxHelp::CreateHelpURL_Impl( const OUString& aCommandURL, const OUString& rModuleName )
+{
+    // build up the help URL
+    OUStringBuffer aHelpURL("vnd.sun.star.help://");
+    bool bHasAnchor = false;
+    OUString aAnchor;
+
+    OUString aModuleName( rModuleName );
+    if (aModuleName.isEmpty())
+        aModuleName = getDefaultModule_Impl();
+
+    aHelpURL.append(aModuleName);
+
+    if ( aCommandURL.isEmpty() )
+        aHelpURL.append("/start");
+    else
+    {
+        aHelpURL.append('/');
+        aHelpURL.append(rtl::Uri::encode(aCommandURL,
+                                              rtl_UriCharClassRelSegment,
+                                              rtl_UriEncodeKeepEscapes,
+                                              RTL_TEXTENCODING_UTF8));
+
+        OUStringBuffer aTempURL = aHelpURL;
+        AppendConfigToken( aTempURL, true );
+        bHasAnchor = GetHelpAnchor_Impl(aTempURL.makeStringAndClear(), aAnchor);
+    }
+
+    AppendConfigToken( aHelpURL, true );
+
+    if ( bHasAnchor )
+    {
+        aHelpURL.append('#');
+        aHelpURL.append(aAnchor);
+    }
+
+    return aHelpURL.makeStringAndClear();
+}
+
+static SfxHelpWindow_Impl* impl_createHelp(Reference< XFrame2 >& rHelpTask   ,
+                                    Reference< XFrame >& rHelpContent)
+{
+    Reference < XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
+
+    // otherwise - create new help task
+    Reference< XFrame2 > xHelpTask(
+        xDesktop->findFrame(  "OFFICE_HELP_TASK", FrameSearchFlag::TASKS | FrameSearchFlag::CREATE),
+        UNO_QUERY);
+    if (!xHelpTask.is())
+        return nullptr;
+
+    // create all internal windows and sub frames ...
+    Reference< css::awt::XWindow >      xParentWindow = xHelpTask->getContainerWindow();
+    VclPtr<vcl::Window>                 pParentWindow = VCLUnoHelper::GetWindow( xParentWindow );
+    VclPtrInstance<SfxHelpWindow_Impl>  pHelpWindow( xHelpTask, pParentWindow );
+    Reference< css::awt::XWindow >      xHelpWindow   = VCLUnoHelper::GetInterface( pHelpWindow );
+
+    Reference< XFrame > xHelpContent;
+    if (xHelpTask->setComponent( xHelpWindow, Reference< XController >() ))
+    {
+        // Customize UI ...
+        xHelpTask->setName("OFFICE_HELP_TASK");
+
+        Reference< XPropertySet > xProps(xHelpTask, UNO_QUERY);
+        if (xProps.is())
+            xProps->setPropertyValue(
+                "Title",
+                makeAny(SfxResId(STR_HELP_WINDOW_TITLE)));
+
+        pHelpWindow->setContainerWindow( xParentWindow );
+        xParentWindow->setVisible(true);
+        xHelpWindow->setVisible(true);
+
+        // This sub frame is created internally (if we called new SfxHelpWindow_Impl() ...)
+        // It should exist :-)
+        xHelpContent = xHelpTask->findFrame("OFFICE_HELP", FrameSearchFlag::CHILDREN);
+    }
+
+    if (!xHelpContent.is())
+    {
+        pHelpWindow.disposeAndClear();
+        return nullptr;
+    }
+
+    xHelpContent->setName("OFFICE_HELP");
+
+    rHelpTask    = xHelpTask;
+    rHelpContent = xHelpContent;
+    return pHelpWindow;
+}
+
+OUString SfxHelp::GetHelpText( const OUString& aCommandURL, const vcl::Window* pWindow )
+{
+    OUString sModuleName = GetHelpModuleName_Impl(aCommandURL);
+    auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(aCommandURL, getCurrentModuleIdentifier_Impl());
+    OUString sRealCommand = vcl::CommandInfoProvider::GetRealCommandForCommand(aProperties);
+    OUString sHelpText = SfxHelp_Impl::GetHelpText( sRealCommand.isEmpty() ? aCommandURL : sRealCommand, sModuleName );
+
+    OString aNewHelpId;
+
+    if (pWindow && sHelpText.isEmpty())
+    {
+        // no help text found -> try with parent help id.
+        vcl::Window* pParent = pWindow->GetParent();
+        while ( pParent )
+        {
+            aNewHelpId = pParent->GetHelpId();
+            sHelpText = SfxHelp_Impl::GetHelpText( OStringToOUString(aNewHelpId, RTL_TEXTENCODING_UTF8), sModuleName );
+            if (!sHelpText.isEmpty())
+                pParent = nullptr;
+            else
+                pParent = pParent->GetParent();
+        }
+
+        if (bIsDebug && sHelpText.isEmpty())
+            aNewHelpId.clear();
+    }
+
+    // add some debug information?
+    if ( bIsDebug )
+    {
+        sHelpText += "\n-------------\n" +
+            sModuleName + ": " + aCommandURL;
+        if ( !aNewHelpId.isEmpty() )
+        {
+            sHelpText += " - " +
+                OStringToOUString(aNewHelpId, RTL_TEXTENCODING_UTF8);
+        }
+    }
+
+    return sHelpText;
+}
+
+OUString SfxHelp::GetHelpText(const OUString& aCommandURL, const weld::Widget* pWidget)
+{
+    OUString sModuleName = GetHelpModuleName_Impl(aCommandURL);
+    auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(aCommandURL, getCurrentModuleIdentifier_Impl());
+    OUString sRealCommand = vcl::CommandInfoProvider::GetRealCommandForCommand(aProperties);
+    OUString sHelpText = SfxHelp_Impl::GetHelpText( sRealCommand.isEmpty() ? aCommandURL : sRealCommand, sModuleName );
+
+    OString aNewHelpId;
+
+    if (pWidget && sHelpText.isEmpty())
+    {
+        // no help text found -> try with parent help id.
+        std::unique_ptr<weld::Widget> xParent(pWidget->weld_parent());
+        while (xParent)
+        {
+            aNewHelpId = xParent->get_help_id();
+            sHelpText = SfxHelp_Impl::GetHelpText( OStringToOUString(aNewHelpId, RTL_TEXTENCODING_UTF8), sModuleName );
+            if (!sHelpText.isEmpty())
+                xParent.reset();
+            else
+                xParent = xParent->weld_parent();
+        }
+
+        if (bIsDebug && sHelpText.isEmpty())
+            aNewHelpId.clear();
+    }
+
+    // add some debug information?
+    if ( bIsDebug )
+    {
+        sHelpText += "\n-------------\n" +
+            sModuleName + ": " + aCommandURL;
+        if ( !aNewHelpId.isEmpty() )
+        {
+            sHelpText += " - " +
+                OStringToOUString(aNewHelpId, RTL_TEXTENCODING_UTF8);
+        }
+    }
+
+    return sHelpText;
+}
+
+OUString SfxHelp::GetURLHelpText(const OUString& aURL)
+{
+    SvtSecurityOptions aSecOpt;
+    bool bCtrlClickHlink = aSecOpt.IsOptionSet(SvtSecurityOptions::EOption::CtrlClickHyperlink);
+
+    // "ctrl-click to follow link:" for not MacOS
+    // "⌘-click to follow link:" for MacOs
+    vcl::KeyCode aCode(KEY_SPACE);
+    vcl::KeyCode aModifiedCode(KEY_SPACE, KEY_MOD1);
+    OUString aModStr(aModifiedCode.GetName());
+    aModStr = aModStr.replaceFirst(aCode.GetName(), "");
+    aModStr = aModStr.replaceAll("+", "");
+    OUString aHelpStr
+        = bCtrlClickHlink ? SfxResId(STR_CTRLCLICKHYPERLINK) : SfxResId(STR_CLICKHYPERLINK);
+    aHelpStr = aHelpStr.replaceFirst("%{key}", aModStr);
+    aHelpStr = aHelpStr.replaceFirst("%{link}", aURL);
+    return aHelpStr;
+}
+
+void SfxHelp::SearchKeyword( const OUString& rKeyword )
+{
+    Start_Impl(OUString(), static_cast<vcl::Window*>(nullptr), rKeyword);
+}
+
+bool SfxHelp::Start( const OUString& rURL, const vcl::Window* pWindow )
+{
+    return Start_Impl( rURL, pWindow, OUString() );
+}
+
+bool SfxHelp::Start(const OUString& rURL, weld::Widget* pWidget)
+{
+    return Start_Impl(rURL, pWidget, OUString());
+}
+
+/// Redirect the vnd.sun.star.help:// urls to http://help.libreoffice.org
+static bool impl_showOnlineHelp( const OUString& rURL )
+{
+    static const OUString aInternal("vnd.sun.star.help://");
+    if ( rURL.getLength() <= aInternal.getLength() || !rURL.startsWith(aInternal) )
+        return false;
+
+    OUString aHelpLink = officecfg::Office::Common::Help::HelpRootURL::get();
+    OUString aTarget = "Target=" + rURL.copy(aInternal.getLength());
+    aTarget = aTarget.replaceAll("%2F", "/").replaceAll("?", "&");
+    aHelpLink += aTarget;
+
+    if (comphelper::LibreOfficeKit::isActive())
+    {
+        if(SfxViewShell* pViewShell = SfxViewShell::Current())
+        {
+            pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_HYPERLINK_CLICKED,
+                                                   aHelpLink.toUtf8().getStr());
+            return true;
+        }
+        return false;
+    }
+
+    try
+    {
+#ifdef MACOSX
+        LSOpenCFURLRef(CFURLCreateWithString(kCFAllocatorDefault,
+                           CFStringCreateWithCString(kCFAllocatorDefault,
+                               aHelpLink.toUtf8().getStr(),
+                               kCFStringEncodingUTF8),
+                           nullptr),
+            nullptr);
+#else
+        sfx2::openUriExternally(aHelpLink, false);
+#endif
+        return true;
+    }
+    catch (const Exception&)
+    {
+    }
+    return false;
+}
+
+namespace {
+
+bool rewriteFlatpakHelpRootUrl(OUString * helpRootUrl) {
+    assert(helpRootUrl != nullptr);
+    //TODO: this function for now assumes that the passed-in *helpRootUrl references
+    // /app/libreoffice/help (which belongs to the org.libreoffice.LibreOffice.Help
+    // extension); it replaces it with the corresponding file URL as seen outside the flatpak
+    // sandbox:
+    struct Failure: public std::exception {};
+    try {
+        static auto const url = [] {
+            // From /.flatpak-info [Instance] section, read
+            //   app-path=<path>
+            //   app-extensions=...;org.libreoffice.LibreOffice.Help=<sha>;...
+            // lines:
+            osl::File ini("file:///.flatpak-info");
+            auto err = ini.open(osl_File_OpenFlag_Read);
+            if (err != osl::FileBase::E_None) {
+                SAL_WARN("sfx.appl", "LIBO_FLATPAK mode failure opening /.flatpak-info: " << err);
+                throw Failure();
+            }
+            OUString path;
+            OUString extensions;
+            bool havePath = false;
+            bool haveExtensions = false;
+            for (bool instance = false; !(havePath && haveExtensions);) {
+                rtl::ByteSequence bytes;
+                err = ini.readLine(bytes);
+                if (err != osl::FileBase::E_None) {
+                    SAL_WARN(
+                        "sfx.appl",
+                        "LIBO_FLATPAK mode reading /.flatpak-info fails with " << err
+                            << " before [Instance] app-path");
+                    throw Failure();
+                }
+                std::string_view const line(
+                    reinterpret_cast<char const *>(bytes.getConstArray()), bytes.getLength());
+                if (instance) {
+                    static constexpr auto keyPath = OUStringLiteral("app-path=");
+                    static constexpr auto keyExtensions = OUStringLiteral("app-extensions=");
+                    if (!havePath && line.length() >= o3tl::make_unsigned(keyPath.size)
+                        && line.substr(0, keyPath.size) == keyPath.data)
+                    {
+                        auto const value = line.substr(keyPath.size);
+                        if (!rtl_convertStringToUString(
+                                &path.pData, value.data(), value.length(),
+                                osl_getThreadTextEncoding(),
+                                (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR
+                                 | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
+                                 | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
+                        {
+                            SAL_WARN(
+                                "sfx.appl",
+                                "LIBO_FLATPAK mode failure converting app-path \"" << value
+                                    << "\" encoding");
+                            throw Failure();
+                        }
+                        havePath = true;
+                    } else if (!haveExtensions && line.length() >= o3tl::make_unsigned(keyExtensions.size)
+                               && line.substr(0, keyExtensions.size) == keyExtensions.data)
+                    {
+                        auto const value = line.substr(keyExtensions.size);
+                        if (!rtl_convertStringToUString(
+                                &extensions.pData, value.data(), value.length(),
+                                osl_getThreadTextEncoding(),
+                                (RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR
+                                 | RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
+                                 | RTL_TEXTTOUNICODE_FLAGS_INVALID_ERROR)))
+                        {
+                            SAL_WARN(
+                                "sfx.appl",
+                                "LIBO_FLATPAK mode failure converting app-extensions \"" << value
+                                    << "\" encoding");
+                            throw Failure();
+                        }
+                        haveExtensions = true;
+                    } else if (line.length() > 0 && line[0] == '[') {
+                        SAL_WARN(
+                            "sfx.appl",
+                            "LIBO_FLATPAK mode /.flatpak-info lacks [Instance] app-path and"
+                                " app-extensions");
+                        throw Failure();
+                    }
+                } else if (line == "[Instance]") {
+                    instance = true;
+                }
+            }
+            ini.close();
+            // Extract <sha> from ...;org.libreoffice.LibreOffice.Help=<sha>;...:
+            OUString sha;
+            for (sal_Int32 i = 0;;) {
+                OUString elem = extensions.getToken(0, ';', i);
+                if (elem.startsWith("org.libreoffice.LibreOffice.Help=", &sha)) {
+                    break;
+                }
+                if (i == -1) {
+                    SAL_WARN(
+                        "sfx.appl",
+                        "LIBO_FLATPAK mode /.flatpak-info [Instance] app-extensions \""
+                            << extensions << "\" org.libreoffice.LibreOffice.Help");
+                    throw Failure();
+                }
+            }
+            // Assuming that <path> is of the form
+            //   /.../app/org.libreoffice.LibreOffice/<arch>/<branch>/<sha'>/files
+            // rewrite it as
+            //   /.../runtime/org.libreoffice.LibreOffice.Help/<arch>/<branch>/<sha>/files
+            // because the extension's files are stored at a different place than the app's files,
+            // so use this hack until flatpak itself provides a better solution:
+            static constexpr auto segments = OUStringLiteral("/app/org.libreoffice.LibreOffice/");
+            auto const i1 = path.lastIndexOf(segments);
+                // use lastIndexOf instead of indexOf, in case the user-controlled prefix /.../
+                // happens to contain such segments
+            if (i1 == -1) {
+                SAL_WARN(
+                    "sfx.appl",
+                    "LIBO_FLATPAK mode /.flatpak-info [Instance] app-path \"" << path
+                        << "\" doesn't contain /app/org.libreoffice.LibreOffice/");
+                throw Failure();
+            }
+            auto const i2 = i1 + segments.size;
+            auto i3 = path.indexOf('/', i2);
+            if (i3 == -1) {
+                SAL_WARN(
+                    "sfx.appl",
+                    "LIBO_FLATPAK mode /.flatpak-info [Instance] app-path \"" << path
+                        << "\" doesn't contain branch segment");
+                throw Failure();
+            }
+            i3 = path.indexOf('/', i3 + 1);
+            if (i3 == -1) {
+                SAL_WARN(
+                    "sfx.appl",
+                    "LIBO_FLATPAK mode /.flatpak-info [Instance] app-path \"" << path
+                        << "\" doesn't contain sha segment");
+                throw Failure();
+            }
+            ++i3;
+            auto const i4 = path.indexOf('/', i3);
+            if (i4 == -1) {
+                SAL_WARN(
+                    "sfx.appl",
+                    "LIBO_FLATPAK mode /.flatpak-info [Instance] app-path \"" << path
+                        << "\" doesn't contain files segment");
+                throw Failure();
+            }
+            path = path.copy(0, i1) + "/runtime/org.libreoffice.LibreOffice.Help/"
+                + path.copy(i2, i3 - i2) + sha + path.copy(i4);
+            // Turn <path> into a file URL:
+            OUString url_;
+            err = osl::FileBase::getFileURLFromSystemPath(path, url_);
+            if (err != osl::FileBase::E_None) {
+                SAL_WARN(
+                    "sfx.appl",
+                    "LIBO_FLATPAK mode failure converting app-path \"" << path << "\" to URL: "
+                        << err);
+                throw Failure();
+            }
+            return url_;
+        }();
+        *helpRootUrl = url;
+        return true;
+    } catch (Failure &) {
+        return false;
+    }
+}
+
+}
+
+#define SHTML1 "<!DOCTYPE HTML><html lang=\"en-US\"><head><meta charset=\"UTF-8\">"
+#define SHTML2 "<meta http-equiv=\"refresh\" content=\"1; url='"
+#define SHTML3 "'\"><script type=\"text/javascript\"> window.location.href = \""
+#define SHTML4 "\";</script><title>Help Page Redirection</title></head><body></body></html>"
+
+// use a tempfile since e.g. xdg-open doesn't support URL-parameters with file:// URLs
+static bool impl_showOfflineHelp( const OUString& rURL )
+{
+    OUString aBaseInstallPath = getHelpRootURL();
+    // For the flatpak case, find the pathname outside the flatpak sandbox that corresponds to
+    // aBaseInstallPath, because that is what needs to be stored in aTempFile below:
+    if (flatpak::isFlatpak() && !rewriteFlatpakHelpRootUrl(&aBaseInstallPath)) {
+        return false;
+    }
+
+    OUString aHelpLink( aBaseInstallPath + "/index.html?" );
+    OUString aTarget = "Target=" + rURL.copy(RTL_CONSTASCII_LENGTH("vnd.sun.star.help://"));
+    aTarget = aTarget.replaceAll("%2F","/").replaceAll("?","&");
+    aHelpLink += aTarget;
+
+    // Get a html tempfile (for the flatpak case, create it in XDG_CACHE_HOME instead of /tmp for
+    // technical reasons, so that it can be accessed by the browser running outside the sandbox):
+    OUString const aExtension(".html");
+    OUString * parent = nullptr;
+    if (flatpak::isFlatpak() && !flatpak::createTemporaryHtmlDirectory(&parent)) {
+        return false;
+    }
+    ::utl::TempFile aTempFile("NewHelp", true, &aExtension, parent, false );
+
+    SvStream* pStream = aTempFile.GetStream(StreamMode::WRITE);
+    pStream->SetStreamCharSet(RTL_TEXTENCODING_UTF8);
+
+    OUString aTempStr = SHTML1 SHTML2 +
+        aHelpLink + SHTML3 +
+        aHelpLink + SHTML4;
+
+    pStream->WriteUnicodeOrByteText(aTempStr);
+
+    aTempFile.CloseStream();
+    try
+    {
+#ifdef MACOSX
+        LSOpenCFURLRef(CFURLCreateWithString(kCFAllocatorDefault,
+                           CFStringCreateWithCString(kCFAllocatorDefault,
+                               aTempFile.GetURL().toUtf8().getStr(),
+                               kCFStringEncodingUTF8),
+                           nullptr),
+            nullptr);
+#else
+        sfx2::openUriExternally(aTempFile.GetURL(), false);
+#endif
+        return true;
+    }
+    catch (const Exception&)
+    {
+    }
+    aTempFile.EnableKillingFile();
+    return false;
+}
+
+namespace
+{
+    // tdf#119579 skip floating windows as potential parent for missing help dialog
+    const vcl::Window* GetBestParent(const vcl::Window* pWindow)
+    {
+        while (pWindow)
+        {
+            if (pWindow->IsSystemWindow() && pWindow->GetType() != WindowType::FLOATINGWINDOW)
+                break;
+            pWindow = pWindow->GetParent();
+        }
+        return pWindow;
+    }
+}
+
+namespace {
+
+class HelpManualMessage : public weld::MessageDialogController
+{
+private:
+    std::unique_ptr<weld::CheckButton> m_xHideOfflineHelpCB;
+
+public:
+    HelpManualMessage(weld::Widget* pParent)
+        : MessageDialogController(pParent, "sfx/ui/helpmanual.ui", "onlinehelpmanual", "hidedialog")
+        , m_xHideOfflineHelpCB(m_xBuilder->weld_check_button("hidedialog"))
+    {
+        LanguageTag aLangTag = Application::GetSettings().GetUILanguageTag();
+        OUString sLocaleString = SvtLanguageTable::GetLanguageString(aLangTag.getLanguageType());
+        OUString sPrimText = get_primary_text();
+        set_primary_text(sPrimText.replaceAll("$UILOCALE", sLocaleString));
+    }
+
+    bool GetOfflineHelpPopUp() const { return !m_xHideOfflineHelpCB->get_active(); }
+};
+
+}
+
+bool SfxHelp::Start_Impl(const OUString& rURL, const vcl::Window* pWindow, const OUString& rKeyword)
+{
+    OUStringBuffer aHelpRootURL("vnd.sun.star.help://");
+    AppendConfigToken(aHelpRootURL, true);
+    SfxContentHelper::GetResultSet(aHelpRootURL.makeStringAndClear());
+
+    /* rURL may be
+     *       - a "real" URL
+     *       - a HelpID (formerly a long, now a string)
+     *      If rURL is a URL, CreateHelpURL should be called for this URL
+     *      If rURL is an arbitrary string, the same should happen, but the URL should be tried out
+     *      if it delivers real help content. In case only the Help Error Document is returned, the
+     *      parent of the window for that help was called, is asked for its HelpID.
+     *      For compatibility reasons this upward search is not implemented for "real" URLs.
+     *      Help keyword search now is implemented as own method; in former versions it
+     *      was done via Help::Start, but this implementation conflicted with the upward search.
+     */
+    OUString aHelpURL;
+    INetURLObject aParser( rURL );
+    INetProtocol nProtocol = aParser.GetProtocol();
+
+    switch ( nProtocol )
+    {
+        case INetProtocol::VndSunStarHelp:
+            // already a vnd.sun.star.help URL -> nothing to do
+            aHelpURL = rURL;
+            break;
+        default:
+        {
+            OUString aHelpModuleName(GetHelpModuleName_Impl(rURL));
+            OUString aRealCommand;
+
+            if ( nProtocol == INetProtocol::Uno )
+            {
+                // Command can be just an alias to another command.
+                auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(rURL, getCurrentModuleIdentifier_Impl());
+                aRealCommand = vcl::CommandInfoProvider::GetRealCommandForCommand(aProperties);
+            }
+
+            // no URL, just a HelpID (maybe empty in case of keyword search)
+            aHelpURL = CreateHelpURL_Impl( aRealCommand.isEmpty() ? rURL : aRealCommand, aHelpModuleName );
+
+            if ( impl_hasHelpInstalled() && pWindow && SfxContentHelper::IsHelpErrorDocument( aHelpURL ) )
+            {
+                // no help found -> try with parent help id.
+                vcl::Window* pParent = pWindow->GetParent();
+                while ( pParent )
+                {
+                    OString aHelpId = pParent->GetHelpId();
+                    aHelpURL = CreateHelpURL( OStringToOUString(aHelpId, RTL_TEXTENCODING_UTF8), aHelpModuleName );
+
+                    if ( !SfxContentHelper::IsHelpErrorDocument( aHelpURL ) )
+                    {
+                        break;
+                    }
+                    else
+                    {
+                        pParent = pParent->GetParent();
+                        if (!pParent)
+                        {
+                            // create help url of start page ( helpid == 0 -> start page)
+                            aHelpURL = CreateHelpURL( OUString(), aHelpModuleName );
+                        }
+                    }
+                }
+            }
+            break;
+        }
+    }
+
+    if ( comphelper::LibreOfficeKit::isActive() )
+    {
+        impl_showOnlineHelp( aHelpURL );
+        return true;
+    }
+#ifdef MACOSX
+    if (@available(macOS 10.14, *)) {
+        // Workaround: Safari sandboxing prevents it from accessing files in the LibreOffice.app folder
+        // force online-help instead if Safari is default browser.
+        CFURLRef pBrowser = LSCopyDefaultApplicationURLForURL(
+                                CFURLCreateWithString(
+                                    kCFAllocatorDefault,
+                                    static_cast<CFStringRef>(@"https://www.libreoffice.org"),
+                                    nullptr),
+                                kLSRolesAll, nullptr);
+        if([static_cast<NSString*>(CFURLGetString(pBrowser)) isEqualToString:@"file:///Applications/Safari.app/"]) {
+            impl_showOnlineHelp( aHelpURL );
+            return true;
+        }
+    }
+#endif
+
+    // If the HTML or no help is installed, but aHelpURL nevertheless references valid help content,
+    // that implies that this help content belongs to an extension (and thus would not be available
+    // in neither the offline nor online HTML help); in that case, fall through to the "old-help to
+    // display" code below:
+    if (SfxContentHelper::IsHelpErrorDocument(aHelpURL))
+    {
+        if ( impl_hasHTMLHelpInstalled() && impl_showOfflineHelp(aHelpURL) )
+        {
+            return true;
+        }
+
+        if ( !impl_hasHelpInstalled() )
+        {
+            SvtHelpOptions aHelpOptions;
+            bool bShowOfflineHelpPopUp = aHelpOptions.IsOfflineHelpPopUp();
+
+            pWindow = GetBestParent(pWindow);
+
+            TopLevelWindowLocker aBusy;
+
+            if(bShowOfflineHelpPopUp)
+            {
+                weld::Window* pWeldWindow = pWindow ? pWindow->GetFrameWeld() : nullptr;
+                aBusy.incBusy(pWeldWindow);
+                HelpManualMessage aQueryBox(pWeldWindow);
+                short OnlineHelpBox = aQueryBox.run();
+                bShowOfflineHelpPopUp = OnlineHelpBox != RET_OK;
+                aHelpOptions.SetOfflineHelpPopUp(aQueryBox.GetOfflineHelpPopUp());
+                aBusy.decBusy();
+            }
+            if(!bShowOfflineHelpPopUp)
+            {
+                if ( impl_showOnlineHelp( aHelpURL ) )
+                    return true;
+                else
+                {
+                    weld::Window* pWeldWindow = pWindow ? pWindow->GetFrameWeld() : nullptr;
+                    aBusy.incBusy(pWeldWindow);
+                    NoHelpErrorBox aErrBox(pWeldWindow);
+                    aErrBox.run();
+                    aBusy.decBusy();
+                    return false;
+                }
+            }
+            else
+            {
+                return false;
+            }
+        }
+    }
+
+    // old-help to display
+    Reference < XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
+
+    // check if help window is still open
+    // If not, create a new one and return access directly to the internal sub frame showing the help content
+    // search must be done here; search one desktop level could return an arbitrary frame
+    Reference< XFrame2 > xHelp(
+        xDesktop->findFrame( "OFFICE_HELP_TASK", FrameSearchFlag::CHILDREN),
+                               UNO_QUERY);
+    Reference< XFrame > xHelpContent = xDesktop->findFrame(
+        "OFFICE_HELP",
+        FrameSearchFlag::CHILDREN);
+
+    SfxHelpWindow_Impl* pHelpWindow = nullptr;
+    if (!xHelp.is())
+        pHelpWindow = impl_createHelp(xHelp, xHelpContent);
+    else
+        pHelpWindow = static_cast<SfxHelpWindow_Impl*>(VCLUnoHelper::GetWindow(xHelp->getComponentWindow()).get());
+    if (!xHelp.is() || !xHelpContent.is() || !pHelpWindow)
+        return false;
+
+    SAL_INFO("sfx.appl", "HelpId = " << aHelpURL);
+
+    pHelpWindow->SetHelpURL( aHelpURL );
+    pHelpWindow->loadHelpContent(aHelpURL);
+    if (!rKeyword.isEmpty())
+        pHelpWindow->OpenKeyword( rKeyword );
+
+    Reference < css::awt::XTopWindow > xTopWindow( xHelp->getContainerWindow(), UNO_QUERY );
+    if ( xTopWindow.is() )
+        xTopWindow->toFront();
+
+    return true;
+}
+
+bool SfxHelp::Start_Impl(const OUString& rURL, weld::Widget* pWidget, const OUString& rKeyword)
+{
+    OUStringBuffer aHelpRootURL("vnd.sun.star.help://");
+    AppendConfigToken(aHelpRootURL, true);
+    SfxContentHelper::GetResultSet(aHelpRootURL.makeStringAndClear());
+
+    /* rURL may be
+     *       - a "real" URL
+     *       - a HelpID (formerly a long, now a string)
+     *      If rURL is a URL, CreateHelpURL should be called for this URL
+     *      If rURL is an arbitrary string, the same should happen, but the URL should be tried out
+     *      if it delivers real help content. In case only the Help Error Document is returned, the
+     *      parent of the window for that help was called, is asked for its HelpID.
+     *      For compatibility reasons this upward search is not implemented for "real" URLs.
+     *      Help keyword search now is implemented as own method; in former versions it
+     *      was done via Help::Start, but this implementation conflicted with the upward search.
+     */
+    OUString aHelpURL;
+    INetURLObject aParser( rURL );
+    INetProtocol nProtocol = aParser.GetProtocol();
+
+    switch ( nProtocol )
+    {
+        case INetProtocol::VndSunStarHelp:
+            // already a vnd.sun.star.help URL -> nothing to do
+            aHelpURL = rURL;
+            break;
+        default:
+        {
+            OUString aHelpModuleName(GetHelpModuleName_Impl(rURL));
+            OUString aRealCommand;
+
+            if ( nProtocol == INetProtocol::Uno )
+            {
+                // Command can be just an alias to another command.
+                auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(rURL, getCurrentModuleIdentifier_Impl());
+                aRealCommand = vcl::CommandInfoProvider::GetRealCommandForCommand(aProperties);
+            }
+
+            // no URL, just a HelpID (maybe empty in case of keyword search)
+            aHelpURL = CreateHelpURL_Impl( aRealCommand.isEmpty() ? rURL : aRealCommand, aHelpModuleName );
+
+            if ( impl_hasHelpInstalled() && pWidget && SfxContentHelper::IsHelpErrorDocument( aHelpURL ) )
+            {
+                bool bUseFinalFallback = true;
+                // no help found -> try ids of parents.
+                pWidget->help_hierarchy_foreach([&aHelpModuleName, &aHelpURL, &bUseFinalFallback](const OString& rHelpId){
+                    if (rHelpId.isEmpty())
+                        return false;
+                    aHelpURL = CreateHelpURL( OStringToOUString(rHelpId, RTL_TEXTENCODING_UTF8), aHelpModuleName);
+                    bool bFinished = !SfxContentHelper::IsHelpErrorDocument(aHelpURL);
+                    if (bFinished)
+                        bUseFinalFallback = false;
+                    return bFinished;
+                });
+
+                if (bUseFinalFallback)
+                {
+                    // create help url of start page ( helpid == 0 -> start page)
+                    aHelpURL = CreateHelpURL( OUString(), aHelpModuleName );
+                }
+            }
+            break;
+        }
+    }
+
+    if ( comphelper::LibreOfficeKit::isActive() )
+    {
+        impl_showOnlineHelp( aHelpURL );
+        return true;
+    }
+
+    // If the HTML or no help is installed, but aHelpURL nevertheless references valid help content,
+    // that implies that help content belongs to an extension (and thus would not be available
+    // in neither the offline nor online HTML help); in that case, fall through to the "old-help to
+    // display" code below:
+    if (SfxContentHelper::IsHelpErrorDocument(aHelpURL))
+    {
+        if ( impl_hasHTMLHelpInstalled() && impl_showOfflineHelp(aHelpURL) )
+        {
+            return true;
+        }
+
+        if ( !impl_hasHelpInstalled() )
+        {
+            SvtHelpOptions aHelpOptions;
+            bool bShowOfflineHelpPopUp = aHelpOptions.IsOfflineHelpPopUp();
+
+            TopLevelWindowLocker aBusy;
+
+            if(bShowOfflineHelpPopUp)
+            {
+                aBusy.incBusy(pWidget);
+                HelpManualMessage aQueryBox(pWidget);
+                short OnlineHelpBox = aQueryBox.run();
+                bShowOfflineHelpPopUp = OnlineHelpBox != RET_OK;
+                aHelpOptions.SetOfflineHelpPopUp(aQueryBox.GetOfflineHelpPopUp());
+                aBusy.decBusy();
+            }
+            if(!bShowOfflineHelpPopUp)
+            {
+                if ( impl_showOnlineHelp( aHelpURL ) )
+                    return true;
+                else
+                {
+                    aBusy.incBusy(pWidget);
+                    NoHelpErrorBox aErrBox(pWidget);
+                    aErrBox.run();
+                    aBusy.decBusy();
+                    return false;
+                }
+            }
+            else
+            {
+                return false;
+            }
+
+        }
+    }
+
+    // old-help to display
+    Reference < XDesktop2 > xDesktop = Desktop::create( ::comphelper::getProcessComponentContext() );
+
+    // check if help window is still open
+    // If not, create a new one and return access directly to the internal sub frame showing the help content
+    // search must be done here; search one desktop level could return an arbitrary frame
+    Reference< XFrame2 > xHelp(
+        xDesktop->findFrame( "OFFICE_HELP_TASK", FrameSearchFlag::CHILDREN),
+                               UNO_QUERY);
+    Reference< XFrame > xHelpContent = xDesktop->findFrame(
+        "OFFICE_HELP",
+        FrameSearchFlag::CHILDREN);
+
+    SfxHelpWindow_Impl* pHelpWindow = nullptr;
+    if (!xHelp.is())
+        pHelpWindow = impl_createHelp(xHelp, xHelpContent);
+    else
+        pHelpWindow = static_cast<SfxHelpWindow_Impl*>(VCLUnoHelper::GetWindow(xHelp->getComponentWindow()).get());
+    if (!xHelp.is() || !xHelpContent.is() || !pHelpWindow)
+        return false;
+
+    SAL_INFO("sfx.appl", "HelpId = " << aHelpURL);
+
+    pHelpWindow->SetHelpURL( aHelpURL );
+    pHelpWindow->loadHelpContent(aHelpURL);
+    if (!rKeyword.isEmpty())
+        pHelpWindow->OpenKeyword( rKeyword );
+
+    Reference < css::awt::XTopWindow > xTopWindow( xHelp->getContainerWindow(), UNO_QUERY );
+    if ( xTopWindow.is() )
+        xTopWindow->toFront();
+
+    return true;
+}
+
+OUString SfxHelp::CreateHelpURL(const OUString& aCommandURL, const OUString& rModuleName)
+{
+    SfxHelp* pHelp = static_cast< SfxHelp* >(Application::GetHelp());
+    return pHelp ? SfxHelp::CreateHelpURL_Impl( aCommandURL, rModuleName ) : OUString();
+}
+
+OUString SfxHelp::GetDefaultHelpModule()
+{
+    return getDefaultModule_Impl();
+}
+
+OUString SfxHelp::GetCurrentModuleIdentifier()
+{
+    return getCurrentModuleIdentifier_Impl();
+}
+
+bool SfxHelp::IsHelpInstalled()
+{
+    return impl_hasHelpInstalled();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/sfxpicklist.cxx b/sfx2/source/appl/sfxpicklist.cxx
new file mode 100644
index 000000000..ec32dd038
--- /dev/null
+++ b/sfx2/source/appl/sfxpicklist.cxx
@@ -0,0 +1,235 @@
+/* -*- 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 <comphelper/lok.hxx>
+#include <comphelper/base64.hxx>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <unotools/historyoptions.hxx>
+#include <unotools/useroptions.hxx>
+#include <tools/datetime.hxx>
+#include <tools/urlobj.hxx>
+#include <svl/inethist.hxx>
+#include <vcl/gdimtf.hxx>
+#include <vcl/pngwrite.hxx>
+#include <vcl/svapp.hxx>
+#include <officecfg/Office/Common.hxx>
+
+
+#include <sfx2/app.hxx>
+#include <sfxpicklist.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/event.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/docfile.hxx>
+#include <openurlhint.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/viewfrm.hxx>
+
+#include <rtl/instance.hxx>
+
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::util;
+
+
+namespace
+{
+    class thePickListMutex
+        : public rtl::Static<osl::Mutex, thePickListMutex> {};
+}
+
+class SfxPickListImpl : public SfxListener
+{
+    /**
+     * Adds the given document to the pick list (recent documents) if it satisfies
+       certain requirements, e.g. being writable. Check implementation for requirement
+       details.
+     */
+    static void         AddDocumentToPickList( const SfxObjectShell* pDocShell );
+
+public:
+    SfxPickListImpl(SfxApplication& rApp);
+    virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
+};
+
+void SfxPickListImpl::AddDocumentToPickList( const SfxObjectShell* pDocSh )
+{
+    if (pDocSh->IsAvoidRecentDocs() || comphelper::LibreOfficeKit::isActive())
+        return;
+
+    SfxMedium *pMed = pDocSh->GetMedium();
+    if( !pMed )
+        return;
+
+    // Unnamed Documents and embedded-Documents not in Picklist
+    if ( !pDocSh->HasName() ||
+            SfxObjectCreateMode::STANDARD != pDocSh->GetCreateMode() )
+        return;
+
+    // Help not in History
+    INetURLObject aURL( pDocSh->IsDocShared() ? pDocSh->GetSharedFileURL() : pMed->GetOrigURL() );
+    if ( aURL.GetProtocol() == INetProtocol::VndSunStarHelp )
+        return;
+
+    // add no document that forbids this
+    if ( !pMed->IsUpdatePickList() )
+        return;
+
+    // ignore hidden documents
+    if ( !SfxViewFrame::GetFirst( pDocSh ) )
+        return;
+
+    OUString  aTitle = pDocSh->GetTitle(SFX_TITLE_PICKLIST);
+    OUString  aFilter;
+    std::shared_ptr<const SfxFilter> pFilter = pMed->GetFilter();
+    if ( pFilter )
+        aFilter = pFilter->GetFilterName();
+
+    std::optional<OUString> aThumbnail;
+
+    // generate the thumbnail
+    //fdo#74834: only generate thumbnail for history if the corresponding option is not disabled in the configuration
+    if (!pDocSh->IsModified() && !Application::IsHeadlessModeEnabled() &&
+            officecfg::Office::Common::History::RecentDocsThumbnail::get())
+    {
+        // not modified => the document matches what is in the shell
+        const SfxUnoAnyItem* pEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pMed->GetItemSet(), SID_ENCRYPTIONDATA, false);
+        if ( pEncryptionDataItem )
+        {
+            // encrypted document, will show a generic document icon instead
+            aThumbnail = OUString();
+        }
+        else
+        {
+            std::shared_ptr<GDIMetaFile> xMetaFile = pDocSh->GetPreviewMetaFile();
+            BitmapEx aResultBitmap;
+            if (xMetaFile->CreateThumbnail(aResultBitmap))
+            {
+                SvMemoryStream aStream(65535, 65535);
+                vcl::PNGWriter aWriter(aResultBitmap);
+                if (aWriter.Write(aStream))
+                {
+                    Sequence<sal_Int8> aSequence(static_cast<const sal_Int8*>(aStream.GetData()), aStream.Tell());
+                    OUStringBuffer aBuffer;
+                    ::comphelper::Base64::encode(aBuffer, aSequence);
+                    aThumbnail = aBuffer.makeStringAndClear();
+                }
+            }
+        }
+    }
+
+    // add to svtool history options
+    SvtHistoryOptions().AppendItem( ePICKLIST,
+            aURL.GetURLNoPass( INetURLObject::DecodeMechanism::NONE ),
+            aFilter,
+            aTitle,
+            aThumbnail);
+
+    if ( aURL.GetProtocol() == INetProtocol::File )
+        Application::AddToRecentDocumentList( aURL.GetURLNoPass( INetURLObject::DecodeMechanism::NONE ),
+                                                                 pFilter ? pFilter->GetMimeType() : OUString(),
+                                                                 pFilter ? pFilter->GetServiceName() : OUString() );
+}
+
+SfxPickList::SfxPickList(SfxApplication& rApp)
+    : mxImpl(new SfxPickListImpl(rApp))
+{
+}
+
+SfxPickList::~SfxPickList()
+{
+}
+
+SfxPickListImpl::SfxPickListImpl(SfxApplication& rApp)
+{
+    StartListening(rApp);
+}
+
+void SfxPickListImpl::Notify( SfxBroadcaster&, const SfxHint& rHint )
+{
+    const SfxOpenUrlHint* pOpenUrlHint = dynamic_cast<const SfxOpenUrlHint*>(&rHint);
+    if ( pOpenUrlHint )
+    {
+        INetURLHistory::GetOrCreate()->PutUrl( INetURLObject( pOpenUrlHint->GetDocumentURL() ));
+    }
+
+    const SfxEventHint* pEventHint = dynamic_cast<const SfxEventHint*>(&rHint);
+    if ( !pEventHint )
+        return;
+
+    // only ObjectShell-related events with media interest
+    SfxObjectShell* pDocSh = pEventHint->GetObjShell();
+    if( !pDocSh )
+        return;
+
+    switch ( pEventHint->GetEventId() )
+    {
+        case SfxEventHintId::CreateDoc:
+        {
+            bool bAllowModif = pDocSh->IsEnableSetModified();
+            if ( bAllowModif )
+                pDocSh->EnableSetModified( false );
+
+            using namespace ::com::sun::star;
+            uno::Reference<document::XDocumentProperties> xDocProps(
+                pDocSh->getDocProperties());
+            if (xDocProps.is()) {
+                xDocProps->setAuthor( SvtUserOptions().GetFullName() );
+                ::DateTime now( ::DateTime::SYSTEM );
+                xDocProps->setCreationDate( now.GetUNODateTime() );
+            }
+
+            if ( bAllowModif )
+                pDocSh->EnableSetModified( bAllowModif );
+        }
+        break;
+
+        case SfxEventHintId::OpenDoc:
+        case SfxEventHintId::SaveDocDone:
+        case SfxEventHintId::SaveAsDocDone:
+        case SfxEventHintId::SaveToDocDone:
+        case SfxEventHintId::CloseDoc:
+        {
+            AddDocumentToPickList(pDocSh);
+        }
+        break;
+
+        case SfxEventHintId::SaveAsDoc:
+        {
+            SfxMedium *pMedium = pDocSh->GetMedium();
+            if (!pMedium)
+                return;
+
+            // We're starting a "Save As". Add the current document (if it's
+            // not a "new" document) to the "Recent Documents" list before we
+            // switch to the new path.
+            // If the current document is new, path will be empty.
+            OUString path = pMedium->GetOrigURL();
+            if (!path.isEmpty())
+            {
+                AddDocumentToPickList(pDocSh);
+            }
+        }
+        break;
+        default: break;
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/shellimpl.cxx b/sfx2/source/appl/shellimpl.cxx
new file mode 100644
index 000000000..2ef1a7fe3
--- /dev/null
+++ b/sfx2/source/appl/shellimpl.cxx
@@ -0,0 +1,127 @@
+/* -*- 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 <shellimpl.hxx>
+
+SfxObjectShellArr_Impl::iterator SfxObjectShellArr_Impl::begin()
+{
+    return maData.begin();
+}
+
+SfxObjectShellArr_Impl::iterator SfxObjectShellArr_Impl::end()
+{
+    return maData.end();
+}
+
+const SfxObjectShell* SfxObjectShellArr_Impl::operator[] ( size_t i ) const
+{
+    return maData[i];
+}
+
+SfxObjectShell* SfxObjectShellArr_Impl::operator[] ( size_t i )
+{
+    return maData[i];
+}
+
+void SfxObjectShellArr_Impl::erase( const iterator& it )
+{
+    maData.erase(it);
+}
+
+void SfxObjectShellArr_Impl::push_back( SfxObjectShell* p )
+{
+    maData.push_back(p);
+}
+
+size_t SfxObjectShellArr_Impl::size() const
+{
+    return maData.size();
+}
+
+SfxViewFrameArr_Impl::iterator SfxViewFrameArr_Impl::begin()
+{
+    return maData.begin();
+}
+
+SfxViewFrameArr_Impl::iterator SfxViewFrameArr_Impl::end()
+{
+    return maData.end();
+}
+
+const SfxViewFrame* SfxViewFrameArr_Impl::operator[] ( size_t i ) const
+{
+    return maData[i];
+}
+
+SfxViewFrame* SfxViewFrameArr_Impl::operator[] ( size_t i )
+{
+    return maData[i];
+}
+
+void SfxViewFrameArr_Impl::erase( const iterator& it )
+{
+    maData.erase(it);
+}
+
+void SfxViewFrameArr_Impl::push_back( SfxViewFrame* p )
+{
+    maData.push_back(p);
+}
+
+size_t SfxViewFrameArr_Impl::size() const
+{
+    return maData.size();
+}
+
+SfxViewShellArr_Impl::iterator SfxViewShellArr_Impl::begin()
+{
+    return maData.begin();
+}
+
+SfxViewShellArr_Impl::iterator SfxViewShellArr_Impl::end()
+{
+    return maData.end();
+}
+
+const SfxViewShell* SfxViewShellArr_Impl::operator[] ( size_t i ) const
+{
+    return maData[i];
+}
+
+SfxViewShell* SfxViewShellArr_Impl::operator[] ( size_t i )
+{
+    return maData[i];
+}
+
+void SfxViewShellArr_Impl::erase( const iterator& it )
+{
+    maData.erase(it);
+}
+
+void SfxViewShellArr_Impl::push_back( SfxViewShell* p )
+{
+    maData.push_back(p);
+}
+
+size_t SfxViewShellArr_Impl::size() const
+{
+    return maData.size();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/shutdownicon.cxx b/sfx2/source/appl/shutdownicon.cxx
new file mode 100644
index 000000000..740cbc702
--- /dev/null
+++ b/sfx2/source/appl/shutdownicon.cxx
@@ -0,0 +1,736 @@
+/* -*- 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 <sal/log.hxx>
+
+#include <cassert>
+
+#include <boost/logic/tribool.hpp>
+#include "shutdownicon.hxx"
+#include <sfx2/strings.hrc>
+#include <sfx2/app.hxx>
+#include <osl/mutex.hxx>
+#include <svtools/imagemgr.hxx>
+#include <svtools/miscopt.hxx>
+#include <com/sun/star/task/InteractionHandler.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/frame/TerminationVetoException.hpp>
+#include <com/sun/star/frame/XDispatchResultListener.hpp>
+#include <com/sun/star/frame/XNotifyingDispatch.hpp>
+#include <com/sun/star/frame/XFramesSupplier.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
+#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/ControlActions.hpp>
+#include <com/sun/star/document/MacroExecMode.hpp>
+#include <com/sun/star/document/UpdateDocMode.hpp>
+#include <sfx2/filedlghelper.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <comphelper/processfactory.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <comphelper/extract.hxx>
+#include <tools/urlobj.hxx>
+#include <tools/debug.hxx>
+#include <osl/file.hxx>
+#include <osl/module.hxx>
+#include <rtl/ref.hxx>
+#include <vcl/svapp.hxx>
+
+#include <sfx2/sfxresid.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::ui::dialogs;
+using namespace ::sfx2;
+
+class SfxNotificationListener_Impl : public cppu::WeakImplHelper< XDispatchResultListener >
+{
+public:
+    virtual void SAL_CALL dispatchFinished( const DispatchResultEvent& aEvent ) override;
+    virtual void SAL_CALL disposing( const EventObject& aEvent ) override;
+};
+
+void SAL_CALL SfxNotificationListener_Impl::dispatchFinished( const DispatchResultEvent& )
+{
+    ShutdownIcon::LeaveModalMode();
+}
+
+void SAL_CALL SfxNotificationListener_Impl::disposing( const EventObject& )
+{
+}
+
+OUString SAL_CALL ShutdownIcon::getImplementationName()
+{
+    return "com.sun.star.comp.desktop.QuickstartWrapper";
+}
+
+sal_Bool SAL_CALL ShutdownIcon::supportsService(OUString const & ServiceName)
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+css::uno::Sequence<OUString> SAL_CALL ShutdownIcon::getSupportedServiceNames()
+{
+    return { "com.sun.star.office.Quickstart" };
+}
+
+bool ShutdownIcon::bModalMode = false;
+ShutdownIcon* ShutdownIcon::pShutdownIcon = nullptr;
+
+extern "C" {
+    static void disabled_initSystray() { }
+    static void disabled_deInitSystray() { }
+}
+
+namespace {
+
+boost::logic::tribool loaded(boost::logic::indeterminate); // loplugin:constvars:ignore
+oslGenericFunction pInitSystray = disabled_initSystray;
+oslGenericFunction pDeInitSystray = disabled_deInitSystray;
+
+bool LoadModule()
+{
+    if (boost::logic::indeterminate(loaded))
+    {
+#ifdef ENABLE_QUICKSTART_APPLET
+#  ifdef _WIN32
+        pInitSystray = win32_init_sys_tray;
+        pDeInitSystray = win32_shutdown_sys_tray;
+        loaded = true;
+#  elif defined MACOSX
+        pInitSystray = aqua_init_systray;
+        pDeInitSystray = aqua_shutdown_systray;
+        loaded = true;
+#  endif // MACOSX
+#endif // ENABLE_QUICKSTART_APPLET
+    }
+    assert(!boost::logic::indeterminate(loaded));
+    return bool(loaded);
+}
+
+}
+
+void ShutdownIcon::initSystray()
+{
+    if (m_bInitialized)
+        return;
+    m_bInitialized = true;
+
+    (void) LoadModule();
+    m_bVeto = true;
+    pInitSystray();
+}
+
+void ShutdownIcon::deInitSystray()
+{
+    if (!m_bInitialized)
+        return;
+
+    if (pDeInitSystray)
+        pDeInitSystray();
+
+    m_bVeto = false;
+    pInitSystray = nullptr;
+    pDeInitSystray = nullptr;
+
+    m_pFileDlg.reset();
+    m_bInitialized = false;
+}
+
+
+ShutdownIcon::ShutdownIcon( const css::uno::Reference< XComponentContext > & rxContext ) :
+    ShutdownIconServiceBase( m_aMutex ),
+    m_bVeto ( false ),
+    m_bListenForTermination ( false ),
+    m_bSystemDialogs( false ),
+    m_xContext( rxContext ),
+    m_bInitialized( false )
+{
+    m_bSystemDialogs = SvtMiscOptions().UseSystemFileDialog();
+}
+
+ShutdownIcon::~ShutdownIcon()
+{
+    deInitSystray();
+}
+
+
+void ShutdownIcon::OpenURL( const OUString& aURL, const OUString& rTarget, const Sequence< PropertyValue >& aArgs )
+{
+    if ( !getInstance() || !getInstance()->m_xDesktop.is() )
+        return;
+
+    css::uno::Reference < XDispatchProvider > xDispatchProvider = getInstance()->m_xDesktop;
+    if ( !xDispatchProvider.is() )
+        return;
+
+    css::util::URL aDispatchURL;
+    aDispatchURL.Complete = aURL;
+
+    css::uno::Reference< util::XURLTransformer > xURLTransformer( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+    try
+    {
+        css::uno::Reference< css::frame::XDispatch > xDispatch;
+
+        xURLTransformer->parseStrict( aDispatchURL );
+        xDispatch = xDispatchProvider->queryDispatch( aDispatchURL, rTarget, 0 );
+        if ( xDispatch.is() )
+            xDispatch->dispatch( aDispatchURL, aArgs );
+    }
+    catch ( css::uno::RuntimeException& )
+    {
+        throw;
+    }
+    catch ( css::uno::Exception& )
+    {
+    }
+}
+
+
+void ShutdownIcon::FileOpen()
+{
+    if ( getInstance() && getInstance()->m_xDesktop.is() )
+    {
+        ::SolarMutexGuard aGuard;
+        EnterModalMode();
+        getInstance()->StartFileDialog();
+    }
+}
+
+
+void ShutdownIcon::FromTemplate()
+{
+    if ( !getInstance() || !getInstance()->m_xDesktop.is() )
+        return;
+
+    css::uno::Reference < css::frame::XFramesSupplier > xDesktop = getInstance()->m_xDesktop;
+    css::uno::Reference < css::frame::XFrame > xFrame( xDesktop->getActiveFrame() );
+    if ( !xFrame.is() )
+        xFrame = xDesktop;
+
+    URL aTargetURL;
+    aTargetURL.Complete = ".uno:NewDoc";
+    css::uno::Reference< util::XURLTransformer > xTrans( util::URLTransformer::create( ::comphelper::getProcessComponentContext() ) );
+    xTrans->parseStrict( aTargetURL );
+
+    css::uno::Reference < css::frame::XDispatchProvider > xProv( xFrame, UNO_QUERY );
+    css::uno::Reference < css::frame::XDispatch > xDisp;
+    if ( xProv.is() )
+    {
+        xDisp = xProv->queryDispatch( aTargetURL, "_self", 0 );
+    }
+    if ( !xDisp.is() )
+        return;
+
+    Sequence<PropertyValue> aArgs(1);
+    PropertyValue* pArg = aArgs.getArray();
+    pArg[0].Name = "Referer";
+    pArg[0].Value <<= OUString("private:user");
+    css::uno::Reference< css::frame::XNotifyingDispatch > xNotifier(xDisp, UNO_QUERY);
+    if (xNotifier.is())
+    {
+        EnterModalMode();
+        xNotifier->dispatchWithNotification(aTargetURL, aArgs, new SfxNotificationListener_Impl);
+    }
+    else
+        xDisp->dispatch( aTargetURL, aArgs );
+}
+
+OUString ShutdownIcon::GetUrlDescription( const OUString& aUrl )
+{
+    ::SolarMutexGuard aGuard;
+
+    return SvFileInformationManager::GetDescription( INetURLObject( aUrl ) );
+}
+
+void ShutdownIcon::StartFileDialog()
+{
+    ::SolarMutexGuard aGuard;
+
+    bool bDirty = ( m_bSystemDialogs != SvtMiscOptions().UseSystemFileDialog() );
+
+    if ( m_pFileDlg && bDirty )
+    {
+        // Destroy instance as changing the system file dialog setting
+        // forces us to create a new FileDialogHelper instance!
+        m_pFileDlg.reset();
+    }
+
+    if ( !m_pFileDlg )
+        m_pFileDlg.reset( new FileDialogHelper(
+                ui::dialogs::TemplateDescription::FILEOPEN_READONLY_VERSION,
+                FileDialogFlags::MultiSelection, OUString(), SfxFilterFlags::NONE, SfxFilterFlags::NONE, nullptr ) );
+    m_pFileDlg->StartExecuteModal( LINK( this, ShutdownIcon, DialogClosedHdl_Impl ) );
+}
+
+IMPL_LINK( ShutdownIcon, DialogClosedHdl_Impl, FileDialogHelper*, /*unused*/, void )
+{
+    DBG_ASSERT( m_pFileDlg, "ShutdownIcon, DialogClosedHdl_Impl(): no file dialog" );
+
+    // use constructor for filling up filters automatically!
+    if ( ERRCODE_NONE == m_pFileDlg->GetError() )
+    {
+        css::uno::Reference< XFilePicker3 >    xPicker = m_pFileDlg->GetFilePicker();
+
+        try
+        {
+
+            if ( xPicker.is() )
+            {
+
+                css::uno::Reference < XFilePickerControlAccess > xPickerControls ( xPicker, UNO_QUERY );
+
+                Sequence< OUString >        sFiles = xPicker->getSelectedFiles();
+                int                         nFiles = sFiles.getLength();
+
+                int                         nArgs=3;
+                Sequence< PropertyValue >   aArgs(3);
+
+                css::uno::Reference < css::task::XInteractionHandler2 > xInteraction(
+                    task::InteractionHandler::createWithParent(::comphelper::getProcessComponentContext(), nullptr) );
+
+                aArgs[0].Name = "InteractionHandler";
+                aArgs[0].Value <<= xInteraction;
+
+                aArgs[1].Name = "MacroExecutionMode";
+                aArgs[1].Value <<= sal_Int16(css::document::MacroExecMode::USE_CONFIG);
+
+                aArgs[2].Name = "UpdateDocMode";
+                aArgs[2].Value <<= sal_Int16(css::document::UpdateDocMode::ACCORDING_TO_CONFIG);
+
+                // use the filedlghelper to get the current filter name,
+                // because it removes the extensions before you get the filter name.
+                OUString aFilterName( m_pFileDlg->GetCurrentFilter() );
+
+                if ( xPickerControls.is() )
+                {
+
+                    // Set readonly flag
+
+                    bool    bReadOnly = false;
+
+
+                    xPickerControls->getValue( ExtendedFilePickerElementIds::CHECKBOX_READONLY, 0 ) >>= bReadOnly;
+
+                    // Only set property if readonly is set to TRUE
+
+                    if ( bReadOnly )
+                    {
+                        aArgs.realloc( ++nArgs );
+                        aArgs[nArgs-1].Name  = "ReadOnly";
+                        aArgs[nArgs-1].Value <<= bReadOnly;
+                    }
+
+                    // Get version string
+
+                    sal_Int32   iVersion = -1;
+
+                    xPickerControls->getValue( ExtendedFilePickerElementIds::LISTBOX_VERSION, ControlActions::GET_SELECTED_ITEM_INDEX ) >>= iVersion;
+
+                    if ( iVersion >= 0 )
+                    {
+                        sal_Int16   uVersion = static_cast<sal_Int16>(iVersion);
+
+                        aArgs.realloc( ++nArgs );
+                        aArgs[nArgs-1].Name  = "Version";
+                        aArgs[nArgs-1].Value <<= uVersion;
+                    }
+
+                    // Retrieve the current filter
+
+                    if ( aFilterName.isEmpty() )
+                        xPickerControls->getValue( CommonFilePickerElementIds::LISTBOX_FILTER, ControlActions::GET_SELECTED_ITEM ) >>= aFilterName;
+
+                }
+
+
+                // Convert UI filter name to internal filter name
+
+                if ( !aFilterName.isEmpty() )
+                {
+                    std::shared_ptr<const SfxFilter> pFilter = SfxGetpApp()->GetFilterMatcher().GetFilter4UIName( aFilterName, SfxFilterFlags::NONE, SfxFilterFlags::NOTINFILEDLG );
+
+                    if ( pFilter )
+                    {
+                        aFilterName = pFilter->GetFilterName();
+
+                        if ( !aFilterName.isEmpty() )
+                        {
+                            aArgs.realloc( ++nArgs );
+                            aArgs[nArgs-1].Name  = "FilterName";
+                            aArgs[nArgs-1].Value <<= aFilterName;
+                        }
+                    }
+                }
+
+                if ( 1 == nFiles )
+                    OpenURL( sFiles[0], "_default", aArgs );
+                else
+                {
+                    OUString    aBaseDirURL = sFiles[0];
+                    if ( !aBaseDirURL.isEmpty() && !aBaseDirURL.endsWith("/") )
+                        aBaseDirURL += "/";
+
+                    int iFiles;
+                    for ( iFiles = 1; iFiles < nFiles; iFiles++ )
+                    {
+                        OUString aURL = aBaseDirURL + sFiles[iFiles];
+                        OpenURL( aURL, "_default", aArgs );
+                    }
+                }
+            }
+        }
+        catch ( ... )
+        {
+        }
+    }
+
+#ifdef _WIN32
+    // Destroy dialog to prevent problems with custom controls
+    // This fix is dependent on the dialog settings. Destroying the dialog here will
+    // crash the non-native dialog implementation! Therefore make this dependent on
+    // the settings.
+    if ( SvtMiscOptions().UseSystemFileDialog() )
+    {
+        m_pFileDlg.reset();
+    }
+#endif
+
+    LeaveModalMode();
+}
+
+
+void ShutdownIcon::addTerminateListener()
+{
+    ShutdownIcon* pInst = getInstance();
+    if ( ! pInst)
+        return;
+
+    if (pInst->m_bListenForTermination)
+        return;
+
+    css::uno::Reference< XDesktop2 > xDesktop = pInst->m_xDesktop;
+    if ( ! xDesktop.is())
+        return;
+
+    xDesktop->addTerminateListener( pInst );
+    pInst->m_bListenForTermination = true;
+}
+
+
+void ShutdownIcon::terminateDesktop()
+{
+    ShutdownIcon* pInst = getInstance();
+    if ( ! pInst)
+        return;
+
+    css::uno::Reference< XDesktop2 > xDesktop = pInst->m_xDesktop;
+    if ( ! xDesktop.is())
+        return;
+
+    // always remove ourselves as listener
+    pInst->m_bListenForTermination = true;
+    xDesktop->removeTerminateListener( pInst );
+
+    // terminate desktop only if no tasks exist
+    css::uno::Reference< XIndexAccess > xTasks = xDesktop->getFrames();
+    if( xTasks.is() && xTasks->getCount() < 1 )
+        Application::Quit();
+
+    // remove the instance pointer
+    ShutdownIcon::pShutdownIcon = nullptr;
+}
+
+
+ShutdownIcon* ShutdownIcon::getInstance()
+{
+    OSL_ASSERT( pShutdownIcon );
+    return pShutdownIcon;
+}
+
+
+ShutdownIcon* ShutdownIcon::createInstance()
+{
+    if (pShutdownIcon)
+        return pShutdownIcon;
+
+    try {
+        std::unique_ptr<ShutdownIcon> pIcon(new ShutdownIcon( comphelper::getProcessComponentContext() ));
+        pIcon->init ();
+        pShutdownIcon = pIcon.release();
+    } catch (...) {
+    }
+
+    return pShutdownIcon;
+}
+
+void ShutdownIcon::init()
+{
+    css::uno::Reference < XDesktop2 > xDesktop = Desktop::create( m_xContext );
+    osl::MutexGuard aGuard(m_aMutex);
+    m_xDesktop = xDesktop;
+}
+
+
+void SAL_CALL ShutdownIcon::disposing()
+{
+    m_xContext.clear();
+    m_xDesktop.clear();
+
+    deInitSystray();
+}
+
+
+// XEventListener
+void SAL_CALL ShutdownIcon::disposing( const css::lang::EventObject& )
+{
+}
+
+
+// XTerminateListener
+void SAL_CALL ShutdownIcon::queryTermination( const css::lang::EventObject& )
+{
+    SAL_INFO("sfx.appl", "ShutdownIcon::queryTermination: veto is " << m_bVeto);
+    osl::MutexGuard  aGuard( m_aMutex );
+
+    if ( m_bVeto )
+        throw css::frame::TerminationVetoException();
+}
+
+
+void SAL_CALL ShutdownIcon::notifyTermination( const css::lang::EventObject& )
+{
+}
+
+
+void SAL_CALL ShutdownIcon::initialize( const css::uno::Sequence< css::uno::Any>& aArguments )
+{
+    ::osl::ResettableMutexGuard aGuard( m_aMutex );
+
+    // third argument only sets veto, everything else will be ignored!
+    if (aArguments.getLength() > 2)
+    {
+        bool bVeto = ::cppu::any2bool(aArguments[2]);
+        m_bVeto = bVeto;
+        return;
+    }
+
+    if ( aArguments.getLength() > 0 )
+    {
+        if ( !ShutdownIcon::pShutdownIcon )
+        {
+            try
+            {
+                bool bQuickstart = ::cppu::any2bool( aArguments[0] );
+                if( !bQuickstart && !GetAutostart() )
+                    return;
+                aGuard.clear();
+                init ();
+                aGuard.reset();
+                if ( !m_xDesktop.is() )
+                    return;
+
+                /* Create a sub-classed instance - foo */
+                ShutdownIcon::pShutdownIcon = this;
+                initSystray();
+            }
+            catch(const css::lang::IllegalArgumentException&)
+            {
+            }
+        }
+    }
+    if ( aArguments.getLength() > 1 )
+    {
+            bool bAutostart = ::cppu::any2bool( aArguments[1] );
+            if (bAutostart && !GetAutostart())
+                SetAutostart( true );
+            if (!bAutostart && GetAutostart())
+                SetAutostart( false );
+    }
+
+}
+
+
+void ShutdownIcon::EnterModalMode()
+{
+    bModalMode = true;
+}
+
+
+void ShutdownIcon::LeaveModalMode()
+{
+    bModalMode = false;
+}
+
+#ifdef _WIN32
+// defined in shutdowniconw32.cxx
+#elif defined MACOSX
+// defined in shutdowniconaqua.cxx
+#else
+bool ShutdownIcon::IsQuickstarterInstalled()
+{
+    return false;
+}
+#endif
+
+
+#ifdef ENABLE_QUICKSTART_APPLET
+#ifdef _WIN32
+OUString ShutdownIcon::getShortcutName()
+{
+    return GetAutostartFolderNameW32() + "\\" + SfxResId(STR_QUICKSTART_LNKNAME) + ".lnk";
+}
+#endif // _WIN32
+#endif
+
+bool ShutdownIcon::GetAutostart( )
+{
+#if defined MACOSX
+    return true;
+#elif defined ENABLE_QUICKSTART_APPLET
+    bool bRet = false;
+    OUString aShortcut( getShortcutName() );
+    OUString aShortcutUrl;
+    osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl );
+    osl::File f( aShortcutUrl );
+    osl::File::RC error = f.open( osl_File_OpenFlag_Read );
+    if( error == osl::File::E_None )
+    {
+        f.close();
+        bRet = true;
+    }
+    return bRet;
+#else // ENABLE_QUICKSTART_APPLET
+    return false;
+#endif
+}
+
+void ShutdownIcon::SetAutostart( bool bActivate )
+{
+#ifdef ENABLE_QUICKSTART_APPLET
+#ifndef MACOSX
+    OUString aShortcut( getShortcutName() );
+#endif
+
+    if( bActivate && IsQuickstarterInstalled() )
+    {
+#ifdef _WIN32
+        EnableAutostartW32( aShortcut );
+#endif
+    }
+    else
+    {
+#ifndef MACOSX
+        OUString aShortcutUrl;
+        ::osl::File::getFileURLFromSystemPath( aShortcut, aShortcutUrl );
+        ::osl::File::remove( aShortcutUrl );
+#endif
+    }
+#else
+    (void)bActivate; // unused variable
+#endif // ENABLE_QUICKSTART_APPLET
+}
+
+static const ::sal_Int32 PROPHANDLE_TERMINATEVETOSTATE = 0;
+
+// XFastPropertySet
+void SAL_CALL ShutdownIcon::setFastPropertyValue(       ::sal_Int32                  nHandle,
+                                                  const css::uno::Any& aValue )
+{
+    switch(nHandle)
+    {
+        case PROPHANDLE_TERMINATEVETOSTATE :
+             {
+                // use new value in case it's a valid information only
+                bool bState( false );
+                if (! (aValue >>= bState))
+                    return;
+
+                m_bVeto = bState;
+                if (m_bVeto && ! m_bListenForTermination)
+                    addTerminateListener();
+             }
+             break;
+
+        default :
+            throw css::beans::UnknownPropertyException(OUString::number(nHandle));
+    }
+}
+
+// XFastPropertySet
+css::uno::Any SAL_CALL ShutdownIcon::getFastPropertyValue( ::sal_Int32 nHandle )
+{
+    css::uno::Any aValue;
+    switch(nHandle)
+    {
+        case PROPHANDLE_TERMINATEVETOSTATE :
+             {
+                bool bState   = (m_bListenForTermination && m_bVeto);
+                aValue <<= bState;
+             }
+             break;
+
+        default :
+            throw css::beans::UnknownPropertyException(OUString::number(nHandle));
+    }
+
+    return aValue;
+}
+
+namespace {
+
+struct Instance {
+    explicit Instance(
+        css::uno::Reference<css::uno::XComponentContext> const & context):
+        instance(static_cast<cppu::OWeakObject *>(new ShutdownIcon(context)))
+    {}
+
+    rtl::Reference<css::uno::XInterface> instance;
+};
+
+struct Singleton:
+    public rtl::StaticWithArg<
+        Instance, css::uno::Reference<css::uno::XComponentContext>, Singleton>
+{};
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_desktop_QuickstartWrapper_get_implementation(
+    css::uno::XComponentContext *context,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(static_cast<cppu::OWeakObject *>(
+                Singleton::get(context).instance.get()));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/shutdownicon.hxx b/sfx2/source/appl/shutdownicon.hxx
new file mode 100644
index 000000000..682933040
--- /dev/null
+++ b/sfx2/source/appl/shutdownicon.hxx
@@ -0,0 +1,160 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_SFX2_SOURCE_APPL_SHUTDOWNICON_HXX
+#define INCLUDED_SFX2_SOURCE_APPL_SHUTDOWNICON_HXX
+
+#include <com/sun/star/frame/XTerminateListener.hpp>
+#include <com/sun/star/frame/XDesktop2.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/beans/XFastPropertySet.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <rtl/ustring.hxx>
+#include <osl/mutex.hxx>
+#include <cppuhelper/compbase.hxx>
+#include <tools/link.hxx>
+#include <memory>
+
+extern "C" {
+
+void SAL_DLLPUBLIC_EXPORT plugin_init_sys_tray();
+void SAL_DLLPUBLIC_EXPORT plugin_shutdown_sys_tray();
+
+}
+
+namespace sfx2
+{
+    class FileDialogHelper;
+}
+
+typedef ::cppu::WeakComponentImplHelper<
+    css::lang::XInitialization,
+    css::frame::XTerminateListener,
+    css::lang::XServiceInfo,
+    css::beans::XFastPropertySet > ShutdownIconServiceBase;
+
+#define WRITER_URL          "private:factory/swriter"
+#define CALC_URL            "private:factory/scalc"
+#define IMPRESS_URL         "private:factory/simpress"
+#define IMPRESS_WIZARD_URL  "private:factory/simpress?slot=6686"
+#define DRAW_URL            "private:factory/sdraw"
+#define MATH_URL            "private:factory/smath"
+#define BASE_URL            "private:factory/sdatabase?Interactive"
+#define STARTMODULE_URL     ".uno:ShowStartModule"
+
+class ShutdownIcon : public ShutdownIconServiceBase
+{
+        ::osl::Mutex            m_aMutex;
+        bool                    m_bVeto;
+        bool                    m_bListenForTermination;
+        bool                    m_bSystemDialogs;
+        std::unique_ptr<sfx2::FileDialogHelper> m_pFileDlg;
+        css::uno::Reference< css::uno::XComponentContext > m_xContext;
+
+        static ShutdownIcon *pShutdownIcon; // one instance
+
+        bool m_bInitialized;
+        void initSystray();
+        void deInitSystray();
+
+        static void EnterModalMode();
+        static void LeaveModalMode();
+        static OUString getShortcutName();
+
+        friend class SfxNotificationListener_Impl;
+
+    public:
+        explicit ShutdownIcon( const css::uno::Reference< css::uno::XComponentContext > & rxContext );
+
+        virtual ~ShutdownIcon() override;
+
+        virtual OUString SAL_CALL getImplementationName() override;
+
+        virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override;
+
+        virtual css::uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
+
+        static ShutdownIcon* getInstance();
+        static ShutdownIcon* createInstance();
+
+        static void terminateDesktop();
+        static void addTerminateListener();
+
+        static void FileOpen();
+        static void OpenURL( const OUString& aURL, const OUString& rTarget, const css::uno::Sequence< css::beans::PropertyValue >& =
+            css::uno::Sequence< css::beans::PropertyValue >( 0 ) );
+        static void FromTemplate();
+
+        static void SetAutostart( bool bActivate );
+        static bool GetAutostart();
+        static bool bModalMode;
+
+        /// @throws css::uno::Exception
+        void init();
+
+        static OUString GetUrlDescription( const OUString& aUrl );
+
+        void SetVeto( bool bVeto )  { m_bVeto = bVeto;}
+
+        void                    StartFileDialog();
+        DECL_LINK(DialogClosedHdl_Impl, sfx2::FileDialogHelper*, void);
+
+        static bool IsQuickstarterInstalled();
+
+        // Component Helper - force override
+        virtual void SAL_CALL disposing() override;
+
+        // XEventListener
+        virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;
+
+        // XTerminateListener
+        virtual void SAL_CALL queryTermination( const css::lang::EventObject& aEvent ) override;
+        virtual void SAL_CALL notifyTermination( const css::lang::EventObject& aEvent ) override;
+
+        // XInitialization
+        virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+        // XFastPropertySet
+        virtual void SAL_CALL setFastPropertyValue(       ::sal_Int32                  nHandle,
+                                                    const css::uno::Any& aValue ) override;
+        virtual css::uno::Any SAL_CALL getFastPropertyValue( ::sal_Int32 nHandle ) override;
+
+        css::uno::Reference< css::frame::XDesktop2 > m_xDesktop;
+
+#ifdef _WIN32
+        static void EnableAutostartW32( const OUString &aShortcutName );
+        static OUString GetAutostartFolderNameW32();
+#endif
+};
+
+extern "C" {
+#  ifdef _WIN32
+    // builtin win32 systray
+    void win32_init_sys_tray();
+    void win32_shutdown_sys_tray();
+#  elif defined MACOSX
+    void aqua_init_systray();
+    void aqua_shutdown_systray();
+#  endif
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/shutdowniconaqua.mm b/sfx2/source/appl/shutdowniconaqua.mm
new file mode 100644
index 000000000..78c89f338
--- /dev/null
+++ b/sfx2/source/appl/shutdowniconaqua.mm
@@ -0,0 +1,509 @@
+/* -*- 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/moduleoptions.hxx>
+#include <unotools/dynamicmenuoptions.hxx>
+#include <unotools/historyoptions.hxx>
+#include <rtl/ustring.hxx>
+#include <tools/urlobj.hxx>
+#include <osl/file.h>
+#include <comphelper/sequenceashashmap.hxx>
+#include <sfx2/app.hxx>
+#include <sal/macros.h>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/strings.hrc>
+#include <vcl/svapp.hxx>
+#include "shutdownicon.hxx"
+
+#include <com/sun/star/util/XStringWidth.hpp>
+
+#include <cppuhelper/implbase.hxx>
+
+#include <set>
+#include <vector>
+
+#include <premac.h>
+#include <objc/objc-runtime.h>
+#include <Cocoa/Cocoa.h>
+#include <postmac.h>
+
+#define MI_OPEN                    1
+#define MI_WRITER                  2
+#define MI_CALC                    3
+#define MI_IMPRESS                 4
+#define MI_DRAW                    5
+#define MI_BASE                    6
+#define MI_MATH                    7
+#define MI_TEMPLATE                8
+#define MI_STARTMODULE             9
+
+@interface QSMenuExecute : NSObject
+{
+}
+-(void)executeMenuItem: (NSMenuItem*)pItem;
+-(void)dockIconClicked: (NSObject*)pSender;
+@end
+
+@implementation QSMenuExecute
+-(void)executeMenuItem: (NSMenuItem*)pItem
+{
+    switch( [pItem tag] )
+    {
+    case MI_OPEN:
+        ShutdownIcon::FileOpen();
+        break;
+    case MI_WRITER:
+        ShutdownIcon::OpenURL( WRITER_URL, "_default" );
+        break;
+    case MI_CALC:
+        ShutdownIcon::OpenURL( CALC_URL, "_default" );
+        break;
+    case MI_IMPRESS:
+        ShutdownIcon::OpenURL( IMPRESS_URL, "_default" );
+        break;
+    case MI_DRAW:
+        ShutdownIcon::OpenURL( DRAW_URL, "_default" );
+        break;
+    case MI_BASE:
+        ShutdownIcon::OpenURL( BASE_URL, "_default" );
+        break;
+    case MI_MATH:
+        ShutdownIcon::OpenURL( MATH_URL, "_default" );
+        break;
+    case MI_TEMPLATE:
+        ShutdownIcon::FromTemplate();
+        break;
+    case MI_STARTMODULE:
+        ShutdownIcon::OpenURL( STARTMODULE_URL, "_default" );
+        break;
+    default:
+        break;
+    }
+}
+
+-(void)dockIconClicked: (NSObject*)pSender
+{
+    (void)pSender;
+    // start module
+    ShutdownIcon::OpenURL( STARTMODULE_URL, "_default" );
+}
+
+@end
+
+bool ShutdownIcon::IsQuickstarterInstalled()
+{
+    return true;
+}
+
+static NSMenuItem* pDefMenu = nil, *pDockSubMenu = nil;
+static QSMenuExecute* pExecute = nil;
+
+static std::set< OUString > aShortcuts;
+
+static NSString* getAutoreleasedString( const OUString& rStr )
+{
+    return [[[NSString alloc] initWithCharacters: reinterpret_cast<unichar const *>(rStr.getStr()) length: rStr.getLength()] autorelease];
+}
+
+namespace {
+
+struct RecentMenuEntry
+{
+    OUString aURL;
+    OUString aFilter;
+    OUString aTitle;
+    OUString aPassword;
+};
+
+class RecentFilesStringLength : public ::cppu::WeakImplHelper< css::util::XStringWidth >
+{
+    public:
+        RecentFilesStringLength() {}
+
+        // XStringWidth
+        sal_Int32 SAL_CALL queryStringWidth( const OUString& aString ) override
+        {
+            return aString.getLength();
+        }
+};
+
+}
+
+@interface RecentMenuDelegate : NSObject
+{
+    std::vector< RecentMenuEntry >* m_pRecentFilesItems;
+}
+-(id)init;
+-(void)dealloc;
+-(void)menuNeedsUpdate:(NSMenu *)menu;
+-(void)executeRecentEntry: (NSMenuItem*)item;
+@end
+
+@implementation RecentMenuDelegate
+-(id)init
+{
+    if( (self = [super init]) )
+    {
+        m_pRecentFilesItems = new std::vector< RecentMenuEntry >();
+    }
+    return self;
+}
+
+-(void)dealloc
+{
+    delete m_pRecentFilesItems;
+    [super dealloc];
+}
+
+-(void)menuNeedsUpdate:(NSMenu *)menu
+{
+    // clear menu
+    int nItems = [menu numberOfItems];
+    while( nItems -- )
+        [menu removeItemAtIndex: 0];
+
+    // update recent item list
+    css::uno::Sequence< css::uno::Sequence< css::beans::PropertyValue > > aHistoryList( SvtHistoryOptions().GetList( ePICKLIST ) );
+
+    int nPickListMenuItems = ( aHistoryList.getLength() > 99 ) ? 99 : aHistoryList.getLength();
+
+    m_pRecentFilesItems->clear();
+    if( nPickListMenuItems > 0 )
+    {
+        for ( int i = 0; i < nPickListMenuItems; i++ )
+        {
+            css::uno::Sequence< css::beans::PropertyValue >& rPickListEntry = aHistoryList[i];
+            RecentMenuEntry aRecentFile;
+
+            for ( const css::beans::PropertyValue& rProp : rPickListEntry )
+            {
+                const css::uno::Any& a = rProp.Value;
+
+                if ( rProp.Name == HISTORY_PROPERTYNAME_URL )
+                    a >>= aRecentFile.aURL;
+                else if ( rProp.Name == HISTORY_PROPERTYNAME_FILTER )
+                    a >>= aRecentFile.aFilter;
+                else if ( rProp.Name == HISTORY_PROPERTYNAME_TITLE )
+                    a >>= aRecentFile.aTitle;
+                else if ( rProp.Name == HISTORY_PROPERTYNAME_PASSWORD )
+                    a >>= aRecentFile.aPassword;
+            }
+
+            m_pRecentFilesItems->push_back( aRecentFile );
+        }
+    }
+
+    // insert new recent items
+    for ( std::vector<RecentMenuEntry>::size_type i = 0; i < m_pRecentFilesItems->size(); i++ )
+    {
+        OUString   aMenuTitle;
+        INetURLObject   aURL( (*m_pRecentFilesItems)[i].aURL );
+
+        if ( aURL.GetProtocol() == INetProtocol::File )
+        {
+            // Do handle file URL differently => convert it to a system
+            // path and abbreviate it with a special function:
+            OUString aSystemPath( aURL.getFSysPath( FSysStyle::Detect ) );
+            OUString aCompactedSystemPath;
+
+            oslFileError nError = osl_abbreviateSystemPath( aSystemPath.pData, &aCompactedSystemPath.pData, 46, nullptr );
+            if ( !nError )
+                aMenuTitle = aCompactedSystemPath;
+            else
+                aMenuTitle = aSystemPath;
+        }
+        else
+        {
+            // Use INetURLObject to abbreviate all other URLs
+            css::uno::Reference< css::util::XStringWidth > xStringLength( new RecentFilesStringLength() );
+            aMenuTitle = aURL.getAbbreviated( xStringLength, 46, INetURLObject::DecodeMechanism::Unambiguous );
+        }
+
+        NSMenuItem* pNewItem = [[NSMenuItem alloc] initWithTitle: getAutoreleasedString( aMenuTitle )
+                                                   action: @selector(executeRecentEntry:)
+                                                   keyEquivalent: @""];
+        [pNewItem setTag: i];
+        [pNewItem setTarget: self];
+        [pNewItem setEnabled: YES];
+        [menu addItem: pNewItem];
+        [pNewItem autorelease];
+    }
+}
+
+-(void)executeRecentEntry: (NSMenuItem*)item
+{
+    sal_Int32 nIndex = [item tag];
+    if( ( nIndex >= 0 ) && ( nIndex < static_cast<sal_Int32>( m_pRecentFilesItems->size() ) ) )
+    {
+        const RecentMenuEntry& rRecentFile = (*m_pRecentFilesItems)[ nIndex ];
+        int NUM_OF_PICKLIST_ARGS = 3;
+        css::uno::Sequence< css::beans::PropertyValue > aArgsList( NUM_OF_PICKLIST_ARGS );
+
+        aArgsList[0].Name = "Referer";
+        aArgsList[0].Value <<= OUString( "private:user" );
+
+        // documents in the picklist will never be opened as templates
+        aArgsList[1].Name = "AsTemplate";
+        aArgsList[1].Value <<= false;
+
+        OUString  aFilter( rRecentFile.aFilter );
+        sal_Int32 nPos = aFilter.indexOf( '|' );
+        if ( nPos >= 0 )
+        {
+            OUString aFilterOptions;
+
+            if ( nPos < ( aFilter.getLength() - 1 ) )
+                aFilterOptions = aFilter.copy( nPos+1 );
+
+            aArgsList[2].Name = "FilterOptions";
+            aArgsList[2].Value <<= aFilterOptions;
+
+            aFilter = aFilter.copy( 0, nPos-1 );
+            aArgsList.realloc( ++NUM_OF_PICKLIST_ARGS );
+        }
+
+        aArgsList[NUM_OF_PICKLIST_ARGS-1].Name = "FilterName";
+        aArgsList[NUM_OF_PICKLIST_ARGS-1].Value <<= aFilter;
+
+        ShutdownIcon::OpenURL( rRecentFile.aURL, "_default", aArgsList );
+    }
+}
+@end
+
+static RecentMenuDelegate* pRecentDelegate = nil;
+
+static OUString getShortCut( const OUString& i_rTitle )
+{
+    // create shortcut
+    OUString aKeyEquiv;
+    for( sal_Int32 nIndex = 0; nIndex < i_rTitle.getLength(); nIndex++ )
+    {
+        OUString aShortcut( i_rTitle.copy( nIndex, 1 ).toAsciiLowerCase() );
+        if( aShortcuts.find( aShortcut ) == aShortcuts.end() )
+        {
+            aShortcuts.insert( aShortcut );
+            aKeyEquiv = aShortcut;
+            break;
+        }
+    }
+
+    return aKeyEquiv;   
+}
+
+static void appendMenuItem( NSMenu* i_pMenu, NSMenu* i_pDockMenu, const OUString& i_rTitle, int i_nTag, const OUString& i_rKeyEquiv )
+{
+    if( ! i_rTitle.getLength() )
+        return;
+
+    NSMenuItem* pItem = [[NSMenuItem alloc] initWithTitle: getAutoreleasedString( i_rTitle )
+                                            action: @selector(executeMenuItem:)
+                                            keyEquivalent: (i_rKeyEquiv.getLength() ? getAutoreleasedString( i_rKeyEquiv ) : @"")
+                        ];
+    [pItem setTag: i_nTag];
+    [pItem setTarget: pExecute];
+    [pItem setEnabled: YES];
+    [i_pMenu addItem: pItem];
+
+    if( i_pDockMenu )
+    {
+        // create a similar entry in the dock menu
+        pItem = [[NSMenuItem alloc] initWithTitle: getAutoreleasedString( i_rTitle )
+                                    action: @selector(executeMenuItem:)
+                                    keyEquivalent: @""
+                            ];
+        [pItem setTag: i_nTag];
+        [pItem setTarget: pExecute];
+        [pItem setEnabled: YES];
+        [i_pDockMenu addItem: pItem];
+    }
+}
+
+static void appendRecentMenu( NSMenu* i_pMenu, NSMenu* i_pDockMenu, const OUString& i_rTitle )
+{
+    if( ! pRecentDelegate )
+        pRecentDelegate = [[RecentMenuDelegate alloc] init];
+
+    NSMenuItem* pItem = [i_pMenu addItemWithTitle: getAutoreleasedString( i_rTitle )
+                                                   action: @selector(executeMenuItem:)
+                                                   keyEquivalent: @""
+                        ];
+    [pItem setEnabled: YES];
+    NSMenu* pRecentMenu = [[NSMenu alloc] initWithTitle: getAutoreleasedString( i_rTitle ) ];
+
+    // When compiling against 10.6 SDK, we get the warning:
+    // class 'RecentMenuDelegate' does not implement the 'NSMenuDelegate' protocol
+
+    // No idea if that is a bogus warning, or if the way this is
+    // implemented just is so weird that the compiler gets
+    // confused. Anyway, to avoid warnings, instead of this:
+    // [pRecentMenu setDelegate: pRecentDelegate];
+    // do this:
+    reinterpret_cast<id (*)(id, SEL, ...)>(objc_msgSend)(
+        pRecentMenu, @selector(setDelegate:), pRecentDelegate);
+
+    [pRecentMenu setAutoenablesItems: NO];
+    [pItem setSubmenu: pRecentMenu];
+
+    if( i_pDockMenu )
+    {
+        // create a similar entry in the dock menu
+        pItem = [i_pDockMenu addItemWithTitle: getAutoreleasedString( i_rTitle )
+                             action: @selector(executeMenuItem:)
+                             keyEquivalent: @""
+                        ];
+        [pItem setEnabled: YES];
+        pRecentMenu = [[NSMenu alloc] initWithTitle: getAutoreleasedString( i_rTitle ) ];
+
+        // See above
+        // [pRecentMenu setDelegate: pRecentDelegate];
+        reinterpret_cast<id (*)(id, SEL, ...)>(objc_msgSend)(
+            pRecentMenu, @selector(setDelegate:), pRecentDelegate);
+
+        [pRecentMenu setAutoenablesItems: NO];
+        [pItem setSubmenu: pRecentMenu];
+    }
+}
+
+
+extern "C"
+{
+
+void aqua_init_systray()
+{
+    SolarMutexGuard aGuard;
+
+    ShutdownIcon *pShutdownIcon = ShutdownIcon::getInstance();
+    if( ! pShutdownIcon )
+        return;
+
+    // disable shutdown
+    pShutdownIcon->SetVeto( true );
+    ShutdownIcon::addTerminateListener();
+
+    if( ! pDefMenu )
+    {
+        if( [NSApp respondsToSelector: @selector(addFallbackMenuItem:)] )
+        {
+            aShortcuts.clear();
+
+            pExecute = [[QSMenuExecute alloc] init];
+            pDefMenu = [[NSMenuItem alloc] initWithTitle: getAutoreleasedString( SfxResId(STR_QUICKSTART_FILE) ) action: nullptr keyEquivalent: @""];
+            pDockSubMenu = [[NSMenuItem alloc] initWithTitle: getAutoreleasedString( SfxResId(STR_QUICKSTART_FILE) ) action: nullptr keyEquivalent: @""];
+            NSMenu* pMenu = [[NSMenu alloc] initWithTitle: getAutoreleasedString( SfxResId(STR_QUICKSTART_FILE) )];
+            [pMenu setAutoenablesItems: NO];
+            NSMenu* pDockMenu = [[NSMenu alloc] initWithTitle: getAutoreleasedString( SfxResId(STR_QUICKSTART_FILE) )];
+            [pDockMenu setAutoenablesItems: NO];
+
+            // collect the URLs of the entries in the File/New menu
+            SvtModuleOptions    aModuleOptions;
+            std::set< OUString > aFileNewAppsAvailable;
+            SvtDynamicMenuOptions aOpt;
+            css::uno::Sequence < css::uno::Sequence < css::beans::PropertyValue > > const aNewMenu = aOpt.GetMenu( EDynamicMenuType::NewMenu );
+
+            for ( auto const & newMenuProp : aNewMenu )
+            {
+                comphelper::SequenceAsHashMap aEntryItems( newMenuProp );
+                OUString sURL( aEntryItems.getUnpackedValueOrDefault( "URL", OUString() ) );
+                if ( sURL.getLength() )
+                    aFileNewAppsAvailable.insert( sURL );
+            }
+
+            // describe the menu entries for launching the applications
+            struct MenuEntryDescriptor
+            {
+                SvtModuleOptions::EModule   eModuleIdentifier;
+                int                         nMenuTag;
+                const char*                 pAsciiURLDescription;
+            }   aMenuItems[] =
+            {
+                { SvtModuleOptions::EModule::WRITER,    MI_WRITER,  WRITER_URL },
+                { SvtModuleOptions::EModule::CALC,      MI_CALC,    CALC_URL },
+                { SvtModuleOptions::EModule::IMPRESS,   MI_IMPRESS, IMPRESS_WIZARD_URL },
+                { SvtModuleOptions::EModule::DRAW,      MI_DRAW,    DRAW_URL },
+                { SvtModuleOptions::EModule::DATABASE,  MI_BASE,    BASE_URL },
+                { SvtModuleOptions::EModule::MATH,      MI_MATH,    MATH_URL }
+            };
+
+            // insert entry for startcenter
+            if( aModuleOptions.IsModuleInstalled( SvtModuleOptions::EModule::STARTMODULE ) )
+            {
+                appendMenuItem( pMenu, nil, SfxResId(STR_QUICKSTART_STARTCENTER), MI_STARTMODULE, "n" );
+                if( [NSApp respondsToSelector: @selector(setDockIconClickHandler:)] )
+                    [NSApp performSelector:@selector(setDockIconClickHandler:) withObject: pExecute];
+                else
+                    OSL_FAIL( "setDockIconClickHandler selector failed on NSApp" );
+
+            }
+
+            // insert the menu entries for launching the applications
+            for ( size_t i = 0; i < SAL_N_ELEMENTS( aMenuItems ); ++i )
+            {
+                if ( !aModuleOptions.IsModuleInstalled( aMenuItems[i].eModuleIdentifier ) )
+                    // the complete application is not even installed
+                    continue;
+
+                OUString sURL( OUString::createFromAscii( aMenuItems[i].pAsciiURLDescription ) );
+
+                if ( aFileNewAppsAvailable.find( sURL ) == aFileNewAppsAvailable.end() )
+                    // the application is installed, but the entry has been configured to *not* appear in the File/New
+                    // menu => also let not appear it in the quickstarter
+                    continue;
+
+                OUString aKeyEquiv( getShortCut( ShutdownIcon::GetUrlDescription( sURL ) ) );
+
+                appendMenuItem( pMenu, pDockMenu, ShutdownIcon::GetUrlDescription( sURL ), aMenuItems[i].nMenuTag, aKeyEquiv );
+            }
+
+            // insert the remaining menu entries
+
+            // add recent menu
+            appendRecentMenu( pMenu, pDockMenu, SfxResId(STR_QUICKSTART_RECENTDOC) );
+
+            OUString aTitle( SfxResId(STR_QUICKSTART_FROMTEMPLATE) );
+            OUString aKeyEquiv( getShortCut( aTitle ) );
+            appendMenuItem( pMenu, pDockMenu, aTitle, MI_TEMPLATE, aKeyEquiv );
+            aTitle = SfxResId(STR_QUICKSTART_FILEOPEN);
+            aKeyEquiv = getShortCut( aTitle );
+            appendMenuItem( pMenu, pDockMenu, aTitle, MI_OPEN, aKeyEquiv );
+
+            [pDefMenu setSubmenu: pMenu];
+            [NSApp performSelector:@selector(addFallbackMenuItem:) withObject: pDefMenu];
+
+            if( [NSApp respondsToSelector: @selector(addDockMenuItem:)] )
+            {
+                [pDockSubMenu setSubmenu: pDockMenu];
+                // add the submenu
+                [NSApp performSelector:@selector(addDockMenuItem:) withObject: pDockSubMenu];
+            }
+            else
+                OSL_FAIL( "addDockMenuItem selector failed on NSApp" );
+        }
+        else
+            OSL_FAIL( "addFallbackMenuItem selector failed on NSApp" );
+    }
+}
+
+void SAL_DLLPUBLIC_EXPORT aqua_shutdown_systray()
+{
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/shutdowniconw32.cxx b/sfx2/source/appl/shutdowniconw32.cxx
new file mode 100644
index 000000000..2540b2c79
--- /dev/null
+++ b/sfx2/source/appl/shutdowniconw32.cxx
@@ -0,0 +1,811 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/macros.h>
+#include <sal/log.hxx>
+
+#include <unotools/moduleoptions.hxx>
+#include <unotools/dynamicmenuoptions.hxx>
+
+#undef WB_LEFT
+#undef WB_RIGHT
+
+#include "shutdownicon.hxx"
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/strings.hrc>
+#include <shlobj.h>
+#include <objidl.h>
+#include <osl/thread.h>
+#include <systools/win32/qswin32.h>
+#include <comphelper/sequenceashashmap.hxx>
+#include <o3tl/char16_t2wchar_t.hxx>
+
+#include <set>
+
+using namespace ::osl;
+
+using ::com::sun::star::uno::Sequence;
+using ::com::sun::star::beans::PropertyValue;
+
+
+#define EXECUTER_WINDOWCLASS    L"SO Executer Class"
+#define EXECUTER_WINDOWNAME     L"SO Executer Window"
+
+
+#define ID_QUICKSTART               1
+#define IDM_EXIT                    2
+#define IDM_OPEN                    3
+#define IDM_WRITER                  4
+#define IDM_CALC                    5
+#define IDM_IMPRESS                 6
+#define IDM_DRAW                    7
+#define IDM_BASE                    8
+#define IDM_TEMPLATE                9
+#define IDM_MATH                    12
+#define IDM_INSTALL                 10
+#define IDM_STARTCENTER             14
+
+
+#define ICON_LO_DEFAULT                 1
+#define ICON_TEXT_DOCUMENT              2
+#define ICON_SPREADSHEET_DOCUMENT       4
+#define ICON_DRAWING_DOCUMENT           6
+#define ICON_PRESENTATION_DOCUMENT      8
+#define ICON_TEMPLATE                   11
+#define ICON_DATABASE_DOCUMENT          12
+#define ICON_MATH_DOCUMENT              13
+#define ICON_OPEN                       5   // See index of open folder icon in shell32.dll
+
+#define SFX_TASKBAR_NOTIFICATION    WM_USER+1
+
+static HWND  aListenerWindow = nullptr;
+static HWND  aExecuterWindow = nullptr;
+static HMENU popupMenu = nullptr;
+
+static void OnMeasureItem(HWND hwnd, LPMEASUREITEMSTRUCT lpmis);
+static void OnDrawItem(HWND hwnd, LPDRAWITEMSTRUCT lpdis);
+
+namespace {
+
+typedef struct tagMYITEM
+{
+    OUString text;
+    OUString module;
+    UINT iconId;
+} MYITEM;
+
+}
+
+static void addMenuItem( HMENU hMenu, UINT id, UINT iconId, const OUString& text, int& pos, bool bOwnerdraw, const OUString& module )
+{
+    MENUITEMINFOW mi = {};
+
+    mi.cbSize = sizeof( mi );
+    if( id == static_cast<UINT>( -1 ) )
+    {
+        mi.fMask=MIIM_TYPE;
+        mi.fType=MFT_SEPARATOR;
+    }
+    else
+    {
+        if( bOwnerdraw )
+        {
+            mi.fMask=MIIM_TYPE | MIIM_STATE | MIIM_ID | MIIM_DATA;
+            mi.fType=MFT_OWNERDRAW;
+            mi.fState=MFS_ENABLED;
+            mi.wID = id;
+
+            MYITEM *pMyItem = new MYITEM;
+            pMyItem->text = text;
+            pMyItem->iconId = iconId;
+            pMyItem->module = module;
+            mi.dwItemData = reinterpret_cast<DWORD_PTR>(pMyItem);
+        }
+        else
+        {
+            mi.fMask=MIIM_TYPE | MIIM_STATE | MIIM_ID | MIIM_DATA;
+            mi.fType=MFT_STRING;
+            mi.fState=MFS_ENABLED;
+            mi.wID = id;
+            mi.dwTypeData = o3tl::toW(
+                const_cast<sal_Unicode *>(text.getStr()));
+            mi.cch = text.getLength();
+        }
+
+        if ( IDM_TEMPLATE == id )
+            mi.fState |= MFS_DEFAULT;
+    }
+
+    InsertMenuItemW( hMenu, pos++, TRUE, &mi );
+}
+
+
+static HMENU createSystrayMenu( )
+{
+    SvtModuleOptions    aModuleOptions;
+
+    HMENU hMenu = CreatePopupMenu();
+    int pos=0;
+
+    ShutdownIcon *pShutdownIcon = ShutdownIcon::getInstance();
+    OSL_ENSURE( pShutdownIcon, "ShutdownIcon instance empty!");
+
+    if( !pShutdownIcon )
+        return nullptr;
+
+    // collect the URLs of the entries in the File/New menu
+    ::std::set< OUString > aFileNewAppsAvailable;
+    SvtDynamicMenuOptions aOpt;
+    Sequence < Sequence < PropertyValue > > const aNewMenu = aOpt.GetMenu( EDynamicMenuType::NewMenu );
+    const OUString sURLKey( "URL"  );
+
+    for ( auto const & newMenuProp : aNewMenu )
+    {
+        ::comphelper::SequenceAsHashMap aEntryItems( newMenuProp );
+        OUString sURL( aEntryItems.getUnpackedValueOrDefault( sURLKey, OUString() ) );
+        if ( sURL.getLength() )
+            aFileNewAppsAvailable.insert( sURL );
+    }
+
+    // describe the menu entries for launching the applications
+    struct MenuEntryDescriptor
+    {
+        SvtModuleOptions::EModule   eModuleIdentifier;
+        UINT                        nMenuItemID;
+        UINT                        nMenuIconID;
+        const char*                 pAsciiURLDescription;
+    }   aMenuItems[] =
+    {
+        { SvtModuleOptions::EModule::WRITER,    IDM_WRITER, ICON_TEXT_DOCUMENT,         WRITER_URL },
+        { SvtModuleOptions::EModule::CALC,      IDM_CALC,   ICON_SPREADSHEET_DOCUMENT,  CALC_URL },
+        { SvtModuleOptions::EModule::IMPRESS,   IDM_IMPRESS,ICON_PRESENTATION_DOCUMENT, IMPRESS_WIZARD_URL },
+        { SvtModuleOptions::EModule::DRAW,      IDM_DRAW,   ICON_DRAWING_DOCUMENT,      DRAW_URL },
+        { SvtModuleOptions::EModule::DATABASE,  IDM_BASE,   ICON_DATABASE_DOCUMENT,     BASE_URL },
+        { SvtModuleOptions::EModule::MATH,      IDM_MATH,   ICON_MATH_DOCUMENT,         MATH_URL },
+    };
+
+    // insert the menu entries for launching the applications
+    for ( size_t i = 0; i < SAL_N_ELEMENTS(aMenuItems); ++i )
+    {
+        if ( !aModuleOptions.IsModuleInstalled( aMenuItems[i].eModuleIdentifier ) )
+            // the complete application is not even installed
+            continue;
+
+        OUString sURL( OUString::createFromAscii( aMenuItems[i].pAsciiURLDescription ) );
+
+        if ( aFileNewAppsAvailable.find( sURL ) == aFileNewAppsAvailable.end() )
+            // the application is installed, but the entry has been configured to *not* appear in the File/New
+            // menu => also let not appear it in the quickstarter
+            continue;
+
+        addMenuItem( hMenu, aMenuItems[i].nMenuItemID, aMenuItems[i].nMenuIconID,
+            ShutdownIcon::GetUrlDescription( sURL ), pos, true, "" );
+    }
+
+
+    // insert the remaining menu entries
+    addMenuItem( hMenu, IDM_TEMPLATE, ICON_TEMPLATE,
+        SfxResId( STR_QUICKSTART_FROMTEMPLATE ), pos, true, "");
+    addMenuItem( hMenu, static_cast< UINT >( -1 ), 0, OUString(), pos, false, "" );
+    addMenuItem( hMenu, IDM_OPEN,   ICON_OPEN, SfxResId(STR_QUICKSTART_FILEOPEN), pos, true, "SHELL32");
+    addMenuItem( hMenu, static_cast< UINT >( -1 ), 0, OUString(), pos, false, "" );
+    addMenuItem( hMenu, IDM_INSTALL,0, SfxResId(STR_QUICKSTART_PRELAUNCH), pos, false, "" );
+    addMenuItem( hMenu, static_cast< UINT >( -1 ), 0, OUString(), pos, false, "" );
+    addMenuItem( hMenu, IDM_EXIT,   0, SfxResId(STR_QUICKSTART_EXIT), pos, false, "" );
+
+    // indicate status of autostart folder
+    CheckMenuItem( hMenu, IDM_INSTALL, MF_BYCOMMAND | (ShutdownIcon::GetAutostart() ? MF_CHECKED : MF_UNCHECKED) );
+
+    return hMenu;
+}
+
+
+static void deleteSystrayMenu( HMENU hMenu )
+{
+    if( !hMenu || !IsMenu( hMenu ))
+        return;
+
+    MENUITEMINFOW mi = {};
+    int pos=0;
+    mi.cbSize = sizeof( mi );
+    mi.fMask = MIIM_DATA;
+
+    while( GetMenuItemInfoW( hMenu, pos++, true, &mi ) )
+    {
+        MYITEM *pMyItem = reinterpret_cast<MYITEM*>(mi.dwItemData);
+        if( pMyItem )
+        {
+            pMyItem->text.clear();
+            delete pMyItem;
+        }
+        mi.fMask = MIIM_DATA;
+    }
+}
+
+
+static void addTaskbarIcon( HWND hWnd )
+{
+    OUString strTip = SfxResId(STR_QUICKSTART_TIP);
+
+    // add taskbar icon
+    NOTIFYICONDATAW nid;
+    nid.hIcon = static_cast<HICON>(LoadImageW( GetModuleHandleW( nullptr ), MAKEINTRESOURCEW( ICON_LO_DEFAULT ),
+        IMAGE_ICON, GetSystemMetrics( SM_CXSMICON ), GetSystemMetrics( SM_CYSMICON ),
+        LR_DEFAULTCOLOR | LR_SHARED ));
+
+    wcsncpy( nid.szTip, o3tl::toW(strTip.getStr()), 64 );
+
+    nid.cbSize              = sizeof(nid);
+    nid.hWnd                = hWnd;
+    nid.uID                 = ID_QUICKSTART;
+    nid.uCallbackMessage    = SFX_TASKBAR_NOTIFICATION;
+    nid.uFlags              = NIF_MESSAGE|NIF_TIP|NIF_ICON;
+
+    Shell_NotifyIconW(NIM_ADD, &nid);
+}
+
+
+static LRESULT CALLBACK listenerWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    static UINT s_uTaskbarRestart = 0;
+    static UINT s_uMsgKillTray = 0;
+
+    switch (uMsg)
+    {
+        case WM_NCCREATE:
+            return TRUE;
+        case WM_CREATE:
+            {
+                // request notification when taskbar is recreated
+                // we then have to add our icon again
+                s_uTaskbarRestart = RegisterWindowMessageW(L"TaskbarCreated");
+                s_uMsgKillTray = RegisterWindowMessageW( SHUTDOWN_QUICKSTART_MESSAGE );
+
+                // create the menu
+                if( !popupMenu )
+                    if( (popupMenu = createSystrayMenu( )) == nullptr )
+                        return -1;
+
+                // and the icon
+                addTaskbarIcon( hWnd );
+
+                // disable shutdown
+                ShutdownIcon::getInstance()->SetVeto( true );
+                ShutdownIcon::addTerminateListener();
+            }
+            return 0;
+
+        case WM_MEASUREITEM:
+            OnMeasureItem(hWnd, reinterpret_cast<LPMEASUREITEMSTRUCT>(lParam));
+            return TRUE;
+
+        case WM_DRAWITEM:
+            OnDrawItem(hWnd, reinterpret_cast<LPDRAWITEMSTRUCT>(lParam));
+            return TRUE;
+
+        case SFX_TASKBAR_NOTIFICATION:
+            switch( lParam )
+            {
+                case WM_LBUTTONDOWN:
+                {
+                    bool const ret = PostMessageW(aExecuterWindow, WM_COMMAND, IDM_STARTCENTER, reinterpret_cast<LPARAM>(hWnd));
+                    SAL_WARN_IF(!ret, "sfx.appl", "ERROR: PostMessage() failed!");
+                    break;
+                }
+
+                case WM_RBUTTONDOWN:
+                {
+                    POINT pt;
+                    GetCursorPos(&pt);
+                    SetForegroundWindow( hWnd );
+
+                    // update status before showing menu, could have been changed from option page
+                    CheckMenuItem( popupMenu, IDM_INSTALL, MF_BYCOMMAND| (ShutdownIcon::GetAutostart() ? MF_CHECKED : MF_UNCHECKED) );
+
+                    EnableMenuItem( popupMenu, IDM_EXIT, MF_BYCOMMAND | (ShutdownIcon::bModalMode ? MF_GRAYED : MF_ENABLED) );
+                    EnableMenuItem( popupMenu, IDM_OPEN, MF_BYCOMMAND | (ShutdownIcon::bModalMode ? MF_GRAYED : MF_ENABLED) );
+                    EnableMenuItem( popupMenu, IDM_TEMPLATE, MF_BYCOMMAND | (ShutdownIcon::bModalMode ? MF_GRAYED : MF_ENABLED) );
+                    int m = TrackPopupMenuEx( popupMenu, TPM_RETURNCMD|TPM_LEFTALIGN|TPM_RIGHTBUTTON,
+                                              pt.x, pt.y, hWnd, nullptr );
+                    bool const ret = PostMessageW( hWnd, 0, 0, 0 );
+                    SAL_WARN_IF(!ret, "sfx.appl", "ERROR: PostMessage() failed!");
+                    switch( m )
+                    {
+                        case IDM_OPEN:
+                        case IDM_WRITER:
+                        case IDM_CALC:
+                        case IDM_IMPRESS:
+                        case IDM_DRAW:
+                        case IDM_TEMPLATE:
+                        case IDM_BASE:
+                        case IDM_MATH:
+                            break;
+                        case IDM_INSTALL:
+                            CheckMenuItem( popupMenu, IDM_INSTALL, MF_BYCOMMAND| (ShutdownIcon::GetAutostart() ? MF_CHECKED : MF_UNCHECKED) );
+                            break;
+                        case IDM_EXIT:
+                            // delete taskbar icon
+                            NOTIFYICONDATAW nid;
+                            nid.cbSize=sizeof(nid);
+                            nid.hWnd = hWnd;
+                            nid.uID = ID_QUICKSTART;
+                            Shell_NotifyIconW(NIM_DELETE, &nid);
+                            break;
+                    }
+
+                    bool const ret2 = PostMessageW(aExecuterWindow, WM_COMMAND, m, reinterpret_cast<LPARAM>(hWnd));
+                    SAL_WARN_IF(!ret2, "sfx.appl", "ERROR: PostMessage() failed!");
+                }
+                break;
+            }
+            break;
+        case WM_DESTROY:
+            deleteSystrayMenu( popupMenu );
+            // We don't need the Systray Thread anymore
+            PostQuitMessage( 0 );
+            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
+        default:
+            if( uMsg == s_uTaskbarRestart )
+            {
+                // re-create taskbar icon
+                addTaskbarIcon( hWnd );
+            }
+            else if ( uMsg == s_uMsgKillTray )
+            {
+                // delete taskbar icon
+                NOTIFYICONDATAW nid;
+                nid.cbSize=sizeof(nid);
+                nid.hWnd = hWnd;
+                nid.uID = ID_QUICKSTART;
+                Shell_NotifyIconW(NIM_DELETE, &nid);
+
+                bool const ret = PostMessageW(aExecuterWindow, WM_COMMAND, IDM_EXIT, reinterpret_cast<LPARAM>(hWnd));
+                SAL_WARN_IF(!ret, "sfx.appl", "ERROR: PostMessage() failed!");
+            }
+            else
+                return DefWindowProcW(hWnd, uMsg, wParam, lParam);
+    }
+    return 0;
+}
+
+
+static LRESULT CALLBACK executerWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    switch (uMsg)
+    {
+        case WM_NCCREATE:
+            return TRUE;
+        case WM_CREATE:
+            return 0;
+
+        case WM_COMMAND:
+            switch( LOWORD(wParam) )
+            {
+                case IDM_OPEN:
+                    if ( !ShutdownIcon::bModalMode )
+                        ShutdownIcon::FileOpen();
+                break;
+                case IDM_WRITER:
+                    ShutdownIcon::OpenURL( WRITER_URL, "_default" );
+                break;
+                case IDM_CALC:
+                    ShutdownIcon::OpenURL( CALC_URL, "_default" );
+                break;
+                case IDM_IMPRESS:
+                    ShutdownIcon::OpenURL( IMPRESS_WIZARD_URL, "_default" );
+                break;
+                case IDM_DRAW:
+                    ShutdownIcon::OpenURL( DRAW_URL, "_default" );
+                break;
+                case IDM_BASE:
+                    ShutdownIcon::OpenURL( BASE_URL, "_default" );
+                break;
+                case IDM_MATH:
+                    ShutdownIcon::OpenURL( MATH_URL, "_default" );
+                break;
+                case IDM_STARTCENTER:
+                    ShutdownIcon::OpenURL( STARTMODULE_URL, "_default" );
+                break;
+                case IDM_TEMPLATE:
+                    if ( !ShutdownIcon::bModalMode )
+                        ShutdownIcon::FromTemplate();
+                break;
+                case IDM_INSTALL:
+                    ShutdownIcon::SetAutostart( !ShutdownIcon::GetAutostart() );
+                    break;
+                case IDM_EXIT:
+                    // remove listener and
+                    //  terminate office if running in background
+                    if ( !ShutdownIcon::bModalMode )
+                        ShutdownIcon::terminateDesktop();
+                    break;
+            }
+            break;
+        case WM_DESTROY:
+        default:
+            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
+    }
+    return 0;
+}
+
+
+static DWORD WINAPI SystrayThread( LPVOID /*lpParam*/ )
+{
+    osl_setThreadName("SystrayThread");
+
+    aListenerWindow = CreateWindowExW(0,
+        QUICKSTART_CLASSNAME,        // registered class name
+        QUICKSTART_WINDOWNAME,       // window name
+        0,                           // window style
+        CW_USEDEFAULT,               // horizontal position of window
+        CW_USEDEFAULT,               // vertical position of window
+        CW_USEDEFAULT,               // window width
+        CW_USEDEFAULT,               // window height
+        nullptr,                     // handle to parent or owner window
+        nullptr,                     // menu handle or child identifier
+        GetModuleHandleW( nullptr ), // handle to application instance
+        nullptr                      // window-creation data
+        );
+
+    MSG msg;
+
+    while ( GetMessageW( &msg, nullptr, 0, 0 ) )
+    {
+        TranslateMessage( &msg );
+        DispatchMessageW( &msg );
+    }
+
+    return msg.wParam; // Exit code of WM_QUIT
+}
+
+
+void win32_init_sys_tray()
+{
+    if ( ShutdownIcon::IsQuickstarterInstalled() )
+    {
+        WNDCLASSEXW listenerClass;
+        listenerClass.cbSize        = sizeof(listenerClass);
+        listenerClass.style         = 0;
+        listenerClass.lpfnWndProc   = listenerWndProc;
+        listenerClass.cbClsExtra    = 0;
+        listenerClass.cbWndExtra    = 0;
+        listenerClass.hInstance     = GetModuleHandleW( nullptr );
+        listenerClass.hIcon         = nullptr;
+        listenerClass.hCursor       = nullptr;
+        listenerClass.hbrBackground = nullptr;
+        listenerClass.lpszMenuName  = nullptr;
+        listenerClass.lpszClassName = QUICKSTART_CLASSNAME;
+        listenerClass.hIconSm       = nullptr;
+
+        RegisterClassExW(&listenerClass);
+
+        WNDCLASSEXW executerClass;
+        executerClass.cbSize        = sizeof(executerClass);
+        executerClass.style         = 0;
+        executerClass.lpfnWndProc   = executerWndProc;
+        executerClass.cbClsExtra    = 0;
+        executerClass.cbWndExtra    = 0;
+        executerClass.hInstance     = GetModuleHandleW( nullptr );
+        executerClass.hIcon         = nullptr;
+        executerClass.hCursor       = nullptr;
+        executerClass.hbrBackground = nullptr;
+        executerClass.lpszMenuName  = nullptr;
+        executerClass.lpszClassName = EXECUTER_WINDOWCLASS;
+        executerClass.hIconSm       = nullptr;
+
+        RegisterClassExW( &executerClass );
+
+        aExecuterWindow = CreateWindowExW(0,
+            EXECUTER_WINDOWCLASS,        // registered class name
+            EXECUTER_WINDOWNAME,         // window name
+            0,                           // window style
+            CW_USEDEFAULT,               // horizontal position of window
+            CW_USEDEFAULT,               // vertical position of window
+            CW_USEDEFAULT,               // window width
+            CW_USEDEFAULT,               // window height
+            nullptr,                     // handle to parent or owner window
+            nullptr,                     // menu handle or child identifier
+            GetModuleHandleW( nullptr ), // handle to application instance
+            nullptr                      // window-creation data
+            );
+
+        DWORD   dwThreadId;
+        CloseHandle(CreateThread(nullptr, 0, SystrayThread, nullptr, 0, &dwThreadId));
+    }
+}
+
+
+void win32_shutdown_sys_tray()
+{
+    if ( ShutdownIcon::IsQuickstarterInstalled() )
+    {
+        if( IsWindow( aListenerWindow ) )
+        {
+            DestroyWindow( aListenerWindow );
+            aListenerWindow = nullptr;
+            DestroyWindow( aExecuterWindow );
+            aExecuterWindow = nullptr;
+        }
+        UnregisterClassW( QUICKSTART_CLASSNAME, GetModuleHandleW( nullptr ) );
+        UnregisterClassW( EXECUTER_WINDOWCLASS, GetModuleHandleW( nullptr ) );
+    }
+}
+
+
+void OnMeasureItem(HWND hwnd, LPMEASUREITEMSTRUCT lpmis)
+{
+    MYITEM *pMyItem = reinterpret_cast<MYITEM *>(lpmis->itemData);
+    HDC hdc = GetDC(hwnd);
+    SIZE size;
+
+    NONCLIENTMETRICSW ncm = {};
+    ncm.cbSize = sizeof(ncm);
+
+    SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
+
+    // Assume every menu item can be default and printed bold
+    ncm.lfMenuFont.lfWeight = FW_BOLD;
+
+    HFONT hfntOld = static_cast<HFONT>(SelectObject(hdc, CreateFontIndirectW( &ncm.lfMenuFont )));
+
+    GetTextExtentPoint32W(hdc, o3tl::toW(pMyItem->text.getStr()),
+            pMyItem->text.getLength(), &size);
+
+    lpmis->itemWidth = size.cx + 4 + GetSystemMetrics( SM_CXSMICON );
+    lpmis->itemHeight = std::max<int>(size.cy, GetSystemMetrics( SM_CYSMICON ));
+    lpmis->itemHeight += 4;
+
+    DeleteObject( SelectObject(hdc, hfntOld) );
+    ReleaseDC(hwnd, hdc);
+}
+
+void OnDrawItem(HWND /*hwnd*/, LPDRAWITEMSTRUCT lpdis)
+{
+    MYITEM *pMyItem = reinterpret_cast<MYITEM *>(lpdis->itemData);
+    COLORREF clrPrevText, clrPrevBkgnd;
+    HFONT hfntOld;
+    HBRUSH hbrOld;
+    int x, y;
+    bool    fSelected = lpdis->itemState & ODS_SELECTED;
+    bool    fDisabled = lpdis->itemState & (ODS_DISABLED | ODS_GRAYED);
+
+    // Set the appropriate foreground and background colors.
+
+    RECT aRect = lpdis->rcItem;
+
+    clrPrevBkgnd = SetBkColor( lpdis->hDC, GetSysColor(COLOR_MENU) );
+
+    if ( fDisabled )
+        clrPrevText = SetTextColor( lpdis->hDC, GetSysColor( COLOR_GRAYTEXT ) );
+    else
+        clrPrevText = SetTextColor( lpdis->hDC, GetSysColor( fSelected ? COLOR_HIGHLIGHTTEXT : COLOR_MENUTEXT ) );
+
+    if ( fSelected )
+        clrPrevBkgnd = SetBkColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHT) );
+    else
+        clrPrevBkgnd = SetBkColor( lpdis->hDC, GetSysColor(COLOR_MENU) );
+
+    hbrOld = static_cast<HBRUSH>(SelectObject( lpdis->hDC, CreateSolidBrush( GetBkColor( lpdis->hDC ) ) ));
+
+    // Fill background
+    PatBlt(lpdis->hDC, aRect.left, aRect.top, aRect.right-aRect.left, aRect.bottom-aRect.top, PATCOPY);
+
+    int height = aRect.bottom-aRect.top;
+
+    x = aRect.left;
+    y = aRect.top;
+
+    int     cx = GetSystemMetrics( SM_CXSMICON );
+    int     cy = GetSystemMetrics( SM_CYSMICON );
+    HICON   hIcon( nullptr );
+    HMODULE hModule( GetModuleHandleW( nullptr ) );
+
+    if ( pMyItem->module.getLength() > 0 )
+    {
+        LPCWSTR pModuleName = o3tl::toW( pMyItem->module.getStr() );
+        hModule = GetModuleHandleW( pModuleName );
+        if ( hModule == nullptr )
+        {
+            hModule = LoadLibraryW(pModuleName);
+        }
+    }
+
+    hIcon = static_cast<HICON>(LoadImageW( hModule, MAKEINTRESOURCEW( pMyItem->iconId ),
+                                IMAGE_ICON, cx, cy,
+                                LR_DEFAULTCOLOR | LR_SHARED ));
+
+
+    HBRUSH hbrIcon = CreateSolidBrush( GetSysColor( COLOR_GRAYTEXT ) );
+
+    DrawStateW( lpdis->hDC, hbrIcon, nullptr, reinterpret_cast<LPARAM>(hIcon), WPARAM(0), x, y+(height-cy)/2, 0, 0, DST_ICON | (fDisabled ? (fSelected ? DSS_MONO : DSS_DISABLED) : DSS_NORMAL) );
+
+    DeleteObject( hbrIcon );
+
+    x += cx + 4;    // space for icon
+    aRect.left = x;
+
+    NONCLIENTMETRICSW ncm = {};
+    ncm.cbSize = sizeof(ncm);
+
+    SystemParametersInfoW(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
+
+    // Print default menu entry with bold font
+    if ( lpdis->itemState & ODS_DEFAULT )
+        ncm.lfMenuFont.lfWeight = FW_BOLD;
+
+    hfntOld = static_cast<HFONT>(SelectObject(lpdis->hDC, CreateFontIndirectW( &ncm.lfMenuFont )));
+
+
+    SIZE    size;
+    GetTextExtentPointW( lpdis->hDC, o3tl::toW(pMyItem->text.getStr()), pMyItem->text.getLength(), &size );
+
+    DrawStateW( lpdis->hDC, nullptr, nullptr, reinterpret_cast<LPARAM>(pMyItem->text.getStr()), WPARAM(0), aRect.left, aRect.top + (height - size.cy)/2, 0, 0, DST_TEXT | (fDisabled && !fSelected ? DSS_DISABLED : DSS_NORMAL) );
+
+    // Restore the original font and colors.
+    DeleteObject( SelectObject( lpdis->hDC, hbrOld ) );
+    DeleteObject( SelectObject( lpdis->hDC, hfntOld) );
+    SetTextColor(lpdis->hDC, clrPrevText);
+    SetBkColor(lpdis->hDC, clrPrevBkgnd);
+}
+
+
+// code from setup2 project
+
+
+static void SHFree_( void *pv )
+{
+    IMalloc *pMalloc;
+    if( NOERROR == SHGetMalloc(&pMalloc) )
+    {
+        pMalloc->Free( pv );
+        pMalloc->Release();
+    }
+}
+
+#define ALLOC(type, n) static_cast<type *>(HeapAlloc(GetProcessHeap(), 0, sizeof(type) * n ))
+#define FREE(p) HeapFree(GetProcessHeap(), 0, p)
+
+static OUString SHGetSpecialFolder( int nFolderID )
+{
+
+    LPITEMIDLIST    pidl;
+    HRESULT         hHdl = SHGetSpecialFolderLocation( nullptr, nFolderID, &pidl );
+    OUString        aFolder;
+
+    if( hHdl == NOERROR )
+    {
+        WCHAR *lpFolderA;
+        lpFolderA = ALLOC( WCHAR, 16000 );
+
+        SHGetPathFromIDListW( pidl, lpFolderA );
+        aFolder = o3tl::toU( lpFolderA );
+
+        FREE( lpFolderA );
+        SHFree_( pidl );
+    }
+    return aFolder;
+}
+
+OUString ShutdownIcon::GetAutostartFolderNameW32()
+{
+    return SHGetSpecialFolder(CSIDL_STARTUP);
+}
+
+static HRESULT WINAPI SHCoCreateInstance( LPVOID lpszReserved, REFCLSID clsid, LPUNKNOWN pUnkUnknown, REFIID iid, LPVOID *ppv )
+{
+    HRESULT hResult = E_NOTIMPL;
+    HMODULE hModShell = GetModuleHandleW( L"SHELL32" );
+
+    if ( hModShell != nullptr )
+    {
+        typedef HRESULT (WINAPI *SHCoCreateInstance_PROC)( LPVOID lpszReserved, REFCLSID clsid, LPUNKNOWN pUnkUnknwon, REFIID iid, LPVOID *ppv );
+
+        SHCoCreateInstance_PROC lpfnSHCoCreateInstance = reinterpret_cast<SHCoCreateInstance_PROC>(GetProcAddress( hModShell, MAKEINTRESOURCEA(102) ));
+
+        if ( lpfnSHCoCreateInstance )
+            hResult = lpfnSHCoCreateInstance( lpszReserved, clsid, pUnkUnknown, iid, ppv );
+    }
+    return hResult;
+}
+
+static bool CreateShortcut( const OUString& rAbsObject, const OUString& rAbsObjectPath,
+    const OUString& rAbsShortcut, const OUString& rDescription, const OUString& rParameter )
+{
+    HRESULT hres;
+    IShellLinkW* psl;
+    CLSID clsid_ShellLink = CLSID_ShellLink;
+    CLSID clsid_IShellLink = IID_IShellLinkW;
+
+    hres = CoCreateInstance( clsid_ShellLink, nullptr, CLSCTX_INPROC_SERVER,
+                             clsid_IShellLink, reinterpret_cast<void**>(&psl) );
+    if( FAILED(hres) )
+        hres = SHCoCreateInstance( nullptr, clsid_ShellLink, nullptr, clsid_IShellLink, reinterpret_cast<void**>(&psl) );
+
+    if( SUCCEEDED(hres) )
+    {
+        IPersistFile* ppf;
+        psl->SetPath( o3tl::toW(rAbsObject.getStr()) );
+        psl->SetWorkingDirectory( o3tl::toW(rAbsObjectPath.getStr()) );
+        psl->SetDescription( o3tl::toW(rDescription.getStr()) );
+        if( rParameter.getLength() )
+            psl->SetArguments( o3tl::toW(rParameter.getStr()) );
+
+        CLSID clsid_IPersistFile = IID_IPersistFile;
+        hres = psl->QueryInterface( clsid_IPersistFile, reinterpret_cast<void**>(&ppf) );
+
+        if( SUCCEEDED(hres) )
+        {
+            hres = ppf->Save( o3tl::toW(rAbsShortcut.getStr()), TRUE );
+            ppf->Release();
+        } else return false;
+        psl->Release();
+    } else return false;
+    return true;
+}
+
+
+// install/uninstall
+
+static bool FileExistsW( LPCWSTR lpPath )
+{
+    bool    bExists = false;
+    WIN32_FIND_DATAW    aFindData;
+
+    HANDLE  hFind = FindFirstFileW( lpPath, &aFindData );
+
+    if ( INVALID_HANDLE_VALUE != hFind )
+    {
+        bExists = true;
+        FindClose( hFind );
+    }
+
+    return bExists;
+}
+
+bool ShutdownIcon::IsQuickstarterInstalled()
+{
+    wchar_t aPath[_MAX_PATH];
+    GetModuleFileNameW( nullptr, aPath, _MAX_PATH-1);
+
+    OUString aOfficepath( o3tl::toU(aPath) );
+    int i = aOfficepath.lastIndexOf('\\');
+    if( i != -1 )
+        aOfficepath = aOfficepath.copy(0, i);
+
+    OUString quickstartExe(aOfficepath + "\\quickstart.exe");
+
+    return FileExistsW( o3tl::toW(quickstartExe.getStr()) );
+}
+
+void ShutdownIcon::EnableAutostartW32( const OUString &aShortcut )
+{
+    wchar_t aPath[_MAX_PATH];
+    GetModuleFileNameW( nullptr, aPath, _MAX_PATH-1);
+
+    OUString aOfficepath( o3tl::toU(aPath) );
+    int i = aOfficepath.lastIndexOf('\\');
+    if( i != -1 )
+        aOfficepath = aOfficepath.copy(0, i);
+
+    OUString quickstartExe(aOfficepath + "\\quickstart.exe");
+
+    CreateShortcut( quickstartExe, aOfficepath, aShortcut, OUString(), OUString() );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/workwin.cxx b/sfx2/source/appl/workwin.cxx
new file mode 100644
index 000000000..7af0324e9
--- /dev/null
+++ b/sfx2/source/appl/workwin.cxx
@@ -0,0 +1,2454 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_features.h>
+#include <config_feature_desktop.h>
+#include <comphelper/lok.hxx>
+#include <comphelper/processfactory.hxx>
+#include <osl/diagnose.h>
+
+#include <sfx2/docfile.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/app.hxx>
+#include <workwin.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/dockwin.hxx>
+#include <sfx2/viewsh.hxx>
+#include <splitwin.hxx>
+#include <childwinimpl.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/toolbarids.hxx>
+#include <vcl/taskpanelist.hxx>
+#include <vcl/svapp.hxx>
+#include <svl/eitem.hxx>
+#include <tools/svborder.hxx>
+#include <tools/debug.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <com/sun/star/ui/XUIElement.hpp>
+#include <com/sun/star/frame/LayoutManagerEvents.hpp>
+#include <com/sun/star/frame/ModuleManager.hpp>
+#include <com/sun/star/frame/XLayoutManager.hpp>
+#include <com/sun/star/frame/XLayoutManagerEventBroadcaster.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/lang/DisposedException.hpp>
+#include <type_traits>
+#include <unordered_map>
+#include <sfx2/notebookbar/SfxNotebookBar.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+namespace {
+
+struct ResIdToResName
+{
+    ToolbarId   eId;
+    const char* pName;
+};
+
+}
+
+static const ResIdToResName pToolBarResToName[] =
+{
+    { ToolbarId::FullScreenToolbox,       "fullscreenbar"        },
+    { ToolbarId::EnvToolbox,              "standardbar",         },
+    { ToolbarId::SvxTbx_Form_Navigation,  "formsnavigationbar"   },
+    { ToolbarId::SvxTbx_Form_Filter,      "formsfilterbar"       },
+    { ToolbarId::SvxTbx_Text_Control_Attributes, "formtextobjectbar"    },
+    { ToolbarId::SvxTbx_Controls,         "formcontrols"         },
+    { ToolbarId::SvxTbx_FormDesign,       "formdesign"           },
+    { ToolbarId::Math_Toolbox,            "toolbar"              },      //math
+    { ToolbarId::Text_Toolbox_Sc,         "textobjectbar"        },      //calc
+    { ToolbarId::Draw_Objectbar,          "drawobjectbar"        },
+    { ToolbarId::Graphic_Objectbar,       "graphicobjectbar"     },
+    { ToolbarId::Objectbar_Format,        "formatobjectbar"      },
+    { ToolbarId::Objectbar_Preview,       "previewbar"           },
+    { ToolbarId::Objectbar_Tools,         "toolbar"              },      //calc
+    { ToolbarId::Bezier_Toolbox_Sd,       "bezierobjectbar"      },      //draw/impress
+    { ToolbarId::Gluepoints_Toolbox,      "gluepointsobjectbar"  },
+    { ToolbarId::Draw_Graf_Toolbox,       "graphicobjectbar"     },
+    { ToolbarId::Draw_Obj_Toolbox,        "drawingobjectbar"     },      //impress
+    { ToolbarId::Draw_Text_Toolbox_Sd,    "textobjectbar"        },      //impress
+    { ToolbarId::Draw_Toolbox_Sd,         "toolbar"              },      //impress
+    { ToolbarId::Draw_Options_Toolbox,    "optionsbar"           },
+    { ToolbarId::Draw_CommonTask_Toolbox, "commontaskbar"        },
+    { ToolbarId::Graphic_Obj_Toolbox,     "drawingobjectbar"     },      //draw
+    { ToolbarId::Outline_Toolbox,         "outlinetoolbar"       },      //impress
+    { ToolbarId::Slide_Toolbox,           "slideviewtoolbar"     },
+    { ToolbarId::Slide_Obj_Toolbox,       "slideviewobjectbar"   },
+    { ToolbarId::Bezier_Toolbox_Sw,       "bezierobjectbar"      },
+    { ToolbarId::Draw_Toolbox_Sw,         "drawingobjectbar"     },
+    { ToolbarId::Draw_Text_Toolbox_Sw,    "drawtextobjectbar"    },
+    { ToolbarId::Frame_Toolbox,           "frameobjectbar"       },
+    { ToolbarId::Grafik_Toolbox,          "graphicobjectbar"     },
+    { ToolbarId::Num_Toolbox,             "numobjectbar"         },
+    { ToolbarId::Ole_Toolbox,             "oleobjectbar"         },
+    { ToolbarId::Table_Toolbox,           "tableobjectbar"       },
+    { ToolbarId::Text_Toolbox_Sw,         "textobjectbar"        },
+    { ToolbarId::PView_Toolbox,           "previewobjectbar"     },      //writer
+    { ToolbarId::Webtools_Toolbox,        "toolbar"              },      //web
+    { ToolbarId::Webtext_Toolbox,         "textobjectbar"        },
+    { ToolbarId::Tools_Toolbox,           "toolbar"              },      //writer
+    { ToolbarId::Webframe_Toolbox,        "frameobjectbar"       },      //web
+    { ToolbarId::Webgraphic_Toolbox,      "graphicobjectbar"     },
+    { ToolbarId::Webole_Toolbox,          "oleobjectbar"         },
+    { ToolbarId::Basicide_Objectbar,      "macrobar"             },
+    { ToolbarId::Svx_Fontwork_Bar,        "fontworkobjectbar"    },      //global
+    { ToolbarId::Svx_Extrusion_Bar,       "extrusionobjectbar"   },
+    { ToolbarId::FormLayer_Toolbox,       "formsobjectbar"       },
+    { ToolbarId::Module_Toolbox,          "viewerbar"            },      //writer (plugin)
+    { ToolbarId::Objectbar_App,           "viewerbar"            },      //calc   (plugin)
+    { ToolbarId::Draw_Viewer_Toolbox,     "viewerbar"            },      //impress(plugin)
+    { ToolbarId::Draw_Media_Toolbox,      "mediaobjectbar"       },      //draw/impress
+    { ToolbarId::Media_Objectbar,         "mediaobjectbar"       },      //calc
+    { ToolbarId::Media_Toolbox,           "mediaobjectbar"       },      //writer
+    { ToolbarId::None,                           ""                     }
+};
+
+// Sort the Children according their alignment
+// The order corresponds to the enum SfxChildAlignment (->CHILDWIN.HXX).
+
+static constexpr OUStringLiteral g_aLayoutManagerPropName = "LayoutManager";
+
+// Help to make changes to the alignment compatible!
+LayoutManagerListener::LayoutManagerListener(
+    SfxWorkWindow* pWrkWin ) :
+    m_bHasFrame( false ),
+    m_pWrkWin( pWrkWin )
+{
+}
+
+LayoutManagerListener::~LayoutManagerListener()
+{
+}
+
+void LayoutManagerListener::setFrame( const css::uno::Reference< css::frame::XFrame >& xFrame )
+{
+    SolarMutexGuard aGuard;
+    if ( !m_pWrkWin || m_bHasFrame )
+        return;
+
+    m_xFrame    = xFrame;
+    m_bHasFrame = true;
+
+    if ( !xFrame.is() )
+        return;
+
+    css::uno::Reference< css::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
+    css::uno::Reference< css::frame::XLayoutManagerEventBroadcaster > xLayoutManager;
+    if ( !xPropSet.is() )
+        return;
+
+    try
+    {
+        Any aValue = xPropSet->getPropertyValue( g_aLayoutManagerPropName );
+        aValue >>= xLayoutManager;
+
+        if ( xLayoutManager.is() )
+            xLayoutManager->addLayoutManagerEventListener(
+                css::uno::Reference< css::frame::XLayoutManagerListener >(
+                    static_cast< OWeakObject* >( this ), css::uno::UNO_QUERY ));
+
+        xPropSet.set( xLayoutManager, UNO_QUERY );
+        if ( xPropSet.is() )
+        {
+            aValue = xPropSet->getPropertyValue( "LockCount" );
+            aValue >>= m_pWrkWin->m_nLock;
+        }
+    }
+    catch ( css::lang::DisposedException& )
+    {
+    }
+    catch ( const css::uno::RuntimeException& )
+    {
+        throw;
+    }
+    catch ( css::uno::Exception& )
+    {
+    }
+}
+
+
+//  XComponent
+
+void SAL_CALL LayoutManagerListener::addEventListener(
+    const css::uno::Reference< css::lang::XEventListener >& )
+{
+    // do nothing, only internal class
+}
+
+void SAL_CALL LayoutManagerListener::removeEventListener(
+    const css::uno::Reference< css::lang::XEventListener >& )
+{
+    // do nothing, only internal class
+}
+
+void SAL_CALL LayoutManagerListener::dispose()
+{
+    SolarMutexGuard aGuard;
+
+    // reset member
+    m_pWrkWin = nullptr;
+
+    css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame.get(), css::uno::UNO_QUERY );
+    if ( !xFrame.is() )
+        return;
+
+    m_xFrame.clear();
+    m_bHasFrame = false;
+
+    css::uno::Reference< css::beans::XPropertySet > xPropSet( xFrame, css::uno::UNO_QUERY );
+    css::uno::Reference< css::frame::XLayoutManagerEventBroadcaster > xLayoutManager;
+    if ( !xPropSet.is() )
+        return;
+
+    try
+    {
+        css::uno::Any aValue = xPropSet->getPropertyValue( g_aLayoutManagerPropName );
+        aValue >>= xLayoutManager;
+
+        // remove as listener from layout manager
+        if ( xLayoutManager.is() )
+            xLayoutManager->removeLayoutManagerEventListener(
+                css::uno::Reference< css::frame::XLayoutManagerListener >(
+                    static_cast< OWeakObject* >( this ), css::uno::UNO_QUERY ));
+    }
+    catch ( css::lang::DisposedException& )
+    {
+    }
+    catch ( const css::uno::RuntimeException& )
+    {
+        throw;
+    }
+    catch ( css::uno::Exception& )
+    {
+    }
+}
+
+
+//  XEventListener
+
+void SAL_CALL LayoutManagerListener::disposing(
+    const css::lang::EventObject& )
+{
+    SolarMutexGuard aGuard;
+    m_pWrkWin = nullptr;
+    m_bHasFrame = false;
+    m_xFrame.clear();
+}
+
+
+// XLayoutManagerEventListener
+
+void SAL_CALL LayoutManagerListener::layoutEvent(
+    const css::lang::EventObject&,
+    ::sal_Int16                   eLayoutEvent,
+    const css::uno::Any&                        )
+{
+    SolarMutexGuard aGuard;
+    if ( !m_pWrkWin )
+        return;
+
+    if ( eLayoutEvent == css::frame::LayoutManagerEvents::VISIBLE )
+    {
+        m_pWrkWin->MakeVisible_Impl( true );
+        m_pWrkWin->ShowChildren_Impl();
+        m_pWrkWin->ArrangeChildren_Impl();
+    }
+    else if ( eLayoutEvent == css::frame::LayoutManagerEvents::INVISIBLE )
+    {
+        m_pWrkWin->MakeVisible_Impl( false );
+        m_pWrkWin->HideChildren_Impl();
+        m_pWrkWin->ArrangeChildren_Impl();
+    }
+    else if ( eLayoutEvent == css::frame::LayoutManagerEvents::LOCK )
+    {
+        m_pWrkWin->Lock_Impl( true );
+    }
+    else if ( eLayoutEvent == css::frame::LayoutManagerEvents::UNLOCK )
+    {
+        m_pWrkWin->Lock_Impl( false );
+    }
+}
+
+namespace
+{
+    struct ToolbarIdHash
+    {
+        size_t operator()(ToolbarId t) const
+        {
+            typedef std::underlying_type<ToolbarId>::type underlying_type;
+            return std::hash<underlying_type>()(static_cast<underlying_type>(t));
+        }
+    };
+
+    class FilledToolBarResIdToResourceURLMap
+    {
+    private:
+        typedef std::unordered_map<ToolbarId, OUString, ToolbarIdHash> ToolBarResIdToResourceURLMap;
+        ToolBarResIdToResourceURLMap m_aResIdToResourceURLMap;
+    public:
+        FilledToolBarResIdToResourceURLMap()
+        {
+            sal_Int32 nIndex( 0 );
+            while (pToolBarResToName[nIndex].eId != ToolbarId::None)
+            {
+                OUString aResourceURL( OUString::createFromAscii( pToolBarResToName[nIndex].pName ));
+                m_aResIdToResourceURLMap.emplace(pToolBarResToName[nIndex].eId, aResourceURL);
+                ++nIndex;
+            }
+        }
+
+        OUString findURL(ToolbarId eId) const
+        {
+            ToolBarResIdToResourceURLMap::const_iterator aIter = m_aResIdToResourceURLMap.find(eId);
+            if ( aIter != m_aResIdToResourceURLMap.end() )
+                return aIter->second;
+            return OUString();
+        }
+    };
+
+    class theFilledToolBarResIdToResourceURLMap
+        : public rtl::Static<FilledToolBarResIdToResourceURLMap,
+                             theFilledToolBarResIdToResourceURLMap>
+    {
+    };
+}
+
+static OUString GetResourceURLFromToolbarId(ToolbarId eId)
+{
+    return theFilledToolBarResIdToResourceURLMap::get().findURL(eId);
+}
+
+static sal_uInt16 TbxMatch( sal_uInt16 nPos )
+{
+    switch ( nPos )
+    {
+        case SFX_OBJECTBAR_APPLICATION :
+            return 0;
+        case SFX_OBJECTBAR_OPTIONS:
+            return 1;
+        case SFX_OBJECTBAR_MACRO:
+            return 2;
+        case SFX_OBJECTBAR_OBJECT:
+            return 3;
+        case SFX_OBJECTBAR_TOOLS:
+            return 4;
+        case SFX_OBJECTBAR_FULLSCREEN:
+        case SFX_OBJECTBAR_COMMONTASK:
+        case SFX_OBJECTBAR_RECORDING:
+            return nPos+1;
+        default:
+            return nPos;
+    }
+}
+
+static sal_uInt16 ChildAlignValue(SfxChildAlignment eAlign)
+{
+    sal_uInt16 ret = 17;
+
+    switch (eAlign)
+    {
+        case SfxChildAlignment::HIGHESTTOP:
+            ret = 1;
+            break;
+        case SfxChildAlignment::LOWESTBOTTOM:
+            ret = 2;
+            break;
+        case SfxChildAlignment::FIRSTLEFT:
+            ret = 3;
+            break;
+        case SfxChildAlignment::LASTRIGHT:
+            ret = 4;
+            break;
+        case SfxChildAlignment::LEFT:
+            ret = 5;
+            break;
+        case SfxChildAlignment::RIGHT:
+            ret = 6;
+            break;
+        case SfxChildAlignment::FIRSTRIGHT:
+            ret = 7;
+            break;
+        case SfxChildAlignment::LASTLEFT:
+            ret = 8;
+            break;
+        case SfxChildAlignment::TOP:
+            ret = 9;
+            break;
+        case SfxChildAlignment::BOTTOM:
+            ret = 10;
+            break;
+        case SfxChildAlignment::TOOLBOXTOP:
+            ret = 11;
+            break;
+        case SfxChildAlignment::TOOLBOXBOTTOM:
+            ret = 12;
+            break;
+        case SfxChildAlignment::LOWESTTOP:
+            ret = 13;
+            break;
+        case SfxChildAlignment::HIGHESTBOTTOM:
+            ret = 14;
+            break;
+        case SfxChildAlignment::TOOLBOXLEFT:
+            ret = 15;
+            break;
+        case SfxChildAlignment::TOOLBOXRIGHT:
+            ret = 16;
+            break;
+        case SfxChildAlignment::NOALIGNMENT:
+            break;  // -Wall not handled...
+    }
+
+    return ret;
+}
+
+void SfxWorkWindow::Sort_Impl()
+{
+    aSortedList.clear();
+    for (size_t i = 0; i < aChildren.size(); ++i)
+    {
+        SfxChild_Impl *pCli = aChildren[i].get();
+        if (pCli)
+        {
+            decltype(aSortedList)::size_type k;
+            for (k=0; k<aSortedList.size(); k++)
+                if (ChildAlignValue( aChildren[aSortedList[k]]->eAlign ) >
+                    ChildAlignValue(pCli->eAlign))
+                    break;
+            aSortedList.insert( aSortedList.begin() + k, i );
+        }
+    }
+
+    bSorted = true;
+}
+
+static constexpr OUStringLiteral g_aStatusBarResName( "private:resource/statusbar/statusbar" );
+static constexpr OUStringLiteral g_aTbxTypeName( "private:resource/toolbar/" );
+static constexpr OUStringLiteral g_aProgressBarResName( "private:resource/progressbar/progressbar" );
+
+// constructor for workwin of a Frame
+
+SfxWorkWindow::SfxWorkWindow( vcl::Window *pWin, SfxFrame *pFrm, SfxFrame* pMaster ) :
+    pBindings(&pFrm->GetCurrentViewFrame()->GetBindings()),
+    pWorkWin (pWin),
+    pActiveChild( nullptr ),
+    nUpdateMode(SfxVisibilityFlags::Standard),
+    nChildren( 0 ),
+    nOrigMode( SfxVisibilityFlags::Invisible ),
+    bSorted( true ),
+    bDockingAllowed(true),
+    bInternalDockingAllowed(true),
+    bAllChildrenVisible(true),
+#if !defined(ANDROID) || HAVE_FEATURE_ANDROID_LOK
+    bIsFullScreen( false ),
+#else // Fennec-based Android Viewer
+    bIsFullScreen( true ),
+#endif
+#if HAVE_FEATURE_DESKTOP
+    bShowStatusBar( true ),
+#else
+    bShowStatusBar( sal_False ),
+#endif
+    m_nLock( 0 ),
+    pMasterFrame( pMaster ),
+    pFrame( pFrm )
+{
+    DBG_ASSERT (pBindings, "No Bindings!");
+
+    pBindings->SetWorkWindow_Impl( this );
+
+    // For the ObjectBars an integral place in the Childlist is reserved,
+    // so that they always come in a defined order.
+    for (int i=0; i<SFX_OBJECTBAR_MAX; ++i)
+        aChildren.push_back( nullptr );
+
+    // create and initialize layout manager listener
+    Reference< css::frame::XFrame > xFrame = GetFrameInterface();
+    LayoutManagerListener* pLayoutManagerListener = new LayoutManagerListener( this );
+    m_xLayoutManagerListener.set( static_cast< cppu::OWeakObject* >( pLayoutManagerListener ),
+                                  css::uno::UNO_QUERY );
+    pLayoutManagerListener->setFrame( xFrame );
+
+    SfxShell* pConfigShell = pFrm->GetCurrentViewFrame();
+    if ( pConfigShell && pConfigShell->GetObjectShell() )
+    {
+        bShowStatusBar = ( !pConfigShell->GetObjectShell()->IsInPlaceActive() );
+        bDockingAllowed = true;
+        bInternalDockingAllowed = true;
+    }
+
+    // The required split windows (one for each side) can be created
+    for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
+    {
+        // The SplitWindows excludes direct ChildWindows of the WorkWindows
+        // and receives the docked window.
+
+        SfxChildAlignment eAlign =
+                        ( n == SFX_SPLITWINDOWS_LEFT ? SfxChildAlignment::LEFT :
+                            n == SFX_SPLITWINDOWS_RIGHT ? SfxChildAlignment::RIGHT :
+                            n == SFX_SPLITWINDOWS_TOP ? SfxChildAlignment::TOP :
+                                SfxChildAlignment::BOTTOM );
+        VclPtr<SfxSplitWindow> pSplitWin = VclPtr<SfxSplitWindow>::Create(pWorkWin, eAlign, this, true );
+        pSplit[n] = pSplitWin;
+    }
+
+    nOrigMode = SfxVisibilityFlags::Standard;
+    nUpdateMode = SfxVisibilityFlags::Standard;
+}
+
+
+// Destructor
+
+SfxWorkWindow::~SfxWorkWindow()
+{
+
+    // Delete SplitWindows
+    for (VclPtr<SfxSplitWindow> & p : pSplit)
+    {
+        if (p->GetWindowCount())
+            ReleaseChild_Impl(*p);
+        p.disposeAndClear();
+    }
+
+    // Delete help structure for Child-Windows
+    DBG_ASSERT( aChildren.empty(), "dangling children" );
+
+    if ( m_xLayoutManagerListener.is() )
+        m_xLayoutManagerListener->dispose();
+}
+
+void SfxWorkWindow::Lock_Impl( bool bLock )
+{
+    if ( bLock )
+        m_nLock++;
+    else
+        --m_nLock;
+    if ( m_nLock<0 )
+    {
+        OSL_FAIL("Lock count underflow!");
+        assert(m_nLock >= 0);
+        m_nLock = 0;
+    }
+
+    if ( !m_nLock )
+        ArrangeChildren_Impl();
+}
+
+
+// Helper method to release the child lists. Should the destructor not be
+// called after this, instead work continues, then space for the object bars
+// and split windows has to be reserved in the same way as in the constructor
+// of SfxWorkWindow.
+
+void SfxWorkWindow::DeleteControllers_Impl()
+{
+
+    // Lock SplitWindows (which means suppressing the Resize-Reaction of the
+    // DockingWindows)
+    for (size_t n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
+    {
+        VclPtr<SfxSplitWindow> const &p = pSplit[n];
+        if (p->GetWindowCount())
+            p->Lock();
+    }
+
+    // Delete Child-Windows
+    while(!aChildWins.empty())
+    {
+        std::unique_ptr<SfxChildWin_Impl> pCW = std::move(*aChildWins.begin());
+        aChildWins.erase(aChildWins.begin());
+        SfxChildWindow *pChild = pCW->pWin;
+        if (pChild)
+        {
+            if (comphelper::LibreOfficeKit::isActive())
+            {
+                vcl::Window* pWindow = pChild->GetWindow();
+                if (pWindow)
+                {
+                    pWindow->ReleaseLOKNotifier();
+                }
+            }
+            pChild->Hide();
+
+            // If the child window is a direct child window and not in a
+            // SplitWindow, cancel it at the workwindow.
+            // After TH a cancellation on the SplitWindow is not necessary
+            // since this window is also destroyed (see below).
+            if (pCW->pCli)
+            {
+                if (pChild->GetController())
+                    ReleaseChild_Impl(*pChild->GetController());
+                else
+                    ReleaseChild_Impl(*pChild->GetWindow());
+            }
+
+            pCW->pWin = nullptr;
+            pWorkWin->GetSystemWindow()->GetTaskPaneList()->RemoveWindow( pChild->GetWindow() );
+            pChild->Destroy();
+        }
+
+        // ATTENTION: The array itself is cleared after this loop!!
+        // Therefore we have to set every array entry to zero as it could be
+        // accessed by calling pChild->Destroy().
+        // Window::NotifyAllChildren() calls SfxWorkWindow::DataChanged_Impl for
+        // 8-bit displays (WM_QUERYPALETTECHANGED message due to focus change)!!
+    }
+
+    Reference< css::frame::XFrame > xFrame = GetFrameInterface();
+    Reference< css::beans::XPropertySet > xPropSet( xFrame, UNO_QUERY );
+    Reference< css::frame::XLayoutManager > xLayoutManager;
+    if ( xPropSet.is() )
+    {
+        try
+        {
+            Any aValue = xPropSet->getPropertyValue( g_aLayoutManagerPropName );
+            aValue >>= xLayoutManager;
+        }
+        catch ( Exception& )
+        {
+        }
+    }
+
+    if ( xLayoutManager.is() )
+    {
+        xLayoutManager->reset();
+
+        // Delete StatusBar
+        ResetStatusBar_Impl();
+
+        // Delete ObjectBars (this is done last, so that aChildren does not
+        // receive dead Pointers)
+        for (SfxObjectBar_Impl & i : aObjBarList)
+        {
+            // Not every position must be occupied
+            ToolbarId eId = i.eId;
+            if (eId != ToolbarId::None)
+                i.eId = ToolbarId::None;
+        }
+    }
+
+    // ObjectBars are all released at once, since they occupy a
+    // fixed contiguous area in the array pChild
+    aChildren.clear();
+    bSorted = false;
+
+    nChildren = 0;
+}
+
+
+// for placing the child window.
+
+void SfxWorkWindow::ArrangeChildren_Impl( bool bForce )
+{
+    if ( pFrame->IsClosing_Impl() || ( m_nLock && !bForce ))
+        return;
+
+    SfxInPlaceClient *pClient = nullptr;
+    SfxViewFrame *pF = pFrame->GetCurrentViewFrame();
+    if ( pF && pF->GetViewShell() )
+        pClient = pF->GetViewShell()->GetIPClient();
+
+    if ( pClient )
+        return;
+
+    aClientArea = GetTopRect_Impl();
+    if ( aClientArea.IsEmpty() )
+        return;
+
+    SvBorder aBorder;
+    if ( nChildren && IsVisible_Impl() )
+        aBorder = Arrange_Impl();
+    // If the current application document contains an IPClient, then the
+    // object through SetTopToolFramePixel has to be assigned the available
+    // space. The object will then point to its UITools and sets the app border
+    // (-> SfxInPlaceEnv_Impl:: ArrangeChildren_Impl ()). Otherwise the
+    // app border is set here directly to possibly overwrite the Border that
+    // was set by an object from another document.  The object does not set
+    // the SetAppBorder when it removes its UI tools so that no-dithering
+    // ObjectBar arises.
+    // (->SfxInPlaceEnv_Impl::ArrangeChildren_Impl())
+
+    pMasterFrame->SetToolSpaceBorderPixel_Impl( aBorder );
+
+    ArrangeAutoHideWindows( nullptr );
+}
+
+void SfxWorkWindow::FlushPendingChildSizes()
+{
+    // tdf#116865, if any windows are being resized, i.e. their
+    // resize timer is active, then calling GetSizePixel on
+    // them forces the timer to fire and sets the final
+    // size to which they are getting resized towards.
+    for (size_t i = 0; i < aChildren.size(); ++i)
+    {
+        SfxChild_Impl *pCli = aChildren[i].get();
+        if (!pCli || !pCli->pWin)
+            continue;
+        (void)pCli->pWin->GetSizePixel();
+    }
+}
+
+SvBorder SfxWorkWindow::Arrange_Impl()
+
+/*  [Description]
+
+    This method organizes all visible child windows so that the docked window
+    sorted in order from the outside to the inside are placed after one
+    another. If a visible window does not fit anymore into the free
+    ClientArea, it is set to "not visible".
+*/
+{
+    //tdf#116865 trigger pending sizing timers now so we arrange
+    //with the final size of the client area.
+    //
+    //Otherwise calling GetSizePixel in the following loop will trigger the
+    //timers, causing reentry into Arrange_Impl again where the inner
+    //Arrange_Impl arranges with the final size, and then returns to this outer
+    //Arrange_Impl which would rearrange with the old client area size
+    FlushPendingChildSizes();
+    aClientArea = GetTopRect_Impl();
+    aUpperClientArea = aClientArea;
+
+    SvBorder aBorder;
+    if ( !nChildren )
+        return aBorder;
+
+    if (!bSorted)
+        Sort_Impl();
+
+    Point aPos;
+    Size aSize;
+    tools::Rectangle aTmp( aClientArea );
+
+    for (sal_uInt16 n : aSortedList)
+    {
+        SfxChild_Impl* pCli = aChildren[n].get();
+        if ( !pCli->pWin )
+            continue;
+
+        // First, we assume that there is room for the window.
+        pCli->nVisible |= SfxChildVisibility::FITS_IN;
+
+        // Skip invisible windows
+        if (pCli->nVisible != SfxChildVisibility::VISIBLE)
+            continue;
+
+        if ( pCli->bResize )
+            aSize = pCli->aSize;
+        else
+            aSize = pCli->pWin->GetSizePixel();
+
+        SvBorder aTemp = aBorder;
+        bool bAllowHiding = true;
+        switch ( pCli->eAlign )
+        {
+            case SfxChildAlignment::HIGHESTTOP:
+            case SfxChildAlignment::TOP:
+            case SfxChildAlignment::TOOLBOXTOP:
+            case SfxChildAlignment::LOWESTTOP:
+                aSize.setWidth( aTmp.GetWidth() );
+                if ( pCli->pWin->GetType() == WindowType::SPLITWINDOW )
+                    aSize = static_cast<SplitWindow *>(pCli->pWin.get())->CalcLayoutSizePixel( aSize );
+                bAllowHiding = false;
+                aBorder.Top() += aSize.Height();
+                aPos = aTmp.TopLeft();
+                aTmp.AdjustTop(aSize.Height() );
+                if ( pCli->eAlign == SfxChildAlignment::HIGHESTTOP )
+                    aUpperClientArea.AdjustTop(aSize.Height() );
+                break;
+
+            case SfxChildAlignment::LOWESTBOTTOM:
+            case SfxChildAlignment::BOTTOM:
+            case SfxChildAlignment::TOOLBOXBOTTOM:
+            case SfxChildAlignment::HIGHESTBOTTOM:
+                aSize.setWidth( aTmp.GetWidth() );
+                if ( pCli->pWin->GetType() == WindowType::SPLITWINDOW )
+                    aSize = static_cast<SplitWindow *>(pCli->pWin.get())->CalcLayoutSizePixel( aSize );
+                aBorder.Bottom() += aSize.Height();
+                aPos = aTmp.BottomLeft();
+                aPos.AdjustY( -(aSize.Height()-1) );
+                aTmp.AdjustBottom( -(aSize.Height()) );
+                if ( pCli->eAlign == SfxChildAlignment::LOWESTBOTTOM )
+                    aUpperClientArea.AdjustBottom( -(aSize.Height()) );
+                break;
+
+            case SfxChildAlignment::FIRSTLEFT:
+            case SfxChildAlignment::LEFT:
+            case SfxChildAlignment::LASTLEFT:
+            case SfxChildAlignment::TOOLBOXLEFT:
+                aSize.setHeight( aTmp.GetHeight() );
+                if ( pCli->pWin->GetType() == WindowType::SPLITWINDOW )
+                    aSize = static_cast<SplitWindow *>(pCli->pWin.get())->CalcLayoutSizePixel( aSize );
+                bAllowHiding = false;
+                aBorder.Left() += aSize.Width();
+                aPos = aTmp.TopLeft();
+                aTmp.AdjustLeft(aSize.Width() );
+                if ( pCli->eAlign != SfxChildAlignment::TOOLBOXLEFT )
+                    aUpperClientArea.AdjustLeft(aSize.Width() );
+                break;
+
+            case SfxChildAlignment::FIRSTRIGHT:
+            case SfxChildAlignment::RIGHT:
+            case SfxChildAlignment::LASTRIGHT:
+            case SfxChildAlignment::TOOLBOXRIGHT:
+                aSize.setHeight( aTmp.GetHeight() );
+                if ( pCli->pWin->GetType() == WindowType::SPLITWINDOW )
+                    aSize = static_cast<SplitWindow *>(pCli->pWin.get())->CalcLayoutSizePixel( aSize );
+                aBorder.Right() += aSize.Width();
+                aPos = aTmp.TopRight();
+                aPos.AdjustX( -(aSize.Width()-1) );
+                aTmp.AdjustRight( -(aSize.Width()) );
+                if ( pCli->eAlign != SfxChildAlignment::TOOLBOXRIGHT )
+                    aUpperClientArea.AdjustRight( -(aSize.Width()) );
+                break;
+
+            default:
+                pCli->aSize = pCli->pWin->GetSizePixel();
+                pCli->bResize = false;
+                continue;
+        }
+
+        pCli->pWin->SetPosSizePixel( aPos, aSize );
+        pCli->bResize = false;
+        pCli->aSize = aSize;
+        if( bAllowHiding && !RequestTopToolSpacePixel_Impl( aBorder ) )
+        {
+            pCli->nVisible ^= SfxChildVisibility::FITS_IN;
+            aBorder = aTemp;
+        }
+    }
+
+    if ( aClientArea.GetWidth() >= aBorder.Left() + aBorder.Right() )
+    {
+        aClientArea.AdjustLeft(aBorder.Left() );
+        aClientArea.AdjustRight( -(aBorder.Right()) );
+    }
+    else
+    {
+        aBorder.Left() = aClientArea.Left();
+        aBorder.Right() = aClientArea.Right();
+        aClientArea.SetRight( aTmp.Left() );
+        aClientArea.SetLeft( aTmp.Left() );
+    }
+
+    if ( aClientArea.GetHeight() >= aBorder.Top() + aBorder.Bottom() )
+    {
+        aClientArea.AdjustTop(aBorder.Top() );
+        aClientArea.AdjustBottom( -(aBorder.Bottom()) );
+    }
+    else
+    {
+        aBorder.Top() = aClientArea.Top();
+        aBorder.Bottom() = aClientArea.Bottom();
+        aClientArea.SetTop(aTmp.Top());
+        aClientArea.SetBottom(aTmp.Top());
+    }
+
+    return IsDockingAllowed() ? aBorder : SvBorder();
+}
+
+bool SfxWorkWindow::PrepareClose_Impl()
+{
+    for (const std::unique_ptr<SfxChildWin_Impl> &pCW : aChildWins)
+    {
+        SfxChildWindow *pChild = pCW->pWin;
+        if ( pChild && !pChild->QueryClose() )
+            return false;
+    }
+
+    return true;
+}
+
+SfxChild_Impl* SfxWorkWindow::RegisterChild_Impl( vcl::Window& rWindow,
+                    SfxChildAlignment eAlign )
+{
+    DBG_ASSERT( aChildren.size() < 255, "too many children" );
+    DBG_ASSERT( SfxChildAlignValid(eAlign), "invalid align" );
+    DBG_ASSERT( !FindChild_Impl(&rWindow), "child registered more than once" );
+
+
+    if ( rWindow.GetParent() != pWorkWin )
+        rWindow.SetParent( pWorkWin );
+
+    auto pChild = std::make_unique<SfxChild_Impl>(rWindow, rWindow.GetSizePixel(),
+                                    eAlign, rWindow.IsVisible());
+
+    aChildren.push_back(std::move(pChild));
+    bSorted = false;
+    nChildren++;
+    return aChildren.back().get();
+}
+
+SfxChild_Impl* SfxWorkWindow::RegisterChild_Impl(std::shared_ptr<SfxDialogController>& rController,
+                    SfxChildAlignment eAlign )
+{
+    DBG_ASSERT( aChildren.size() < 255, "too many children" );
+    DBG_ASSERT( SfxChildAlignValid(eAlign), "invalid align" );
+
+    auto pChild = std::make_unique<SfxChild_Impl>(rController, eAlign);
+
+    aChildren.push_back(std::move(pChild));
+    bSorted = false;
+    nChildren++;
+    return aChildren.back().get();
+}
+
+void SfxWorkWindow::ReleaseChild_Impl( vcl::Window& rWindow )
+{
+
+    SfxChild_Impl *pChild = nullptr;
+    decltype(aChildren)::size_type nPos;
+    for ( nPos = 0; nPos < aChildren.size(); ++nPos )
+    {
+        pChild = aChildren[nPos].get();
+        if ( pChild && pChild->pWin == &rWindow )
+        {
+            bSorted = false;
+            nChildren--;
+            aChildren.erase(aChildren.begin() + nPos);
+            return;
+        }
+    }
+    OSL_FAIL( "releasing unregistered child" );
+}
+
+void SfxWorkWindow::ReleaseChild_Impl(SfxDialogController& rController)
+{
+
+    SfxChild_Impl *pChild = nullptr;
+    decltype(aChildren)::size_type nPos;
+    for ( nPos = 0; nPos < aChildren.size(); ++nPos )
+    {
+        pChild = aChildren[nPos].get();
+        if (pChild && pChild->xController.get() == &rController)
+        {
+            bSorted = false;
+            nChildren--;
+            aChildren.erase(aChildren.begin() + nPos);
+            return;
+        }
+    }
+    OSL_FAIL( "releasing unregistered child" );
+}
+
+SfxChild_Impl* SfxWorkWindow::FindChild_Impl( const vcl::Window* rWindow ) const
+{
+
+    sal_uInt16 nCount = aChildren.size();
+    for ( sal_uInt16 nPos = 0; nPos < nCount; ++nPos )
+    {
+        SfxChild_Impl *pChild = aChildren[nPos].get();
+        if ( pChild && pChild->pWin == rWindow )
+            return pChild;
+    }
+
+    return nullptr;
+}
+
+void SfxWorkWindow::ShowChildren_Impl()
+{
+    bool bInvisible = ( !IsVisible_Impl() || ( !pWorkWin->IsReallyVisible() && !pWorkWin->IsReallyShown() ));
+
+    for (std::unique_ptr<SfxChild_Impl>& pCli : aChildren)
+    {
+        if (!pCli)
+            continue;
+        SfxChildWin_Impl* pCW = nullptr;
+        if (pCli->pWin || pCli->xController)
+        {
+            // We have to find the SfxChildWin_Impl to retrieve the
+            // SFX_CHILDWIN flags that can influence visibility.
+            for (const std::unique_ptr<SfxChildWin_Impl>& pCWin : aChildWins)
+            {
+                SfxChild_Impl*    pChild  = pCWin->pCli;
+                if ( pChild == pCli.get() )
+                {
+                    pCW = pCWin.get();
+                    break;
+                }
+            }
+
+            bool bVisible( !bInvisible );
+            if ( pCW )
+            {
+                // Check flag SFX_CHILDWIN_NEVERHIDE that forces us to show
+                // the child window even in situations where no child window is
+                // visible.
+                SfxChildWindowFlags nFlags = pCW->aInfo.nFlags;
+                bVisible = !bInvisible || ( nFlags & SfxChildWindowFlags::NEVERHIDE );
+            }
+
+            if ( SfxChildVisibility::VISIBLE == (pCli->nVisible & SfxChildVisibility::VISIBLE) && bVisible )
+            {
+                ShowFlags nFlags = pCli->bSetFocus ? ShowFlags::NONE : ShowFlags::NoFocusChange | ShowFlags::NoActivate;
+                if (pCli->xController)
+                {
+                    if (!pCli->xController->getDialog()->get_visible())
+                    {
+                        auto xController = pCli->xController;
+                        weld::DialogController::runAsync(xController,
+                            [=](sal_Int32 /*nResult*/){ xController->Close(); });
+                    }
+                }
+                else
+                    pCli->pWin->Show(true, nFlags);
+                pCli->bSetFocus = false;
+            }
+            else
+            {
+                if (pCli->xController)
+                {
+                    if (pCli->xController->getDialog()->get_visible())
+                        pCli->xController->response(RET_CLOSE);
+                }
+                else
+                    pCli->pWin->Hide();
+            }
+        }
+    }
+}
+
+
+void SfxWorkWindow::HideChildren_Impl()
+{
+    for ( sal_uInt16 nPos = aChildren.size(); nPos > 0; --nPos )
+    {
+        SfxChild_Impl *pChild = aChildren[nPos-1].get();
+        if (!pChild)
+            continue;
+        if (pChild->xController)
+            pChild->xController->response(RET_CLOSE);
+        else if (pChild->pWin)
+            pChild->pWin->Hide();
+    }
+}
+
+void SfxWorkWindow::ResetObjectBars_Impl()
+{
+    for ( auto & n: aObjBarList )
+        n.bDestroy = true;
+
+    for ( auto & n: aChildWins )
+        n->nId = 0;
+}
+
+void SfxWorkWindow::SetObjectBar_Impl(sal_uInt16 nPos, SfxVisibilityFlags nFlags, ToolbarId eId)
+{
+    DBG_ASSERT( nPos < SFX_OBJECTBAR_MAX, "object bar position overflow" );
+
+    SfxObjectBar_Impl aObjBar;
+    aObjBar.eId = eId;
+    aObjBar.nMode = nFlags;
+
+    for (SfxObjectBar_Impl & rBar : aObjBarList)
+    {
+        if ( rBar.eId == aObjBar.eId )
+        {
+            rBar = aObjBar;
+            return;
+        }
+    }
+
+    aObjBarList.push_back( aObjBar );
+}
+
+bool SfxWorkWindow::IsVisible_Impl( SfxVisibilityFlags nMode ) const
+{
+    switch( nUpdateMode )
+    {
+        case SfxVisibilityFlags::Standard:
+            return true;
+        case SfxVisibilityFlags::Invisible:
+            return false;
+        case SfxVisibilityFlags::Client:
+        case SfxVisibilityFlags::Server:
+            return bool(nMode & nUpdateMode);
+        default:
+            return (nMode & nOrigMode ) ||
+                nOrigMode == SfxVisibilityFlags::Standard;
+    }
+}
+
+void SfxWorkWindow::UpdateObjectBars_Impl()
+{
+    if ( pFrame->IsClosing_Impl() )
+        return;
+
+    UpdateObjectBars_Impl2();
+
+    {
+        ArrangeChildren_Impl( false );
+
+        ShowChildren_Impl();
+    }
+
+    ShowChildren_Impl();
+}
+
+Reference< css::task::XStatusIndicator > SfxWorkWindow::GetStatusIndicator()
+{
+    Reference< css::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY );
+    Reference< css::frame::XLayoutManager > xLayoutManager;
+    Reference< css::task::XStatusIndicator > xStatusIndicator;
+
+    if ( xPropSet.is() )
+    {
+        Any aValue = xPropSet->getPropertyValue( g_aLayoutManagerPropName );
+        aValue >>= xLayoutManager;
+        if ( xLayoutManager.is() )
+        {
+            xLayoutManager->createElement( g_aProgressBarResName );
+            xLayoutManager->showElement( g_aProgressBarResName );
+
+            Reference< css::ui::XUIElement > xProgressBar =
+                xLayoutManager->getElement( g_aProgressBarResName );
+            if ( xProgressBar.is() )
+            {
+                xStatusIndicator.set( xProgressBar->getRealInterface(), UNO_QUERY );
+            }
+        }
+    }
+
+    return xStatusIndicator;
+}
+
+
+bool SfxWorkWindow::IsPluginMode( SfxObjectShell const * pObjShell )
+{
+    if ( pObjShell && pObjShell->GetMedium() )
+    {
+        const SfxBoolItem* pViewOnlyItem = SfxItemSet::GetItem<SfxBoolItem>(pObjShell->GetMedium()->GetItemSet(), SID_VIEWONLY, false);
+        if ( pViewOnlyItem && pViewOnlyItem->GetValue() )
+            return true;
+    }
+
+    return false;
+}
+
+
+css::uno::Reference< css::frame::XFrame > SfxWorkWindow::GetFrameInterface()
+{
+    css::uno::Reference< css::frame::XFrame > xFrame;
+
+    SfxDispatcher* pDispatcher( GetBindings().GetDispatcher() );
+    if ( pDispatcher )
+    {
+        SfxViewFrame* pViewFrame = pDispatcher->GetFrame();
+        if ( pViewFrame )
+           xFrame = pViewFrame->GetFrame().GetFrameInterface();
+    }
+
+    return xFrame;
+}
+
+
+void SfxWorkWindow::UpdateObjectBars_Impl2()
+{
+    // Lock SplitWindows (which means suppressing the Resize-Reaction of the
+    // DockingWindows)
+    for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
+    {
+        VclPtr<SfxSplitWindow> const & p = pSplit[n];
+        if (p->GetWindowCount())
+            p->Lock();
+    }
+
+    Reference< css::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY );
+    Reference< css::frame::XLayoutManager > xLayoutManager;
+
+    if ( xPropSet.is() )
+    {
+        Any aValue = xPropSet->getPropertyValue( g_aLayoutManagerPropName );
+        aValue >>= xLayoutManager;
+    }
+
+    if ( !xLayoutManager.is() )
+        return;
+
+    bool       bPluginMode( false );
+    SfxDispatcher* pDispatcher( GetBindings().GetDispatcher() );
+
+    if ( pDispatcher )
+    {
+        SfxViewFrame* pViewFrame = pDispatcher->GetFrame();
+        if ( pViewFrame )
+           bPluginMode = IsPluginMode( pViewFrame->GetObjectShell() );
+    }
+
+    // Iterate over all Toolboxes
+    xLayoutManager->lock();
+    for ( auto const & n: aObjBarList )
+    {
+        ToolbarId eId = n.eId;
+        bool    bDestroy = n.bDestroy;
+
+        // Determine the valid mode for the ToolBox
+        SfxVisibilityFlags nTbxMode = n.nMode;
+        bool bFullScreenTbx( nTbxMode & SfxVisibilityFlags::FullScreen );
+        nTbxMode &= ~SfxVisibilityFlags::FullScreen;
+        nTbxMode &= ~SfxVisibilityFlags::Viewer;
+
+        // Is a ToolBox required in this context ?
+        bool bModesMatching = (nUpdateMode != SfxVisibilityFlags::Invisible) && ((nTbxMode & nUpdateMode) == nUpdateMode);
+        if ( bDestroy || sfx2::SfxNotebookBar::IsActive())
+        {
+            OUString aTbxId = g_aTbxTypeName + GetResourceURLFromToolbarId(eId);
+            xLayoutManager->destroyElement( aTbxId );
+        }
+        else if ( eId != ToolbarId::None && ( ( bModesMatching && !bIsFullScreen ) ||
+                                ( bIsFullScreen && bFullScreenTbx ) ) )
+        {
+            OUString aTbxId = g_aTbxTypeName + GetResourceURLFromToolbarId(eId);
+            if ( !IsDockingAllowed() && !xLayoutManager->isElementFloating( aTbxId ))
+                xLayoutManager->destroyElement( aTbxId );
+            else
+            {
+                xLayoutManager->requestElement( aTbxId );
+                if ( bPluginMode )
+                    xLayoutManager->lockWindow( aTbxId );
+            }
+        }
+        else if ( eId != ToolbarId::None )
+        {
+            // Delete the Toolbox at this Position if possible
+            OUString aTbxId = g_aTbxTypeName + GetResourceURLFromToolbarId(eId);
+            xLayoutManager->destroyElement( aTbxId );
+        }
+    }
+
+    UpdateStatusBar_Impl();
+
+    // unlocking automatically forces Layout
+    xLayoutManager->unlock();
+
+    UpdateChildWindows_Impl();
+
+    // Unlock the SplitWindows again
+    for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
+    {
+        VclPtr<SfxSplitWindow> const & p = pSplit[n];
+        if (p->GetWindowCount())
+            p->Lock(false);
+    }
+}
+
+void SfxWorkWindow::UpdateChildWindows_Impl()
+{
+    // tdf#100870, tdf#101320: don't use range-based for loop when
+    // container is modified
+    for ( size_t n=0; n<aChildWins.size(); n++ )
+    {
+        // any current or in the context available Childwindows
+        SfxChildWin_Impl *pCW = aChildWins[n].get();
+        SfxChildWindow *pChildWin = pCW->pWin;
+        bool bCreate = false;
+        if ( pCW->nId && (pCW->aInfo.nFlags & SfxChildWindowFlags::ALWAYSAVAILABLE || IsVisible_Impl( pCW->nVisibility ) ) )
+        {
+            // In the context is an appropriate ChildWindow allowed;
+            // it is also turned on?
+            if ( pChildWin == nullptr && pCW->bCreate )
+            {
+                // Internal docking is only used for embedding into another
+                // container. We force the floating state of all floatable
+                // child windows.
+                if ( !bInternalDockingAllowed )
+                {
+                    // Special case for all non-floatable child windows. We have
+                    // to prevent the creation here!
+                    bCreate = !( pCW->aInfo.nFlags & SfxChildWindowFlags::FORCEDOCK );
+                }
+                else if ( !IsDockingAllowed() || bIsFullScreen ) // || !bInternalDocking )
+                {
+                    // In Presentation mode or FullScreen only FloatingWindows
+                    SfxChildAlignment eAlign;
+                    if ( pCW->aInfo.GetExtraData_Impl( &eAlign ) )
+                        bCreate = ( eAlign == SfxChildAlignment::NOALIGNMENT );
+                }
+                else
+                    bCreate = true;
+
+                if (pCW->aInfo.nFlags & SfxChildWindowFlags::NEVERCLONE)
+                    pCW->bCreate = bCreate = false; // Don't create and remember that we haven't created.
+
+                // Currently, no window here, but it is enabled; windows
+                // Create window and if possible theContext
+                if ( bCreate )
+                    CreateChildWin_Impl( pCW, false );
+
+                if ( !bAllChildrenVisible && pCW->pCli )
+                    pCW->pCli->nVisible &= ~SfxChildVisibility::ACTIVE;
+            }
+            else if ( pChildWin )
+            {
+                // Window already exists, it should also be visible?
+                if ( ( !bIsFullScreen || pChildWin->GetAlignment() == SfxChildAlignment::NOALIGNMENT ) && bAllChildrenVisible )
+                {
+                    // Update Mode is compatible; definitely enable it
+                    bCreate = true;
+                    if ( pCW->pCli )
+                    {
+                        // The window is a direct Child
+                        if ((IsDockingAllowed() && bInternalDockingAllowed)
+                            || pCW->pCli->eAlign == SfxChildAlignment::NOALIGNMENT)
+                            pCW->pCli->nVisible |= SfxChildVisibility::NOT_HIDDEN;
+                    }
+                    else
+                    {
+                        if ( pCW->bCreate && IsDockingAllowed() && bInternalDockingAllowed )
+                            // The window ia within a SplitWindow
+                            static_cast<SfxDockingWindow*>(pChildWin->GetWindow())->Reappear_Impl();
+                    }
+
+                    if ( pCW->nInterfaceId != pChildWin->GetContextId() )
+                        pChildWin->CreateContext( pCW->nInterfaceId, GetBindings() );
+                }
+            }
+        }
+
+        if ( pChildWin && !bCreate )
+        {
+            if ( !pChildWin->QueryClose() || pChildWin->IsHideNotDelete() || Application::IsUICaptured() )
+            {
+                if ( pCW->pCli )
+                {
+                    if ( pCW->pCli->nVisible & SfxChildVisibility::NOT_HIDDEN )
+                        pCW->pCli->nVisible ^= SfxChildVisibility::NOT_HIDDEN;
+                }
+                else
+                    static_cast<SfxDockingWindow*>(pChildWin->GetWindow())->Disappear_Impl();
+            }
+            else
+                RemoveChildWin_Impl( pCW );
+        }
+    }
+}
+
+void SfxWorkWindow::CreateChildWin_Impl( SfxChildWin_Impl *pCW, bool bSetFocus )
+{
+    pCW->aInfo.bVisible = true;
+
+    SfxChildWindow *pChildWin = SfxChildWindow::CreateChildWindow( pCW->nId, pWorkWin, &GetBindings(), pCW->aInfo).release();
+    if (!pChildWin)
+        return;
+
+    if ( bSetFocus )
+        bSetFocus = pChildWin->WantsFocus();
+    pChildWin->SetWorkWindow_Impl( this );
+
+    // At least the extra string is changed during the evaluation,
+    // also get it anewed
+    SfxChildWinInfo aInfo = pChildWin->GetInfo();
+    pCW->aInfo.aExtraString = aInfo.aExtraString;
+    pCW->aInfo.bVisible = aInfo.bVisible;
+    pCW->aInfo.nFlags |= aInfo.nFlags;
+
+    // The creation was successful
+    GetBindings().Invalidate(pCW->nId);
+
+    sal_uInt16 nPos = pChildWin->GetPosition();
+    if (nPos != CHILDWIN_NOPOS)
+    {
+        DBG_ASSERT(nPos < SFX_OBJECTBAR_MAX, "Illegal objectbar position!");
+        if ( aChildren[TbxMatch(nPos)] )// &&
+        {
+            // ChildWindow replaces ObjectBar
+            aChildren[TbxMatch(nPos)]->nVisible ^= SfxChildVisibility::NOT_HIDDEN;
+        }
+    }
+
+    // make childwin keyboard accessible
+    pWorkWin->GetSystemWindow()->GetTaskPaneList()->AddWindow( pChildWin->GetWindow() );
+
+    pCW->pWin = pChildWin;
+
+    if ( pChildWin->GetAlignment() == SfxChildAlignment::NOALIGNMENT || pChildWin->GetWindow()->GetParent() == pWorkWin)
+    {
+        // The window is not docked or docked outside of one split windows
+        // and must therefore be registered explicitly as a Child
+        if (pChildWin->GetController())
+            pCW->pCli = RegisterChild_Impl(pChildWin->GetController(), pChildWin->GetAlignment());
+        else
+            pCW->pCli = RegisterChild_Impl(*(pChildWin->GetWindow()), pChildWin->GetAlignment());
+        pCW->pCli->nVisible = SfxChildVisibility::VISIBLE;
+        if ( pChildWin->GetAlignment() != SfxChildAlignment::NOALIGNMENT && bIsFullScreen )
+            pCW->pCli->nVisible ^= SfxChildVisibility::ACTIVE;
+        pCW->pCli->bSetFocus = bSetFocus;
+    }
+    else
+    {
+        // A docked window which parent is not a WorkingWindow, must lie
+        // in a SplitWindow and thus not be explicitly registered.
+        // This happens already in the initialization of SfxDockingWindows!
+    }
+
+    if ( pCW->nInterfaceId != pChildWin->GetContextId() )
+        pChildWin->CreateContext( pCW->nInterfaceId, GetBindings() );
+
+    // Save the information in the INI file
+    SaveStatus_Impl(pChildWin, pCW->aInfo);
+}
+
+void SfxWorkWindow::RemoveChildWin_Impl( SfxChildWin_Impl *pCW )
+{
+    sal_uInt16 nId = pCW->nSaveId;
+    SfxChildWindow *pChildWin = pCW->pWin;
+
+    // Save the information in the INI file
+    SfxChildWindowFlags nFlags = pCW->aInfo.nFlags;
+    pCW->aInfo = pChildWin->GetInfo();
+    pCW->aInfo.nFlags |= nFlags;
+    SaveStatus_Impl(pChildWin, pCW->aInfo);
+
+    pChildWin->Hide();
+
+    if ( pCW->pCli )
+    {
+        // Child window is a direct child window and must therefore unregister
+        // itself from the  WorkWindow
+        pCW->pCli = nullptr;
+        if (pChildWin->GetController())
+            ReleaseChild_Impl(*pChildWin->GetController());
+        else
+            ReleaseChild_Impl(*pChildWin->GetWindow());
+    }
+    else
+    {
+        // ChildWindow is within a SplitWindow and unregister itself in
+        // the destructor.
+    }
+
+    pWorkWin->GetSystemWindow()->GetTaskPaneList()->RemoveWindow( pChildWin->GetWindow() );
+    pCW->pWin = nullptr;
+    pChildWin->Destroy();
+
+    GetBindings().Invalidate( nId );
+}
+
+void SfxWorkWindow::ResetStatusBar_Impl()
+{
+    aStatBar.eId = StatusBarId::None;
+}
+
+void SfxWorkWindow::SetStatusBar_Impl(StatusBarId eId)
+{
+    if (eId != StatusBarId::None && bShowStatusBar && IsVisible_Impl())
+        aStatBar.eId = eId;
+}
+
+void SfxWorkWindow::UpdateStatusBar_Impl()
+{
+    Reference< css::beans::XPropertySet > xPropSet( GetFrameInterface(), UNO_QUERY );
+    Reference< css::frame::XLayoutManager > xLayoutManager;
+
+    Any aValue = xPropSet->getPropertyValue( g_aLayoutManagerPropName );
+    aValue >>= xLayoutManager;
+
+    // No status bar, if no ID is required or when in FullScreenView or
+    // if disabled
+    if (aStatBar.eId != StatusBarId::None && IsDockingAllowed() && bInternalDockingAllowed && bShowStatusBar &&
+        !bIsFullScreen)
+    {
+        // Id has changed, thus create a suitable Statusbarmanager, this takes
+        // over the  current status bar;
+        if ( xLayoutManager.is() )
+            xLayoutManager->requestElement( g_aStatusBarResName );
+    }
+    else
+    {
+        // Destroy the current StatusBar
+        // The Manager only creates the Status bar, does not destroy it.
+        if ( xLayoutManager.is() )
+            xLayoutManager->destroyElement( g_aStatusBarResName );
+    }
+}
+
+void SfxWorkWindow::MakeVisible_Impl( bool bVis )
+{
+    if ( bVis )
+        nOrigMode = SfxVisibilityFlags::Standard;
+    else
+        nOrigMode = SfxVisibilityFlags::Invisible;
+
+    if ( nOrigMode != nUpdateMode)
+        nUpdateMode = nOrigMode;
+}
+
+bool SfxWorkWindow::IsVisible_Impl() const
+{
+    return nOrigMode != SfxVisibilityFlags::Invisible;
+}
+
+
+void SfxWorkWindow::HidePopups_Impl(bool bHide, sal_uInt16 nId )
+{
+    if (comphelper::LibreOfficeKit::isActive() && bHide)
+        return;
+
+    for (const std::unique_ptr<SfxChildWin_Impl>& i : aChildWins)
+    {
+        SfxChildWindow *pCW = i->pWin;
+        if (pCW && pCW->GetAlignment() == SfxChildAlignment::NOALIGNMENT && pCW->GetType() != nId)
+        {
+            vcl::Window *pWin = pCW->GetWindow();
+            SfxChild_Impl *pChild = FindChild_Impl(pWin);
+            if (!pChild)
+            {
+                SAL_WARN("sfx.appl", "missing SfxChild_Impl child!");
+                continue;
+            }
+            if (bHide)
+            {
+                pChild->nVisible &= ~SfxChildVisibility::ACTIVE;
+                pCW->Hide();
+            }
+            else if ( !comphelper::LibreOfficeKit::isActive() ||
+                      SfxChildVisibility::ACTIVE != (pChild->nVisible & SfxChildVisibility::ACTIVE) )
+            {
+                pChild->nVisible |= SfxChildVisibility::ACTIVE;
+                if ( SfxChildVisibility::VISIBLE == (pChild->nVisible & SfxChildVisibility::VISIBLE) )
+                    pCW->Show( ShowFlags::NoFocusChange | ShowFlags::NoActivate );
+            }
+        }
+    }
+}
+
+
+void SfxWorkWindow::ConfigChild_Impl(SfxChildIdentifier eChild,
+            SfxDockingConfig eConfig, sal_uInt16 nId)
+{
+    SfxDockingWindow* pDockWin=nullptr;
+    sal_uInt16 nPos = USHRT_MAX;
+    vcl::Window *pWin=nullptr;
+    SfxChildWin_Impl *pCW = nullptr;
+
+    // configure direct childwindow
+    for (const std::unique_ptr<SfxChildWin_Impl>& i : aChildWins)
+    {
+        pCW = i.get();
+        SfxChildWindow *pChild = pCW->pWin;
+        if ( pChild && (pChild->GetType() == nId ))
+        {
+            if (SfxDockingWindow* pSfxDockingWindow = dynamic_cast<SfxDockingWindow*>(pChild->GetWindow()))
+            {
+                // it's a DockingWindow
+                pDockWin = pSfxDockingWindow;
+            }
+            else
+            {
+                // FloatingWindow or ModelessDialog
+                pWin = pChild->GetWindow();
+            }
+            break;
+        }
+    }
+
+    if ( pDockWin )
+    {
+        if ( eChild == SfxChildIdentifier::DOCKINGWINDOW || pDockWin->GetAlignment() == SfxChildAlignment::NOALIGNMENT )
+        {
+            if ( eChild == SfxChildIdentifier::SPLITWINDOW && eConfig == SfxDockingConfig::TOGGLEFLOATMODE)
+            {
+                // DockingWindow was dragged out of a SplitWindow
+                pCW->pCli = RegisterChild_Impl(*pDockWin, pDockWin->GetAlignment());
+                pCW->pCli->nVisible = SfxChildVisibility::VISIBLE;
+            }
+
+            pWin = pDockWin;
+        }
+        else
+        {
+            SfxSplitWindow *pSplitWin = GetSplitWindow_Impl(pDockWin->GetAlignment());
+
+            // configure DockingWindow inside a SplitWindow
+            if ( eConfig == SfxDockingConfig::TOGGLEFLOATMODE)
+            {
+                // DockingWindow was dragged into a SplitWindow
+                pCW->pCli = nullptr;
+                ReleaseChild_Impl(*pDockWin);
+            }
+
+            pWin = pSplitWin->GetSplitWindow();
+            if ( pSplitWin->GetWindowCount() == 1 )
+                static_cast<SplitWindow*>(pWin)->Show( true, ShowFlags::NoFocusChange | ShowFlags::NoActivate );
+        }
+    }
+
+    DBG_ASSERT( pCW, "Unknown window!" );
+
+    if ( !bSorted )
+        // windows may have been registered and released without an update until now
+        Sort_Impl();
+
+    decltype(aSortedList)::size_type n;
+    for ( n=0; n<aSortedList.size(); ++n )
+    {
+        SfxChild_Impl *pChild = aChildren[aSortedList[n]].get();
+        if ( pChild && pChild->pWin == pWin )
+            break;
+    }
+
+    if ( n < aSortedList.size() )
+        // sometimes called while toggeling float mode
+        nPos = aSortedList[n];
+
+    switch ( eConfig )
+    {
+        case SfxDockingConfig::SETDOCKINGRECTS :
+        {
+            if (nPos == USHRT_MAX || !pDockWin)
+                return;
+
+            tools::Rectangle aOuterRect( GetTopRect_Impl() );
+            aOuterRect.SetPos( pWorkWin->OutputToScreenPixel( aOuterRect.TopLeft() ));
+            tools::Rectangle aInnerRect( aOuterRect );
+
+            // The current affected window is included in the calculation of
+            // the inner rectangle!
+            for (sal_uInt16 i : aSortedList)
+            {
+                SfxChild_Impl* pCli = aChildren[i].get();
+
+                if ( pCli && pCli->nVisible == SfxChildVisibility::VISIBLE && pCli->pWin )
+                {
+                    switch ( pCli->eAlign )
+                    {
+                        case SfxChildAlignment::TOP:
+                            // Object-Toolboxes come always last
+                                aInnerRect.AdjustTop(pCli->aSize.Height() );
+                            break;
+
+                        case SfxChildAlignment::HIGHESTTOP:
+                            // Always performed first
+                            aInnerRect.AdjustTop(pCli->aSize.Height() );
+                            break;
+
+                        case SfxChildAlignment::LOWESTTOP:
+                            // Is only counted if it is the current window
+                            if ( i == nPos )
+                                aInnerRect.AdjustTop(pCli->aSize.Height() );
+                            break;
+
+                        case SfxChildAlignment::BOTTOM:
+                            // Object-Toolboxes come always last
+                                aInnerRect.AdjustBottom( -(pCli->aSize.Height()) );
+                            break;
+
+                        case SfxChildAlignment::LOWESTBOTTOM:
+                            // Always performed first
+                            aInnerRect.AdjustBottom( -(pCli->aSize.Height()) );
+                            break;
+
+                        case SfxChildAlignment::HIGHESTBOTTOM:
+                            // Is only counted if it is the current window
+                            if ( i == nPos )
+                                aInnerRect.AdjustBottom( -(pCli->aSize.Height()) );
+                            break;
+
+                        case SfxChildAlignment::LEFT:
+                            // Toolboxes come always last
+                                aInnerRect.AdjustLeft(pCli->aSize.Width() );
+                            break;
+
+                        case SfxChildAlignment::FIRSTLEFT:
+                            // Always performed first
+                            aInnerRect.AdjustLeft(pCli->aSize.Width() );
+                            break;
+
+                        case SfxChildAlignment::LASTLEFT:
+                            // Is only counted if it is the current window
+                            if (i == nPos)
+                                aInnerRect.AdjustLeft(pCli->aSize.Width() );
+                            break;
+
+                        case SfxChildAlignment::RIGHT:
+                            // Toolboxes come always last
+                                aInnerRect.AdjustRight( -(pCli->aSize.Width()) );
+                            break;
+
+                        case SfxChildAlignment::FIRSTRIGHT:
+                            // Is only counted if it is the current window
+                            if (i == nPos)
+                                aInnerRect.AdjustRight( -(pCli->aSize.Width()) );
+                            break;
+
+                        case SfxChildAlignment::LASTRIGHT:
+                            // Always performed first
+                            aInnerRect.AdjustRight( -(pCli->aSize.Width()) );
+                            break;
+
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            pDockWin->SetDockingRects(aOuterRect, aInnerRect);
+            break;
+        }
+
+        case SfxDockingConfig::ALIGNDOCKINGWINDOW :
+        case SfxDockingConfig::TOGGLEFLOATMODE:
+        {
+            if ( nPos == USHRT_MAX && !pCW )
+                return;
+
+            SfxChildAlignment eAlign = SfxChildAlignment::NOALIGNMENT;
+            SfxChild_Impl *pCli = ( nPos != USHRT_MAX ) ? aChildren[nPos].get() : nullptr;
+            if ( pCli && pDockWin )
+            {
+                eAlign = pDockWin->GetAlignment();
+                if ( eChild == SfxChildIdentifier::DOCKINGWINDOW || eAlign == SfxChildAlignment::NOALIGNMENT)
+                {
+                    // configuration inside the SplitWindow, no change for the SplitWindows' configuration
+                    pCli->bResize = true;
+                    pCli->aSize = pDockWin->GetSizePixel();
+                }
+            }
+
+            if ( pCli )
+            {
+                if( pCli->eAlign != eAlign )
+                {
+                    bSorted = false;
+                    pCli->eAlign = eAlign;
+                }
+
+                ArrangeChildren_Impl();
+                ShowChildren_Impl();
+            }
+
+            if ( pCW && pCW->pWin )
+            {
+                // store changed configuration
+                SfxChildWindowFlags nFlags = pCW->aInfo.nFlags;
+                pCW->aInfo = pCW->pWin->GetInfo();
+                pCW->aInfo.nFlags |= nFlags;
+                SaveStatus_Impl( pCW->pWin, pCW->aInfo);
+            }
+
+            break;
+        }
+    }
+}
+
+
+void SfxWorkWindow::SetChildWindowVisible_Impl( sal_uInt32 lId, bool bEnabled, SfxVisibilityFlags nMode )
+{
+    sal_uInt16 nInter = static_cast<sal_uInt16>( lId >> 16 );
+    sal_uInt16 nId = static_cast<sal_uInt16>( lId & 0xFFFF );
+
+    SfxChildWin_Impl *pCW=nullptr;
+
+    if ( !pCW )
+    {
+        // If no Parent or the Parent us still unknown, then search here
+        sal_uInt16 nCount = aChildWins.size();
+        for (sal_uInt16 n=0; n<nCount; n++)
+            if (aChildWins[n]->nSaveId == nId)
+            {
+                pCW = aChildWins[n].get();
+                break;
+            }
+    }
+
+    if ( !pCW )
+    {
+        // If new, then initialize, add this here depending on the flag or
+        // the Parent
+        pCW = new SfxChildWin_Impl( lId );
+        pCW->nId = nId;
+        InitializeChild_Impl( pCW );
+        aChildWins.push_back( std::unique_ptr<SfxChildWin_Impl>(pCW) );
+    }
+
+    pCW->nId = nId;
+    if ( nInter )
+        pCW->nInterfaceId = nInter;
+    pCW->nVisibility = nMode;
+    pCW->bEnable = bEnabled;
+}
+
+
+// The on/off status of a ChildWindow is switched
+
+void SfxWorkWindow::ToggleChildWindow_Impl(sal_uInt16 nId, bool bSetFocus)
+{
+    sal_uInt16 nCount = aChildWins.size();
+    sal_uInt16 n;
+    for (n=0; n<nCount; n++)
+        if (aChildWins[n]->nId == nId)
+            break;
+
+    if ( n<nCount )
+    {
+        // The Window is already known
+        SfxChildWin_Impl *pCW = aChildWins[n].get();
+        SfxChildWindow *pChild = pCW->pWin;
+
+        bool bCreationAllowed( true );
+        if ( !bInternalDockingAllowed )
+        {
+            // Special case for all non-floatable child windows. We have
+            // to prevent the creation here!
+            bCreationAllowed = !( pCW->aInfo.nFlags & SfxChildWindowFlags::FORCEDOCK );
+        }
+
+        if ( bCreationAllowed )
+        {
+            if ( pCW->bCreate )
+            {
+                if ( pChild )
+                {
+                    if ( pChild->QueryClose() )
+                    {
+                        pCW->bCreate = false;
+                        // The Window should be switched off
+                        pChild->SetVisible_Impl( false );
+                        RemoveChildWin_Impl( pCW );
+                    }
+                }
+                else
+                {
+                    // no actual Window exists, yet => just remember the "switched off" state
+                    pCW->bCreate = false;
+                }
+            }
+            else
+            {
+                pCW->bCreate = true;
+                if ( pChild )
+                {
+                    ShowChildWindow_Impl( nId, true, bSetFocus );
+                }
+                else
+                {
+                    // create actual Window
+                    CreateChildWin_Impl( pCW, bSetFocus );
+                    if ( !pCW->pWin )
+                        // no success
+                        pCW->bCreate = false;
+                }
+            }
+        }
+
+        ArrangeChildren_Impl();
+        ShowChildren_Impl();
+
+        if ( pCW->bCreate && bCreationAllowed )
+        {
+            if ( !pCW->pCli )
+            {
+                SfxDockingWindow *pDock =
+                    static_cast<SfxDockingWindow*>( pCW->pWin->GetWindow() );
+                if ( pDock->IsAutoHide_Impl() )
+                    pDock->AutoShow_Impl();
+            }
+        }
+
+        return;
+    }
+
+#ifdef DBG_UTIL
+    nCount = aChildWins.size();
+    for (n=0; n<nCount; n++)
+        if (aChildWins[n]->nSaveId == nId)
+            break;
+
+    if ( n < nCount )
+    {
+        OSL_FAIL("The ChildWindow is not in context!");
+    }
+    else
+    {
+        OSL_FAIL("The ChildWindow is not registered!");
+    }
+#endif
+}
+
+
+bool SfxWorkWindow::HasChildWindow_Impl(sal_uInt16 nId)
+{
+    sal_uInt16 nCount = aChildWins.size();
+    sal_uInt16 n;
+    for (n=0; n<nCount; n++)
+        if (aChildWins[n]->nSaveId == nId)
+            break;
+
+    if (n<nCount)
+    {
+        SfxChildWin_Impl *pCW = aChildWins[n].get();
+        SfxChildWindow *pChild = pCW->pWin;
+        return ( pChild && pCW->bCreate );
+    }
+
+    return false;
+}
+
+bool SfxWorkWindow::IsFloating( sal_uInt16 nId )
+{
+    SfxChildWin_Impl *pCW=nullptr;
+
+    if ( !pCW )
+    {
+        // If no Parent or the Parent us still unknown, then search here
+        sal_uInt16 nCount = aChildWins.size();
+        for (sal_uInt16 n=0; n<nCount; n++)
+            if (aChildWins[n]->nSaveId == nId)
+            {
+                pCW = aChildWins[n].get();
+                break;
+            }
+    }
+
+    if ( !pCW )
+    {
+        // If new, then initialize, add this here depending on the flag or
+        // the Parent
+        pCW = new SfxChildWin_Impl( nId );
+        pCW->bEnable = false;
+        pCW->nId = 0;
+        pCW->nVisibility = SfxVisibilityFlags::Invisible;
+        InitializeChild_Impl( pCW );
+        aChildWins.push_back( std::unique_ptr<SfxChildWin_Impl>(pCW) );
+    }
+
+    SfxChildAlignment eAlign;
+    if ( pCW->aInfo.GetExtraData_Impl( &eAlign ) )
+        return( eAlign == SfxChildAlignment::NOALIGNMENT );
+    else
+        return true;
+}
+
+
+bool SfxWorkWindow::KnowsChildWindow_Impl(sal_uInt16 nId)
+{
+    SfxChildWin_Impl *pCW=nullptr;
+    sal_uInt16 nCount = aChildWins.size();
+    sal_uInt16 n;
+    for (n=0; n<nCount; n++)
+    {
+        pCW = aChildWins[n].get();
+        if ( pCW->nSaveId == nId)
+             break;
+    }
+
+    if (n<nCount)
+    {
+        if ( !(pCW->aInfo.nFlags & SfxChildWindowFlags::ALWAYSAVAILABLE) && !IsVisible_Impl(  pCW->nVisibility ) )
+            return false;
+        return pCW->bEnable;
+    }
+    else
+        return false;
+}
+
+
+void SfxWorkWindow::SetChildWindow_Impl(sal_uInt16 nId, bool bOn, bool bSetFocus)
+{
+    SfxChildWin_Impl *pCW=nullptr;
+    SfxWorkWindow *pWork = nullptr;
+
+    if ( !pCW )
+    {
+        // If no Parent or the Parent us still unknown, then search here
+        sal_uInt16 nCount = aChildWins.size();
+        for (sal_uInt16 n=0; n<nCount; n++)
+            if (aChildWins[n]->nSaveId == nId)
+            {
+                pCW = aChildWins[n].get();
+                pWork = this;
+                break;
+            }
+    }
+
+    if ( !pCW )
+    {
+        // If new, then initialize, add this here depending on the flag or
+        // the Parent
+        pCW = new SfxChildWin_Impl( nId );
+        InitializeChild_Impl( pCW );
+        if ( !pWork || pCW->aInfo.nFlags & SfxChildWindowFlags::TASK )
+            pWork = this;
+        pWork->aChildWins.push_back( std::unique_ptr<SfxChildWin_Impl>(pCW) );
+    }
+
+    if ( pCW->bCreate != bOn )
+        pWork->ToggleChildWindow_Impl(nId,bSetFocus);
+}
+
+
+void SfxWorkWindow::ShowChildWindow_Impl(sal_uInt16 nId, bool bVisible, bool bSetFocus)
+{
+    sal_uInt16 nCount = aChildWins.size();
+    SfxChildWin_Impl* pCW=nullptr;
+    sal_uInt16 n;
+    for (n=0; n<nCount; n++)
+    {
+        pCW = aChildWins[n].get();
+        if (pCW->nId == nId)
+            break;
+    }
+
+    if ( n<nCount )
+    {
+        SfxChildWindow *pChildWin = pCW->pWin;
+        if ( pChildWin )
+        {
+            if ( bVisible )
+            {
+                if ( pCW->pCli )
+                {
+                    pCW->pCli->bSetFocus = bSetFocus;
+                    pCW->pCli->nVisible = SfxChildVisibility::VISIBLE;
+                    pChildWin->Show( bSetFocus && pChildWin->WantsFocus() ? ShowFlags::NONE : ShowFlags::NoFocusChange | ShowFlags::NoActivate );
+                }
+                else
+                    static_cast<SfxDockingWindow*>(pChildWin->GetWindow())->Reappear_Impl();
+
+            }
+            else
+            {
+                if ( pCW->pCli )
+                {
+                    pCW->pCli->nVisible = SfxChildVisibility::VISIBLE ^ SfxChildVisibility::NOT_HIDDEN;
+                    pCW->pWin->Hide();
+                }
+                else
+                    static_cast<SfxDockingWindow*>(pChildWin->GetWindow())->Disappear_Impl();
+
+            }
+
+            ArrangeChildren_Impl();
+            ShowChildren_Impl();
+        }
+        else if ( bVisible )
+        {
+            SetChildWindow_Impl( nId, true, bSetFocus );
+            pChildWin = pCW->pWin;
+        }
+
+        if ( pChildWin )
+        {
+            pChildWin->SetVisible_Impl( bVisible );
+            SfxChildWindowFlags nFlags = pCW->aInfo.nFlags;
+            pCW->aInfo = pChildWin->GetInfo();
+            pCW->aInfo.nFlags |= nFlags;
+            if ( !pCW->bCreate )
+                SaveStatus_Impl( pChildWin, pCW->aInfo );
+        }
+
+        return;
+    }
+
+#ifdef DBG_UTIL
+    nCount = aChildWins.size();
+    for (n=0; n<nCount; n++)
+        if (aChildWins[n]->nSaveId == nId)
+            break;
+
+    if ( n<nCount )
+    {
+        OSL_FAIL("The ChildWindow is not in context!");
+    }
+    else
+    {
+        OSL_FAIL("The ChildWindow is not registered");
+    }
+#endif
+}
+
+
+SfxChildWindow* SfxWorkWindow::GetChildWindow_Impl(sal_uInt16 nId)
+{
+    sal_uInt16 nCount = aChildWins.size();
+    sal_uInt16 n;
+    for (n=0; n<nCount; n++)
+        if (aChildWins[n]->nSaveId == nId)
+             break;
+
+    if (n<nCount)
+        return aChildWins[n]->pWin;
+    return nullptr;
+}
+
+
+void SfxWorkWindow::ResetChildWindows_Impl()
+{
+    for (std::unique_ptr<SfxChildWin_Impl>& pChildWin : aChildWins)
+    {
+        pChildWin->nId = 0;
+        pChildWin->bEnable = false;
+    }
+}
+
+// returns the size of the area (client area) of the
+// parent windows, in which the ChildWindow can be fitted.
+
+tools::Rectangle SfxWorkWindow::GetTopRect_Impl() const
+{
+    return pMasterFrame->GetTopOuterRectPixel_Impl();
+}
+
+
+// Virtual method to find out if there is room for a ChildWindow in the
+// client area of the parent.
+
+bool SfxWorkWindow::RequestTopToolSpacePixel_Impl( SvBorder aBorder )
+{
+    return !(!IsDockingAllowed() ||
+            aClientArea.GetWidth() < aBorder.Left() + aBorder.Right() ||
+            aClientArea.GetHeight() < aBorder.Top() + aBorder.Bottom());
+}
+
+void SfxWorkWindow::SaveStatus_Impl(SfxChildWindow *pChild, const SfxChildWinInfo &rInfo)
+{
+    // The Status of the Presentation mode is not saved
+    if ( IsDockingAllowed() && bInternalDockingAllowed )
+        pChild->SaveStatus(rInfo);
+}
+
+void SfxWorkWindow::InitializeChild_Impl(SfxChildWin_Impl *pCW)
+{
+    SfxDispatcher *pDisp = pBindings->GetDispatcher_Impl();
+    SfxViewFrame *pViewFrame = pDisp ? pDisp->GetFrame() :nullptr;
+    SfxModule *pMod = pViewFrame ? SfxModule::GetActiveModule(pViewFrame) :nullptr;
+
+    OUString sModule;
+    if (pViewFrame)
+    {
+        try
+        {
+            uno::Reference< frame::XModuleManager2 > xModuleManager(
+                frame::ModuleManager::create(::comphelper::getProcessComponentContext()));
+            sModule = xModuleManager->identify(pViewFrame->GetFrame().GetFrameInterface());
+            SvtModuleOptions::EFactory eFac = SvtModuleOptions::ClassifyFactoryByServiceName(sModule);
+            sModule = SvtModuleOptions::GetFactoryShortName(eFac);
+        }
+        catch (...)
+        {
+        }
+    }
+
+    SfxChildWinFactory* pFact=nullptr;
+    SfxApplication *pApp = SfxGetpApp();
+    {
+        SfxChildWinFactArr_Impl &rFactories = pApp->GetChildWinFactories_Impl();
+        for ( size_t nFactory = 0; nFactory < rFactories.size(); ++nFactory )
+        {
+            pFact = &rFactories[nFactory];
+            if ( pFact->nId == pCW->nSaveId )
+            {
+                pCW->aInfo   = pFact->aInfo;
+                pCW->aInfo.aModule = sModule;
+                SfxChildWindow::InitializeChildWinFactory_Impl(
+                                            pCW->nSaveId, pCW->aInfo);
+                pCW->bCreate = pCW->aInfo.bVisible;
+                SfxChildWindowFlags nFlags = pFact->aInfo.nFlags;
+                if ( nFlags & SfxChildWindowFlags::TASK )
+                    pCW->aInfo.nFlags |= SfxChildWindowFlags::TASK;
+                if ( nFlags & SfxChildWindowFlags::CANTGETFOCUS )
+                    pCW->aInfo.nFlags |= SfxChildWindowFlags::CANTGETFOCUS;
+                if ( nFlags & SfxChildWindowFlags::FORCEDOCK )
+                    pCW->aInfo.nFlags |= SfxChildWindowFlags::FORCEDOCK;
+                pFact->aInfo = pCW->aInfo;
+                return;
+            }
+        }
+    }
+
+    if ( !pMod )
+        return;
+
+    SfxChildWinFactArr_Impl *pFactories = pMod->GetChildWinFactories_Impl();
+    if ( !pFactories )
+        return;
+
+    SfxChildWinFactArr_Impl &rFactories = *pFactories;
+    for ( size_t nFactory = 0; nFactory < rFactories.size(); ++nFactory )
+    {
+        pFact = &rFactories[nFactory];
+        if ( pFact->nId == pCW->nSaveId )
+        {
+            pCW->aInfo   = pFact->aInfo;
+            pCW->aInfo.aModule = sModule;
+            SfxChildWindow::InitializeChildWinFactory_Impl(
+                                        pCW->nSaveId, pCW->aInfo);
+            pCW->bCreate = pCW->aInfo.bVisible;
+            SfxChildWindowFlags nFlags = pFact->aInfo.nFlags;
+            if ( nFlags & SfxChildWindowFlags::TASK )
+                pCW->aInfo.nFlags |= SfxChildWindowFlags::TASK;
+            if ( nFlags & SfxChildWindowFlags::CANTGETFOCUS )
+                pCW->aInfo.nFlags |= SfxChildWindowFlags::CANTGETFOCUS;
+            if ( nFlags & SfxChildWindowFlags::FORCEDOCK )
+                pCW->aInfo.nFlags |= SfxChildWindowFlags::FORCEDOCK;
+            if ( nFlags & SfxChildWindowFlags::ALWAYSAVAILABLE )
+                pCW->aInfo.nFlags |= SfxChildWindowFlags::ALWAYSAVAILABLE;
+            pFact->aInfo = pCW->aInfo;
+            return;
+        }
+    }
+}
+
+SfxSplitWindow* SfxWorkWindow::GetSplitWindow_Impl( SfxChildAlignment eAlign )
+{
+    switch ( eAlign )
+    {
+        case SfxChildAlignment::TOP:
+            return pSplit[2];
+
+        case SfxChildAlignment::BOTTOM:
+            return pSplit[3];
+
+        case SfxChildAlignment::LEFT:
+            return pSplit[0];
+
+        case SfxChildAlignment::RIGHT:
+            return pSplit[1];
+
+        default:
+            return nullptr;
+    }
+}
+
+void SfxWorkWindow::MakeChildrenVisible_Impl( bool bVis )
+{
+    bAllChildrenVisible = bVis;
+    if ( bVis )
+    {
+        if ( !bSorted )
+            Sort_Impl();
+        for (sal_uInt16 n : aSortedList)
+        {
+            SfxChild_Impl* pCli = aChildren[n].get();
+            if ( (pCli->eAlign == SfxChildAlignment::NOALIGNMENT) || (IsDockingAllowed() && bInternalDockingAllowed) )
+                pCli->nVisible |= SfxChildVisibility::ACTIVE;
+        }
+    }
+    else
+    {
+        if ( !bSorted )
+            Sort_Impl();
+        for (sal_uInt16 n : aSortedList)
+        {
+            SfxChild_Impl* pCli = aChildren[n].get();
+            pCli->nVisible &= ~SfxChildVisibility::ACTIVE;
+        }
+    }
+}
+
+bool SfxWorkWindow::IsAutoHideMode( const SfxSplitWindow *pSplitWin )
+{
+    for (const VclPtr<SfxSplitWindow> & pWin : pSplit)
+    {
+        if ( pWin.get() != pSplitWin && pWin->IsAutoHide( true ) )
+            return true;
+    }
+    return false;
+}
+
+
+void SfxWorkWindow::EndAutoShow_Impl( Point aPos )
+{
+    for (VclPtr<SfxSplitWindow> & p : pSplit)
+    {
+        if ( p && p->IsAutoHide(false) )
+        {
+            Point aLocalPos = p->ScreenToOutputPixel( aPos );
+            tools::Rectangle aRect( Point(), p->GetSizePixel() );
+            if ( !aRect.IsInside( aLocalPos ) )
+                p->FadeOut();
+        }
+    }
+}
+
+void SfxWorkWindow::ArrangeAutoHideWindows( SfxSplitWindow *pActSplitWin )
+{
+    if ( m_nLock )
+        return;
+
+    tools::Rectangle aArea( aUpperClientArea );
+    for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
+    {
+        // Either dummy window or window in the auto-show-mode are processed
+        // (not pinned, FadeIn).
+        // Only the abandoned window may be invisible, because perhaps its
+        // size is just being calculated before it is displayed.
+        VclPtr<SfxSplitWindow> const & pSplitWin = pSplit[n];
+        bool bDummyWindow = !pSplitWin->IsFadeIn();
+        vcl::Window *pDummy = pSplitWin->GetSplitWindow();
+        vcl::Window *pWin = bDummyWindow ? pDummy : pSplitWin;
+        if ( (pSplitWin->IsPinned() && !bDummyWindow) || (!pWin->IsVisible() && pActSplitWin != pSplitWin) )
+            continue;
+
+        // Width and position of the dummy window as a starting point
+        Size aSize = pDummy->GetSizePixel();
+        Point aPos = pDummy->GetPosPixel();
+
+        switch ( n )
+        {
+            case 0 :
+            {
+                // Left SplitWindow
+                // Get the width of the Window yourself, if no DummyWindow
+                if ( !bDummyWindow )
+                    aSize.setWidth( pSplitWin->GetSizePixel().Width() );
+
+                // If a Window is visible to the left, then the free region
+                // starts to the right from it, for example at the Client area
+                long nLeft = aPos.X() + aSize.Width();
+                if ( nLeft > aArea.Left() )
+                    aArea.SetLeft( nLeft );
+                break;
+            }
+            case 1 :
+            {
+                // Right SplitWindow
+                // Position to correct the difference of the widths
+                aPos.AdjustX(aSize.Width() );
+
+                // Get the width of the Window yourself, if no DummyWindow
+                if ( !bDummyWindow )
+                    aSize.setWidth( pSplitWin->GetSizePixel().Width() );
+
+                aPos.AdjustX( -(aSize.Width()) );
+
+                // If already a window is opened at the left side, then the
+                // right is not allowed to overlap this one.
+                if ( aPos.X() < aArea.Left() )
+                {
+                    aPos.setX( aArea.Left() );
+                    aSize.setWidth( aArea.GetWidth() );
+                }
+
+                // If a Window is visible to the right, then the free region
+                // starts to the left from it, for example at the Client area
+                long nRight = aPos.X();
+                if ( !aArea.IsWidthEmpty() && nRight < aArea.Right() )
+                    aArea.SetRight( nRight );
+                break;
+            }
+            case 2 :
+            {
+                // Top SplitWindow
+                // Get the height of the Window yourself, if no DummyWindow
+                if ( !bDummyWindow )
+                    aSize.setHeight( pSplitWin->GetSizePixel().Height() );
+
+
+                // Adjust width with regard to if a Window is already open
+                // to the left or right
+                aPos.setX( aArea.Left() );
+                aSize.setWidth( aArea.GetWidth() );
+
+                // If a Window is visible at the top, then the free region
+                // starts beneath it, for example at the Client area
+                long nTop = aPos.Y() + aSize.Height();
+                if ( nTop > aArea.Top() )
+                    aArea.SetTop( nTop );
+                break;
+            }
+            case 3 :
+            {
+                // The bottom SplitWindow
+                // Position to correct the difference of the heights
+                aPos.AdjustY(aSize.Height() );
+
+                // Get the height of the Window yourself, if no DummyWindow
+                if ( !bDummyWindow )
+                    aSize.setHeight( pSplitWin->GetSizePixel().Height() );
+
+                aPos.AdjustY( -(aSize.Height()) );
+
+                // Adjust width with regard to if a Window is already open
+                // to the left or right.
+                aPos.setX( aArea.Left() );
+                aSize.setWidth( aArea.GetWidth() );
+
+                // If already a window is opened at the top, then the
+                // bottom one is not allowed to overlap this one.
+                if ( aPos.Y() < aArea.Top() )
+                {
+                    aPos.setY( aArea.Top() );
+                    aSize.setHeight( aArea.GetHeight() );
+                }
+
+                break;
+            }
+        }
+
+        if ( !bDummyWindow )
+            // the FadeIn-Window is a Floating window, which coordinates are
+            // set in Screen coordinates.
+            pSplitWin->SetPosSizePixel( pWorkWin->OutputToScreenPixel(aPos), aSize );
+        else
+            // the docked DummyWindow
+            pDummy->SetPosSizePixel( aPos, aSize );
+    }
+}
+
+tools::Rectangle SfxWorkWindow::GetFreeArea( bool bAutoHide ) const
+{
+    if ( bAutoHide )
+    {
+        tools::Rectangle aArea( aClientArea );
+        for ( sal_uInt16 n=0; n<SFX_SPLITWINDOWS_MAX; n++ )
+        {
+            if ( pSplit[n]->IsPinned() || !pSplit[n]->IsVisible() )
+                continue;
+
+            Size aSize = pSplit[n]->GetSizePixel();
+            switch ( n )
+            {
+                case 0 :
+                    aArea.AdjustLeft(aSize.Width() );
+                    break;
+                case 1 :
+                    aArea.AdjustRight( -(aSize.Width()) );
+                    break;
+                case 2 :
+                    aArea.AdjustTop(aSize.Height() );
+                    break;
+                case 3 :
+                    aArea.AdjustBottom( -(aSize.Height()) );
+                    break;
+            }
+        }
+
+        return aArea;
+    }
+    else
+        return aClientArea;
+}
+
+void SfxWorkWindow::SetActiveChild_Impl( vcl::Window *pChild )
+{
+    pActiveChild = pChild;
+}
+
+void SfxWorkWindow::DataChanged_Impl()
+{
+    ArrangeChildren_Impl();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/appl/xpackcreator.cxx b/sfx2/source/appl/xpackcreator.cxx
new file mode 100644
index 000000000..825a334f3
--- /dev/null
+++ b/sfx2/source/appl/xpackcreator.cxx
@@ -0,0 +1,172 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <com/sun/star/ucb/XCommandEnvironment.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/io/XOutputStream.hpp>
+#include <com/sun/star/embed/XPackageStructureCreator.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+
+#include <comphelper/processfactory.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <sot/stg.hxx>
+#include <sot/storage.hxx>
+#include <tools/stream.hxx>
+#include <unotools/tempfile.hxx>
+#include <unotools/ucbhelper.hxx>
+#include <ucbhelper/content.hxx>
+
+using namespace css;
+
+namespace {
+
+class OPackageStructureCreator : public ::cppu::WeakImplHelper< embed::XPackageStructureCreator,
+                                                                lang::XServiceInfo >
+{
+public:
+    OPackageStructureCreator() {}
+
+    // XPackageStructureCreator
+    virtual void SAL_CALL convertToPackage( const OUString& aFolderUrl, const uno::Reference< io::XOutputStream >& xTargetStream ) override;
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+
+void SAL_CALL OPackageStructureCreator::convertToPackage( const OUString& aFolderUrl,
+                                                          const uno::Reference< io::XOutputStream >& xTargetStream )
+{
+    uno::Reference< ucb::XCommandEnvironment > xComEnv;
+
+    if ( !xTargetStream.is() )
+        throw io::IOException(); // TODO/LATER
+
+    bool bSuccess = false;
+    ::ucbhelper::Content aContent;
+    if( ::ucbhelper::Content::create( aFolderUrl, xComEnv, comphelper::getProcessComponentContext(), aContent ) )
+    {
+        std::unique_ptr<SvStream> pTempStream;
+
+        OUString aTempURL = ::utl::TempFile().GetURL();
+        try {
+            if ( aContent.isFolder() )
+            {
+                UCBStorage* pUCBStorage = new UCBStorage( aContent,
+                                                          aFolderUrl,
+                                                          StreamMode::READ,
+                                                          false,
+                                                          true );
+                tools::SvRef<SotStorage> aStorage = new SotStorage( pUCBStorage );
+
+                if ( !aTempURL.isEmpty() )
+                {
+                    pTempStream.reset(new SvFileStream( aTempURL, StreamMode::STD_READWRITE ));
+                    tools::SvRef<SotStorage> aTargetStorage = new SotStorage( true, *pTempStream );
+                    aStorage->CopyTo( aTargetStorage.get() );
+                    aTargetStorage->Commit();
+
+                    if ( aStorage->GetError() || aTargetStorage->GetError() || pTempStream->GetError() )
+                        throw io::IOException();
+
+                    aTargetStorage = nullptr;
+                    aStorage = nullptr;
+
+                    pTempStream->Seek( 0 );
+
+                    uno::Sequence< sal_Int8 > aSeq( 32000 );
+                    sal_uInt32 nRead = 0;
+                    do {
+                        if ( aSeq.getLength() < 32000 )
+                            aSeq.realloc( 32000 );
+
+                        nRead = pTempStream->ReadBytes(aSeq.getArray(), 32000);
+                        if ( nRead < 32000 )
+                            aSeq.realloc( nRead );
+                        xTargetStream->writeBytes( aSeq );
+                    } while (pTempStream->good() && nRead);
+
+                    if ( pTempStream->GetError() )
+                        throw io::IOException();
+
+                    bSuccess = true;
+                }
+            }
+        }
+        catch (const uno::RuntimeException&)
+        {
+            pTempStream.reset();
+
+            if ( !aTempURL.isEmpty() )
+                ::utl::UCBContentHelper::Kill( aTempURL );
+
+            throw;
+        }
+        catch (const io::IOException&)
+        {
+            pTempStream.reset();
+
+            if ( !aTempURL.isEmpty() )
+                ::utl::UCBContentHelper::Kill( aTempURL );
+
+            throw;
+        }
+        catch (const uno::Exception&)
+        {
+        }
+
+        pTempStream.reset();
+
+        if ( !aTempURL.isEmpty() )
+            ::utl::UCBContentHelper::Kill( aTempURL );
+    }
+
+    if ( !bSuccess )
+        throw io::IOException(); // TODO/LATER: can't proceed with creation
+}
+
+OUString SAL_CALL OPackageStructureCreator::getImplementationName()
+{
+    return "com.sun.star.comp.embed.PackageStructureCreator";
+}
+
+sal_Bool SAL_CALL OPackageStructureCreator::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+uno::Sequence< OUString > SAL_CALL OPackageStructureCreator::getSupportedServiceNames()
+{
+    return { "com.sun.star.embed.PackageStructureCreator", "com.sun.star.comp.embed.PackageStructureCreator" };
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_embed_PackageStructureCreator_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new OPackageStructureCreator());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */