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

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

40 files changed, 20105 insertions, 0 deletions

diff --git a/sfx2/source/dialog/alienwarn.cxx b/sfx2/source/dialog/alienwarn.cxx
new file mode 100644
index 000000000..bce34556b
--- /dev/null
+++ b/sfx2/source/dialog/alienwarn.cxx
@@ -0,0 +1,75 @@
+/* -*- 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/saveopt.hxx>
+#include <alienwarn.hxx>
+
+SfxAlienWarningDialog::SfxAlienWarningDialog(weld::Window* pParent, const OUString& _rFormatName,
+                                             const OUString& _rDefaultExtension, bool rDefaultIsAlien)
+    : MessageDialogController(pParent, "sfx/ui/alienwarndialog.ui", "AlienWarnDialog", "ask")
+    , m_xKeepCurrentBtn(m_xBuilder->weld_button("save"))
+    , m_xUseDefaultFormatBtn(m_xBuilder->weld_button("cancel"))
+    , m_xWarningOnBox(m_xBuilder->weld_check_button("ask"))
+{
+    OUString aExtension = "ODF";
+
+    // replace formatname (text)
+    OUString sInfoText = m_xDialog->get_primary_text();
+    sInfoText = sInfoText.replaceAll( "%FORMATNAME", _rFormatName );
+    m_xDialog->set_primary_text(sInfoText);
+
+    // replace formatname (button)
+    sInfoText = m_xKeepCurrentBtn->get_label();
+    sInfoText = sInfoText.replaceAll( "%FORMATNAME", _rFormatName );
+    m_xKeepCurrentBtn->set_label(sInfoText);
+
+    // hide ODF explanation if default format is alien
+    // and set the proper extension in the button
+    if( rDefaultIsAlien )
+    {
+        m_xDialog->set_secondary_text(OUString());
+        aExtension = _rDefaultExtension.toAsciiUpperCase();
+    }
+
+    // replace defaultextension (button)
+    sInfoText = m_xUseDefaultFormatBtn->get_label();
+    sInfoText = sInfoText.replaceAll( "%DEFAULTEXTENSION", aExtension );
+    m_xUseDefaultFormatBtn->set_label(sInfoText);
+
+    // load value of "warning on" checkbox from save options
+    m_xWarningOnBox->set_active(SvtSaveOptions().IsWarnAlienFormat());
+}
+
+SfxAlienWarningDialog::~SfxAlienWarningDialog()
+{
+    try
+    {
+        // save value of "warning off" checkbox, if necessary
+        SvtSaveOptions aSaveOpt;
+        bool bChecked = m_xWarningOnBox->get_active();
+        if (aSaveOpt.IsWarnAlienFormat() != bChecked)
+            aSaveOpt.SetWarnAlienFormat(bChecked);
+    }
+    catch (...)
+    {
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/backingcomp.cxx b/sfx2/source/dialog/backingcomp.cxx
new file mode 100644
index 000000000..b70367a18
--- /dev/null
+++ b/sfx2/source/dialog/backingcomp.cxx
@@ -0,0 +1,743 @@
+/* -*- 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 "backingwindow.hxx"
+
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/awt/KeyEvent.hpp>
+#include <com/sun/star/frame/XLayoutManager.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/awt/XWindow.hpp>
+#include <com/sun/star/awt/XKeyListener.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/lang/XEventListener.hpp>
+#include <com/sun/star/lang/XComponent.hpp>
+#include <com/sun/star/lang/XTypeProvider.hpp>
+
+#include <cppuhelper/supportsservice.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <cppuhelper/typeprovider.hxx>
+#include <cppuhelper/weak.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <vcl/wrkwin.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/syswin.hxx>
+
+#include <sfx2/notebookbar/SfxNotebookBar.hxx>
+
+namespace {
+
+/**
+    implements the backing component.
+
+    This component is a special one, which doesn't provide a controller
+    nor a model. It supports the following features:
+        - Drag & Drop
+        - Key Accelerators
+        - Simple Menu
+        - Progress Bar
+        - Background
+ */
+class BackingComp : public  css::lang::XTypeProvider
+                  , public  css::lang::XServiceInfo
+                  , public  css::lang::XInitialization
+                  , public  css::frame::XController  // => XComponent
+                  , public  css::awt::XKeyListener // => XEventListener
+                  , public css::frame::XDispatchProvider
+                  , public css::frame::XDispatch
+                  , public  ::cppu::OWeakObject
+{
+private:
+    /** reference to the component window. */
+    css::uno::Reference< css::awt::XWindow > m_xWindow;
+
+    /** the owner frame of this component. */
+    css::uno::Reference< css::frame::XFrame > m_xFrame;
+
+    Size m_aInitialWindowMinSize;
+
+public:
+
+    explicit BackingComp();
+
+    // XInterface
+    virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type& aType ) override;
+    virtual void          SAL_CALL acquire       (                             ) throw(                          ) override;
+    virtual void          SAL_CALL release       (                             ) throw(                          ) override;
+
+    // XTypeProvide
+    virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes           () override;
+    virtual css::uno::Sequence< sal_Int8 >       SAL_CALL getImplementationId() 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;
+
+    // XInitialization
+    virtual void SAL_CALL initialize( const css::uno::Sequence< css::uno::Any >& lArgs ) override;
+
+    // XController
+    virtual void SAL_CALL attachFrame( const css::uno::Reference< css::frame::XFrame >& xFrame ) override;
+    virtual sal_Bool SAL_CALL attachModel( const css::uno::Reference< css::frame::XModel >& xModel ) override;
+    virtual sal_Bool SAL_CALL suspend( sal_Bool bSuspend ) override;
+    virtual css::uno::Any SAL_CALL getViewData() override;
+    virtual void SAL_CALL restoreViewData( const css::uno::Any& aData ) override;
+    virtual css::uno::Reference< css::frame::XModel > SAL_CALL getModel() override;
+    virtual css::uno::Reference< css::frame::XFrame > SAL_CALL getFrame() override;
+
+    // XKeyListener
+    virtual void SAL_CALL keyPressed ( const css::awt::KeyEvent& aEvent ) override;
+    virtual void SAL_CALL keyReleased( const css::awt::KeyEvent& aEvent ) override;
+
+    // XEventListener
+    virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) override;
+
+    // XComponent
+    virtual void SAL_CALL dispose            (                                                                   ) override;
+    virtual void SAL_CALL addEventListener   ( const css::uno::Reference< css::lang::XEventListener >& xListener ) override;
+    virtual void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener >& xListener ) override;
+
+    // XDispatchProvider
+    virtual css::uno::Reference< css::frame::XDispatch > SAL_CALL queryDispatch( const css::util::URL& aURL, const OUString& sTargetFrameName , sal_Int32 nSearchFlags ) override;
+    virtual css::uno::Sequence< css::uno::Reference< css::frame::XDispatch > > SAL_CALL queryDispatches( const css::uno::Sequence< css::frame::DispatchDescriptor >& lDescriptions    ) override;
+
+    // XDispatch
+    virtual void SAL_CALL dispatch( const css::util::URL& aURL, const css::uno::Sequence< css::beans::PropertyValue >& lArguments ) override;
+    virtual void SAL_CALL addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener, const css::util::URL& aURL ) override;
+    virtual void SAL_CALL removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener, const css::util::URL& aURL ) override;
+};
+
+BackingComp::BackingComp()
+{
+}
+
+/** return information about supported interfaces.
+
+    Some interfaces are supported by his class directly, but some other ones are
+    used by aggregation. An instance of this class must provide some window interfaces.
+    But it must represent a VCL window behind such interfaces too! So we use an internal
+    saved window member to ask it for its interfaces and return it. But we must be aware then,
+    that it can be destroyed from outside too ...
+
+    @param  aType
+                describe the required interface type
+
+    @return An Any holding the instance, which provides the queried interface.
+            Note: There exist two possible results ... this instance itself and her window member!
+ */
+
+css::uno::Any SAL_CALL BackingComp::queryInterface( /*IN*/ const css::uno::Type& aType )
+{
+    // first look for own supported interfaces
+    css::uno::Any aResult = ::cppu::queryInterface(
+                aType,
+                static_cast< css::lang::XTypeProvider* >(this),
+                static_cast< css::lang::XServiceInfo* >(this),
+                static_cast< css::lang::XInitialization* >(this),
+                static_cast< css::frame::XController* >(this),
+                static_cast< css::lang::XComponent* >(this),
+                static_cast< css::lang::XEventListener* >(this),
+                static_cast< css::awt::XKeyListener* >(static_cast< css::lang::XEventListener* >(this)),
+                static_cast< css::frame::XDispatchProvider* >(this),
+                static_cast< css::frame::XDispatch* >(this) );
+
+    // then look for supported window interfaces
+    // Note: They exist only, if this instance was initialized
+    // with a valid window reference. It's aggregation on demand ...
+    if (!aResult.hasValue())
+    {
+        /* SAFE { */
+        SolarMutexGuard aGuard;
+        if (m_xWindow.is())
+            aResult = m_xWindow->queryInterface(aType);
+        /* } SAFE */
+    }
+
+    // look for XWeak and XInterface
+    if (!aResult.hasValue())
+        aResult = OWeakObject::queryInterface(aType);
+
+    return aResult;
+}
+
+
+/** increase ref count of this instance.
+ */
+
+void SAL_CALL BackingComp::acquire()
+    throw()
+{
+    OWeakObject::acquire();
+}
+
+
+/** decrease ref count of this instance.
+ */
+
+void SAL_CALL BackingComp::release()
+    throw()
+{
+    OWeakObject::release();
+}
+
+
+/** return collection about all supported interfaces.
+
+    Optimize this method !
+    We initialize a static variable only one time.
+    And we don't must use a mutex at every call!
+    For the first call; pTypeCollection is NULL -
+    for the second call pTypeCollection is different from NULL!
+
+    @return A list of all supported interface types.
+*/
+
+css::uno::Sequence< css::uno::Type > SAL_CALL BackingComp::getTypes()
+{
+    static cppu::OTypeCollection aTypeCollection = [this]() {
+        SolarMutexGuard aGuard;
+        css::uno::Reference<css::lang::XTypeProvider> xProvider(m_xWindow, css::uno::UNO_QUERY);
+
+        css::uno::Sequence<css::uno::Type> lWindowTypes;
+        if (xProvider.is())
+            lWindowTypes = xProvider->getTypes();
+
+        return cppu::OTypeCollection(
+            cppu::UnoType<css::lang::XInitialization>::get(),
+            cppu::UnoType<css::lang::XTypeProvider>::get(),
+            cppu::UnoType<css::lang::XServiceInfo>::get(),
+            cppu::UnoType<css::frame::XController>::get(),
+            cppu::UnoType<css::lang::XComponent>::get(),
+            cppu::UnoType<css::frame::XDispatchProvider>::get(),
+            cppu::UnoType<css::frame::XDispatch>::get(), lWindowTypes);
+    }();
+
+    return aTypeCollection.getTypes();
+}
+
+
+/** create one unique Id for all instances of this class.
+
+    Optimize this method
+    We initialize a static variable only one time. And we don't must use a mutex at every call!
+    For the first call; pID is NULL - for the second call pID is different from NULL!
+
+    @return A byte array, which represent the unique id.
+*/
+
+css::uno::Sequence< sal_Int8 > SAL_CALL BackingComp::getImplementationId()
+{
+    return css::uno::Sequence<sal_Int8>();
+}
+
+OUString SAL_CALL BackingComp::getImplementationName()
+{
+    return "com.sun.star.comp.sfx2.BackingComp";
+}
+
+sal_Bool SAL_CALL BackingComp::supportsService( /*IN*/ const OUString& sServiceName )
+{
+    return cppu::supportsService(this, sServiceName);
+}
+
+css::uno::Sequence< OUString > SAL_CALL BackingComp::getSupportedServiceNames()
+{
+    return { "com.sun.star.frame.StartModule", "com.sun.star.frame.ProtocolHandler" };
+}
+
+
+/**
+    attach this component to a target frame.
+
+    We have to use the container window of this frame as parent window of our own component window.
+    But it's not allowed to work with it really. May another component used it too.
+    Currently we need it only to create our child component window and support it's
+    interfaces inside our queryInterface() method. The user of us must have e.g. the
+    XWindow interface of it to be able to call setComponent(xWindow,xController) at the
+    frame!
+
+    May he will do the following things:
+
+    <listing>
+        XController xBackingComp = (XController)UnoRuntime.queryInterface(
+            XController.class,
+            xSMGR.createInstance(SERVICENAME_STARTMODULE));
+
+        // at this time XWindow isn't present at this instance!
+        XWindow xBackingComp = (XWindow)UnoRuntime.queryInterface(
+            XWindow.class,
+            xBackingComp);
+
+        // attach controller to the frame
+        // We will use its container window, to create
+        // the component window. From now we offer the window interfaces!
+        xBackingComp.attachFrame(xFrame);
+
+        XWindow xBackingComp = (XWindow)UnoRuntime.queryInterface(
+            XWindow.class,
+            xBackingComp);
+
+        // Our user can set us at the frame as new component
+        xFrame.setComponent(xBackingWin, xBackingComp);
+
+        // But that had no effect to our view state.
+        // We must be started to create our UI elements like e.g. menu, title, background ...
+        XInitialization xBackingInit = (XInitialization)UnoRuntime.queryInterface(
+            XInitialization.class,
+            xBackingComp);
+
+        xBackingInit.initialize(lArgs);
+    </listing>
+
+    @param  xFrame
+                reference to our new target frame
+
+    @throw  css::uno::RuntimeException
+                if the given frame reference is wrong or component window couldn't be created
+                successfully.
+                We throw it too, if we already attached to a frame. Because we don't support
+                reparenting of our component window on demand!
+*/
+
+void SAL_CALL BackingComp::attachFrame( /*IN*/ const css::uno::Reference< css::frame::XFrame >& xFrame )
+{
+    /* SAFE */
+    SolarMutexGuard aGuard;
+
+    // check some required states
+    if (m_xFrame.is())
+        throw css::uno::RuntimeException(
+                "already attached",
+                static_cast< ::cppu::OWeakObject* >(this));
+
+    if (!xFrame.is())
+        throw css::uno::RuntimeException(
+                "invalid frame reference",
+                static_cast< ::cppu::OWeakObject* >(this));
+
+    if (!m_xWindow.is())
+        return; // disposed
+
+    // safe the frame reference
+    m_xFrame = xFrame;
+
+    // initialize the component and its parent window
+    css::uno::Reference< css::awt::XWindow > xParentWindow = xFrame->getContainerWindow();
+    VclPtr< WorkWindow > pParent = static_cast<WorkWindow*>(VCLUnoHelper::GetWindow(xParentWindow).get());
+    VclPtr< vcl::Window > pWindow = VCLUnoHelper::GetWindow(m_xWindow);
+
+    // disable full screen mode of the frame!
+    if (pParent && pParent->IsFullScreenMode())
+    {
+        pParent->ShowFullScreenMode(false);
+        pParent->SetMenuBarMode(MenuBarMode::Normal);
+    }
+
+    // create the menu bar for the backing component
+    css::uno::Reference< css::beans::XPropertySet > xPropSet(m_xFrame, css::uno::UNO_QUERY_THROW);
+    css::uno::Reference< css::frame::XLayoutManager > xLayoutManager;
+    xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager;
+    if (xLayoutManager.is())
+    {
+        xLayoutManager->lock();
+        xLayoutManager->createElement("private:resource/menubar/menubar");
+        xLayoutManager->unlock();
+    }
+
+    if (pWindow)
+    {
+        // set help ID for our canvas
+        pWindow->SetHelpId("FWK_HID_BACKINGWINDOW");
+    }
+
+    // inform BackingWindow about frame
+    BackingWindow* pBack = dynamic_cast<BackingWindow*>(pWindow.get());
+    if( pBack )
+        pBack->setOwningFrame( m_xFrame );
+
+    // set NotebookBar
+    SystemWindow* pSysWindow = pParent;
+    if (pSysWindow)
+    {
+        //sfx2::SfxNotebookBar::StateMethod(pSysWindow, m_xFrame, "sfx/ui/notebookbar.ui");
+    }
+
+    // Set a minimum size for Start Center
+    if( !pParent || !pBack )
+        return;
+
+    long nMenuHeight = 0;
+    vcl::Window* pMenu = pParent->GetWindow(GetWindowType::Next);
+    if( pMenu )
+        nMenuHeight = pMenu->GetSizePixel().Height();
+
+    m_aInitialWindowMinSize = pParent->GetMinOutputSizePixel();
+    if (!m_aInitialWindowMinSize.Width())
+        m_aInitialWindowMinSize.AdjustWidth(1);
+    if (!m_aInitialWindowMinSize.Height())
+        m_aInitialWindowMinSize.AdjustHeight(1);
+
+    pParent->SetMinOutputSizePixel(
+        Size(
+            pBack->get_width_request(),
+            pBack->get_height_request() + nMenuHeight));
+
+    /* } SAFE */
+}
+
+
+/** not supported.
+
+    This component does not know any model. It will be represented by a window and
+    its controller only.
+
+    return  <FALSE/> every time.
+ */
+
+sal_Bool SAL_CALL BackingComp::attachModel( /*IN*/ const css::uno::Reference< css::frame::XModel >& )
+{
+    return false;
+}
+
+
+/** not supported.
+
+    This component does not know any model. It will be represented by a window and
+    its controller only.
+
+    return  An empty reference every time.
+ */
+
+css::uno::Reference< css::frame::XModel > SAL_CALL BackingComp::getModel()
+{
+    return css::uno::Reference< css::frame::XModel >();
+}
+
+
+/** not supported.
+
+    return  An empty value.
+ */
+
+css::uno::Any SAL_CALL BackingComp::getViewData()
+{
+    return css::uno::Any();
+}
+
+
+/** not supported.
+
+    @param  aData
+                not used.
+ */
+
+void SAL_CALL BackingComp::restoreViewData( /*IN*/ const css::uno::Any& )
+{
+}
+
+
+/** returns the attached frame for this component.
+
+    @see    attachFrame()
+
+    @return The internally saved frame reference.
+            Can be null, if attachFrame() was not called before.
+ */
+
+css::uno::Reference< css::frame::XFrame > SAL_CALL BackingComp::getFrame()
+{
+    /* SAFE { */
+    SolarMutexGuard aGuard;
+    return m_xFrame;
+    /* } SAFE */
+}
+
+
+/** ask controller for its current working state.
+
+    If someone wishes to close this component, it must suspend the controller before.
+    That will be a chance for it to disagree with that AND show any UI for a possible
+    UI user.
+
+    @param  bSuspend
+                If it's set to sal_True this controller should be suspended.
+                sal_False will resuspend it.
+
+    @return sal_True if the request could be finished successfully; sal_False otherwise.
+ */
+
+sal_Bool SAL_CALL BackingComp::suspend( /*IN*/ sal_Bool )
+{
+    /* FIXME ... implemented by using default :-( */
+    return true;
+}
+
+
+/** callback from our window member.
+
+    Our internal saved window wish to die. It will be disposed from outside (may be the frame)
+    and inform us. We must release its reference only here. Of course we check the given reference
+    here and reject callback from unknown sources.
+
+    Note: deregistration as listener isn't necessary here. The broadcaster do it automatically.
+
+    @param  aEvent
+                describe the broadcaster of this callback
+
+    @throw css::uno::RuntimeException
+                if the broadcaster doesn't represent the expected window reference.
+*/
+
+void SAL_CALL BackingComp::disposing( /*IN*/ const css::lang::EventObject& aEvent )
+{
+    // Attention: don't free m_pAccExec here! see comments inside dtor and
+    // keyPressed() for further details.
+
+    /* SAFE { */
+    SolarMutexGuard aGuard;
+
+    if (!aEvent.Source.is() || aEvent.Source!=m_xWindow || !m_xWindow.is())
+        throw css::uno::RuntimeException(
+                "unexpected source or called twice",
+                static_cast< ::cppu::OWeakObject* >(this));
+
+    m_xWindow.clear();
+
+    /* } SAFE */
+}
+
+
+/** kill this instance.
+
+    It can be called from our owner frame only. But there is no possibility to check the caller.
+    We have to release all our internal used resources and die. From this point we can throw
+    DisposedExceptions for every further interface request... but current implementation doesn't do so...
+
+*/
+
+void SAL_CALL BackingComp::dispose()
+{
+    /* SAFE { */
+    SolarMutexGuard aGuard;
+
+    if (m_xFrame.is())
+    {
+        css::uno::Reference< css::awt::XWindow > xParentWindow = m_xFrame->getContainerWindow();
+        VclPtr< WorkWindow > pParent = static_cast<WorkWindow*>(VCLUnoHelper::GetWindow(xParentWindow).get());
+        if (pParent)
+        {
+            pParent->SetMinOutputSizePixel(m_aInitialWindowMinSize);
+            // hide NotebookBar
+            sfx2::SfxNotebookBar::CloseMethod(static_cast<SystemWindow*>(pParent));
+        }
+    }
+
+    // stop listening at the window
+    if (m_xWindow.is())
+    {
+        m_xWindow->removeEventListener(this);
+        m_xWindow->removeKeyListener(this);
+        m_xWindow.clear();
+    }
+
+    // forget all other used references
+    m_xFrame.clear();
+
+    /* } SAFE */
+}
+
+
+/** not supported.
+
+    @param  xListener
+                not used.
+
+    @throw  css::uno::RuntimeException
+                because the listener expect to be holded alive by this container.
+                We must inform it about this unsupported feature.
+ */
+
+void SAL_CALL BackingComp::addEventListener( /*IN*/ const css::uno::Reference< css::lang::XEventListener >& )
+{
+    throw css::uno::RuntimeException(
+            "not supported",
+            static_cast< ::cppu::OWeakObject* >(this));
+}
+
+
+/** not supported.
+
+    Because registration is not supported too, we must do nothing here. Nobody can call this method really.
+
+    @param  xListener
+                not used.
+ */
+
+void SAL_CALL BackingComp::removeEventListener( /*IN*/ const css::uno::Reference< css::lang::XEventListener >& )
+{
+}
+
+
+/**
+    force initialization for this component.
+
+    Inside attachFrame() we created our component window. But it was not allowed there, to
+    initialize it. E.g. the menu must be set at the container window of the frame, which
+    is our parent window. But may at that time another component used it.
+    That's why our creator has to inform us, when it's time to initialize us really.
+    Currently only calling of this method must be done. But further implementations
+    can use special in parameter to configure this initialization...
+
+    @param  lArgs
+                currently not used
+
+    @throw  css::uno::RuntimeException
+                if some resources are missing
+                Means if may be attachedFrame() wasn't called before.
+ */
+
+void SAL_CALL BackingComp::initialize( /*IN*/ const css::uno::Sequence< css::uno::Any >& lArgs )
+{
+    /* SAFE { */
+    SolarMutexGuard aGuard;
+
+    if (m_xWindow.is())
+        throw css::uno::Exception(
+                "already initialized",
+                static_cast< ::cppu::OWeakObject* >(this));
+
+    css::uno::Reference< css::awt::XWindow > xParentWindow;
+    if (
+        (lArgs.getLength()!=1         ) ||
+        (!(lArgs[0] >>= xParentWindow)) ||
+        (!xParentWindow.is()          )
+       )
+    {
+        throw css::uno::Exception(
+                "wrong or corrupt argument list",
+                static_cast< ::cppu::OWeakObject* >(this));
+    }
+
+    // create the component window
+    VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(xParentWindow);
+    VclPtr<vcl::Window> pWindow = VclPtr<BackingWindow>::Create(pParent);
+    m_xWindow = VCLUnoHelper::GetInterface(pWindow);
+
+    if (!m_xWindow.is())
+        throw css::uno::RuntimeException(
+                "couldn't create component window",
+                static_cast< ::cppu::OWeakObject* >(this));
+
+    // start listening for window disposing
+    // It's set at our owner frame as component window later too. So it will may be disposed there ...
+    m_xWindow->addEventListener(static_cast< css::lang::XEventListener* >(this));
+
+    m_xWindow->setVisible(true);
+
+    /* } SAFE */
+}
+
+
+void SAL_CALL BackingComp::keyPressed( /*IN*/ const css::awt::KeyEvent&  )
+{
+}
+
+
+void SAL_CALL BackingComp::keyReleased( /*IN*/ const css::awt::KeyEvent& )
+{
+    /* Attention
+        Please use keyPressed() instead of this method. Otherwise it would be possible, that
+        - a key input may be first switch to the backing mode
+        - and this component register itself as key listener too
+        - and it's first event will be a keyReleased() for the already well known event, which switched to the backing mode!
+        So it will be handled twice! document => backing mode => exit app...
+     */
+}
+
+// XDispatchProvider
+css::uno::Reference< css::frame::XDispatch > SAL_CALL BackingComp::queryDispatch( const css::util::URL& aURL, const OUString& /*sTargetFrameName*/, sal_Int32 /*nSearchFlags*/ )
+{
+    css::uno::Reference< css::frame::XDispatch > xDispatch;
+    if ( aURL.Protocol == "vnd.org.libreoffice.recentdocs:" )
+        xDispatch = this;
+
+    return xDispatch;
+}
+
+css::uno::Sequence < css::uno::Reference< css::frame::XDispatch > > SAL_CALL BackingComp::queryDispatches( const css::uno::Sequence < css::frame::DispatchDescriptor >& seqDescripts )
+{
+    sal_Int32 nCount = seqDescripts.getLength();
+    css::uno::Sequence < css::uno::Reference < XDispatch > > lDispatcher( nCount );
+
+    std::transform(seqDescripts.begin(), seqDescripts.end(), lDispatcher.begin(),
+        [this](const css::frame::DispatchDescriptor& rDesc) -> css::uno::Reference<XDispatch> {
+            return queryDispatch(rDesc.FeatureURL, rDesc.FrameName, rDesc.SearchFlags); });
+
+    return lDispatcher;
+}
+
+// XDispatch
+void SAL_CALL BackingComp::dispatch( const css::util::URL& aURL, const css::uno::Sequence < css::beans::PropertyValue >& /*lArgs*/ )
+{
+    // vnd.org.libreoffice.recentdocs:ClearRecentFileList  - clear recent files
+    if ( aURL.Path != "ClearRecentFileList" )
+        return;
+
+    VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow(m_xWindow);
+    BackingWindow* pBack = dynamic_cast<BackingWindow*>(pWindow.get());
+    if( !pBack )
+        return;
+
+    pBack->clearRecentFileList();
+
+    // Recalculate minimum width
+    css::uno::Reference< css::awt::XWindow > xParentWindow = m_xFrame->getContainerWindow();
+    VclPtr< WorkWindow > pParent = static_cast<WorkWindow*>(VCLUnoHelper::GetWindow(xParentWindow).get());
+    if( pParent )
+    {
+        pParent->SetMinOutputSizePixel( Size(
+                pBack->get_width_request(),
+                pParent->GetMinOutputSizePixel().Height()) );
+    }
+}
+
+void SAL_CALL BackingComp::addStatusListener( const css::uno::Reference< css::frame::XStatusListener >& /*xControl*/, const css::util::URL& /*aURL*/ )
+{
+}
+
+void SAL_CALL BackingComp::removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& /*xControl*/, const css::util::URL& /*aURL*/ )
+{
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_sfx2_BackingComp_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new BackingComp);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/backingwindow.cxx b/sfx2/source/dialog/backingwindow.cxx
new file mode 100644
index 000000000..caff3c45a
--- /dev/null
+++ b/sfx2/source/dialog/backingwindow.cxx
@@ -0,0 +1,804 @@
+/* -*- 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 "backingwindow.hxx"
+
+#include <vcl/accel.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/syswin.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/fixed.hxx>
+
+#include <unotools/historyoptions.hxx>
+#include <unotools/moduleoptions.hxx>
+#include <svtools/openfiledroptargetlistener.hxx>
+#include <svtools/colorcfg.hxx>
+#include <svtools/langhelp.hxx>
+#include <templateviewitem.hxx>
+
+#include <vcl/menubtn.hxx>
+
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+
+#include <tools/diagnose_ex.h>
+
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/datatransfer/dnd/XDropTarget.hpp>
+#include <com/sun/star/document/MacroExecMode.hpp>
+#include <com/sun/star/document/UpdateDocMode.hpp>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/system/SystemShellExecute.hpp>
+#include <com/sun/star/system/SystemShellExecuteFlags.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/task/InteractionHandler.hpp>
+
+#include <officecfg/Office/Common.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::document;
+
+const char SERVICENAME_CFGREADACCESS[] = "com.sun.star.configuration.ConfigurationAccess";
+
+// increase size of the text in the buttons on the left fMultiplier-times
+float const g_fMultiplier = 1.4f;
+
+BackingWindow::BackingWindow( vcl::Window* i_pParent ) :
+    Window( i_pParent ),
+    mbLocalViewInitialized(false),
+    mbInitControls( false )
+{
+    m_pUIBuilder.reset(new VclBuilder(this, getUIRootDir(), "sfx/ui/startcenter.ui", "StartCenter" ));
+
+    get(mpOpenButton, "open_all");
+    get(mpRemoteButton, "open_remote");
+    get(mpRecentButton, "open_recent");
+    get(mpTemplateButton, "templates_all");
+
+    get(mpCreateLabel, "create_label");
+
+    get(mpWriterAllButton, "writer_all");
+    get(mpCalcAllButton, "calc_all");
+    get(mpImpressAllButton, "impress_all");
+    get(mpDrawAllButton, "draw_all");
+    get(mpDBAllButton, "database_all");
+    get(mpMathAllButton, "math_all");
+
+    get(mpHelpButton, "help");
+    //set an alternative help label that doesn't hotkey the H of the Help menu
+    mpHelpButton->SetText(get<Window>("althelplabel")->GetText());
+    get(mpExtensionsButton, "extensions");
+
+    //Containers are invisible to cursor traversal
+    //So on pressing "right" when in Help the
+    //extension button is considered as a candidate
+
+    //But the containers are not invisible to the PushButton ctor which checks
+    //if the preceding window of its parent is a button and if it then
+    //defaults to grouping with it and if it is not a button defaults to
+    //setting itself as the start of a new group.
+
+    //So here take the second button and set it as explicitly not the start
+    //of a group, i.e. allow it to be grouped with the preceding
+    //PushButton so when seen as a candidate by cursor travelling
+    //it will be accepted as a continuation of the group.
+    WinBits nBits = mpExtensionsButton->GetStyle();
+    nBits &= ~WB_GROUP;
+    nBits |= WB_NOGROUP;
+    mpExtensionsButton->SetStyle(nBits);
+    assert(mpHelpButton->GetStyle() & WB_GROUP);
+    assert(!(mpExtensionsButton->GetStyle() & WB_GROUP));
+
+    get(mpAllButtonsBox, "all_buttons_box");
+    get(mpButtonsBox, "buttons_box");
+    get(mpSmallButtonsBox, "small_buttons_box");
+
+    get(mpAllRecentThumbnails, "all_recent");
+    get(mpLocalView, "local_view");
+
+    maDndWindows.emplace_back(mpAllRecentThumbnails);
+
+    try
+    {
+        mxContext.set( ::comphelper::getProcessComponentContext(), uno::UNO_SET_THROW );
+    }
+    catch (const Exception&)
+    {
+        TOOLS_WARN_EXCEPTION( "fwk", "BackingWindow" );
+    }
+
+    // fdo#34392: we do the layout dynamically, the layout depends on the font,
+    // so we should handle data changed events (font changing) of the last child
+    // control, at this point all the controls have updated settings (i.e. font).
+
+    EnableChildTransparentMode();
+
+    SetStyle( GetStyle() | WB_DIALOGCONTROL );
+
+    // get dispatch provider
+    Reference<XDesktop2> xDesktop = Desktop::create( comphelper::getProcessComponentContext() );
+    mxDesktopDispatchProvider = xDesktop;
+
+    // init background
+    SetBackground();
+}
+
+BackingWindow::~BackingWindow()
+{
+    disposeOnce();
+}
+
+void BackingWindow::dispose()
+{
+    // deregister drag&drop helper
+    if (mxDropTargetListener.is())
+    {
+        for (auto const & pDndWin : maDndWindows)
+        {
+            css::uno::Reference< css::datatransfer::dnd::XDropTarget > xDropTarget =
+                    pDndWin->GetDropTarget();
+            if (xDropTarget.is())
+            {
+                xDropTarget->removeDropTargetListener(mxDropTargetListener);
+                xDropTarget->setActive(false);
+            }
+        }
+        mxDropTargetListener.clear();
+    }
+    disposeBuilder();
+    maDndWindows.clear();
+    mpOpenButton.clear();
+    mpRemoteButton.clear();
+    mpRecentButton.clear();
+    mpTemplateButton.clear();
+    mpCreateLabel.clear();
+    mpWriterAllButton.clear();
+    mpCalcAllButton.clear();
+    mpImpressAllButton.clear();
+    mpDrawAllButton.clear();
+    mpDBAllButton.clear();
+    mpMathAllButton.clear();
+    mpHelpButton.clear();
+    mpExtensionsButton.clear();
+    mpAllButtonsBox.clear();
+    mpButtonsBox.clear();
+    mpSmallButtonsBox.clear();
+    mpAllRecentThumbnails.clear();
+    mpLocalView.clear();
+    vcl::Window::dispose();
+}
+
+void BackingWindow::initControls()
+{
+    if( mbInitControls )
+        return;
+
+    mbInitControls = true;
+
+    // collect the URLs of the entries in the File/New menu
+    SvtModuleOptions    aModuleOptions;
+
+    if (aModuleOptions.IsModuleInstalled(SvtModuleOptions::EModule::WRITER))
+        mpAllRecentThumbnails->mnFileTypes |= sfx2::ApplicationType::TYPE_WRITER;
+
+    if (aModuleOptions.IsModuleInstalled(SvtModuleOptions::EModule::CALC))
+        mpAllRecentThumbnails->mnFileTypes |= sfx2::ApplicationType::TYPE_CALC;
+
+    if (aModuleOptions.IsModuleInstalled(SvtModuleOptions::EModule::IMPRESS))
+        mpAllRecentThumbnails->mnFileTypes |= sfx2::ApplicationType::TYPE_IMPRESS;
+
+    if (aModuleOptions.IsModuleInstalled(SvtModuleOptions::EModule::DRAW))
+        mpAllRecentThumbnails->mnFileTypes |= sfx2::ApplicationType::TYPE_DRAW;
+
+    if (aModuleOptions.IsModuleInstalled(SvtModuleOptions::EModule::DATABASE))
+        mpAllRecentThumbnails->mnFileTypes |= sfx2::ApplicationType::TYPE_DATABASE;
+
+    if (aModuleOptions.IsModuleInstalled(SvtModuleOptions::EModule::MATH))
+        mpAllRecentThumbnails->mnFileTypes |= sfx2::ApplicationType::TYPE_MATH;
+
+    mpAllRecentThumbnails->mnFileTypes |= sfx2::ApplicationType::TYPE_OTHER;
+    mpAllRecentThumbnails->Reload();
+    mpAllRecentThumbnails->ShowTooltips( true );
+    mpRecentButton->SetActive(true);
+
+    //initialize Template view
+    mpLocalView->SetStyle( mpLocalView->GetStyle() | WB_VSCROLL);
+    mpLocalView->Hide();
+
+    //set handlers
+    mpLocalView->setCreateContextMenuHdl(LINK(this, BackingWindow, CreateContextMenuHdl));
+    mpLocalView->setOpenTemplateHdl(LINK(this, BackingWindow, OpenTemplateHdl));
+    mpLocalView->setEditTemplateHdl(LINK(this, BackingWindow, EditTemplateHdl));
+    mpLocalView->ShowTooltips( true );
+
+    checkInstalledModules();
+
+    mpExtensionsButton->SetClickHdl(LINK(this, BackingWindow, ExtLinkClickHdl));
+
+    mpOpenButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    mpRemoteButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    mpWriterAllButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    mpDrawAllButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    mpCalcAllButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    mpDBAllButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    mpImpressAllButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    mpMathAllButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+
+    setupMenuButton(mpRecentButton);
+    setupMenuButton(mpTemplateButton);
+
+    ApplyStyleSettings();
+}
+
+void BackingWindow::DataChanged(const DataChangedEvent& rDCEvt)
+{
+    if ((rDCEvt.GetType() != DataChangedEventType::SETTINGS)
+            || !(rDCEvt.GetFlags() & AllSettingsFlags::STYLE))
+    {
+        vcl::Window::DataChanged(rDCEvt);
+        return;
+    }
+
+    ApplyStyleSettings();
+    Invalidate();
+}
+
+template <typename WidgetClass>
+void BackingWindow::setLargerFont(WidgetClass& pWidget, const vcl::Font& rFont)
+{
+    vcl::Font aFont(rFont);
+    aFont.SetFontSize(Size(0, aFont.GetFontSize().Height() * g_fMultiplier));
+    pWidget->SetControlFont(aFont);
+}
+
+void BackingWindow::ApplyStyleSettings()
+{
+    const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
+    const Color aButtonsBackground(rStyleSettings.GetWindowColor());
+    const vcl::Font& aButtonFont(rStyleSettings.GetPushButtonFont());
+    const vcl::Font& aLabelFont(rStyleSettings.GetLabelFont());
+
+    // setup larger fonts
+    setLargerFont(mpOpenButton, aButtonFont);
+    setLargerFont(mpOpenButton, aButtonFont);
+    setLargerFont(mpRemoteButton, aButtonFont);
+    setLargerFont(mpRecentButton, aButtonFont);
+    setLargerFont(mpTemplateButton, aButtonFont);
+    setLargerFont(mpWriterAllButton, aButtonFont);
+    setLargerFont(mpDrawAllButton, aButtonFont);
+    setLargerFont(mpCalcAllButton, aButtonFont);
+    setLargerFont(mpDBAllButton, aButtonFont);
+    setLargerFont(mpImpressAllButton, aButtonFont);
+    setLargerFont(mpMathAllButton, aButtonFont);
+    setLargerFont(mpCreateLabel, aLabelFont);
+
+    // motif image under the buttons
+    Wallpaper aWallpaper(get<FixedImage>("motif")->GetImage().GetBitmapEx());
+    aWallpaper.SetStyle(WallpaperStyle::BottomRight);
+    aWallpaper.SetColor(aButtonsBackground);
+    mpButtonsBox->SetBackground(aWallpaper);
+
+    mpAllButtonsBox->SetBackground(aButtonsBackground);
+    mpSmallButtonsBox->SetBackground(aButtonsBackground);
+
+    Resize();
+
+    // compute the menubar height
+    sal_Int32 nMenuHeight = 0;
+    SystemWindow* pSystemWindow = GetSystemWindow();
+    if (pSystemWindow)
+    {
+        MenuBar* pMenuBar = pSystemWindow->GetMenuBar();
+        if (pMenuBar)
+            nMenuHeight = pMenuBar->ImplGetWindow()->GetOutputSizePixel().Height();
+    }
+
+    set_width_request(mpAllRecentThumbnails->get_width_request() + mpAllButtonsBox->GetOptimalSize().Width());
+    set_height_request(nMenuHeight + mpAllButtonsBox->GetOptimalSize().Height());
+}
+
+void BackingWindow::initializeLocalView()
+{
+    if (!mbLocalViewInitialized)
+    {
+        mbLocalViewInitialized = true;
+        mpLocalView->Populate();
+        mpLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::NONE));
+        mpLocalView->showAllTemplates();
+    }
+}
+
+void BackingWindow::setupMenuButton(MenuToggleButton* pButton)
+{
+    pButton->SetDelayMenu(true);
+    pButton->SetDropDown(PushButtonDropdownStyle::SplitMenuButton);
+
+    PopupMenu* pMenu = pButton->GetPopupMenu();
+    pMenu->SetMenuFlags(pMenu->GetMenuFlags() | MenuFlags::AlwaysShowDisabledEntries);
+
+    pButton->SetClickHdl(LINK(this, BackingWindow, ClickHdl));
+    pButton->SetSelectHdl(LINK(this, BackingWindow, MenuSelectHdl));
+}
+
+void BackingWindow::checkInstalledModules()
+{
+    SvtModuleOptions aModuleOpt;
+
+    mpWriterAllButton->Enable( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::WRITER ));
+
+    mpCalcAllButton->Enable( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::CALC ) );
+
+    mpImpressAllButton->Enable( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::IMPRESS ) );
+
+    mpDrawAllButton->Enable( aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::DRAW ) );
+
+    mpMathAllButton->Enable(aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::MATH ));
+
+    mpDBAllButton->Enable(aModuleOpt.IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ));
+}
+
+void BackingWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
+{
+    Resize();
+
+    Wallpaper aBack(svtools::ColorConfig().GetColorValue(::svtools::APPBACKGROUND).nColor);
+    vcl::Region aClip(tools::Rectangle(Point(0, 0), GetOutputSizePixel()));
+
+    aClip.Exclude(maStartCentButtons);
+
+    rRenderContext.Push(PushFlags::CLIPREGION);
+    rRenderContext.IntersectClipRegion(aClip);
+    rRenderContext.DrawWallpaper(tools::Rectangle(Point(0, 0), GetOutputSizePixel()), aBack);
+    rRenderContext.Pop();
+
+    ScopedVclPtrInstance<VirtualDevice> pVDev(rRenderContext);
+    pVDev->EnableRTL(rRenderContext.IsRTLEnabled());
+    pVDev->SetOutputSizePixel(maStartCentButtons.GetSize());
+    Point aOffset(Point(0, 0) - maStartCentButtons.TopLeft());
+    pVDev->DrawWallpaper(tools::Rectangle(aOffset, GetOutputSizePixel()), aBack);
+
+    rRenderContext.DrawOutDev(maStartCentButtons.TopLeft(), maStartCentButtons.GetSize(),
+                              Point(0, 0), maStartCentButtons.GetSize(),
+                              *pVDev);
+}
+
+bool BackingWindow::PreNotify(NotifyEvent& rNEvt)
+{
+    if( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
+    {
+        const KeyEvent* pEvt = rNEvt.GetKeyEvent();
+        const vcl::KeyCode& rKeyCode(pEvt->GetKeyCode());
+
+        // Subwindows of BackingWindow: Sidebar and Thumbnail view
+        if( rKeyCode.GetCode() == KEY_F6 )
+        {
+            if( rKeyCode.IsShift() ) // Shift + F6
+            {
+                if( mpAllRecentThumbnails->HasFocus() || mpLocalView->HasFocus())
+                {
+                    mpOpenButton->GrabFocus();
+                    return true;
+                }
+            }
+            else if ( rKeyCode.IsMod1() ) // Ctrl + F6
+            {
+                if(mpAllRecentThumbnails->IsVisible())
+                {
+                    mpAllRecentThumbnails->GrabFocus();
+                    return true;
+                }
+                else if(mpLocalView->IsVisible())
+                {
+                    mpLocalView->GrabFocus();
+                    return true;
+                }
+            }
+            else // F6
+            {
+                if( mpAllButtonsBox->HasChildPathFocus() )
+                {
+                    if(mpAllRecentThumbnails->IsVisible())
+                    {
+                        mpAllRecentThumbnails->GrabFocus();
+                        return true;
+                    }
+                    else if(mpLocalView->IsVisible())
+                    {
+                        mpLocalView->GrabFocus();
+                        return true;
+                    }
+                }
+            }
+        }
+
+        // try the 'normal' accelerators (so that eg. Ctrl+Q works)
+        if (!mpAccExec)
+        {
+            mpAccExec = svt::AcceleratorExecute::createAcceleratorHelper();
+            mpAccExec->init( comphelper::getProcessComponentContext(), mxFrame);
+        }
+
+        const OUString aCommand = mpAccExec->findCommand(svt::AcceleratorExecute::st_VCLKey2AWTKey(rKeyCode));
+        if ((aCommand != "vnd.sun.star.findbar:FocusToFindbar") && pEvt && mpAccExec->execute(rKeyCode))
+            return true;
+    }
+    else if (rNEvt.GetType() == MouseNotifyEvent::COMMAND)
+    {
+        Accelerator::ToggleMnemonicsOnHierarchy(*rNEvt.GetCommandEvent(), this);
+    }
+
+    return Window::PreNotify( rNEvt );
+}
+
+void BackingWindow::GetFocus()
+{
+    GetFocusFlags nFlags = GetParent()->GetGetFocusFlags();
+    if( nFlags & GetFocusFlags::F6 )
+    {
+        if( nFlags & GetFocusFlags::Forward ) // F6
+        {
+            mpOpenButton->GrabFocus();
+            return;
+        }
+        else // Shift + F6 or Ctrl + F6
+        {
+            mpAllRecentThumbnails->GrabFocus();
+            return;
+        }
+    }
+    Window::GetFocus();
+}
+
+void BackingWindow::setOwningFrame( const css::uno::Reference< css::frame::XFrame >& xFrame )
+{
+    mxFrame = xFrame;
+    if( ! mbInitControls )
+        initControls();
+
+    // establish drag&drop mode
+    mxDropTargetListener.set(new OpenFileDropTargetListener(mxContext, mxFrame));
+
+    for (auto const & pDndWin : maDndWindows)
+    {
+        css::uno::Reference< css::datatransfer::dnd::XDropTarget > xDropTarget =
+            pDndWin->GetDropTarget();
+        if (xDropTarget.is())
+        {
+            xDropTarget->addDropTargetListener(mxDropTargetListener);
+            xDropTarget->setActive(true);
+        }
+    }
+}
+
+void BackingWindow::Resize()
+{
+    maStartCentButtons = tools::Rectangle( Point(0, 0), GetOutputSizePixel() );
+
+    if (isLayoutEnabled(this))
+        VclContainer::setLayoutAllocation(*GetWindow(GetWindowType::FirstChild),
+            maStartCentButtons.TopLeft(), maStartCentButtons.GetSize());
+
+    if (!IsInPaint())
+        Invalidate();
+}
+
+IMPL_LINK(BackingWindow, ExtLinkClickHdl, Button*, pButton, void)
+{
+    OUString aNode;
+
+    if (pButton == mpExtensionsButton)
+        aNode = "AddFeatureURL";
+
+    if (aNode.isEmpty())
+        return;
+
+    try
+    {
+        uno::Sequence<uno::Any> args(comphelper::InitAnyPropertySequence(
+        {
+            {"nodepath", uno::Any(OUString("/org.openoffice.Office.Common/Help/StartCenter"))}
+        }));
+
+        Reference<lang::XMultiServiceFactory> xConfig = configuration::theDefaultProvider::get( comphelper::getProcessComponentContext() );
+        Reference<container::XNameAccess> xNameAccess(xConfig->createInstanceWithArguments(SERVICENAME_CFGREADACCESS, args), UNO_QUERY);
+        if (xNameAccess.is())
+        {
+            OUString sURL;
+            Any value(xNameAccess->getByName(aNode));
+
+            sURL = value.get<OUString>();
+            localizeWebserviceURI(sURL);
+
+            Reference<css::system::XSystemShellExecute> const
+                xSystemShellExecute(
+                    css::system::SystemShellExecute::create(
+                        ::comphelper::getProcessComponentContext()));
+            xSystemShellExecute->execute(sURL, OUString(),
+                css::system::SystemShellExecuteFlags::URIS_ONLY);
+        }
+    }
+    catch (const Exception&)
+    {
+    }
+}
+
+IMPL_LINK( BackingWindow, ClickHdl, Button*, pButton, void )
+{
+    // dispatch the appropriate URL and end the dialog
+    if( pButton == mpWriterAllButton )
+        dispatchURL( "private:factory/swriter" );
+    else if( pButton == mpCalcAllButton )
+        dispatchURL( "private:factory/scalc" );
+    else if( pButton == mpImpressAllButton )
+        dispatchURL( "private:factory/simpress?slot=6686" );
+    else if( pButton == mpDrawAllButton )
+        dispatchURL( "private:factory/sdraw" );
+    else if( pButton == mpDBAllButton )
+        dispatchURL( "private:factory/sdatabase?Interactive" );
+    else if( pButton == mpMathAllButton )
+        dispatchURL( "private:factory/smath" );
+    else if( pButton == mpOpenButton )
+    {
+        Reference< XDispatchProvider > xFrame( mxFrame, UNO_QUERY );
+
+        Sequence< css::beans::PropertyValue > aArgs(1);
+        PropertyValue* pArg = aArgs.getArray();
+        pArg[0].Name = "Referer";
+        pArg[0].Value <<= OUString("private:user");
+
+        dispatchURL( ".uno:Open", OUString(), xFrame, aArgs );
+    }
+    else if( pButton == mpRemoteButton )
+    {
+        Reference< XDispatchProvider > xFrame( mxFrame, UNO_QUERY );
+
+        Sequence< css::beans::PropertyValue > aArgs(0);
+
+        dispatchURL( ".uno:OpenRemote", OUString(), xFrame, aArgs );
+    }
+    else if( pButton == mpRecentButton )
+    {
+        mpLocalView->Hide();
+        mpAllRecentThumbnails->Show();
+        mpAllRecentThumbnails->GrabFocus();
+        mpRecentButton->SetActive(true);
+        mpTemplateButton->SetActive(false);
+        mpTemplateButton->Invalidate();
+    }
+    else if( pButton == mpTemplateButton )
+    {
+        mpAllRecentThumbnails->Hide();
+        initializeLocalView();
+        mpLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::NONE));
+        mpLocalView->Show();
+        mpLocalView->reload();
+        mpLocalView->GrabFocus();
+        mpRecentButton->SetActive(false);
+        mpRecentButton->Invalidate();
+        mpTemplateButton->SetActive(true);
+    }
+}
+
+IMPL_LINK( BackingWindow, MenuSelectHdl, MenuButton*, pButton, void )
+{
+    if(pButton == mpRecentButton)
+    {
+        SvtHistoryOptions().Clear(ePICKLIST);
+        mpAllRecentThumbnails->Reload();
+        return;
+    }
+    else if(pButton == mpTemplateButton)
+    {
+        initializeLocalView();
+
+        OString sId = pButton->GetCurItemIdent();
+
+        if( sId == "filter_writer" )
+        {
+            mpLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::WRITER));
+        }
+        else if( sId == "filter_calc" )
+        {
+            mpLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::CALC));
+        }
+        else if( sId == "filter_impress" )
+        {
+            mpLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::IMPRESS));
+        }
+        else if( sId == "filter_draw" )
+        {
+            mpLocalView->filterItems(ViewFilter_Application(FILTER_APPLICATION::DRAW));
+        }
+        else if( sId == "manage" )
+        {
+            Reference< XDispatchProvider > xFrame( mxFrame, UNO_QUERY );
+
+            Sequence< css::beans::PropertyValue > aArgs(1);
+            PropertyValue* pArg = aArgs.getArray();
+            pArg[0].Name = "Referer";
+            pArg[0].Value <<= OUString("private:user");
+
+            dispatchURL( ".uno:NewDoc", OUString(), xFrame, aArgs );
+            return;
+        }
+
+        mpAllRecentThumbnails->Hide();
+        mpLocalView->Show();
+        mpLocalView->reload();
+        mpLocalView->GrabFocus();
+        mpRecentButton->SetActive(false);
+        mpTemplateButton->SetActive(true);
+        mpRecentButton->Invalidate();
+    }
+}
+
+IMPL_LINK(BackingWindow, CreateContextMenuHdl, ThumbnailViewItem*, pItem, void)
+{
+    const TemplateViewItem *pViewItem = dynamic_cast<TemplateViewItem*>(pItem);
+
+    if (pViewItem)
+        mpLocalView->createContextMenu();
+}
+
+IMPL_LINK(BackingWindow, OpenTemplateHdl, ThumbnailViewItem*, pItem, void)
+{
+    uno::Sequence< PropertyValue > aArgs(4);
+    aArgs[0].Name = "AsTemplate";
+    aArgs[0].Value <<= true;
+    aArgs[1].Name = "MacroExecutionMode";
+    aArgs[1].Value <<= MacroExecMode::USE_CONFIG;
+    aArgs[2].Name = "UpdateDocMode";
+    aArgs[2].Value <<= UpdateDocMode::ACCORDING_TO_CONFIG;
+    aArgs[3].Name = "InteractionHandler";
+    aArgs[3].Value <<= task::InteractionHandler::createWithParent( ::comphelper::getProcessComponentContext(), nullptr );
+
+    TemplateViewItem *pTemplateItem = static_cast<TemplateViewItem*>(pItem);
+
+    Reference< XDispatchProvider > xFrame( mxFrame, UNO_QUERY );
+
+    try
+    {
+        dispatchURL( pTemplateItem->getPath(), "_default", xFrame, aArgs );
+    }
+    catch( const uno::Exception& )
+    {
+    }
+}
+
+IMPL_LINK(BackingWindow, EditTemplateHdl, ThumbnailViewItem*, pItem, void)
+{
+    uno::Sequence< PropertyValue > aArgs(3);
+    aArgs[0].Name = "AsTemplate";
+    aArgs[0].Value <<= false;
+    aArgs[1].Name = "MacroExecutionMode";
+    aArgs[1].Value <<= MacroExecMode::USE_CONFIG;
+    aArgs[2].Name = "UpdateDocMode";
+    aArgs[2].Value <<= UpdateDocMode::ACCORDING_TO_CONFIG;
+
+    TemplateViewItem *pViewItem = static_cast<TemplateViewItem*>(pItem);
+
+    Reference< XDispatchProvider > xFrame( mxFrame, UNO_QUERY );
+
+    try
+    {
+        dispatchURL( pViewItem->getPath(), "_default", xFrame, aArgs );
+    }
+    catch( const uno::Exception& )
+    {
+    }
+}
+
+namespace {
+
+struct ImplDelayedDispatch
+{
+    Reference< XDispatch >      xDispatch;
+    css::util::URL   aDispatchURL;
+    Sequence< PropertyValue >   aArgs;
+
+    ImplDelayedDispatch( const Reference< XDispatch >& i_xDispatch,
+                         const css::util::URL& i_rURL,
+                         const Sequence< PropertyValue >& i_rArgs )
+    : xDispatch( i_xDispatch ),
+      aDispatchURL( i_rURL ),
+      aArgs( i_rArgs )
+    {
+    }
+};
+
+}
+
+static void implDispatchDelayed( void*, void* pArg )
+{
+    struct ImplDelayedDispatch* pDispatch = static_cast<ImplDelayedDispatch*>(pArg);
+    try
+    {
+        pDispatch->xDispatch->dispatch( pDispatch->aDispatchURL, pDispatch->aArgs );
+    }
+    catch (const Exception&)
+    {
+    }
+
+    // clean up
+    delete pDispatch;
+}
+
+void BackingWindow::dispatchURL( const OUString& i_rURL,
+                                 const OUString& rTarget,
+                                 const Reference< XDispatchProvider >& i_xProv,
+                                 const Sequence< PropertyValue >& i_rArgs )
+{
+    // if no special dispatch provider is given, get the desktop
+    Reference< XDispatchProvider > xProvider( i_xProv.is() ? i_xProv : mxDesktopDispatchProvider );
+
+    // check for dispatch provider
+    if( !xProvider.is())
+        return;
+
+    // get a URL transformer to clean up the URL
+    css::util::URL aDispatchURL;
+    aDispatchURL.Complete = i_rURL;
+
+    Reference < css::util::XURLTransformer > xURLTransformer(
+        css::util::URLTransformer::create( comphelper::getProcessComponentContext() ) );
+    try
+    {
+        // clean up the URL
+        xURLTransformer->parseStrict( aDispatchURL );
+        // get a Dispatch for the URL and target
+        Reference< XDispatch > xDispatch(
+            xProvider->queryDispatch( aDispatchURL, rTarget, 0 )
+            );
+        // dispatch the URL
+        if ( xDispatch.is() )
+        {
+            std::unique_ptr<ImplDelayedDispatch> pDisp(new ImplDelayedDispatch( xDispatch, aDispatchURL, i_rArgs ));
+            if( Application::PostUserEvent( Link<void*,void>( nullptr, implDispatchDelayed ), pDisp.get() ) )
+                pDisp.release();
+        }
+    }
+    catch (const css::uno::RuntimeException&)
+    {
+        throw;
+    }
+    catch (const css::uno::Exception&)
+    {
+    }
+}
+
+Size BackingWindow::GetOptimalSize() const
+{
+    if (isLayoutEnabled(this))
+        return VclContainer::getLayoutRequisition(*GetWindow(GetWindowType::FirstChild));
+
+    return Window::GetOptimalSize();
+}
+
+void BackingWindow::clearRecentFileList()
+{
+    mpAllRecentThumbnails->Clear();
+    set_width_request(mpAllRecentThumbnails->get_width_request() + mpAllButtonsBox->GetOptimalSize().Width());
+}
+/* vim:set shiftwidth=4 softtabstop=4 expandtab:*/
diff --git a/sfx2/source/dialog/backingwindow.hxx b/sfx2/source/dialog/backingwindow.hxx
new file mode 100644
index 000000000..16f92c29d
--- /dev/null
+++ b/sfx2/source/dialog/backingwindow.hxx
@@ -0,0 +1,130 @@
+/* -*- 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_DIALOG_BACKINGWINDOW_HXX
+#define INCLUDED_SFX2_SOURCE_DIALOG_BACKINGWINDOW_HXX
+
+#include <rtl/ustring.hxx>
+
+#include <vcl/builder.hxx>
+#include <vcl/button.hxx>
+#include <vcl/layout.hxx>
+
+#include <vcl/menubtn.hxx>
+
+#include <recentdocsview.hxx>
+#include <templatedefaultview.hxx>
+
+#include <svtools/acceleratorexecute.hxx>
+
+#include <com/sun/star/datatransfer/dnd/XDropTargetListener.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+
+#include <memory>
+
+class ToolBox;
+
+class BackingWindow : public vcl::Window, public VclBuilderContainer
+{
+    css::uno::Reference<css::uno::XComponentContext> mxContext;
+    css::uno::Reference<css::frame::XDispatchProvider> mxDesktopDispatchProvider;
+    css::uno::Reference<css::frame::XFrame> mxFrame;
+
+    /** helper for drag&drop. */
+    css::uno::Reference<css::datatransfer::dnd::XDropTargetListener> mxDropTargetListener;
+
+    VclPtr<PushButton> mpOpenButton;
+    VclPtr<MenuToggleButton> mpRecentButton;
+    VclPtr<PushButton> mpRemoteButton;
+    VclPtr<MenuToggleButton> mpTemplateButton;
+
+    VclPtr<FixedText>  mpCreateLabel;
+
+    VclPtr<PushButton> mpWriterAllButton;
+    VclPtr<PushButton> mpCalcAllButton;
+    VclPtr<PushButton> mpImpressAllButton;
+    VclPtr<PushButton> mpDrawAllButton;
+    VclPtr<PushButton> mpDBAllButton;
+    VclPtr<PushButton> mpMathAllButton;
+
+    VclPtr<PushButton> mpHelpButton;
+    VclPtr<PushButton> mpExtensionsButton;
+
+    VclPtr<VclBox> mpAllButtonsBox;
+    VclPtr<VclBox> mpButtonsBox;
+    VclPtr<VclBox> mpSmallButtonsBox;
+
+    VclPtr<sfx2::RecentDocsView> mpAllRecentThumbnails;
+    VclPtr<TemplateDefaultView> mpLocalView;
+    bool mbLocalViewInitialized;
+
+    std::vector< VclPtr<vcl::Window> > maDndWindows;
+
+    tools::Rectangle maStartCentButtons;
+
+    bool mbInitControls;
+    std::unique_ptr<svt::AcceleratorExecute> mpAccExec;
+
+    void setupMenuButton(MenuToggleButton* pButton);
+
+    void dispatchURL(const OUString& i_rURL,
+                     const OUString& i_rTarget = OUString("_default"),
+                     const css::uno::Reference<css::frame::XDispatchProvider >& i_xProv = css::uno::Reference<css::frame::XDispatchProvider>(),
+                     const css::uno::Sequence<css::beans::PropertyValue >& = css::uno::Sequence<css::beans::PropertyValue>());
+
+    DECL_LINK(ClickHdl, Button*, void);
+    DECL_LINK(MenuSelectHdl, MenuButton*, void);
+    DECL_LINK(ExtLinkClickHdl, Button*, void);
+    DECL_LINK(CreateContextMenuHdl, ThumbnailViewItem*, void);
+    DECL_LINK(OpenTemplateHdl, ThumbnailViewItem*, void);
+    DECL_LINK(EditTemplateHdl, ThumbnailViewItem*, void);
+
+    void initControls();
+
+    void initializeLocalView();
+
+    void checkInstalledModules();
+
+    void DataChanged(const DataChangedEvent&) override;
+
+    template <typename WidgetClass> void setLargerFont(WidgetClass&, const vcl::Font&);
+    void ApplyStyleSettings();
+
+public:
+    explicit BackingWindow(vcl::Window* pParent);
+    virtual ~BackingWindow() override;
+    virtual void dispose() override;
+
+    virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override;
+    virtual void Resize() override;
+    virtual bool PreNotify(NotifyEvent& rNEvt) override;
+    virtual void GetFocus() override;
+
+    virtual Size GetOptimalSize() const override;
+
+    void setOwningFrame(const css::uno::Reference<css::frame::XFrame>& xFrame );
+
+    void clearRecentFileList();
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/basedlgs.cxx b/sfx2/source/dialog/basedlgs.cxx
new file mode 100644
index 000000000..d0cafa692
--- /dev/null
+++ b/sfx2/source/dialog/basedlgs.cxx
@@ -0,0 +1,323 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <vcl/help.hxx>
+#include <svl/eitem.hxx>
+#include <unotools/viewoptions.hxx>
+#include <vcl/idle.hxx>
+
+#include <sfx2/basedlgs.hxx>
+#include <sfx2/tabdlg.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/childwin.hxx>
+#include <sfx2/viewsh.hxx>
+#include <workwin.hxx>
+#include <sfx2/lokhelper.hxx>
+#include <comphelper/lok.hxx>
+
+using namespace ::com::sun::star::uno;
+
+#define USERITEM_NAME "UserItem"
+
+class SfxModelessDialog_Impl : public SfxListener
+{
+public:
+    OString aWinState;
+    SfxChildWindow* pMgr;
+    bool            bClosing;
+    void            Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
+
+    Idle            aMoveIdle;
+};
+
+void SfxModelessDialog_Impl::Notify( SfxBroadcaster&, const SfxHint& rHint )
+{
+    if (pMgr && rHint.GetId() == SfxHintId::Dying) {
+        pMgr->Destroy();
+    }
+}
+
+void SfxModelessDialogController::Initialize(SfxChildWinInfo const *pInfo)
+
+/*  [Description]
+
+    Initialization of the class SfxModelessDialog via a SfxChildWinInfo.
+    The initialization is done only in a 2nd step after the constructor, this
+    constructor should be called from the derived class or from the
+    SfxChildWindows.
+*/
+
+{
+    if (!pInfo)
+        return;
+    m_xImpl->aWinState = pInfo->aWinState;
+    if (m_xImpl->aWinState.isEmpty())
+        return;
+    m_xDialog->set_window_state(m_xImpl->aWinState);
+}
+
+SfxModelessDialogController::SfxModelessDialogController(SfxBindings* pBindinx,
+    SfxChildWindow *pCW, weld::Window *pParent, const OUString& rUIXMLDescription,
+    const OString& rID)
+    : SfxDialogController(pParent, rUIXMLDescription, rID)
+{
+    Init(pBindinx, pCW);
+}
+
+/*  [Description]
+
+    Fills a SfxChildWinInfo with specific data from SfxModelessDialog,
+    so that it can be written in the INI file. It is assumed that rinfo
+    receives all other possible relevant data in the ChildWindow class.
+    ModelessDialogs have no specific information, so that the base
+    implementation does nothing and therefore must not be called.
+*/
+void SfxModelessDialogController::FillInfo(SfxChildWinInfo& rInfo) const
+{
+    rInfo.aSize = m_xDialog->get_size();
+}
+
+void SfxModelessDialogController::Init(SfxBindings *pBindinx, SfxChildWindow *pCW)
+{
+    m_pBindings = pBindinx;
+    m_xImpl.reset(new SfxModelessDialog_Impl);
+    m_xImpl->pMgr = pCW;
+    m_xImpl->bClosing = false;
+    if (pBindinx)
+        m_xImpl->StartListening( *pBindinx );
+}
+
+/*  [Description]
+
+    If a ModelessDialog is enabled its ViewFrame will be activated.
+    This is necessary by PluginInFrames.
+*/
+IMPL_LINK_NOARG(SfxDialogController, FocusChangeHdl, weld::Widget&, void)
+{
+    if (m_xDialog->has_toplevel_focus())
+        Activate();
+    else
+        Deactivate();
+}
+
+void SfxModelessDialogController::Activate()
+{
+    if (!m_xImpl)
+        return;
+    m_pBindings->SetActiveFrame(m_xImpl->pMgr->GetFrame());
+    m_xImpl->pMgr->Activate_Impl();
+}
+
+void SfxModelessDialogController::Deactivate()
+{
+    if (!m_xImpl)
+        return;
+    m_pBindings->SetActiveFrame(css::uno::Reference< css::frame::XFrame>());
+}
+
+SfxModelessDialogController::~SfxModelessDialogController()
+{
+    if (!m_xImpl->pMgr)
+        return;
+    auto xFrame = m_xImpl->pMgr->GetFrame();
+    if (!xFrame)
+        return;
+    if (xFrame == m_pBindings->GetActiveFrame())
+        m_pBindings->SetActiveFrame(nullptr);
+}
+
+void SfxDialogController::EndDialog()
+{
+    if (!m_xDialog->get_visible())
+        return;
+    response(RET_CLOSE);
+}
+
+bool SfxModelessDialogController::IsClosing() const
+{
+    return m_xImpl->bClosing;
+}
+
+void SfxModelessDialogController::EndDialog()
+{
+    if (m_xImpl->bClosing)
+        return;
+    // In the case of async dialogs, the call to SfxDialogController::EndDialog
+    // may delete this object, so keep myself alive for the duration of this
+    // stack frame.
+    auto aHoldSelf = shared_from_this();
+    m_xImpl->bClosing = true;
+    SfxDialogController::EndDialog();
+    if (!m_xImpl)
+        return;
+    m_xImpl->bClosing = false;
+}
+
+void SfxModelessDialogController::ChildWinDispose()
+{
+    if (m_xImpl->pMgr)
+    {
+        WindowStateMask nMask = WindowStateMask::Pos | WindowStateMask::State;
+        if (m_xDialog->get_resizable())
+            nMask |= WindowStateMask::Width | WindowStateMask::Height;
+        m_xImpl->aWinState = m_xDialog->get_window_state(nMask);
+        GetBindings().GetWorkWindow_Impl()->ConfigChild_Impl( SfxChildIdentifier::DOCKINGWINDOW, SfxDockingConfig::ALIGNDOCKINGWINDOW, m_xImpl->pMgr->GetType() );
+    }
+
+    m_xImpl->pMgr = nullptr;
+}
+
+/*  [Description]
+
+    The window is closed when the ChildWindow is destroyed by running the
+    ChildWindow-slots.
+*/
+void SfxModelessDialogController::Close()
+{
+    if (m_xImpl->bClosing)
+        return;
+    // Execute with Parameters, since Toggle is ignored by some ChildWindows.
+    SfxBoolItem aValue(m_xImpl->pMgr->GetType(), false);
+    m_pBindings->GetDispatcher_Impl()->ExecuteList(
+        m_xImpl->pMgr->GetType(),
+        SfxCallMode::RECORD|SfxCallMode::SYNCHRON, { &aValue } );
+}
+
+SfxDialogController::SfxDialogController(weld::Widget* pParent, const OUString& rUIFile,
+                                         const OString& rDialogId)
+    : GenericDialogController(pParent, rUIFile, rDialogId,
+                                    comphelper::LibreOfficeKit::isActive()
+                                    && SfxViewShell::Current()
+                                    && SfxViewShell::Current()->isLOKMobilePhone())
+{
+    m_xDialog->SetInstallLOKNotifierHdl(LINK(this, SfxDialogController, InstallLOKNotifierHdl));
+    m_xDialog->connect_toplevel_focus_changed(LINK(this, SfxDialogController, FocusChangeHdl));
+}
+
+IMPL_STATIC_LINK_NOARG(SfxDialogController, InstallLOKNotifierHdl, void*, vcl::ILibreOfficeKitNotifier*)
+{
+    return SfxViewShell::Current();
+}
+
+SfxSingleTabDialogController::SfxSingleTabDialogController(weld::Widget *pParent, const SfxItemSet* pSet,
+    const OUString& rUIXMLDescription, const OString& rID)
+    : SfxOkDialogController(pParent, rUIXMLDescription, rID)
+    , m_pInputSet(pSet)
+    , m_xContainer(m_xDialog->weld_content_area())
+    , m_xOKBtn(m_xBuilder->weld_button("ok"))
+    , m_xHelpBtn(m_xBuilder->weld_button("help"))
+{
+    m_xOKBtn->connect_clicked(LINK(this, SfxSingleTabDialogController, OKHdl_Impl));
+}
+
+SfxSingleTabDialogController::~SfxSingleTabDialogController()
+{
+}
+
+/*  [Description]
+
+    Insert a (new) TabPage; an existing page is deleted.
+    The passed on page is initialized with the initially given Itemset
+    through calling Reset().
+*/
+void SfxSingleTabDialogController::SetTabPage(std::unique_ptr<SfxTabPage> xTabPage)
+{
+    m_xSfxPage = std::move(xTabPage);
+    if (!m_xSfxPage)
+        return;
+
+    // First obtain the user data, only then Reset()
+    OUString sConfigId = OStringToOUString(m_xSfxPage->GetConfigId(), RTL_TEXTENCODING_UTF8);
+    SvtViewOptions aPageOpt(EViewType::TabPage, sConfigId);
+    Any aUserItem = aPageOpt.GetUserItem( USERITEM_NAME );
+    OUString sUserData;
+    aUserItem >>= sUserData;
+    m_xSfxPage->SetUserData(sUserData);
+    m_xSfxPage->Reset(GetInputItemSet());
+
+    m_xHelpBtn->set_visible(Help::IsContextHelpEnabled());
+
+    // Set TabPage text in the Dialog if there is any
+    OUString sTitle(m_xSfxPage->GetPageTitle());
+    if (!sTitle.isEmpty())
+        m_xDialog->set_title(sTitle);
+
+    // Dialog receives the HelpId of TabPage if there is any
+    OString sHelpId(m_xSfxPage->GetHelpId());
+    if (!sHelpId.isEmpty())
+        m_xDialog->set_help_id(sHelpId);
+}
+
+/*  [Description]
+
+    Ok_Handler; FillItemSet() is called for setting of Page.
+*/
+IMPL_LINK_NOARG(SfxSingleTabDialogController, OKHdl_Impl, weld::Button&, void)
+{
+    const SfxItemSet* pInputSet = GetInputItemSet();
+    if (!pInputSet)
+    {
+        // TabPage without ItemSet
+        m_xDialog->response(RET_OK);
+        return;
+    }
+
+    if (!GetOutputItemSet())
+    {
+        CreateOutputItemSet(*pInputSet);
+    }
+
+    bool bModified = false;
+
+    if (m_xSfxPage->HasExchangeSupport())
+    {
+        DeactivateRC nRet = m_xSfxPage->DeactivatePage(m_xOutputSet.get());
+        if (nRet != DeactivateRC::LeavePage)
+            return;
+        else
+            bModified = m_xOutputSet->Count() > 0;
+    }
+    else
+        bModified = m_xSfxPage->FillItemSet(m_xOutputSet.get());
+
+    if (bModified)
+    {
+        // Save user data in IniManager.
+        m_xSfxPage->FillUserData();
+        OUString sData(m_xSfxPage->GetUserData());
+
+        OUString sConfigId = OStringToOUString(m_xSfxPage->GetConfigId(),
+            RTL_TEXTENCODING_UTF8);
+        SvtViewOptions aPageOpt(EViewType::TabPage, sConfigId);
+        aPageOpt.SetUserItem( USERITEM_NAME, makeAny( sData ) );
+        m_xDialog->response(RET_OK);
+    }
+    else
+        m_xDialog->response(RET_CANCEL);
+}
+
+void SfxSingleTabDialogController::CreateOutputItemSet(const SfxItemSet& rSet)
+{
+    assert(!m_xOutputSet && "Double creation of OutputSet!");
+    m_xOutputSet.reset(new SfxItemSet(rSet));
+    m_xOutputSet->ClearItem();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/bluthsnd.cxx b/sfx2/source/dialog/bluthsnd.cxx
new file mode 100644
index 000000000..ded98ceb0
--- /dev/null
+++ b/sfx2/source/dialog/bluthsnd.cxx
@@ -0,0 +1,50 @@
+/* -*- 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 <com/sun/star/frame/XFrame.hpp>
+
+#include <stdio.h>
+
+#include <bluthsndapi.hxx>
+
+SfxBluetoothModel::SendMailResult SfxBluetoothModel::SaveAndSend( const css::uno::Reference< css::frame::XFrame >& xFrame )
+{
+    SaveResult      eSaveResult;
+    SendMailResult  eResult = SEND_MAIL_ERROR;
+    OUString   aFileName;
+
+    eSaveResult  = SaveDocumentAsFormat( OUString(), xFrame, OUString(), aFileName );
+    if( eSaveResult == SAVE_SUCCESSFULL )
+    {
+        maAttachedDocuments.push_back( aFileName );
+        return Send();
+    }
+    else if( eSaveResult == SAVE_CANCELLED )
+        eResult = SEND_MAIL_CANCELLED;
+
+    return eResult;
+}
+
+SfxBluetoothModel::SendMailResult SfxBluetoothModel::Send()
+{
+#ifndef LINUX
+    (void) this; // avoid loplugin:staticmethods
+    return SEND_MAIL_ERROR;
+#else
+    char bthsend[300];
+    SendMailResult eResult = SEND_MAIL_OK;
+    OUString aFileName = maAttachedDocuments[0];
+    snprintf(bthsend,300,"bluetooth-sendto %s",OUStringToOString( aFileName, RTL_TEXTENCODING_UTF8).getStr() );
+    if( !system( bthsend ) )
+        eResult = SEND_MAIL_ERROR;
+    return eResult;
+#endif
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/charmappopup.cxx b/sfx2/source/dialog/charmappopup.cxx
new file mode 100644
index 000000000..7788a45c7
--- /dev/null
+++ b/sfx2/source/dialog/charmappopup.cxx
@@ -0,0 +1,75 @@
+/* -*- 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/charmappopup.hxx>
+#include <charmapcontrol.hxx>
+#include <vcl/toolbox.hxx>
+
+CharmapPopup::CharmapPopup(const css::uno::Reference<css::uno::XComponentContext>& rContext)
+    : PopupWindowController(rContext, nullptr, OUString())
+{
+}
+
+CharmapPopup::~CharmapPopup()
+{
+}
+
+void CharmapPopup::initialize( const css::uno::Sequence< css::uno::Any >& rArguments )
+{
+    PopupWindowController::initialize(rArguments);
+
+    ToolBox* pToolBox = nullptr;
+    sal_uInt16 nId = 0;
+    if (getToolboxId(nId, &pToolBox) && pToolBox->GetItemCommand(nId) == m_aCommandURL)
+        pToolBox->SetItemBits(nId, ToolBoxItemBits::DROPDOWNONLY | pToolBox->GetItemBits(nId));
+}
+
+std::unique_ptr<WeldToolbarPopup> CharmapPopup::weldPopupWindow()
+{
+    return std::make_unique<SfxCharmapCtrl>(this, m_pToolbar);
+}
+
+VclPtr<vcl::Window> CharmapPopup::createVclPopupWindow( vcl::Window* pParent )
+{
+    mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
+        std::make_unique<SfxCharmapCtrl>(this, pParent->GetFrameWeld()));
+
+    mxInterimPopover->Show();
+
+    return mxInterimPopover;
+}
+
+OUString CharmapPopup::getImplementationName()
+{
+    return "com.sun.star.comp.sfx2.InsertSymbolToolBoxControl";
+}
+
+css::uno::Sequence<OUString> CharmapPopup::getSupportedServiceNames()
+{
+    return { "com.sun.star.frame.ToolbarController" };
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_sfx2_InsertSymbolToolBoxControl_get_implementation(
+    css::uno::XComponentContext* rContext,
+    css::uno::Sequence<css::uno::Any> const & )
+{
+    return cppu::acquire( new CharmapPopup( rContext ) );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/checkin.cxx b/sfx2/source/dialog/checkin.cxx
new file mode 100644
index 000000000..6d90be8af
--- /dev/null
+++ b/sfx2/source/dialog/checkin.cxx
@@ -0,0 +1,40 @@
+/* -*- 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 <checkin.hxx>
+
+SfxCheckinDialog::SfxCheckinDialog(weld::Window* pParent)
+    : GenericDialogController( pParent, "sfx/ui/checkin.ui", "CheckinDialog")
+    , m_xCommentED(m_xBuilder->weld_text_view("VersionComment"))
+    , m_xMajorCB(m_xBuilder->weld_check_button("MajorVersion"))
+    , m_xOKBtn(m_xBuilder->weld_button("ok"))
+{
+    m_xOKBtn->connect_clicked(LINK(this, SfxCheckinDialog, OKHdl));
+}
+
+SfxCheckinDialog::~SfxCheckinDialog()
+{
+}
+
+OUString SfxCheckinDialog::GetComment( ) const
+{
+    return m_xCommentED->get_text();
+}
+
+bool SfxCheckinDialog::IsMajor( ) const
+{
+    return m_xMajorCB->get_active();
+}
+
+IMPL_LINK_NOARG(SfxCheckinDialog, OKHdl, weld::Button&, void )
+{
+    m_xDialog->response(RET_OK);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/dialoghelper.cxx b/sfx2/source/dialog/dialoghelper.cxx
new file mode 100644
index 000000000..5668e9b2a
--- /dev/null
+++ b/sfx2/source/dialog/dialoghelper.cxx
@@ -0,0 +1,49 @@
+/* -*- 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 <unotools/localedatawrapper.hxx>
+#include <sfx2/dialoghelper.hxx>
+#include <tools/datetime.hxx>
+#include <vcl/outdev.hxx>
+
+Size getParagraphPreviewOptimalSize(const OutputDevice& rReference)
+{
+    return rReference.LogicToPixel(Size(68 , 112), MapMode(MapUnit::MapAppFont));
+}
+
+Size getDrawPreviewOptimalSize(const OutputDevice& rReference)
+{
+    return rReference.LogicToPixel(Size(88, 42), MapMode(MapUnit::MapAppFont));
+}
+
+Size getPreviewStripSize(const OutputDevice& rReference)
+{
+    return rReference.LogicToPixel(Size(70 , 40), MapMode(MapUnit::MapAppFont));
+}
+
+Size getPreviewOptionsSize(const OutputDevice& rReference)
+{
+    return rReference.LogicToPixel(Size(70 , 27), MapMode(MapUnit::MapAppFont));
+}
+
+OUString getWidestTime(const LocaleDataWrapper& rWrapper)
+{
+    Date aDate(22, 12, 2000);
+    tools::Time aTime(22, 59, 59);
+    DateTime aDateTime(aDate, aTime);
+    return formatTime(aDateTime, rWrapper);
+}
+
+OUString formatTime(const DateTime& rDateTime, const LocaleDataWrapper& rWrapper)
+{
+    return rWrapper.getDate(rDateTime) + " "
+        + rWrapper.getTime(rDateTime, false);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/dinfdlg.cxx b/sfx2/source/dialog/dinfdlg.cxx
new file mode 100644
index 000000000..0d0964368
--- /dev/null
+++ b/sfx2/source/dialog/dinfdlg.cxx
@@ -0,0 +1,2347 @@
+/* -*- 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/eitem.hxx>
+#include <tools/datetime.hxx>
+#include <tools/debug.hxx>
+#include <tools/urlobj.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <unotools/datetime.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <unotools/cmdoptions.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/xmlsechelper.hxx>
+#include <unotools/useroptions.hxx>
+#include <svtools/ctrlbox.hxx>
+#include <svtools/imagemgr.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+
+#include <memory>
+
+#include <comphelper/sequence.hxx>
+#include <comphelper/string.hxx>
+#include <com/sun/star/security/DocumentSignatureInformation.hpp>
+#include <com/sun/star/security/DocumentDigitalSignatures.hpp>
+#include <unotools/syslocale.hxx>
+#include <rtl/math.hxx>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/beans/XPropertyContainer.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/util/DateTime.hpp>
+#include <com/sun/star/util/Date.hpp>
+#include <com/sun/star/util/DateTimeWithTimezone.hpp>
+#include <com/sun/star/util/DateWithTimezone.hpp>
+#include <com/sun/star/util/Duration.hpp>
+#include <com/sun/star/document/XDocumentProperties.hpp>
+#include <com/sun/star/document/CmisProperty.hpp>
+
+#include <vcl/timer.hxx>
+#include <vcl/settings.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <sfx2/dinfdlg.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <helper.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/docfile.hxx>
+
+#include <documentfontsdialog.hxx>
+#include <dinfdlg.hrc>
+#include <sfx2/strings.hrc>
+#include <strings.hxx>
+#include <tools/diagnose_ex.h>
+#include "securitypage.hxx"
+
+#include <algorithm>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::ui::dialogs;
+using namespace ::com::sun::star::uno;
+
+struct CustomProperty
+{
+    OUString         m_sName;
+    css::uno::Any    m_aValue;
+
+    CustomProperty( const OUString& sName, const css::uno::Any& rValue ) :
+        m_sName( sName ), m_aValue( rValue ) {}
+};
+
+SfxPoolItem* SfxDocumentInfoItem::CreateDefault() { return new SfxDocumentInfoItem; }
+
+namespace {
+
+OUString CreateSizeText( sal_Int64 nSize )
+{
+    OUString aUnitStr = " " + SfxResId(STR_BYTES);
+    sal_Int64 nSize1 = nSize;
+    sal_Int64 nSize2 = nSize1;
+    sal_Int64 nMega = 1024 * 1024;
+    sal_Int64 nGiga = nMega * 1024;
+    double fSize = nSize;
+    int nDec = 0;
+
+    if ( nSize1 >= 10000 && nSize1 < nMega )
+    {
+        nSize1 /= 1024;
+        aUnitStr = " " + SfxResId(STR_KB);
+        fSize /= 1024;
+        nDec = 0;
+    }
+    else if ( nSize1 >= nMega && nSize1 < nGiga )
+    {
+        nSize1 /= nMega;
+        aUnitStr = " " + SfxResId(STR_MB);
+        fSize /= nMega;
+        nDec = 2;
+    }
+    else if ( nSize1 >= nGiga )
+    {
+        nSize1 /= nGiga;
+        aUnitStr = " " + SfxResId(STR_GB);
+        fSize /= nGiga;
+        nDec = 3;
+    }
+    const SvtSysLocale aSysLocale;
+    const LocaleDataWrapper& rLocaleWrapper = aSysLocale.GetLocaleData();
+    OUString aSizeStr = rLocaleWrapper.getNum( nSize1, 0 ) + aUnitStr;
+    if ( nSize1 < nSize2 )
+    {
+        aSizeStr = ::rtl::math::doubleToUString( fSize,
+                rtl_math_StringFormat_F, nDec,
+                rLocaleWrapper.getNumDecimalSep()[0] )
+                 + aUnitStr
+                 + " ("
+                 + rLocaleWrapper.getNum( nSize2, 0 )
+                 + " "
+                 + SfxResId(STR_BYTES)
+                 + ")";
+    }
+    return aSizeStr;
+}
+
+OUString ConvertDateTime_Impl( const OUString& rName,
+    const util::DateTime& uDT, const LocaleDataWrapper& rWrapper )
+{
+     Date aD(uDT);
+     tools::Time aT(uDT);
+     const OUString aDelim( ", " );
+     OUString aStr = rWrapper.getDate( aD )
+                   + aDelim
+                   + rWrapper.getTime( aT );
+     OUString aAuthor = comphelper::string::stripStart(rName, ' ');
+     if (!aAuthor.isEmpty())
+     {
+        aStr += aDelim + aAuthor;
+     }
+     return aStr;
+}
+
+}
+
+
+SfxDocumentInfoItem::SfxDocumentInfoItem()
+    : SfxStringItem()
+    , m_AutoloadDelay(0)
+    , m_AutoloadURL()
+    , m_isAutoloadEnabled(false)
+    , m_DefaultTarget()
+    , m_TemplateName()
+    , m_Author()
+    , m_CreationDate()
+    , m_ModifiedBy()
+    , m_ModificationDate()
+    , m_PrintedBy()
+    , m_PrintDate()
+    , m_EditingCycles(0)
+    , m_EditingDuration(0)
+    , m_Description()
+    , m_Keywords()
+    , m_Subject()
+    , m_Title()
+    , m_bHasTemplate( true )
+    , m_bDeleteUserData( false )
+    , m_bUseUserData( true )
+    , m_bUseThumbnailSave( true )
+{
+}
+
+SfxDocumentInfoItem::SfxDocumentInfoItem( const OUString& rFile,
+        const uno::Reference<document::XDocumentProperties>& i_xDocProps,
+        const uno::Sequence<document::CmisProperty>& i_cmisProps,
+        bool bIs, bool _bIs )
+    : SfxStringItem( SID_DOCINFO, rFile )
+    , m_AutoloadDelay( i_xDocProps->getAutoloadSecs() )
+    , m_AutoloadURL( i_xDocProps->getAutoloadURL() )
+    , m_isAutoloadEnabled( (m_AutoloadDelay > 0) || !m_AutoloadURL.isEmpty() )
+    , m_DefaultTarget( i_xDocProps->getDefaultTarget() )
+    , m_TemplateName( i_xDocProps->getTemplateName() )
+    , m_Author( i_xDocProps->getAuthor() )
+    , m_CreationDate( i_xDocProps->getCreationDate() )
+    , m_ModifiedBy( i_xDocProps->getModifiedBy() )
+    , m_ModificationDate( i_xDocProps->getModificationDate() )
+    , m_PrintedBy( i_xDocProps->getPrintedBy() )
+    , m_PrintDate( i_xDocProps->getPrintDate() )
+    , m_EditingCycles( i_xDocProps->getEditingCycles() )
+    , m_EditingDuration( i_xDocProps->getEditingDuration() )
+    , m_Description( i_xDocProps->getDescription() )
+    , m_Keywords( ::comphelper::string::convertCommaSeparated(
+                    i_xDocProps->getKeywords()) )
+    , m_Subject( i_xDocProps->getSubject() )
+    , m_Title( i_xDocProps->getTitle() )
+    , m_bHasTemplate( true )
+    , m_bDeleteUserData( false )
+    , m_bUseUserData( bIs )
+    , m_bUseThumbnailSave( _bIs )
+{
+    try
+    {
+        Reference< beans::XPropertyContainer > xContainer = i_xDocProps->getUserDefinedProperties();
+        if ( xContainer.is() )
+        {
+            Reference < beans::XPropertySet > xSet( xContainer, UNO_QUERY );
+            const Sequence< beans::Property > lProps = xSet->getPropertySetInfo()->getProperties();
+            for ( const beans::Property& rProp : lProps )
+            {
+                // "fix" property? => not a custom property => ignore it!
+                if (!(rProp.Attributes & css::beans::PropertyAttribute::REMOVABLE))
+                {
+                    SAL_WARN( "sfx.dialog", "non-removable user-defined property?");
+                    continue;
+                }
+
+                uno::Any aValue = xSet->getPropertyValue(rProp.Name);
+                std::unique_ptr<CustomProperty> pProp(new CustomProperty( rProp.Name, aValue ));
+                m_aCustomProperties.push_back( std::move(pProp) );
+            }
+        }
+
+        // get CMIS properties
+        m_aCmisProperties = i_cmisProps;
+    }
+    catch ( Exception& ) {}
+}
+
+
+SfxDocumentInfoItem::SfxDocumentInfoItem( const SfxDocumentInfoItem& rItem )
+    : SfxStringItem( rItem )
+    , m_AutoloadDelay( rItem.getAutoloadDelay() )
+    , m_AutoloadURL( rItem.getAutoloadURL() )
+    , m_isAutoloadEnabled( rItem.isAutoloadEnabled() )
+    , m_DefaultTarget( rItem.getDefaultTarget() )
+    , m_TemplateName( rItem.getTemplateName() )
+    , m_Author( rItem.getAuthor() )
+    , m_CreationDate( rItem.getCreationDate() )
+    , m_ModifiedBy( rItem.getModifiedBy() )
+    , m_ModificationDate( rItem.getModificationDate() )
+    , m_PrintedBy( rItem.getPrintedBy() )
+    , m_PrintDate( rItem.getPrintDate() )
+    , m_EditingCycles( rItem.getEditingCycles() )
+    , m_EditingDuration( rItem.getEditingDuration() )
+    , m_Description( rItem.getDescription() )
+    , m_Keywords( rItem.getKeywords() )
+    , m_Subject( rItem.getSubject() )
+    , m_Title( rItem.getTitle() )
+    , m_bHasTemplate( rItem.m_bHasTemplate )
+    , m_bDeleteUserData( rItem.m_bDeleteUserData )
+    , m_bUseUserData( rItem.m_bUseUserData )
+    , m_bUseThumbnailSave( rItem.m_bUseThumbnailSave )
+{
+    for (auto const & pOtherProp : rItem.m_aCustomProperties)
+    {
+        std::unique_ptr<CustomProperty> pProp(new CustomProperty( pOtherProp->m_sName,
+                                                    pOtherProp->m_aValue ));
+        m_aCustomProperties.push_back( std::move(pProp) );
+    }
+
+    m_aCmisProperties = rItem.m_aCmisProperties;
+}
+
+SfxDocumentInfoItem::~SfxDocumentInfoItem()
+{
+    ClearCustomProperties();
+}
+
+SfxDocumentInfoItem* SfxDocumentInfoItem::Clone( SfxItemPool * ) const
+{
+    return new SfxDocumentInfoItem( *this );
+}
+
+bool SfxDocumentInfoItem::operator==( const SfxPoolItem& rItem) const
+{
+    if (!SfxStringItem::operator==(rItem))
+        return false;
+    const SfxDocumentInfoItem& rInfoItem(static_cast<const SfxDocumentInfoItem&>(rItem));
+
+    return
+         m_AutoloadDelay        == rInfoItem.m_AutoloadDelay     &&
+         m_AutoloadURL          == rInfoItem.m_AutoloadURL       &&
+         m_isAutoloadEnabled    == rInfoItem.m_isAutoloadEnabled &&
+         m_DefaultTarget        == rInfoItem.m_DefaultTarget     &&
+         m_Author               == rInfoItem.m_Author            &&
+         m_CreationDate         == rInfoItem.m_CreationDate      &&
+         m_ModifiedBy           == rInfoItem.m_ModifiedBy        &&
+         m_ModificationDate     == rInfoItem.m_ModificationDate  &&
+         m_PrintedBy            == rInfoItem.m_PrintedBy         &&
+         m_PrintDate            == rInfoItem.m_PrintDate         &&
+         m_EditingCycles        == rInfoItem.m_EditingCycles     &&
+         m_EditingDuration      == rInfoItem.m_EditingDuration   &&
+         m_Description          == rInfoItem.m_Description       &&
+         m_Keywords             == rInfoItem.m_Keywords          &&
+         m_Subject              == rInfoItem.m_Subject           &&
+         m_Title                == rInfoItem.m_Title             &&
+         m_aCustomProperties.size() == rInfoItem.m_aCustomProperties.size() &&
+         std::equal(m_aCustomProperties.begin(), m_aCustomProperties.end(),
+            rInfoItem.m_aCustomProperties.begin()) &&
+         m_aCmisProperties.getLength() == rInfoItem.m_aCmisProperties.getLength();
+}
+
+
+void SfxDocumentInfoItem::resetUserData(const OUString & i_rAuthor)
+{
+    m_Author = i_rAuthor;
+    DateTime now( DateTime::SYSTEM );
+    m_CreationDate = now.GetUNODateTime();
+    m_ModifiedBy = OUString();
+    m_PrintedBy = OUString();
+    m_ModificationDate = util::DateTime();
+    m_PrintDate = util::DateTime();
+    m_EditingDuration = 0;
+    m_EditingCycles = 1;
+}
+
+
+void SfxDocumentInfoItem::UpdateDocumentInfo(
+        const uno::Reference<document::XDocumentProperties>& i_xDocProps,
+        bool i_bDoNotUpdateUserDefined) const
+{
+    if (isAutoloadEnabled()) {
+        i_xDocProps->setAutoloadSecs(getAutoloadDelay());
+        i_xDocProps->setAutoloadURL(getAutoloadURL());
+    } else {
+        i_xDocProps->setAutoloadSecs(0);
+        i_xDocProps->setAutoloadURL(OUString());
+    }
+    i_xDocProps->setDefaultTarget(getDefaultTarget());
+    i_xDocProps->setAuthor(getAuthor());
+    i_xDocProps->setCreationDate(getCreationDate());
+    i_xDocProps->setModifiedBy(getModifiedBy());
+    i_xDocProps->setModificationDate(getModificationDate());
+    i_xDocProps->setPrintedBy(getPrintedBy());
+    i_xDocProps->setPrintDate(getPrintDate());
+    i_xDocProps->setEditingCycles(getEditingCycles());
+    i_xDocProps->setEditingDuration(getEditingDuration());
+    i_xDocProps->setDescription(getDescription());
+    i_xDocProps->setKeywords(
+        ::comphelper::string::convertCommaSeparated(getKeywords()));
+    i_xDocProps->setSubject(getSubject());
+    i_xDocProps->setTitle(getTitle());
+
+    // this is necessary in case of replaying a recorded macro:
+    // in this case, the macro may contain the 4 old user-defined DocumentInfo
+    // fields, but not any of the DocumentInfo properties;
+    // as a consequence, most of the UserDefined properties of the
+    // DocumentProperties would be summarily deleted here, which does not
+    // seem like a good idea.
+    if (i_bDoNotUpdateUserDefined)
+        return;
+
+    try
+    {
+        Reference< beans::XPropertyContainer > xContainer = i_xDocProps->getUserDefinedProperties();
+        Reference < beans::XPropertySet > xSet( xContainer, UNO_QUERY );
+        Reference< beans::XPropertySetInfo > xSetInfo = xSet->getPropertySetInfo();
+        const Sequence< beans::Property > lProps = xSetInfo->getProperties();
+        for ( const beans::Property& rProp : lProps )
+        {
+            if (rProp.Attributes & css::beans::PropertyAttribute::REMOVABLE)
+            {
+                xContainer->removeProperty( rProp.Name );
+            }
+        }
+
+        for (auto const & pProp : m_aCustomProperties)
+        {
+            try
+            {
+                xContainer->addProperty( pProp->m_sName,
+                    beans::PropertyAttribute::REMOVABLE, pProp->m_aValue );
+            }
+            catch ( Exception const & )
+            {
+                TOOLS_WARN_EXCEPTION( "sfx.dialog", "SfxDocumentInfoItem::updateDocumentInfo(): exception while adding custom properties" );
+            }
+        }
+    }
+    catch ( Exception const & )
+    {
+        TOOLS_WARN_EXCEPTION( "sfx.dialog", "SfxDocumentInfoItem::updateDocumentInfo(): exception while removing custom properties" );
+    }
+}
+
+
+void SfxDocumentInfoItem::SetDeleteUserData( bool bSet )
+{
+    m_bDeleteUserData = bSet;
+}
+
+
+void SfxDocumentInfoItem::SetUseUserData( bool bSet )
+{
+    m_bUseUserData = bSet;
+}
+
+void SfxDocumentInfoItem::SetUseThumbnailSave( bool bSet )
+{
+    m_bUseThumbnailSave = bSet;
+}
+
+std::vector< std::unique_ptr<CustomProperty> > SfxDocumentInfoItem::GetCustomProperties() const
+{
+    std::vector< std::unique_ptr<CustomProperty> > aRet;
+    for (auto const & pOtherProp : m_aCustomProperties)
+    {
+        std::unique_ptr<CustomProperty> pProp(new CustomProperty( pOtherProp->m_sName,
+                                                    pOtherProp->m_aValue ));
+        aRet.push_back( std::move(pProp) );
+    }
+
+    return aRet;
+}
+
+void SfxDocumentInfoItem::ClearCustomProperties()
+{
+    m_aCustomProperties.clear();
+}
+
+void SfxDocumentInfoItem::AddCustomProperty( const OUString& sName, const Any& rValue )
+{
+    std::unique_ptr<CustomProperty> pProp(new CustomProperty( sName, rValue ));
+    m_aCustomProperties.push_back( std::move(pProp) );
+}
+
+
+void SfxDocumentInfoItem::SetCmisProperties( const Sequence< document::CmisProperty >& cmisProps)
+{
+    m_aCmisProperties = cmisProps;
+}
+
+bool SfxDocumentInfoItem::QueryValue( Any& rVal, sal_uInt8 nMemberId ) const
+{
+    OUString aValue;
+    sal_Int32 nValue = 0;
+    bool bValue = false;
+    bool bIsInt = false;
+    bool bIsString = false;
+    nMemberId &= ~CONVERT_TWIPS;
+    switch ( nMemberId )
+    {
+        case MID_DOCINFO_USEUSERDATA:
+            bValue = IsUseUserData();
+            break;
+        case MID_DOCINFO_USETHUMBNAILSAVE:
+            bValue = IsUseThumbnailSave();
+            break;
+        case MID_DOCINFO_DELETEUSERDATA:
+            bValue = m_bDeleteUserData;
+            break;
+        case MID_DOCINFO_AUTOLOADENABLED:
+            bValue = isAutoloadEnabled();
+            break;
+        case MID_DOCINFO_AUTOLOADSECS:
+            bIsInt = true;
+            nValue = getAutoloadDelay();
+            break;
+        case MID_DOCINFO_AUTOLOADURL:
+            bIsString = true;
+            aValue = getAutoloadURL();
+            break;
+        case MID_DOCINFO_DEFAULTTARGET:
+            bIsString = true;
+            aValue = getDefaultTarget();
+            break;
+        case MID_DOCINFO_DESCRIPTION:
+            bIsString = true;
+            aValue = getDescription();
+            break;
+        case MID_DOCINFO_KEYWORDS:
+            bIsString = true;
+            aValue = getKeywords();
+            break;
+        case MID_DOCINFO_SUBJECT:
+            bIsString = true;
+            aValue = getSubject();
+            break;
+        case MID_DOCINFO_TITLE:
+            bIsString = true;
+            aValue = getTitle();
+            break;
+        default:
+            OSL_FAIL("Wrong MemberId!");
+            return false;
+     }
+
+    if ( bIsString )
+        rVal <<= aValue;
+    else if ( bIsInt )
+        rVal <<= nValue;
+    else
+        rVal <<= bValue;
+    return true;
+}
+
+bool SfxDocumentInfoItem::PutValue( const Any& rVal, sal_uInt8 nMemberId )
+{
+    OUString aValue;
+    sal_Int32 nValue=0;
+    bool bValue = false;
+    bool bRet = false;
+    nMemberId &= ~CONVERT_TWIPS;
+    switch ( nMemberId )
+    {
+        case MID_DOCINFO_USEUSERDATA:
+            bRet = (rVal >>= bValue);
+            if ( bRet )
+                SetUseUserData( bValue );
+            break;
+        case MID_DOCINFO_USETHUMBNAILSAVE:
+            bRet = (rVal >>=bValue);
+            if ( bRet )
+                SetUseThumbnailSave( bValue );
+            break;
+        case MID_DOCINFO_DELETEUSERDATA:
+            // QUESTION: deleting user data was done here; seems to be superfluous!
+            bRet = (rVal >>= bValue);
+            if ( bRet )
+                SetDeleteUserData( bValue );
+            break;
+        case MID_DOCINFO_AUTOLOADENABLED:
+            bRet = (rVal >>= bValue);
+            if ( bRet )
+                m_isAutoloadEnabled = bValue;
+            break;
+        case MID_DOCINFO_AUTOLOADSECS:
+            bRet = (rVal >>= nValue);
+            if ( bRet )
+                m_AutoloadDelay = nValue;
+            break;
+        case MID_DOCINFO_AUTOLOADURL:
+            bRet = (rVal >>= aValue);
+            if ( bRet )
+                m_AutoloadURL = aValue;
+            break;
+        case MID_DOCINFO_DEFAULTTARGET:
+            bRet = (rVal >>= aValue);
+            if ( bRet )
+                m_DefaultTarget = aValue;
+            break;
+        case MID_DOCINFO_DESCRIPTION:
+            bRet = (rVal >>= aValue);
+            if ( bRet )
+                setDescription(aValue);
+            break;
+        case MID_DOCINFO_KEYWORDS:
+            bRet = (rVal >>= aValue);
+            if ( bRet )
+                setKeywords(aValue);
+            break;
+        case MID_DOCINFO_SUBJECT:
+            bRet = (rVal >>= aValue);
+            if ( bRet )
+                setSubject(aValue);
+            break;
+        case MID_DOCINFO_TITLE:
+            bRet = (rVal >>= aValue);
+            if ( bRet )
+                setTitle(aValue);
+            break;
+        default:
+            OSL_FAIL("Wrong MemberId!");
+            return false;
+    }
+
+    return bRet;
+}
+
+SfxDocumentDescPage::SfxDocumentDescPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rItemSet)
+    : SfxTabPage(pPage, pController, "sfx/ui/descriptioninfopage.ui", "DescriptionInfoPage", &rItemSet)
+    , m_pInfoItem(nullptr)
+    , m_xTitleEd(m_xBuilder->weld_entry("title"))
+    , m_xThemaEd(m_xBuilder->weld_entry("subject"))
+    , m_xKeywordsEd(m_xBuilder->weld_entry("keywords"))
+    , m_xCommentEd(m_xBuilder->weld_text_view("comments"))
+{
+    m_xCommentEd->set_size_request(m_xKeywordsEd->get_preferred_size().Width(),
+                                   m_xCommentEd->get_height_rows(16));
+}
+
+SfxDocumentDescPage::~SfxDocumentDescPage()
+{
+}
+
+std::unique_ptr<SfxTabPage> SfxDocumentDescPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet *rItemSet)
+{
+     return std::make_unique<SfxDocumentDescPage>(pPage, pController, *rItemSet);
+}
+
+bool SfxDocumentDescPage::FillItemSet(SfxItemSet *rSet)
+{
+    // Test whether a change is present
+    const bool bTitleMod = m_xTitleEd->get_value_changed_from_saved();
+    const bool bThemeMod = m_xThemaEd->get_value_changed_from_saved();
+    const bool bKeywordsMod = m_xKeywordsEd->get_value_changed_from_saved();
+    const bool bCommentMod = m_xCommentEd->get_value_changed_from_saved();
+    if ( !( bTitleMod || bThemeMod || bKeywordsMod || bCommentMod ) )
+    {
+        return false;
+    }
+
+    // Generating the output data
+    const SfxPoolItem* pItem = nullptr;
+    SfxDocumentInfoItem* pInfo = nullptr;
+    const SfxItemSet* pExSet = GetDialogExampleSet();
+
+    if ( pExSet && SfxItemState::SET != pExSet->GetItemState( SID_DOCINFO, true, &pItem ) )
+        pInfo = m_pInfoItem;
+    else if ( pItem )
+        pInfo = new SfxDocumentInfoItem( *static_cast<const SfxDocumentInfoItem *>(pItem) );
+
+    if ( !pInfo )
+    {
+        SAL_WARN( "sfx.dialog", "SfxDocumentDescPage::FillItemSet(): no item found" );
+        return false;
+    }
+
+    if ( bTitleMod )
+    {
+        pInfo->setTitle( m_xTitleEd->get_text() );
+    }
+    if ( bThemeMod )
+    {
+        pInfo->setSubject( m_xThemaEd->get_text() );
+    }
+    if ( bKeywordsMod )
+    {
+        pInfo->setKeywords( m_xKeywordsEd->get_text() );
+    }
+    if ( bCommentMod )
+    {
+        pInfo->setDescription( m_xCommentEd->get_text() );
+    }
+    rSet->Put( *pInfo );
+    if ( pInfo != m_pInfoItem )
+    {
+        delete pInfo;
+    }
+
+    return true;
+}
+
+void SfxDocumentDescPage::Reset(const SfxItemSet *rSet)
+{
+    m_pInfoItem = const_cast<SfxDocumentInfoItem*>(&rSet->Get(SID_DOCINFO));
+
+    m_xTitleEd->set_text(m_pInfoItem->getTitle());
+    m_xThemaEd->set_text(m_pInfoItem->getSubject());
+    m_xKeywordsEd->set_text(m_pInfoItem->getKeywords());
+    m_xCommentEd->set_text(m_pInfoItem->getDescription());
+
+    m_xTitleEd->save_value();
+    m_xThemaEd->save_value();
+    m_xKeywordsEd->save_value();
+    m_xCommentEd->save_value();
+
+    const SfxBoolItem* pROItem = SfxItemSet::GetItem<SfxBoolItem>(rSet, SID_DOC_READONLY, false);
+    if (pROItem && pROItem->GetValue())
+    {
+        m_xTitleEd->set_editable(false);
+        m_xThemaEd->set_editable(false);
+        m_xKeywordsEd->set_editable(false);
+        m_xCommentEd->set_editable(false);
+    }
+}
+
+SfxDocumentPage::SfxDocumentPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rItemSet)
+    : SfxTabPage(pPage, pController, "sfx/ui/documentinfopage.ui", "DocumentInfoPage", &rItemSet)
+    , bEnableUseUserData( false )
+    , bHandleDelete( false )
+    , m_xBmp(m_xBuilder->weld_image("icon"))
+    , m_xNameED(m_xBuilder->weld_label("nameed"))
+    , m_xChangePassBtn(m_xBuilder->weld_button("changepass"))
+    , m_xShowTypeFT(m_xBuilder->weld_label("showtype"))
+    , m_xFileValEd(m_xBuilder->weld_label("showlocation"))
+    , m_xShowSizeFT(m_xBuilder->weld_label("showsize"))
+    , m_xCreateValFt(m_xBuilder->weld_label("showcreate"))
+    , m_xChangeValFt(m_xBuilder->weld_label("showmodify"))
+    , m_xSignedValFt(m_xBuilder->weld_label("showsigned"))
+    , m_xSignatureBtn(m_xBuilder->weld_button("signature"))
+    , m_xPrintValFt(m_xBuilder->weld_label("showprint"))
+    , m_xTimeLogValFt(m_xBuilder->weld_label("showedittime"))
+    , m_xDocNoValFt(m_xBuilder->weld_label("showrevision"))
+    , m_xUseUserDataCB(m_xBuilder->weld_check_button("userdatacb"))
+    , m_xDeleteBtn(m_xBuilder->weld_button("reset"))
+    , m_xUseThumbnailSaveCB(m_xBuilder->weld_check_button("thumbnailsavecb"))
+    , m_xTemplFt(m_xBuilder->weld_label("templateft"))
+    , m_xTemplValFt(m_xBuilder->weld_label("showtemplate"))
+{
+    m_aUnknownSize = m_xShowSizeFT->get_label();
+    m_xShowSizeFT->set_label(OUString());
+
+    m_aMultiSignedStr = m_xSignedValFt->get_label();
+    m_xSignedValFt->set_label(OUString());
+
+    ImplUpdateSignatures();
+    ImplCheckPasswordState();
+    m_xChangePassBtn->connect_clicked( LINK( this, SfxDocumentPage, ChangePassHdl ) );
+    m_xSignatureBtn->connect_clicked( LINK( this, SfxDocumentPage, SignatureHdl ) );
+    m_xDeleteBtn->connect_clicked( LINK( this, SfxDocumentPage, DeleteHdl ) );
+
+    // [i96288] Check if the document signature command is enabled
+    // on the main list enable/disable the pushbutton accordingly
+    SvtCommandOptions aCmdOptions;
+    if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, "Signature" ) )
+        m_xSignatureBtn->set_sensitive(false);
+}
+
+SfxDocumentPage::~SfxDocumentPage()
+{
+}
+
+IMPL_LINK_NOARG(SfxDocumentPage, DeleteHdl, weld::Button&, void)
+{
+    OUString aName;
+    if (bEnableUseUserData && m_xUseUserDataCB->get_active())
+        aName = SvtUserOptions().GetFullName();
+    const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() );
+    DateTime now( DateTime::SYSTEM );
+    util::DateTime uDT( now.GetUNODateTime() );
+    m_xCreateValFt->set_label( ConvertDateTime_Impl( aName, uDT, rLocaleWrapper ) );
+    m_xChangeValFt->set_label( "" );
+    m_xPrintValFt->set_label( "" );
+    const tools::Time aTime( 0 );
+    m_xTimeLogValFt->set_label( rLocaleWrapper.getDuration( aTime ) );
+    m_xDocNoValFt->set_label(OUString('1'));
+    bHandleDelete = true;
+}
+
+IMPL_LINK_NOARG(SfxDocumentPage, SignatureHdl, weld::Button&, void)
+{
+    SfxObjectShell* pDoc = SfxObjectShell::Current();
+    if( pDoc )
+    {
+        pDoc->SignDocumentContent(GetFrameWeld());
+
+        ImplUpdateSignatures();
+    }
+}
+
+IMPL_LINK_NOARG(SfxDocumentPage, ChangePassHdl, weld::Button&, void)
+{
+    SfxObjectShell* pShell = SfxObjectShell::Current();
+    do
+    {
+        if (!pShell)
+            break;
+        SfxItemSet* pMedSet = pShell->GetMedium()->GetItemSet();
+        if (!pMedSet)
+            break;
+        std::shared_ptr<const SfxFilter> pFilter = pShell->GetMedium()->GetFilter();
+        if (!pFilter)
+            break;
+
+        sfx2::RequestPassword(pFilter, OUString(), pMedSet, GetFrameWeld()->GetXWindow());
+        pShell->SetModified();
+    }
+    while (false);
+}
+
+void SfxDocumentPage::ImplUpdateSignatures()
+{
+    SfxObjectShell* pDoc = SfxObjectShell::Current();
+    if ( !pDoc )
+        return;
+
+    SfxMedium* pMedium = pDoc->GetMedium();
+    if ( !pMedium || pMedium->GetName().isEmpty() || !pMedium->GetStorage().is() )
+        return;
+
+    Reference< security::XDocumentDigitalSignatures > xD;
+    try
+    {
+        xD = security::DocumentDigitalSignatures::createDefault(comphelper::getProcessComponentContext());
+        xD->setParentWindow(GetDialogController()->getDialog()->GetXWindow());
+    }
+    catch ( const css::uno::DeploymentException& )
+    {
+    }
+    OUString s;
+    Sequence< security::DocumentSignatureInformation > aInfos;
+
+    if ( xD.is() )
+        aInfos = xD->verifyDocumentContentSignatures( pMedium->GetZipStorageToSign_Impl(),
+                                                      uno::Reference< io::XInputStream >() );
+    if ( aInfos.getLength() > 1 )
+        s = m_aMultiSignedStr;
+    else if ( aInfos.getLength() == 1 )
+    {
+        const security::DocumentSignatureInformation& rInfo = aInfos[ 0 ];
+        s = utl::GetDateTimeString( rInfo.SignatureDate, rInfo.SignatureTime ) + ", " +
+            comphelper::xmlsec::GetContentPart(rInfo.Signer->getSubjectName(), rInfo.Signer->getCertificateKind());
+    }
+    m_xSignedValFt->set_label(s);
+}
+
+void SfxDocumentPage::ImplCheckPasswordState()
+{
+    SfxObjectShell* pShell = SfxObjectShell::Current();
+    do
+    {
+        if (!pShell)
+            break;
+        SfxItemSet* pMedSet = pShell->GetMedium()->GetItemSet();
+        if (!pMedSet)
+            break;
+        const SfxUnoAnyItem* pEncryptionDataItem = SfxItemSet::GetItem<SfxUnoAnyItem>(pMedSet, SID_ENCRYPTIONDATA, false);
+        uno::Sequence< beans::NamedValue > aEncryptionData;
+        if (pEncryptionDataItem)
+            pEncryptionDataItem->GetValue() >>= aEncryptionData;
+        else
+             break;
+
+        if (!aEncryptionData.hasElements())
+             break;
+        m_xChangePassBtn->set_sensitive(true);
+        return;
+    }
+    while (false);
+    m_xChangePassBtn->set_sensitive(false);
+}
+
+std::unique_ptr<SfxTabPage> SfxDocumentPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rItemSet)
+{
+     return std::make_unique<SfxDocumentPage>(pPage, pController, *rItemSet);
+}
+
+void SfxDocumentPage::EnableUseUserData()
+{
+    bEnableUseUserData = true;
+    m_xUseUserDataCB->show();
+    m_xDeleteBtn->show();
+}
+
+bool SfxDocumentPage::FillItemSet( SfxItemSet* rSet )
+{
+    bool bRet = false;
+
+    if ( !bHandleDelete && bEnableUseUserData &&
+         m_xUseUserDataCB->get_state_changed_from_saved() )
+    {
+        const SfxItemSet* pExpSet = GetDialogExampleSet();
+        const SfxPoolItem* pItem;
+
+        if ( pExpSet && SfxItemState::SET == pExpSet->GetItemState( SID_DOCINFO, true, &pItem ) )
+        {
+            const SfxDocumentInfoItem* pInfoItem = static_cast<const SfxDocumentInfoItem*>(pItem);
+            bool bUseData = ( TRISTATE_TRUE == m_xUseUserDataCB->get_state() );
+            const_cast<SfxDocumentInfoItem*>(pInfoItem)->SetUseUserData( bUseData );
+            rSet->Put( *pInfoItem );
+            bRet = true;
+        }
+    }
+
+    if ( bHandleDelete )
+    {
+        const SfxItemSet* pExpSet = GetDialogExampleSet();
+        const SfxPoolItem* pItem;
+        if ( pExpSet && SfxItemState::SET == pExpSet->GetItemState( SID_DOCINFO, true, &pItem ) )
+        {
+            const SfxDocumentInfoItem* pInfoItem = static_cast<const SfxDocumentInfoItem*>(pItem);
+            bool bUseAuthor = bEnableUseUserData && m_xUseUserDataCB->get_active();
+            SfxDocumentInfoItem newItem( *pInfoItem );
+            newItem.resetUserData( bUseAuthor
+                ? SvtUserOptions().GetFullName()
+                : OUString() );
+            const_cast<SfxDocumentInfoItem*>(pInfoItem)->SetUseUserData( TRISTATE_TRUE == m_xUseUserDataCB->get_state() );
+            newItem.SetUseUserData( TRISTATE_TRUE == m_xUseUserDataCB->get_state() );
+
+            newItem.SetDeleteUserData( true );
+            rSet->Put( newItem );
+            bRet = true;
+        }
+    }
+
+    if ( m_xUseThumbnailSaveCB->get_state_changed_from_saved() )
+    {
+        const SfxItemSet* pExpSet = GetDialogExampleSet();
+        const SfxPoolItem* pItem;
+
+        if ( pExpSet && SfxItemState::SET == pExpSet->GetItemState( SID_DOCINFO, true, &pItem ) )
+        {
+            const SfxDocumentInfoItem* pInfoItem = static_cast<const SfxDocumentInfoItem*>(pItem);
+            bool bUseThumbnail = ( TRISTATE_TRUE == m_xUseThumbnailSaveCB->get_state() );
+            const_cast<SfxDocumentInfoItem*>(pInfoItem)->SetUseThumbnailSave( bUseThumbnail );
+            rSet->Put( *pInfoItem );
+            bRet = true;
+        }
+    }
+
+    return bRet;
+}
+
+void SfxDocumentPage::Reset( const SfxItemSet* rSet )
+{
+    // Determine the document information
+    const SfxDocumentInfoItem& rInfoItem = rSet->Get(SID_DOCINFO);
+
+    // template data
+    if (rInfoItem.HasTemplate())
+    {
+        const OUString& rName = rInfoItem.getTemplateName();
+        if (rName.getLength() > SAL_MAX_INT16) // tdf#122780 pick some ~arbitrary max size
+            m_xTemplValFt->set_label(rName.copy(0, SAL_MAX_INT16));
+        else
+            m_xTemplValFt->set_label(rName);
+    }
+    else
+    {
+        m_xTemplFt->hide();
+        m_xTemplValFt->hide();
+    }
+
+    // determine file name
+    OUString aFile( rInfoItem.GetValue() );
+    OUString aFactory( aFile );
+    if ( aFile.getLength() > 2 && aFile[0] == '[' )
+    {
+        sal_Int32 nPos = aFile.indexOf( ']' );
+        aFactory = aFile.copy( 1, nPos-1  );
+        aFile = aFile.copy( nPos+1 );
+    }
+
+    // determine name
+    INetURLObject aURL(aFile);
+    OUString aName = aURL.GetLastName(INetURLObject::DecodeMechanism::WithCharset);
+    if ( aName.isEmpty() || aURL.GetProtocol() == INetProtocol::PrivSoffice )
+        aName = SfxResId( STR_NONAME );
+    m_xNameED->set_label( aName );
+
+    // determine context symbol
+    aURL.SetSmartProtocol( INetProtocol::File );
+    aURL.SetSmartURL( aFactory);
+    const OUString& rMainURL = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+    OUString aImage = SvFileInformationManager::GetImageId( aURL, true );
+    m_xBmp->set_from_icon_name(aImage);
+
+    // determine size and type
+    OUString aSizeText( m_aUnknownSize );
+    if ( aURL.GetProtocol() == INetProtocol::File ||
+         aURL.isAnyKnownWebDAVScheme() )
+        aSizeText = CreateSizeText( SfxContentHelper::GetSize( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) );
+    m_xShowSizeFT->set_label( aSizeText );
+
+    OUString aDescription = SvFileInformationManager::GetDescription( INetURLObject(rMainURL) );
+    if ( aDescription.isEmpty() )
+        aDescription = SfxResId( STR_SFX_NEWOFFICEDOC );
+    m_xShowTypeFT->set_label( aDescription );
+
+    // determine location
+    aURL.SetSmartURL( aFile);
+    if ( aURL.GetProtocol() == INetProtocol::File )
+    {
+        INetURLObject aPath( aURL );
+        aPath.setFinalSlash();
+        aPath.removeSegment();
+        // we know it's a folder -> don't need the final slash, but it's better for WB_PATHELLIPSIS
+        aPath.removeFinalSlash();
+        OUString aText( aPath.PathToFileName() ); //! (pb) MaxLen?
+        m_xFileValEd->set_label( aText );
+    }
+    else if ( aURL.GetProtocol() != INetProtocol::PrivSoffice )
+        m_xFileValEd->set_label( aURL.GetPartBeforeLastName() );
+
+    // handle access data
+    bool bUseUserData = rInfoItem.IsUseUserData();
+    const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() );
+    m_xCreateValFt->set_label( ConvertDateTime_Impl( rInfoItem.getAuthor(),
+        rInfoItem.getCreationDate(), rLocaleWrapper ) );
+    util::DateTime aTime( rInfoItem.getModificationDate() );
+    if ( aTime.Month > 0 )
+        m_xChangeValFt->set_label( ConvertDateTime_Impl(
+            rInfoItem.getModifiedBy(), aTime, rLocaleWrapper ) );
+    aTime = rInfoItem.getPrintDate();
+    if ( aTime.Month > 0 )
+        m_xPrintValFt->set_label( ConvertDateTime_Impl( rInfoItem.getPrintedBy(),
+            aTime, rLocaleWrapper ) );
+    const long nTime = rInfoItem.getEditingDuration();
+    if ( bUseUserData )
+    {
+        const tools::Time aT( nTime/3600, (nTime%3600)/60, nTime%60 );
+        m_xTimeLogValFt->set_label( rLocaleWrapper.getDuration( aT ) );
+        m_xDocNoValFt->set_label( OUString::number(
+            rInfoItem.getEditingCycles() ) );
+    }
+
+    bool bUseThumbnailSave = rInfoItem.IsUseThumbnailSave();
+
+    // Check for cmis properties where otherwise unavailable
+    if ( rInfoItem.isCmisDocument( ) )
+    {
+        const uno::Sequence< document::CmisProperty > aCmisProps = rInfoItem.GetCmisProperties();
+        for ( const auto& rCmisProp : aCmisProps )
+        {
+            if ( rCmisProp.Id == "cmis:contentStreamLength" &&
+                 aSizeText == m_aUnknownSize )
+            {
+                Sequence< sal_Int64 > seqValue;
+                rCmisProp.Value >>= seqValue;
+                SvNumberFormatter aNumberFormatter( ::comphelper::getProcessComponentContext(),
+                        Application::GetSettings().GetLanguageTag().getLanguageType() );
+                sal_uInt32 nIndex = aNumberFormatter.GetFormatIndex( NF_NUMBER_SYSTEM );
+                if ( seqValue.hasElements() )
+                {
+                    OUString sValue;
+                    aNumberFormatter.GetInputLineString( seqValue[0], nIndex, sValue );
+                    m_xShowSizeFT->set_label( CreateSizeText( sValue.toInt64( ) ) );
+                }
+            }
+
+            util::DateTime uDT;
+            OUString emptyDate = ConvertDateTime_Impl( "", uDT, rLocaleWrapper );
+            if ( rCmisProp.Id == "cmis:creationDate" &&
+                 (m_xCreateValFt->get_label() == emptyDate ||
+                  m_xCreateValFt->get_label().isEmpty()))
+            {
+                Sequence< util::DateTime > seqValue;
+                rCmisProp.Value >>= seqValue;
+                if ( seqValue.hasElements() )
+                {
+                    m_xCreateValFt->set_label( ConvertDateTime_Impl( "", seqValue[0], rLocaleWrapper ) );
+                }
+            }
+            if ( rCmisProp.Id == "cmis:lastModificationDate" &&
+                 (m_xChangeValFt->get_label() == emptyDate ||
+                  m_xChangeValFt->get_label().isEmpty()))
+            {
+                Sequence< util::DateTime > seqValue;
+                rCmisProp.Value >>= seqValue;
+                if ( seqValue.hasElements() )
+                {
+                    m_xChangeValFt->set_label( ConvertDateTime_Impl( "", seqValue[0], rLocaleWrapper ) );
+                }
+            }
+        }
+    }
+
+    m_xUseUserDataCB->set_active(bUseUserData);
+    m_xUseUserDataCB->save_state();
+    m_xUseUserDataCB->set_sensitive( bEnableUseUserData );
+    bHandleDelete = false;
+    m_xDeleteBtn->set_sensitive( bEnableUseUserData );
+    m_xUseThumbnailSaveCB->set_active(bUseThumbnailSave);
+    m_xUseThumbnailSaveCB->save_state();
+}
+
+SfxDocumentInfoDialog::SfxDocumentInfoDialog(weld::Window* pParent, const SfxItemSet& rItemSet)
+    : SfxTabDialogController(pParent, "sfx/ui/documentpropertiesdialog.ui",
+                             "DocumentPropertiesDialog", &rItemSet)
+{
+    const SfxDocumentInfoItem& rInfoItem = rItemSet.Get( SID_DOCINFO );
+
+#ifdef DBG_UTIL
+    const SfxStringItem* pURLItem = rItemSet.GetItem<SfxStringItem>(SID_BASEURL, false);
+    DBG_ASSERT( pURLItem, "No BaseURL provided for InternetTabPage!" );
+#endif
+
+     // Determine the Titles
+    const SfxPoolItem* pItem = nullptr;
+    OUString aTitle(m_xDialog->get_title());
+    if ( SfxItemState::SET !=
+         rItemSet.GetItemState( SID_EXPLORER_PROPS_START, false, &pItem ) )
+    {
+        // File name
+        const OUString& aFile( rInfoItem.GetValue() );
+
+        INetURLObject aURL;
+        aURL.SetSmartProtocol( INetProtocol::File );
+        aURL.SetSmartURL( aFile);
+        if ( INetProtocol::PrivSoffice != aURL.GetProtocol() )
+        {
+            OUString aLastName( aURL.GetLastName() );
+            if ( !aLastName.isEmpty() )
+                aTitle = aTitle.replaceFirst("%1", aLastName);
+            else
+                aTitle = aTitle.replaceFirst("%1", aFile);
+        }
+        else
+            aTitle = aTitle.replaceFirst("%1", SfxResId( STR_NONAME ));
+    }
+    else
+    {
+        DBG_ASSERT( dynamic_cast<const SfxStringItem *>(pItem) != nullptr,
+                    "SfxDocumentInfoDialog:<SfxStringItem> expected" );
+        aTitle = aTitle.replaceFirst("%1", static_cast<const SfxStringItem*>(pItem)->GetValue());
+    }
+    m_xDialog->set_title(aTitle);
+
+    // Property Pages
+    AddTabPage("general", SfxDocumentPage::Create, nullptr);
+    AddTabPage("description", SfxDocumentDescPage::Create, nullptr);
+    AddTabPage("customprops", SfxCustomPropertiesPage::Create, nullptr);
+    if (rInfoItem.isCmisDocument())
+        AddTabPage("cmisprops", SfxCmisPropertiesPage::Create, nullptr);
+    else
+        RemoveTabPage("cmisprops");
+    AddTabPage("security", SfxSecurityPage::Create, nullptr);
+}
+
+void SfxDocumentInfoDialog::PageCreated(const OString& rId, SfxTabPage &rPage)
+{
+    if (rId == "general")
+        static_cast<SfxDocumentPage&>(rPage).EnableUseUserData();
+}
+
+void SfxDocumentInfoDialog::AddFontTabPage()
+{
+    AddTabPage("font", SfxResId(STR_FONT_TABPAGE), SfxDocumentFontsPage::Create);
+}
+
+// class CustomPropertiesYesNoButton -------------------------------------
+
+CustomPropertiesYesNoButton::CustomPropertiesYesNoButton(std::unique_ptr<weld::Widget> xTopLevel,
+                                                         std::unique_ptr<weld::RadioButton> xYesButton,
+                                                         std::unique_ptr<weld::RadioButton> xNoButton)
+    : m_xTopLevel(std::move(xTopLevel))
+    , m_xYesButton(std::move(xYesButton))
+    , m_xNoButton(std::move(xNoButton))
+{
+    CheckNo();
+}
+
+CustomPropertiesYesNoButton::~CustomPropertiesYesNoButton()
+{
+}
+
+namespace {
+
+class DurationDialog_Impl : public weld::GenericDialogController
+{
+    std::unique_ptr<weld::CheckButton> m_xNegativeCB;
+    std::unique_ptr<weld::SpinButton> m_xYearNF;
+    std::unique_ptr<weld::SpinButton> m_xMonthNF;
+    std::unique_ptr<weld::SpinButton> m_xDayNF;
+    std::unique_ptr<weld::SpinButton> m_xHourNF;
+    std::unique_ptr<weld::SpinButton> m_xMinuteNF;
+    std::unique_ptr<weld::SpinButton> m_xSecondNF;
+    std::unique_ptr<weld::SpinButton> m_xMSecondNF;
+
+public:
+    DurationDialog_Impl(weld::Widget* pParent, const util::Duration& rDuration);
+    util::Duration  GetDuration() const;
+};
+
+}
+
+DurationDialog_Impl::DurationDialog_Impl(weld::Widget* pParent, const util::Duration& rDuration)
+    : GenericDialogController(pParent, "sfx/ui/editdurationdialog.ui", "EditDurationDialog")
+    , m_xNegativeCB(m_xBuilder->weld_check_button("negative"))
+    , m_xYearNF(m_xBuilder->weld_spin_button("years"))
+    , m_xMonthNF(m_xBuilder->weld_spin_button("months"))
+    , m_xDayNF(m_xBuilder->weld_spin_button("days"))
+    , m_xHourNF(m_xBuilder->weld_spin_button("hours"))
+    , m_xMinuteNF(m_xBuilder->weld_spin_button("minutes"))
+    , m_xSecondNF(m_xBuilder->weld_spin_button("seconds"))
+    , m_xMSecondNF(m_xBuilder->weld_spin_button("milliseconds"))
+{
+    m_xNegativeCB->set_active(rDuration.Negative);
+    m_xYearNF->set_value(rDuration.Years);
+    m_xMonthNF->set_value(rDuration.Months);
+    m_xDayNF->set_value(rDuration.Days);
+    m_xHourNF->set_value(rDuration.Hours);
+    m_xMinuteNF->set_value(rDuration.Minutes);
+    m_xSecondNF->set_value(rDuration.Seconds);
+    m_xMSecondNF->set_value(rDuration.NanoSeconds);
+}
+
+util::Duration  DurationDialog_Impl::GetDuration() const
+{
+    util::Duration  aRet;
+    aRet.Negative = m_xNegativeCB->get_active();
+    aRet.Years = m_xYearNF->get_value();
+    aRet.Months = m_xMonthNF->get_value();
+    aRet.Days = m_xDayNF->get_value();
+    aRet.Hours  = m_xHourNF->get_value();
+    aRet.Minutes = m_xMinuteNF->get_value();
+    aRet.Seconds = m_xSecondNF->get_value();
+    aRet.NanoSeconds = m_xMSecondNF->get_value();
+    return aRet;
+}
+
+CustomPropertiesDurationField::CustomPropertiesDurationField(std::unique_ptr<weld::Entry> xEntry,
+                                                             std::unique_ptr<weld::Button> xEditButton)
+    : m_xEntry(std::move(xEntry))
+    , m_xEditButton(std::move(xEditButton))
+{
+    m_xEditButton->connect_clicked(LINK(this, CustomPropertiesDurationField, ClickHdl));
+    SetDuration( util::Duration(false, 0, 0, 0, 0, 0, 0, 0) );
+}
+
+void CustomPropertiesDurationField::set_visible(bool bVisible)
+{
+    m_xEntry->set_visible(bVisible);
+    m_xEditButton->set_visible(bVisible);
+}
+
+void CustomPropertiesDurationField::SetDuration( const util::Duration& rDuration )
+{
+    m_aDuration = rDuration;
+    OUString sText = (rDuration.Negative ? OUString('-') : OUString('+')) +
+        SfxResId(SFX_ST_DURATION_FORMAT);
+    sText = sText.replaceFirst( "%1", OUString::number( rDuration.Years ) );
+    sText = sText.replaceFirst( "%2", OUString::number( rDuration.Months ) );
+    sText = sText.replaceFirst( "%3", OUString::number( rDuration.Days   ) );
+    sText = sText.replaceFirst( "%4", OUString::number( rDuration.Hours  ) );
+    sText = sText.replaceFirst( "%5", OUString::number( rDuration.Minutes) );
+    sText = sText.replaceFirst( "%6", OUString::number( rDuration.Seconds) );
+    m_xEntry->set_text(sText);
+}
+
+IMPL_LINK(CustomPropertiesDurationField, ClickHdl, weld::Button&, rButton, void)
+{
+    DurationDialog_Impl aDurationDlg(&rButton, GetDuration());
+    if (aDurationDlg.run() == RET_OK)
+        SetDuration(aDurationDlg.GetDuration());
+}
+
+namespace
+{
+    void fillNameBox(weld::ComboBox& rNameBox)
+    {
+        for (size_t i = 0; i < SAL_N_ELEMENTS(SFX_CB_PROPERTY_STRINGARRAY); ++i)
+            rNameBox.append_text(SfxResId(SFX_CB_PROPERTY_STRINGARRAY[i]));
+        Size aSize(rNameBox.get_preferred_size());
+        rNameBox.set_size_request(aSize.Width(), aSize.Height());
+    }
+
+    void fillTypeBox(weld::ComboBox& rTypeBox)
+    {
+        for (size_t i = 0; i < SAL_N_ELEMENTS(SFX_LB_PROPERTY_STRINGARRAY); ++i)
+        {
+            OUString sId(OUString::number(SFX_LB_PROPERTY_STRINGARRAY[i].second));
+            rTypeBox.append(sId, SfxResId(SFX_LB_PROPERTY_STRINGARRAY[i].first));
+        }
+        rTypeBox.set_active(0);
+        Size aSize(rTypeBox.get_preferred_size());
+        rTypeBox.set_size_request(aSize.Width(), aSize.Height());
+    }
+}
+
+// struct CustomPropertyLine ---------------------------------------------
+CustomPropertyLine::CustomPropertyLine(CustomPropertiesWindow* pParent, weld::Widget* pContainer)
+    : m_pParent(pParent)
+    , m_xBuilder(Application::CreateBuilder(pContainer, "sfx/ui/linefragment.ui"))
+    , m_xLine(m_xBuilder->weld_container("lineentry"))
+    , m_xNameBox(m_xBuilder->weld_combo_box("namebox"))
+    , m_xTypeBox(m_xBuilder->weld_combo_box("typebox"))
+    , m_xValueEdit(m_xBuilder->weld_entry("valueedit"))
+    , m_xDateTimeBox(m_xBuilder->weld_widget("datetimebox"))
+    , m_xDateField(new CustomPropertiesDateField(new SvtCalendarBox(m_xBuilder->weld_menu_button("date"))))
+    , m_xTimeField(new CustomPropertiesTimeField(m_xBuilder->weld_time_spin_button("time", TimeFieldFormat::F_SEC)))
+    , m_xDurationBox(m_xBuilder->weld_widget("durationbox"))
+    , m_xDurationField(new CustomPropertiesDurationField(m_xBuilder->weld_entry("duration"),
+                                                         m_xBuilder->weld_button("durationbutton")))
+    , m_xYesNoButton(new CustomPropertiesYesNoButton(m_xBuilder->weld_widget("yesno"),
+                                                     m_xBuilder->weld_radio_button("yes"),
+                                                     m_xBuilder->weld_radio_button("no")))
+    , m_xRemoveButton(m_xBuilder->weld_button("remove"))
+    , m_bTypeLostFocus( false )
+{
+    fillNameBox(*m_xNameBox);
+    fillTypeBox(*m_xTypeBox);
+
+    m_xTypeBox->connect_changed(LINK(this, CustomPropertyLine, TypeHdl));
+    m_xRemoveButton->connect_clicked(LINK(this, CustomPropertyLine, RemoveHdl));
+    m_xValueEdit->connect_focus_out(LINK(this, CustomPropertyLine, EditLoseFocusHdl));
+    //add lose focus handlers of date/time fields
+    m_xTypeBox->connect_focus_out(LINK(this, CustomPropertyLine, BoxLoseFocusHdl));
+}
+
+void CustomPropertyLine::Clear()
+{
+    m_xNameBox->set_active(-1);
+    m_xValueEdit->set_text(OUString());
+
+}
+
+void CustomPropertyLine::Hide()
+{
+    m_xLine->hide();
+}
+
+CustomPropertiesWindow::CustomPropertiesWindow(weld::Container& rParent, weld::Label& rHeaderAccName,
+                                               weld::Label& rHeaderAccType, weld::Label& rHeaderAccValue)
+    : m_nHeight(0)
+    , m_nLineHeight(0)
+    , m_nScrollPos(0)
+    , m_pCurrentLine(nullptr)
+    , m_aNumberFormatter(::comphelper::getProcessComponentContext(),
+                         Application::GetSettings().GetLanguageTag().getLanguageType())
+    , m_rBody(rParent)
+    , m_rHeaderAccName(rHeaderAccName)
+    , m_rHeaderAccType(rHeaderAccType)
+    , m_rHeaderAccValue(rHeaderAccValue)
+{
+    m_aEditLoseFocusIdle.SetPriority( TaskPriority::LOWEST );
+    m_aEditLoseFocusIdle.SetInvokeHandler( LINK( this, CustomPropertiesWindow, EditTimeoutHdl ) );
+    m_aBoxLoseFocusIdle.SetPriority( TaskPriority::LOWEST );
+    m_aBoxLoseFocusIdle.SetInvokeHandler( LINK( this, CustomPropertiesWindow, BoxTimeoutHdl ) );
+}
+
+CustomPropertiesWindow::~CustomPropertiesWindow()
+{
+    m_aEditLoseFocusIdle.Stop();
+    m_aBoxLoseFocusIdle.Stop();
+
+    m_pCurrentLine = nullptr;
+}
+
+void CustomPropertyLine::DoTypeHdl(const weld::ComboBox& rBox)
+{
+    auto nType = rBox.get_active_id().toInt32();
+    m_xValueEdit->set_visible( (CUSTOM_TYPE_TEXT == nType) || (CUSTOM_TYPE_NUMBER  == nType) );
+    m_xDateTimeBox->set_visible( (CUSTOM_TYPE_DATE == nType) || (CUSTOM_TYPE_DATETIME  == nType) );
+    m_xDateField->set_visible( (CUSTOM_TYPE_DATE == nType) || (CUSTOM_TYPE_DATETIME  == nType) );
+    m_xTimeField->set_visible( CUSTOM_TYPE_DATETIME  == nType );
+    m_xDurationBox->set_visible( CUSTOM_TYPE_DURATION == nType );
+    m_xDurationField->set_visible( CUSTOM_TYPE_DURATION == nType );
+    m_xYesNoButton->set_visible( CUSTOM_TYPE_BOOLEAN == nType );
+}
+
+IMPL_LINK(CustomPropertyLine, TypeHdl, weld::ComboBox&, rBox, void)
+{
+    DoTypeHdl(rBox);
+}
+
+void CustomPropertiesWindow::Remove(const CustomPropertyLine* pLine)
+{
+    StoreCustomProperties();
+
+    auto pFound = std::find_if( m_aCustomPropertiesLines.begin(), m_aCustomPropertiesLines.end(),
+                    [&] (const std::unique_ptr<CustomPropertyLine>& p) { return p.get() == pLine; });
+    if ( pFound != m_aCustomPropertiesLines.end() )
+    {
+        sal_uInt32 nLineNumber = pFound - m_aCustomPropertiesLines.begin();
+        sal_uInt32 nDataModelIndex = GetCurrentDataModelPosition() + nLineNumber;
+        m_aCustomProperties.erase(m_aCustomProperties.begin() + nDataModelIndex);
+
+        ReloadLinesContent();
+    }
+
+    m_aRemovedHdl.Call(nullptr);
+}
+
+IMPL_LINK_NOARG(CustomPropertyLine, RemoveHdl, weld::Button&, void)
+{
+    m_pParent->Remove(this);
+}
+
+void CustomPropertiesWindow::EditLoseFocus(CustomPropertyLine* pLine)
+{
+    m_pCurrentLine = pLine;
+    m_aEditLoseFocusIdle.Start();
+}
+
+IMPL_LINK_NOARG(CustomPropertyLine, EditLoseFocusHdl, weld::Widget&, void)
+{
+    if (!m_bTypeLostFocus)
+        m_pParent->EditLoseFocus(this);
+    else
+        m_bTypeLostFocus = false;
+}
+
+void CustomPropertiesWindow::BoxLoseFocus(CustomPropertyLine* pLine)
+{
+    m_pCurrentLine = pLine;
+    m_aBoxLoseFocusIdle.Start();
+}
+
+IMPL_LINK_NOARG(CustomPropertyLine, BoxLoseFocusHdl, weld::Widget&, void)
+{
+    m_pParent->BoxLoseFocus(this);
+}
+
+IMPL_LINK_NOARG(CustomPropertiesWindow, EditTimeoutHdl, Timer *, void)
+{
+    ValidateLine( m_pCurrentLine, false );
+}
+
+IMPL_LINK_NOARG(CustomPropertiesWindow, BoxTimeoutHdl, Timer *, void)
+{
+    ValidateLine( m_pCurrentLine, true );
+}
+
+bool CustomPropertiesWindow::IsLineValid( CustomPropertyLine* pLine ) const
+{
+    bool bIsValid = true;
+    pLine->m_bTypeLostFocus = false;
+    auto nType = pLine->m_xTypeBox->get_active_id().toInt32();
+    OUString sValue = pLine->m_xValueEdit->get_text();
+    if ( sValue.isEmpty() )
+        return true;
+
+    sal_uInt32 nIndex = NUMBERFORMAT_ENTRY_NOT_FOUND;
+    if ( CUSTOM_TYPE_NUMBER == nType )
+        // tdf#116214 Scientific format allows to use also standard numbers
+        nIndex = const_cast< SvNumberFormatter& >(
+            m_aNumberFormatter ).GetFormatIndex( NF_SCIENTIFIC_000E00 );
+    else if ( CUSTOM_TYPE_DATE == nType )
+        nIndex = const_cast< SvNumberFormatter& >(
+            m_aNumberFormatter).GetFormatIndex( NF_DATE_SYS_DDMMYYYY );
+
+    if ( nIndex != NUMBERFORMAT_ENTRY_NOT_FOUND )
+    {
+        sal_uInt32 nTemp = nIndex;
+        double fDummy = 0.0;
+        bIsValid = const_cast< SvNumberFormatter& >(
+            m_aNumberFormatter ).IsNumberFormat( sValue, nIndex, fDummy );
+        if ( bIsValid && nTemp != nIndex )
+            // sValue is a number but the format doesn't match the index
+            bIsValid = false;
+    }
+
+    return bIsValid;
+}
+
+void CustomPropertiesWindow::ValidateLine( CustomPropertyLine* pLine, bool bIsFromTypeBox )
+{
+    if (pLine && !IsLineValid(pLine))
+    {
+        if ( bIsFromTypeBox ) // LoseFocus of TypeBox
+            pLine->m_bTypeLostFocus = true;
+        std::unique_ptr<weld::MessageDialog> xMessageBox(Application::CreateMessageDialog(&m_rBody,
+                                                         VclMessageType::Question, VclButtonsType::OkCancel, SfxResId(STR_SFX_QUERY_WRONG_TYPE)));
+        if (xMessageBox->run() == RET_OK)
+            pLine->m_xTypeBox->set_active_id(OUString::number(CUSTOM_TYPE_TEXT));
+        else
+            pLine->m_xValueEdit->grab_focus();
+    }
+}
+
+void CustomPropertiesWindow::SetVisibleLineCount(sal_uInt32 nCount)
+{
+    while (GetExistingLineCount() < nCount)
+    {
+        CreateNewLine();
+    }
+}
+
+void CustomPropertiesWindow::AddLine(const OUString& sName, Any const & rAny)
+{
+    m_aCustomProperties.push_back(std::unique_ptr<CustomProperty>(new CustomProperty(sName, rAny)));
+    ReloadLinesContent();
+}
+
+void CustomPropertiesWindow::CreateNewLine()
+{
+    CustomPropertyLine* pNewLine = new CustomPropertyLine(this, &m_rBody);
+    pNewLine->m_xNameBox->set_accessible_relation_labeled_by(&m_rHeaderAccName);
+    pNewLine->m_xNameBox->set_accessible_name(m_rHeaderAccName.get_label());
+    pNewLine->m_xTypeBox->set_accessible_relation_labeled_by(&m_rHeaderAccType);
+    pNewLine->m_xTypeBox->set_accessible_name(m_rHeaderAccType.get_label());
+    pNewLine->m_xValueEdit->set_accessible_relation_labeled_by(&m_rHeaderAccValue);
+    pNewLine->m_xValueEdit->set_accessible_name(m_rHeaderAccValue.get_label());
+
+    m_aCustomPropertiesLines.emplace_back( pNewLine );
+
+    pNewLine->DoTypeHdl(*pNewLine->m_xTypeBox);
+    pNewLine->m_xNameBox->grab_focus();
+}
+
+bool CustomPropertiesWindow::AreAllLinesValid() const
+{
+    bool bRet = true;
+    for ( std::unique_ptr<CustomPropertyLine> const & pLine : m_aCustomPropertiesLines )
+    {
+        if ( !IsLineValid( pLine.get() ) )
+        {
+            bRet = false;
+            break;
+        }
+    }
+
+    return bRet;
+}
+
+void CustomPropertiesWindow::ClearAllLines()
+{
+    for (auto& pLine : m_aCustomPropertiesLines)
+    {
+        pLine->Clear();
+    }
+    m_pCurrentLine = nullptr;
+    m_aCustomProperties.clear();
+    m_nScrollPos = 0;
+}
+
+void CustomPropertiesWindow::DoScroll( sal_Int32 nNewPos )
+{
+    StoreCustomProperties();
+    m_nScrollPos += nNewPos;
+    ReloadLinesContent();
+}
+
+Sequence< beans::PropertyValue > CustomPropertiesWindow::GetCustomProperties()
+{
+    StoreCustomProperties();
+
+    Sequence< beans::PropertyValue > aPropertiesSeq(GetTotalLineCount());
+
+    for (sal_uInt32 i = 0; i < GetTotalLineCount(); ++i)
+    {
+        aPropertiesSeq[i].Name = m_aCustomProperties[i]->m_sName;
+        aPropertiesSeq[i].Value = m_aCustomProperties[i]->m_aValue;
+    }
+
+    return aPropertiesSeq;
+}
+
+CustomPropertiesTimeField::CustomPropertiesTimeField(std::unique_ptr<weld::TimeSpinButton> xTimeField)
+    : m_xTimeField(std::move(xTimeField))
+    , m_isUTC(false)
+{
+}
+
+CustomPropertiesTimeField::~CustomPropertiesTimeField()
+{
+}
+
+CustomPropertiesDateField::CustomPropertiesDateField(SvtCalendarBox* pDateField)
+    : m_xDateField(pDateField)
+{
+    DateTime aDateTime(DateTime::SYSTEM);
+    m_xDateField->set_date(aDateTime);
+}
+
+void CustomPropertiesDateField::set_visible(bool bVisible)
+{
+    m_xDateField->set_visible(bVisible);
+}
+
+Date CustomPropertiesDateField::get_date() const
+{
+    return m_xDateField->get_date();
+}
+
+void CustomPropertiesDateField::set_date(const Date& rDate)
+{
+    m_xDateField->set_date(rDate);
+}
+
+CustomPropertiesDateField::~CustomPropertiesDateField()
+{
+}
+
+void CustomPropertiesWindow::StoreCustomProperties()
+{
+    sal_uInt32 nDataModelPos = GetCurrentDataModelPosition();
+
+    for (sal_uInt32 i = 0; nDataModelPos + i < GetTotalLineCount() && i < GetExistingLineCount(); i++)
+    {
+        CustomPropertyLine* pLine = m_aCustomPropertiesLines[i].get();
+
+        OUString sPropertyName = pLine->m_xNameBox->get_active_text();
+        if (!sPropertyName.isEmpty())
+        {
+            m_aCustomProperties[nDataModelPos + i]->m_sName = sPropertyName;
+            auto nType = pLine->m_xTypeBox->get_active_id().toInt32();
+            if (CUSTOM_TYPE_NUMBER == nType)
+            {
+                double nValue = 0;
+                sal_uInt32 nIndex = m_aNumberFormatter.GetFormatIndex(NF_NUMBER_SYSTEM);
+                bool bIsNum = m_aNumberFormatter.
+                    IsNumberFormat(pLine->m_xValueEdit->get_text(), nIndex, nValue);
+                if (bIsNum)
+                    m_aCustomProperties[nDataModelPos + i]->m_aValue <<= nValue;
+            }
+            else if (CUSTOM_TYPE_BOOLEAN == nType)
+            {
+                bool bValue = pLine->m_xYesNoButton->IsYesChecked();
+                m_aCustomProperties[nDataModelPos + i]->m_aValue <<= bValue;
+            }
+            else if (CUSTOM_TYPE_DATETIME == nType)
+            {
+                Date aTmpDate = pLine->m_xDateField->get_date();
+                tools::Time aTmpTime = pLine->m_xTimeField->get_value();
+                util::DateTime const aDateTime(aTmpTime.GetNanoSec(),
+                    aTmpTime.GetSec(), aTmpTime.GetMin(), aTmpTime.GetHour(),
+                    aTmpDate.GetDay(), aTmpDate.GetMonth(), aTmpDate.GetYear(),
+                    pLine->m_xTimeField->m_isUTC);
+                if (pLine->m_xDateField->m_TZ)
+                {
+                    m_aCustomProperties[nDataModelPos + i]->m_aValue <<= util::DateTimeWithTimezone(
+                        aDateTime, *pLine->m_xDateField->m_TZ);
+                }
+                else
+                {
+                    m_aCustomProperties[nDataModelPos + i]->m_aValue <<= aDateTime;
+                }
+            }
+            else if (CUSTOM_TYPE_DATE == nType)
+            {
+                Date aTmpDate = pLine->m_xDateField->get_date();
+                util::Date const aDate(aTmpDate.GetDay(), aTmpDate.GetMonth(),
+                    aTmpDate.GetYear());
+                if (pLine->m_xDateField->m_TZ)
+                {
+                    m_aCustomProperties[nDataModelPos + i]->m_aValue <<= util::DateWithTimezone(
+                        aDate, *pLine->m_xDateField->m_TZ);
+                }
+                else
+                {
+                    m_aCustomProperties[nDataModelPos + i]->m_aValue <<= aDate;
+                }
+            }
+            else if (CUSTOM_TYPE_DURATION == nType)
+            {
+                m_aCustomProperties[nDataModelPos + i]->m_aValue <<= pLine->m_xDurationField->GetDuration();
+            }
+            else
+            {
+                OUString sValue(pLine->m_xValueEdit->get_text());
+                m_aCustomProperties[nDataModelPos + i]->m_aValue <<= sValue;
+            }
+        }
+    }
+}
+
+void CustomPropertiesWindow::SetCustomProperties(std::vector< std::unique_ptr<CustomProperty> >&& rProperties)
+{
+    m_aCustomProperties = std::move(rProperties);
+    ReloadLinesContent();
+}
+
+void CustomPropertiesWindow::ReloadLinesContent()
+{
+    double nTmpValue = 0;
+    bool bTmpValue = false;
+    OUString sTmpValue;
+    util::DateTime aTmpDateTime;
+    util::Date aTmpDate;
+    util::DateTimeWithTimezone aTmpDateTimeTZ;
+    util::DateWithTimezone aTmpDateTZ;
+    util::Duration aTmpDuration;
+    SvtSysLocale aSysLocale;
+    const LocaleDataWrapper& rLocaleWrapper = aSysLocale.GetLocaleData();
+    sal_IntPtr nType = CUSTOM_TYPE_UNKNOWN;
+    OUString sValue;
+
+    sal_uInt32 nDataModelPos = GetCurrentDataModelPosition();
+    sal_uInt32 i = 0;
+
+    for (; nDataModelPos + i < GetTotalLineCount() && i < GetExistingLineCount(); i++)
+    {
+        const OUString& rName = m_aCustomProperties[nDataModelPos + i]->m_sName;
+        const css::uno::Any& rAny = m_aCustomProperties[nDataModelPos + i]->m_aValue;
+
+        CustomPropertyLine* pLine = m_aCustomPropertiesLines[i].get();
+        pLine->Clear();
+
+        pLine->m_xNameBox->set_entry_text(rName);
+        pLine->m_xLine->show();
+
+        if (!rAny.hasValue())
+        {
+            pLine->m_xValueEdit->set_text(OUString());
+        }
+        else if (rAny >>= nTmpValue)
+        {
+            sal_uInt32 nIndex = m_aNumberFormatter.GetFormatIndex(NF_NUMBER_SYSTEM);
+            m_aNumberFormatter.GetInputLineString(nTmpValue, nIndex, sValue);
+            pLine->m_xValueEdit->set_text(sValue);
+            nType = CUSTOM_TYPE_NUMBER;
+        }
+        else if (rAny >>= bTmpValue)
+        {
+            sValue = (bTmpValue ? rLocaleWrapper.getTrueWord() : rLocaleWrapper.getFalseWord());
+            nType = CUSTOM_TYPE_BOOLEAN;
+        }
+        else if (rAny >>= sTmpValue)
+        {
+            pLine->m_xValueEdit->set_text(sTmpValue);
+            nType = CUSTOM_TYPE_TEXT;
+        }
+        else if (rAny >>= aTmpDate)
+        {
+            pLine->m_xDateField->set_date(Date(aTmpDate));
+            nType = CUSTOM_TYPE_DATE;
+        }
+        else if (rAny >>= aTmpDateTime)
+        {
+            pLine->m_xDateField->set_date(Date(aTmpDateTime));
+            pLine->m_xTimeField->set_value(tools::Time(aTmpDateTime));
+            pLine->m_xTimeField->m_isUTC = aTmpDateTime.IsUTC;
+            nType = CUSTOM_TYPE_DATETIME;
+        }
+        else if (rAny >>= aTmpDateTZ)
+        {
+            pLine->m_xDateField->set_date(Date(aTmpDateTZ.DateInTZ.Day,
+                aTmpDateTZ.DateInTZ.Month, aTmpDateTZ.DateInTZ.Year));
+            pLine->m_xDateField->m_TZ = aTmpDateTZ.Timezone;
+            nType = CUSTOM_TYPE_DATE;
+        }
+        else if (rAny >>= aTmpDateTimeTZ)
+        {
+            util::DateTime const& rDT(aTmpDateTimeTZ.DateTimeInTZ);
+            pLine->m_xDateField->set_date(Date(rDT));
+            pLine->m_xTimeField->set_value(tools::Time(rDT));
+            pLine->m_xTimeField->m_isUTC = rDT.IsUTC;
+            pLine->m_xDateField->m_TZ = aTmpDateTimeTZ.Timezone;
+            nType = CUSTOM_TYPE_DATETIME;
+        }
+        else if (rAny >>= aTmpDuration)
+        {
+            nType = CUSTOM_TYPE_DURATION;
+            pLine->m_xDurationField->SetDuration(aTmpDuration);
+        }
+
+        if (nType != CUSTOM_TYPE_UNKNOWN)
+        {
+            if (CUSTOM_TYPE_BOOLEAN == nType)
+            {
+                if (bTmpValue)
+                    pLine->m_xYesNoButton->CheckYes();
+                else
+                    pLine->m_xYesNoButton->CheckNo();
+            }
+            pLine->m_xTypeBox->set_active_id(OUString::number(nType));
+        }
+
+        pLine->DoTypeHdl(*pLine->m_xTypeBox);
+    }
+
+    while (nDataModelPos + i >= GetTotalLineCount() && i < GetExistingLineCount())
+    {
+        CustomPropertyLine* pLine = m_aCustomPropertiesLines[i].get();
+        pLine->Hide();
+        i++;
+    }
+}
+
+CustomPropertiesControl::CustomPropertiesControl()
+    : m_nThumbPos(0)
+{
+}
+
+void CustomPropertiesControl::Init(weld::Builder& rBuilder)
+{
+    m_xBox = rBuilder.weld_widget("box");
+    m_xBody = rBuilder.weld_container("properties");
+
+    m_xName = rBuilder.weld_label("name");
+    m_xType = rBuilder.weld_label("type");
+    m_xValue = rBuilder.weld_label("value");
+    m_xVertScroll = rBuilder.weld_scrolled_window("scroll");
+    m_xVertScroll->set_user_managed_scrolling();
+    m_xPropertiesWin.reset(new CustomPropertiesWindow(*m_xBody, *m_xName, *m_xType, *m_xValue));
+
+    m_xBox->set_stack_background();
+    m_xVertScroll->show();
+
+    std::unique_ptr<CustomPropertyLine> xNewLine(new CustomPropertyLine(m_xPropertiesWin.get(), m_xBody.get()));
+    Size aLineSize(xNewLine->m_xLine->get_preferred_size());
+    m_xPropertiesWin->SetLineHeight(aLineSize.Height() + 6);
+    m_xBody->set_size_request(aLineSize.Width() + 6, -1);
+    auto nHeight = aLineSize.Height() * 8;
+    m_xVertScroll->set_size_request(-1, nHeight + 6);
+
+    m_xPropertiesWin->SetHeight(nHeight);
+    m_xVertScroll->connect_size_allocate(LINK(this, CustomPropertiesControl, ResizeHdl));
+
+    m_xName->set_size_request(xNewLine->m_xNameBox->get_preferred_size().Width(), -1);
+    m_xType->set_size_request(xNewLine->m_xTypeBox->get_preferred_size().Width(), -1);
+    m_xValue->set_size_request(xNewLine->m_xValueEdit->get_preferred_size().Width(), -1);
+
+    m_xBody->move(xNewLine->m_xLine.get(), nullptr);
+    xNewLine.reset();
+
+    m_xPropertiesWin->SetRemovedHdl( LINK( this, CustomPropertiesControl, RemovedHdl ) );
+
+    m_xVertScroll->vadjustment_set_lower(0);
+    m_xVertScroll->vadjustment_set_upper(0);
+    m_xVertScroll->vadjustment_set_page_size(0xFFFF);
+
+    Link<weld::ScrolledWindow&,void> aScrollLink = LINK( this, CustomPropertiesControl, ScrollHdl );
+    m_xVertScroll->connect_vadjustment_changed(aScrollLink);
+
+    ResizeHdl(Size(-1, nHeight));
+}
+
+IMPL_LINK(CustomPropertiesControl, ResizeHdl, const Size&, rSize, void)
+{
+    int nHeight = rSize.Height() - 6;
+    if (nHeight == m_xPropertiesWin->GetHeight())
+        return;
+    m_xPropertiesWin->SetHeight(nHeight);
+    sal_Int32 nScrollOffset = m_xPropertiesWin->GetLineHeight();
+    sal_Int32 nVisibleEntries = nHeight / nScrollOffset;
+    m_xPropertiesWin->SetVisibleLineCount( nVisibleEntries );
+    m_xVertScroll->vadjustment_set_page_increment( nVisibleEntries - 1 );
+    m_xVertScroll->vadjustment_set_page_size( nVisibleEntries );
+    m_xPropertiesWin->ReloadLinesContent();
+}
+
+CustomPropertiesControl::~CustomPropertiesControl()
+{
+}
+
+IMPL_LINK( CustomPropertiesControl, ScrollHdl, weld::ScrolledWindow&, rScrollBar, void )
+{
+    sal_Int32 nOffset = m_xPropertiesWin->GetLineHeight();
+    int nThumbPos = rScrollBar.vadjustment_get_value();
+    nOffset *= ( m_nThumbPos - nThumbPos );
+    m_nThumbPos = nThumbPos;
+    m_xPropertiesWin->DoScroll( nOffset );
+}
+
+IMPL_LINK_NOARG(CustomPropertiesControl, RemovedHdl, void*, void)
+{
+    auto nLineCount = m_xPropertiesWin->GetTotalLineCount();
+    m_xVertScroll->vadjustment_set_upper(nLineCount + 1);
+    if (m_xPropertiesWin->GetTotalLineCount() > m_xPropertiesWin->GetExistingLineCount())
+    {
+        m_xVertScroll->vadjustment_set_value(nLineCount - 1);
+        ScrollHdl(*m_xVertScroll);
+    }
+}
+
+void CustomPropertiesControl::AddLine( Any const & rAny )
+{
+    m_xPropertiesWin->AddLine( OUString(), rAny );
+    auto nLineCount = m_xPropertiesWin->GetTotalLineCount();
+    m_xVertScroll->vadjustment_set_upper(nLineCount + 1);
+    if (m_xPropertiesWin->GetHeight() < nLineCount * m_xPropertiesWin->GetLineHeight())
+    {
+        m_xVertScroll->vadjustment_set_value(nLineCount + 1);
+        ScrollHdl(*m_xVertScroll);
+    }
+}
+
+void CustomPropertiesControl::SetCustomProperties(std::vector< std::unique_ptr<CustomProperty> >&& rProperties)
+{
+    m_xPropertiesWin->SetCustomProperties(std::move(rProperties));
+    auto nLineCount = m_xPropertiesWin->GetTotalLineCount();
+    m_xVertScroll->vadjustment_set_upper(nLineCount + 1);
+}
+
+// class SfxCustomPropertiesPage -----------------------------------------
+SfxCustomPropertiesPage::SfxCustomPropertiesPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rItemSet )
+    : SfxTabPage(pPage, pController, "sfx/ui/custominfopage.ui", "CustomInfoPage", &rItemSet)
+    , m_xPropertiesCtrl(new CustomPropertiesControl)
+    , m_xAdd(m_xBuilder->weld_button("add"))
+{
+    m_xPropertiesCtrl->Init(*m_xBuilder);
+    m_xAdd->connect_clicked(LINK(this, SfxCustomPropertiesPage, AddHdl));
+}
+
+SfxCustomPropertiesPage::~SfxCustomPropertiesPage()
+{
+    m_xPropertiesCtrl.reset();
+}
+
+IMPL_LINK_NOARG(SfxCustomPropertiesPage, AddHdl, weld::Button&, void)
+{
+    // tdf#115853: reload current lines before adding a brand new one
+    // indeed the info are deleted by ClearCustomProperties
+    // each time SfxDocumentInfoItem destructor is called
+    SfxDocumentInfoItem pInfo;
+    const Sequence< beans::PropertyValue > aPropertySeq = m_xPropertiesCtrl->GetCustomProperties();
+    for ( const auto& rProperty : aPropertySeq )
+    {
+        if ( !rProperty.Name.isEmpty() )
+        {
+            pInfo.AddCustomProperty( rProperty.Name, rProperty.Value );
+        }
+    }
+
+    Any aAny;
+    m_xPropertiesCtrl->AddLine(aAny);
+}
+
+bool SfxCustomPropertiesPage::FillItemSet( SfxItemSet* rSet )
+{
+    const SfxPoolItem* pItem = nullptr;
+    SfxDocumentInfoItem* pInfo = nullptr;
+    bool bMustDelete = false;
+
+    if (const SfxItemSet* pItemSet = GetDialogExampleSet())
+    {
+        if (SfxItemState::SET != pItemSet->GetItemState(SID_DOCINFO, true, &pItem))
+            pInfo = const_cast<SfxDocumentInfoItem*>(&rSet->Get( SID_DOCINFO ));
+        else
+        {
+            bMustDelete = true;
+            pInfo = new SfxDocumentInfoItem( *static_cast<const SfxDocumentInfoItem*>(pItem) );
+        }
+    }
+
+    if ( pInfo )
+    {
+        // If it's a CMIS document, we can't save custom properties
+        if ( pInfo->isCmisDocument( ) )
+        {
+            if ( bMustDelete )
+                delete pInfo;
+            return false;
+        }
+
+        pInfo->ClearCustomProperties();
+        const Sequence< beans::PropertyValue > aPropertySeq = m_xPropertiesCtrl->GetCustomProperties();
+        for ( const auto& rProperty : aPropertySeq )
+        {
+            if ( !rProperty.Name.isEmpty() )
+                pInfo->AddCustomProperty( rProperty.Name, rProperty.Value );
+        }
+    }
+
+    if (pInfo)
+    {
+        rSet->Put(*pInfo);
+        if ( bMustDelete )
+            delete pInfo;
+    }
+    return true;
+}
+
+void SfxCustomPropertiesPage::Reset( const SfxItemSet* rItemSet )
+{
+    m_xPropertiesCtrl->ClearAllLines();
+    const SfxDocumentInfoItem& rInfoItem = rItemSet->Get(SID_DOCINFO);
+    std::vector< std::unique_ptr<CustomProperty> > aCustomProps = rInfoItem.GetCustomProperties();
+    m_xPropertiesCtrl->SetCustomProperties(std::move(aCustomProps));
+}
+
+DeactivateRC SfxCustomPropertiesPage::DeactivatePage( SfxItemSet* /*pSet*/ )
+{
+    DeactivateRC nRet = DeactivateRC::LeavePage;
+    if ( !m_xPropertiesCtrl->AreAllLinesValid() )
+        nRet = DeactivateRC::KeepPage;
+    return nRet;
+}
+
+std::unique_ptr<SfxTabPage> SfxCustomPropertiesPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rItemSet)
+{
+    return std::make_unique<SfxCustomPropertiesPage>(pPage, pController, *rItemSet);
+}
+
+CmisValue::CmisValue(weld::Widget* pParent, const OUString& aStr)
+    : m_xBuilder(Application::CreateBuilder(pParent, "sfx/ui/cmisline.ui"))
+    , m_xFrame(m_xBuilder->weld_frame("CmisFrame"))
+    , m_xValueEdit(m_xBuilder->weld_entry("value"))
+{
+    m_xValueEdit->show();
+    m_xValueEdit->set_text(aStr);
+}
+
+CmisDateTime::CmisDateTime(weld::Widget* pParent, const util::DateTime& aDateTime)
+    : m_xBuilder(Application::CreateBuilder(pParent, "sfx/ui/cmisline.ui"))
+    , m_xFrame(m_xBuilder->weld_frame("CmisFrame"))
+    , m_xDateField(new SvtCalendarBox(m_xBuilder->weld_menu_button("date")))
+    , m_xTimeField(m_xBuilder->weld_time_spin_button("time", TimeFieldFormat::F_SEC))
+{
+    m_xDateField->show();
+    m_xTimeField->show();
+    m_xDateField->set_date(Date(aDateTime));
+    m_xTimeField->set_value(tools::Time(aDateTime));
+}
+
+CmisYesNo::CmisYesNo(weld::Widget* pParent, bool bValue)
+    : m_xBuilder(Application::CreateBuilder(pParent, "sfx/ui/cmisline.ui"))
+    , m_xFrame(m_xBuilder->weld_frame("CmisFrame"))
+    , m_xYesButton(m_xBuilder->weld_radio_button("yes"))
+    , m_xNoButton(m_xBuilder->weld_radio_button("no"))
+{
+    m_xYesButton->show();
+    m_xNoButton->show();
+    if (bValue)
+        m_xYesButton->set_active(true);
+    else
+        m_xNoButton->set_active(true);
+}
+
+// struct CmisPropertyLine ---------------------------------------------
+CmisPropertyLine::CmisPropertyLine(weld::Widget* pParent)
+    : m_xBuilder(Application::CreateBuilder(pParent, "sfx/ui/cmisline.ui"))
+    , m_sType(CMIS_TYPE_STRING)
+    , m_bUpdatable(false)
+    , m_bRequired(false)
+    , m_bMultiValued(false)
+    , m_bOpenChoice(false)
+    , m_xFrame(m_xBuilder->weld_frame("CmisFrame"))
+    , m_xName(m_xBuilder->weld_label("name"))
+    , m_xType(m_xBuilder->weld_label("type"))
+{
+    m_xFrame->set_sensitive(true);
+}
+
+CmisPropertyLine::~CmisPropertyLine( )
+{
+}
+
+// class CmisPropertiesWindow -----------------------------------------
+
+CmisPropertiesWindow::CmisPropertiesWindow(std::unique_ptr<weld::Container> xParent)
+    : m_xBox(std::move(xParent))
+    , m_aNumberFormatter(::comphelper::getProcessComponentContext(),
+                         Application::GetSettings().GetLanguageTag().getLanguageType())
+{
+}
+
+CmisPropertiesWindow::~CmisPropertiesWindow()
+{
+}
+
+void CmisPropertiesWindow::ClearAllLines()
+{
+    m_aCmisPropertiesLines.clear();
+}
+
+void CmisPropertiesWindow::AddLine( const OUString& sId, const OUString& sName,
+                                    const OUString& sType, const bool bUpdatable,
+                                    const bool bRequired, const bool bMultiValued,
+                                    const bool bOpenChoice, Any& /*aChoices*/, Any const & rAny )
+{
+    std::unique_ptr<CmisPropertyLine> pNewLine(new CmisPropertyLine(m_xBox.get()));
+
+    pNewLine->m_sId = sId;
+    pNewLine->m_sType = sType;
+    pNewLine->m_bUpdatable = bUpdatable;
+    pNewLine->m_bRequired = bRequired;
+    pNewLine->m_bMultiValued = bMultiValued;
+    pNewLine->m_bOpenChoice = bOpenChoice;
+
+    if ( sType == CMIS_TYPE_INTEGER )
+    {
+        Sequence< sal_Int64 > seqValue;
+        rAny >>= seqValue;
+        sal_uInt32 nIndex = m_aNumberFormatter.GetFormatIndex( NF_NUMBER_SYSTEM );
+        for ( const auto& rValue : std::as_const(seqValue) )
+        {
+            OUString sValue;
+            m_aNumberFormatter.GetInputLineString( rValue, nIndex, sValue );
+            std::unique_ptr<CmisValue> pValue(new CmisValue(m_xBox.get(), sValue));
+            pValue->m_xValueEdit->set_editable(bUpdatable);
+            pNewLine->m_aValues.push_back( std::move(pValue) );
+        }
+    }
+    else if ( sType == CMIS_TYPE_DECIMAL )
+    {
+        Sequence< double > seqValue;
+        rAny >>= seqValue;
+        sal_uInt32 nIndex = m_aNumberFormatter.GetFormatIndex( NF_NUMBER_SYSTEM );
+        for ( const auto& rValue : std::as_const(seqValue) )
+        {
+            OUString sValue;
+            m_aNumberFormatter.GetInputLineString( rValue, nIndex, sValue );
+            std::unique_ptr<CmisValue> pValue(new CmisValue(m_xBox.get(), sValue));
+            pValue->m_xValueEdit->set_editable(bUpdatable);
+            pNewLine->m_aValues.push_back( std::move(pValue) );
+        }
+
+    }
+    else if ( sType == CMIS_TYPE_BOOL )
+    {
+        Sequence<sal_Bool> seqValue;
+        rAny >>= seqValue;
+        for ( const auto& rValue : std::as_const(seqValue) )
+        {
+            std::unique_ptr<CmisYesNo> pYesNo(new CmisYesNo(m_xBox.get(), rValue));
+            pYesNo->m_xYesButton->set_sensitive( bUpdatable );
+            pYesNo->m_xNoButton->set_sensitive( bUpdatable );
+            pNewLine->m_aYesNos.push_back( std::move(pYesNo) );
+        }
+    }
+    else if ( sType == CMIS_TYPE_STRING )
+    {
+        Sequence< OUString > seqValue;
+        rAny >>= seqValue;
+        for ( const auto& rValue : std::as_const(seqValue) )
+        {
+            std::unique_ptr<CmisValue> pValue(new CmisValue(m_xBox.get(), rValue));
+            pValue->m_xValueEdit->set_editable(bUpdatable);
+            pNewLine->m_aValues.push_back( std::move(pValue) );
+        }
+    }
+    else if ( sType == CMIS_TYPE_DATETIME )
+    {
+        Sequence< util::DateTime > seqValue;
+        rAny >>= seqValue;
+        for ( const auto& rValue : std::as_const(seqValue) )
+        {
+            std::unique_ptr<CmisDateTime> pDateTime(new CmisDateTime(m_xBox.get(), rValue));
+            pDateTime->m_xDateField->set_sensitive(bUpdatable);
+            pDateTime->m_xTimeField->set_sensitive(bUpdatable);
+            pNewLine->m_aDateTimes.push_back( std::move(pDateTime) );
+        }
+    }
+    pNewLine->m_xName->set_label( sName );
+    pNewLine->m_xName->show();
+    pNewLine->m_xType->set_label( sType );
+    pNewLine->m_xType->show();
+
+    m_aCmisPropertiesLines.push_back( std::move(pNewLine) );
+}
+
+Sequence< document::CmisProperty > CmisPropertiesWindow::GetCmisProperties() const
+{
+    Sequence< document::CmisProperty > aPropertiesSeq( m_aCmisPropertiesLines.size() );
+    sal_Int32 i = 0;
+    for ( auto& rxLine : m_aCmisPropertiesLines )
+    {
+        CmisPropertyLine* pLine = rxLine.get();
+
+        aPropertiesSeq[i].Id = pLine->m_sId;
+        aPropertiesSeq[i].Type = pLine->m_sType;
+        aPropertiesSeq[i].Updatable = pLine->m_bUpdatable;
+        aPropertiesSeq[i].Required = pLine->m_bRequired;
+        aPropertiesSeq[i].OpenChoice = pLine->m_bOpenChoice;
+        aPropertiesSeq[i].MultiValued = pLine->m_bMultiValued;
+
+        OUString sPropertyName = pLine->m_xName->get_label();
+        if ( !sPropertyName.isEmpty() )
+        {
+            aPropertiesSeq[i].Name = sPropertyName;
+            OUString sType = pLine->m_xType->get_label();
+            if ( CMIS_TYPE_DECIMAL == sType )
+            {
+                sal_uInt32 nIndex = const_cast< SvNumberFormatter& >(
+                    m_aNumberFormatter ).GetFormatIndex( NF_NUMBER_SYSTEM );
+                Sequence< double > seqValue( pLine->m_aValues.size( ) );
+                sal_Int32 k = 0;
+                for ( const auto& rxValue : pLine->m_aValues )
+                {
+                    double dValue = 0.0;
+                    OUString sValue( rxValue->m_xValueEdit->get_text() );
+                    bool bIsNum = const_cast< SvNumberFormatter& >( m_aNumberFormatter ).
+                    IsNumberFormat( sValue, nIndex, dValue );
+                    if ( bIsNum )
+                        seqValue[k] = dValue;
+                    ++k;
+                }
+                aPropertiesSeq[i].Value <<= seqValue;
+            }
+            else if ( CMIS_TYPE_INTEGER == sType )
+            {
+                sal_uInt32 nIndex = const_cast< SvNumberFormatter& >(
+                    m_aNumberFormatter ).GetFormatIndex( NF_NUMBER_SYSTEM );
+                Sequence< sal_Int64 > seqValue( pLine->m_aValues.size( ) );
+                sal_Int32 k = 0;
+                for ( const auto& rxValue : pLine->m_aValues )
+                {
+                    double dValue = 0;
+                    OUString sValue( rxValue->m_xValueEdit->get_text() );
+                    bool bIsNum = const_cast< SvNumberFormatter& >( m_aNumberFormatter ).
+                    IsNumberFormat( sValue, nIndex, dValue );
+                    if ( bIsNum )
+                        seqValue[k] = static_cast<sal_Int64>(dValue);
+                    ++k;
+                }
+                aPropertiesSeq[i].Value <<= seqValue;
+            }
+            else if ( CMIS_TYPE_BOOL == sType )
+            {
+                Sequence<sal_Bool> seqValue( pLine->m_aYesNos.size( ) );
+                sal_Int32 k = 0;
+                for ( const auto& rxYesNo : pLine->m_aYesNos )
+                {
+                    bool bValue = rxYesNo->m_xYesButton->get_active();
+                    seqValue[k] = bValue;
+                    ++k;
+                }
+                aPropertiesSeq[i].Value <<= seqValue;
+
+            }
+            else if ( CMIS_TYPE_DATETIME == sType )
+            {
+                Sequence< util::DateTime > seqValue( pLine->m_aDateTimes.size( ) );
+                sal_Int32 k = 0;
+                for ( const auto& rxDateTime : pLine->m_aDateTimes )
+                {
+                    Date aTmpDate = rxDateTime->m_xDateField->get_date();
+                    tools::Time aTmpTime = rxDateTime->m_xTimeField->get_value();
+                    util::DateTime aDateTime( aTmpTime.GetNanoSec(), aTmpTime.GetSec(),
+                                              aTmpTime.GetMin(), aTmpTime.GetHour(),
+                                              aTmpDate.GetDay(), aTmpDate.GetMonth(),
+                                              aTmpDate.GetYear(), true );
+                    seqValue[k] = aDateTime;
+                    ++k;
+                }
+                aPropertiesSeq[i].Value <<= seqValue;
+            }
+            else
+            {
+                Sequence< OUString > seqValue( pLine->m_aValues.size( ) );
+                sal_Int32 k = 0;
+                for ( const auto& rxValue : pLine->m_aValues )
+                {
+                    OUString sValue( rxValue->m_xValueEdit->get_text() );
+                    seqValue[k] = sValue;
+                    ++k;
+                }
+                aPropertiesSeq[i].Value <<= seqValue;
+            }
+        }
+        ++i;
+    }
+
+    return aPropertiesSeq;
+}
+
+CmisPropertiesControl::CmisPropertiesControl(weld::Builder& rBuilder)
+    : m_aPropertiesWin(rBuilder.weld_container("CmisWindow"))
+    , m_xScrolledWindow(rBuilder.weld_scrolled_window("CmisScroll"))
+{
+    // set height to something small and force it to take the size
+    // dictated by the other pages
+    m_xScrolledWindow->set_size_request(-1, 42);
+}
+
+void CmisPropertiesControl::ClearAllLines()
+{
+   m_aPropertiesWin.ClearAllLines();
+}
+
+void CmisPropertiesControl::AddLine( const OUString& sId, const OUString& sName,
+                                     const OUString& sType, const bool bUpdatable,
+                                     const bool bRequired, const bool bMultiValued,
+                                     const bool bOpenChoice, Any& aChoices, Any const & rAny
+                                     )
+{
+    m_aPropertiesWin.AddLine( sId, sName, sType, bUpdatable, bRequired, bMultiValued,
+                               bOpenChoice, aChoices, rAny );
+}
+
+// class SfxCmisPropertiesPage -----------------------------------------
+SfxCmisPropertiesPage::SfxCmisPropertiesPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rItemSet)
+    : SfxTabPage(pPage, pController, "sfx/ui/cmisinfopage.ui", "CmisInfoPage", &rItemSet)
+    , m_xPropertiesCtrl(new CmisPropertiesControl(*m_xBuilder))
+{
+}
+
+SfxCmisPropertiesPage::~SfxCmisPropertiesPage()
+{
+    m_xPropertiesCtrl.reset();
+}
+
+bool SfxCmisPropertiesPage::FillItemSet( SfxItemSet* rSet )
+{
+    const SfxPoolItem* pItem = nullptr;
+    SfxDocumentInfoItem* pInfo = nullptr;
+    bool bMustDelete = false;
+
+    if (const SfxItemSet* pItemSet = GetDialogExampleSet())
+    {
+        if (SfxItemState::SET != pItemSet->GetItemState(SID_DOCINFO, true, &pItem))
+            pInfo = const_cast<SfxDocumentInfoItem*>(&rSet->Get( SID_DOCINFO ));
+        else
+        {
+            bMustDelete = true;
+            pInfo = new SfxDocumentInfoItem( *static_cast<const SfxDocumentInfoItem*>(pItem) );
+        }
+    }
+
+    sal_Int32 modifiedNum = 0;
+    if ( pInfo )
+    {
+        Sequence< document::CmisProperty > aOldProps = pInfo->GetCmisProperties( );
+        Sequence< document::CmisProperty > aNewProps = m_xPropertiesCtrl->GetCmisProperties();
+
+        std::vector< document::CmisProperty > changedProps;
+        for ( sal_Int32 i = 0; i< aNewProps.getLength( ); ++i )
+        {
+            if ( aOldProps[i].Updatable && !aNewProps[i].Id.isEmpty( ) )
+            {
+                if ( aOldProps[i].Type == CMIS_TYPE_DATETIME )
+                {
+                    Sequence< util::DateTime > oldValue;
+                    aOldProps[i].Value >>= oldValue;
+                    // We only edit hours and minutes
+                    // don't compare NanoSeconds and Seconds
+                    for ( auto& rDateTime : oldValue )
+                    {
+                        rDateTime.NanoSeconds = 0;
+                        rDateTime.Seconds = 0;
+                    }
+                    Sequence< util::DateTime > newValue;
+                    aNewProps[i].Value >>= newValue;
+                    if ( oldValue != newValue )
+                    {
+                        modifiedNum++;
+                        changedProps.push_back( aNewProps[i] );
+                    }
+                }
+                else if ( aOldProps[i].Value != aNewProps[i].Value )
+                {
+                    modifiedNum++;
+                    changedProps.push_back( aNewProps[i] );
+                }
+            }
+        }
+        Sequence< document::CmisProperty> aModifiedProps( comphelper::containerToSequence(changedProps) );
+        pInfo->SetCmisProperties( aModifiedProps );
+        rSet->Put( *pInfo );
+        if ( bMustDelete )
+            delete pInfo;
+    }
+
+    return modifiedNum;
+}
+
+void SfxCmisPropertiesPage::Reset( const SfxItemSet* rItemSet )
+{
+    m_xPropertiesCtrl->ClearAllLines();
+    const SfxDocumentInfoItem& rInfoItem = rItemSet->Get(SID_DOCINFO);
+    uno::Sequence< document::CmisProperty > aCmisProps = rInfoItem.GetCmisProperties();
+    for ( auto& rCmisProp : aCmisProps )
+    {
+        m_xPropertiesCtrl->AddLine(rCmisProp.Id,
+                                   rCmisProp.Name,
+                                   rCmisProp.Type,
+                                   rCmisProp.Updatable,
+                                   rCmisProp.Required,
+                                   rCmisProp.MultiValued,
+                                   rCmisProp.OpenChoice,
+                                   rCmisProp.Choices,
+                                   rCmisProp.Value);
+    }
+}
+
+DeactivateRC SfxCmisPropertiesPage::DeactivatePage( SfxItemSet* /*pSet*/ )
+{
+    return DeactivateRC::LeavePage;
+}
+
+std::unique_ptr<SfxTabPage> SfxCmisPropertiesPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rItemSet)
+{
+    return std::make_unique<SfxCmisPropertiesPage>(pPage, pController, *rItemSet);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/dockwin.cxx b/sfx2/source/dialog/dockwin.cxx
new file mode 100644
index 000000000..562585a90
--- /dev/null
+++ b/sfx2/source/dialog/dockwin.cxx
@@ -0,0 +1,1555 @@
+/* -*- 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/eitem.hxx>
+#include <svl/solar.hrc>
+#include <vcl/event.hxx>
+#include <vcl/layout.hxx>
+#include <vcl/settings.hxx>
+
+#include <vcl/svapp.hxx>
+#include <vcl/timer.hxx>
+#include <vcl/idle.hxx>
+#include <o3tl/safeint.hxx>
+#include <osl/diagnose.h>
+#include <rtl/instance.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+#include <tools/debug.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+
+#include <sfx2/dockwin.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/dispatch.hxx>
+#include <workwin.hxx>
+#include <splitwin.hxx>
+#include <sfx2/viewsh.hxx>
+
+#include <com/sun/star/beans/UnknownPropertyException.hpp>
+#include <com/sun/star/lang/XSingleComponentFactory.hpp>
+#include <com/sun/star/awt/XWindow.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+#include <com/sun/star/frame/ModuleManager.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/ui/theWindowStateConfiguration.hpp>
+#include <com/sun/star/ui/theWindowContentFactoryManager.hpp>
+
+#define MAX_TOGGLEAREA_WIDTH        20
+#define MAX_TOGGLEAREA_HEIGHT       20
+
+using namespace ::com::sun::star;
+
+// If you want to change the number you also have to:
+// - Add new slot ids to sfxsids.hrc
+// - Add new slots to frmslots.sdi
+// - Add new slot definitions to sfx.sdi
+static const int NUM_OF_DOCKINGWINDOWS = 10;
+
+namespace {
+
+class SfxTitleDockingWindow : public SfxDockingWindow
+{
+    VclPtr<vcl::Window>   m_pWrappedWindow;
+
+public:
+                        SfxTitleDockingWindow(
+                            SfxBindings* pBindings ,
+                            SfxChildWindow* pChildWin ,
+                            vcl::Window* pParent ,
+                            WinBits nBits);
+    virtual             ~SfxTitleDockingWindow() override;
+    virtual void        dispose() override;
+
+    vcl::Window*        GetWrappedWindow() const { return m_pWrappedWindow; }
+    void                SetWrappedWindow(vcl::Window* const pWindow);
+
+    virtual void        StateChanged( StateChangedType nType ) override;
+    virtual void        Resize() override;
+    virtual void        Resizing( Size& rSize ) override;
+};
+
+    struct WindowState
+    {
+        OUString sTitle;
+    };
+}
+
+static bool lcl_getWindowState( const uno::Reference< container::XNameAccess >& xWindowStateMgr, const OUString& rResourceURL, WindowState& rWindowState )
+{
+    bool bResult = false;
+
+    try
+    {
+        uno::Any a;
+        uno::Sequence< beans::PropertyValue > aWindowState;
+        a = xWindowStateMgr->getByName( rResourceURL );
+        if ( a >>= aWindowState )
+        {
+            for ( const auto& rProp : std::as_const(aWindowState) )
+            {
+                if ( rProp.Name == "UIName" )
+                {
+                    rProp.Value >>= rWindowState.sTitle;
+                }
+            }
+        }
+
+        bResult = true;
+    }
+    catch ( container::NoSuchElementException& )
+    {
+        bResult = false;
+    }
+
+    return bResult;
+}
+
+SfxDockingWrapper::SfxDockingWrapper( vcl::Window* pParentWnd ,
+                                      sal_uInt16 nId ,
+                                      SfxBindings* pBindings ,
+                                      SfxChildWinInfo* pInfo )
+                    : SfxChildWindow( pParentWnd , nId )
+{
+    uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+    const OUString aDockWindowResourceURL( "private:resource/dockingwindow/" );
+
+    VclPtr<SfxTitleDockingWindow> pTitleDockWindow = VclPtr<SfxTitleDockingWindow>::Create( pBindings, this, pParentWnd,
+        WB_STDDOCKWIN | WB_CLIPCHILDREN | WB_SIZEABLE | WB_3DLOOK | WB_ROLLABLE);
+    SetWindow( pTitleDockWindow );
+
+    // Use factory manager to retrieve XWindow factory. That can be used to instantiate
+    // the real window factory.
+    uno::Reference< lang::XSingleComponentFactory > xFactoryMgr = ui::theWindowContentFactoryManager::get(xContext);
+
+    SfxDispatcher* pDispatcher = pBindings->GetDispatcher();
+    uno::Reference< frame::XFrame > xFrame = pDispatcher->GetFrame()->GetFrame().GetFrameInterface();
+    // create a resource URL from the nId provided by the sfx2
+    OUString aResourceURL =  aDockWindowResourceURL + OUString::number(nId);
+    uno::Sequence<uno::Any> aArgs(comphelper::InitAnyPropertySequence(
+    {
+        {"Frame", uno::Any(xFrame)},
+        {"ResourceURL", uno::Any(aResourceURL)},
+    }));
+
+    uno::Reference< awt::XWindow > xWindow;
+    try
+    {
+        xWindow.set(
+            xFactoryMgr->createInstanceWithArgumentsAndContext( aArgs, xContext ),
+            uno::UNO_QUERY );
+
+        static uno::WeakReference< frame::XModuleManager2 >  s_xModuleManager;
+
+        uno::Reference< frame::XModuleManager2 > xModuleManager( s_xModuleManager );
+        if ( !xModuleManager.is() )
+        {
+            xModuleManager = frame::ModuleManager::create(xContext);
+            s_xModuleManager = xModuleManager;
+        }
+
+        static uno::WeakReference< container::XNameAccess > s_xWindowStateConfiguration;
+
+        uno::Reference< container::XNameAccess > xWindowStateConfiguration( s_xWindowStateConfiguration );
+        if ( !xWindowStateConfiguration.is() )
+        {
+            xWindowStateConfiguration = ui::theWindowStateConfiguration::get( xContext );
+            s_xWindowStateConfiguration = xWindowStateConfiguration;
+        }
+
+        OUString sModuleIdentifier = xModuleManager->identify( xFrame );
+
+        uno::Reference< container::XNameAccess > xModuleWindowState(
+                                                    xWindowStateConfiguration->getByName( sModuleIdentifier ),
+                                                    uno::UNO_QUERY );
+        if ( xModuleWindowState.is() )
+        {
+            WindowState aDockWinState;
+            if ( lcl_getWindowState( xModuleWindowState, aResourceURL, aDockWinState ))
+                pTitleDockWindow->SetText( aDockWinState.sTitle );
+        }
+    }
+    catch ( beans::UnknownPropertyException& )
+    {
+    }
+    catch ( uno::RuntimeException& )
+    {
+    }
+    catch ( uno::Exception& )
+    {
+    }
+
+    VclPtr<vcl::Window> pContentWindow = VCLUnoHelper::GetWindow(xWindow);
+    if ( pContentWindow )
+        pContentWindow->SetStyle( pContentWindow->GetStyle() | WB_DIALOGCONTROL | WB_CHILDDLGCTRL );
+    pTitleDockWindow->SetWrappedWindow(pContentWindow);
+
+    GetWindow()->SetOutputSizePixel( Size( 270, 240 ) );
+
+    static_cast<SfxDockingWindow*>( GetWindow() )->Initialize( pInfo );
+    SetHideNotDelete( true );
+}
+
+std::unique_ptr<SfxChildWindow> SfxDockingWrapper::CreateImpl(vcl::Window *pParent, sal_uInt16 nId,
+                                              SfxBindings *pBindings, SfxChildWinInfo* pInfo)
+{
+    return std::make_unique<SfxDockingWrapper>(pParent, nId, pBindings, pInfo);
+}
+
+void SfxDockingWrapper::RegisterChildWindow (bool bVis, SfxModule *pMod, SfxChildWindowFlags nFlags)
+{
+    // pre-register a couple of docking windows
+    for (int i=0; i < NUM_OF_DOCKINGWINDOWS; i++ )
+    {
+        sal_uInt16 nID = sal_uInt16(SID_DOCKWIN_START+i);
+        auto pFact = std::make_unique<SfxChildWinFactory>( SfxDockingWrapper::CreateImpl, nID, 0xffff );
+        pFact->aInfo.nFlags |= nFlags;
+        pFact->aInfo.bVisible = bVis;
+        SfxChildWindow::RegisterChildWindow(pMod, std::move(pFact));
+    }
+}
+
+SfxChildWinInfo  SfxDockingWrapper::GetInfo() const
+{
+    SfxChildWinInfo aInfo = SfxChildWindow::GetInfo();
+    static_cast<SfxDockingWindow*>(GetWindow())->FillInfo( aInfo );
+    return aInfo;
+};
+
+SfxTitleDockingWindow::SfxTitleDockingWindow(SfxBindings* pBind, SfxChildWindow* pChildWin,
+                                             vcl::Window* pParent, WinBits nBits)
+    : SfxDockingWindow(pBind, pChildWin, pParent, nBits)
+    , m_pWrappedWindow(nullptr)
+{
+}
+
+SfxTitleDockingWindow::~SfxTitleDockingWindow()
+{
+    disposeOnce();
+}
+
+void SfxTitleDockingWindow::dispose()
+{
+    m_pWrappedWindow.disposeAndClear();
+    SfxDockingWindow::dispose();
+}
+
+void SfxTitleDockingWindow::SetWrappedWindow( vcl::Window* const pWindow )
+{
+    m_pWrappedWindow = pWindow;
+    if (m_pWrappedWindow)
+    {
+        m_pWrappedWindow->SetParent(this);
+        m_pWrappedWindow->SetSizePixel( GetOutputSizePixel() );
+        m_pWrappedWindow->Show();
+    }
+}
+
+void SfxTitleDockingWindow::StateChanged( StateChangedType nType )
+{
+    if ( nType == StateChangedType::InitShow )
+    {
+        vcl::Window* pWindow = GetWrappedWindow();
+        if ( pWindow )
+        {
+            pWindow->SetSizePixel( GetOutputSizePixel() );
+            pWindow->Show();
+        }
+    }
+
+    SfxDockingWindow::StateChanged(nType);
+}
+
+void SfxTitleDockingWindow::Resize()
+{
+    SfxDockingWindow::Resize();
+    if (m_pWrappedWindow)
+        m_pWrappedWindow->SetSizePixel( GetOutputSizePixel() );
+}
+
+void SfxTitleDockingWindow::Resizing( Size &rSize )
+{
+    SfxDockingWindow::Resizing( rSize );
+    if (m_pWrappedWindow)
+        m_pWrappedWindow->SetSizePixel( GetOutputSizePixel() );
+}
+
+namespace
+{
+    struct ChildrenRegisteredMap : public rtl::Static< bool, ChildrenRegisteredMap > {};
+}
+
+static bool lcl_checkDockingWindowID( sal_uInt16 nID )
+{
+    return !(nID < SID_DOCKWIN_START || nID >= o3tl::make_unsigned(SID_DOCKWIN_START+NUM_OF_DOCKINGWINDOWS));
+}
+
+static SfxWorkWindow* lcl_getWorkWindowFromXFrame( const uno::Reference< frame::XFrame >& rFrame )
+{
+    // We need to find the corresponding SfxFrame of our XFrame
+    SfxFrame* pFrame  = SfxFrame::GetFirst();
+    SfxFrame* pXFrame = nullptr;
+    while ( pFrame )
+    {
+        uno::Reference< frame::XFrame > xViewShellFrame( pFrame->GetFrameInterface() );
+        if ( xViewShellFrame == rFrame )
+        {
+            pXFrame = pFrame;
+            break;
+        }
+        else
+            pFrame = SfxFrame::GetNext( *pFrame );
+    }
+
+    // If we have a SfxFrame we can retrieve the work window (Sfx layout manager for docking windows)
+    if ( pXFrame )
+        return pXFrame->GetWorkWindow_Impl();
+    else
+        return nullptr;
+}
+
+/** Factory function used by the framework layout manager to "create" a docking window with a special name.
+    The string rDockingWindowName MUST BE a valid ID! The ID is pre-defined by a certain slot range located
+    in sfxsids.hrc (currently SID_DOCKWIN_START = 9800).
+*/
+void SfxDockingWindowFactory( const uno::Reference< frame::XFrame >& rFrame, const OUString& rDockingWindowName )
+{
+    SolarMutexGuard aGuard;
+    sal_uInt16 nID = sal_uInt16(rDockingWindowName.toInt32());
+
+    // Check the range of the provided ID otherwise nothing will happen
+    if ( !lcl_checkDockingWindowID( nID ))
+        return;
+
+    SfxWorkWindow* pWorkWindow = lcl_getWorkWindowFromXFrame( rFrame );
+    if ( pWorkWindow )
+    {
+        SfxChildWindow* pChildWindow = pWorkWindow->GetChildWindow_Impl(nID);
+        if ( !pChildWindow )
+        {
+            // Register window at the workwindow child window list
+            pWorkWindow->SetChildWindow_Impl( nID, true, false );
+        }
+    }
+}
+
+/** Function used by the framework layout manager to determine the visibility state of a docking window with
+    a special name. The string rDockingWindowName MUST BE a valid ID! The ID is pre-defined by a certain slot
+    range located in sfxsids.hrc (currently SID_DOCKWIN_START = 9800).
+*/
+bool IsDockingWindowVisible( const uno::Reference< frame::XFrame >& rFrame, const OUString& rDockingWindowName )
+{
+    SolarMutexGuard aGuard;
+
+    sal_uInt16 nID = sal_uInt16(rDockingWindowName.toInt32());
+
+    // Check the range of the provided ID otherwise nothing will happen
+    if ( lcl_checkDockingWindowID( nID ))
+    {
+        SfxWorkWindow* pWorkWindow = lcl_getWorkWindowFromXFrame( rFrame );
+        if ( pWorkWindow )
+        {
+            SfxChildWindow* pChildWindow = pWorkWindow->GetChildWindow_Impl(nID);
+            if ( pChildWindow )
+                return true;
+        }
+    }
+
+    return false;
+}
+
+class SfxDockingWindow_Impl
+{
+friend class SfxDockingWindow;
+
+    SfxChildAlignment   eLastAlignment;
+    SfxChildAlignment   eDockAlignment;
+    bool                bConstructed;
+    Size                aMinSize;
+    VclPtr<SfxSplitWindow>  pSplitWin;
+    Idle                aMoveIdle;
+
+    // The following members are only valid in the time from startDocking to
+    // EndDocking:
+    Size                aSplitSize;
+    long                nHorizontalSize;
+    long                nVerticalSize;
+    sal_uInt16          nLine;
+    sal_uInt16          nPos;
+    sal_uInt16          nDockLine;
+    sal_uInt16          nDockPos;
+    bool                bNewLine;
+    bool                bDockingPrevented;
+    OString             aWinState;
+
+    explicit            SfxDockingWindow_Impl(SfxDockingWindow *pBase);
+    SfxChildAlignment   GetLastAlignment() const
+                        { return eLastAlignment; }
+    void                SetLastAlignment(SfxChildAlignment eAlign)
+                        { eLastAlignment = eAlign; }
+    SfxChildAlignment   GetDockAlignment() const
+                        { return eDockAlignment; }
+    void                SetDockAlignment(SfxChildAlignment eAlign)
+                        { eDockAlignment = eAlign; }
+};
+
+SfxDockingWindow_Impl::SfxDockingWindow_Impl(SfxDockingWindow* pBase)
+    :eLastAlignment(SfxChildAlignment::NOALIGNMENT)
+    ,eDockAlignment(SfxChildAlignment::NOALIGNMENT)
+    ,bConstructed(false)
+    ,pSplitWin(nullptr)
+    ,nHorizontalSize(0)
+    ,nVerticalSize(0)
+    ,nLine(0)
+    ,nPos(0)
+    ,nDockLine(0)
+    ,nDockPos(0)
+    ,bNewLine(false)
+    ,bDockingPrevented(false)
+{
+    aMoveIdle.SetPriority(TaskPriority::RESIZE);
+    aMoveIdle.SetInvokeHandler(LINK(pBase,SfxDockingWindow,TimerHdl));
+    aMoveIdle.SetDebugName( "sfx::SfxDockingWindow_Impl aMoveIdle" );
+}
+
+/*  [Description]
+
+    This virtual method of the class FloatingWindow keeps track of changes in
+    FloatingSize. If this method is overridden by a derived class,
+    then the FloatingWindow: Resize() must also be called.
+*/
+void SfxDockingWindow::Resize()
+{
+    DockingWindow::Resize();
+    Invalidate();
+    if ( !pImpl || !pImpl->bConstructed || !pMgr )
+        return;
+
+    if ( IsFloatingMode() )
+    {
+        // start timer for saving window status information
+        pImpl->aMoveIdle.Start();
+    }
+    else
+    {
+        Size aSize( GetSizePixel() );
+        switch ( pImpl->GetDockAlignment() )
+        {
+            case SfxChildAlignment::LEFT:
+            case SfxChildAlignment::FIRSTLEFT:
+            case SfxChildAlignment::LASTLEFT:
+            case SfxChildAlignment::RIGHT:
+            case SfxChildAlignment::FIRSTRIGHT:
+            case SfxChildAlignment::LASTRIGHT:
+                pImpl->nHorizontalSize = aSize.Width();
+                pImpl->aSplitSize = aSize;
+                break;
+            case SfxChildAlignment::TOP:
+            case SfxChildAlignment::LOWESTTOP:
+            case SfxChildAlignment::HIGHESTTOP:
+            case SfxChildAlignment::BOTTOM:
+            case SfxChildAlignment::HIGHESTBOTTOM:
+            case SfxChildAlignment::LOWESTBOTTOM:
+                pImpl->nVerticalSize = aSize.Height();
+                pImpl->aSplitSize = aSize;
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+/*  [Description]
+
+    This virtual method of the class DockingWindow makes it possible to
+    intervene in the switching of the floating mode.
+    If this method is overridden by a derived class,
+    then the SfxDockingWindow::PrepareToggleFloatingMode() must be called
+    afterwards, if not FALSE is returned.
+*/
+bool SfxDockingWindow::PrepareToggleFloatingMode()
+{
+    if (!pImpl || !pImpl->bConstructed)
+        return true;
+
+    if ( (Application::IsInModalMode() && IsFloatingMode()) || !pMgr )
+        return false;
+
+    if ( pImpl->bDockingPrevented )
+        return false;
+
+    if (!IsFloatingMode())
+    {
+        // Test, if FloatingMode is permitted.
+        if ( CheckAlignment(GetAlignment(),SfxChildAlignment::NOALIGNMENT) != SfxChildAlignment::NOALIGNMENT )
+            return false;
+
+        if ( pImpl->pSplitWin )
+        {
+            // The DockingWindow is inside a SplitWindow and will be teared of.
+            pImpl->pSplitWin->RemoveWindow(this/*, sal_False*/);
+            pImpl->pSplitWin = nullptr;
+        }
+    }
+    else if ( pMgr )
+    {
+        pImpl->aWinState = GetFloatingWindow()->GetWindowState();
+
+        // Test if it is allowed to dock,
+        if (CheckAlignment(GetAlignment(),pImpl->GetLastAlignment()) == SfxChildAlignment::NOALIGNMENT)
+            return false;
+
+        // Test, if the Workwindow allows for docking at the moment.
+        SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+        if ( !pWorkWin->IsDockingAllowed() || !pWorkWin->IsInternalDockingAllowed() )
+            return false;
+    }
+
+    return true;
+}
+
+/*  [Description]
+
+    This virtual method of the DockingWindow class sets the internal data of
+    the SfxDockingWindow and ensures the correct alignment on the parent window.
+    Through PrepareToggleFloatMode and Initialize it is ensured that
+    pImpl-> GetLastAlignment() always delivers an allowed alignment. If this
+    method is overridden by a derived class, then first the
+    SfxDockingWindow::ToggleFloatingMode() must be called.
+*/
+void SfxDockingWindow::ToggleFloatingMode()
+{
+    if ( !pImpl || !pImpl->bConstructed || !pMgr )
+        return;                                 // No Handler call
+
+    // Remember old alignment and then switch.
+    // SV has already switched, but the alignment SfxDockingWindow is still
+    // the old one. What I was before?
+    SfxChildAlignment eLastAlign = GetAlignment();
+
+    SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+
+    if (IsFloatingMode())
+    {
+        SetAlignment(SfxChildAlignment::NOALIGNMENT);
+        if ( !pImpl->aWinState.isEmpty() )
+            GetFloatingWindow()->SetWindowState( pImpl->aWinState );
+        else
+            GetFloatingWindow()->SetOutputSizePixel( GetFloatingSize() );
+    }
+    else
+    {
+        if (pImpl->GetDockAlignment() == eLastAlign)
+        {
+            // If ToggleFloatingMode was called, but the DockAlignment still
+            // is unchanged, then this means that it must have been a toggling
+            // through DClick, so use last alignment
+            SetAlignment (pImpl->GetLastAlignment());
+        }
+        else
+        {
+
+            // Toggling was triggered by dragging
+            pImpl->nLine = pImpl->nDockLine;
+            pImpl->nPos = pImpl->nDockPos;
+            SetAlignment (pImpl->GetDockAlignment());
+        }
+
+        // The DockingWindow is now in a SplitWindow
+        pImpl->pSplitWin = pWorkWin->GetSplitWindow_Impl(GetAlignment());
+
+        // The LastAlignment is still the last docked
+        SfxSplitWindow *pSplit = pWorkWin->GetSplitWindow_Impl(pImpl->GetLastAlignment());
+
+        DBG_ASSERT( pSplit, "LastAlignment is not correct!" );
+        if ( pSplit && pSplit != pImpl->pSplitWin )
+            pSplit->ReleaseWindow_Impl(this);
+        if ( pImpl->GetDockAlignment() == eLastAlign )
+            pImpl->pSplitWin->InsertWindow( this, pImpl->aSplitSize );
+        else
+            pImpl->pSplitWin->InsertWindow( this, pImpl->aSplitSize, pImpl->nLine, pImpl->nPos, pImpl->bNewLine );
+        if ( !pImpl->pSplitWin->IsFadeIn() )
+            pImpl->pSplitWin->FadeIn();
+    }
+
+    // Keep the old alignment for the next toggle; set it only now due to the
+    // unregister SplitWindow!
+    pImpl->SetLastAlignment(eLastAlign);
+
+    // Reset DockAlignment, if EndDocking is still called
+    pImpl->SetDockAlignment(GetAlignment());
+
+    // Dock or undock SfxChildWindow correctly.
+    pWorkWin->ConfigChild_Impl( SfxChildIdentifier::SPLITWINDOW, SfxDockingConfig::TOGGLEFLOATMODE, pMgr->GetType() );
+}
+
+/*  [Description]
+
+    This virtual method of the DockingWindow class takes the inner and outer
+    docking rectangle from the parent window. If this method is overridden by
+    a derived class, then SfxDockingWindow:StartDocking() has to be called at
+    the end.
+*/
+void SfxDockingWindow::StartDocking()
+{
+    if ( !pImpl || !pImpl->bConstructed || !pMgr )
+        return;
+    SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+    pWorkWin->ConfigChild_Impl( SfxChildIdentifier::SPLITWINDOW, SfxDockingConfig::SETDOCKINGRECTS, pMgr->GetType() );
+    pImpl->SetDockAlignment(GetAlignment());
+
+    if ( pImpl->pSplitWin )
+    {
+        // Get the current docking data
+        pImpl->pSplitWin->GetWindowPos(this, pImpl->nLine, pImpl->nPos);
+        pImpl->nDockLine = pImpl->nLine;
+        pImpl->nDockPos = pImpl->nPos;
+        pImpl->bNewLine = false;
+    }
+}
+
+/*  [Description]
+
+    This virtual method of the DockingWindow class calculates the current
+    tracking rectangle. For this purpose the method CalcAlignment(RPOs, rRect)
+    is used, the behavior can be influenced by the derived classes (see below).
+    This method should if possible not be overwritten.
+*/
+bool SfxDockingWindow::Docking( const Point& rPos, tools::Rectangle& rRect )
+{
+    if ( Application::IsInModalMode() )
+        return true;
+
+    if ( !pImpl || !pImpl->bConstructed || !pMgr )
+    {
+        rRect.SetSize( Size() );
+        return IsFloatingMode();
+    }
+
+    SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+    if ( pImpl->bDockingPrevented || !pWorkWin->IsInternalDockingAllowed() )
+        return false;
+
+    bool bFloatMode = false;
+
+    if ( GetOuterRect().IsInside( rPos ) )
+    {
+        // Mouse within OuterRect: calculate Alignment and Rectangle
+        SfxChildAlignment eAlign = CalcAlignment(rPos, rRect);
+        if (eAlign == SfxChildAlignment::NOALIGNMENT)
+            bFloatMode = true;
+        pImpl->SetDockAlignment(eAlign);
+    }
+    else
+    {
+        // Mouse is not within OuterRect: must be FloatingWindow
+        // Is this allowed?
+        if (CheckAlignment(pImpl->GetDockAlignment(),SfxChildAlignment::NOALIGNMENT) != SfxChildAlignment::NOALIGNMENT)
+            return false;
+        bFloatMode = true;
+        if ( SfxChildAlignment::NOALIGNMENT != pImpl->GetDockAlignment() )
+        {
+            // Due to a bug the rRect may only be changed when the
+            // alignment is changed!
+            pImpl->SetDockAlignment(SfxChildAlignment::NOALIGNMENT);
+            rRect.SetSize(CalcDockingSize(SfxChildAlignment::NOALIGNMENT));
+        }
+    }
+
+    return bFloatMode;
+}
+
+/** Virtual method of the DockingWindow class ensures the correct alignment on
+    the parent window. If this method is overridden by a derived class, then
+    SfxDockingWindow::EndDocking() must be called first.
+*/
+void SfxDockingWindow::EndDocking( const tools::Rectangle& rRect, bool bFloatMode )
+{
+    if ( !pImpl || !pImpl->bConstructed || IsDockingCanceled() || !pMgr )
+        return;
+
+    SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+
+    // If the alignment changes and the window is in a docked state in a
+    // SplitWindow, then it must be re-registered. If it is docked again,
+    // PrepareToggleFloatingMode() and ToggleFloatingMode() perform the
+    // re-registered
+    bool bReArrange = !bFloatMode;
+
+    if ( bReArrange )
+    {
+        if ( GetAlignment() != pImpl->GetDockAlignment() )
+        {
+            // before Show() is called must the reassignment have been made,
+            // therefore the base class can not be called
+            if ( IsFloatingMode() )
+                Show( false, ShowFlags::NoFocusChange );
+
+            // Set the size for toggling.
+            pImpl->aSplitSize = rRect.GetSize();
+            if ( IsFloatingMode() )
+            {
+                SetFloatingMode( bFloatMode );
+                if ( IsFloatingMode() )
+                    Show( true, ShowFlags::NoFocusChange );
+            }
+            else
+            {
+                pImpl->pSplitWin->RemoveWindow(this,false);
+                pImpl->nLine = pImpl->nDockLine;
+                pImpl->nPos = pImpl->nDockPos;
+                pImpl->pSplitWin->ReleaseWindow_Impl(this);
+                pImpl->pSplitWin = pWorkWin->GetSplitWindow_Impl(pImpl->GetDockAlignment());
+                pImpl->pSplitWin->InsertWindow( this, pImpl->aSplitSize, pImpl->nDockLine, pImpl->nDockPos, pImpl->bNewLine );
+                if ( !pImpl->pSplitWin->IsFadeIn() )
+                    pImpl->pSplitWin->FadeIn();
+            }
+        }
+        else if ( pImpl->nLine != pImpl->nDockLine || pImpl->nPos != pImpl->nDockPos || pImpl->bNewLine )
+        {
+            // Moved within Splitwindows
+            if ( pImpl->nLine != pImpl->nDockLine )
+                pImpl->aSplitSize = rRect.GetSize();
+            pImpl->pSplitWin->MoveWindow( this, pImpl->aSplitSize, pImpl->nDockLine, pImpl->nDockPos, pImpl->bNewLine );
+        }
+    }
+    else
+    {
+        DockingWindow::EndDocking(rRect, bFloatMode);
+    }
+
+    SetAlignment( IsFloatingMode() ? SfxChildAlignment::NOALIGNMENT : pImpl->GetDockAlignment() );
+}
+
+/*  [Description]
+
+    Virtual method of the DockingWindow class. Here, the interactive resize in
+    FloatingMode can be influenced, for example by only allowing for discrete
+    values for width and / or height. The base implementation prevents that the
+    output size is smaller than one set with SetMinOutputSizePixel().
+*/
+void SfxDockingWindow::Resizing( Size& /*rSize*/ )
+{
+
+}
+
+/*  [Description]
+
+    Constructor for the SfxDockingWindow class. A SfxChildWindow will be
+    required because the docking is implemented in Sfx through SfxChildWindows.
+*/
+SfxDockingWindow::SfxDockingWindow( SfxBindings *pBindinx, SfxChildWindow *pCW,
+    vcl::Window* pParent, WinBits nWinBits) :
+    DockingWindow (pParent, nWinBits),
+    pBindings(pBindinx),
+    pMgr(pCW)
+{
+    pImpl.reset(new SfxDockingWindow_Impl(this));
+}
+
+/** Constructor for the SfxDockingWindow class. A SfxChildWindow will be
+    required because the docking is implemented in Sfx through SfxChildWindows.
+*/
+SfxDockingWindow::SfxDockingWindow( SfxBindings *pBindinx, SfxChildWindow *pCW,
+    vcl::Window* pParent, const OString& rID, const OUString& rUIXMLDescription)
+    : DockingWindow(pParent, "DockingWindow", "sfx/ui/dockingwindow.ui")
+    , pBindings(pBindinx)
+    , pMgr(pCW)
+{
+    m_xVclContentArea = VclPtr<VclVBox>::Create(this);
+    m_xVclContentArea->Show();
+    m_xBuilder.reset(Application::CreateInterimBuilder(m_xVclContentArea, rUIXMLDescription));
+    m_xContainer = m_xBuilder->weld_container(rID);
+
+    pImpl.reset(new SfxDockingWindow_Impl(this));
+}
+
+/** Initialization of the SfxDockingDialog class via a SfxChildWinInfo.
+    The initialization is done only in a 2nd step after the constructor, this
+    constructor should be called from the derived class or from the
+    SfxChildWindows.
+*/
+void SfxDockingWindow::Initialize(SfxChildWinInfo *pInfo)
+{
+    if ( !pMgr )
+    {
+        pImpl->SetDockAlignment( SfxChildAlignment::NOALIGNMENT );
+        pImpl->bConstructed = true;
+        return;
+    }
+
+    if (pInfo && (pInfo->nFlags & SfxChildWindowFlags::FORCEDOCK))
+        pImpl->bDockingPrevented = true;
+
+    pImpl->aSplitSize = GetOutputSizePixel();
+    if ( !GetFloatingSize().Width() )
+    {
+        Size aMinSize( GetMinOutputSizePixel() );
+        SetFloatingSize( pImpl->aSplitSize );
+        if ( pImpl->aSplitSize.Width() < aMinSize.Width() )
+            pImpl->aSplitSize.setWidth( aMinSize.Width() );
+        if ( pImpl->aSplitSize.Height() < aMinSize.Height() )
+            pImpl->aSplitSize.setHeight( aMinSize.Height() );
+    }
+
+    bool bVertHorzRead( false );
+    if (pInfo && !pInfo->aExtraString.isEmpty())
+    {
+        // get information about alignment, split size and position in SplitWindow
+        OUString aStr;
+        sal_Int32 nPos = pInfo->aExtraString.indexOf("AL:");
+        if ( nPos != -1 )
+        {
+            // alignment information
+            sal_Int32 n1 = pInfo->aExtraString.indexOf('(', nPos);
+            if ( n1 != -1 )
+            {
+                sal_Int32 n2 = pInfo->aExtraString.indexOf(')', n1);
+                if ( n2 != -1 )
+                {
+                    // extract alignment information from extrastring
+                    aStr = pInfo->aExtraString.copy(nPos, n2 - nPos + 1);
+                    pInfo->aExtraString = pInfo->aExtraString.replaceAt(nPos, n2 - nPos + 1, "");
+                    aStr = aStr.replaceAt(nPos, n1-nPos+1, "");
+                }
+            }
+        }
+
+        if ( !aStr.isEmpty() )
+        {
+            // accept window state only if alignment is also set
+            pImpl->aWinState = pInfo->aWinState;
+
+            // check for valid alignment
+            SfxChildAlignment eLocalAlignment = static_cast<SfxChildAlignment>(static_cast<sal_uInt16>(aStr.toInt32()));
+            bool bIgnoreFloatConfig = (eLocalAlignment == SfxChildAlignment::NOALIGNMENT &&
+                                       !StyleSettings::GetDockingFloatsSupported());
+            if (pImpl->bDockingPrevented || bIgnoreFloatConfig)
+                // docking prevented, ignore old configuration and take alignment from default
+                aStr.clear();
+            else
+                SetAlignment( eLocalAlignment );
+
+            SfxChildAlignment eAlign = CheckAlignment(GetAlignment(),GetAlignment());
+            if ( eAlign != GetAlignment() )
+            {
+                OSL_FAIL("Invalid Alignment!");
+                SetAlignment( eAlign );
+                aStr.clear();
+            }
+
+            // get last alignment (for toggeling)
+            nPos = aStr.indexOf(',');
+            if ( nPos != -1 )
+            {
+                aStr = aStr.copy(nPos+1);
+                pImpl->SetLastAlignment( static_cast<SfxChildAlignment>(static_cast<sal_uInt16>(aStr.toInt32())) );
+            }
+
+            nPos = aStr.indexOf(',');
+            if ( nPos != -1 )
+            {
+                // get split size and position in SplitWindow
+                Point aPos;
+                aStr = aStr.copy(nPos+1);
+                if ( GetPosSizeFromString( aStr, aPos, pImpl->aSplitSize ) )
+                {
+                    pImpl->nLine = pImpl->nDockLine = static_cast<sal_uInt16>(aPos.X());
+                    pImpl->nPos  = pImpl->nDockPos  = static_cast<sal_uInt16>(aPos.Y());
+                    pImpl->nVerticalSize = pImpl->aSplitSize.Height();
+                    pImpl->nHorizontalSize = pImpl->aSplitSize.Width();
+                    if ( GetSplitSizeFromString( aStr, pImpl->aSplitSize ))
+                        bVertHorzRead = true;
+                }
+            }
+        }
+        else {
+            OSL_FAIL( "Information is missing!" );
+        }
+    }
+
+    if ( !bVertHorzRead )
+    {
+        pImpl->nVerticalSize = pImpl->aSplitSize.Height();
+        pImpl->nHorizontalSize = pImpl->aSplitSize.Width();
+    }
+
+    SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+    if ( GetAlignment() != SfxChildAlignment::NOALIGNMENT )
+    {
+        // check if SfxWorkWindow is able to allow docking at its border
+        if (
+            !pWorkWin->IsDockingAllowed() ||
+            !pWorkWin->IsInternalDockingAllowed() ||
+            ( (GetFloatStyle() & WB_STANDALONE) && Application::IsInModalMode()) )
+        {
+            SetAlignment( SfxChildAlignment::NOALIGNMENT );
+        }
+    }
+
+    // detect floating mode
+    // toggeling mode will not execute code in handlers, because pImpl->bConstructed is not set yet
+    bool bFloatMode = IsFloatingMode();
+    if ( bFloatMode != (GetAlignment() == SfxChildAlignment::NOALIGNMENT) )
+    {
+        bFloatMode = !bFloatMode;
+        SetFloatingMode( bFloatMode );
+        if ( bFloatMode )
+        {
+            if ( !pImpl->aWinState.isEmpty() )
+                GetFloatingWindow()->SetWindowState( pImpl->aWinState );
+            else
+                GetFloatingWindow()->SetOutputSizePixel( GetFloatingSize() );
+        }
+    }
+
+    if ( IsFloatingMode() )
+    {
+        // validate last alignment
+        SfxChildAlignment eLastAlign = pImpl->GetLastAlignment();
+        if ( eLastAlign == SfxChildAlignment::NOALIGNMENT)
+            eLastAlign = CheckAlignment(eLastAlign, SfxChildAlignment::LEFT);
+        if ( eLastAlign == SfxChildAlignment::NOALIGNMENT)
+            eLastAlign = CheckAlignment(eLastAlign, SfxChildAlignment::RIGHT);
+        if ( eLastAlign == SfxChildAlignment::NOALIGNMENT)
+            eLastAlign = CheckAlignment(eLastAlign, SfxChildAlignment::TOP);
+        if ( eLastAlign == SfxChildAlignment::NOALIGNMENT)
+            eLastAlign = CheckAlignment(eLastAlign, SfxChildAlignment::BOTTOM);
+        pImpl->SetLastAlignment(eLastAlign);
+    }
+    else
+    {
+        // docked window must have NOALIGNMENT as last alignment
+        pImpl->SetLastAlignment(SfxChildAlignment::NOALIGNMENT);
+
+        pImpl->pSplitWin = pWorkWin->GetSplitWindow_Impl(GetAlignment());
+        pImpl->pSplitWin->InsertWindow(this, pImpl->aSplitSize);
+    }
+
+    // save alignment
+    pImpl->SetDockAlignment( GetAlignment() );
+}
+
+void SfxDockingWindow::Initialize_Impl()
+{
+    if ( !pMgr )
+    {
+        pImpl->bConstructed = true;
+        return;
+    }
+
+    FloatingWindow* pFloatWin = GetFloatingWindow();
+    bool bSet = false;
+    if ( pFloatWin )
+    {
+        bSet = !pFloatWin->IsDefaultPos();
+    }
+    else
+    {
+        Point aPos = GetFloatingPos();
+        if ( aPos != Point() )
+            bSet = true;
+    }
+
+    if ( !bSet)
+    {
+        SfxViewFrame *pFrame = pBindings->GetDispatcher_Impl()->GetFrame();
+        vcl::Window* pEditWin = pFrame->GetViewShell()->GetWindow();
+        Point aPos = pEditWin->OutputToScreenPixel( pEditWin->GetPosPixel() );
+        aPos = GetParent()->ScreenToOutputPixel( aPos );
+        SetFloatingPos( aPos );
+    }
+
+    if ( pFloatWin )
+    {
+        // initialize floating window
+        if ( pImpl->aWinState.isEmpty() )
+            // window state never set before, get if from defaults
+            pImpl->aWinState = pFloatWin->GetWindowState();
+
+        // trick: use VCL method SetWindowState to adjust position and size
+        pFloatWin->SetWindowState( pImpl->aWinState );
+        Size aSize(pFloatWin->GetSizePixel());
+
+        // remember floating size for calculating alignment and tracking rectangle
+        SetFloatingSize(aSize);
+
+    }
+
+    // allow calling of docking handlers
+    pImpl->bConstructed = true;
+}
+
+/** Fills a SfxChildWinInfo with specific data from SfxDockingWindow,
+    so that it can be written in the INI file. It is assumed that rinfo
+    receives all other possible relevant data in the ChildWindow class.
+    Insertions are marked with size and the ZoomIn flag.
+    If this method is overridden, the base implementation must be called first.
+*/
+void SfxDockingWindow::FillInfo(SfxChildWinInfo& rInfo) const
+{
+    if (!pMgr || !pImpl)
+        return;
+
+    if (GetFloatingWindow() && pImpl->bConstructed)
+        pImpl->aWinState = GetFloatingWindow()->GetWindowState();
+
+    rInfo.aWinState = pImpl->aWinState;
+    rInfo.aExtraString = "AL:(";
+    rInfo.aExtraString += OUString::number(static_cast<sal_uInt16>(GetAlignment()));
+    rInfo.aExtraString += ",";
+    rInfo.aExtraString += OUString::number (static_cast<sal_uInt16>(pImpl->GetLastAlignment()));
+
+    Point aPos(pImpl->nLine, pImpl->nPos);
+    rInfo.aExtraString += ",";
+    rInfo.aExtraString += OUString::number( aPos.X() );
+    rInfo.aExtraString += "/";
+    rInfo.aExtraString += OUString::number( aPos.Y() );
+    rInfo.aExtraString += "/";
+    rInfo.aExtraString += OUString::number( pImpl->nHorizontalSize );
+    rInfo.aExtraString += "/";
+    rInfo.aExtraString += OUString::number( pImpl->nVerticalSize );
+    rInfo.aExtraString += ",";
+    rInfo.aExtraString += OUString::number( pImpl->aSplitSize.Width() );
+    rInfo.aExtraString += ";";
+    rInfo.aExtraString += OUString::number( pImpl->aSplitSize.Height() );
+
+    rInfo.aExtraString += ")";
+}
+
+SfxDockingWindow::~SfxDockingWindow()
+{
+    disposeOnce();
+}
+
+void SfxDockingWindow::dispose()
+{
+    ReleaseChildWindow_Impl();
+    pImpl.reset();
+    m_xContainer.reset();
+    m_xBuilder.reset();
+    m_xVclContentArea.disposeAndClear();
+    DockingWindow::dispose();
+}
+
+void SfxDockingWindow::ReleaseChildWindow_Impl()
+{
+    if ( pMgr && pMgr->GetFrame() == pBindings->GetActiveFrame() )
+        pBindings->SetActiveFrame( nullptr );
+
+    if ( pMgr && pImpl->pSplitWin && pImpl->pSplitWin->IsItemValid( GetType() ) )
+        pImpl->pSplitWin->RemoveWindow(this);
+
+    pMgr=nullptr;
+}
+
+/** This method calculates a resulting alignment for the given mouse position
+    and tracking rectangle. When changing the alignment it can also be that
+    the tracking rectangle is changed, so that an altered rectangle is
+    returned. The user of this class can influence behaviour of this method,
+    and thus the behavior of his DockinWindow class when docking where the
+    called virtual method:
+
+    SfxDockingWindow::CalcDockingSize (SfxChildAlignment eAlign)
+
+    is overridden (see below).
+*/
+SfxChildAlignment SfxDockingWindow::CalcAlignment(const Point& rPos, tools::Rectangle& rRect)
+{
+    // calculate hypothetical sizes for different modes
+    Size aFloatingSize(CalcDockingSize(SfxChildAlignment::NOALIGNMENT));
+
+    // check if docking is permitted
+    SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+    if ( !pWorkWin->IsDockingAllowed() )
+    {
+        rRect.SetSize( aFloatingSize );
+        return pImpl->GetDockAlignment();
+    }
+
+    // calculate borders to shrink inner area before checking for intersection with tracking rectangle
+    long nLRBorder, nTBBorder;
+
+    // take the smaller size of docked and floating mode
+    Size aBorderTmp = pImpl->aSplitSize;
+    if ( GetFloatingSize().Height() < aBorderTmp.Height() )
+        aBorderTmp.setHeight( GetFloatingSize().Height() );
+    if ( GetFloatingSize().Width() < aBorderTmp.Width() )
+        aBorderTmp.setWidth( GetFloatingSize().Width() );
+
+    nLRBorder = aBorderTmp.Width();
+    nTBBorder = aBorderTmp.Height();
+
+    // limit border to predefined constant values
+    if ( nLRBorder > MAX_TOGGLEAREA_WIDTH )
+        nLRBorder = MAX_TOGGLEAREA_WIDTH;
+    if ( nTBBorder > MAX_TOGGLEAREA_WIDTH )
+        nTBBorder = MAX_TOGGLEAREA_WIDTH;
+
+    // shrink area for floating mode if possible
+    tools::Rectangle aInRect = GetInnerRect();
+    if ( aInRect.GetWidth() > nLRBorder )
+        aInRect.AdjustLeft(nLRBorder/2 );
+    if ( aInRect.GetWidth() > nLRBorder )
+        aInRect.AdjustRight( -(nLRBorder/2) );
+    if ( aInRect.GetHeight() > nTBBorder )
+        aInRect.AdjustTop(nTBBorder/2 );
+    if ( aInRect.GetHeight() > nTBBorder )
+        aInRect.AdjustBottom( -(nTBBorder/2) );
+
+    // calculate alignment resulting from docking rectangle
+    bool bBecomesFloating = false;
+    SfxChildAlignment eDockAlign = pImpl->GetDockAlignment();
+    tools::Rectangle aDockingRect( rRect );
+    if ( !IsFloatingMode() )
+    {
+        // don't use tracking rectangle for alignment check, because it will be too large
+        // to get a floating mode as result - switch to floating size
+        // so the calculation only depends on the position of the rectangle, not the current
+        // docking state of the window
+        aDockingRect.SetSize( GetFloatingSize() );
+
+        // in this mode docking is never done by keyboard, so it's OK to use the mouse position
+        aDockingRect.SetPos( pWorkWin->GetWindow()->OutputToScreenPixel( pWorkWin->GetWindow()->GetPointerPosPixel() ) );
+    }
+
+    Point aPos = aDockingRect.TopLeft();
+    tools::Rectangle aIntersect = GetOuterRect().GetIntersection( aDockingRect );
+    if ( aIntersect.IsEmpty() )
+        // docking rectangle completely outside docking area -> floating mode
+        bBecomesFloating = true;
+    else
+    {
+        // create a small test rect around the mouse position and use this one
+        // instead of the passed rRect to not dock too easily or by accident
+        tools::Rectangle aSmallDockingRect;
+        aSmallDockingRect.SetSize( Size( MAX_TOGGLEAREA_WIDTH, MAX_TOGGLEAREA_HEIGHT ) );
+        Point aNewPos(rPos);
+        aNewPos.AdjustX( -(aSmallDockingRect.GetWidth()/2) );
+        aNewPos.AdjustY( -(aSmallDockingRect.GetHeight()/2) );
+        aSmallDockingRect.SetPos(aNewPos);
+        tools::Rectangle aIntersectRect = aInRect.GetIntersection( aSmallDockingRect );
+        if ( aIntersectRect == aSmallDockingRect )
+            // docking rectangle completely inside (shrunk) inner area -> floating mode
+            bBecomesFloating = true;
+    }
+
+    if ( bBecomesFloating )
+    {
+        eDockAlign = CheckAlignment(pImpl->GetDockAlignment(),SfxChildAlignment::NOALIGNMENT);
+    }
+    else
+    {
+        // docking rectangle is in the "sensible area"
+        Point aInPosTL( aPos.X()-aInRect.Left(), aPos.Y()-aInRect.Top() );
+        Point aInPosBR( aPos.X()-aInRect.Left() + aDockingRect.GetWidth(), aPos.Y()-aInRect.Top() + aDockingRect.GetHeight() );
+        Size  aInSize = aInRect.GetSize();
+        bool  bNoChange = false;
+
+        // check if alignment is still unchanged
+        switch ( GetAlignment() )
+        {
+            case SfxChildAlignment::LEFT:
+            case SfxChildAlignment::FIRSTLEFT:
+            case SfxChildAlignment::LASTLEFT:
+                if (aInPosTL.X() <= 0)
+                {
+                    eDockAlign = GetAlignment();
+                    bNoChange = true;
+                }
+                break;
+            case SfxChildAlignment::TOP:
+            case SfxChildAlignment::LOWESTTOP:
+            case SfxChildAlignment::HIGHESTTOP:
+                if ( aInPosTL.Y() <= 0)
+                {
+                    eDockAlign = GetAlignment();
+                    bNoChange = true;
+                }
+                break;
+            case SfxChildAlignment::RIGHT:
+            case SfxChildAlignment::FIRSTRIGHT:
+            case SfxChildAlignment::LASTRIGHT:
+                if ( aInPosBR.X() >= aInSize.Width())
+                {
+                    eDockAlign = GetAlignment();
+                    bNoChange = true;
+                }
+                break;
+            case SfxChildAlignment::BOTTOM:
+            case SfxChildAlignment::LOWESTBOTTOM:
+            case SfxChildAlignment::HIGHESTBOTTOM:
+                if ( aInPosBR.Y() >= aInSize.Height())
+                {
+                    eDockAlign = GetAlignment();
+                    bNoChange = true;
+                }
+                break;
+            default:
+                break;
+        }
+
+        if ( !bNoChange )
+        {
+            // alignment will change, test alignment according to distance of the docking rectangles edges
+            bool bForbidden = true;
+            if ( aInPosTL.X() <= 0)
+            {
+                eDockAlign = CheckAlignment(pImpl->GetDockAlignment(),SfxChildAlignment::LEFT);
+                bForbidden = ( eDockAlign != SfxChildAlignment::LEFT &&
+                               eDockAlign != SfxChildAlignment::FIRSTLEFT &&
+                               eDockAlign != SfxChildAlignment::LASTLEFT );
+            }
+
+            if ( bForbidden && aInPosTL.Y() <= 0)
+            {
+                eDockAlign = CheckAlignment(pImpl->GetDockAlignment(),SfxChildAlignment::TOP);
+                bForbidden = ( eDockAlign != SfxChildAlignment::TOP &&
+                               eDockAlign != SfxChildAlignment::HIGHESTTOP &&
+                               eDockAlign != SfxChildAlignment::LOWESTTOP );
+            }
+
+            if ( bForbidden && aInPosBR.X() >= aInSize.Width())
+            {
+                eDockAlign = CheckAlignment(pImpl->GetDockAlignment(),SfxChildAlignment::RIGHT);
+                bForbidden = ( eDockAlign != SfxChildAlignment::RIGHT &&
+                               eDockAlign != SfxChildAlignment::FIRSTRIGHT &&
+                               eDockAlign != SfxChildAlignment::LASTRIGHT );
+            }
+
+            if ( bForbidden && aInPosBR.Y() >= aInSize.Height())
+            {
+                eDockAlign = CheckAlignment(pImpl->GetDockAlignment(),SfxChildAlignment::BOTTOM);
+                bForbidden = ( eDockAlign != SfxChildAlignment::BOTTOM &&
+                               eDockAlign != SfxChildAlignment::HIGHESTBOTTOM &&
+                               eDockAlign != SfxChildAlignment::LOWESTBOTTOM );
+            }
+
+            // the calculated alignment was rejected by the window -> take floating mode
+            if ( bForbidden )
+                eDockAlign = CheckAlignment(pImpl->GetDockAlignment(),SfxChildAlignment::NOALIGNMENT);
+        }
+    }
+
+    if ( eDockAlign == SfxChildAlignment::NOALIGNMENT )
+    {
+        // In the FloatingMode the tracking rectangle will get the floating
+        // size. Due to a bug the rRect may only be changed when the
+        // alignment is changed!
+        if ( eDockAlign != pImpl->GetDockAlignment() )
+            aDockingRect.SetSize( aFloatingSize );
+    }
+    else
+    {
+        sal_uInt16 nLine, nPos;
+        SfxSplitWindow *pSplitWin = pWorkWin->GetSplitWindow_Impl(eDockAlign);
+        aPos = pSplitWin->ScreenToOutputPixel( aPos );
+        if ( pSplitWin->GetWindowPos( aPos, nLine, nPos ) )
+        {
+            // mouse over splitwindow, get line and position
+            pImpl->nDockLine = nLine;
+            pImpl->nDockPos = nPos;
+            pImpl->bNewLine = false;
+        }
+        else
+        {
+            // mouse touches inner border -> create new line
+            if ( eDockAlign == GetAlignment() && pImpl->pSplitWin &&
+                 pImpl->nLine == pImpl->pSplitWin->GetLineCount()-1 && pImpl->pSplitWin->GetWindowCount(pImpl->nLine) == 1 )
+            {
+                // if this window is the only one in the last line, it can't be docked as new line in the same splitwindow
+                pImpl->nDockLine = pImpl->nLine;
+                pImpl->nDockPos = pImpl->nPos;
+                pImpl->bNewLine = false;
+            }
+            else
+            {
+                // create new line
+                pImpl->nDockLine = pSplitWin->GetLineCount();
+                pImpl->nDockPos = 0;
+                pImpl->bNewLine = true;
+            }
+        }
+
+        bool bChanged = pImpl->nLine != pImpl->nDockLine || pImpl->nPos != pImpl->nDockPos || eDockAlign != GetAlignment();
+        if ( !bChanged && !IsFloatingMode() )
+        {
+            // window only slightly moved, no change of any property
+            rRect.SetSize( pImpl->aSplitSize );
+            rRect.SetPos( aDockingRect.TopLeft() );
+            return eDockAlign;
+        }
+
+        // calculate new size and position
+        Size aSize;
+        Point aPoint = aDockingRect.TopLeft();
+        Size aInnerSize = GetInnerRect().GetSize();
+        if ( eDockAlign == SfxChildAlignment::LEFT || eDockAlign == SfxChildAlignment::RIGHT )
+        {
+            if ( pImpl->bNewLine )
+            {
+                // set height to height of free area
+                aSize.setHeight( aInnerSize.Height() );
+                aSize.setWidth( pImpl->nHorizontalSize );
+                if ( eDockAlign == SfxChildAlignment::LEFT )
+                {
+                    aPoint = aInnerRect.TopLeft();
+                }
+                else
+                {
+                    aPoint = aInnerRect.TopRight();
+                    aPoint.AdjustX( -(aSize.Width()) );
+                }
+            }
+            else
+            {
+                // get width from splitwindow
+                aSize.setWidth( pSplitWin->GetLineSize(nLine) );
+                aSize.setHeight( pImpl->aSplitSize.Height() );
+            }
+        }
+        else
+        {
+            if ( pImpl->bNewLine )
+            {
+                // set width to width of free area
+                aSize.setWidth( aInnerSize.Width() );
+                aSize.setHeight( pImpl->nVerticalSize );
+                if ( eDockAlign == SfxChildAlignment::TOP )
+                {
+                    aPoint = aInnerRect.TopLeft();
+                }
+                else
+                {
+                    aPoint = aInnerRect.BottomLeft();
+                    aPoint.AdjustY( -(aSize.Height()) );
+                }
+            }
+            else
+            {
+                // get height from splitwindow
+                aSize.setHeight( pSplitWin->GetLineSize(nLine) );
+                aSize.setWidth( pImpl->aSplitSize.Width() );
+            }
+        }
+
+        aDockingRect.SetSize( aSize );
+        aDockingRect.SetPos( aPoint );
+    }
+
+    rRect = aDockingRect;
+    return eDockAlign;
+}
+
+/** Virtual method of the SfxDockingWindow class. This method determines how
+    the size of the DockingWindows changes depending on the alignment. The base
+    implementation uses the floating mode, the size of the marked Floating
+    Size. For horizontal alignment, the width will be the width of the outer
+    DockingRectangle, with vertical alignment the height will be the height of
+    the inner DockingRectangle (resulting from the order in which the SFX child
+    windows are displayed). The other size is set to the current floating-size,
+    this could changed by a to intervening derived class. The docking size must
+    be the same for Left/Right and Top/Bottom.
+*/
+Size SfxDockingWindow::CalcDockingSize(SfxChildAlignment eAlign)
+{
+    // Note: if the resizing is also possible in the docked state, then the
+    // Floating-size does also have to be adjusted?
+
+    Size aSize = GetFloatingSize();
+    switch (eAlign)
+    {
+        case SfxChildAlignment::TOP:
+        case SfxChildAlignment::BOTTOM:
+        case SfxChildAlignment::LOWESTTOP:
+        case SfxChildAlignment::HIGHESTTOP:
+        case SfxChildAlignment::LOWESTBOTTOM:
+        case SfxChildAlignment::HIGHESTBOTTOM:
+            aSize.setWidth( aOuterRect.Right() - aOuterRect.Left() );
+            break;
+        case SfxChildAlignment::LEFT:
+        case SfxChildAlignment::RIGHT:
+        case SfxChildAlignment::FIRSTLEFT:
+        case SfxChildAlignment::LASTLEFT:
+        case SfxChildAlignment::FIRSTRIGHT:
+        case SfxChildAlignment::LASTRIGHT:
+            aSize.setHeight( aInnerRect.Bottom() - aInnerRect.Top() );
+            break;
+        case SfxChildAlignment::NOALIGNMENT:
+            break;
+              default:
+                  break;
+    }
+
+    return aSize;
+}
+
+/** Virtual method of the SfxDockingWindow class. Here a derived class can
+    disallow certain alignments. The base implementation does not
+    prohibit alignment.
+*/
+SfxChildAlignment SfxDockingWindow::CheckAlignment(SfxChildAlignment,
+    SfxChildAlignment eAlign)
+{
+    return eAlign;
+}
+
+/** The window is closed when the ChildWindow is destroyed by running the
+    ChildWindow-slots. If this is method is overridden by a derived class
+    method, then the SfxDockingDialogWindow: Close() must be called afterwards
+    if the Close() was not cancelled with "return sal_False".
+*/
+bool SfxDockingWindow::Close()
+{
+    // Execute with Parameters, since Toggle is ignored by some ChildWindows.
+    if ( !pMgr )
+        return true;
+
+    SfxBoolItem aValue( pMgr->GetType(), false);
+    pBindings->GetDispatcher_Impl()->ExecuteList(
+        pMgr->GetType(), SfxCallMode::RECORD | SfxCallMode::ASYNCHRON,
+        { &aValue });
+    return true;
+}
+
+void SfxDockingWindow::Paint(vcl::RenderContext&, const tools::Rectangle& /*rRect*/)
+{
+}
+
+/** With this method, a minimal OutputSize be can set, that is queried in
+    the Resizing()-Handler.
+*/
+void SfxDockingWindow::SetMinOutputSizePixel( const Size& rSize )
+{
+    pImpl->aMinSize = rSize;
+    DockingWindow::SetMinOutputSizePixel( rSize );
+}
+
+/** Set the minimum size which is returned.*/
+const Size& SfxDockingWindow::GetMinOutputSizePixel() const
+{
+    return pImpl->aMinSize;
+}
+
+bool SfxDockingWindow::EventNotify( NotifyEvent& rEvt )
+{
+    if ( !pImpl )
+        return DockingWindow::EventNotify( rEvt );
+
+    if ( rEvt.GetType() == MouseNotifyEvent::GETFOCUS )
+    {
+        if (pMgr != nullptr)
+            pBindings->SetActiveFrame( pMgr->GetFrame() );
+
+        if ( pImpl->pSplitWin )
+            pImpl->pSplitWin->SetActiveWindow_Impl( this );
+        else if (pMgr != nullptr)
+            pMgr->Activate_Impl();
+
+        // In VCL EventNotify goes first to the window itself, also call the
+        // base class, otherwise the parent learns nothing
+        // if ( rEvt.GetWindow() == this )  PB: #i74693# not necessary any longer
+        DockingWindow::EventNotify( rEvt );
+        return true;
+    }
+    else if( rEvt.GetType() == MouseNotifyEvent::KEYINPUT )
+    {
+        // First, allow KeyInput for Dialog functions
+        if (!DockingWindow::EventNotify(rEvt) && SfxViewShell::Current())
+        {
+            // then also for valid global accelerators.
+            return SfxViewShell::Current()->GlobalKeyInput_Impl( *rEvt.GetKeyEvent() );
+        }
+        return true;
+    }
+    else if ( rEvt.GetType() == MouseNotifyEvent::LOSEFOCUS && !HasChildPathFocus() )
+    {
+        pBindings->SetActiveFrame( nullptr );
+    }
+
+    return DockingWindow::EventNotify( rEvt );
+}
+
+
+void SfxDockingWindow::SetItemSize_Impl( const Size& rSize )
+{
+    pImpl->aSplitSize = rSize;
+
+    SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+    pWorkWin->ConfigChild_Impl( SfxChildIdentifier::SPLITWINDOW, SfxDockingConfig::ALIGNDOCKINGWINDOW, pMgr->GetType() );
+}
+
+void SfxDockingWindow::Disappear_Impl()
+{
+    if ( pImpl->pSplitWin && pImpl->pSplitWin->IsItemValid( GetType() ) )
+        pImpl->pSplitWin->RemoveWindow(this);
+}
+
+void SfxDockingWindow::Reappear_Impl()
+{
+    if ( pImpl->pSplitWin && !pImpl->pSplitWin->IsItemValid( GetType() ) )
+    {
+        pImpl->pSplitWin->InsertWindow( this, pImpl->aSplitSize );
+    }
+}
+
+bool SfxDockingWindow::IsAutoHide_Impl() const
+{
+    if ( pImpl->pSplitWin )
+        return !pImpl->pSplitWin->IsFadeIn();
+    else
+        return false;
+}
+
+void SfxDockingWindow::AutoShow_Impl()
+{
+    if ( pImpl->pSplitWin )
+    {
+        pImpl->pSplitWin->FadeIn();
+    }
+}
+
+void SfxDockingWindow::StateChanged( StateChangedType nStateChange )
+{
+    if ( nStateChange == StateChangedType::InitShow )
+        Initialize_Impl();
+
+    DockingWindow::StateChanged( nStateChange );
+}
+
+void SfxDockingWindow::Move()
+{
+    if ( pImpl )
+        pImpl->aMoveIdle.Start();
+}
+
+IMPL_LINK_NOARG(SfxDockingWindow, TimerHdl, Timer *, void)
+{
+    pImpl->aMoveIdle.Stop();
+    if ( IsReallyVisible() && IsFloatingMode() )
+    {
+        if( !GetFloatingWindow()->IsRollUp() )
+            SetFloatingSize( GetOutputSizePixel() );
+        pImpl->aWinState = GetFloatingWindow()->GetWindowState();
+        SfxWorkWindow *pWorkWin = pBindings->GetWorkWindow_Impl();
+        pWorkWin->ConfigChild_Impl( SfxChildIdentifier::SPLITWINDOW, SfxDockingConfig::ALIGNDOCKINGWINDOW, pMgr->GetType() );
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/documentfontsdialog.cxx b/sfx2/source/dialog/documentfontsdialog.cxx
new file mode 100644
index 000000000..8e48a4a12
--- /dev/null
+++ b/sfx2/source/dialog/documentfontsdialog.cxx
@@ -0,0 +1,113 @@
+/* -*- 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 <documentfontsdialog.hxx>
+
+#include <sfx2/objsh.hxx>
+
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+
+using namespace ::com::sun::star;
+
+std::unique_ptr<SfxTabPage> SfxDocumentFontsPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* set)
+{
+    return std::make_unique<SfxDocumentFontsPage>(pPage, pController, *set);
+}
+
+SfxDocumentFontsPage::SfxDocumentFontsPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& set)
+    : SfxTabPage(pPage, pController, "sfx/ui/documentfontspage.ui", "DocumentFontsPage", &set)
+    , embedFontsCheckbox(m_xBuilder->weld_check_button("embedFonts"))
+    , embedUsedFontsCheckbox(m_xBuilder->weld_check_button("embedUsedFonts"))
+    , embedLatinScriptFontsCheckbox(m_xBuilder->weld_check_button("embedLatinScriptFonts"))
+    , embedAsianScriptFontsCheckbox(m_xBuilder->weld_check_button("embedAsianScriptFonts"))
+    , embedComplexScriptFontsCheckbox(m_xBuilder->weld_check_button("embedComplexScriptFonts"))
+{
+}
+
+SfxDocumentFontsPage::~SfxDocumentFontsPage()
+{
+}
+
+void SfxDocumentFontsPage::Reset( const SfxItemSet* )
+{
+    bool bEmbedFonts = false;
+    bool bEmbedUsedFonts = false;
+
+    bool bEmbedLatinScriptFonts  = false;
+    bool bEmbedAsianScriptFonts  = false;
+    bool bEmbedComplexScriptFonts  = false;
+
+    SfxObjectShell* pDocSh = SfxObjectShell::Current();
+    if (pDocSh)
+    {
+        try
+        {
+            uno::Reference< lang::XMultiServiceFactory > xFac( pDocSh->GetModel(), uno::UNO_QUERY_THROW );
+            uno::Reference< beans::XPropertySet > xProps( xFac->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY_THROW );
+
+            xProps->getPropertyValue("EmbedFonts") >>= bEmbedFonts;
+            xProps->getPropertyValue("EmbedOnlyUsedFonts") >>= bEmbedUsedFonts;
+            xProps->getPropertyValue("EmbedLatinScriptFonts") >>= bEmbedLatinScriptFonts;
+            xProps->getPropertyValue("EmbedAsianScriptFonts") >>= bEmbedAsianScriptFonts;
+            xProps->getPropertyValue("EmbedComplexScriptFonts") >>= bEmbedComplexScriptFonts;
+        }
+        catch( uno::Exception& )
+        {
+        }
+    }
+    embedFontsCheckbox->set_active(bEmbedFonts);
+    embedUsedFontsCheckbox->set_active(bEmbedUsedFonts);
+
+    embedLatinScriptFontsCheckbox->set_active(bEmbedLatinScriptFonts);
+    embedAsianScriptFontsCheckbox->set_active(bEmbedAsianScriptFonts);
+    embedComplexScriptFontsCheckbox->set_active(bEmbedComplexScriptFonts);
+}
+
+bool SfxDocumentFontsPage::FillItemSet( SfxItemSet* )
+{
+    bool bEmbedFonts = embedFontsCheckbox->get_active();
+    bool bEmbedUsedFonts = embedUsedFontsCheckbox->get_active();
+
+    bool bEmbedLatinScriptFonts  = embedLatinScriptFontsCheckbox->get_active();
+    bool bEmbedAsianScriptFonts  = embedAsianScriptFontsCheckbox->get_active();
+    bool bEmbedComplexScriptFonts  = embedComplexScriptFontsCheckbox->get_active();
+
+    SfxObjectShell* pDocSh = SfxObjectShell::Current();
+    if ( pDocSh )
+    {
+        try
+        {
+            uno::Reference< lang::XMultiServiceFactory > xFac( pDocSh->GetModel(), uno::UNO_QUERY_THROW );
+            uno::Reference< beans::XPropertySet > xProps( xFac->createInstance("com.sun.star.document.Settings"), uno::UNO_QUERY_THROW );
+            xProps->setPropertyValue("EmbedFonts", uno::makeAny(bEmbedFonts));
+            xProps->setPropertyValue("EmbedOnlyUsedFonts", uno::makeAny(bEmbedUsedFonts));
+            xProps->setPropertyValue("EmbedLatinScriptFonts", uno::makeAny(bEmbedLatinScriptFonts));
+            xProps->setPropertyValue("EmbedAsianScriptFonts", uno::makeAny(bEmbedAsianScriptFonts));
+            xProps->setPropertyValue("EmbedComplexScriptFonts", uno::makeAny(bEmbedComplexScriptFonts));
+        }
+        catch( uno::Exception& )
+        {
+        }
+    }
+    return false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/filedlghelper.cxx b/sfx2/source/dialog/filedlghelper.cxx
new file mode 100644
index 000000000..1400bf71e
--- /dev/null
+++ b/sfx2/source/dialog/filedlghelper.cxx
@@ -0,0 +1,2770 @@
+/* -*- 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/filedlghelper.hxx>
+#include <sal/types.h>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp>
+#include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp>
+#include <com/sun/star/ui/dialogs/FilePreviewImageFormats.hpp>
+#include <com/sun/star/ui/dialogs/ControlActions.hpp>
+#include <com/sun/star/ui/dialogs/TemplateDescription.hpp>
+#include <com/sun/star/ui/dialogs/XControlInformation.hpp>
+#include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp>
+#include <com/sun/star/ui/dialogs/XFilePreview.hpp>
+#include <com/sun/star/ui/dialogs/XFilterManager.hpp>
+#include <com/sun/star/ui/dialogs/XFilePicker3.hpp>
+#include <com/sun/star/ui/dialogs/XAsynchronousExecutableDialog.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/embed/ElementModes.hpp>
+#include <com/sun/star/container/XEnumeration.hpp>
+#include <com/sun/star/container/XContainerQuery.hpp>
+#include <com/sun/star/task/InteractionHandler.hpp>
+#include <com/sun/star/task/XInteractionRequest.hpp>
+#include <com/sun/star/util/RevisionTag.hpp>
+#include <comphelper/fileurl.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <comphelper/string.hxx>
+#include <comphelper/types.hxx>
+#include <tools/urlobj.hxx>
+#include <vcl/help.hxx>
+#include <vcl/weld.hxx>
+#include <unotools/ucbstreamhelper.hxx>
+#include <unotools/ucbhelper.hxx>
+#include <osl/file.hxx>
+#include <osl/security.hxx>
+#include <vcl/mnemonic.hxx>
+#include <vcl/svapp.hxx>
+#include <unotools/pathoptions.hxx>
+#include <unotools/saveopt.hxx>
+#include <unotools/securityoptions.hxx>
+#include <svl/itemset.hxx>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <vcl/dibtools.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <unotools/viewoptions.hxx>
+#include <svtools/helpids.h>
+#include <comphelper/docpasswordrequest.hxx>
+#include <comphelper/docpasswordhelper.hxx>
+#include <ucbhelper/content.hxx>
+#include <comphelper/storagehelper.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/frame.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/sfxsids.hrc>
+#include "filtergrouping.hxx"
+#include "filedlgimpl.hxx"
+#include <sfx2/strings.hrc>
+#include <sal/log.hxx>
+#include <comphelper/sequence.hxx>
+#include <tools/diagnose_ex.h>
+
+#ifdef UNX
+#include <errno.h>
+#include <sys/stat.h>
+#endif
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::ui::dialogs;
+using namespace ::com::sun::star::ui::dialogs::TemplateDescription;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::beans;
+using namespace ::cppu;
+
+#define IODLG_CONFIGNAME        "FilePicker_Save"
+#define IMPGRF_CONFIGNAME       "FilePicker_Graph"
+#define USERITEM_NAME           "UserItem"
+
+namespace sfx2
+{
+
+namespace
+{
+    bool lclSupportsOOXMLEncryption(const OUString& aFilterName)
+    {
+        return  aFilterName == "Calc MS Excel 2007 XML"
+                ||  aFilterName == "MS Word 2007 XML"
+                ||  aFilterName == "Impress MS PowerPoint 2007 XML"
+                ||  aFilterName == "Impress MS PowerPoint 2007 XML AutoPlay"
+                ||  aFilterName == "Calc Office Open XML"
+                ||  aFilterName == "Impress Office Open XML"
+                ||  aFilterName == "Impress Office Open XML AutoPlay"
+                ||  aFilterName == "Office Open XML Text";
+    }
+}
+
+static const OUString* GetLastFilterConfigId( FileDialogHelper::Context _eContext )
+{
+    static const OUString aSD_EXPORT_IDENTIFIER("SdExportLastFilter");
+    static const OUString aSI_EXPORT_IDENTIFIER("SiExportLastFilter");
+    static const OUString aSW_EXPORT_IDENTIFIER("SwExportLastFilter");
+
+    const OUString* pRet = nullptr;
+
+    switch( _eContext )
+    {
+        case FileDialogHelper::SD_EXPORT: pRet = &aSD_EXPORT_IDENTIFIER; break;
+        case FileDialogHelper::SI_EXPORT: pRet = &aSI_EXPORT_IDENTIFIER; break;
+        case FileDialogHelper::SW_EXPORT: pRet = &aSW_EXPORT_IDENTIFIER; break;
+        default: break;
+    }
+
+    return pRet;
+}
+
+static OUString EncodeSpaces_Impl( const OUString& rSource );
+static OUString DecodeSpaces_Impl( const OUString& rSource );
+
+// FileDialogHelper_Impl
+
+// XFilePickerListener Methods
+void SAL_CALL FileDialogHelper_Impl::fileSelectionChanged( const FilePickerEvent& )
+{
+    SolarMutexGuard aGuard;
+    mpAntiImpl->FileSelectionChanged();
+}
+
+void SAL_CALL FileDialogHelper_Impl::directoryChanged( const FilePickerEvent& )
+{
+    SolarMutexGuard aGuard;
+    mpAntiImpl->DirectoryChanged();
+}
+
+OUString SAL_CALL FileDialogHelper_Impl::helpRequested( const FilePickerEvent& aEvent )
+{
+    SolarMutexGuard aGuard;
+    return sfx2::FileDialogHelper::HelpRequested( aEvent );
+}
+
+void SAL_CALL FileDialogHelper_Impl::controlStateChanged( const FilePickerEvent& aEvent )
+{
+    SolarMutexGuard aGuard;
+    mpAntiImpl->ControlStateChanged( aEvent );
+}
+
+void SAL_CALL FileDialogHelper_Impl::dialogSizeChanged()
+{
+    SolarMutexGuard aGuard;
+    mpAntiImpl->DialogSizeChanged();
+}
+
+// XDialogClosedListener Methods
+void SAL_CALL FileDialogHelper_Impl::dialogClosed( const DialogClosedEvent& _rEvent )
+{
+    SolarMutexGuard aGuard;
+    mpAntiImpl->DialogClosed( _rEvent );
+    postExecute( _rEvent.DialogResult );
+}
+
+// handle XFilePickerListener events
+void FileDialogHelper_Impl::handleFileSelectionChanged()
+{
+    if ( mbHasVersions )
+        updateVersions();
+
+    if ( mbShowPreview )
+        maPreviewIdle.Start();
+}
+
+void FileDialogHelper_Impl::handleDirectoryChanged()
+{
+    if ( mbShowPreview )
+        TimeOutHdl_Impl( nullptr );
+}
+
+OUString FileDialogHelper_Impl::handleHelpRequested( const FilePickerEvent& aEvent )
+{
+    //!!! todo: cache the help strings (here or TRA)
+
+    OString sHelpId;
+    // mapping from element id -> help id
+    switch ( aEvent.ElementId )
+    {
+        case ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION :
+            sHelpId = HID_FILESAVE_AUTOEXTENSION;
+            break;
+
+        case ExtendedFilePickerElementIds::CHECKBOX_PASSWORD :
+            sHelpId = HID_FILESAVE_SAVEWITHPASSWORD;
+            break;
+
+        case ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS :
+            sHelpId = HID_FILESAVE_CUSTOMIZEFILTER;
+            break;
+
+        case ExtendedFilePickerElementIds::CHECKBOX_READONLY :
+            sHelpId = HID_FILEOPEN_READONLY;
+            break;
+
+        case ExtendedFilePickerElementIds::CHECKBOX_LINK :
+            sHelpId = HID_FILEDLG_LINK_CB;
+            break;
+
+        case ExtendedFilePickerElementIds::CHECKBOX_PREVIEW :
+            sHelpId = HID_FILEDLG_PREVIEW_CB;
+            break;
+
+        case ExtendedFilePickerElementIds::PUSHBUTTON_PLAY :
+            sHelpId = HID_FILESAVE_DOPLAY;
+            break;
+
+        case ExtendedFilePickerElementIds::LISTBOX_VERSION_LABEL :
+        case ExtendedFilePickerElementIds::LISTBOX_VERSION :
+            sHelpId = HID_FILEOPEN_VERSION;
+            break;
+
+        case ExtendedFilePickerElementIds::LISTBOX_TEMPLATE_LABEL :
+        case ExtendedFilePickerElementIds::LISTBOX_TEMPLATE :
+            sHelpId = HID_FILESAVE_TEMPLATE;
+            break;
+
+        case ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE_LABEL :
+        case ExtendedFilePickerElementIds::LISTBOX_IMAGE_TEMPLATE :
+            sHelpId = HID_FILEOPEN_IMAGE_TEMPLATE;
+            break;
+
+        case ExtendedFilePickerElementIds::LISTBOX_IMAGE_ANCHOR_LABEL :
+        case ExtendedFilePickerElementIds::LISTBOX_IMAGE_ANCHOR :
+            sHelpId = HID_FILEOPEN_IMAGE_ANCHOR;
+            break;
+
+        case ExtendedFilePickerElementIds::CHECKBOX_SELECTION :
+            sHelpId = HID_FILESAVE_SELECTION;
+            break;
+
+        default:
+            SAL_WARN( "sfx.dialog", "invalid element id" );
+    }
+
+    OUString aHelpText;
+    Help* pHelp = Application::GetHelp();
+    if ( pHelp )
+        aHelpText = pHelp->GetHelpText(OStringToOUString(sHelpId, RTL_TEXTENCODING_UTF8), static_cast<weld::Widget*>(nullptr));
+    return aHelpText;
+}
+
+void FileDialogHelper_Impl::handleControlStateChanged( const FilePickerEvent& aEvent )
+{
+    switch ( aEvent.ElementId )
+    {
+        case CommonFilePickerElementIds::LISTBOX_FILTER:
+            updateFilterOptionsBox();
+            enablePasswordBox( false );
+            updateSelectionBox();
+            // only use it for export and with our own dialog
+            if ( mbExport && !mbSystemPicker )
+                updateExportButton();
+            break;
+
+        case ExtendedFilePickerElementIds::CHECKBOX_PREVIEW:
+            updatePreviewState(true);
+            break;
+    }
+}
+
+void FileDialogHelper_Impl::handleDialogSizeChanged()
+{
+    if ( mbShowPreview )
+        TimeOutHdl_Impl( nullptr );
+}
+
+// XEventListener Methods
+void SAL_CALL FileDialogHelper_Impl::disposing( const EventObject& )
+{
+    SolarMutexGuard aGuard;
+    dispose();
+}
+
+void FileDialogHelper_Impl::dispose()
+{
+    if ( mxFileDlg.is() )
+    {
+        // remove the event listener
+        mxFileDlg->removeFilePickerListener( this );
+
+        ::comphelper::disposeComponent( mxFileDlg );
+        mxFileDlg.clear();
+    }
+}
+
+OUString FileDialogHelper_Impl::getCurrentFilterUIName() const
+{
+    OUString aFilterName;
+
+    if( mxFileDlg.is() )
+    {
+        aFilterName = mxFileDlg->getCurrentFilter();
+
+        if ( !aFilterName.isEmpty() && isShowFilterExtensionEnabled() )
+            aFilterName = getFilterName( aFilterName );
+    }
+
+    return aFilterName;
+}
+
+void FileDialogHelper_Impl::LoadLastUsedFilter( const OUString& _rContextIdentifier )
+{
+    SvtViewOptions aDlgOpt( EViewType::Dialog, IODLG_CONFIGNAME );
+
+    if( aDlgOpt.Exists() )
+    {
+        OUString    aLastFilter;
+        if( aDlgOpt.GetUserItem( _rContextIdentifier ) >>= aLastFilter )
+            setFilter( aLastFilter );
+    }
+}
+
+void FileDialogHelper_Impl::SaveLastUsedFilter()
+{
+    const OUString* pConfigId = GetLastFilterConfigId( meContext );
+    if( pConfigId )
+        SvtViewOptions( EViewType::Dialog, IODLG_CONFIGNAME ).SetUserItem( *pConfigId,
+                            makeAny( getFilterWithExtension( getFilter() ) ) );
+}
+
+std::shared_ptr<const SfxFilter> FileDialogHelper_Impl::getCurentSfxFilter()
+{
+    OUString aFilterName = getCurrentFilterUIName();
+
+    if ( mpMatcher && !aFilterName.isEmpty() )
+        return mpMatcher->GetFilter4UIName( aFilterName, m_nMustFlags, m_nDontFlags );
+
+    return nullptr;
+}
+
+bool FileDialogHelper_Impl::updateExtendedControl( sal_Int16 _nExtendedControlId, bool _bEnable )
+{
+    bool bIsEnabled = false;
+
+    uno::Reference < XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+    if ( xCtrlAccess.is() )
+    {
+        try
+        {
+            xCtrlAccess->enableControl( _nExtendedControlId, _bEnable );
+            bIsEnabled = _bEnable;
+        }
+        catch( const IllegalArgumentException& )
+        {
+            TOOLS_WARN_EXCEPTION( "sfx", "FileDialogHelper_Impl::updateExtendedControl" );
+        }
+    }
+    return bIsEnabled;
+}
+
+bool FileDialogHelper_Impl::CheckFilterOptionsCapability( const std::shared_ptr<const SfxFilter>& _pFilter )
+{
+    bool bResult = false;
+
+    if( mxFilterCFG.is() && _pFilter )
+    {
+        try
+        {
+            Sequence < PropertyValue > aProps;
+            Any aAny = mxFilterCFG->getByName( _pFilter->GetName() );
+            if ( aAny >>= aProps )
+            {
+                OUString aServiceName;
+                for( const auto& rProp : std::as_const(aProps) )
+                {
+                    if( rProp.Name == "UIComponent" )
+                    {
+                        rProp.Value >>= aServiceName;
+                        if( !aServiceName.isEmpty() )
+                            bResult = true;
+                    }
+                }
+            }
+        }
+        catch( const Exception& )
+        {
+        }
+    }
+
+    return bResult;
+}
+
+bool FileDialogHelper_Impl::isInOpenMode() const
+{
+    bool bRet = false;
+
+    switch ( m_nDialogType )
+    {
+        case FILEOPEN_SIMPLE:
+        case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE:
+        case FILEOPEN_PLAY:
+        case FILEOPEN_LINK_PLAY:
+        case FILEOPEN_READONLY_VERSION:
+        case FILEOPEN_LINK_PREVIEW:
+        case FILEOPEN_PREVIEW:
+            bRet = true;
+    }
+
+    return bRet;
+}
+
+void FileDialogHelper_Impl::updateFilterOptionsBox()
+{
+    if ( !m_bHaveFilterOptions )
+        return;
+
+    updateExtendedControl(
+        ExtendedFilePickerElementIds::CHECKBOX_FILTEROPTIONS,
+        CheckFilterOptionsCapability( getCurentSfxFilter() )
+    );
+}
+
+void FileDialogHelper_Impl::updateExportButton()
+{
+    uno::Reference < XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+    if ( !xCtrlAccess.is() )
+        return;
+
+    OUString sOldLabel( xCtrlAccess->getLabel( CommonFilePickerElementIds::PUSHBUTTON_OK ) );
+
+    // initialize button label; we need the label with the mnemonic char
+    if ( maButtonLabel.isEmpty() || maButtonLabel.indexOf( MNEMONIC_CHAR ) == -1 )
+    {
+        // cut the ellipses, if necessary
+        sal_Int32 nIndex = sOldLabel.indexOf( "..." );
+        if ( -1 == nIndex )
+            nIndex = sOldLabel.getLength();
+        maButtonLabel = sOldLabel.copy( 0, nIndex );
+    }
+
+    OUString sLabel = maButtonLabel;
+    // filter with options -> append ellipses on export button label
+    if ( CheckFilterOptionsCapability( getCurentSfxFilter() ) )
+        sLabel += "...";
+
+    if ( sOldLabel != sLabel )
+    {
+        try
+        {
+            xCtrlAccess->setLabel( CommonFilePickerElementIds::PUSHBUTTON_OK, sLabel );
+        }
+        catch( const IllegalArgumentException& )
+        {
+            TOOLS_WARN_EXCEPTION( "sfx.dialog", "FileDialogHelper_Impl::updateExportButton" );
+        }
+    }
+}
+
+void FileDialogHelper_Impl::updateSelectionBox()
+{
+    if ( !mbHasSelectionBox )
+        return;
+
+    // Does the selection box exist?
+    bool bSelectionBoxFound = false;
+    uno::Reference< XControlInformation > xCtrlInfo( mxFileDlg, UNO_QUERY );
+    if ( xCtrlInfo.is() )
+    {
+        Sequence< OUString > aCtrlList = xCtrlInfo->getSupportedControls();
+        bSelectionBoxFound = comphelper::findValue(aCtrlList, "SelectionBox") != -1;
+    }
+
+    if ( bSelectionBoxFound )
+    {
+        std::shared_ptr<const SfxFilter> pFilter = getCurentSfxFilter();
+        mbSelectionFltrEnabled = updateExtendedControl(
+            ExtendedFilePickerElementIds::CHECKBOX_SELECTION,
+            ( mbSelectionEnabled && pFilter && ( pFilter->GetFilterFlags() & SfxFilterFlags::SUPPORTSSELECTION ) ) );
+        uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+        xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0, makeAny( mbSelection ) );
+    }
+}
+
+void FileDialogHelper_Impl::enablePasswordBox( bool bInit )
+{
+    if ( ! mbHasPassword )
+        return;
+
+    bool bWasEnabled = mbIsPwdEnabled;
+
+    std::shared_ptr<const SfxFilter> pCurrentFilter = getCurentSfxFilter();
+    mbIsPwdEnabled = updateExtendedControl(
+        ExtendedFilePickerElementIds::CHECKBOX_PASSWORD,
+        pCurrentFilter && ( pCurrentFilter->GetFilterFlags() & SfxFilterFlags::ENCRYPTION )
+    );
+
+    if( bInit )
+    {
+        // in case of initialization previous state is not interesting
+        if( mbIsPwdEnabled )
+        {
+            uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+            if( mbPwdCheckBoxState )
+                xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0, makeAny( true ) );
+        }
+    }
+    else if( !bWasEnabled && mbIsPwdEnabled )
+    {
+        uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+        if( mbPwdCheckBoxState )
+            xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0, makeAny( true ) );
+    }
+    else if( bWasEnabled && !mbIsPwdEnabled )
+    {
+        // remember user settings until checkbox is enabled
+        uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+        Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0 );
+        bool bPassWord = false;
+        mbPwdCheckBoxState = ( aValue >>= bPassWord ) && bPassWord;
+        xCtrlAccess->setValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0, makeAny( false ) );
+    }
+}
+
+void FileDialogHelper_Impl::updatePreviewState( bool _bUpdatePreviewWindow )
+{
+    if ( !mbHasPreview )
+        return;
+
+    uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+
+    // check, whether or not we have to display a preview
+    if ( !xCtrlAccess.is() )
+        return;
+
+    try
+    {
+        Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW, 0 );
+        bool bShowPreview = false;
+
+        if ( aValue >>= bShowPreview )
+        {
+            mbShowPreview = bShowPreview;
+
+            // setShowState has currently no effect for the
+            // OpenOffice FilePicker (see svtools/source/filepicker/iodlg.cxx)
+            uno::Reference< XFilePreview > xFilePreview( mxFileDlg, UNO_QUERY );
+            if ( xFilePreview.is() )
+                xFilePreview->setShowState( mbShowPreview );
+
+            if ( _bUpdatePreviewWindow )
+                TimeOutHdl_Impl( nullptr );
+        }
+    }
+    catch( const Exception& )
+    {
+        TOOLS_WARN_EXCEPTION( "sfx.dialog", "FileDialogHelper_Impl::updatePreviewState" );
+    }
+}
+
+void FileDialogHelper_Impl::updateVersions()
+{
+    Sequence < OUString > aEntries;
+    Sequence < OUString > aPathSeq = mxFileDlg->getFiles();
+
+    if ( aPathSeq.getLength() == 1 )
+    {
+        INetURLObject aObj( aPathSeq[0] );
+
+        if ( ( aObj.GetProtocol() == INetProtocol::File ) &&
+            ( utl::UCBContentHelper::IsDocument( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ) ) )
+        {
+            try
+            {
+                uno::Reference< embed::XStorage > xStorage = ::comphelper::OStorageHelper::GetStorageFromURL(
+                                                                aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ),
+                                                                embed::ElementModes::READ );
+
+                DBG_ASSERT( xStorage.is(), "The method must return the storage or throw exception!" );
+                if ( !xStorage.is() )
+                    throw uno::RuntimeException();
+
+                uno::Sequence < util::RevisionTag > xVersions = SfxMedium::GetVersionList( xStorage );
+
+                aEntries.realloc( xVersions.getLength() + 1 );
+                aEntries[0] = SfxResId( STR_SFX_FILEDLG_ACTUALVERSION );
+
+                std::transform(xVersions.begin(), xVersions.end(), std::next(aEntries.begin()),
+                    [](const util::RevisionTag& rVersion) -> OUString { return rVersion.Identifier; });
+            }
+            catch( const uno::Exception& )
+            {
+            }
+        }
+    }
+
+    uno::Reference < XFilePickerControlAccess > xDlg( mxFileDlg, UNO_QUERY );
+    Any aValue;
+
+    try
+    {
+        xDlg->setValue( ExtendedFilePickerElementIds::LISTBOX_VERSION,
+                        ControlActions::DELETE_ITEMS, aValue );
+    }
+    catch( const IllegalArgumentException& ){}
+
+    if ( !aEntries.hasElements() )
+        return;
+
+    try
+    {
+        aValue <<= aEntries;
+        xDlg->setValue( ExtendedFilePickerElementIds::LISTBOX_VERSION,
+                        ControlActions::ADD_ITEMS, aValue );
+
+        Any aPos;
+        aPos <<= sal_Int32(0);
+        xDlg->setValue( ExtendedFilePickerElementIds::LISTBOX_VERSION,
+                        ControlActions::SET_SELECT_ITEM, aPos );
+    }
+    catch( const IllegalArgumentException& ){}
+}
+
+IMPL_LINK_NOARG(FileDialogHelper_Impl, TimeOutHdl_Impl, Timer *, void)
+{
+    if ( !mbHasPreview )
+        return;
+
+    maGraphic.Clear();
+
+    Any aAny;
+    uno::Reference < XFilePreview > xFilePicker( mxFileDlg, UNO_QUERY );
+
+    if ( ! xFilePicker.is() )
+        return;
+
+    Sequence < OUString > aPathSeq = mxFileDlg->getFiles();
+
+    if ( mbShowPreview && ( aPathSeq.getLength() == 1 ) )
+    {
+        OUString    aURL = aPathSeq[0];
+
+        if ( ERRCODE_NONE == getGraphic( aURL, maGraphic ) )
+        {
+            // changed the code slightly;
+            // before: the bitmap was scaled and
+            // surrounded a white frame
+            // now: the bitmap will only be scaled
+            // and the filepicker implementation
+            // is responsible for placing it at its
+            // proper position and painting a frame
+
+            BitmapEx aBmp = maGraphic.GetBitmapEx();
+            if ( !aBmp.IsEmpty() )
+            {
+                // scale the bitmap to the correct size
+                sal_Int32 nOutWidth  = xFilePicker->getAvailableWidth();
+                sal_Int32 nOutHeight = xFilePicker->getAvailableHeight();
+                sal_Int32 nBmpWidth  = aBmp.GetSizePixel().Width();
+                sal_Int32 nBmpHeight = aBmp.GetSizePixel().Height();
+
+                double nXRatio = static_cast<double>(nOutWidth) / nBmpWidth;
+                double nYRatio = static_cast<double>(nOutHeight) / nBmpHeight;
+
+                if ( nXRatio < nYRatio )
+                    aBmp.Scale( nXRatio, nXRatio );
+                else
+                    aBmp.Scale( nYRatio, nYRatio );
+
+                // Convert to true color, to allow CopyPixel
+                aBmp.Convert( BmpConversion::N24Bit );
+
+                // and copy it into the Any
+                SvMemoryStream aData;
+
+                WriteDIB(aBmp, aData, false);
+
+                const Sequence < sal_Int8 > aBuffer(
+                    static_cast< const sal_Int8* >(aData.GetData()),
+                    aData.GetEndOfData() );
+
+                aAny <<= aBuffer;
+            }
+        }
+    }
+
+    try
+    {
+        SolarMutexReleaser aReleaseForCallback;
+        // clear the preview window
+        xFilePicker->setImage( FilePreviewImageFormats::BITMAP, aAny );
+    }
+    catch( const IllegalArgumentException& )
+    {
+    }
+}
+
+ErrCode FileDialogHelper_Impl::getGraphic( const OUString& rURL,
+                                           Graphic& rGraphic ) const
+{
+    if ( utl::UCBContentHelper::IsFolder( rURL ) )
+        return ERRCODE_IO_NOTAFILE;
+
+    if ( !mpGraphicFilter )
+        return ERRCODE_IO_NOTSUPPORTED;
+
+    // select graphic filter from dialog filter selection
+    OUString aCurFilter( getFilter() );
+
+    sal_uInt16 nFilter = !aCurFilter.isEmpty() && mpGraphicFilter->GetImportFormatCount()
+                    ? mpGraphicFilter->GetImportFormatNumber( aCurFilter )
+                    : GRFILTER_FORMAT_DONTKNOW;
+
+    INetURLObject aURLObj( rURL );
+
+    if ( aURLObj.HasError() || INetProtocol::NotValid == aURLObj.GetProtocol() )
+    {
+        aURLObj.SetSmartProtocol( INetProtocol::File );
+        aURLObj.SetSmartURL( rURL );
+    }
+
+    ErrCode nRet = ERRCODE_NONE;
+
+    GraphicFilterImportFlags nFilterImportFlags = GraphicFilterImportFlags::SetLogsizeForJpeg;
+    // non-local?
+    if ( INetProtocol::File != aURLObj.GetProtocol() )
+    {
+        std::unique_ptr<SvStream> pStream = ::utl::UcbStreamHelper::CreateStream( rURL, StreamMode::READ );
+
+        if( pStream )
+            nRet = mpGraphicFilter->ImportGraphic( rGraphic, rURL, *pStream, nFilter, nullptr, nFilterImportFlags );
+        else
+            nRet = mpGraphicFilter->ImportGraphic( rGraphic, aURLObj, nFilter, nullptr, nFilterImportFlags );
+    }
+    else
+    {
+        nRet = mpGraphicFilter->ImportGraphic( rGraphic, aURLObj, nFilter, nullptr, nFilterImportFlags );
+    }
+
+    return nRet;
+}
+
+ErrCode FileDialogHelper_Impl::getGraphic( Graphic& rGraphic ) const
+{
+    ErrCode nRet = ERRCODE_NONE;
+
+    // rhbz#1079672 do not return maGraphic, it needs not to be the selected file
+
+    OUString aPath;
+    Sequence<OUString> aPathSeq = mxFileDlg->getFiles();
+
+    if (aPathSeq.getLength() == 1)
+    {
+        aPath = aPathSeq[0];
+    }
+
+    if (!aPath.isEmpty())
+        nRet = getGraphic(aPath, rGraphic);
+    else
+        nRet = ERRCODE_IO_GENERAL;
+
+    return nRet;
+}
+
+static bool lcl_isSystemFilePicker( const uno::Reference< XFilePicker3 >& _rxFP )
+{
+    try
+    {
+        uno::Reference< XServiceInfo > xSI( _rxFP, UNO_QUERY );
+        if ( !xSI.is() )
+            return true;
+        return xSI->supportsService( "com.sun.star.ui.dialogs.SystemFilePicker" );
+    }
+    catch( const Exception& )
+    {
+    }
+    return false;
+}
+
+namespace {
+
+enum open_or_save_t {OPEN, SAVE, UNDEFINED};
+
+}
+
+static open_or_save_t lcl_OpenOrSave(sal_Int16 const nDialogType)
+{
+    switch (nDialogType)
+    {
+        case FILEOPEN_SIMPLE:
+        case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE:
+        case FILEOPEN_LINK_PREVIEW_IMAGE_ANCHOR:
+        case FILEOPEN_PLAY:
+        case FILEOPEN_LINK_PLAY:
+        case FILEOPEN_READONLY_VERSION:
+        case FILEOPEN_LINK_PREVIEW:
+        case FILEOPEN_PREVIEW:
+            return OPEN;
+        case FILESAVE_SIMPLE:
+        case FILESAVE_AUTOEXTENSION_PASSWORD:
+        case FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS:
+        case FILESAVE_AUTOEXTENSION_SELECTION:
+        case FILESAVE_AUTOEXTENSION_TEMPLATE:
+        case FILESAVE_AUTOEXTENSION:
+            return SAVE;
+        default:
+            assert(false); // invalid dialog type
+    }
+    return UNDEFINED;
+}
+
+// FileDialogHelper_Impl
+
+css::uno::Reference<css::awt::XWindow> FileDialogHelper_Impl::GetFrameInterface()
+{
+    if (mpFrameWeld)
+        return mpFrameWeld->GetXWindow();
+    return css::uno::Reference<css::awt::XWindow>();
+}
+
+FileDialogHelper_Impl::FileDialogHelper_Impl(
+    FileDialogHelper* _pAntiImpl,
+    sal_Int16 nDialogType,
+    FileDialogFlags nFlags,
+    sal_Int16 nDialog,
+    weld::Window* pFrameWeld,
+    const OUString& sStandardDir,
+    const css::uno::Sequence< OUString >& rBlackList
+    )
+    :m_nDialogType          ( nDialogType )
+    ,meContext              ( FileDialogHelper::UNKNOWN_CONTEXT )
+{
+    const char* pServiceName=nullptr;
+    switch (nDialog)
+    {
+        case SFX2_IMPL_DIALOG_SYSTEM:
+        case SFX2_IMPL_DIALOG_OOO:
+            pServiceName = "com.sun.star.ui.dialogs.OfficeFilePicker";
+            break;
+        case SFX2_IMPL_DIALOG_REMOTE:
+            pServiceName = "com.sun.star.ui.dialogs.RemoteFilePicker";
+            break;
+        default:
+            pServiceName = "com.sun.star.ui.dialogs.FilePicker";
+            break;
+    }
+
+    OUString aService = OUString::createFromAscii( pServiceName );
+
+    uno::Reference< XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
+
+    // create the file open dialog
+    // the flags can be SFXWB_INSERT or SFXWB_MULTISELECTION
+
+    mpFrameWeld             = pFrameWeld;
+    mpAntiImpl              = _pAntiImpl;
+    mbHasAutoExt            = false;
+    mbHasPassword           = false;
+    m_bHaveFilterOptions    = false;
+    mbIsPwdEnabled          = true;
+    mbHasVersions           = false;
+    mbHasPreview            = false;
+    mbShowPreview           = false;
+    mbDeleteMatcher         = false;
+    mbInsert                = bool(nFlags & (FileDialogFlags::Insert|
+                                             FileDialogFlags::InsertCompare|
+                                             FileDialogFlags::InsertMerge));
+    mbExport                = bool(nFlags & FileDialogFlags::Export);
+    mbIsSaveDlg             = false;
+    mbPwdCheckBoxState      = false;
+    mbSelection             = false;
+    mbSelectionEnabled      = true;
+    mbHasSelectionBox       = false;
+    mbSelectionFltrEnabled  = false;
+
+    // default settings
+    m_nDontFlags = SFX_FILTER_NOTINSTALLED | SfxFilterFlags::INTERNAL | SfxFilterFlags::NOTINFILEDLG;
+    if (OPEN == lcl_OpenOrSave(m_nDialogType))
+        m_nMustFlags = SfxFilterFlags::IMPORT;
+    else
+        m_nMustFlags = SfxFilterFlags::EXPORT;
+
+
+    mpMatcher = nullptr;
+    mpGraphicFilter = nullptr;
+    mnPostUserEventId = nullptr;
+
+    // create the picker component
+    mxFileDlg.set(xFactory->createInstance( aService ), css::uno::UNO_QUERY);
+    mbSystemPicker = lcl_isSystemFilePicker( mxFileDlg );
+
+    uno::Reference< XInitialization > xInit( mxFileDlg, UNO_QUERY );
+
+    if ( ! mxFileDlg.is() )
+    {
+        return;
+    }
+
+
+    if ( xInit.is() )
+    {
+        sal_Int16 nTemplateDescription = TemplateDescription::FILEOPEN_SIMPLE;
+
+        switch ( m_nDialogType )
+        {
+            case FILEOPEN_SIMPLE:
+                nTemplateDescription = TemplateDescription::FILEOPEN_SIMPLE;
+                break;
+
+            case FILESAVE_SIMPLE:
+                nTemplateDescription = TemplateDescription::FILESAVE_SIMPLE;
+                mbIsSaveDlg = true;
+                break;
+
+            case FILESAVE_AUTOEXTENSION_PASSWORD:
+                nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD;
+                mbHasPassword = true;
+                mbHasAutoExt = true;
+                mbIsSaveDlg = true;
+                break;
+
+            case FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS:
+                nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_PASSWORD_FILTEROPTIONS;
+                mbHasPassword = true;
+
+                m_bHaveFilterOptions = true;
+                if( xFactory.is() )
+                {
+                    mxFilterCFG.set(
+                        xFactory->createInstance( "com.sun.star.document.FilterFactory" ),
+                        UNO_QUERY );
+                }
+
+                mbHasAutoExt = true;
+                mbIsSaveDlg = true;
+                break;
+
+            case FILESAVE_AUTOEXTENSION_SELECTION:
+                nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_SELECTION;
+                mbHasAutoExt = true;
+                mbIsSaveDlg = true;
+                mbHasSelectionBox = true;
+                if ( mbExport && !mxFilterCFG.is() && xFactory.is() )
+                {
+                    mxFilterCFG.set(
+                        xFactory->createInstance( "com.sun.star.document.FilterFactory" ),
+                        UNO_QUERY );
+                }
+                break;
+
+            case FILESAVE_AUTOEXTENSION_TEMPLATE:
+                nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION_TEMPLATE;
+                mbHasAutoExt = true;
+                mbIsSaveDlg = true;
+                break;
+
+            case FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE:
+                nTemplateDescription = TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_TEMPLATE;
+                mbHasPreview = true;
+                break;
+
+            case FILEOPEN_LINK_PREVIEW_IMAGE_ANCHOR:
+                nTemplateDescription = TemplateDescription::FILEOPEN_LINK_PREVIEW_IMAGE_ANCHOR;
+                mbHasPreview = true;
+                break;
+
+            case FILEOPEN_PLAY:
+                nTemplateDescription = TemplateDescription::FILEOPEN_PLAY;
+                break;
+
+            case FILEOPEN_LINK_PLAY:
+                nTemplateDescription = TemplateDescription::FILEOPEN_LINK_PLAY;
+                break;
+
+            case FILEOPEN_READONLY_VERSION:
+                nTemplateDescription = TemplateDescription::FILEOPEN_READONLY_VERSION;
+                mbHasVersions = true;
+                break;
+
+            case FILEOPEN_LINK_PREVIEW:
+                nTemplateDescription = TemplateDescription::FILEOPEN_LINK_PREVIEW;
+                mbHasPreview = true;
+                break;
+
+            case FILESAVE_AUTOEXTENSION:
+                nTemplateDescription = TemplateDescription::FILESAVE_AUTOEXTENSION;
+                mbHasAutoExt = true;
+                mbIsSaveDlg = true;
+                break;
+
+            case FILEOPEN_PREVIEW:
+                nTemplateDescription = TemplateDescription::FILEOPEN_PREVIEW;
+                mbHasPreview = true;
+                break;
+
+            default:
+                SAL_WARN( "sfx.dialog", "FileDialogHelper::ctor with unknown type" );
+                break;
+        }
+
+        if (mbHasPreview)
+        {
+            maPreviewIdle.SetPriority( TaskPriority::LOWEST );
+            maPreviewIdle.SetInvokeHandler( LINK( this, FileDialogHelper_Impl, TimeOutHdl_Impl ) );
+        }
+
+        auto xWindow = GetFrameInterface();
+
+        Sequence < Any > aInitArguments(!xWindow.is() ? 3 : 4);
+
+        // This is a hack. We currently know that the internal file picker implementation
+        // supports the extended arguments as specified below.
+        // TODO:
+        // a) adjust the service description so that it includes the TemplateDescription and ParentWindow args
+        // b) adjust the implementation of the system file picker to that it recognizes it
+        if ( mbSystemPicker )
+        {
+            aInitArguments[0] <<= nTemplateDescription;
+            if (xWindow.is())
+                aInitArguments[1] <<= xWindow;
+        }
+        else
+        {
+            aInitArguments[0] <<= NamedValue(
+                                    "TemplateDescription",
+                                    makeAny( nTemplateDescription )
+                                );
+
+            aInitArguments[1] <<= NamedValue(
+                                    "StandardDir",
+                                    makeAny( sStandardDir )
+                                );
+
+            aInitArguments[2] <<= NamedValue(
+                                    "BlackList",
+                                    makeAny( rBlackList )
+                                );
+
+
+            if (xWindow.is())
+                aInitArguments[3] <<= NamedValue("ParentWindow", makeAny(xWindow));
+        }
+
+        try
+        {
+            xInit->initialize( aInitArguments );
+        }
+        catch( const Exception& )
+        {
+            OSL_FAIL( "FileDialogHelper_Impl::FileDialogHelper_Impl: could not initialize the picker!" );
+        }
+    }
+
+
+    // set multiselection mode
+    if ( nFlags & FileDialogFlags::MultiSelection )
+        mxFileDlg->setMultiSelectionMode( true );
+
+    if ( nFlags & FileDialogFlags::Graphic ) // generate graphic filter only on demand
+    {
+        addGraphicFilter();
+    }
+
+    // Export dialog
+    if ( mbExport )
+    {
+        mxFileDlg->setTitle( SfxResId( STR_SFX_EXPLORERFILE_EXPORT ) );
+        try {
+                css::uno::Reference < XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY_THROW );
+                xCtrlAccess->enableControl( ExtendedFilePickerElementIds::LISTBOX_FILTER_SELECTOR, true );
+        }
+        catch( const Exception & ) { }
+    }
+
+    // Save a copy dialog
+    if ( nFlags & FileDialogFlags::SaveACopy )
+    {
+        mxFileDlg->setTitle( SfxResId( STR_PB_SAVEACOPY ) );
+    }
+
+    // the "insert file" dialog needs another title
+    if ( mbInsert )
+    {
+        if ( nFlags & FileDialogFlags::InsertCompare )
+        {
+            mxFileDlg->setTitle( SfxResId( STR_PB_COMPAREDOC ) );
+        }
+        else if ( nFlags & FileDialogFlags::InsertMerge )
+        {
+            mxFileDlg->setTitle( SfxResId( STR_PB_MERGEDOC ) );
+        }
+        else
+        {
+            mxFileDlg->setTitle( SfxResId( STR_SFX_EXPLORERFILE_INSERT ) );
+        }
+        uno::Reference < XFilePickerControlAccess > xExtDlg( mxFileDlg, UNO_QUERY );
+        if ( xExtDlg.is() )
+        {
+            try
+            {
+                xExtDlg->setLabel( CommonFilePickerElementIds::PUSHBUTTON_OK,
+                                   SfxResId( STR_SFX_EXPLORERFILE_BUTTONINSERT ) );
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+    }
+
+    // add the event listener
+    mxFileDlg->addFilePickerListener( this );
+}
+
+FileDialogHelper_Impl::~FileDialogHelper_Impl()
+{
+    // Remove user event if we haven't received it yet
+    if ( mnPostUserEventId )
+        Application::RemoveUserEvent( mnPostUserEventId );
+    mnPostUserEventId = nullptr;
+
+    mpGraphicFilter.reset();
+
+    if ( mbDeleteMatcher )
+        delete mpMatcher;
+
+    maPreviewIdle.ClearInvokeHandler();
+
+    ::comphelper::disposeComponent( mxFileDlg );
+}
+
+void FileDialogHelper_Impl::setControlHelpIds( const sal_Int16* _pControlId, const char** _pHelpId )
+{
+    DBG_ASSERT( _pControlId && _pHelpId, "FileDialogHelper_Impl::setControlHelpIds: invalid array pointers!" );
+    if ( !_pControlId || !_pHelpId )
+        return;
+
+    // forward these ids to the file picker
+    try
+    {
+        const OUString sHelpIdPrefix( INET_HID_SCHEME  );
+        // the ids for the single controls
+        uno::Reference< XFilePickerControlAccess > xControlAccess( mxFileDlg, UNO_QUERY );
+        if ( xControlAccess.is() )
+        {
+            while ( *_pControlId )
+            {
+                DBG_ASSERT( INetURLObject( OStringToOUString( *_pHelpId, RTL_TEXTENCODING_UTF8 ) ).GetProtocol() == INetProtocol::NotValid, "Wrong HelpId!" );
+                OUString sId = sHelpIdPrefix +
+                    OUString( *_pHelpId, strlen( *_pHelpId ), RTL_TEXTENCODING_UTF8 );
+                xControlAccess->setValue( *_pControlId, ControlActions::SET_HELP_URL, makeAny( sId ) );
+
+                ++_pControlId; ++_pHelpId;
+            }
+        }
+    }
+    catch( const Exception& )
+    {
+        OSL_FAIL( "FileDialogHelper_Impl::setControlHelpIds: caught an exception while setting the help ids!" );
+    }
+}
+
+IMPL_LINK_NOARG( FileDialogHelper_Impl, InitControls, void*, void )
+{
+    mnPostUserEventId = nullptr;
+    enablePasswordBox( true );
+    updateFilterOptionsBox( );
+    updateSelectionBox( );
+}
+
+void FileDialogHelper_Impl::preExecute()
+{
+    loadConfig( );
+    setDefaultValues( );
+    updatePreviewState( false );
+
+    implInitializeFileName( );
+
+#if !(defined(MACOSX) && defined(MACOSX)) && !defined(_WIN32)
+    // allow for dialog implementations which need to be executed before they return valid values for
+    // current filter and such
+
+    // On Vista (at least SP1) it's the same as on MacOSX, the modal dialog won't let message pass
+    // through before it returns from execution
+    mnPostUserEventId = Application::PostUserEvent( LINK( this, FileDialogHelper_Impl, InitControls ) );
+#else
+    // However, the macOS implementation's pickers run modally in execute and so the event doesn't
+    // get through in time... so we call the methods directly
+    enablePasswordBox( true );
+    updateFilterOptionsBox( );
+    updateSelectionBox( );
+#endif
+}
+
+void FileDialogHelper_Impl::postExecute( sal_Int16 _nResult )
+{
+    if ( ExecutableDialogResults::CANCEL != _nResult )
+        saveConfig();
+}
+
+void FileDialogHelper_Impl::implInitializeFileName( )
+{
+    if ( maFileName.isEmpty() )
+        return;
+
+    INetURLObject aObj( maPath );
+    aObj.Append( maFileName );
+
+    // in case we're operating as save dialog, and "auto extension" is checked,
+    // cut the extension from the name
+    if ( !(mbIsSaveDlg && mbHasAutoExt) )
+        return;
+
+    try
+    {
+        bool bAutoExtChecked = false;
+
+        uno::Reference < XFilePickerControlAccess > xControlAccess( mxFileDlg, UNO_QUERY );
+        if  (   xControlAccess.is()
+            &&  (   xControlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0 )
+                >>= bAutoExtChecked
+                )
+            )
+        {
+            if ( bAutoExtChecked )
+            {   // cut the extension
+                aObj.removeExtension( );
+                mxFileDlg->setDefaultName(
+                    aObj.GetLastName(INetURLObject::DecodeMechanism::WithCharset));
+            }
+        }
+    }
+    catch( const Exception& )
+    {
+        OSL_FAIL( "FileDialogHelper_Impl::implInitializeFileName: could not ask for the auto-extension current-value!" );
+    }
+}
+
+sal_Int16 FileDialogHelper_Impl::implDoExecute()
+{
+    preExecute();
+
+    sal_Int16 nRet = ExecutableDialogResults::CANCEL;
+
+//On MacOSX the native file picker has to run in the primordial thread because of drawing issues
+//On Linux the native gtk file picker, when backed by gnome-vfs2, needs to be run in the same
+//primordial thread as the ucb gnome-vfs2 provider was initialized in.
+
+    {
+        try
+        {
+#ifdef _WIN32
+            if ( mbSystemPicker )
+            {
+                SolarMutexReleaser aSolarMutex;
+                nRet = mxFileDlg->execute();
+            }
+            else
+#endif
+                nRet = mxFileDlg->execute();
+        }
+        catch( const Exception& )
+        {
+            TOOLS_WARN_EXCEPTION( "sfx.dialog", "FileDialogHelper_Impl::implDoExecute" );
+        }
+    }
+
+    postExecute( nRet );
+
+    return nRet;
+}
+
+void FileDialogHelper_Impl::implStartExecute()
+{
+    DBG_ASSERT( mxFileDlg.is(), "invalid file dialog" );
+
+    preExecute();
+
+    if ( mbSystemPicker )
+    {
+    }
+    else
+    {
+        try
+        {
+            uno::Reference< XAsynchronousExecutableDialog > xAsyncDlg( mxFileDlg, UNO_QUERY );
+            if ( xAsyncDlg.is() )
+                xAsyncDlg->startExecuteModal( this );
+        }
+        catch( const Exception& )
+        {
+            TOOLS_WARN_EXCEPTION( "sfx.dialog", "FileDialogHelper_Impl::implDoExecute" );
+        }
+    }
+}
+
+static void lcl_saveLastURLs(std::vector<OUString>& rpURLList,
+                      ::std::vector< OUString >& lLastURLs )
+{
+    lLastURLs.clear();
+    for (auto const& url : rpURLList)
+        lLastURLs.push_back(url);
+}
+
+void FileDialogHelper_Impl::implGetAndCacheFiles(const uno::Reference< XInterface >& xPicker, std::vector<OUString>& rpURLList, const std::shared_ptr<const SfxFilter>& pFilter)
+{
+    rpURLList.clear();
+
+    OUString sExtension;
+    if (pFilter)
+    {
+        sExtension = pFilter->GetDefaultExtension ();
+        sExtension = sExtension.replaceAll("*", "").replaceAll(".", "");
+    }
+
+    // a) the new way (optional!)
+    uno::Reference< XFilePicker3 > xPickNew(xPicker, UNO_QUERY);
+    if (xPickNew.is())
+    {
+        Sequence< OUString > lFiles    = xPickNew->getSelectedFiles();
+        comphelper::sequenceToContainer(rpURLList, lFiles);
+    }
+
+    // b) the olde way ... non optional.
+    else
+    {
+        uno::Reference< XFilePicker3 > xPickOld(xPicker, UNO_QUERY_THROW);
+        Sequence< OUString > lFiles = xPickOld->getFiles();
+        ::sal_Int32          nFiles = lFiles.getLength();
+        if ( nFiles == 1 )
+        {
+            rpURLList.push_back(lFiles[0]);
+        }
+        else if ( nFiles > 1 )
+        {
+            INetURLObject aPath( lFiles[0] );
+            aPath.setFinalSlash();
+
+            for (::sal_Int32 i = 1; i < nFiles; i++)
+            {
+                if (i == 1)
+                    aPath.Append( lFiles[i] );
+                else
+                    aPath.setName( lFiles[i] );
+
+                rpURLList.push_back(aPath.GetMainURL(INetURLObject::DecodeMechanism::NONE));
+            }
+        }
+    }
+
+    lcl_saveLastURLs(rpURLList, mlLastURLs);
+}
+
+ErrCode FileDialogHelper_Impl::execute( std::vector<OUString>& rpURLList,
+                                        std::unique_ptr<SfxItemSet>& rpSet,
+                                        OUString&       rFilter )
+{
+    // rFilter is a pure output parameter, it shouldn't be used for anything else
+    // changing this would surely break code
+    // rpSet is in/out parameter, usually just a media-descriptor that can be changed by dialog
+
+    uno::Reference< XFilePickerControlAccess > xCtrlAccess( mxFileDlg, UNO_QUERY );
+
+    // retrieves parameters from rpSet
+    // for now only Password is used
+    if ( rpSet )
+    {
+        // check password checkbox if the document had password before
+        if( mbHasPassword )
+        {
+            const SfxBoolItem* pPassItem = SfxItemSet::GetItem<SfxBoolItem>(rpSet.get(), SID_PASSWORDINTERACTION, false);
+            mbPwdCheckBoxState = ( pPassItem != nullptr && pPassItem->GetValue() );
+
+            // in case the document has password to modify, the dialog should be shown
+            const SfxUnoAnyItem* pPassToModifyItem = SfxItemSet::GetItem<SfxUnoAnyItem>(rpSet.get(), SID_MODIFYPASSWORDINFO, false);
+            mbPwdCheckBoxState |= ( pPassToModifyItem && pPassToModifyItem->GetValue().hasValue() );
+        }
+
+        const SfxBoolItem* pSelectItem = SfxItemSet::GetItem<SfxBoolItem>(rpSet.get(), SID_SELECTION, false);
+        if ( pSelectItem )
+            mbSelection = pSelectItem->GetValue();
+        else
+            mbSelectionEnabled = false;
+
+        // the password will be set in case user decide so
+        rpSet->ClearItem( SID_PASSWORDINTERACTION );
+        if (rpSet->HasItem( SID_PASSWORD ))
+        {
+            // As the SID_ENCRYPTIONDATA and SID_PASSWORD are using for setting password together, we need to clear them both.
+            // Note: Do not remove SID_ENCRYPTIONDATA without SID_PASSWORD
+            rpSet->ClearItem( SID_PASSWORD );
+            rpSet->ClearItem( SID_ENCRYPTIONDATA );
+        }
+        rpSet->ClearItem( SID_RECOMMENDREADONLY );
+        rpSet->ClearItem( SID_MODIFYPASSWORDINFO );
+
+    }
+
+    if ( mbHasPassword && !mbPwdCheckBoxState )
+    {
+        SvtSecurityOptions aSecOpt;
+        mbPwdCheckBoxState = (
+            aSecOpt.IsOptionSet( SvtSecurityOptions::EOption::DocWarnRecommendPassword ) );
+    }
+
+    rpURLList.clear();
+
+    if ( ! mxFileDlg.is() )
+        return ERRCODE_ABORT;
+
+    if ( ExecutableDialogResults::CANCEL != implDoExecute() )
+    {
+        // create an itemset if there is no
+        if( !rpSet )
+            rpSet.reset(new SfxAllItemSet( SfxGetpApp()->GetPool() ));
+
+        // the item should remain only if it was set by the dialog
+        rpSet->ClearItem( SID_SELECTION );
+
+        if( mbExport && mbHasSelectionBox )
+        {
+            try
+            {
+                Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0 );
+                bool bSelection = false;
+                if ( aValue >>= bSelection )
+                    rpSet->Put( SfxBoolItem( SID_SELECTION, bSelection ) );
+            }
+            catch( const IllegalArgumentException& )
+            {
+                OSL_FAIL( "FileDialogHelper_Impl::execute: caught an IllegalArgumentException!" );
+            }
+        }
+
+
+        // set the read-only flag. When inserting a file, this flag is always set
+        if ( mbInsert )
+            rpSet->Put( SfxBoolItem( SID_DOC_READONLY, true ) );
+        else
+        {
+            if ( ( FILEOPEN_READONLY_VERSION == m_nDialogType ) && xCtrlAccess.is() )
+            {
+                try
+                {
+                    Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_READONLY, 0 );
+                    bool bReadOnly = false;
+                    if ( ( aValue >>= bReadOnly ) && bReadOnly )
+                        rpSet->Put( SfxBoolItem( SID_DOC_READONLY, bReadOnly ) );
+                }
+                catch( const IllegalArgumentException& )
+                {
+                    OSL_FAIL( "FileDialogHelper_Impl::execute: caught an IllegalArgumentException!" );
+                }
+            }
+        }
+        if ( mbHasVersions && xCtrlAccess.is() )
+        {
+            try
+            {
+                Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::LISTBOX_VERSION,
+                                                    ControlActions::GET_SELECTED_ITEM_INDEX );
+                sal_Int32 nVersion = 0;
+                if ( ( aValue >>= nVersion ) && nVersion > 0 )
+                    // open a special version; 0 == current version
+                    rpSet->Put( SfxInt16Item( SID_VERSION, static_cast<short>(nVersion) ) );
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+
+        // set the filter
+        getRealFilter( rFilter );
+
+        std::shared_ptr<const SfxFilter> pCurrentFilter = getCurentSfxFilter();
+
+        // fill the rpURLList
+        implGetAndCacheFiles( mxFileDlg, rpURLList, pCurrentFilter );
+        if ( rpURLList.empty() )
+            return ERRCODE_ABORT;
+
+        // check, whether or not we have to display a password box
+        if ( pCurrentFilter && mbHasPassword && mbIsPwdEnabled && xCtrlAccess.is() )
+        {
+            try
+            {
+                Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_PASSWORD, 0 );
+                bool bPassWord = false;
+                if ( ( aValue >>= bPassWord ) && bPassWord )
+                {
+                    // ask for a password
+                    OUString aDocName(rpURLList[0]);
+                    ErrCode errCode = RequestPassword(pCurrentFilter, aDocName, rpSet.get(), GetFrameInterface());
+                    if (errCode != ERRCODE_NONE)
+                        return errCode;
+                }
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+        // check, whether or not we have to display a key selection box
+        if ( pCurrentFilter && mbHasPassword && xCtrlAccess.is() )
+        {
+            try
+            {
+                Any aValue = xCtrlAccess->getValue( ExtendedFilePickerElementIds::CHECKBOX_GPGENCRYPTION, 0 );
+                bool bGpg = false;
+                if ( ( aValue >>= bGpg ) && bGpg )
+                {
+                    uno::Sequence< beans::NamedValue > aEncryptionData;
+                    while(true)
+                    {
+                        try
+                        {
+                            // ask for keys
+                            aEncryptionData = ::comphelper::OStorageHelper::CreateGpgPackageEncryptionData();
+                            break; // user cancelled or we've some keys now
+                        }
+                        catch( const IllegalArgumentException& )
+                        {
+                            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(mpFrameWeld,
+                                                                                     VclMessageType::Warning, VclButtonsType::Ok,
+                                                                                     SfxResId(RID_SVXSTR_GPG_ENCRYPT_FAILURE)));
+                            xBox->run();
+                        }
+                    }
+
+                    if ( aEncryptionData.hasElements() )
+                        rpSet->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::makeAny( aEncryptionData) ) );
+                }
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+
+        SaveLastUsedFilter();
+        return ERRCODE_NONE;
+    }
+    else
+        return ERRCODE_ABORT;
+}
+
+ErrCode FileDialogHelper_Impl::execute()
+{
+    if ( ! mxFileDlg.is() )
+        return ERRCODE_ABORT;
+
+    sal_Int16 nRet = implDoExecute();
+
+    maPath = mxFileDlg->getDisplayDirectory();
+
+    if ( ExecutableDialogResults::CANCEL == nRet )
+        return ERRCODE_ABORT;
+    else
+    {
+        return ERRCODE_NONE;
+    }
+}
+
+OUString FileDialogHelper_Impl::getPath() const
+{
+    OUString aPath;
+
+    if ( mxFileDlg.is() )
+        aPath = mxFileDlg->getDisplayDirectory();
+
+    if ( aPath.isEmpty() )
+        aPath = maPath;
+
+    return aPath;
+}
+
+OUString FileDialogHelper_Impl::getFilter() const
+{
+    OUString aFilter = getCurrentFilterUIName();
+
+    if( aFilter.isEmpty() )
+        aFilter = maCurFilter;
+
+    return aFilter;
+}
+
+void FileDialogHelper_Impl::getRealFilter( OUString& _rFilter ) const
+{
+    _rFilter = getCurrentFilterUIName();
+
+    if ( _rFilter.isEmpty() )
+        _rFilter = maCurFilter;
+
+    if ( !_rFilter.isEmpty() && mpMatcher )
+    {
+        std::shared_ptr<const SfxFilter> pFilter =
+            mpMatcher->GetFilter4UIName( _rFilter, m_nMustFlags, m_nDontFlags );
+        _rFilter = pFilter ? pFilter->GetFilterName() : OUString();
+    }
+}
+
+void FileDialogHelper_Impl::verifyPath()
+{
+#ifdef UNX
+    // lp#905355, fdo#43895
+    // Check that the file has read only permission and is in /tmp -- this is
+    //  the case if we have opened the file from the web with firefox only.
+    if (maFileName.isEmpty()) {
+        return;
+    }
+    INetURLObject url(maPath);
+    if (url.GetProtocol() != INetProtocol::File
+        || url.getName(0, true, INetURLObject::DecodeMechanism::WithCharset) != "tmp")
+    {
+        return;
+    }
+    if (maFileName.indexOf('/') != -1) {
+        SAL_WARN("sfx.dialog", maFileName << " contains /");
+        return;
+    }
+    url.insertName(
+        maFileName, false, INetURLObject::LAST_SEGMENT,
+        INetURLObject::EncodeMechanism::All);
+    OUString sysPathU;
+    osl::FileBase::RC e = osl::FileBase::getSystemPathFromFileURL(
+        url.GetMainURL(INetURLObject::DecodeMechanism::NONE), sysPathU);
+    if (e != osl::FileBase::E_None) {
+        SAL_WARN(
+            "sfx.dialog",
+            "getSystemPathFromFileURL("
+                << url.GetMainURL(INetURLObject::DecodeMechanism::NONE) << ") failed with "
+                << +e);
+        return;
+    }
+    OString sysPathC;
+    if (!sysPathU.convertToString(
+            &sysPathC, osl_getThreadTextEncoding(),
+            (RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR
+             | RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR)))
+    {
+        SAL_WARN(
+            "sfx.dialog",
+            "convertToString(" << sysPathU << ") failed for encoding "
+                << +osl_getThreadTextEncoding());
+        return;
+    }
+    struct stat aFileStat;
+    if (stat(sysPathC.getStr(), &aFileStat) == -1) {
+        SAL_WARN( "sfx.dialog", "stat(" << sysPathC << ") failed with errno " << errno);
+        return;
+    }
+    if ((aFileStat.st_mode & (S_IRWXO | S_IRWXG | S_IRWXU)) == S_IRUSR) {
+        maPath = SvtPathOptions().GetWorkPath();
+        mxFileDlg->setDisplayDirectory( maPath );
+    }
+#else
+    (void) this;
+#endif
+}
+
+void FileDialogHelper_Impl::displayFolder( const OUString& _rPath )
+{
+    if ( _rPath.isEmpty() )
+        // nothing to do
+        return;
+
+    maPath = _rPath;
+    if ( mxFileDlg.is() )
+    {
+        try
+        {
+            mxFileDlg->setDisplayDirectory( maPath );
+            verifyPath();
+        }
+        catch( const IllegalArgumentException& )
+        {
+            TOOLS_WARN_EXCEPTION( "sfx", "FileDialogHelper_Impl::displayFolder" );
+        }
+    }
+}
+
+void FileDialogHelper_Impl::setFileName( const OUString& _rFile )
+{
+    maFileName = _rFile;
+    if ( mxFileDlg.is() )
+    {
+        try
+        {
+            mxFileDlg->setDefaultName( maFileName );
+            verifyPath();
+        }
+        catch( const IllegalArgumentException& )
+        {
+            TOOLS_WARN_EXCEPTION( "sfx", "FileDialogHelper_Impl::setFileName" );
+        }
+    }
+}
+
+void FileDialogHelper_Impl::setFilter( const OUString& rFilter )
+{
+    DBG_ASSERT( rFilter.indexOf(':') == -1, "Old filter name used!");
+
+    maCurFilter = rFilter;
+
+    if ( !rFilter.isEmpty() && mpMatcher )
+    {
+        std::shared_ptr<const SfxFilter> pFilter = mpMatcher->GetFilter4FilterName(
+                                        rFilter, m_nMustFlags, m_nDontFlags );
+        if ( pFilter )
+            maCurFilter = pFilter->GetUIName();
+    }
+
+    if ( !maCurFilter.isEmpty() && mxFileDlg.is() )
+    {
+        try
+        {
+            mxFileDlg->setCurrentFilter( maCurFilter );
+        }
+        catch( const IllegalArgumentException& ){}
+    }
+}
+
+void FileDialogHelper_Impl::createMatcher( const OUString& rFactory )
+{
+    if (mbDeleteMatcher)
+        delete mpMatcher;
+
+    mpMatcher = new SfxFilterMatcher( SfxObjectShell::GetServiceNameFromFactory(rFactory) );
+    mbDeleteMatcher = true;
+}
+
+void FileDialogHelper_Impl::addFilters( const OUString& rFactory,
+                                        SfxFilterFlags nMust,
+                                        SfxFilterFlags nDont )
+{
+    if ( ! mxFileDlg.is() )
+        return;
+
+    if (mbDeleteMatcher)
+        delete mpMatcher;
+
+    // we still need a matcher to convert UI names to filter names
+    if ( rFactory.isEmpty() )
+    {
+        SfxApplication *pSfxApp = SfxGetpApp();
+        mpMatcher = &pSfxApp->GetFilterMatcher();
+        mbDeleteMatcher = false;
+    }
+    else
+    {
+        mpMatcher = new SfxFilterMatcher( rFactory );
+        mbDeleteMatcher = true;
+    }
+
+    uno::Reference< XMultiServiceFactory > xSMGR = ::comphelper::getProcessServiceFactory();
+    uno::Reference< XContainerQuery > xFilterCont(
+        xSMGR->createInstance("com.sun.star.document.FilterFactory"),
+        UNO_QUERY);
+    if ( ! xFilterCont.is() )
+        return;
+
+    m_nMustFlags |= nMust;
+    m_nDontFlags |= nDont;
+
+    // create the list of filters
+    OUString sQuery =
+        "getSortedFilterList()"
+        ":module=" +
+        rFactory + // use long name here !
+        ":iflags=" +
+        OUString::number(static_cast<sal_Int32>(m_nMustFlags)) +
+        ":eflags=" +
+        OUString::number(static_cast<sal_Int32>(m_nDontFlags));
+
+    uno::Reference< XEnumeration > xResult;
+    try
+    {
+        xResult = xFilterCont->createSubSetEnumerationByQuery(sQuery);
+    }
+    catch( const uno::Exception& )
+    {
+        SAL_WARN( "sfx.dialog", "Could not get filters from the configuration!" );
+    }
+
+    TSortedFilterList         aIter   (xResult);
+
+    // append the filters
+    OUString sFirstFilter;
+    if (OPEN == lcl_OpenOrSave(m_nDialogType))
+        ::sfx2::appendFiltersForOpen( aIter, mxFileDlg, sFirstFilter, *this );
+    else if ( mbExport )
+        ::sfx2::appendExportFilters( aIter, mxFileDlg, sFirstFilter, *this );
+    else
+        ::sfx2::appendFiltersForSave( aIter, mxFileDlg, sFirstFilter, *this, rFactory );
+
+    // set our initial selected filter (if we do not already have one)
+    if ( maSelectFilter.isEmpty() )
+        maSelectFilter = sFirstFilter;
+}
+
+void FileDialogHelper_Impl::addFilter( const OUString& rFilterName,
+                                       const OUString& rExtension )
+{
+    if ( ! mxFileDlg.is() )
+        return;
+
+    try
+    {
+        mxFileDlg->appendFilter( rFilterName, rExtension );
+
+        if ( maSelectFilter.isEmpty() )
+            maSelectFilter = rFilterName;
+    }
+    catch( const IllegalArgumentException& )
+    {
+        SAL_WARN( "sfx.dialog", "Could not append Filter" << rFilterName );
+    }
+}
+
+void FileDialogHelper_Impl::addGraphicFilter()
+{
+    if ( ! mxFileDlg.is() )
+        return;
+
+    // create the list of filters
+    mpGraphicFilter.reset( new GraphicFilter );
+    sal_uInt16 i, j, nCount = mpGraphicFilter->GetImportFormatCount();
+
+    // compute the extension string for all known import filters
+    OUString aExtensions;
+
+    for ( i = 0; i < nCount; i++ )
+    {
+        j = 0;
+        while( true )
+        {
+            OUString sWildcard = mpGraphicFilter->GetImportWildcard( i, j++ );
+            if ( sWildcard.isEmpty() )
+                break;
+            if ( aExtensions.indexOf( sWildcard ) == -1 )
+            {
+                if ( !aExtensions.isEmpty() )
+                    aExtensions += ";";
+                aExtensions += sWildcard;
+            }
+        }
+    }
+
+#if defined(_WIN32)
+    if ( aExtensions.getLength() > 240 )
+        aExtensions = FILEDIALOG_FILTER_ALL;
+#endif
+    bool bIsInOpenMode = isInOpenMode();
+
+    try
+    {
+        // if the extension is not "All files", insert "All images"
+        if (aExtensions != FILEDIALOG_FILTER_ALL)
+        {
+            OUString aAllFilterName = SfxResId(STR_SFX_IMPORT_ALL_IMAGES);
+            aAllFilterName = ::sfx2::addExtension( aAllFilterName, aExtensions, bIsInOpenMode, *this );
+            mxFileDlg->appendFilter( aAllFilterName, aExtensions );
+            maSelectFilter = aAllFilterName; // and make it the default
+        }
+
+        // rhbz#1715109 always include All files *.* or *
+        OUString aAllFilesName = SfxResId( STR_SFX_FILTERNAME_ALL );
+        aAllFilesName = ::sfx2::addExtension( aAllFilesName, FILEDIALOG_FILTER_ALL, bIsInOpenMode, *this );
+        mxFileDlg->appendFilter( aAllFilesName, FILEDIALOG_FILTER_ALL );
+
+        // if the extension is "All files", make that the default
+        if (aExtensions == FILEDIALOG_FILTER_ALL)
+            maSelectFilter = aAllFilesName;
+    }
+    catch( const IllegalArgumentException& )
+    {
+        SAL_WARN( "sfx.dialog", "Could not append Filter" );
+    }
+
+    // Now add the filter
+    for ( i = 0; i < nCount; i++ )
+    {
+        OUString aName = mpGraphicFilter->GetImportFormatName( i );
+        OUString aExt;
+        j = 0;
+        while( true )
+        {
+            OUString sWildcard = mpGraphicFilter->GetImportWildcard( i, j++ );
+            if ( sWildcard.isEmpty() )
+                break;
+            if ( aExt.indexOf( sWildcard ) == -1 )
+            {
+                if ( !aExt.isEmpty() )
+                    aExt += ";";
+                aExt += sWildcard;
+            }
+        }
+        aName = ::sfx2::addExtension( aName, aExt, bIsInOpenMode, *this );
+        try
+        {
+            mxFileDlg->appendFilter( aName, aExt );
+        }
+        catch( const IllegalArgumentException& )
+        {
+            SAL_WARN( "sfx.dialog", "Could not append Filter" );
+        }
+    }
+}
+
+#define GRF_CONFIG_STR      "   "
+#define STD_CONFIG_STR      "1 "
+
+static void SetToken( OUString& rOrigStr, sal_Int32 nToken, sal_Unicode cTok, const OUString& rStr)
+{
+    const sal_Unicode*  pStr        = rOrigStr.getStr();
+    sal_Int32     nLen              = rOrigStr.getLength();
+    sal_Int32     nTok              = 0;
+    sal_Int32     nFirstChar        = 0;
+    sal_Int32     i                 = nFirstChar;
+
+    // Determine token position and length
+    pStr += i;
+    while ( i < nLen )
+    {
+        // Increase token count if match
+        if ( *pStr == cTok )
+        {
+            ++nTok;
+
+            if ( nTok == nToken )
+                nFirstChar = i+1;
+            else
+            {
+                if ( nTok > nToken )
+                    break;
+            }
+        }
+
+        ++pStr;
+        ++i;
+    }
+
+    if ( nTok >= nToken )
+        rOrigStr = rOrigStr.replaceAt( nFirstChar, i-nFirstChar, rStr );
+}
+
+
+void FileDialogHelper_Impl::saveConfig()
+{
+    uno::Reference < XFilePickerControlAccess > xDlg( mxFileDlg, UNO_QUERY );
+    Any aValue;
+
+    if ( ! xDlg.is() )
+        return;
+
+    if ( mbHasPreview )
+    {
+        SvtViewOptions aDlgOpt( EViewType::Dialog, IMPGRF_CONFIGNAME );
+        OUString aUserData(GRF_CONFIG_STR);
+
+        try
+        {
+            aValue = xDlg->getValue( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW, 0 );
+            bool bValue = false;
+            aValue >>= bValue;
+            SetToken( aUserData, 1, ' ', OUString::number( static_cast<sal_Int32>(bValue) ) );
+
+            INetURLObject aObj( getPath() );
+
+            if ( aObj.GetProtocol() == INetProtocol::File )
+                SetToken( aUserData, 2, ' ', aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+
+            OUString aFilter = getFilter();
+            aFilter = EncodeSpaces_Impl( aFilter );
+            SetToken( aUserData, 3, ' ', aFilter );
+
+            aDlgOpt.SetUserItem( USERITEM_NAME, makeAny( aUserData ) );
+        }
+        catch( const IllegalArgumentException& ){}
+    }
+    else
+    {
+        bool bWriteConfig = false;
+        SvtViewOptions aDlgOpt( EViewType::Dialog, IODLG_CONFIGNAME );
+        OUString aUserData(STD_CONFIG_STR);
+
+        if ( aDlgOpt.Exists() )
+        {
+            Any aUserItem = aDlgOpt.GetUserItem( USERITEM_NAME );
+            OUString aTemp;
+            if ( aUserItem >>= aTemp )
+                aUserData = aTemp;
+        }
+
+        if ( mbHasAutoExt )
+        {
+            try
+            {
+                aValue = xDlg->getValue( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0 );
+                bool bAutoExt = true;
+                aValue >>= bAutoExt;
+                SetToken( aUserData, 0, ' ', OUString::number( static_cast<sal_Int32>(bAutoExt) ) );
+                bWriteConfig = true;
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+
+        if ( ! mbIsSaveDlg )
+        {
+            OUString aPath = getPath();
+            if ( comphelper::isFileUrl( aPath ) )
+            {
+                SetToken( aUserData, 1, ' ', aPath );
+                bWriteConfig = true;
+            }
+        }
+
+        if( mbHasSelectionBox && mbSelectionFltrEnabled )
+        {
+            try
+            {
+                aValue = xDlg->getValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0 );
+                bool bSelection = true;
+                aValue >>= bSelection;
+                if ( comphelper::string::getTokenCount(aUserData, ' ') < 3 )
+                    aUserData += " ";
+                SetToken( aUserData, 2, ' ', OUString::number( static_cast<sal_Int32>(bSelection) ) );
+                bWriteConfig = true;
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+
+        if ( bWriteConfig )
+            aDlgOpt.SetUserItem( USERITEM_NAME, makeAny( aUserData ) );
+    }
+
+    SfxApplication *pSfxApp = SfxGetpApp();
+    pSfxApp->SetLastDir_Impl( getPath() );
+}
+
+namespace
+{
+    OUString getInitPath( const OUString& _rFallback, const sal_Int32 _nFallbackToken )
+    {
+        SfxApplication *pSfxApp = SfxGetpApp();
+        OUString sPath = pSfxApp->GetLastDir_Impl();
+
+        if ( sPath.isEmpty() )
+            sPath = _rFallback.getToken( _nFallbackToken, ' ' );
+
+        // check if the path points to a valid (accessible) directory
+        bool bValid = false;
+        if ( !sPath.isEmpty() )
+        {
+            OUString sPathCheck( sPath );
+            if ( sPathCheck[ sPathCheck.getLength() - 1 ] != '/' )
+                sPathCheck += "/";
+            sPathCheck += ".";
+            try
+            {
+                ::ucbhelper::Content aContent( sPathCheck,
+                                               utl::UCBContentHelper::getDefaultCommandEnvironment(),
+                                               comphelper::getProcessComponentContext() );
+                bValid = aContent.isFolder();
+            }
+            catch( const Exception& ) {}
+        }
+
+        if ( !bValid )
+            sPath.clear();
+
+        return sPath;
+    }
+}
+
+void FileDialogHelper_Impl::loadConfig()
+{
+    uno::Reference < XFilePickerControlAccess > xDlg( mxFileDlg, UNO_QUERY );
+    Any aValue;
+
+    if ( ! xDlg.is() )
+        return;
+
+    if ( mbHasPreview )
+    {
+        SvtViewOptions aViewOpt( EViewType::Dialog, IMPGRF_CONFIGNAME );
+        OUString aUserData;
+
+        if ( aViewOpt.Exists() )
+        {
+            Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME );
+            OUString aTemp;
+            if ( aUserItem >>= aTemp )
+                aUserData = aTemp;
+        }
+
+        if ( !aUserData.isEmpty() )
+        {
+            try
+            {
+                // respect the last "insert as link" state
+                bool bLink = aUserData.getToken( 0, ' ' ).toInt32();
+                aValue <<= bLink;
+                xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_LINK, 0, aValue );
+
+                // respect the last "show preview" state
+                bool bShowPreview = aUserData.getToken( 1, ' ' ).toInt32();
+                aValue <<= bShowPreview;
+                xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_PREVIEW, 0, aValue );
+
+                if ( maPath.isEmpty() )
+                    displayFolder( getInitPath( aUserData, 2 ) );
+
+                if ( maCurFilter.isEmpty() )
+                {
+                    OUString aFilter = aUserData.getToken( 3, ' ' );
+                    aFilter = DecodeSpaces_Impl( aFilter );
+                    setFilter( aFilter );
+                }
+
+                // set the member so we know that we have to show the preview
+                mbShowPreview = bShowPreview;
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+
+        if ( maPath.isEmpty() )
+            displayFolder( SvtPathOptions().GetGraphicPath() );
+    }
+    else
+    {
+        SvtViewOptions aViewOpt( EViewType::Dialog, IODLG_CONFIGNAME );
+        OUString aUserData;
+
+        if ( aViewOpt.Exists() )
+        {
+            Any aUserItem = aViewOpt.GetUserItem( USERITEM_NAME );
+            OUString aTemp;
+            if ( aUserItem >>= aTemp )
+                aUserData = aTemp;
+        }
+
+        if ( aUserData.isEmpty() )
+            aUserData = STD_CONFIG_STR;
+
+        if ( maPath.isEmpty() )
+            displayFolder( getInitPath( aUserData, 1 ) );
+
+        if ( mbHasAutoExt )
+        {
+            sal_Int32 nFlag = aUserData.getToken( 0, ' ' ).toInt32();
+            aValue <<= static_cast<bool>(nFlag);
+            try
+            {
+                xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, 0, aValue );
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+
+        if( mbHasSelectionBox )
+        {
+            sal_Int32 nFlag = aUserData.getToken( 2, ' ' ).toInt32();
+            aValue <<= static_cast<bool>(nFlag);
+            try
+            {
+                xDlg->setValue( ExtendedFilePickerElementIds::CHECKBOX_SELECTION, 0, aValue );
+            }
+            catch( const IllegalArgumentException& ){}
+        }
+
+        if ( maPath.isEmpty() )
+            displayFolder( SvtPathOptions().GetWorkPath() );
+    }
+}
+
+void FileDialogHelper_Impl::setDefaultValues()
+{
+    // when no filter is set, we set the currentFilter to <all>
+    if ( maCurFilter.isEmpty() && !maSelectFilter.isEmpty() )
+    {
+        try
+        {
+            mxFileDlg->setCurrentFilter( maSelectFilter );
+        }
+        catch( const IllegalArgumentException& )
+        {}
+    }
+
+    // when no path is set, we use the standard 'work' folder
+    if ( maPath.isEmpty() )
+    {
+        OUString aWorkFolder = SvtPathOptions().GetWorkPath();
+        try
+        {
+            mxFileDlg->setDisplayDirectory( aWorkFolder );
+        }
+        catch( const Exception& )
+        {
+            OSL_FAIL( "FileDialogHelper_Impl::setDefaultValues: caught an exception while setting the display directory!" );
+        }
+    }
+}
+
+bool FileDialogHelper_Impl::isShowFilterExtensionEnabled() const
+{
+    return !maFilters.empty();
+}
+
+void FileDialogHelper_Impl::addFilterPair( const OUString& rFilter,
+                                           const OUString& rFilterWithExtension )
+{
+    maFilters.emplace_back( rFilter, rFilterWithExtension );
+
+}
+
+OUString FileDialogHelper_Impl::getFilterName( const OUString& rFilterWithExtension ) const
+{
+    OUString sRet;
+    for (auto const& filter : maFilters)
+    {
+        if (filter.Second == rFilterWithExtension)
+        {
+            sRet = filter.First;
+            break;
+        }
+    }
+    return sRet;
+}
+
+OUString FileDialogHelper_Impl::getFilterWithExtension( const OUString& rFilter ) const
+{
+    OUString sRet;
+    for (auto const& filter : maFilters)
+    {
+        if ( filter.First == rFilter )
+        {
+            sRet = filter.Second;
+            break;
+        }
+    }
+    return sRet;
+}
+
+void FileDialogHelper_Impl::SetContext( FileDialogHelper::Context _eNewContext )
+{
+    meContext = _eNewContext;
+
+    const OUString* pConfigId = GetLastFilterConfigId( _eNewContext );
+    if( pConfigId )
+        LoadLastUsedFilter( *pConfigId );
+}
+
+// FileDialogHelper
+
+FileDialogHelper::FileDialogHelper(
+    sal_Int16 nDialogType,
+    FileDialogFlags nFlags,
+    const OUString& rFact,
+    SfxFilterFlags nMust,
+    SfxFilterFlags nDont,
+    weld::Window* pPreferredParent)
+    :   m_nError(0),
+        mpImpl(new FileDialogHelper_Impl(this, nDialogType, nFlags, SFX2_IMPL_DIALOG_CONFIG, pPreferredParent))
+{
+
+    // create the list of filters
+    mpImpl->addFilters(
+            SfxObjectShell::GetServiceNameFromFactory(rFact), nMust, nDont );
+}
+
+FileDialogHelper::FileDialogHelper(
+    sal_Int16 nDialogType,
+    FileDialogFlags nFlags,
+    const OUString& rFact,
+    sal_Int16 nDialog,
+    SfxFilterFlags nMust,
+    SfxFilterFlags nDont,
+    const OUString& rStandardDir,
+    const css::uno::Sequence< OUString >& rBlackList,
+    weld::Window* pPreferredParent)
+    :   m_nError(0),
+        mpImpl( new FileDialogHelper_Impl( this, nDialogType, nFlags, nDialog, pPreferredParent, rStandardDir, rBlackList ) )
+{
+    // create the list of filters
+    mpImpl->addFilters(
+            SfxObjectShell::GetServiceNameFromFactory(rFact), nMust, nDont );
+}
+
+FileDialogHelper::FileDialogHelper(sal_Int16 nDialogType, FileDialogFlags nFlags, weld::Window* pPreferredParent)
+    :   m_nError(0),
+        mpImpl( new FileDialogHelper_Impl( this, nDialogType, nFlags, SFX2_IMPL_DIALOG_CONFIG, pPreferredParent ) )
+{
+}
+
+FileDialogHelper::FileDialogHelper(
+    sal_Int16 nDialogType,
+    FileDialogFlags nFlags,
+    const OUString& aFilterUIName,
+    const OUString& aExtName,
+    const OUString& rStandardDir,
+    const css::uno::Sequence< OUString >& rBlackList,
+    weld::Window* pPreferredParent )
+    :   m_nError(0),
+        mpImpl( new FileDialogHelper_Impl( this, nDialogType, nFlags, SFX2_IMPL_DIALOG_CONFIG, pPreferredParent, rStandardDir, rBlackList ) )
+{
+    // the wildcard here is expected in form "*.extension"
+    OUString aWildcard;
+    if ( aExtName.indexOf( '*' ) != 0 )
+    {
+        if ( !aExtName.isEmpty() && aExtName.indexOf( '.' ) != 0 )
+            aWildcard = "*.";
+        else
+            aWildcard = "*";
+    }
+
+    aWildcard += aExtName;
+
+    OUString const aUIString = ::sfx2::addExtension(
+        aFilterUIName, aWildcard, (OPEN == lcl_OpenOrSave(mpImpl->m_nDialogType)), *mpImpl);
+    AddFilter( aUIString, aWildcard );
+}
+
+FileDialogHelper::~FileDialogHelper()
+{
+    mpImpl->dispose();
+}
+
+void FileDialogHelper::CreateMatcher( const OUString& rFactory )
+{
+    mpImpl->createMatcher( SfxObjectShell::GetServiceNameFromFactory(rFactory) );
+}
+
+void FileDialogHelper::SetControlHelpIds( const sal_Int16* _pControlId, const char** _pHelpId )
+{
+    mpImpl->setControlHelpIds( _pControlId, _pHelpId );
+}
+
+void FileDialogHelper::SetContext( Context _eNewContext )
+{
+    mpImpl->SetContext( _eNewContext );
+}
+
+IMPL_LINK_NOARG(FileDialogHelper, ExecuteSystemFilePicker, void*, void)
+{
+    m_nError = mpImpl->execute();
+    m_aDialogClosedLink.Call( this );
+}
+
+// rDirPath has to be a directory
+ErrCode FileDialogHelper::Execute( std::vector<OUString>& rpURLList,
+                                   std::unique_ptr<SfxItemSet>& rpSet,
+                                   OUString&       rFilter,
+                                   const OUString& rDirPath )
+{
+    SetDisplayFolder( rDirPath );
+    return mpImpl->execute( rpURLList, rpSet, rFilter );
+}
+
+
+ErrCode FileDialogHelper::Execute()
+{
+    return mpImpl->execute();
+}
+
+ErrCode FileDialogHelper::Execute( std::unique_ptr<SfxItemSet>& rpSet,
+                                   OUString&       rFilter )
+{
+    ErrCode nRet;
+    std::vector<OUString> rURLList;
+    nRet = mpImpl->execute(rURLList, rpSet, rFilter);
+    return nRet;
+}
+
+void FileDialogHelper::StartExecuteModal( const Link<FileDialogHelper*,void>& rEndDialogHdl )
+{
+    m_aDialogClosedLink = rEndDialogHdl;
+    m_nError = ERRCODE_NONE;
+    if ( mpImpl->isSystemFilePicker() )
+        Application::PostUserEvent( LINK( this, FileDialogHelper, ExecuteSystemFilePicker ) );
+    else
+        mpImpl->implStartExecute();
+}
+
+sal_Int16 FileDialogHelper::GetDialogType() const { return mpImpl ? mpImpl->m_nDialogType : 0; }
+
+bool FileDialogHelper::IsPasswordEnabled() const
+{
+    return mpImpl && mpImpl->isPasswordEnabled();
+}
+
+OUString FileDialogHelper::GetRealFilter() const
+{
+    OUString sFilter;
+    if (mpImpl)
+        mpImpl->getRealFilter( sFilter );
+    return sFilter;
+}
+
+void FileDialogHelper::SetTitle( const OUString& rNewTitle )
+{
+    if ( mpImpl->mxFileDlg.is() )
+        mpImpl->mxFileDlg->setTitle( rNewTitle );
+}
+
+OUString FileDialogHelper::GetPath() const
+{
+    OUString aPath;
+
+    if ( !mpImpl->mlLastURLs.empty())
+        return mpImpl->mlLastURLs[0];
+
+    if ( mpImpl->mxFileDlg.is() )
+    {
+        Sequence < OUString > aPathSeq = mpImpl->mxFileDlg->getFiles();
+
+        if ( aPathSeq.getLength() == 1 )
+        {
+            aPath = aPathSeq[0];
+        }
+    }
+
+    return aPath;
+}
+
+Sequence < OUString > FileDialogHelper::GetMPath() const
+{
+    if ( !mpImpl->mlLastURLs.empty())
+        return comphelper::containerToSequence(mpImpl->mlLastURLs);
+
+    if ( mpImpl->mxFileDlg.is() )
+        return mpImpl->mxFileDlg->getFiles();
+    else
+    {
+        Sequence < OUString > aEmpty;
+        return aEmpty;
+    }
+}
+
+Sequence< OUString > FileDialogHelper::GetSelectedFiles() const
+{
+    // a) the new way (optional!)
+    uno::Sequence< OUString > aResultSeq;
+    if (mpImpl->mxFileDlg.is())
+    {
+        aResultSeq = mpImpl->mxFileDlg->getSelectedFiles();
+    }
+    // b) the olde way ... non optional.
+    else
+    {
+        uno::Reference< XFilePicker > xPickOld(mpImpl->mxFileDlg, UNO_QUERY_THROW);
+        Sequence< OUString > lFiles = xPickOld->getFiles();
+        ::sal_Int32          nFiles = lFiles.getLength();
+        if ( nFiles > 1 )
+        {
+            aResultSeq = Sequence< OUString >( nFiles-1 );
+
+            INetURLObject aPath( lFiles[0] );
+            aPath.setFinalSlash();
+
+            for (::sal_Int32 i = 1; i < nFiles; i++)
+            {
+                if (i == 1)
+                    aPath.Append( lFiles[i] );
+                else
+                    aPath.setName( lFiles[i] );
+
+                aResultSeq[i-1] = aPath.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+            }
+        }
+        else
+            aResultSeq = lFiles;
+    }
+
+    return aResultSeq;
+}
+
+OUString FileDialogHelper::GetDisplayDirectory() const
+{
+    return mpImpl->getPath();
+}
+
+OUString FileDialogHelper::GetCurrentFilter() const
+{
+    return mpImpl->getFilter();
+}
+
+ErrCode FileDialogHelper::GetGraphic( Graphic& rGraphic ) const
+{
+    return mpImpl->getGraphic( rGraphic );
+}
+
+static int impl_isFolder( const OUString& rPath )
+{
+    try
+    {
+        ::ucbhelper::Content aContent(
+            rPath, uno::Reference< ucb::XCommandEnvironment > (),
+            comphelper::getProcessComponentContext() );
+        if ( aContent.isFolder() )
+            return 1;
+
+        return 0;
+    }
+    catch ( const Exception & )
+    {
+    }
+
+    return -1;
+}
+
+void FileDialogHelper::SetDisplayDirectory( const OUString& _rPath )
+{
+    if ( _rPath.isEmpty() )
+        return;
+
+    // if the given path isn't a folder, we cut off the last part
+    // and take it as filename and the rest of the path should be
+    // the folder
+
+    INetURLObject aObj( _rPath );
+
+    OUString sFileName = aObj.GetLastName(INetURLObject::DecodeMechanism::WithCharset);
+    aObj.removeSegment();
+    OUString sPath = aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+    int nIsFolder = impl_isFolder( _rPath );
+    if ( nIsFolder == 0 ||
+         ( nIsFolder == -1 && impl_isFolder( sPath ) == 1 ) )
+    {
+        mpImpl->setFileName( sFileName );
+        mpImpl->displayFolder( sPath );
+    }
+    else
+    {
+        INetURLObject aObjPathName( _rPath );
+        OUString sFolder( aObjPathName.GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
+        if ( sFolder.isEmpty() )
+        {
+            // _rPath is not a valid path -> fallback to home directory
+            osl::Security aSecurity;
+            aSecurity.getHomeDir( sFolder );
+        }
+        mpImpl->displayFolder( sFolder );
+    }
+}
+
+void FileDialogHelper::SetDisplayFolder( const OUString& _rURL )
+{
+    mpImpl->displayFolder( _rURL );
+}
+
+void FileDialogHelper::SetFileName( const OUString& _rFileName )
+{
+    mpImpl->setFileName( _rFileName );
+}
+
+void FileDialogHelper::AddFilter( const OUString& rFilterName,
+                                  const OUString& rExtension )
+{
+    mpImpl->addFilter( rFilterName, rExtension );
+}
+
+void FileDialogHelper::SetCurrentFilter( const OUString& rFilter )
+{
+    OUString sFilter( rFilter );
+    if ( mpImpl->isShowFilterExtensionEnabled() )
+        sFilter = mpImpl->getFilterWithExtension( rFilter );
+    mpImpl->setFilter( sFilter );
+}
+
+const uno::Reference < XFilePicker3 >& FileDialogHelper::GetFilePicker() const
+{
+    return mpImpl->mxFileDlg;
+}
+
+// XFilePickerListener Methods
+void FileDialogHelper::FileSelectionChanged()
+{
+    mpImpl->handleFileSelectionChanged();
+}
+
+void FileDialogHelper::DirectoryChanged()
+{
+    mpImpl->handleDirectoryChanged();
+}
+
+OUString FileDialogHelper::HelpRequested( const FilePickerEvent& aEvent )
+{
+    return sfx2::FileDialogHelper_Impl::handleHelpRequested( aEvent );
+}
+
+void FileDialogHelper::ControlStateChanged( const FilePickerEvent& aEvent )
+{
+    mpImpl->handleControlStateChanged( aEvent );
+}
+
+void FileDialogHelper::DialogSizeChanged()
+{
+    mpImpl->handleDialogSizeChanged();
+}
+
+void FileDialogHelper::DialogClosed( const DialogClosedEvent& _rEvent )
+{
+    m_nError = ( RET_OK == _rEvent.DialogResult ) ? ERRCODE_NONE : ERRCODE_ABORT;
+    m_aDialogClosedLink.Call( this );
+}
+
+ErrCode FileOpenDialog_Impl( weld::Window* pParent,
+                             sal_Int16 nDialogType,
+                             FileDialogFlags nFlags,
+                             std::vector<OUString>& rpURLList,
+                             OUString& rFilter,
+                             std::unique_ptr<SfxItemSet>& rpSet,
+                             const OUString* pPath,
+                             sal_Int16 nDialog,
+                             const OUString& rStandardDir,
+                             const css::uno::Sequence< OUString >& rBlackList )
+{
+    ErrCode nRet;
+    std::unique_ptr<FileDialogHelper> pDialog;
+    // Sign existing PDF: only works with PDF files and they are opened
+    // read-only to discourage editing (which would invalidate existing
+    // signatures).
+    if (nFlags & FileDialogFlags::SignPDF)
+        pDialog.reset(new FileDialogHelper(nDialogType, nFlags, SfxResId(STR_SFX_FILTERNAME_PDF), "pdf", rStandardDir, rBlackList, pParent));
+    else
+        pDialog.reset(new FileDialogHelper(nDialogType, nFlags, OUString(), nDialog, SfxFilterFlags::NONE, SfxFilterFlags::NONE, rStandardDir, rBlackList, pParent));
+
+    OUString aPath;
+    if ( pPath )
+        aPath = *pPath;
+
+    nRet = pDialog->Execute(rpURLList, rpSet, rFilter, aPath);
+    DBG_ASSERT( rFilter.indexOf(": ") == -1, "Old filter name used!");
+
+    if (rpSet && nFlags & FileDialogFlags::SignPDF)
+        rpSet->Put(SfxBoolItem(SID_DOC_READONLY, true));
+    return nRet;
+}
+
+ErrCode RequestPassword(const std::shared_ptr<const SfxFilter>& pCurrentFilter, OUString const & aURL, SfxItemSet* pSet, const css::uno::Reference<css::awt::XWindow>& rParent)
+{
+    uno::Reference<task::XInteractionHandler2> xInteractionHandler = task::InteractionHandler::createWithParent(::comphelper::getProcessComponentContext(), rParent);
+    // TODO: need a save way to distinguish MS filters from other filters
+    // for now MS-filters are the only alien filters that support encryption
+    const bool bMSType = !pCurrentFilter->IsOwnFormat();
+    // For OOXML we can use the standard password ("unlimited" characters)
+    // request, otherwise the MS limited password request is needed.
+    const bool bOOXML = bMSType && lclSupportsOOXMLEncryption( pCurrentFilter->GetFilterName());
+    const ::comphelper::DocPasswordRequestType eType = bMSType && !bOOXML ?
+        ::comphelper::DocPasswordRequestType::MS :
+        ::comphelper::DocPasswordRequestType::Standard;
+
+    ::rtl::Reference< ::comphelper::DocPasswordRequest > pPasswordRequest( new ::comphelper::DocPasswordRequest( eType, css::task::PasswordRequestMode_PASSWORD_CREATE, aURL, bool( pCurrentFilter->GetFilterFlags() & SfxFilterFlags::PASSWORDTOMODIFY ) ) );
+
+    uno::Reference< css::task::XInteractionRequest > rRequest( pPasswordRequest.get() );
+    do
+    {
+        xInteractionHandler->handle( rRequest );
+        if (!pPasswordRequest->isPassword() || bMSType)
+        {
+            break;
+        }
+        OString const utf8Pwd(OUStringToOString(pPasswordRequest->getPassword(), RTL_TEXTENCODING_UTF8));
+        OString const utf8Ptm(OUStringToOString(pPasswordRequest->getPasswordToModify(), RTL_TEXTENCODING_UTF8));
+        if (!(52 <= utf8Pwd.getLength() && utf8Pwd.getLength() <= 55
+                && SvtSaveOptions().GetODFSaneDefaultVersion() < SvtSaveOptions::ODFSVER_012)
+            && !(52 <= utf8Ptm.getLength() && utf8Ptm.getLength() <= 55))
+        {
+            break;
+        }
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(Application::GetFrameWeld(rParent), VclMessageType::Warning,
+            VclButtonsType::Ok, SfxResId(STR_PASSWORD_LEN)));
+        xBox->set_secondary_text(SfxResId(STR_PASSWORD_WARNING));
+        xBox->run();
+    }
+    while (true);
+    if ( pPasswordRequest->isPassword() )
+    {
+        if ( pPasswordRequest->getPassword().getLength() )
+        {
+            css::uno::Sequence< css::beans::NamedValue > aEncryptionData;
+
+            // TODO/LATER: The filters should show the password dialog themself in future
+            if ( bMSType )
+            {
+                if (bOOXML)
+                {
+                    ::comphelper::SequenceAsHashMap aHashData;
+                    aHashData[ OUString( "OOXPassword" ) ] <<= pPasswordRequest->getPassword();
+                    aHashData[ OUString( "CryptoType" ) ] <<= OUString( "Standard" );
+                    aEncryptionData = aHashData.getAsConstNamedValueList();
+                }
+                else
+                {
+                    uno::Sequence< sal_Int8 > aUniqueID = ::comphelper::DocPasswordHelper::GenerateRandomByteSequence( 16 );
+                    uno::Sequence< sal_Int8 > aEncryptionKey = ::comphelper::DocPasswordHelper::GenerateStd97Key( pPasswordRequest->getPassword(), aUniqueID );
+
+                    if ( aEncryptionKey.hasElements() )
+                    {
+                        ::comphelper::SequenceAsHashMap aHashData;
+                        aHashData[ OUString( "STD97EncryptionKey"  ) ] <<= aEncryptionKey;
+                        aHashData[ OUString( "STD97UniqueID"  ) ] <<= aUniqueID;
+
+                        aEncryptionData = aHashData.getAsConstNamedValueList();
+                    }
+                    else
+                    {
+                        return ERRCODE_IO_NOTSUPPORTED;
+                    }
+                }
+            }
+
+            // tdf#118639: We need ODF encryption data for autorecovery where password will already
+            // be unavailable, even for non-ODF documents, so append it here unconditionally
+            pSet->Put(SfxUnoAnyItem(
+                SID_ENCRYPTIONDATA,
+                uno::makeAny(comphelper::concatSequences(
+                    aEncryptionData, comphelper::OStorageHelper::CreatePackageEncryptionData(
+                                         pPasswordRequest->getPassword())))));
+        }
+
+        if ( pPasswordRequest->getRecommendReadOnly() )
+            pSet->Put( SfxBoolItem( SID_RECOMMENDREADONLY, true ) );
+
+        if ( bMSType )
+        {
+            // the empty password has 0 as Hash
+            sal_Int32 nHash = SfxMedium::CreatePasswordToModifyHash( pPasswordRequest->getPasswordToModify(),
+                                                                     pCurrentFilter->GetServiceName() == "com.sun.star.text.TextDocument" );
+            if ( nHash )
+                pSet->Put( SfxUnoAnyItem( SID_MODIFYPASSWORDINFO, uno::makeAny( nHash ) ) );
+        }
+        else
+        {
+            uno::Sequence< beans::PropertyValue > aModifyPasswordInfo = ::comphelper::DocPasswordHelper::GenerateNewModifyPasswordInfo( pPasswordRequest->getPasswordToModify() );
+            if ( aModifyPasswordInfo.hasElements() )
+                pSet->Put( SfxUnoAnyItem( SID_MODIFYPASSWORDINFO, uno::makeAny( aModifyPasswordInfo ) ) );
+        }
+    }
+    else
+        return ERRCODE_ABORT;
+    return ERRCODE_NONE;
+}
+
+OUString EncodeSpaces_Impl( const OUString& rSource )
+{
+    OUString sRet = rSource.replaceAll( " ", "%20" );
+    return sRet;
+}
+
+OUString DecodeSpaces_Impl( const OUString& rSource )
+{
+    OUString sRet = rSource.replaceAll( "%20", " " );
+    return sRet;
+}
+
+}   // end of namespace sfx2
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/filedlgimpl.hxx b/sfx2/source/dialog/filedlgimpl.hxx
new file mode 100644
index 000000000..c0ddb5545
--- /dev/null
+++ b/sfx2/source/dialog/filedlgimpl.hxx
@@ -0,0 +1,219 @@
+/* -*- 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_DIALOG_FILEDLGIMPL_HXX
+#define INCLUDED_SFX2_SOURCE_DIALOG_FILEDLGIMPL_HXX
+
+#include <vcl/timer.hxx>
+#include <vcl/idle.hxx>
+#include <vcl/graph.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <com/sun/star/beans/StringPair.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/ui/dialogs/XFilePickerListener.hpp>
+#include <com/sun/star/ui/dialogs/XDialogClosedListener.hpp>
+#include <sfx2/fcontnr.hxx>
+#include <sfx2/filedlghelper.hxx>
+
+class SfxFilterMatcher;
+class GraphicFilter;
+class FileDialogHelper;
+struct ImplSVEvent;
+
+namespace sfx2
+{
+    class FileDialogHelper_Impl :
+        public ::cppu::WeakImplHelper<
+            css::ui::dialogs::XFilePickerListener,
+            css::ui::dialogs::XDialogClosedListener >
+    {
+        friend class FileDialogHelper;
+
+        css::uno::Reference < css::ui::dialogs::XFilePicker3 > mxFileDlg;
+        css::uno::Reference < css::container::XNameAccess >   mxFilterCFG;
+
+        std::vector< css::beans::StringPair >   maFilters;
+
+        SfxFilterMatcher*           mpMatcher;
+        std::unique_ptr<GraphicFilter> mpGraphicFilter;
+        FileDialogHelper*           mpAntiImpl;
+        weld::Window*               mpFrameWeld;
+
+        ::std::vector< OUString > mlLastURLs;
+
+        OUString             maPath;
+        OUString             maFileName;
+        OUString             maCurFilter;
+        OUString             maSelectFilter;
+        OUString             maButtonLabel;
+
+        Idle                        maPreviewIdle;
+        Graphic                     maGraphic;
+
+        const short                 m_nDialogType;
+
+        SfxFilterFlags              m_nMustFlags;
+        SfxFilterFlags              m_nDontFlags;
+
+        ImplSVEvent *               mnPostUserEventId;
+
+        FileDialogHelper::Context   meContext;
+
+        bool                    mbHasPassword           : 1;
+        bool                    mbIsPwdEnabled          : 1;
+        bool                    m_bHaveFilterOptions    : 1;
+        bool                    mbHasVersions           : 1;
+        bool                    mbHasAutoExt            : 1;
+        bool                    mbHasPreview            : 1;
+        bool                    mbShowPreview           : 1;
+        bool                    mbIsSaveDlg             : 1;
+        bool                    mbExport                : 1;
+
+        bool                    mbDeleteMatcher         : 1;
+        bool                    mbInsert                : 1;
+        bool                    mbSystemPicker          : 1;
+        bool                    mbPwdCheckBoxState      : 1;
+        bool                    mbSelection             : 1;
+        bool                    mbSelectionEnabled      : 1;
+        bool                    mbHasSelectionBox       : 1;
+        bool                    mbSelectionFltrEnabled  : 1;
+
+    private:
+        void                    addFilters( const OUString& rFactory,
+                                            SfxFilterFlags nMust,
+                                            SfxFilterFlags nDont );
+        void                    addFilter( const OUString& rFilterName,
+                                           const OUString& rExtension );
+        void                    addGraphicFilter();
+        void                    enablePasswordBox( bool bInit );
+        void                    updateFilterOptionsBox();
+        void                    updateExportButton();
+        void                    updateSelectionBox();
+        void                    updateVersions();
+        void                    updatePreviewState( bool _bUpdatePreviewWindow );
+        void                    dispose();
+
+        void                    loadConfig();
+        void                    saveConfig();
+
+        std::shared_ptr<const SfxFilter>        getCurentSfxFilter();
+        bool                updateExtendedControl( sal_Int16 _nExtendedControlId, bool _bEnable );
+
+        ErrCode                 getGraphic( const OUString& rURL, Graphic& rGraphic ) const;
+        void                    setDefaultValues();
+
+        void                    preExecute();
+        void                    postExecute( sal_Int16 _nResult );
+        sal_Int16               implDoExecute();
+        void                    implStartExecute();
+
+        void                    setControlHelpIds( const sal_Int16* _pControlId, const char** _pHelpId );
+
+        bool                    CheckFilterOptionsCapability( const std::shared_ptr<const SfxFilter>& _pFilter );
+
+        bool                    isInOpenMode() const;
+        OUString                getCurrentFilterUIName() const;
+
+        void                    LoadLastUsedFilter( const OUString& _rContextIdentifier );
+        void                    SaveLastUsedFilter();
+
+        void                    implInitializeFileName( );
+
+        void                    verifyPath( );
+
+        void                    implGetAndCacheFiles( const css::uno::Reference< XInterface >& xPicker  ,
+                                                      std::vector<OUString>&                   rpURLList,
+                                                      const std::shared_ptr<const SfxFilter>&  pFilter  );
+
+        DECL_LINK( TimeOutHdl_Impl, Timer *, void);
+        DECL_LINK( InitControls, void*, void );
+
+    public:
+        // XFilePickerListener methods
+        virtual void SAL_CALL               fileSelectionChanged( const css::ui::dialogs::FilePickerEvent& aEvent ) override;
+        virtual void SAL_CALL               directoryChanged( const css::ui::dialogs::FilePickerEvent& aEvent ) override;
+        virtual OUString SAL_CALL           helpRequested( const css::ui::dialogs::FilePickerEvent& aEvent ) override;
+        virtual void SAL_CALL               controlStateChanged( const css::ui::dialogs::FilePickerEvent& aEvent ) override;
+        virtual void SAL_CALL               dialogSizeChanged() override;
+
+        // XDialogClosedListener methods
+        virtual void SAL_CALL               dialogClosed( const css::ui::dialogs::DialogClosedEvent& _rEvent ) override;
+
+        // XEventListener methods
+        virtual void SAL_CALL       disposing( const css::lang::EventObject& Source ) override;
+
+        // handle XFilePickerListener events
+        void                    handleFileSelectionChanged();
+        void                    handleDirectoryChanged();
+        static OUString         handleHelpRequested( const css::ui::dialogs::FilePickerEvent& aEvent );
+        void                    handleControlStateChanged( const css::ui::dialogs::FilePickerEvent& aEvent );
+        void                    handleDialogSizeChanged();
+
+        // Own methods
+                                FileDialogHelper_Impl(
+                                    FileDialogHelper* _pAntiImpl,
+                                    const sal_Int16 nDialogType,
+                                    FileDialogFlags nFlags,
+                                    sal_Int16 nDialog,
+                                    weld::Window* pFrameWeld,
+                                    const OUString& sStandardDir = OUString(),
+                                    const css::uno::Sequence< OUString >&   rBlackList = css::uno::Sequence< OUString >()
+                                );
+        virtual                 ~FileDialogHelper_Impl() override;
+
+        ErrCode                 execute( std::vector<OUString>& rpURLList,
+                                         std::unique_ptr<SfxItemSet>& rpSet,
+                                         OUString&       rFilter );
+        ErrCode                 execute();
+
+        void                    setFilter( const OUString& rFilter );
+
+        /** sets the directory which should be browsed
+
+            <p>If the given path does not point to a valid (existent and accessible) folder, the request
+            is silently dropped</p>
+        */
+        void                    displayFolder( const OUString& rPath );
+        void                    setFileName( const OUString& _rFile );
+
+        OUString                getPath() const;
+        OUString                getFilter() const;
+        void                    getRealFilter( OUString& _rFilter ) const;
+
+        ErrCode                 getGraphic( Graphic& rGraphic ) const;
+        void                    createMatcher( const OUString& rFactory );
+
+        bool                    isShowFilterExtensionEnabled() const;
+        void                    addFilterPair( const OUString& rFilter,
+                                               const OUString& rFilterWithExtension );
+        OUString                getFilterName( const OUString& rFilterWithExtension ) const;
+        OUString                getFilterWithExtension( const OUString& rFilter ) const;
+
+        void                    SetContext( FileDialogHelper::Context _eNewContext );
+
+        bool             isSystemFilePicker() const { return mbSystemPicker; }
+        bool             isPasswordEnabled() const { return mbIsPwdEnabled; }
+
+        css::uno::Reference<css::awt::XWindow> GetFrameInterface();
+    };
+
+}   // end of namespace sfx2
+
+#endif // INCLUDED_SFX2_SOURCE_DIALOG_FILEDLGIMPL_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/filtergrouping.cxx b/sfx2/source/dialog/filtergrouping.cxx
new file mode 100644
index 000000000..85505f644
--- /dev/null
+++ b/sfx2/source/dialog/filtergrouping.cxx
@@ -0,0 +1,1166 @@
+/* -*- 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 "filtergrouping.hxx"
+#include <sfx2/fcontnr.hxx>
+#include <sfx2/filedlghelper.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/docfilt.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sal/log.hxx>
+#include <com/sun/star/ui/dialogs/XFilterGroupManager.hpp>
+#include <com/sun/star/beans/StringPair.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <unotools/confignode.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <comphelper/sequence.hxx>
+#include <comphelper/string.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/debug.hxx>
+
+#include <list>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+
+namespace sfx2
+{
+
+
+    using namespace ::com::sun::star::uno;
+    using namespace ::com::sun::star::ui::dialogs;
+    using namespace ::com::sun::star::lang;
+    using namespace ::com::sun::star::beans;
+    using namespace ::utl;
+
+
+    /**
+
+    Some general words about what's going on here...
+
+    <p>In our file open dialog, usually we display every filter we know. That's how it was before: every filter
+    lead to an own line in the filter list box, e.g. "StarWriter 5.0 Document" or "Microsoft Word 97".</p>
+
+    <p>But then the PM came. And everything changed...</p>
+
+    <p>A basic idea are groups: Why simply listing all the single filters? Couldn't we draw nice separators
+    between the filters which logically belong together? I.e. all the filters which open a document in StarWriter:
+    couldn't we separate them from all the filters which open the document in StarCalc?<br/>
+    So spoke the PM, and engineering obeyed.</p>
+
+    <p>So we have groups. They're just a visual aspect: All the filters of a group are presented together, separated
+    by a line from other groups.</p>
+
+    <p>Let's be honest: How the concrete implementation of the file picker service separates the different groups
+    is a matter of this implementation. We only do this grouping and suggest it to the FilePicker service ...</p>
+
+    <p>Now for the second concept:<br/>
+    Thinking about it (and that's what the PM did), both "StarWriter 5.0 Document" and "Microsoft Word 97"
+    describe a text document. It's a text. It's of no interest for the user that one of the texts was saved in
+    MS' format, and one in our own format.<br/>
+    So in a first step, we want to have a filter entry "Text documents". This would cover both above-mentioned
+    filters, as well as any other filters for documents which are texts.</p>
+
+    <p>Such an entry as "Text documents" is - within the scope of this file - called "class" or "filter class".</p>
+
+    <p>In the file-open-dialog, such a class looks like an ordinary filter: it's simply a name in the filter
+    listbox. Selecting means that all the files matching one of the "sub-filters" are displayed (in the example above,
+    this would be "*.sdw", "*.doc" and so on).</p>
+
+    <p>Now there are two types of filter classes: global ones and local ones. "Text documents" is a global class. As
+    well as "Spreadsheets". Or "Web pages".<br/>
+    Let's have a look at a local class: The filters "MS Word 95" and "MS WinWord 6.0" together form the class
+    "Microsoft Word 6.0 / 95" (don't ask for the reasons. At least not me. Ask the PM). There are a lot of such
+    local classes ...</p>
+
+    <p>The difference between global and local classes is as follows: Global classes are presented in an own group.
+    There is one dedicated group at the top of the list, containing all the global groups - no local groups and no
+    single filters.</p>
+
+    <p>Ehm - it was a lie. Not really at the top. Before this group, there is this single "All files" entry. It forms
+    its own group. But this is uninteresting here.</p>
+
+    <p>Local classes must consist of filters which - without the classification - would all belong to the same group.
+    Then, they're combined to one entry (in the example above: "Microsoft Word 6.0 / 95"), and this entry is inserted
+    into the file picker filter list, instead of the single filters which form the class.</p>
+
+    <p>This is an interesting difference between local and global classes: Filters which are part of a global class
+    are listed in their own group, too. Filters in local classes aren't listed a second time - neither directly (as
+    the filter itself) nor indirectly (as part of another local group).</p>
+
+    <p>The only exception are filters which are part of a global class <em>and</em> a local class. This is allowed.
+    Being contained in two local classes isn't.</p>
+
+    <p>So that's all what you need to know: Understand the concept of "filter classes" (a filter class combines
+    different filters and acts as if it's a filter itself) and the concept of groups (a group just describes a
+    logical correlation of filters and usually is represented to the user by drawing group separators in the filter
+    list).</p>
+
+    <p>If you got it, go try understanding this file :).</p>
+
+    */
+
+
+    typedef StringPair                          FilterDescriptor;   // a single filter or a filter class (display name and filter mask)
+    typedef ::std::list< FilterDescriptor >     FilterGroup;        // a list of single filter entries
+    typedef ::std::list< FilterGroup >          GroupedFilterList;  // a list of all filters, already grouped
+
+    /// the logical name of a filter
+    typedef OUString                     FilterName;
+
+    // a struct which holds references from a logical filter name to a filter group entry
+    // used for quick lookup of classes (means class entries - entries representing a class)
+    // which a given filter may belong to
+    typedef ::std::map< OUString, FilterGroup::iterator >    FilterGroupEntryReferrer;
+
+    namespace {
+
+    /// a descriptor for a filter class (which in the final dialog is represented by one filter entry)
+    struct FilterClass
+    {
+        OUString             sDisplayName;       // the display name
+        Sequence< FilterName >      aSubFilters;        // the (logical) names of the filter which belong to the class
+    };
+
+    }
+
+    typedef ::std::list< FilterClass >                                  FilterClassList;
+    typedef ::std::map< OUString, FilterClassList::iterator >    FilterClassReferrer;
+
+
+// = reading of configuration data
+
+
+    static void lcl_ReadFilterClass( const OConfigurationNode& _rClassesNode, const OUString& _rLogicalClassName,
+        FilterClass& /* [out] */ _rClass )
+    {
+            // the description node for the current class
+        OConfigurationNode aClassDesc = _rClassesNode.openNode( _rLogicalClassName );
+
+        // the values
+        aClassDesc.getNodeValue( "DisplayName" ) >>= _rClass.sDisplayName;
+        aClassDesc.getNodeValue( "Filters" ) >>= _rClass.aSubFilters;
+    }
+
+    namespace {
+
+    struct CreateEmptyClassRememberPos
+    {
+    protected:
+        FilterClassList&        m_rClassList;
+        FilterClassReferrer&    m_rClassesReferrer;
+
+    public:
+        CreateEmptyClassRememberPos( FilterClassList& _rClassList, FilterClassReferrer& _rClassesReferrer )
+            :m_rClassList       ( _rClassList )
+            ,m_rClassesReferrer ( _rClassesReferrer )
+        {
+        }
+
+        // operate on a single class name
+        void operator() ( const FilterName& _rLogicalFilterName )
+        {
+            // insert a new (empty) class
+            m_rClassList.emplace_back( );
+            // get the position of this new entry
+            FilterClassList::iterator aInsertPos = m_rClassList.end();
+            --aInsertPos;
+            // remember this position
+            m_rClassesReferrer.emplace( _rLogicalFilterName, aInsertPos );
+        }
+    };
+
+
+    struct ReadGlobalFilter
+    {
+    protected:
+        OConfigurationNode      m_aClassesNode;
+        FilterClassReferrer&    m_aClassReferrer;
+
+    public:
+        ReadGlobalFilter( const OConfigurationNode& _rClassesNode, FilterClassReferrer& _rClassesReferrer )
+            :m_aClassesNode     ( _rClassesNode )
+            ,m_aClassReferrer   ( _rClassesReferrer )
+        {
+        }
+
+        // operate on a single logical name
+        void operator() ( const FilterName& _rName )
+        {
+            FilterClassReferrer::iterator aClassRef = m_aClassReferrer.find( _rName );
+            if ( m_aClassReferrer.end() == aClassRef )
+            {
+                // we do not know this global class
+                OSL_FAIL( "ReadGlobalFilter::operator(): unknown filter name!" );
+                // TODO: perhaps we should be more tolerant - at the moment, the filter is dropped
+                // We could silently push_back it to the container...
+            }
+            else
+            {
+                // read the data of this class into the node referred to by aClassRef
+                lcl_ReadFilterClass( m_aClassesNode, _rName, *aClassRef->second );
+            }
+        }
+    };
+
+    }
+
+    static void lcl_ReadGlobalFilters( const OConfigurationNode& _rFilterClassification, FilterClassList& _rGlobalClasses, std::vector<OUString>& _rGlobalClassNames )
+    {
+        _rGlobalClasses.clear();
+        _rGlobalClassNames.clear();
+
+        // get the list describing the order of all global classes
+        Sequence< OUString > aGlobalClasses;
+        _rFilterClassification.getNodeValue( "GlobalFilters/Order" ) >>= aGlobalClasses;
+
+        // copy the logical names
+        comphelper::sequenceToContainer(_rGlobalClassNames, aGlobalClasses);
+
+        // Global classes are presented in an own group, so their order matters (while the order of the
+        // "local classes" doesn't).
+        // That's why we can't simply add the global classes to _rGlobalClasses using the order in which they
+        // are returned from the configuration - it is completely undefined, and we need a _defined_ order.
+        FilterClassReferrer aClassReferrer;
+        ::std::for_each(
+            aGlobalClasses.begin(),
+            aGlobalClasses.end(),
+            CreateEmptyClassRememberPos( _rGlobalClasses, aClassReferrer )
+        );
+            // now _rGlobalClasses contains a dummy entry for each global class,
+            // while aClassReferrer maps from the logical name of the class to the position within _rGlobalClasses where
+            // it's dummy entry resides
+
+
+        // go for all the single class entries
+        OConfigurationNode aFilterClassesNode =
+            _rFilterClassification.openNode( "GlobalFilters/Classes" );
+        Sequence< OUString > aFilterClasses = aFilterClassesNode.getNodeNames();
+        ::std::for_each(
+            aFilterClasses.begin(),
+            aFilterClasses.end(),
+            ReadGlobalFilter( aFilterClassesNode, aClassReferrer )
+        );
+    }
+
+    namespace {
+
+    struct ReadLocalFilter
+    {
+    protected:
+        OConfigurationNode      m_aClassesNode;
+        FilterClassList&        m_rClasses;
+
+    public:
+        ReadLocalFilter( const OConfigurationNode& _rClassesNode, FilterClassList& _rClasses )
+            :m_aClassesNode ( _rClassesNode )
+            ,m_rClasses     ( _rClasses )
+        {
+        }
+
+        // operate on a single logical name
+        void operator() ( const FilterName& _rName )
+        {
+            // read the data for this class
+            FilterClass aClass;
+            lcl_ReadFilterClass( m_aClassesNode, _rName, aClass );
+
+            // insert the class descriptor
+            m_rClasses.push_back( aClass );
+        }
+    };
+
+    }
+
+    static void lcl_ReadLocalFilters( const OConfigurationNode& _rFilterClassification, FilterClassList& _rLocalClasses )
+    {
+        _rLocalClasses.clear();
+
+        // the node for the local classes
+        OConfigurationNode aFilterClassesNode =
+            _rFilterClassification.openNode( "LocalFilters/Classes" );
+        Sequence< OUString > aFilterClasses = aFilterClassesNode.getNodeNames();
+
+        ::std::for_each(
+            aFilterClasses.begin(),
+            aFilterClasses.end(),
+            ReadLocalFilter( aFilterClassesNode, _rLocalClasses )
+        );
+    }
+
+
+    static void lcl_ReadClassification( FilterClassList& _rGlobalClasses, std::vector<OUString>& _rGlobalClassNames, FilterClassList& _rLocalClasses )
+    {
+
+        // open our config node
+        OConfigurationTreeRoot aFilterClassification = OConfigurationTreeRoot::createWithComponentContext(
+            ::comphelper::getProcessComponentContext(),
+            "org.openoffice.Office.UI/FilterClassification",
+            -1,
+            OConfigurationTreeRoot::CM_READONLY
+        );
+
+
+        // go for the global classes
+        lcl_ReadGlobalFilters( aFilterClassification, _rGlobalClasses, _rGlobalClassNames );
+
+
+        // go for the local classes
+        lcl_ReadLocalFilters( aFilterClassification, _rLocalClasses );
+
+    }
+
+
+// = grouping and classifying
+
+    namespace {
+
+    // a struct which adds helps remembering a reference to a class entry
+    struct ReferToFilterEntry
+    {
+    protected:
+        FilterGroupEntryReferrer&   m_rEntryReferrer;
+        FilterGroup::iterator       m_aClassPos;
+
+    public:
+        ReferToFilterEntry( FilterGroupEntryReferrer& _rEntryReferrer, const FilterGroup::iterator& _rClassPos )
+            :m_rEntryReferrer( _rEntryReferrer )
+            ,m_aClassPos( _rClassPos )
+        {
+        }
+
+        // operate on a single filter name
+        void operator() ( const FilterName& _rName )
+        {
+            ::std::pair< FilterGroupEntryReferrer::iterator, bool > aInsertRes =
+            m_rEntryReferrer.emplace( _rName, m_aClassPos );
+            SAL_WARN_IF(
+                !aInsertRes.second, "sfx.dialog",
+                "already have an element for " << _rName);
+        }
+    };
+
+
+    struct FillClassGroup
+    {
+    protected:
+        FilterGroup&                m_rClassGroup;
+        FilterGroupEntryReferrer&   m_rClassReferrer;
+
+    public:
+        FillClassGroup( FilterGroup& _rClassGroup, FilterGroupEntryReferrer& _rClassReferrer )
+            :m_rClassGroup      ( _rClassGroup )
+            ,m_rClassReferrer   ( _rClassReferrer )
+        {
+        }
+
+        // operate on a single class
+        void operator() ( const FilterClass& _rClass )
+        {
+            // create an empty filter descriptor for the class
+            FilterDescriptor aClassEntry;
+            // set its name (which is all we know by now)
+            aClassEntry.First = _rClass.sDisplayName;
+
+            // add it to the group
+            m_rClassGroup.push_back( aClassEntry );
+            // the position of the newly added class
+            FilterGroup::iterator aClassEntryPos = m_rClassGroup.end();
+            --aClassEntryPos;
+
+            // and for all the sub filters of the class, remember the class
+            // (respectively the position of the class it the group)
+            ::std::for_each(
+                _rClass.aSubFilters.begin(),
+                _rClass.aSubFilters.end(),
+                ReferToFilterEntry( m_rClassReferrer, aClassEntryPos )
+            );
+        }
+    };
+
+    }
+
+    static const sal_Unicode s_cWildcardSeparator( ';' );
+
+    static OUString getSeparatorString()
+    {
+        return ";";
+    }
+
+    namespace {
+
+    struct CheckAppendSingleWildcard
+    {
+        OUString& _rToBeExtended;
+
+        explicit CheckAppendSingleWildcard( OUString& _rBase ) : _rToBeExtended( _rBase ) { }
+
+        void operator() ( const OUString& _rWC )
+        {
+            // check for double wildcards
+            sal_Int32 nExistentPos = _rToBeExtended.indexOf( _rWC );
+            if  ( -1 < nExistentPos )
+            {   // found this wildcard (already part of _rToBeExtended)
+                if  (   ( 0 == nExistentPos )
+                    ||  ( s_cWildcardSeparator == _rToBeExtended[ nExistentPos - 1 ] )
+                    )
+                {   // the wildcard really starts at this position (it starts at pos 0 or the previous character is a separator
+                    sal_Int32 nExistentWCEnd = nExistentPos + _rWC.getLength();
+                    if  (   ( _rToBeExtended.getLength() == nExistentWCEnd )
+                        ||  ( s_cWildcardSeparator == _rToBeExtended[ nExistentWCEnd ] )
+                        )
+                    {   // it's really the complete wildcard we found
+                        // (not something like _rWC being "*.t" and _rToBeExtended containing "*.txt")
+                        // -> outta here
+                        return;
+                    }
+                }
+            }
+
+            if ( !_rToBeExtended.isEmpty() )
+                _rToBeExtended += getSeparatorString();
+            _rToBeExtended += _rWC;
+        }
+    };
+
+
+    // a helper struct which adds a fixed (Sfx-)filter to a filter group entry given by iterator
+    struct AppendWildcardToDescriptor
+    {
+    protected:
+        ::std::vector< OUString > aWildCards;
+
+    public:
+        explicit AppendWildcardToDescriptor( const OUString& _rWildCard );
+
+        // operate on a single class entry
+        void operator() ( const FilterGroupEntryReferrer::value_type& _rClassReference )
+        {
+            // simply add our wildcards
+            ::std::for_each(
+                aWildCards.begin(),
+                aWildCards.end(),
+                CheckAppendSingleWildcard( _rClassReference.second->Second )
+            );
+        }
+    };
+
+    }
+
+    AppendWildcardToDescriptor::AppendWildcardToDescriptor( const OUString& _rWildCard )
+    {
+        DBG_ASSERT( !_rWildCard.isEmpty(),
+            "AppendWildcardToDescriptor::AppendWildcardToDescriptor: invalid wildcard!" );
+        DBG_ASSERT( _rWildCard.isEmpty() || _rWildCard[0] != s_cWildcardSeparator,
+            "AppendWildcardToDescriptor::AppendWildcardToDescriptor: wildcard already separated!" );
+
+        aWildCards.reserve( comphelper::string::getTokenCount(_rWildCard, s_cWildcardSeparator) );
+
+        const sal_Unicode* pTokenLoop = _rWildCard.getStr();
+        const sal_Unicode* pTokenLoopEnd = pTokenLoop + _rWildCard.getLength();
+        const sal_Unicode* pTokenStart = pTokenLoop;
+        for ( ; pTokenLoop != pTokenLoopEnd; ++pTokenLoop )
+        {
+            if ( ( s_cWildcardSeparator == *pTokenLoop ) && ( pTokenLoop > pTokenStart ) )
+            {   // found a new token separator (and a non-empty token)
+                aWildCards.emplace_back( pTokenStart, pTokenLoop - pTokenStart );
+
+                // search the start of the next token
+                while ( ( pTokenStart != pTokenLoopEnd ) && ( *pTokenStart != s_cWildcardSeparator ) )
+                    ++pTokenStart;
+
+                if ( pTokenStart == pTokenLoopEnd )
+                    // reached the end
+                    break;
+
+                ++pTokenStart;
+                pTokenLoop = pTokenStart;
+            }
+        }
+        if ( pTokenLoop > pTokenStart )
+            // the last one...
+            aWildCards.emplace_back( pTokenStart, pTokenLoop - pTokenStart );
+    }
+
+
+    static void lcl_InitGlobalClasses( GroupedFilterList& _rAllFilters, const FilterClassList& _rGlobalClasses, FilterGroupEntryReferrer& _rGlobalClassesRef )
+    {
+        // we need an extra group in our "all filters" container
+        _rAllFilters.push_front( FilterGroup() );
+        FilterGroup& rGlobalFilters = _rAllFilters.front();
+            // it's important to work on the reference: we want to access the members of this filter group
+            // by an iterator (FilterGroup::const_iterator)
+        // the referrer for the global classes
+
+        // initialize the group
+        ::std::for_each(
+            _rGlobalClasses.begin(),
+            _rGlobalClasses.end(),
+            FillClassGroup( rGlobalFilters, _rGlobalClassesRef )
+        );
+            // now we have:
+            // in rGlobalFilters: a list of FilterDescriptor's, where each's descriptor's display name is set to the name of a class
+            // in aGlobalClassesRef: a mapping from logical filter names to positions within rGlobalFilters
+            //  this way, if we encounter an arbitrary filter, we can easily (and efficient) check if it belongs to a global class
+            //  and modify the descriptor for this class accordingly
+    }
+
+
+    typedef ::std::vector< ::std::pair< FilterGroupEntryReferrer::mapped_type, FilterGroup::iterator > >
+            MapGroupEntry2GroupEntry;
+            // this is not really a map - it's just called this way because it is used as a map
+
+    namespace {
+
+    struct FindGroupEntry
+    {
+        FilterGroupEntryReferrer::mapped_type aLookingFor;
+        explicit FindGroupEntry( FilterGroupEntryReferrer::mapped_type const & _rLookingFor ) : aLookingFor( _rLookingFor ) { }
+
+        bool operator() ( const MapGroupEntry2GroupEntry::value_type& _rMapEntry )
+        {
+            return _rMapEntry.first == aLookingFor;
+        }
+    };
+
+    struct CopyGroupEntryContent
+    {
+        void operator() ( const MapGroupEntry2GroupEntry::value_type& _rMapEntry )
+        {
+            *_rMapEntry.second = *_rMapEntry.first;
+        }
+    };
+
+
+    struct CopyNonEmptyFilter
+    {
+        FilterGroup& rTarget;
+        explicit CopyNonEmptyFilter( FilterGroup& _rTarget ) :rTarget( _rTarget ) { }
+
+        void operator() ( const FilterDescriptor& _rFilter )
+        {
+            if ( !_rFilter.Second.isEmpty() )
+                rTarget.push_back( _rFilter );
+        }
+    };
+
+    }
+
+    static void lcl_GroupAndClassify( TSortedFilterList& _rFilterMatcher, GroupedFilterList& _rAllFilters )
+    {
+        _rAllFilters.clear();
+
+
+        // read the classification of filters
+        FilterClassList aGlobalClasses, aLocalClasses;
+        std::vector<OUString> aGlobalClassNames;
+        lcl_ReadClassification( aGlobalClasses, aGlobalClassNames, aLocalClasses );
+
+
+        // for the global filter classes
+        FilterGroupEntryReferrer aGlobalClassesRef;
+        lcl_InitGlobalClasses( _rAllFilters, aGlobalClasses, aGlobalClassesRef );
+
+        // insert as much placeholders (FilterGroup's) into _rAllFilter for groups as we have global classes
+        // (this assumes that both numbers are the same, which, speaking strictly, must not hold - but it does, as we know ...)
+        sal_Int32 nGlobalClasses = aGlobalClasses.size();
+        while ( nGlobalClasses-- )
+            _rAllFilters.emplace_back( );
+
+
+        // for the local classes:
+        // if n filters belong to a local class, they do not appear in their respective group explicitly, instead
+        // and entry for the class is added to the group and the extensions of the filters are collected under
+        // this entry
+        FilterGroupEntryReferrer aLocalClassesRef;
+        FilterGroup aCollectedLocals;
+        ::std::for_each(
+            aLocalClasses.begin(),
+            aLocalClasses.end(),
+            FillClassGroup( aCollectedLocals, aLocalClassesRef )
+        );
+        // to map from the position within aCollectedLocals to positions within the real groups
+        // (where they finally belong to)
+        MapGroupEntry2GroupEntry    aLocalFinalPositions;
+
+
+        // now add the filters
+        // the group which we currently work with
+        GroupedFilterList::iterator aCurrentGroup = _rAllFilters.end(); // no current group
+        // the filter container of the current group - if this changes between two filters, a new group is reached
+        OUString aCurrentServiceName;
+
+        OUString sFilterWildcard;
+        OUString sFilterName;
+        // loop through all the filters
+        for ( std::shared_ptr<const SfxFilter> pFilter = _rFilterMatcher.First(); pFilter; pFilter = _rFilterMatcher.Next() )
+        {
+            sFilterName = pFilter->GetFilterName();
+            sFilterWildcard = pFilter->GetWildcard().getGlob();
+            AppendWildcardToDescriptor aExtendWildcard( sFilterWildcard );
+
+            DBG_ASSERT( !sFilterWildcard.isEmpty(), "sfx2::lcl_GroupAndClassify: invalid wildcard of this filter!" );
+
+
+            // check for a change in the group
+            OUString aServiceName = pFilter->GetServiceName();
+            if ( aServiceName != aCurrentServiceName )
+            {   // we reached a new group
+
+                // look for the place in _rAllFilters where this ne group belongs - this is determined
+                // by the order of classes in aGlobalClassNames
+                GroupedFilterList::iterator aGroupPos = _rAllFilters.begin();
+                DBG_ASSERT( aGroupPos != _rAllFilters.end(),
+                    "sfx2::lcl_GroupAndClassify: invalid all-filters array here!" );
+                    // the loop below will work on invalid objects else ...
+                ++aGroupPos;
+                auto aGlobalIter = std::find(aGlobalClassNames.begin(), aGlobalClassNames.end(), aServiceName);
+                auto nGroupPosShift = std::min(
+                    std::distance(aGlobalClassNames.begin(), aGlobalIter),
+                    std::distance(aGroupPos, _rAllFilters.end()));
+                std::advance(aGroupPos, nGroupPosShift);
+                if ( aGroupPos != _rAllFilters.end() )
+                    // we found a global class name which matches the doc service name -> fill the filters of this
+                    // group in the respective prepared group
+                    aCurrentGroup = aGroupPos;
+                else
+                    // insert a new entry in our overall-list
+                    aCurrentGroup = _rAllFilters.insert( _rAllFilters.end(), FilterGroup() );
+
+                // remember the container to properly detect the next group
+                aCurrentServiceName = aServiceName;
+            }
+
+            assert(aCurrentGroup != _rAllFilters.end()); //invalid current group!
+            if (aCurrentGroup == _rAllFilters.end())
+                aCurrentGroup = _rAllFilters.begin();
+
+
+            // check if the filter is part of a global group
+            ::std::pair< FilterGroupEntryReferrer::iterator, FilterGroupEntryReferrer::iterator >
+                aBelongsTo = aGlobalClassesRef.equal_range( sFilterName );
+            // add the filter to the entries for these classes
+            // (if they exist - if not, the range is empty and the for_each is a no-op)
+            ::std::for_each(
+                aBelongsTo.first,
+                aBelongsTo.second,
+                aExtendWildcard
+            );
+
+
+            // add the filter to its group
+
+            // for this, check if the filter is part of a local filter
+            FilterGroupEntryReferrer::iterator aBelongsToLocal = aLocalClassesRef.find( sFilterName );
+            if ( aLocalClassesRef.end() != aBelongsToLocal )
+            {
+                // okay, there is a local class which the filter belongs to
+                // -> append the wildcard
+                aExtendWildcard( *aBelongsToLocal );
+
+                if ( std::none_of( aLocalFinalPositions.begin(), aLocalFinalPositions.end(), FindGroupEntry( aBelongsToLocal->second ) ) )
+                {   // the position within aCollectedLocals has not been mapped to a final position
+                    // within the "real" group (aCollectedLocals is only temporary)
+                    // -> do this now (as we just encountered the first filter belonging to this local class
+                    // add a new entry which is the "real" group entry
+                    aCurrentGroup->push_back( FilterDescriptor( aBelongsToLocal->second->First, OUString() ) );
+                    // the position where we inserted the entry
+                    FilterGroup::iterator aInsertPos = aCurrentGroup->end();
+                    --aInsertPos;
+                    // remember this pos
+                    aLocalFinalPositions.emplace_back( aBelongsToLocal->second, aInsertPos );
+                }
+            }
+            else
+                aCurrentGroup->push_back( FilterDescriptor( pFilter->GetUIName(), sFilterWildcard ) );
+        }
+
+        // now just complete the infos for the local groups:
+        // During the above loop, they have been collected in aCollectedLocals, but this is only temporary
+        // They have to be copied into their final positions (which are stored in aLocalFinalPositions)
+        ::std::for_each(
+            aLocalFinalPositions.begin(),
+            aLocalFinalPositions.end(),
+            CopyGroupEntryContent()
+        );
+
+        // and remove local groups which do not apply - e.g. have no entries due to the limited content of the
+        // current SfxFilterMatcherIter
+
+        FilterGroup& rGlobalFilters = _rAllFilters.front();
+        FilterGroup aNonEmptyGlobalFilters;
+        ::std::for_each(
+            rGlobalFilters.begin(),
+            rGlobalFilters.end(),
+            CopyNonEmptyFilter( aNonEmptyGlobalFilters )
+        );
+        rGlobalFilters.swap( aNonEmptyGlobalFilters );
+    }
+
+    namespace {
+
+    struct AppendFilter
+    {
+        protected:
+            Reference< XFilterManager >         m_xFilterManager;
+            FileDialogHelper_Impl*              m_pFileDlgImpl;
+            bool                                m_bAddExtension;
+
+        public:
+            AppendFilter( const Reference< XFilterManager >& _rxFilterManager,
+                          FileDialogHelper_Impl* _pImpl, bool _bAddExtension ) :
+
+                m_xFilterManager( _rxFilterManager ),
+                m_pFileDlgImpl  ( _pImpl ),
+                m_bAddExtension ( _bAddExtension )
+
+            {
+                DBG_ASSERT( m_xFilterManager.is(), "AppendFilter::AppendFilter: invalid filter manager!" );
+                DBG_ASSERT( m_pFileDlgImpl, "AppendFilter::AppendFilter: invalid filedlg impl!" );
+            }
+
+            // operate on a single filter
+            void operator() ( const FilterDescriptor& _rFilterEntry )
+            {
+                OUString sDisplayText = m_bAddExtension
+                    ? addExtension( _rFilterEntry.First, _rFilterEntry.Second, true, *m_pFileDlgImpl )
+                    : _rFilterEntry.First;
+                m_xFilterManager->appendFilter( sDisplayText, _rFilterEntry.Second );
+            }
+    };
+
+    }
+
+// = handling for the "all files" entry
+
+
+    static bool lcl_hasAllFilesFilter( TSortedFilterList& _rFilterMatcher, OUString& /* [out] */ _rAllFilterName )
+    {
+        bool        bHasAll = false;
+        _rAllFilterName = SfxResId( STR_SFX_FILTERNAME_ALL );
+
+
+        // check if there's already a filter <ALL>
+        for ( std::shared_ptr<const SfxFilter> pFilter = _rFilterMatcher.First(); pFilter && !bHasAll; pFilter = _rFilterMatcher.Next() )
+        {
+            if ( pFilter->GetUIName() == _rAllFilterName )
+                bHasAll = true;
+        }
+        return bHasAll;
+    }
+
+
+    static void lcl_EnsureAllFilesEntry( TSortedFilterList& _rFilterMatcher, GroupedFilterList& _rFilters )
+    {
+
+        OUString sAllFilterName;
+        if ( !lcl_hasAllFilesFilter( _rFilterMatcher, sAllFilterName ) )
+        {
+            // get the first group of filters (by definition, this group contains the global classes)
+            DBG_ASSERT( !_rFilters.empty(), "lcl_EnsureAllFilesEntry: invalid filter list!" );
+            if ( !_rFilters.empty() )
+            {
+                FilterGroup& rGlobalClasses = *_rFilters.begin();
+                rGlobalClasses.push_front( FilterDescriptor( sAllFilterName, FILEDIALOG_FILTER_ALL ) );
+            }
+        }
+    }
+
+
+// = filling an XFilterManager
+
+    namespace {
+
+    struct AppendFilterGroup
+    {
+    protected:
+        Reference< XFilterManager >         m_xFilterManager;
+        Reference< XFilterGroupManager >    m_xFilterGroupManager;
+        FileDialogHelper_Impl*              m_pFileDlgImpl;
+
+    public:
+        AppendFilterGroup( const Reference< XFilterManager >& _rxFilterManager, FileDialogHelper_Impl* _pImpl )
+            :m_xFilterManager       ( _rxFilterManager )
+            ,m_xFilterGroupManager  ( _rxFilterManager, UNO_QUERY )
+            ,m_pFileDlgImpl         ( _pImpl )
+        {
+            DBG_ASSERT( m_xFilterManager.is(), "AppendFilterGroup::AppendFilterGroup: invalid filter manager!" );
+            DBG_ASSERT( m_pFileDlgImpl, "AppendFilterGroup::AppendFilterGroup: invalid filedlg impl!" );
+        }
+
+        void appendGroup( const FilterGroup& _rGroup, bool _bAddExtension )
+        {
+            try
+            {
+                if ( m_xFilterGroupManager.is() )
+                {   // the file dialog implementation supports visual grouping of filters
+                    // create a representation of the group which is understandable by the XFilterGroupManager
+                    if ( !_rGroup.empty() )
+                    {
+                        Sequence< StringPair > aFilters( comphelper::containerToSequence(_rGroup) );
+                        if ( _bAddExtension )
+                        {
+                            for ( StringPair & filter : aFilters )
+                                filter.First = addExtension( filter.First, filter.Second, true, *m_pFileDlgImpl );
+                        }
+                        m_xFilterGroupManager->appendFilterGroup( OUString(), aFilters );
+                    }
+                }
+                else
+                {
+                    ::std::for_each(
+                        _rGroup.begin(),
+                        _rGroup.end(),
+                        AppendFilter( m_xFilterManager, m_pFileDlgImpl, _bAddExtension ) );
+                }
+            }
+            catch( const Exception& )
+            {
+                DBG_UNHANDLED_EXCEPTION("sfx.dialog");
+            }
+        }
+
+        // operate on a single filter group
+        void operator() ( const FilterGroup& _rGroup )
+        {
+            appendGroup( _rGroup, true );
+        }
+    };
+
+    }
+
+    TSortedFilterList::TSortedFilterList(const css::uno::Reference< css::container::XEnumeration >& xFilterList)
+        : m_nIterator(0)
+    {
+        if (!xFilterList.is())
+            return;
+
+        m_lFilters.clear();
+        while(xFilterList->hasMoreElements())
+        {
+            ::comphelper::SequenceAsHashMap lFilterProps (xFilterList->nextElement());
+            OUString                 sFilterName  = lFilterProps.getUnpackedValueOrDefault(
+                                                             "Name",
+                                                             OUString());
+            if (!sFilterName.isEmpty())
+                m_lFilters.push_back(sFilterName);
+        }
+    }
+
+
+    std::shared_ptr<const SfxFilter> TSortedFilterList::First()
+    {
+        m_nIterator = 0;
+        return impl_getFilter(m_nIterator);
+    }
+
+
+    std::shared_ptr<const SfxFilter> TSortedFilterList::Next()
+    {
+        ++m_nIterator;
+        return impl_getFilter(m_nIterator);
+    }
+
+
+    std::shared_ptr<const SfxFilter> TSortedFilterList::impl_getFilter(sal_Int32 nIndex)
+    {
+        if (nIndex<0 || nIndex>=static_cast<sal_Int32>(m_lFilters.size()))
+            return nullptr;
+        const OUString& sFilterName = m_lFilters[nIndex];
+        if (sFilterName.isEmpty())
+            return nullptr;
+        return SfxFilter::GetFilterByName(sFilterName);
+    }
+
+
+    void appendFiltersForSave( TSortedFilterList& _rFilterMatcher,
+                               const Reference< XFilterManager >& _rxFilterManager,
+                               OUString& _rFirstNonEmpty, FileDialogHelper_Impl& _rFileDlgImpl,
+                               const OUString& _rFactory )
+    {
+        DBG_ASSERT( _rxFilterManager.is(), "sfx2::appendFiltersForSave: invalid manager!" );
+        if ( !_rxFilterManager.is() )
+            return;
+
+        OUString sUIName;
+        OUString sExtension;
+
+        // retrieve the default filter for this application module.
+        // It must be set as first of the generated filter list.
+        std::shared_ptr<const SfxFilter> pDefaultFilter = SfxFilterContainer::GetDefaultFilter_Impl(_rFactory);
+        // Only use one extension (#i32434#)
+        // (and always the first if there are more than one)
+        sExtension = pDefaultFilter->GetWildcard().getGlob().getToken(0, ';');
+        sUIName = addExtension( pDefaultFilter->GetUIName(), sExtension, false, _rFileDlgImpl );
+        try
+        {
+            _rxFilterManager->appendFilter( sUIName, sExtension );
+            if ( _rFirstNonEmpty.isEmpty() )
+                _rFirstNonEmpty = sUIName;
+        }
+        catch( const IllegalArgumentException& )
+        {
+            SAL_WARN( "sfx.dialog", "Could not append DefaultFilter" << sUIName );
+        }
+
+        for ( std::shared_ptr<const SfxFilter> pFilter = _rFilterMatcher.First(); pFilter; pFilter = _rFilterMatcher.Next() )
+        {
+            if (pFilter->GetName() == pDefaultFilter->GetName())
+                continue;
+
+            // Only use one extension (#i32434#)
+            // (and always the first if there are more than one)
+            sExtension = pFilter->GetWildcard().getGlob().getToken(0, ';');
+            sUIName = addExtension( pFilter->GetUIName(), sExtension, false, _rFileDlgImpl );
+            try
+            {
+                _rxFilterManager->appendFilter( sUIName, sExtension );
+                if ( _rFirstNonEmpty.isEmpty() )
+                    _rFirstNonEmpty = sUIName;
+            }
+            catch( const IllegalArgumentException& )
+            {
+                SAL_WARN( "sfx.dialog", "Could not append Filter" << sUIName );
+            }
+        }
+    }
+
+    namespace {
+
+    struct ExportFilter
+    {
+        ExportFilter( const OUString& _aUIName, const OUString& _aWildcard ) :
+            aUIName( _aUIName ), aWildcard( _aWildcard ) {}
+
+        OUString aUIName;
+        OUString aWildcard;
+    };
+
+    }
+
+    void appendExportFilters( TSortedFilterList& _rFilterMatcher,
+                              const Reference< XFilterManager >& _rxFilterManager,
+                              OUString& _rFirstNonEmpty, FileDialogHelper_Impl& _rFileDlgImpl )
+    {
+        DBG_ASSERT( _rxFilterManager.is(), "sfx2::appendExportFilters: invalid manager!" );
+        if ( !_rxFilterManager.is() )
+            return;
+
+        sal_Int32                           nHTMLIndex  = -1;
+        sal_Int32                           nXHTMLIndex  = -1;
+        sal_Int32                           nPDFIndex   = -1;
+        OUString                     sUIName;
+        OUString                     sExtensions;
+        std::vector< ExportFilter >         aImportantFilterGroup;
+        std::vector< ExportFilter >         aFilterGroup;
+        Reference< XFilterGroupManager >    xFilterGroupManager( _rxFilterManager, UNO_QUERY );
+        OUString                     sTypeName;
+
+        for ( std::shared_ptr<const SfxFilter> pFilter = _rFilterMatcher.First(); pFilter; pFilter = _rFilterMatcher.Next() )
+        {
+            sTypeName   = pFilter->GetTypeName();
+            sUIName     = pFilter->GetUIName();
+            sExtensions = pFilter->GetWildcard().getGlob();
+            ExportFilter aExportFilter( sUIName, sExtensions );
+
+            if ( nHTMLIndex == -1 &&
+                ( sTypeName == "generic_HTML" || sTypeName == "graphic_HTML" ) )
+            {
+                aImportantFilterGroup.insert( aImportantFilterGroup.begin(), aExportFilter );
+                nHTMLIndex = 0;
+            }
+            else if ( nXHTMLIndex == -1 && sTypeName == "XHTML_File" )
+            {
+                std::vector< ExportFilter >::iterator aIter = aImportantFilterGroup.begin();
+                if ( nHTMLIndex == -1 )
+                    aImportantFilterGroup.insert( aIter, aExportFilter );
+                else
+                    aImportantFilterGroup.insert( ++aIter, aExportFilter );
+                nXHTMLIndex = 0;
+            }
+            else if ( nPDFIndex == -1 && sTypeName == "pdf_Portable_Document_Format" )
+            {
+                std::vector< ExportFilter >::iterator aIter = aImportantFilterGroup.begin();
+                if ( nHTMLIndex != -1 )
+                    ++aIter;
+                if ( nXHTMLIndex != -1 )
+                    ++aIter;
+                aImportantFilterGroup.insert( aIter, aExportFilter );
+                nPDFIndex = 0;
+            }
+            else
+                aFilterGroup.push_back( aExportFilter );
+        }
+
+        if ( xFilterGroupManager.is() )
+        {
+            // Add both html/pdf filter as a filter group to get a separator between both groups
+            if ( !aImportantFilterGroup.empty() )
+            {
+                Sequence< StringPair > aFilters( aImportantFilterGroup.size() );
+                for ( sal_Int32 i = 0; i < static_cast<sal_Int32>(aImportantFilterGroup.size()); i++ )
+                {
+                    aFilters[i].First   = addExtension( aImportantFilterGroup[i].aUIName,
+                                                        aImportantFilterGroup[i].aWildcard,
+                                                        false, _rFileDlgImpl );
+                    aFilters[i].Second  = aImportantFilterGroup[i].aWildcard;
+                }
+
+                try
+                {
+                    xFilterGroupManager->appendFilterGroup( OUString(), aFilters );
+                }
+                catch( const IllegalArgumentException& )
+                {
+                }
+            }
+
+            if ( !aFilterGroup.empty() )
+            {
+                Sequence< StringPair > aFilters( aFilterGroup.size() );
+                for ( sal_Int32 i = 0; i < static_cast<sal_Int32>(aFilterGroup.size()); i++ )
+                {
+                    aFilters[i].First   = addExtension( aFilterGroup[i].aUIName,
+                                                        aFilterGroup[i].aWildcard,
+                                                        false, _rFileDlgImpl );
+                    aFilters[i].Second  = aFilterGroup[i].aWildcard;
+                }
+
+                try
+                {
+                    xFilterGroupManager->appendFilterGroup( OUString(), aFilters );
+                }
+                catch( const IllegalArgumentException& )
+                {
+                }
+            }
+        }
+        else
+        {
+            // Fallback solution just add both filter groups as single filters
+            sal_Int32 n;
+
+            for ( n = 0; n < static_cast<sal_Int32>(aImportantFilterGroup.size()); n++ )
+            {
+                try
+                {
+                    OUString aUIName = addExtension( aImportantFilterGroup[n].aUIName,
+                                                          aImportantFilterGroup[n].aWildcard,
+                                                          false, _rFileDlgImpl );
+                    _rxFilterManager->appendFilter( aUIName, aImportantFilterGroup[n].aWildcard  );
+                    if ( _rFirstNonEmpty.isEmpty() )
+                        _rFirstNonEmpty = sUIName;
+
+                }
+                catch( const IllegalArgumentException& )
+                {
+                    SAL_WARN( "sfx.dialog", "Could not append Filter" << sUIName );
+                }
+            }
+
+            for ( n = 0; n < static_cast<sal_Int32>(aFilterGroup.size()); n++ )
+            {
+                try
+                {
+                    OUString aUIName = addExtension( aFilterGroup[n].aUIName,
+                                                          aFilterGroup[n].aWildcard,
+                                                          false, _rFileDlgImpl );
+                    _rxFilterManager->appendFilter( aUIName, aFilterGroup[n].aWildcard );
+                    if ( _rFirstNonEmpty.isEmpty() )
+                        _rFirstNonEmpty = sUIName;
+
+                }
+                catch( const IllegalArgumentException& )
+                {
+                    SAL_WARN( "sfx.dialog", "Could not append Filter" << sUIName );
+                }
+            }
+        }
+    }
+
+
+    void appendFiltersForOpen( TSortedFilterList& _rFilterMatcher,
+                               const Reference< XFilterManager >& _rxFilterManager,
+                               OUString& _rFirstNonEmpty, FileDialogHelper_Impl& _rFileDlgImpl )
+    {
+        DBG_ASSERT( _rxFilterManager.is(), "sfx2::appendFiltersForOpen: invalid manager!" );
+        if ( !_rxFilterManager.is() )
+            return;
+
+
+        // group and classify the filters
+        GroupedFilterList aAllFilters;
+        lcl_GroupAndClassify( _rFilterMatcher, aAllFilters );
+
+
+        // ensure that we have the one "all files" entry
+        lcl_EnsureAllFilesEntry( _rFilterMatcher, aAllFilters );
+
+
+        // the first non-empty string - which we assume is the first overall entry
+        if ( !aAllFilters.empty() )
+        {
+            const FilterGroup& rFirstGroup = *aAllFilters.begin();  // should be the global classes
+            if ( !rFirstGroup.empty() )
+                _rFirstNonEmpty = rFirstGroup.begin()->First;
+            // append first group, without extension
+            AppendFilterGroup aGroup( _rxFilterManager, &_rFileDlgImpl );
+            aGroup.appendGroup( rFirstGroup, false );
+        }
+
+
+        // append the filters to the manager
+        if ( !aAllFilters.empty() )
+        {
+            ::std::list< FilterGroup >::iterator pIter = aAllFilters.begin();
+            ++pIter;
+            ::std::for_each(
+                pIter, // first filter group was handled separately, see above
+                aAllFilters.end(),
+                AppendFilterGroup( _rxFilterManager, &_rFileDlgImpl ) );
+        }
+    }
+
+    OUString addExtension( const OUString& _rDisplayText,
+                                  const OUString& _rExtension,
+                                  bool _bForOpen, FileDialogHelper_Impl& _rFileDlgImpl )
+    {
+        OUString sRet = _rDisplayText;
+
+        if ( sRet.indexOf( "(*.*)" ) == -1 )
+        {
+            OUString sExt = _rExtension;
+            if ( !_bForOpen )
+            {
+                // show '*' in extensions only when opening a document
+                sExt = sExt.replaceAll("*", "");
+            }
+            sRet += " (" + sExt + ")";
+        }
+        _rFileDlgImpl.addFilterPair( _rDisplayText, sRet );
+        return sRet;
+    }
+
+
+}   // namespace sfx2
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/filtergrouping.hxx b/sfx2/source/dialog/filtergrouping.hxx
new file mode 100644
index 000000000..bba379f34
--- /dev/null
+++ b/sfx2/source/dialog/filtergrouping.hxx
@@ -0,0 +1,96 @@
+/* -*- 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_DIALOG_FILTERGROUPING_HXX
+#define INCLUDED_SFX2_SOURCE_DIALOG_FILTERGROUPING_HXX
+
+#include <com/sun/star/ui/dialogs/XFilterManager.hpp>
+#include <com/sun/star/container/XEnumeration.hpp>
+#include "filedlgimpl.hxx"
+
+#include <memory>
+
+namespace sfx2
+{
+
+
+    class TSortedFilterList
+    {
+    private:
+        ::std::vector< OUString > m_lFilters;
+        sal_Int32 m_nIterator;
+
+    public:
+        explicit TSortedFilterList(const css::uno::Reference< css::container::XEnumeration >& xFilterList);
+        std::shared_ptr<const SfxFilter> First();
+        std::shared_ptr<const SfxFilter> Next();
+
+    private:
+        std::shared_ptr<const SfxFilter> impl_getFilter(sal_Int32 nIndex);
+    };
+
+
+    /** adds the given filters to the filter manager.
+        <p>To be used when saving generic files.</p>
+    */
+    void appendFiltersForSave(
+        TSortedFilterList& _rFilterMatcher,
+        const css::uno::Reference< css::ui::dialogs::XFilterManager >& _rFilterManager,
+        OUString& /* [out] */ _rFirstNonEmpty,
+        FileDialogHelper_Impl& _rFileDlgImpl,
+        const OUString& _rFactory
+    );
+
+    void appendExportFilters(
+        TSortedFilterList& _rFilterMatcher,
+        const css::uno::Reference< css::ui::dialogs::XFilterManager >& _rFilterManager,
+        OUString& /* [out] */ _rFirstNonEmpty,
+        FileDialogHelper_Impl& _rFileDlgImpl
+        );
+
+
+    /** adds the given filters to the filter manager.
+        <p>To be used when opening generic files.</p>
+    */
+    void appendFiltersForOpen(
+        TSortedFilterList& _rFilterMatcher,
+        const css::uno::Reference< css::ui::dialogs::XFilterManager >& _rFilterManager,
+        OUString& /* [out] */ _rFirstNonEmpty,
+        FileDialogHelper_Impl& _rFileDlgImpl
+    );
+
+
+    /** adds the given extension to the display text.
+        <p>To be used when opening or save generic files.</p>
+    */
+    OUString addExtension(
+        const OUString& _rDisplayText,
+        const OUString& _rExtension,
+        bool _bForOpen,
+        FileDialogHelper_Impl& _rFileDlgImpl
+    );
+
+
+}   // namespace sfx2
+
+
+#endif // INCLUDED_SFX2_SOURCE_DIALOG_FILTERGROUPING_HXX
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/infobar.cxx b/sfx2/source/dialog/infobar.cxx
new file mode 100644
index 000000000..fd64691ff
--- /dev/null
+++ b/sfx2/source/dialog/infobar.cxx
@@ -0,0 +1,514 @@
+/* -*- 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 <basegfx/polygon/b2dpolygon.hxx>
+#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
+#include <drawinglayer/processor2d/baseprocessor2d.hxx>
+#include <drawinglayer/processor2d/processorfromoutputdevice.hxx>
+#include <memory>
+#include <officecfg/Office/UI/Infobar.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/infobar.hxx>
+#include <sfx2/objface.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/viewfrm.hxx>
+#include <vcl/button.hxx>
+#include <vcl/fixed.hxx>
+#include <vcl/decoview.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+
+using namespace std;
+using namespace drawinglayer::geometry;
+using namespace drawinglayer::processor2d;
+using namespace drawinglayer::primitive2d;
+using namespace drawinglayer::attribute;
+using namespace basegfx;
+using namespace css::frame;
+
+namespace
+{
+const long INFO_BAR_BASE_HEIGHT = 40;
+
+void GetInfoBarColors(InfobarType ibType, BColor& rBackgroundColor, BColor& rForegroundColor,
+                      BColor& rMessageColor)
+{
+    rMessageColor = basegfx::BColor(0.0, 0.0, 0.0);
+
+    switch (ibType)
+    {
+        case InfobarType::INFO: // blue; #004785/0,71,133; #BDE5F8/189,229,248
+            rBackgroundColor = basegfx::BColor(0.741, 0.898, 0.973);
+            rForegroundColor = basegfx::BColor(0.0, 0.278, 0.522);
+            break;
+        case InfobarType::SUCCESS: // green; #32550C/50,85,12; #DFF2BF/223,242,191
+            rBackgroundColor = basegfx::BColor(0.874, 0.949, 0.749);
+            rForegroundColor = basegfx::BColor(0.196, 0.333, 0.047);
+            break;
+        case InfobarType::WARNING: // orange; #704300/112,67,0; #FEEFB3/254,239,179
+            rBackgroundColor = basegfx::BColor(0.996, 0.937, 0.702);
+            rForegroundColor = basegfx::BColor(0.439, 0.263, 0.0);
+            break;
+        case InfobarType::DANGER: // red; #7A0006/122,0,6; #FFBABA/255,186,186
+            rBackgroundColor = basegfx::BColor(1.0, 0.729, 0.729);
+            rForegroundColor = basegfx::BColor(0.478, 0.0, 0.024);
+            break;
+    }
+
+    //remove this?
+    const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
+    if (rSettings.GetHighContrastMode())
+    {
+        rBackgroundColor = rSettings.GetLightColor().getBColor();
+        rForegroundColor = rSettings.GetDialogTextColor().getBColor();
+    }
+}
+OUString GetInfoBarIconName(InfobarType ibType)
+{
+    OUString aRet;
+
+    switch (ibType)
+    {
+        case InfobarType::INFO:
+            aRet = "vcl/res/infobox.svg";
+            break;
+        case InfobarType::SUCCESS:
+            aRet = "vcl/res/successbox.svg";
+            break;
+        case InfobarType::WARNING:
+            aRet = "vcl/res/warningbox.svg";
+            break;
+        case InfobarType::DANGER:
+            aRet = "vcl/res/errorbox.svg";
+            break;
+    }
+
+    return aRet;
+}
+
+class SfxCloseButton : public PushButton
+{
+    basegfx::BColor m_aBackgroundColor;
+    basegfx::BColor m_aForegroundColor;
+
+public:
+    explicit SfxCloseButton(vcl::Window* pParent)
+        : PushButton(pParent, 0)
+    {
+        basegfx::BColor aMessageColor;
+        GetInfoBarColors(InfobarType::WARNING, m_aBackgroundColor, m_aForegroundColor,
+                         aMessageColor);
+    }
+
+    virtual void Paint(vcl::RenderContext& rRenderContext,
+                       const ::tools::Rectangle& rRect) override;
+
+    void setBackgroundColor(const basegfx::BColor& rColor);
+    void setForegroundColor(const basegfx::BColor& rColor);
+};
+
+void SfxCloseButton::Paint(vcl::RenderContext& rRenderContext, const ::tools::Rectangle&)
+{
+    Point aBtnPos(0, 0);
+    if (GetButtonState() & DrawButtonFlags::Pressed)
+        aBtnPos.Move(Size(1, 1));
+
+    const ViewInformation2D aNewViewInfos;
+    const unique_ptr<BaseProcessor2D> pProcessor(
+        createBaseProcessor2DFromOutputDevice(rRenderContext, aNewViewInfos));
+
+    const ::tools::Rectangle aRect(aBtnPos, PixelToLogic(GetSizePixel()));
+
+    drawinglayer::primitive2d::Primitive2DContainer aSeq(2);
+
+    //  background
+    B2DPolygon aPolygon;
+    aPolygon.append(B2DPoint(aRect.Left(), aRect.Top()));
+    aPolygon.append(B2DPoint(aRect.Right(), aRect.Top()));
+    aPolygon.append(B2DPoint(aRect.Right(), aRect.Bottom()));
+    aPolygon.append(B2DPoint(aRect.Left(), aRect.Bottom()));
+    aPolygon.setClosed(true);
+
+    Color aBackgroundColor(m_aBackgroundColor);
+    if (IsMouseOver() || HasFocus())
+        aBackgroundColor.ApplyTintOrShade(-2000);
+
+    PolyPolygonColorPrimitive2D* pBack
+        = new PolyPolygonColorPrimitive2D(B2DPolyPolygon(aPolygon), aBackgroundColor.getBColor());
+    aSeq[0] = pBack;
+
+    LineAttribute aLineAttribute(m_aForegroundColor, 2.0);
+
+    // Cross
+    B2DPolyPolygon aCross;
+
+    B2DPolygon aLine1;
+    aLine1.append(B2DPoint(aRect.Left(), aRect.Top()));
+    aLine1.append(B2DPoint(aRect.Right(), aRect.Bottom()));
+    aCross.append(aLine1);
+
+    B2DPolygon aLine2;
+    aLine2.append(B2DPoint(aRect.Right(), aRect.Top()));
+    aLine2.append(B2DPoint(aRect.Left(), aRect.Bottom()));
+    aCross.append(aLine2);
+
+    PolyPolygonStrokePrimitive2D* pCross
+        = new PolyPolygonStrokePrimitive2D(aCross, aLineAttribute, StrokeAttribute());
+
+    aSeq[1] = pCross;
+
+    pProcessor->process(aSeq);
+}
+
+void SfxCloseButton::setBackgroundColor(const basegfx::BColor& rColor)
+{
+    m_aBackgroundColor = rColor;
+}
+
+void SfxCloseButton::setForegroundColor(const basegfx::BColor& rColor)
+{
+    m_aForegroundColor = rColor;
+}
+
+} // anonymous namespace
+
+SfxInfoBarWindow::SfxInfoBarWindow(vcl::Window* pParent, const OUString& sId,
+                                   const OUString& sPrimaryMessage,
+                                   const OUString& sSecondaryMessage, InfobarType ibType,
+                                   WinBits nMessageStyle, bool bShowCloseButton)
+    : Window(pParent, WB_DIALOGCONTROL)
+    , m_sId(sId)
+    , m_eType(ibType)
+    , m_pImage(VclPtr<FixedImage>::Create(this, nMessageStyle))
+    , m_pPrimaryMessage(VclPtr<FixedText>::Create(this, nMessageStyle | WB_WORDBREAK))
+    , m_pSecondaryMessage(VclPtr<FixedText>::Create(this, nMessageStyle | WB_WORDBREAK))
+    , m_pCloseBtn(VclPtr<SfxCloseButton>::Create(this))
+    , m_aActionBtns()
+{
+    m_pCloseBtn->SetStyle(WB_DEFBUTTON | WB_TABSTOP);
+    SetForeAndBackgroundColors(m_eType);
+    float fScaleFactor = GetDPIScaleFactor();
+    long nWidth = pParent->GetSizePixel().getWidth();
+    SetPosSizePixel(Point(0, 0), Size(nWidth, INFO_BAR_BASE_HEIGHT * fScaleFactor));
+
+    m_pImage->SetImage(Image(StockImage::Yes, GetInfoBarIconName(ibType)));
+    m_pImage->SetPaintTransparent(true);
+    m_pImage->Show();
+
+    vcl::Font aFont(m_pPrimaryMessage->GetControlFont());
+    aFont.SetWeight(WEIGHT_BOLD);
+    m_pPrimaryMessage->SetControlFont(aFont);
+    if (!sPrimaryMessage.isEmpty())
+    {
+        m_pPrimaryMessage->SetText(sPrimaryMessage);
+        m_pPrimaryMessage->Show();
+    }
+
+    m_pSecondaryMessage->SetText(sSecondaryMessage);
+    m_pSecondaryMessage->Show();
+
+    if (bShowCloseButton)
+    {
+        m_pCloseBtn->SetClickHdl(LINK(this, SfxInfoBarWindow, CloseHandler));
+        m_pCloseBtn->Show();
+    }
+
+    EnableChildTransparentMode();
+
+    Resize();
+}
+
+void SfxInfoBarWindow::addButton(PushButton* pButton)
+{
+    pButton->SetParent(this);
+    pButton->Show();
+    m_aActionBtns.emplace_back(pButton);
+    Resize();
+}
+
+SfxInfoBarWindow::~SfxInfoBarWindow() { disposeOnce(); }
+
+void SfxInfoBarWindow::SetForeAndBackgroundColors(InfobarType eType)
+{
+    basegfx::BColor aMessageColor;
+    GetInfoBarColors(eType, m_aBackgroundColor, m_aForegroundColor, aMessageColor);
+
+    static_cast<SfxCloseButton*>(m_pCloseBtn.get())->setBackgroundColor(m_aBackgroundColor);
+    static_cast<SfxCloseButton*>(m_pCloseBtn.get())->setForegroundColor(m_aForegroundColor);
+    m_pPrimaryMessage->SetControlForeground(Color(aMessageColor));
+    m_pSecondaryMessage->SetControlForeground(Color(aMessageColor));
+}
+
+void SfxInfoBarWindow::dispose()
+{
+    for (auto& rxBtn : m_aActionBtns)
+        rxBtn.disposeAndClear();
+
+    m_pImage.disposeAndClear();
+    m_pPrimaryMessage.disposeAndClear();
+    m_pSecondaryMessage.disposeAndClear();
+    m_pCloseBtn.disposeAndClear();
+    m_aActionBtns.clear();
+    vcl::Window::dispose();
+}
+
+void SfxInfoBarWindow::Paint(vcl::RenderContext& rRenderContext,
+                             const ::tools::Rectangle& rPaintRect)
+{
+    const ViewInformation2D aNewViewInfos;
+    const unique_ptr<BaseProcessor2D> pProcessor(
+        createBaseProcessor2DFromOutputDevice(rRenderContext, aNewViewInfos));
+
+    const ::tools::Rectangle aRect(Point(0, 0), PixelToLogic(GetSizePixel()));
+
+    drawinglayer::primitive2d::Primitive2DContainer aSeq(2);
+
+    // Light background
+    B2DPolygon aPolygon;
+    aPolygon.append(B2DPoint(aRect.Left(), aRect.Top()));
+    aPolygon.append(B2DPoint(aRect.Right(), aRect.Top()));
+    aPolygon.append(B2DPoint(aRect.Right(), aRect.Bottom()));
+    aPolygon.append(B2DPoint(aRect.Left(), aRect.Bottom()));
+    aPolygon.setClosed(true);
+
+    PolyPolygonColorPrimitive2D* pBack
+        = new PolyPolygonColorPrimitive2D(B2DPolyPolygon(aPolygon), m_aBackgroundColor);
+    aSeq[0] = pBack;
+
+    LineAttribute aLineAttribute(m_aForegroundColor, 1.0);
+
+    // Bottom dark line
+    B2DPolygon aPolygonBottom;
+    aPolygonBottom.append(B2DPoint(aRect.Left(), aRect.Bottom()));
+    aPolygonBottom.append(B2DPoint(aRect.Right(), aRect.Bottom()));
+
+    PolygonStrokePrimitive2D* pLineBottom
+        = new PolygonStrokePrimitive2D(aPolygonBottom, aLineAttribute);
+
+    aSeq[1] = pLineBottom;
+
+    pProcessor->process(aSeq);
+
+    Window::Paint(rRenderContext, rPaintRect);
+}
+
+void SfxInfoBarWindow::Resize()
+{
+    float fScaleFactor = GetDPIScaleFactor();
+
+    long nWidth = GetSizePixel().getWidth();
+    m_pCloseBtn->SetPosSizePixel(Point(nWidth - 25 * fScaleFactor, 15 * fScaleFactor),
+                                 Size(10 * fScaleFactor, 10 * fScaleFactor));
+
+    // Reparent the buttons and place them on the right of the bar
+    long nX = m_pCloseBtn->GetPosPixel().getX() - 15 * fScaleFactor;
+    long nButtonGap = 5 * fScaleFactor;
+
+    for (auto const& actionBtn : m_aActionBtns)
+    {
+        long nButtonWidth = actionBtn->GetSizePixel().getWidth();
+        nX -= nButtonWidth;
+        actionBtn->SetPosSizePixel(Point(nX, 5 * fScaleFactor),
+                                   Size(nButtonWidth, 30 * fScaleFactor));
+        nX -= nButtonGap;
+    }
+
+    Point aPrimaryMessagePosition(32 * fScaleFactor + 10 * fScaleFactor, 10 * fScaleFactor);
+    Point aSecondaryMessagePosition(aPrimaryMessagePosition);
+    Size aMessageSize(nX - 35 * fScaleFactor, 20 * fScaleFactor);
+    Size aPrimaryTextSize = m_pPrimaryMessage->CalcMinimumSize(aMessageSize.getWidth());
+    Size aSecondaryTextSize = m_pSecondaryMessage->CalcMinimumSize(aMessageSize.getWidth()
+                                                                   - aPrimaryTextSize.getWidth());
+    if (!m_pPrimaryMessage->GetText().isEmpty())
+        aSecondaryMessagePosition.AdjustX(aPrimaryTextSize.getWidth() + 6 * fScaleFactor);
+
+    long aMinimumHeight = std::max(m_pPrimaryMessage->CalcMinimumSize().getHeight(),
+                                   m_pSecondaryMessage->CalcMinimumSize().getHeight());
+
+    long aExtraHeight = aSecondaryTextSize.getHeight() - aMinimumHeight;
+
+    // The message won't be legible and the window will get too high
+    if (aMessageSize.getWidth() < 30)
+    {
+        aExtraHeight = 0;
+    }
+
+    m_pPrimaryMessage->SetPosSizePixel(aPrimaryMessagePosition, aPrimaryTextSize);
+    m_pSecondaryMessage->SetPosSizePixel(aSecondaryMessagePosition, aSecondaryTextSize);
+    m_pImage->SetPosSizePixel(Point(4, 4), Size(32 * fScaleFactor, 32 * fScaleFactor));
+
+    SetPosSizePixel(GetPosPixel(), Size(nWidth, INFO_BAR_BASE_HEIGHT * fScaleFactor
+                                                    + aExtraHeight * fScaleFactor));
+}
+
+void SfxInfoBarWindow::Update(const OUString& sPrimaryMessage, const OUString& sSecondaryMessage,
+                              InfobarType eType)
+{
+    if (m_eType != eType)
+    {
+        m_eType = eType;
+        SetForeAndBackgroundColors(m_eType);
+        m_pImage->SetImage(Image(StockImage::Yes, GetInfoBarIconName(eType)));
+    }
+
+    m_pPrimaryMessage->SetText(sPrimaryMessage);
+    m_pSecondaryMessage->SetText(sSecondaryMessage);
+    Resize();
+    Invalidate();
+}
+
+IMPL_LINK_NOARG(SfxInfoBarWindow, CloseHandler, Button*, void)
+{
+    static_cast<SfxInfoBarContainerWindow*>(GetParent())->removeInfoBar(this);
+}
+
+SfxInfoBarContainerWindow::SfxInfoBarContainerWindow(SfxInfoBarContainerChild* pChildWin)
+    : Window(pChildWin->GetParent(), WB_DIALOGCONTROL)
+    , m_pChildWin(pChildWin)
+    , m_pInfoBars()
+{
+}
+
+SfxInfoBarContainerWindow::~SfxInfoBarContainerWindow() { disposeOnce(); }
+
+void SfxInfoBarContainerWindow::dispose()
+{
+    for (auto& infoBar : m_pInfoBars)
+        infoBar.disposeAndClear();
+    m_pInfoBars.clear();
+    Window::dispose();
+}
+
+VclPtr<SfxInfoBarWindow>
+SfxInfoBarContainerWindow::appendInfoBar(const OUString& sId, const OUString& sPrimaryMessage,
+                                         const OUString& sSecondaryMessage, InfobarType ibType,
+                                         WinBits nMessageStyle, bool bShowCloseButton)
+{
+    if (!isInfobarEnabled(sId))
+        return nullptr;
+
+    auto pInfoBar = VclPtr<SfxInfoBarWindow>::Create(this, sId, sPrimaryMessage, sSecondaryMessage,
+                                                     ibType, nMessageStyle, bShowCloseButton);
+
+    basegfx::BColor aBackgroundColor;
+    basegfx::BColor aForegroundColor;
+    basegfx::BColor aMessageColor;
+    GetInfoBarColors(ibType, aBackgroundColor, aForegroundColor, aMessageColor);
+    pInfoBar->m_aBackgroundColor = aBackgroundColor;
+    pInfoBar->m_aForegroundColor = aForegroundColor;
+    m_pInfoBars.push_back(pInfoBar);
+
+    Resize();
+    return pInfoBar;
+}
+
+VclPtr<SfxInfoBarWindow> SfxInfoBarContainerWindow::getInfoBar(const OUString& sId)
+{
+    for (auto const& infoBar : m_pInfoBars)
+    {
+        if (infoBar->getId() == sId)
+            return infoBar;
+    }
+    return nullptr;
+}
+
+bool SfxInfoBarContainerWindow::hasInfoBarWithID(const OUString& sId)
+{
+    return (getInfoBar(sId) != nullptr);
+}
+
+void SfxInfoBarContainerWindow::removeInfoBar(VclPtr<SfxInfoBarWindow> const& pInfoBar)
+{
+    // Remove
+    auto it = std::find(m_pInfoBars.begin(), m_pInfoBars.end(), pInfoBar);
+    if (it != m_pInfoBars.end())
+    {
+        it->disposeAndClear();
+        m_pInfoBars.erase(it);
+    }
+
+    Resize();
+
+    m_pChildWin->Update();
+}
+
+bool SfxInfoBarContainerWindow::isInfobarEnabled(const OUString& sId)
+{
+    if (sId == "readonly")
+        return officecfg::Office::UI::Infobar::Enabled::Readonly::get();
+    if (sId == "signature")
+        return officecfg::Office::UI::Infobar::Enabled::Signature::get();
+    if (sId == "donate")
+        return officecfg::Office::UI::Infobar::Enabled::Donate::get();
+    if (sId == "getinvolved")
+        return officecfg::Office::UI::Infobar::Enabled::GetInvolved::get();
+    if (sId == "hyphenationmissing")
+        return officecfg::Office::UI::Infobar::Enabled::HyphenationMissing::get();
+
+    return true;
+}
+
+void SfxInfoBarContainerWindow::Resize()
+{
+    long nWidth = GetSizePixel().getWidth();
+    long nHeight = 0;
+
+    for (auto& rxInfoBar : m_pInfoBars)
+    {
+        Size aSize = rxInfoBar->GetSizePixel();
+        aSize.setWidth(nWidth);
+        Point aPos(0, nHeight);
+        rxInfoBar->SetPosSizePixel(aPos, aSize);
+        rxInfoBar->Resize();
+        rxInfoBar->Show();
+
+        // Stretch to fit the infobar(s)
+        nHeight += aSize.getHeight();
+    }
+
+    SetSizePixel(Size(nWidth, nHeight));
+}
+
+SFX_IMPL_POS_CHILDWINDOW_WITHID(SfxInfoBarContainerChild, SID_INFOBAR, SFX_OBJECTBAR_OBJECT);
+
+SfxInfoBarContainerChild::SfxInfoBarContainerChild(vcl::Window* _pParent, sal_uInt16 nId,
+                                                   SfxBindings* pBindings, SfxChildWinInfo*)
+    : SfxChildWindow(_pParent, nId)
+    , m_pBindings(pBindings)
+{
+    SetWindow(VclPtr<SfxInfoBarContainerWindow>::Create(this));
+    GetWindow()->SetPosSizePixel(Point(0, 0), Size(_pParent->GetSizePixel().getWidth(), 0));
+    GetWindow()->Show();
+
+    SetAlignment(SfxChildAlignment::LOWESTTOP);
+}
+
+SfxInfoBarContainerChild::~SfxInfoBarContainerChild() {}
+
+SfxChildWinInfo SfxInfoBarContainerChild::GetInfo() const
+{
+    SfxChildWinInfo aInfo = SfxChildWindow::GetInfo();
+    return aInfo;
+}
+
+void SfxInfoBarContainerChild::Update()
+{
+    // Refresh the frame to take the infobars container height change into account
+    const sal_uInt16 nId = GetChildWindowId();
+    SfxViewFrame* pVFrame = m_pBindings->GetDispatcher()->GetFrame();
+    pVFrame->ShowChildWindow(nId);
+
+    // Give the focus to the document view
+    pVFrame->GetWindow().GrabFocusToDocument();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/inputdlg.cxx b/sfx2/source/dialog/inputdlg.cxx
new file mode 100644
index 000000000..57b620d45
--- /dev/null
+++ b/sfx2/source/dialog/inputdlg.cxx
@@ -0,0 +1,39 @@
+/* -*- 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 <sfx2/inputdlg.hxx>
+
+InputDialog::InputDialog(weld::Widget* pParent, const OUString &rLabelText)
+    : GenericDialogController(pParent, "sfx/ui/inputdialog.ui", "InputDialog")
+    , m_xEntry(m_xBuilder->weld_entry("entry"))
+    , m_xLabel(m_xBuilder->weld_label("label"))
+    , m_xHelp(m_xBuilder->weld_button("help"))
+{
+    m_xLabel->set_label(rLabelText);
+}
+
+void InputDialog::HideHelpBtn()
+{
+    m_xHelp->hide();
+}
+
+OUString InputDialog::GetEntryText() const
+{
+    return m_xEntry->get_text();
+}
+
+void InputDialog::SetEntryText(const OUString& rStr)
+{
+    m_xEntry->set_text(rStr);
+    m_xEntry->set_position(-1);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
+
+
diff --git a/sfx2/source/dialog/mailmodel.cxx b/sfx2/source/dialog/mailmodel.cxx
new file mode 100644
index 000000000..63e29270d
--- /dev/null
+++ b/sfx2/source/dialog/mailmodel.cxx
@@ -0,0 +1,846 @@
+/* -*- 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/beans/PropertyValue.hpp>
+#include <com/sun/star/beans/XPropertyAccess.hpp>
+#include <com/sun/star/container/XContainerQuery.hpp>
+#include <com/sun/star/document/XExporter.hpp>
+#include <com/sun/star/embed/XStorage.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XStatusListener.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/frame/ModuleManager.hpp>
+#include <com/sun/star/frame/XStorable.hpp>
+#include <com/sun/star/io/IOException.hpp>
+#include <com/sun/star/lang/XMultiServiceFactory.hpp>
+#include <com/sun/star/system/SimpleSystemMail.hpp>
+#include <com/sun/star/system/SimpleCommandMail.hpp>
+#include <com/sun/star/system/XSimpleMailClientSupplier.hpp>
+#include <com/sun/star/system/SimpleMailClientFlags.hpp>
+#include <com/sun/star/ucb/CommandAbortedException.hpp>
+#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
+#include <com/sun/star/uno/Reference.h>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <com/sun/star/util/XModifiable.hpp>
+#include <vcl/weld.hxx>
+#include <osl/diagnose.h>
+
+#include <sfx2/mailmodelapi.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/strings.hrc>
+
+#include <unotools/tempfile.hxx>
+#include <tools/urlobj.hxx>
+#include <unotools/useroptions.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <comphelper/string.hxx>
+#include <vcl/svapp.hxx>
+#include <cppuhelper/implbase.hxx>
+
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::frame;
+using namespace ::com::sun::star::io;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::ucb;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::util;
+using namespace ::com::sun::star::system;
+
+namespace {
+
+// - class PrepareListener_Impl ------------------------------------------
+class PrepareListener_Impl : public ::cppu::WeakImplHelper< css::frame::XStatusListener >
+{
+    bool m_bState;
+public:
+        PrepareListener_Impl();
+
+        // css.frame.XStatusListener
+        virtual void SAL_CALL statusChanged(const css::frame::FeatureStateEvent& aEvent) override;
+
+        // css.lang.XEventListener
+        virtual void SAL_CALL disposing(const css::lang::EventObject& aEvent) override;
+
+        bool IsSet() const {return m_bState;}
+};
+
+}
+
+PrepareListener_Impl::PrepareListener_Impl() :
+    m_bState( false )
+{
+}
+
+void PrepareListener_Impl::statusChanged(const css::frame::FeatureStateEvent& rEvent)
+{
+    if( rEvent.IsEnabled )
+        rEvent.State >>= m_bState;
+    else
+        m_bState = false;
+}
+
+void PrepareListener_Impl::disposing(const css::lang::EventObject& /*rEvent*/)
+{
+}
+
+// class SfxMailModel -----------------------------------------------
+
+static const char       PDF_DOCUMENT_TYPE[]   = "pdf_Portable_Document_Format";
+
+SfxMailModel::SaveResult SfxMailModel::ShowFilterOptionsDialog(
+    const uno::Reference< lang::XMultiServiceFactory >& xSMGR,
+    const uno::Reference< frame::XModel >& xModel,
+    const OUString& rFilterName,
+    const OUString& rType,
+    bool bModified,
+    sal_Int32& rNumArgs,
+    css::uno::Sequence< css::beans::PropertyValue >& rArgs )
+{
+    SaveResult eRet( SAVE_ERROR );
+
+    try
+    {
+        uno::Sequence < beans::PropertyValue > aProps;
+        css::uno::Reference< css::container::XNameAccess > xFilterCFG(
+                    xSMGR->createInstance( "com.sun.star.document.FilterFactory" ), uno::UNO_QUERY );
+        css::uno::Reference< css::util::XModifiable > xModifiable( xModel, css::uno::UNO_QUERY );
+
+        if ( !xFilterCFG.is() )
+            return eRet;
+
+        uno::Any aAny = xFilterCFG->getByName( rFilterName );
+
+        if ( aAny >>= aProps )
+        {
+            for( const auto& rProp : std::as_const(aProps) )
+            {
+                if( rProp.Name == "UIComponent" )
+                {
+                    OUString aServiceName;
+                    rProp.Value >>= aServiceName;
+                    if( !aServiceName.isEmpty() )
+                    {
+                        uno::Reference< ui::dialogs::XExecutableDialog > xFilterDialog(
+                            xSMGR->createInstance( aServiceName ), uno::UNO_QUERY );
+                        uno::Reference< beans::XPropertyAccess > xFilterProperties(
+                            xFilterDialog, uno::UNO_QUERY );
+
+                        if( xFilterDialog.is() && xFilterProperties.is() )
+                        {
+                            uno::Sequence< beans::PropertyValue > aPropsForDialog(1);
+                            uno::Reference< document::XExporter > xExporter( xFilterDialog, uno::UNO_QUERY );
+
+                            if ( rType == PDF_DOCUMENT_TYPE )
+                            {
+                                //add an internal property, used to tell the dialog we want to set a different
+                                //string for the ok button
+                                //used in filter/source/pdf/impdialog.cxx
+                                uno::Sequence< beans::PropertyValue > aFilterDataValue(1);
+                                aFilterDataValue[0].Name = "_OkButtonString";
+                                aFilterDataValue[0].Value <<= SfxResId(STR_PDF_EXPORT_SEND );
+
+                                //add to the filterdata property, the only one the PDF export filter dialog will care for
+                                aPropsForDialog[0].Name = "FilterData";
+                                aPropsForDialog[0].Value <<= aFilterDataValue;
+
+                                //when executing the dialog will merge the persistent FilterData properties
+                                xFilterProperties->setPropertyValues( aPropsForDialog );
+                            }
+
+                            if( xExporter.is() )
+                                xExporter->setSourceDocument( xModel );
+
+                            if( xFilterDialog->execute() )
+                            {
+                                //get the filter data
+                                uno::Sequence< beans::PropertyValue > aPropsFromDialog = xFilterProperties->getPropertyValues();
+
+                                //add them to the args
+                                auto pProp = std::find_if(aPropsFromDialog.begin(), aPropsFromDialog.end(),
+                                    [](const beans::PropertyValue& rDialogProp) { return rDialogProp.Name == "FilterData"; });
+                                if (pProp != aPropsFromDialog.end())
+                                {
+                                    //found the filterdata, add to the storing argument
+                                    rArgs.realloc( ++rNumArgs );
+                                    rArgs[rNumArgs-1].Name = pProp->Name;
+                                    rArgs[rNumArgs-1].Value = pProp->Value;
+                                }
+                                eRet = SAVE_SUCCESSFULL;
+                            }
+                            else
+                            {
+                                // cancel from dialog, then do not send
+                                // If the model is not modified, it could be modified by the dispatch calls.
+                                // Therefore set back to modified = false. This should not hurt if we call
+                                // on a non-modified model.
+                                if ( !bModified )
+                                {
+                                    try
+                                    {
+                                        xModifiable->setModified( false );
+                                    }
+                                    catch( css::beans::PropertyVetoException& )
+                                    {
+                                    }
+                                }
+                                eRet = SAVE_CANCELLED;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    catch( css::uno::RuntimeException& )
+    {
+        throw;
+    }
+    catch( uno::Exception& )
+    {
+    }
+
+    return eRet;
+}
+
+bool SfxMailModel::IsEmpty() const
+{
+    return maAttachedDocuments.empty();
+}
+
+SfxMailModel::SaveResult SfxMailModel::SaveDocumentAsFormat(
+    const OUString& aSaveFileName,
+    const css::uno::Reference< css::uno::XInterface >& xFrameOrModel,
+    const OUString& rType,
+    OUString& rFileNamePath )
+{
+    SaveResult  eRet( SAVE_ERROR );
+    bool        bSendAsPDF = ( rType == PDF_DOCUMENT_TYPE );
+
+    css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR  = ::comphelper::getProcessServiceFactory();
+    css::uno::Reference< css::uno::XComponentContext > xContext  = ::comphelper::getProcessComponentContext();
+    if (!xContext.is())
+        return eRet;
+
+    css::uno::Reference< css::frame::XModuleManager2 > xModuleManager( css::frame::ModuleManager::create(xContext) );
+
+    OUString aModule;
+    try
+    {
+         aModule = xModuleManager->identify( xFrameOrModel );
+    }
+    catch ( css::uno::RuntimeException& )
+    {
+        throw;
+    }
+    catch ( css::uno::Exception& )
+    {
+    }
+
+    css::uno::Reference< css::frame::XFrame > xFrame( xFrameOrModel, css::uno::UNO_QUERY );
+    css::uno::Reference< css::frame::XModel > xModel( xFrameOrModel, css::uno::UNO_QUERY );
+    if ( xFrame.is() )
+    {
+        css::uno::Reference< css::frame::XController > xController = xFrame->getController();
+        if ( xController.is() )
+            xModel = xController->getModel();
+    }
+
+    // We need at least a valid module name and model reference
+    if ( !aModule.isEmpty()  && xModel.is() )
+    {
+        bool bModified( false );
+        bool bHasLocation( false );
+        bool bStoreTo( false );
+
+        css::uno::Reference< css::util::XModifiable > xModifiable( xModel, css::uno::UNO_QUERY );
+        css::uno::Reference< css::frame::XStorable > xStorable( xModel, css::uno::UNO_QUERY );
+
+        if ( xModifiable.is() )
+            bModified = xModifiable->isModified();
+        if ( xStorable.is() )
+        {
+            OUString aLocation = xStorable->getLocation();
+            INetURLObject aFileObj( aLocation );
+
+            bool bPrivateProtocol = ( aFileObj.GetProtocol() == INetProtocol::PrivSoffice );
+
+            bHasLocation =  !aLocation.isEmpty() && !bPrivateProtocol;
+            OSL_ASSERT( !bPrivateProtocol );
+        }
+        if ( !rType.isEmpty() )
+            bStoreTo = true;
+
+        if ( xStorable.is() )
+        {
+            OUString aFilterName;
+            OUString aTypeName( rType );
+            OUString aFileName;
+            OUString aExtension;
+
+            css::uno::Reference< css::container::XContainerQuery > xContainerQuery(
+                xSMGR->createInstance( "com.sun.star.document.FilterFactory" ),
+                css::uno::UNO_QUERY );
+
+            if ( bStoreTo )
+            {
+                // Retrieve filter from type
+                css::uno::Sequence< css::beans::NamedValue > aQuery( bSendAsPDF ? 3 : 2 );
+                aQuery[0].Name  = "Type";
+                aQuery[0].Value <<= aTypeName;
+                aQuery[1].Name  = "DocumentService";
+                aQuery[1].Value <<= aModule;
+                if( bSendAsPDF )
+                {
+                    // #i91419#
+                    // FIXME: we want just an export filter. However currently we need
+                    // exact flag value as detailed in the filter configuration to get it
+                    // this seems to be a bug
+                    // without flags we get an import filter here, which is also unwanted
+                    aQuery[2].Name  = "Flags";
+                    aQuery[2].Value <<= sal_Int32(0x80042); // EXPORT ALIEN 3RDPARTY
+                }
+
+                css::uno::Reference< css::container::XEnumeration > xEnumeration =
+                    xContainerQuery->createSubSetEnumerationByProperties( aQuery );
+
+                if ( xEnumeration->hasMoreElements() )
+                {
+                    ::comphelper::SequenceAsHashMap aFilterPropsHM( xEnumeration->nextElement() );
+                    aFilterName = aFilterPropsHM.getUnpackedValueOrDefault(
+                                                "Name",
+                                                OUString() );
+                }
+
+                if ( bHasLocation )
+                {
+                    // Retrieve filter from media descriptor
+                    ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
+                    OUString aOrgFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault(
+                                    "FilterName",
+                                    OUString() );
+                    if ( aOrgFilterName == aFilterName )
+                    {
+                        // We should save the document in the original format. Therefore this
+                        // is not a storeTo operation. To support signing in this case, reset
+                        // bStoreTo flag.
+                        bStoreTo = false;
+                    }
+                }
+            }
+            else
+            {
+                if ( bHasLocation )
+                {
+                    // Retrieve filter from media descriptor
+                    ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
+                    aFilterName = aMediaDescrPropsHM.getUnpackedValueOrDefault(
+                                    "FilterName",
+                                    OUString() );
+                }
+
+                if ( !bHasLocation ||  aFilterName.isEmpty())
+                {
+                    // Retrieve the user defined default filter
+                    try
+                    {
+                        ::comphelper::SequenceAsHashMap aFilterPropsHM( xModuleManager->getByName( aModule ) );
+                        aFilterName = aFilterPropsHM.getUnpackedValueOrDefault(
+                                                    "ooSetupFactoryDefaultFilter",
+                                                    OUString() );
+                        css::uno::Reference< css::container::XNameAccess > xNameAccess(
+                            xContainerQuery, css::uno::UNO_QUERY );
+                        if ( xNameAccess.is() )
+                        {
+                            ::comphelper::SequenceAsHashMap aFilterPropsHM2( xNameAccess->getByName( aFilterName ) );
+                            aTypeName = aFilterPropsHM2.getUnpackedValueOrDefault(
+                                                        "Type",
+                                                        OUString() );
+                        }
+                    }
+                    catch ( css::container::NoSuchElementException& )
+                    {
+                    }
+                    catch ( css::beans::UnknownPropertyException& )
+                    {
+                    }
+                }
+            }
+
+            // No filter found => error
+            // No type and no location => error
+            if (( aFilterName.isEmpty() ) ||
+                ( aTypeName.isEmpty()  && !bHasLocation ))
+                return eRet;
+
+            // Determine file name and extension
+            if ( bHasLocation && !bStoreTo )
+            {
+                INetURLObject aFileObj( xStorable->getLocation() );
+                aExtension = aFileObj.getExtension();
+            }
+            else
+            {
+                css::uno::Reference< container::XNameAccess > xTypeDetection(
+                    xSMGR->createInstance( "com.sun.star.document.TypeDetection" ),
+                    css::uno::UNO_QUERY );
+
+
+                if ( xTypeDetection.is() )
+                {
+                    try
+                    {
+                        ::comphelper::SequenceAsHashMap aTypeNamePropsHM( xTypeDetection->getByName( aTypeName ) );
+                        uno::Sequence< OUString > aExtensions = aTypeNamePropsHM.getUnpackedValueOrDefault(
+                                                        "Extensions",
+                                                        ::uno::Sequence< OUString >() );
+                        if ( aExtensions.hasElements() )
+                            aExtension = aExtensions[0];
+                    }
+                    catch ( css::container::NoSuchElementException& )
+                    {
+                    }
+                }
+            }
+
+            // Use provided save file name. If empty determine file name
+            aFileName = aSaveFileName;
+            if ( aFileName.isEmpty() )
+            {
+                if ( !bHasLocation )
+                {
+                    // Create a noname file name with the correct extension
+                    const OUString aNoNameFileName( "noname" );
+                    aFileName = aNoNameFileName;
+                }
+                else
+                {
+                    // Determine file name from model
+                    INetURLObject aFileObj( xStorable->getLocation() );
+                    aFileName = aFileObj.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::NONE );
+                }
+            }
+
+            // No file name => error
+            if ( aFileName.isEmpty() )
+                return eRet;
+
+            OSL_ASSERT( !aFilterName.isEmpty() );
+            OSL_ASSERT( !aFileName.isEmpty() );
+
+            // Creates a temporary directory to store a predefined file into it.
+            // This makes it possible to store the file for "send document as e-mail"
+            // with the original file name. We cannot use the original file as
+            // some mail programs need exclusive access.
+            ::utl::TempFile aTempDir( nullptr, true );
+
+            INetURLObject aFilePathObj( aTempDir.GetURL() );
+            aFilePathObj.insertName( aFileName );
+            aFilePathObj.setExtension( aExtension );
+
+            OUString aFileURL = aFilePathObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+
+            sal_Int32 nNumArgs(0);
+            const OUString aPasswordPropName( "Password" );
+            css::uno::Sequence< css::beans::PropertyValue > aArgs( ++nNumArgs );
+            aArgs[nNumArgs-1].Name  = "FilterName";
+            aArgs[nNumArgs-1].Value <<= aFilterName;
+
+            ::comphelper::SequenceAsHashMap aMediaDescrPropsHM( xModel->getArgs() );
+            OUString aPassword = aMediaDescrPropsHM.getUnpackedValueOrDefault(
+                                            aPasswordPropName,
+                                            OUString() );
+            if ( !aPassword.isEmpty() )
+            {
+                aArgs.realloc( ++nNumArgs );
+                aArgs[nNumArgs-1].Name = aPasswordPropName;
+                aArgs[nNumArgs-1].Value <<= aPassword;
+            }
+
+            bool bNeedsPreparation = false;
+            css::util::URL aPrepareURL;
+            css::uno::Reference< css::frame::XDispatch > xPrepareDispatch;
+            css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider( xFrame, css::uno::UNO_QUERY );
+            css::uno::Reference< css::util::XURLTransformer > xURLTransformer( css::util::URLTransformer::create( xContext ) );
+            if( !bSendAsPDF )
+            {
+                try
+                {
+                    // check if the document needs to be prepared for sending as mail (embedding of links, removal of invisible content)
+
+                    aPrepareURL.Complete = ".uno:PrepareMailExport";
+                    xURLTransformer->parseStrict( aPrepareURL );
+
+                    if ( xDispatchProvider.is() )
+                    {
+                        xPrepareDispatch.set( xDispatchProvider->queryDispatch( aPrepareURL, OUString(), 0 ));
+                        if ( xPrepareDispatch.is() )
+                        {
+                                PrepareListener_Impl* pPrepareListener = new PrepareListener_Impl;
+                                uno::Reference< css::frame::XStatusListener > xStatusListener = pPrepareListener;
+                                xPrepareDispatch->addStatusListener( xStatusListener, aPrepareURL );
+                                bNeedsPreparation = pPrepareListener->IsSet();
+                                xPrepareDispatch->removeStatusListener( xStatusListener, aPrepareURL );
+                        }
+                    }
+                }
+                catch ( css::uno::RuntimeException& )
+                {
+                    throw;
+                }
+                catch ( css::uno::Exception& )
+                {
+                }
+            }
+
+            if ( bModified || !bHasLocation || bStoreTo || bNeedsPreparation )
+            {
+                // Document is modified, is newly created or should be stored in a special format
+                try
+                {
+                    if( bNeedsPreparation && xPrepareDispatch.is() )
+                    {
+                        try
+                        {
+                            css::uno::Sequence< css::beans::PropertyValue > aDispatchArgs;
+                            xPrepareDispatch->dispatch( aPrepareURL, aDispatchArgs );
+                        }
+                        catch ( css::uno::RuntimeException& )
+                        {
+                            throw;
+                        }
+                        catch ( css::uno::Exception& )
+                        {
+                        }
+                    }
+
+                    //check if this is the pdf output filter (i#64555)
+                    if( bSendAsPDF )
+                    {
+                        SaveResult eShowPDFFilterDialog = ShowFilterOptionsDialog(
+                                                            xSMGR, xModel, aFilterName, rType, bModified, nNumArgs, aArgs );
+
+                        // don't continue on dialog cancel or error
+                        if ( eShowPDFFilterDialog != SAVE_SUCCESSFULL )
+                            return eShowPDFFilterDialog;
+                    }
+
+                    xStorable->storeToURL( aFileURL, aArgs );
+                    rFileNamePath = aFileURL;
+                    eRet = SAVE_SUCCESSFULL;
+
+                    if( !bSendAsPDF )
+                    {
+                        css::util::URL aURL;
+                        // #i30432# notify that export is finished - the Writer may want to restore removed content
+                        aURL.Complete = ".uno:MailExportFinished";
+                        xURLTransformer->parseStrict( aURL );
+
+                        if ( xDispatchProvider.is() )
+                        {
+                            css::uno::Reference< css::frame::XDispatch > xDispatch(
+                                xDispatchProvider->queryDispatch( aURL, OUString(), 0 ));
+                            if ( xDispatch.is() )
+                            {
+                                try
+                                {
+                                    css::uno::Sequence< css::beans::PropertyValue > aDispatchArgs;
+                                    xDispatch->dispatch( aURL, aDispatchArgs );
+                                }
+                                catch ( css::uno::RuntimeException& )
+                                {
+                                    throw;
+                                }
+                                catch ( css::uno::Exception& )
+                                {
+                                }
+                            }
+                        }
+                    }
+                    // If the model is not modified, it could be modified by the dispatch calls.
+                    // Therefore set back to modified = false. This should not hurt if we call
+                    // on a non-modified model.
+                    if ( !bModified )
+                    {
+                        try
+                        {
+                            xModifiable->setModified( false );
+                        }
+                        catch( css::beans::PropertyVetoException& )
+                        {
+                        }
+                    }
+                }
+                catch ( css::io::IOException& )
+                {
+                    eRet = SAVE_ERROR;
+                }
+            }
+            else
+            {
+                // We need 1:1 copy of the document to preserve an added signature.
+                aArgs.realloc( ++nNumArgs );
+                aArgs[nNumArgs-1].Name = "CopyStreamIfPossible";
+                aArgs[nNumArgs-1].Value <<= true;
+
+                try
+                {
+                    xStorable->storeToURL( aFileURL, aArgs );
+                    rFileNamePath = aFileURL;
+                    eRet = SAVE_SUCCESSFULL;
+                }
+                catch ( css::io::IOException& )
+                {
+                    eRet = SAVE_ERROR;
+                }
+            }
+        }
+    }
+
+    return eRet;
+}
+
+SfxMailModel::SfxMailModel()
+{
+}
+
+SfxMailModel::~SfxMailModel()
+{
+}
+
+void SfxMailModel::AddToAddress( const OUString& rAddress )
+{
+    // don't add an empty address
+    if ( !rAddress.isEmpty() )
+    {
+        if ( !mpToList )
+            // create the list
+            mpToList.reset(new AddressList_Impl);
+
+        // add address to list
+        mpToList->push_back( rAddress );
+    }
+}
+
+SfxMailModel::SendMailResult SfxMailModel::AttachDocument(
+    const css::uno::Reference< css::uno::XInterface >& xFrameOrModel,
+    const OUString& sAttachmentTitle )
+{
+    OUString sFileName;
+
+    SaveResult eSaveResult = SaveDocumentAsFormat( sAttachmentTitle, xFrameOrModel, OUString()/*sDocumentType*/, sFileName );
+    if ( eSaveResult == SAVE_SUCCESSFULL &&  !sFileName.isEmpty() )
+        maAttachedDocuments.push_back(sFileName);
+    return eSaveResult == SAVE_SUCCESSFULL ? SEND_MAIL_OK : SEND_MAIL_ERROR;
+}
+
+SfxMailModel::SendMailResult SfxMailModel::Send( const css::uno::Reference< css::frame::XFrame >& xFrame )
+{
+    OSL_ENSURE(!maAttachedDocuments.empty(),"No document added!");
+    SendMailResult  eResult = SEND_MAIL_ERROR;
+    if ( !maAttachedDocuments.empty() )
+    {
+        css::uno::Reference < XComponentContext > xContext = ::comphelper::getProcessComponentContext();
+
+        css::uno::Reference< XSimpleMailClientSupplier >    xSimpleMailClientSupplier;
+
+        // Prefer the SimpleSystemMail service if available
+        try {
+            xSimpleMailClientSupplier = SimpleSystemMail::create( xContext );
+        }
+        catch ( const uno::Exception & )
+        {}
+
+        if ( ! xSimpleMailClientSupplier.is() )
+        {
+            try {
+                xSimpleMailClientSupplier = SimpleCommandMail::create( xContext );
+            }
+            catch ( const uno::Exception & )
+            {}
+        }
+
+        if ( xSimpleMailClientSupplier.is() )
+        {
+            css::uno::Reference< XSimpleMailClient > xSimpleMailClient = xSimpleMailClientSupplier->querySimpleMailClient();
+
+            if ( !xSimpleMailClient.is() )
+            {
+                // no mail client support => message box!
+                return SEND_MAIL_ERROR;
+            }
+
+            // we have a simple mail client
+            css::uno::Reference< XSimpleMailMessage > xSimpleMailMessage = xSimpleMailClient->createSimpleMailMessage();
+            if ( xSimpleMailMessage.is() )
+            {
+                sal_Int32 nSendFlags = SimpleMailClientFlags::DEFAULTS;
+                if ( maFromAddress.isEmpty() )
+                {
+                    // from address not set, try figure out users e-mail address
+                    CreateFromAddress_Impl( maFromAddress );
+                }
+                xSimpleMailMessage->setOriginator( maFromAddress );
+
+                size_t nToCount     = mpToList ? mpToList->size() : 0;
+
+                // set recipient (only one) for this simple mail server!!
+                if ( nToCount >= 1 )
+                {
+                    xSimpleMailMessage->setRecipient( mpToList->at( 0 ) );
+                    nSendFlags = SimpleMailClientFlags::NO_USER_INTERFACE;
+                }
+
+                // all other recipient must be handled with CC recipients!
+                if ( nToCount > 1 )
+                {
+                    Sequence< OUString >    aCcRecipientSeq( nToCount - 1 );
+                    for ( size_t i = 1; i < nToCount; ++i )
+                        aCcRecipientSeq[i - 1] = mpToList->at(i);
+                    xSimpleMailMessage->setCcRecipient( aCcRecipientSeq );
+                }
+
+                Sequence< OUString > aAttachmentSeq(maAttachedDocuments.data(),maAttachedDocuments.size());
+
+                if ( xSimpleMailMessage->getSubject().isEmpty() ) {
+                    INetURLObject url(
+                        maAttachedDocuments[0], INetURLObject::EncodeMechanism::WasEncoded);
+                    OUString subject(
+                        url.getBase(
+                            INetURLObject::LAST_SEGMENT, false,
+                            INetURLObject::DecodeMechanism::WithCharset));
+                    if (subject.isEmpty()) {
+                        subject = maAttachedDocuments[0];
+                    }
+                    if ( maAttachedDocuments.size() > 1 )
+                        subject += ", ...";
+                    xSimpleMailMessage->setSubject( subject );
+                }
+                xSimpleMailMessage->setAttachement( aAttachmentSeq );
+
+                bool bSend( false );
+                try
+                {
+                    xSimpleMailClient->sendSimpleMailMessage( xSimpleMailMessage, nSendFlags );
+                    bSend = true;
+                }
+                catch ( IllegalArgumentException& )
+                {
+                }
+                catch ( Exception& )
+                {
+                }
+
+                if ( !bSend )
+                {
+                    css::uno::Reference< css::awt::XWindow > xParentWindow = xFrame->getContainerWindow();
+
+                    SolarMutexGuard aGuard;
+
+                    std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(Application::GetFrameWeld(xParentWindow), "sfx/ui/errorfindemaildialog.ui"));
+                    std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("ErrorFindEmailDialog"));
+                    xBox->run();
+                    eResult = SEND_MAIL_CANCELLED;
+                }
+                else
+                    eResult = SEND_MAIL_OK;
+            }
+        }
+    }
+    else
+        eResult = SEND_MAIL_CANCELLED;
+
+    return eResult;
+}
+
+SfxMailModel::SendMailResult SfxMailModel::SaveAndSend( const css::uno::Reference< css::frame::XFrame >& xFrame, const OUString& rTypeName )
+{
+    SaveResult      eSaveResult;
+    SendMailResult  eResult = SEND_MAIL_ERROR;
+    OUString   aFileName;
+
+    eSaveResult = SaveDocumentAsFormat( OUString(), xFrame, rTypeName, aFileName );
+
+    if ( eSaveResult == SAVE_SUCCESSFULL )
+    {
+        maAttachedDocuments.push_back( aFileName );
+        return Send( xFrame );
+    }
+    else if ( eSaveResult == SAVE_CANCELLED )
+        eResult = SEND_MAIL_CANCELLED;
+
+    return eResult;
+}
+
+// functions -------------------------------------------------------------
+
+bool CreateFromAddress_Impl( OUString& rFrom )
+
+/* [Description]
+
+    This function tries to create a From-address with the help of IniManagers.
+    For this the fields 'first name', 'Name' and 'Email' are read from the
+    application-ini-data. If these fields are not set, FALSE is returned.
+
+    [Return value]
+
+    sal_True:       Address could be created.
+    sal_False:      Address could not be created.
+*/
+
+{
+    SvtUserOptions aUserCFG;
+    OUString aName        = aUserCFG.GetLastName  ();
+    OUString aFirstName   = aUserCFG.GetFirstName ();
+    if ( !aFirstName.isEmpty() || !aName.isEmpty() )
+    {
+        if ( !aFirstName.isEmpty() )
+        {
+            rFrom = comphelper::string::strip(aFirstName, ' ');
+
+            if ( !aName.isEmpty() )
+                rFrom += " ";
+        }
+        rFrom += comphelper::string::strip(aName, ' ');
+        // remove illegal characters
+        rFrom = rFrom.replaceAll("<", "").replaceAll(">", "").replaceAll("@", "");
+    }
+    OUString aEmailName = aUserCFG.GetEmail();
+
+    // remove illegal characters
+    aEmailName = aEmailName.replaceAll("<", "").replaceAll(">", "");
+
+    if ( !aEmailName.isEmpty() )
+    {
+        if ( !rFrom.isEmpty() )
+            rFrom += " ";
+        rFrom += "<" + comphelper::string::strip(aEmailName, ' ') + ">";
+    }
+    else
+        rFrom.clear();
+    return !rFrom.isEmpty();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/mgetempl.cxx b/sfx2/source/dialog/mgetempl.cxx
new file mode 100644
index 000000000..46536f3f4
--- /dev/null
+++ b/sfx2/source/dialog/mgetempl.cxx
@@ -0,0 +1,648 @@
+/* -*- 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 <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <svl/style.hxx>
+#include <osl/diagnose.h>
+
+#include <sfx2/styfitem.hxx>
+#include <sfx2/styledlg.hxx>
+#include <sfx2/tabdlg.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/module.hxx>
+#include <sfx2/sfxsids.hrc>
+
+#include <sfx2/strings.hrc>
+
+#include <svl/stritem.hxx>
+#include <sfx2/dispatch.hxx>
+
+#include "mgetempl.hxx"
+
+/*  SfxManageStyleSheetPage Constructor
+ *
+ *  initializes the list box with the templates
+ */
+SfxManageStyleSheetPage::SfxManageStyleSheetPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttrSet)
+    : SfxTabPage(pPage, pController, "sfx/ui/managestylepage.ui", "ManageStylePage", &rAttrSet)
+    , pStyle(&static_cast<SfxStyleDialogController*>(pController)->GetStyleSheet())
+    , pItem(nullptr)
+    , bModified(false)
+    , aName(pStyle->GetName())
+    , aFollow(pStyle->GetFollow())
+    , aParent(pStyle->GetParent())
+    , nFlags(pStyle->GetMask())
+    , m_xName(m_xBuilder->weld_entry("name"))
+    , m_xAutoCB(m_xBuilder->weld_check_button("autoupdate"))
+    , m_xFollowFt(m_xBuilder->weld_label("nextstyleft"))
+    , m_xFollowLb(m_xBuilder->weld_combo_box("nextstyle"))
+    , m_xEditStyleBtn(m_xBuilder->weld_button("editstyle"))
+    , m_xBaseFt(m_xBuilder->weld_label("linkedwithft"))
+    , m_xBaseLb(m_xBuilder->weld_combo_box("linkedwith"))
+    , m_xEditLinkStyleBtn(m_xBuilder->weld_button("editlinkstyle"))
+    , m_xFilterFt(m_xBuilder->weld_label("categoryft"))
+    , m_xFilterLb(m_xBuilder->weld_combo_box("category"))
+    , m_xDescFt(m_xBuilder->weld_label("desc"))
+    , m_xNameFt(m_xBuilder->weld_label("nameft"))
+{
+    m_xFollowLb->make_sorted();
+    // tdf#120188 like SwCharURLPage limit the width of the style combos
+    const int nMaxWidth(m_xFollowLb->get_approximate_digit_width() * 50);
+    m_xFollowLb->set_size_request(nMaxWidth , -1);
+    m_xBaseLb->make_sorted();
+    m_xBaseLb->set_size_request(nMaxWidth , -1);
+    //note that the code depends on categories not being lexically
+    //sorted, so if it's changed to sorted, the code needs to
+    //be adapted to be position unaware
+    m_xFilterLb->set_size_request(nMaxWidth , -1);
+
+    // this Page needs ExchangeSupport
+    SetExchangeSupport();
+
+    if ( aFollow.isEmpty() || aFollow == aName )
+        m_xEditStyleBtn->set_sensitive(false);
+    else
+        m_xEditStyleBtn->set_sensitive(true);
+
+    int linkSelectPos = m_xBaseLb->get_active();
+    if ( linkSelectPos == 0 )
+        m_xEditLinkStyleBtn->set_sensitive(false);
+    else
+        m_xEditLinkStyleBtn->set_sensitive(true);
+
+    pFamilies = SfxApplication::GetModule_Impl()->CreateStyleFamilies();
+
+    SfxStyleSheetBasePool* pPool = nullptr;
+    SfxObjectShell* pDocShell = SfxObjectShell::Current();
+
+    if ( pDocShell )
+        pPool = pDocShell->GetStyleSheetPool();
+    OSL_ENSURE( pPool, "no Pool or no DocShell" );
+
+    if ( pPool )
+    {
+        pPool->First(pStyle->GetFamily()); // for SW - update internal list
+    }
+
+    if ( pStyle->GetName().isEmpty() && pPool )
+    {
+        // NullString as Name -> generate Name
+        OUString aNoName(SfxStyleDialogController::GenerateUnusedName(*pPool, pStyle->GetFamily()));
+        pStyle->SetName( aNoName );
+        aName = aNoName;
+        aFollow = pStyle->GetFollow();
+        aParent = pStyle->GetParent();
+    }
+    m_xName->set_text(pStyle->GetName());
+
+    // Set the field read-only if it is NOT an user-defined style
+    // but allow selecting and copying
+    if (pStyle->IsUserDefined())
+    {
+        m_xName->set_can_focus(true);
+        m_xName->set_editable(true);
+    }
+
+    if ( pStyle->HasFollowSupport() && pPool )
+    {
+        SfxStyleSheetBase* pPoolStyle = pPool->First(pStyle->GetFamily());
+
+        m_xFollowLb->freeze();
+
+        while ( pPoolStyle )
+        {
+            m_xFollowLb->append_text(pPoolStyle->GetName());
+            pPoolStyle = pPool->Next();
+        }
+
+        // A new Template is not yet in the Pool
+        if (m_xFollowLb->find_text(pStyle->GetName()) == -1)
+            m_xFollowLb->append_text(pStyle->GetName());
+
+        m_xFollowLb->thaw();
+    }
+    else
+    {
+        m_xFollowFt->set_sensitive(false);
+        m_xFollowFt->hide();
+        m_xFollowLb->set_sensitive(false);
+        m_xFollowLb->hide();
+        m_xEditStyleBtn->hide();
+    }
+
+    if ( pStyle->HasParentSupport() && pPool )
+    {
+        m_xBaseLb->freeze();
+
+        if ( pStyle->HasClearParentSupport() )
+            // the base template can be set to NULL
+            m_xBaseLb->append_text(SfxResId(STR_NONE));
+
+        SfxStyleSheetBase* pPoolStyle = pPool->First(pStyle->GetFamily());
+
+        while ( pPoolStyle )
+        {
+            const OUString aStr( pPoolStyle->GetName() );
+            // own name as base template
+            if ( aStr != aName )
+                m_xBaseLb->append_text(aStr);
+            pPoolStyle = pPool->Next();
+        }
+
+        m_xBaseLb->thaw();
+    }
+    else
+    {
+        m_xBaseFt->set_sensitive(false);
+        m_xBaseLb->set_sensitive(false);
+    }
+
+    size_t nCount = pFamilies->size();
+    size_t i;
+    for ( i = 0; i < nCount; ++i )
+    {
+        pItem = &(pFamilies->at(i));
+
+        if ( pItem->GetFamily() == pStyle->GetFamily() )
+            break;
+    }
+
+    if ( i < nCount )
+    {
+        sal_uInt16 nStyleFilterIdx = 0xffff;
+        // Filter flags
+        const SfxStyleFilter& rList = pItem->GetFilterList();
+        nCount = rList.size();
+        sal_uInt16 nIdx = 0;
+        SfxStyleSearchBits nMask = pStyle->GetMask() & ~SfxStyleSearchBits::UserDefined;
+
+        if ( nMask == SfxStyleSearchBits::Auto )   // User Template?
+            nMask = pStyle->GetMask();
+
+        for ( i = 0; i < nCount; ++i )
+        {
+            const SfxFilterTuple& rTupel = rList[ i ];
+
+            if ( rTupel.nFlags != SfxStyleSearchBits::Auto     &&
+                 rTupel.nFlags != SfxStyleSearchBits::Used     &&
+                 rTupel.nFlags != SfxStyleSearchBits::AllVisible &&
+                 rTupel.nFlags != SfxStyleSearchBits::All )
+            {
+                OUString sId(OUString::number(i));
+                m_xFilterLb->insert(nIdx, rTupel.aName, &sId, nullptr, nullptr);
+                if ( ( rTupel.nFlags & nMask ) == nMask )
+                    nStyleFilterIdx = nIdx;
+                ++nIdx;
+            }
+        }
+
+        if ( nStyleFilterIdx != 0xFFFF )
+            m_xFilterLb->set_active(nStyleFilterIdx);
+    }
+
+    if ( !m_xFilterLb->get_count() || !pStyle->IsUserDefined() )
+    {
+        pItem = nullptr;
+        m_xFilterFt->set_sensitive(false);
+        m_xFilterLb->set_sensitive(false);
+    }
+    else
+        m_xFilterLb->save_value();
+    SetDescriptionText_Impl();
+
+    if (m_xFollowLb->get_sensitive() || m_xBaseLb->get_sensitive())
+    {
+        m_xName->connect_focus_in(
+            LINK( this, SfxManageStyleSheetPage, GetFocusHdl ) );
+        m_xName->connect_focus_out(
+            LINK( this, SfxManageStyleSheetPage, LoseFocusHdl ) );
+    }
+    // It is a style with auto update? (SW only)
+    if(SfxItemState::SET == rAttrSet.GetItemState(SID_ATTR_AUTO_STYLE_UPDATE))
+        m_xAutoCB->show();
+    m_xFollowLb->connect_changed(LINK(this, SfxManageStyleSheetPage, EditStyleSelectHdl_Impl));
+    m_xBaseLb->connect_changed(LINK(this, SfxManageStyleSheetPage, EditLinkStyleSelectHdl_Impl));
+    m_xEditStyleBtn->connect_clicked(LINK(this, SfxManageStyleSheetPage, EditStyleHdl_Impl));
+    m_xEditLinkStyleBtn->connect_clicked(LINK(this, SfxManageStyleSheetPage, EditLinkStyleHdl_Impl));
+}
+
+SfxManageStyleSheetPage::~SfxManageStyleSheetPage()
+{
+    pFamilies.reset();
+    pItem = nullptr;
+    pStyle = nullptr;
+}
+
+void SfxManageStyleSheetPage::UpdateName_Impl( weld::ComboBox* pBox,
+                                               const OUString& rNew )
+
+/*  [Description]
+
+    After the change of a template name update the ListBox pBox
+
+    [Parameter]
+
+    ListBox* pBox         ListBox, whose entries are to be updated
+    const String& rNew    the new Name
+*/
+
+{
+    if (pBox->get_sensitive())
+    {
+        // it is the current entry, which name was modified
+        const bool bSelect = pBox->get_active_text() == aBuf;
+        int nOldIndex = pBox->find_text(aBuf);
+        if (nOldIndex != -1)
+            pBox->remove(nOldIndex);
+        pBox->append_text(rNew);
+
+        if (bSelect)
+            pBox->set_active_text(rNew);
+    }
+}
+
+void SfxManageStyleSheetPage::SetDescriptionText_Impl()
+
+/*  [Description]
+
+    Set attribute description. Get the set metric for this.
+*/
+
+{
+    MapUnit eUnit = MapUnit::MapCM;
+    FieldUnit eFieldUnit( FieldUnit::CM );
+    SfxModule* pModule = SfxModule::GetActiveModule();
+    if ( pModule )
+    {
+        const SfxPoolItem* pPoolItem = pModule->GetItem( SID_ATTR_METRIC );
+        if ( pPoolItem )
+            eFieldUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>( pPoolItem )->GetValue());
+    }
+
+    switch ( eFieldUnit )
+    {
+        case FieldUnit::MM:      eUnit = MapUnit::MapMM; break;
+        case FieldUnit::CM:
+        case FieldUnit::M:
+        case FieldUnit::KM:      eUnit = MapUnit::MapCM; break;
+        case FieldUnit::POINT:
+        case FieldUnit::PICA:    eUnit = MapUnit::MapPoint; break;
+        case FieldUnit::INCH:
+        case FieldUnit::FOOT:
+        case FieldUnit::MILE:    eUnit = MapUnit::MapInch; break;
+
+        default:
+            OSL_FAIL( "non supported field unit" );
+    }
+    m_xDescFt->set_label(pStyle->GetDescription(eUnit));
+}
+
+IMPL_LINK_NOARG(SfxManageStyleSheetPage, EditStyleSelectHdl_Impl, weld::ComboBox&, void)
+{
+    OUString aTemplName(m_xFollowLb->get_active_text());
+    OUString aEditTemplName(m_xName->get_text());
+    m_xEditStyleBtn->set_sensitive(aTemplName != aEditTemplName);
+}
+
+IMPL_LINK_NOARG(SfxManageStyleSheetPage, EditStyleHdl_Impl, weld::Button&, void)
+{
+    OUString aTemplName(m_xFollowLb->get_active_text());
+    Execute_Impl(SID_STYLE_EDIT, aTemplName, static_cast<sal_uInt16>(pStyle->GetFamily()));
+}
+
+IMPL_LINK_NOARG(SfxManageStyleSheetPage, EditLinkStyleSelectHdl_Impl, weld::ComboBox&, void)
+{
+    int linkSelectPos = m_xBaseLb->get_active();
+    if ( linkSelectPos == 0 )
+        m_xEditLinkStyleBtn->set_sensitive(false);
+    else
+        m_xEditLinkStyleBtn->set_sensitive(true);
+}
+
+IMPL_LINK_NOARG(SfxManageStyleSheetPage, EditLinkStyleHdl_Impl, weld::Button&, void)
+{
+    OUString aTemplName(m_xBaseLb->get_active_text());
+    if (aTemplName != SfxResId(STR_NONE))
+        Execute_Impl( SID_STYLE_EDIT, aTemplName, static_cast<sal_uInt16>(pStyle->GetFamily()) );
+}
+
+// Internal: Perform functions through the Dispatcher
+bool SfxManageStyleSheetPage::Execute_Impl(
+    sal_uInt16 nId, const OUString &rStr, sal_uInt16 nFamily)
+{
+
+    SfxDispatcher &rDispatcher = *SfxGetpApp()->GetDispatcher_Impl();
+    SfxStringItem aItem(nId, rStr);
+    SfxUInt16Item aFamily(SID_STYLE_FAMILY, nFamily);
+    const SfxPoolItem* pItems[ 6 ];
+    sal_uInt16 nCount = 0;
+    if( !rStr.isEmpty() )
+        pItems[ nCount++ ] = &aItem;
+    pItems[ nCount++ ] = &aFamily;
+
+    pItems[ nCount++ ] = nullptr;
+
+    const SfxPoolItem* pItem = rDispatcher.Execute(
+        nId, SfxCallMode::SYNCHRON | SfxCallMode::RECORD,
+        pItems );
+
+    return pItem != nullptr;
+
+}
+
+IMPL_LINK(SfxManageStyleSheetPage, GetFocusHdl, weld::Widget&, rControl, void)
+
+/*  [Description]
+
+    StarView Handler; GetFocus-Handler of the Edits with the template name.
+*/
+
+{
+    weld::Entry& rEdit = dynamic_cast<weld::Entry&>(rControl);
+    aBuf = comphelper::string::stripStart(rEdit.get_text(), ' ');
+}
+
+IMPL_LINK(SfxManageStyleSheetPage, LoseFocusHdl, weld::Widget&, rControl, void)
+
+/*  [Description]
+
+    StarView Handler; lose-focus-handler of the edits of the template name.
+    This will update the listbox with the subsequent templates. The current
+    template itself is not returned in the listbox of the base templates.
+*/
+
+{
+    weld::Entry& rEdit = dynamic_cast<weld::Entry&>(rControl);
+    const OUString aStr(comphelper::string::stripStart(rEdit.get_text(), ' '));
+    rEdit.set_text(aStr);
+    // Update the Listbox of the base template if possible
+    if ( aStr != aBuf )
+        UpdateName_Impl(m_xFollowLb.get(), aStr);
+}
+
+bool SfxManageStyleSheetPage::FillItemSet( SfxItemSet* rSet )
+
+/*  [Description]
+
+    Handler for setting the (modified) data. I called from the OK of the
+    SfxTabDialog.
+
+    [Parameter]
+
+    SfxItemSet &rAttrSet    The set, which receives the data.
+
+    [Return value]
+
+    sal_Bool                sal_True:  The data had been changed
+                            sal_False: The data had not been changed
+
+    [Cross-reference]
+
+    <class SfxTabDialog>
+*/
+
+{
+    const int nFilterIdx = m_xFilterLb->get_active();
+
+    // Set Filter
+
+    if ( nFilterIdx != -1 &&
+         m_xFilterLb->get_value_changed_from_saved() &&
+         m_xFilterLb->get_sensitive() )
+    {
+        bModified = true;
+        OSL_ENSURE( pItem, "No Item" );
+        // is only possibly for user templates
+        SfxStyleSearchBits nMask = pItem->GetFilterList()[m_xFilterLb->get_id(nFilterIdx).toUInt32()].nFlags | SfxStyleSearchBits::UserDefined;
+        pStyle->SetMask( nMask );
+    }
+    if (m_xAutoCB->get_visible() && m_xAutoCB->get_state_changed_from_saved())
+    {
+        rSet->Put(SfxBoolItem(SID_ATTR_AUTO_STYLE_UPDATE, m_xAutoCB->get_active()));
+    }
+
+    return bModified;
+}
+
+
+void SfxManageStyleSheetPage::Reset( const SfxItemSet* /*rAttrSet*/ )
+
+/*  [Description]
+
+    Handler to initialize the page with the initial data.
+
+    [Parameter]
+
+    const SfxItemSet &rAttrSet          The data set
+
+    [Cross-reference]
+
+    <class SfxTabDialog>
+*/
+
+{
+    bModified = false;
+    OUString sCmp( pStyle->GetName() );
+
+    if ( sCmp != aName )
+        pStyle->SetName( aName );
+    m_xName->set_text( aName );
+    if (m_xName->get_editable())
+        m_xName->select_region(0, -1);
+
+    if ( m_xFollowLb->get_sensitive() )
+    {
+        sCmp = pStyle->GetFollow();
+
+        if ( sCmp != aFollow )
+            pStyle->SetFollow( aFollow );
+
+        if ( aFollow.isEmpty() )
+        {
+            m_xFollowLb->set_active_text( aName );
+            m_xEditStyleBtn->set_sensitive( false );
+        }
+        else
+            m_xFollowLb->set_active_text( aFollow );
+    }
+
+    if (m_xBaseLb->get_sensitive())
+    {
+        sCmp = pStyle->GetParent();
+
+        if ( sCmp != aParent )
+            pStyle->SetParent( aParent );
+
+        if ( aParent.isEmpty() )
+        {
+            m_xBaseLb->set_active_text( SfxResId(STR_NONE) );
+            m_xEditLinkStyleBtn->set_sensitive( false );
+        }
+        else
+            m_xBaseLb->set_active_text( aParent );
+
+        if ( SfxResId(STR_STANDARD) == aName )
+        {
+            // the default template can not be linked
+            m_xBaseFt->set_sensitive(false);
+            m_xBaseLb->set_sensitive(false);
+        }
+    }
+    else
+        m_xEditLinkStyleBtn->set_sensitive( false );
+
+    if (m_xFilterLb->get_sensitive())
+    {
+        SfxStyleSearchBits nCmp = pStyle->GetMask();
+
+        if ( nCmp != nFlags )
+            pStyle->SetMask( nFlags );
+        m_xFilterLb->set_active_text(m_xFilterLb->get_saved_value());
+    }
+}
+
+std::unique_ptr<SfxTabPage> SfxManageStyleSheetPage::Create( weld::Container* pPage, weld::DialogController* pController,
+                                                    const SfxItemSet *rAttrSet )
+{
+    return std::make_unique<SfxManageStyleSheetPage>(pPage, pController, *rAttrSet);
+}
+
+void SfxManageStyleSheetPage::ActivatePage( const SfxItemSet& rSet)
+
+/*  [Description]
+
+    ActivatePage handler of SfxTabDialog, is used for the update of the
+    descriptive text, since this might have changed through changes of data on
+    other pages.
+
+    [Parameter]
+
+    const SfxItemSet&    the set for the exchange of data; is not used here.
+
+    [Cross-reference]
+
+    <SfxTabDialog::ActivatePage(const SfxItemSet &)>
+*/
+
+{
+    SetDescriptionText_Impl();
+
+    // It is a style with auto update? (SW only)
+    const SfxPoolItem* pPoolItem;
+
+    if ( SfxItemState::SET ==
+         rSet.GetItemState( SID_ATTR_AUTO_STYLE_UPDATE, false, &pPoolItem ) )
+        m_xAutoCB->set_active(static_cast<const SfxBoolItem*>(pPoolItem)->GetValue());
+    m_xAutoCB->save_state();
+    m_xName->save_value();
+}
+
+DeactivateRC SfxManageStyleSheetPage::DeactivatePage( SfxItemSet* pItemSet )
+
+/*  [Description]
+
+    DeactivatePage-handler of SfxTabDialog; data is set on the template, so
+    that the correct inheritance on the other pages of the dialog is made.
+    If an error occurs, leaving the page is prevented.
+    [Parameter]
+
+    SfxItemSet*    the set for the exchange of data; is not used here.
+
+    [Cross-reference]
+
+    <SfxTabDialog::DeactivatePage(SfxItemSet*)>
+*/
+
+{
+    DeactivateRC nRet = DeactivateRC::LeavePage;
+
+    if (m_xName->get_value_changed_from_saved())
+    {
+        // By pressing <Enter> LoseFocus() is not triggered through StarView
+        if (m_xName->has_focus())
+            LoseFocusHdl( *m_xName );
+
+        if (!pStyle->SetName(comphelper::string::stripStart(m_xName->get_text(), ' ')))
+        {
+            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrameWeld(),
+                                                                     VclMessageType::Info, VclButtonsType::Ok,
+                                                                     SfxResId(STR_TABPAGE_INVALIDNAME)));
+            xBox->run();
+            m_xName->grab_focus();
+            m_xName->select_region(0, -1);
+            return DeactivateRC::KeepPage;
+        }
+        bModified = true;
+    }
+
+    if (pStyle->HasFollowSupport() && m_xFollowLb->get_sensitive())
+    {
+        const OUString aFollowEntry( m_xFollowLb->get_active_text() );
+
+        if ( pStyle->GetFollow() != aFollowEntry )
+        {
+            if ( !pStyle->SetFollow( aFollowEntry ) )
+            {
+                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrameWeld(),
+                                                                         VclMessageType::Info, VclButtonsType::Ok,
+                                                                         SfxResId(STR_TABPAGE_INVALIDSTYLE)));
+                xBox->run();
+                m_xFollowLb->grab_focus();
+                return DeactivateRC::KeepPage;
+            }
+            bModified = true;
+        }
+    }
+
+    if (m_xBaseLb->get_sensitive())
+    {
+        OUString aParentEntry( m_xBaseLb->get_active_text() );
+
+        if ( SfxResId(STR_NONE) == aParentEntry || aParentEntry == pStyle->GetName() )
+            aParentEntry.clear();
+
+        if ( pStyle->GetParent() != aParentEntry )
+        {
+            if ( !pStyle->SetParent( aParentEntry ) )
+            {
+                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetFrameWeld(),
+                                                                         VclMessageType::Info, VclButtonsType::Ok,
+                                                                         SfxResId(STR_TABPAGE_INVALIDPARENT)));
+                xBox->run();
+                m_xBaseLb->grab_focus();
+                return DeactivateRC::KeepPage;
+            }
+            bModified = true;
+            nRet = nRet | DeactivateRC::RefreshSet;
+        }
+    }
+
+    if ( pItemSet )
+        FillItemSet( pItemSet );
+
+    return nRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/mgetempl.hxx b/sfx2/source/dialog/mgetempl.hxx
new file mode 100644
index 000000000..97e1c843e
--- /dev/null
+++ b/sfx2/source/dialog/mgetempl.hxx
@@ -0,0 +1,94 @@
+/* -*- 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_MGETEMPL_HXX
+#define INCLUDED_SFX2_MGETEMPL_HXX
+
+#include <sfx2/styfitem.hxx>
+#include <sfx2/tabdlg.hxx>
+#include <memory>
+
+namespace weld { class Button; }
+namespace weld { class CheckButton; }
+namespace weld { class ComboBox; }
+namespace weld { class Entry; }
+namespace weld { class Label; }
+namespace weld { class Widget; }
+
+/* expected:
+    SID_TEMPLATE_NAME   :   In: StringItem, Name of Template
+    SID_TEMPLATE_FAMILY :   In: Family of Template
+*/
+
+class SfxManageStyleSheetPage final : public SfxTabPage
+{
+    SfxStyleSheetBase *pStyle;
+    std::unique_ptr<SfxStyleFamilies> pFamilies;
+    const SfxStyleFamilyItem *pItem;
+    OUString aBuf;
+    bool bModified;
+
+    // initial data for the style
+    OUString aName;
+    OUString aFollow;
+    OUString aParent;
+    SfxStyleSearchBits nFlags;
+
+    std::unique_ptr<weld::Entry> m_xName;
+    std::unique_ptr<weld::CheckButton> m_xAutoCB;
+    std::unique_ptr<weld::Label> m_xFollowFt;
+    std::unique_ptr<weld::ComboBox> m_xFollowLb;
+    std::unique_ptr<weld::Button> m_xEditStyleBtn;
+    std::unique_ptr<weld::Label> m_xBaseFt;
+    std::unique_ptr<weld::ComboBox>          m_xBaseLb;
+    std::unique_ptr<weld::Button> m_xEditLinkStyleBtn;
+    std::unique_ptr<weld::Label> m_xFilterFt;
+    std::unique_ptr<weld::ComboBox> m_xFilterLb;
+    std::unique_ptr<weld::Label> m_xDescFt;
+    std::unique_ptr<weld::Label> m_xNameFt;
+
+    friend class SfxStyleDialogController;
+
+    DECL_LINK(GetFocusHdl, weld::Widget&, void);
+    DECL_LINK(LoseFocusHdl, weld::Widget&, void);
+    DECL_LINK(EditStyleSelectHdl_Impl, weld::ComboBox&, void);
+    DECL_LINK(EditStyleHdl_Impl, weld::Button&, void);
+    DECL_LINK(EditLinkStyleSelectHdl_Impl, weld::ComboBox&, void);
+    DECL_LINK(EditLinkStyleHdl_Impl, weld::Button&, void);
+
+    void    UpdateName_Impl(weld::ComboBox*, const OUString &rNew);
+    void    SetDescriptionText_Impl();
+
+
+    static std::unique_ptr<SfxTabPage> Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* );
+
+    virtual bool        FillItemSet(SfxItemSet *) override;
+    virtual void        Reset(const SfxItemSet *) override;
+
+    static bool    Execute_Impl( sal_uInt16 nId, const OUString& rStr, sal_uInt16 nFamily );
+    virtual void        ActivatePage(const SfxItemSet &) override;
+    virtual DeactivateRC DeactivatePage(SfxItemSet *) override;
+
+public:
+    SfxManageStyleSheetPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rAttrSet);
+    virtual ~SfxManageStyleSheetPage() override;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/navigat.cxx b/sfx2/source/dialog/navigat.cxx
new file mode 100644
index 000000000..33456d7bd
--- /dev/null
+++ b/sfx2/source/dialog/navigat.cxx
@@ -0,0 +1,74 @@
+/* -*- 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 <sfx2/bindings.hxx>
+#include <sfx2/navigat.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+#include <helpids.h>
+#include <tools/debug.hxx>
+
+SFX_IMPL_DOCKINGWINDOW( SfxNavigatorWrapper , SID_NAVIGATOR );
+
+SfxNavigatorWrapper::SfxNavigatorWrapper( vcl::Window* pParentWnd ,
+                                                sal_uInt16 nId ,
+                                                SfxBindings* pBindings ,
+                                                SfxChildWinInfo* pInfo )
+                    : SfxChildWindow( pParentWnd , nId )
+{
+    SetWindow( VclPtr<SfxNavigator>::Create( pBindings, this, pParentWnd,
+        WB_STDDOCKWIN | WB_CLIPCHILDREN | WB_SIZEABLE | WB_3DLOOK | WB_ROLLABLE) );
+
+    GetWindow()->SetHelpId ( HID_NAVIGATOR_WINDOW );
+    GetWindow()->SetOutputSizePixel( Size( 270, 240 ) );
+
+    static_cast<SfxDockingWindow*>( GetWindow() )->Initialize( pInfo );
+    SetHideNotDelete( true );
+}
+
+SfxNavigator::SfxNavigator( SfxBindings* pBind ,
+                            SfxChildWindow* pChildWin ,
+                            vcl::Window* pParent ,
+                            WinBits nBits )
+                        : SfxDockingWindow( pBind ,
+                                            pChildWin ,
+                                            pParent ,
+                                            nBits )
+                        , pWrapper( pChildWin )
+{
+    SetText(SfxResId(STR_SID_NAVIGATOR));
+}
+
+void SfxNavigator::Resize()
+{
+    SfxDockingWindow::Resize();
+    if ( pWrapper->GetContextWindow() )
+        pWrapper->GetContextWindow()->SetSizePixel( GetOutputSizePixel() );
+}
+
+bool SfxNavigator::Close()
+{
+    DBG_ASSERT( GetChildWindow_Impl()->GetContext_Impl(), "No Context!" );
+    return SfxDockingWindow::Close();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/newstyle.cxx b/sfx2/source/dialog/newstyle.cxx
new file mode 100644
index 000000000..fcb2e9aac
--- /dev/null
+++ b/sfx2/source/dialog/newstyle.cxx
@@ -0,0 +1,92 @@
+/* -*- 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/style.hxx>
+
+#include <sfx2/newstyle.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+
+// Private methods ------------------------------------------------------
+
+IMPL_LINK_NOARG(SfxNewStyleDlg, OKClickHdl, weld::Button&, void)
+{
+    const OUString aName(m_xColBox->get_active_text());
+    SfxStyleSheetBase* pStyle = m_rPool.Find(aName, m_eSearchFamily);
+    if ( pStyle )
+    {
+        if ( !pStyle->IsUserDefined() )
+        {
+            std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                                     VclMessageType::Info, VclButtonsType::Ok,
+                                                                     SfxResId(STR_POOL_STYLE_NAME)));
+            xBox->run();
+            return;
+        }
+
+        if (RET_YES == m_xQueryOverwriteBox->run())
+            m_xDialog->response(RET_OK);
+    }
+    else
+        m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK_NOARG(SfxNewStyleDlg, OKHdl, weld::TreeView&, bool)
+{
+    OKClickHdl(*m_xOKBtn);
+    return true;
+}
+
+IMPL_LINK(SfxNewStyleDlg, ModifyHdl, weld::ComboBox&, rBox, void)
+{
+    m_xOKBtn->set_sensitive(!rBox.get_active_text().replaceAll(" ", "").isEmpty());
+}
+
+SfxNewStyleDlg::SfxNewStyleDlg(weld::Window* pParent, SfxStyleSheetBasePool& rInPool, SfxStyleFamily eFam)
+    : GenericDialogController(pParent, "sfx/ui/newstyle.ui", "CreateStyleDialog")
+    , m_rPool(rInPool)
+    , m_eSearchFamily(eFam)
+    , m_xColBox(m_xBuilder->weld_entry_tree_view("stylegrid", "stylename", "styles"))
+    , m_xOKBtn(m_xBuilder->weld_button("ok"))
+    , m_xQueryOverwriteBox(Application::CreateMessageDialog(m_xDialog.get(), VclMessageType::Question, VclButtonsType::YesNo,
+                                                                           SfxResId(STR_QUERY_OVERWRITE)))
+{
+    m_xColBox->set_entry_width_chars(20);
+    m_xColBox->set_height_request_by_rows(8);
+
+    m_xOKBtn->connect_clicked(LINK(this, SfxNewStyleDlg, OKClickHdl));
+    m_xColBox->connect_changed(LINK(this, SfxNewStyleDlg, ModifyHdl));
+    m_xColBox->connect_row_activated(LINK(this, SfxNewStyleDlg, OKHdl));
+
+    auto xIter = m_rPool.CreateIterator(eFam, SfxStyleSearchBits::UserDefined);
+    SfxStyleSheetBase *pStyle = xIter->First();
+    while (pStyle)
+    {
+        m_xColBox->append_text(pStyle->GetName());
+        pStyle = xIter->Next();
+    }
+}
+
+SfxNewStyleDlg::~SfxNewStyleDlg()
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/partwnd.cxx b/sfx2/source/dialog/partwnd.cxx
new file mode 100644
index 000000000..367eb49e0
--- /dev/null
+++ b/sfx2/source/dialog/partwnd.cxx
@@ -0,0 +1,175 @@
+/* -*- 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/beans/XPropertySet.hpp>
+#include <com/sun/star/frame/Frame.hpp>
+#include <com/sun/star/frame/XController.hpp>
+#include <com/sun/star/uno/Reference.h>
+#include <comphelper/processfactory.hxx>
+#include <osl/diagnose.h>
+
+#include <toolkit/helper/vclunohelper.hxx>
+
+#include <vcl/event.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <partwnd.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/frame.hxx>
+
+
+// SfxPartChildWnd_Impl
+
+
+SFX_IMPL_DOCKINGWINDOW( SfxPartChildWnd_Impl, SID_BROWSER );
+
+SfxPartChildWnd_Impl::SfxPartChildWnd_Impl
+(
+    vcl::Window* pParentWnd,
+    sal_uInt16 nId,
+    SfxBindings* pBindings,
+    SfxChildWinInfo* pInfo
+)
+    : SfxChildWindow( pParentWnd, nId )
+{
+    // Create Window
+    SetWindow(VclPtr<SfxPartDockWnd_Impl>::Create( pBindings, this, pParentWnd, WB_STDDOCKWIN | WB_CLIPCHILDREN | WB_SIZEABLE | WB_3DLOOK ));
+    SetAlignment(SfxChildAlignment::TOP);
+
+    assert(pInfo);
+    pInfo->nFlags |= SfxChildWindowFlags::FORCEDOCK;
+
+    static_cast<SfxDockingWindow*>(GetWindow())->SetFloatingSize( Size( 175, 175 ) );
+    GetWindow()->SetSizePixel( Size( 175, 175 ) );
+
+    static_cast<SfxDockingWindow*>(GetWindow())->Initialize( pInfo );
+    SetHideNotDelete( true );
+}
+
+SfxPartChildWnd_Impl::~SfxPartChildWnd_Impl()
+{
+    css::uno::Reference< css::frame::XFrame > xFrame = GetFrame();
+
+    // If xFrame=NULL release pMgr! Because this window lives longer then the manager!
+    // In these case we got a xFrame->dispose() call from outside ... and has release our
+    // frame reference in our own DisposingListener.
+    // But don't do it, if xFrame already exist. Then dispose() must come from inside ...
+    // and we need a valid pMgr for further operations ...
+
+    SfxPartDockWnd_Impl* pWin = static_cast<SfxPartDockWnd_Impl*>(GetWindow());
+
+    if ( pWin && xFrame == pWin->GetBindings().GetActiveFrame() )
+        pWin->GetBindings().SetActiveFrame( nullptr );
+}
+
+bool SfxPartChildWnd_Impl::QueryClose()
+{
+    return static_cast<SfxPartDockWnd_Impl*>(GetWindow())->QueryClose();
+}
+
+
+// SfxPartDockWnd_Impl
+
+
+SfxPartDockWnd_Impl::SfxPartDockWnd_Impl
+(
+    SfxBindings* pBind,
+    SfxChildWindow* pChildWin,
+    vcl::Window* pParent,
+    WinBits nBits
+)
+    : SfxDockingWindow( pBind, pChildWin, pParent, nBits )
+{
+    css::uno::Reference < css::frame::XFrame2 > xFrame = css::frame::Frame::create(
+            ::comphelper::getProcessComponentContext() );
+    xFrame->initialize( VCLUnoHelper::GetInterface ( this ) );
+
+    try
+    {
+        css::uno::Reference< css::beans::XPropertySet > xLMPropSet( xFrame->getLayoutManager(), css::uno::UNO_QUERY_THROW );
+
+        const OUString aAutomaticToolbars( "AutomaticToolbars" );
+        xLMPropSet->setPropertyValue( aAutomaticToolbars, css::uno::Any( false ));
+    }
+    catch( css::uno::RuntimeException& )
+    {
+        throw;
+    }
+    catch( css::uno::Exception& )
+    {
+    }
+
+    pChildWin->SetFrame( css::uno::Reference<css::frame::XFrame>(xFrame,css::uno::UNO_QUERY_THROW) );
+    if ( pBind->GetDispatcher() )
+    {
+        css::uno::Reference < css::frame::XFramesSupplier >
+                xSupp ( pBind->GetDispatcher()->GetFrame()->GetFrame().GetFrameInterface(), css::uno::UNO_QUERY );
+        if ( xSupp.is() )
+            xSupp->getFrames()->append( css::uno::Reference<css::frame::XFrame>(xFrame, css::uno::UNO_QUERY_THROW) );
+    }
+    else {
+        OSL_FAIL("Bindings without Dispatcher!");
+    }
+}
+
+
+bool SfxPartDockWnd_Impl::QueryClose()
+{
+    bool bClose = true;
+    SfxChildWindow* pChild = GetChildWindow_Impl();
+    if( pChild )
+    {
+        css::uno::Reference< css::frame::XFrame > xFrame = pChild->GetFrame();
+        if( xFrame.is() )
+        {
+            css::uno::Reference< css::frame::XController >  xCtrl = xFrame->getController();
+            if( xCtrl.is() )
+                bClose = xCtrl->suspend( true );
+        }
+    }
+
+    return bClose;
+}
+
+
+bool SfxPartDockWnd_Impl::EventNotify( NotifyEvent& rEvt )
+{
+    if( rEvt.GetType() == MouseNotifyEvent::GETFOCUS )
+    {
+        SfxChildWindow* pChild = GetChildWindow_Impl();
+        if( pChild )
+        {
+            css::uno::Reference< css::frame::XFrame > xFrame = pChild->GetFrame();
+            if( xFrame.is() )
+                xFrame->activate();
+        }
+    }
+
+    return SfxDockingWindow::EventNotify( rEvt );
+}
+
+void SfxPartDockWnd_Impl::FillInfo( SfxChildWinInfo& rInfo ) const
+{
+    SfxDockingWindow::FillInfo( rInfo );
+    rInfo.bVisible = false;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/passwd.cxx b/sfx2/source/dialog/passwd.cxx
new file mode 100644
index 000000000..efc108278
--- /dev/null
+++ b/sfx2/source/dialog/passwd.cxx
@@ -0,0 +1,195 @@
+/* -*- 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/passwd.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/strings.hrc>
+#include <rtl/ustrbuf.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+
+IMPL_LINK_NOARG(SfxPasswordDialog, EditModifyHdl, weld::Entry&, void)
+{
+    ModifyHdl();
+}
+
+void SfxPasswordDialog::ModifyHdl()
+{
+    bool bEnable = m_xPassword1ED->get_text().getLength() >= mnMinLen;
+    if (m_xPassword2ED->get_visible())
+        bEnable = (bEnable && (m_xPassword2ED->get_text().getLength() >= mnMinLen));
+    m_xOKBtn->set_sensitive(bEnable);
+}
+
+IMPL_LINK(SfxPasswordDialog, InsertTextHdl, OUString&, rTest, bool)
+{
+    if (!mbAsciiOnly)
+        return true;
+
+    const sal_Unicode* pTest = rTest.getStr();
+    sal_Int32 nLen = rTest.getLength();
+    OUStringBuffer aFilter(nLen);
+    bool bReset = false;
+    for (sal_Int32 i = 0; i < nLen; ++i)
+    {
+        if( *pTest > 0x007f )
+            bReset = true;
+        else
+            aFilter.append(*pTest);
+        ++pTest;
+    }
+
+    if (bReset)
+        rTest = aFilter.makeStringAndClear();
+
+    return true;
+}
+
+IMPL_LINK_NOARG(SfxPasswordDialog, OKHdl, weld::Button&, void)
+{
+    bool bConfirmFailed = bool( mnExtras & SfxShowExtras::CONFIRM ) &&
+                          ( GetConfirm() != GetPassword() );
+    if( ( mnExtras & SfxShowExtras::CONFIRM2 ) && ( m_xConfirm2ED->get_text() != GetPassword2() ) )
+        bConfirmFailed = true;
+    if ( bConfirmFailed )
+    {
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(),
+                                                                 VclMessageType::Warning, VclButtonsType::Ok,
+                                                                 SfxResId(STR_ERROR_WRONG_CONFIRM)));
+        xBox->run();
+        m_xConfirm1ED->set_text(OUString());
+        m_xConfirm1ED->grab_focus();
+    }
+    else
+        m_xDialog->response(RET_OK);
+}
+
+// CTOR / DTOR -----------------------------------------------------------
+
+SfxPasswordDialog::SfxPasswordDialog(weld::Widget* pParent, const OUString* pGroupText)
+    : GenericDialogController(pParent, "sfx/ui/password.ui", "PasswordDialog")
+    , m_xPassword1Box(m_xBuilder->weld_frame("password1frame"))
+    , m_xUserFT(m_xBuilder->weld_label("userft"))
+    , m_xUserED(m_xBuilder->weld_entry("usered"))
+    , m_xPassword1FT(m_xBuilder->weld_label("pass1ft"))
+    , m_xPassword1ED(m_xBuilder->weld_entry("pass1ed"))
+    , m_xConfirm1FT(m_xBuilder->weld_label("confirm1ft"))
+    , m_xConfirm1ED(m_xBuilder->weld_entry("confirm1ed"))
+    , m_xPassword2Box(m_xBuilder->weld_frame("password2frame"))
+    , m_xPassword2FT(m_xBuilder->weld_label("pass2ft"))
+    , m_xPassword2ED(m_xBuilder->weld_entry("pass2ed"))
+    , m_xConfirm2FT(m_xBuilder->weld_label("confirm2ft"))
+    , m_xConfirm2ED(m_xBuilder->weld_entry("confirm2ed"))
+    , m_xMinLengthFT(m_xBuilder->weld_label("minlenft"))
+    , m_xOKBtn(m_xBuilder->weld_button("ok"))
+    , maMinLenPwdStr(SfxResId(STR_PASSWD_MIN_LEN))
+    , maMinLenPwdStr1(SfxResId(STR_PASSWD_MIN_LEN1))
+    , maEmptyPwdStr(SfxResId(STR_PASSWD_EMPTY))
+    , mnMinLen(5)
+    , mnExtras(SfxShowExtras::NONE)
+    , mbAsciiOnly(false)
+{
+    Link<weld::Entry&,void> aLink = LINK(this, SfxPasswordDialog, EditModifyHdl);
+    m_xPassword1ED->connect_changed(aLink);
+    m_xPassword2ED->connect_changed(aLink);
+    Link<OUString&,bool> aLink2 = LINK(this, SfxPasswordDialog, InsertTextHdl);
+    m_xPassword1ED->connect_insert_text(aLink2);
+    m_xPassword2ED->connect_insert_text(aLink2);
+    m_xOKBtn->connect_clicked(LINK(this, SfxPasswordDialog, OKHdl));
+
+    if (pGroupText)
+        m_xPassword1Box->set_label(*pGroupText);
+
+    //set the text to the password length
+    SetPasswdText();
+}
+
+void SfxPasswordDialog::SetPasswdText( )
+{
+    //set the new string to the minimum password length
+    if (mnMinLen == 0)
+        m_xMinLengthFT->set_label(maEmptyPwdStr);
+    else
+    {
+        if( mnMinLen == 1 )
+            m_xMinLengthFT->set_label(maMinLenPwdStr1);
+        else
+        {
+            maMainPwdStr = maMinLenPwdStr;
+            maMainPwdStr = maMainPwdStr.replaceAll( "$(MINLEN)", OUString::number(static_cast<sal_Int32>(mnMinLen) ) );
+            m_xMinLengthFT->set_label(maMainPwdStr);
+        }
+    }
+}
+
+
+void SfxPasswordDialog::SetMinLen( sal_uInt16 nLen )
+{
+    mnMinLen = nLen;
+    SetPasswdText();
+    ModifyHdl();
+}
+
+void SfxPasswordDialog::ShowMinLengthText(bool bShow)
+{
+    m_xMinLengthFT->set_visible(bShow);
+}
+
+short SfxPasswordDialog::run()
+{
+    m_xUserFT->hide();
+    m_xUserED->hide();
+    m_xConfirm1FT->hide();
+    m_xConfirm1ED->hide();
+    m_xPassword1FT->hide();
+    m_xPassword2Box->hide();
+    m_xPassword2FT->hide();
+    m_xPassword2ED->hide();
+    m_xPassword2FT->hide();
+    m_xConfirm2FT->hide();
+    m_xConfirm2ED->hide();
+
+    if (mnExtras != SfxShowExtras::NONE)
+        m_xPassword1FT->show();
+    if (mnExtras & SfxShowExtras::USER)
+    {
+        m_xUserFT->show();
+        m_xUserED->show();
+    }
+    if (mnExtras & SfxShowExtras::CONFIRM)
+    {
+        m_xConfirm1FT->show();
+        m_xConfirm1ED->show();
+    }
+    if (mnExtras & SfxShowExtras::PASSWORD2)
+    {
+        m_xPassword2Box->show();
+        m_xPassword2FT->show();
+        m_xPassword2ED->show();
+    }
+    if (mnExtras & SfxShowExtras::CONFIRM2)
+    {
+        m_xConfirm2FT->show();
+        m_xConfirm2ED->show();
+    }
+
+    return GenericDialogController::run();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/printopt.cxx b/sfx2/source/dialog/printopt.cxx
new file mode 100644
index 000000000..43f88786a
--- /dev/null
+++ b/sfx2/source/dialog/printopt.cxx
@@ -0,0 +1,294 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <sal/macros.h>
+#include <unotools/printwarningoptions.hxx>
+#include <svtools/printoptions.hxx>
+#include <svtools/restartdialog.hxx>
+
+#include <comphelper/processfactory.hxx>
+
+#include <sfx2/printopt.hxx>
+
+static sal_uInt16   aDPIArray[] = { 72, 96, 150, 200, 300, 600 };
+static bool     bOutputForPrinter = true;
+
+#define DPI_COUNT SAL_N_ELEMENTS(aDPIArray)
+
+SfxCommonPrintOptionsTabPage::SfxCommonPrintOptionsTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
+    : SfxTabPage(pPage, pController, "sfx/ui/optprintpage.ui", "OptPrintPage", &rSet)
+    , m_xPrinterOutputRB(m_xBuilder->weld_radio_button("printer"))
+    , m_xPrintFileOutputRB(m_xBuilder->weld_radio_button("file"))
+    , m_xReduceTransparencyCB(m_xBuilder->weld_check_button("reducetrans"))
+    , m_xReduceTransparencyAutoRB(m_xBuilder->weld_radio_button("reducetransauto"))
+    , m_xReduceTransparencyNoneRB(m_xBuilder->weld_radio_button("reducetransnone"))
+    , m_xReduceGradientsCB(m_xBuilder->weld_check_button("reducegrad"))
+    , m_xReduceGradientsStripesRB(m_xBuilder->weld_radio_button("reducegradstripes"))
+    , m_xReduceGradientsColorRB(m_xBuilder->weld_radio_button("reducegradcolor"))
+    , m_xReduceGradientsStepCountNF(m_xBuilder->weld_spin_button("reducegradstep"))
+    , m_xReduceBitmapsCB(m_xBuilder->weld_check_button("reducebitmap"))
+    , m_xReduceBitmapsOptimalRB(m_xBuilder->weld_radio_button("reducebitmapoptimal"))
+    , m_xReduceBitmapsNormalRB(m_xBuilder->weld_radio_button("reducebitmapnormal"))
+    , m_xReduceBitmapsResolutionRB(m_xBuilder->weld_radio_button("reducebitmapresol"))
+    , m_xReduceBitmapsResolutionLB(m_xBuilder->weld_combo_box("reducebitmapdpi"))
+    , m_xReduceBitmapsTransparencyCB(m_xBuilder->weld_check_button("reducebitmaptrans"))
+    , m_xConvertToGreyscalesCB(m_xBuilder->weld_check_button("converttogray"))
+    , m_xPDFCB(m_xBuilder->weld_check_button("pdf"))
+    , m_xPaperSizeCB(m_xBuilder->weld_check_button("papersize"))
+    , m_xPaperOrientationCB(m_xBuilder->weld_check_button("paperorient"))
+    , m_xTransparencyCB(m_xBuilder->weld_check_button("trans"))
+{
+#ifndef ENABLE_CUPS
+    m_xPDFCB->hide();
+#endif
+
+    if( bOutputForPrinter )
+    {
+        m_xPrinterOutputRB->set_active(true);
+    }
+    else
+    {
+        m_xPrintFileOutputRB->set_active(true);
+        m_xPDFCB->set_sensitive(false);
+    }
+
+    m_xPrinterOutputRB->connect_toggled( LINK( this, SfxCommonPrintOptionsTabPage, ToggleOutputPrinterRBHdl ) );
+    m_xPrintFileOutputRB->connect_toggled( LINK( this, SfxCommonPrintOptionsTabPage, ToggleOutputPrintFileRBHdl ) );
+
+    m_xReduceTransparencyCB->connect_clicked( LINK( this, SfxCommonPrintOptionsTabPage, ClickReduceTransparencyCBHdl ) );
+    m_xReduceGradientsCB->connect_clicked( LINK( this, SfxCommonPrintOptionsTabPage, ClickReduceGradientsCBHdl ) );
+    m_xReduceBitmapsCB->connect_clicked( LINK( this, SfxCommonPrintOptionsTabPage, ClickReduceBitmapsCBHdl ) );
+
+    m_xReduceGradientsStripesRB->connect_toggled( LINK( this, SfxCommonPrintOptionsTabPage, ToggleReduceGradientsStripesRBHdl ) );
+    m_xReduceBitmapsResolutionRB->connect_toggled( LINK( this, SfxCommonPrintOptionsTabPage, ToggleReduceBitmapsResolutionRBHdl ) );
+}
+
+SfxCommonPrintOptionsTabPage::~SfxCommonPrintOptionsTabPage()
+{
+}
+
+std::unique_ptr<SfxTabPage> SfxCommonPrintOptionsTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet)
+{
+    return std::make_unique<SfxCommonPrintOptionsTabPage>(pPage, pController, *rAttrSet);
+}
+
+bool SfxCommonPrintOptionsTabPage::FillItemSet( SfxItemSet* /*rSet*/ )
+{
+    SvtPrintWarningOptions  aWarnOptions;
+    SvtPrinterOptions       aPrinterOptions;
+    SvtPrintFileOptions     aPrintFileOptions;
+
+
+    if( m_xPaperSizeCB->get_state_changed_from_saved())
+        aWarnOptions.SetPaperSize(m_xPaperSizeCB->get_active());
+    if( m_xPaperOrientationCB->get_state_changed_from_saved() )
+        aWarnOptions.SetPaperOrientation(m_xPaperOrientationCB->get_active());
+    if( m_xTransparencyCB->get_state_changed_from_saved() )
+        aWarnOptions.SetTransparency( m_xTransparencyCB->get_active() );
+
+    ImplSaveControls( m_xPrinterOutputRB->get_active() ? &maPrinterOptions : &maPrintFileOptions );
+
+    aPrinterOptions.SetPrinterOptions( maPrinterOptions );
+    aPrintFileOptions.SetPrinterOptions( maPrintFileOptions );
+
+    return false;
+}
+
+void SfxCommonPrintOptionsTabPage::Reset( const SfxItemSet* /*rSet*/ )
+{
+    SvtPrintWarningOptions  aWarnOptions;
+
+    m_xPaperSizeCB->set_active( aWarnOptions.IsPaperSize() );
+    m_xPaperOrientationCB->set_active( aWarnOptions.IsPaperOrientation() );
+
+    m_xTransparencyCB->set_active( aWarnOptions.IsTransparency() );
+
+    m_xPaperSizeCB->save_state();
+    m_xPaperOrientationCB->save_state();
+    m_xTransparencyCB->save_state();
+
+    SvtBasePrintOptions::GetPrinterOptions( maPrinterOptions );
+    SvtBasePrintOptions::GetPrinterOptions( maPrintFileOptions );
+    if(m_xPrintFileOutputRB->get_active()){
+       m_xPrinterOutputRB->set_active(true);
+    }
+
+    ImplUpdateControls( m_xPrinterOutputRB->get_active() ? &maPrinterOptions : &maPrintFileOptions );
+}
+
+DeactivateRC SfxCommonPrintOptionsTabPage::DeactivatePage( SfxItemSet* pItemSet )
+{
+    if( pItemSet )
+        FillItemSet( pItemSet );
+
+    return DeactivateRC::LeavePage;
+}
+
+void SfxCommonPrintOptionsTabPage::ImplUpdateControls( const PrinterOptions* pCurrentOptions )
+{
+    m_xReduceTransparencyCB->set_active( pCurrentOptions->IsReduceTransparency() );
+
+    if( pCurrentOptions->GetReducedTransparencyMode() == PrinterTransparencyMode::Auto )
+        m_xReduceTransparencyAutoRB->set_active(true);
+    else
+        m_xReduceTransparencyNoneRB->set_active(true);
+
+    m_xReduceGradientsCB->set_active( pCurrentOptions->IsReduceGradients() );
+
+    if( pCurrentOptions->GetReducedGradientMode() == PrinterGradientMode::Stripes )
+        m_xReduceGradientsStripesRB->set_active(true);
+    else
+        m_xReduceGradientsColorRB->set_active(true);
+
+    m_xReduceGradientsStepCountNF->set_value(pCurrentOptions->GetReducedGradientStepCount());
+
+    m_xReduceBitmapsCB->set_active( pCurrentOptions->IsReduceBitmaps() );
+
+    if( pCurrentOptions->GetReducedBitmapMode() == PrinterBitmapMode::Optimal )
+        m_xReduceBitmapsOptimalRB->set_active(true);
+    else if( pCurrentOptions->GetReducedBitmapMode() == PrinterBitmapMode::Normal )
+        m_xReduceBitmapsNormalRB->set_active(true);
+    else
+        m_xReduceBitmapsResolutionRB->set_active(true);
+
+    const sal_uInt16 nDPI = pCurrentOptions->GetReducedBitmapResolution();
+
+    if( nDPI < aDPIArray[ 0 ] )
+        m_xReduceBitmapsResolutionLB->set_active(0);
+    else
+    {
+        for( int i = DPI_COUNT - 1; i >= 0; i-- )
+        {
+            if( nDPI >= aDPIArray[ i ] )
+            {
+                m_xReduceBitmapsResolutionLB->set_active(i);
+                i = -1;
+            }
+        }
+    }
+
+    m_xReduceBitmapsTransparencyCB->set_active( pCurrentOptions->IsReducedBitmapIncludesTransparency() );
+    m_xConvertToGreyscalesCB->set_active( pCurrentOptions->IsConvertToGreyscales() );
+    m_xPDFCB->set_active( pCurrentOptions->IsPDFAsStandardPrintJobFormat() );
+
+    ClickReduceTransparencyCBHdl(*m_xReduceTransparencyCB);
+    ClickReduceGradientsCBHdl(*m_xReduceGradientsCB);
+    ClickReduceBitmapsCBHdl(*m_xReduceBitmapsCB);
+}
+
+void SfxCommonPrintOptionsTabPage::ImplSaveControls( PrinterOptions* pCurrentOptions )
+{
+    pCurrentOptions->SetReduceTransparency( m_xReduceTransparencyCB->get_active() );
+    pCurrentOptions->SetReducedTransparencyMode( m_xReduceTransparencyAutoRB->get_active() ? PrinterTransparencyMode::Auto : PrinterTransparencyMode::NONE );
+    pCurrentOptions->SetReduceGradients( m_xReduceGradientsCB->get_active() );
+    pCurrentOptions->SetReducedGradientMode( m_xReduceGradientsStripesRB->get_active() ? PrinterGradientMode::Stripes : PrinterGradientMode::Color  );
+    pCurrentOptions->SetReducedGradientStepCount(m_xReduceGradientsStepCountNF->get_value());
+    pCurrentOptions->SetReduceBitmaps( m_xReduceBitmapsCB->get_active() );
+    pCurrentOptions->SetReducedBitmapMode( m_xReduceBitmapsOptimalRB->get_active() ? PrinterBitmapMode::Optimal :
+                                           ( m_xReduceBitmapsNormalRB->get_active() ? PrinterBitmapMode::Normal : PrinterBitmapMode::Resolution ) );
+    pCurrentOptions->SetReducedBitmapResolution( aDPIArray[ std::min<sal_uInt16>( m_xReduceBitmapsResolutionLB->get_active(),
+                                                                   SAL_N_ELEMENTS(aDPIArray) - 1 ) ] );
+    pCurrentOptions->SetReducedBitmapIncludesTransparency( m_xReduceBitmapsTransparencyCB->get_active() );
+    pCurrentOptions->SetConvertToGreyscales( m_xConvertToGreyscalesCB->get_active() );
+    bool bOrigBackEnd = pCurrentOptions->IsPDFAsStandardPrintJobFormat();
+    if (bOrigBackEnd != m_xPDFCB->get_active())
+    {
+        pCurrentOptions->SetPDFAsStandardPrintJobFormat( m_xPDFCB->get_active() );
+        svtools::executeRestartDialog(
+                comphelper::getProcessComponentContext(), nullptr,
+                svtools::RESTART_REASON_PDF_AS_STANDARD_JOB_FORMAT);
+    }
+}
+
+IMPL_LINK_NOARG( SfxCommonPrintOptionsTabPage, ClickReduceTransparencyCBHdl, weld::Button&, void )
+{
+    const bool bReduceTransparency = m_xReduceTransparencyCB->get_active();
+
+    m_xReduceTransparencyAutoRB->set_sensitive( bReduceTransparency );
+    m_xReduceTransparencyNoneRB->set_sensitive( bReduceTransparency );
+
+    m_xTransparencyCB->set_sensitive( !bReduceTransparency );
+}
+
+IMPL_LINK_NOARG( SfxCommonPrintOptionsTabPage, ClickReduceGradientsCBHdl, weld::Button&, void )
+{
+    const bool bEnable = m_xReduceGradientsCB->get_active();
+
+    m_xReduceGradientsStripesRB->set_sensitive( bEnable );
+    m_xReduceGradientsColorRB->set_sensitive( bEnable );
+    m_xReduceGradientsStepCountNF->set_sensitive( bEnable );
+
+    ToggleReduceGradientsStripesRBHdl(*m_xReduceGradientsStripesRB);
+}
+
+IMPL_LINK_NOARG( SfxCommonPrintOptionsTabPage, ClickReduceBitmapsCBHdl, weld::Button&, void )
+{
+    const bool bEnable = m_xReduceBitmapsCB->get_active();
+
+    m_xReduceBitmapsOptimalRB->set_sensitive( bEnable );
+    m_xReduceBitmapsNormalRB->set_sensitive( bEnable );
+    m_xReduceBitmapsResolutionRB->set_sensitive( bEnable );
+    m_xReduceBitmapsTransparencyCB->set_sensitive( bEnable );
+    m_xReduceBitmapsResolutionLB->set_sensitive( bEnable );
+
+    ToggleReduceBitmapsResolutionRBHdl(*m_xReduceBitmapsResolutionRB);
+}
+
+IMPL_LINK_NOARG( SfxCommonPrintOptionsTabPage, ToggleReduceGradientsStripesRBHdl, weld::ToggleButton&, void )
+{
+    const bool bEnable = m_xReduceGradientsCB->get_active() && m_xReduceGradientsStripesRB->get_active();
+
+    m_xReduceGradientsStepCountNF->set_sensitive(bEnable);
+}
+
+IMPL_LINK_NOARG( SfxCommonPrintOptionsTabPage, ToggleReduceBitmapsResolutionRBHdl, weld::ToggleButton&, void )
+{
+    const bool bEnable = m_xReduceBitmapsCB->get_active() && m_xReduceBitmapsResolutionRB->get_active();
+
+    m_xReduceBitmapsResolutionLB->set_sensitive(bEnable);
+}
+
+IMPL_LINK( SfxCommonPrintOptionsTabPage, ToggleOutputPrinterRBHdl, weld::ToggleButton&, rButton, void )
+{
+    if (rButton.get_active())
+    {
+        ImplUpdateControls( &maPrinterOptions );
+        bOutputForPrinter = true;
+    }
+    else
+        ImplSaveControls( &maPrinterOptions );
+}
+
+IMPL_LINK( SfxCommonPrintOptionsTabPage, ToggleOutputPrintFileRBHdl, weld::ToggleButton&, rButton, void )
+{
+    if (rButton.get_active())
+    {
+        ImplUpdateControls( &maPrintFileOptions );
+        bOutputForPrinter = false;
+        m_xPDFCB->set_sensitive(false);
+    }
+    else
+    {
+        ImplSaveControls( &maPrintFileOptions );
+        m_xPDFCB->set_sensitive(true);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/recfloat.cxx b/sfx2/source/dialog/recfloat.cxx
new file mode 100644
index 000000000..18833ea5e
--- /dev/null
+++ b/sfx2/source/dialog/recfloat.cxx
@@ -0,0 +1,122 @@
+/* -*- 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/frame/XDispatchRecorder.hpp>
+
+#include <svl/eitem.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <vcl/windowstate.hxx>
+
+#include <recfloat.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/viewsh.hxx>
+
+SFX_IMPL_MODELESSDIALOGCONTOLLER(SfxRecordingFloatWrapper_Impl, SID_RECORDING_FLOATWINDOW);
+
+SfxRecordingFloatWrapper_Impl::SfxRecordingFloatWrapper_Impl(vcl::Window* pParentWnd,
+                                                             sal_uInt16 nId,
+                                                             SfxBindings* pBind,
+                                                             SfxChildWinInfo const * pInfo)
+    : SfxChildWindow(pParentWnd, nId)
+    , pBindings(pBind)
+{
+    SetController(std::make_shared<SfxRecordingFloat_Impl>(pBindings, this, pParentWnd->GetFrameWeld()));
+    SetWantsFocus(false);
+    SfxRecordingFloat_Impl* pFloatDlg = static_cast<SfxRecordingFloat_Impl*>(GetController().get());
+
+    weld::Dialog* pDlg = pFloatDlg->getDialog();
+
+    SfxViewFrame *pFrame = pBind->GetDispatcher_Impl()->GetFrame();
+    vcl::Window* pEditWin = pFrame->GetViewShell()->GetWindow();
+
+    Point aPos = pEditWin->OutputToScreenPixel( pEditWin->GetPosPixel() );
+    aPos.AdjustX(20);
+    aPos.AdjustY(10);
+
+    WindowStateData aState;
+    aState.SetMask(WindowStateMask::Pos);
+    aState.SetX(aPos.X());
+    aState.SetY(aPos.Y());
+    pDlg->set_window_state(aState.ToStr());
+
+    pFloatDlg->Initialize(pInfo);
+}
+
+SfxRecordingFloatWrapper_Impl::~SfxRecordingFloatWrapper_Impl()
+{
+    SfxBoolItem aItem( FN_PARAM_1, true );
+    css::uno::Reference< css::frame::XDispatchRecorder > xRecorder = pBindings->GetRecorder();
+    if ( xRecorder.is() )
+        pBindings->GetDispatcher()->ExecuteList(SID_STOP_RECORDING,
+                SfxCallMode::SYNCHRON, { &aItem });
+}
+
+bool SfxRecordingFloatWrapper_Impl::QueryClose()
+{
+    // asking for recorded macro should be replaced if index access is available!
+    bool bRet = true;
+    css::uno::Reference< css::frame::XDispatchRecorder > xRecorder = pBindings->GetRecorder();
+    if ( xRecorder.is() && !xRecorder->getRecordedMacro().isEmpty() )
+    {
+        SfxRecordingFloat_Impl* pFloatDlg = static_cast<SfxRecordingFloat_Impl*>(GetController().get());
+        weld::Dialog* pDlg = pFloatDlg->getDialog();
+
+        std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(pDlg,
+                                                       VclMessageType::Question, VclButtonsType::YesNo,
+                                                       SfxResId(STR_MACRO_LOSS)));
+        xQueryBox->set_default_response(RET_NO);
+
+        xQueryBox->set_title(SfxResId(STR_CANCEL_RECORDING));
+        bRet = (xQueryBox->run() == RET_YES);
+    }
+
+    return bRet;
+}
+
+SfxRecordingFloat_Impl::SfxRecordingFloat_Impl(SfxBindings* pBind, SfxChildWindow* pChildWin,
+                                               weld::Window* pParent)
+    : SfxModelessDialogController(pBind, pChildWin, pParent, "sfx/ui/floatingrecord.ui",
+                                  "FloatingRecord")
+    , m_xToolbar(m_xBuilder->weld_toolbar("toolbar"))
+    , m_xDispatcher(new ToolbarUnoDispatcher(*m_xToolbar, *m_xBuilder, pBind->GetActiveFrame()))
+{
+    // start recording
+    SfxBoolItem aItem( SID_RECORDMACRO, true );
+    GetBindings().GetDispatcher()->ExecuteList(SID_RECORDMACRO,
+            SfxCallMode::SYNCHRON, { &aItem });
+}
+
+SfxRecordingFloat_Impl::~SfxRecordingFloat_Impl()
+{
+    m_xDispatcher->dispose();
+}
+
+void SfxRecordingFloat_Impl::FillInfo( SfxChildWinInfo& rInfo ) const
+{
+    SfxModelessDialogController::FillInfo( rInfo );
+    rInfo.bVisible = false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/securitypage.cxx b/sfx2/source/dialog/securitypage.cxx
new file mode 100644
index 000000000..84df48131
--- /dev/null
+++ b/sfx2/source/dialog/securitypage.cxx
@@ -0,0 +1,431 @@
+/* -*- 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/htmlmode.hxx>
+
+#include <sfx2/sfxresid.hxx>
+
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/objsh.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/passwd.hxx>
+
+#include <vcl/svapp.hxx>
+#include <vcl/weld.hxx>
+#include <svl/eitem.hxx>
+#include <svl/poolitem.hxx>
+#include <svl/intitem.hxx>
+#include <svl/PasswordHelper.hxx>
+
+#include <sfx2/strings.hrc>
+
+#include "securitypage.hxx"
+
+using namespace ::com::sun::star;
+
+namespace
+{
+    enum RedliningMode  { RL_NONE, RL_WRITER, RL_CALC };
+
+    bool QueryState( sal_uInt16 _nSlot, bool& _rValue )
+    {
+        bool bRet = false;
+        SfxViewShell* pViewSh = SfxViewShell::Current();
+        if (pViewSh)
+        {
+            const SfxPoolItem* pItem;
+            SfxDispatcher* pDisp = pViewSh->GetDispatcher();
+            SfxItemState nState = pDisp->QueryState( _nSlot, pItem );
+            bRet = SfxItemState::DEFAULT <= nState;
+            if (bRet)
+                _rValue = static_cast< const SfxBoolItem* >( pItem )->GetValue();
+        }
+        return bRet;
+    }
+
+
+    bool QueryRecordChangesProtectionState( RedliningMode _eMode, bool& _rValue )
+    {
+        bool bRet = false;
+        if (_eMode != RL_NONE)
+        {
+            sal_uInt16 nSlot = _eMode == RL_WRITER ? FN_REDLINE_PROTECT : SID_CHG_PROTECT;
+            bRet = QueryState( nSlot, _rValue );
+        }
+        return bRet;
+    }
+
+
+    bool QueryRecordChangesState( RedliningMode _eMode, bool& _rValue )
+    {
+        bool bRet = false;
+        if (_eMode != RL_NONE)
+        {
+            sal_uInt16 nSlot = _eMode == RL_WRITER ? FN_REDLINE_ON : FID_CHG_RECORD;
+            bRet = QueryState( nSlot, _rValue );
+        }
+        return bRet;
+    }
+}
+
+
+static bool lcl_GetPassword(
+    weld::Window *pParent,
+    bool bProtect,
+    /*out*/OUString &rPassword )
+{
+    bool bRes = false;
+    SfxPasswordDialog aPasswdDlg(pParent);
+    aPasswdDlg.SetMinLen(1);
+    if (bProtect)
+        aPasswdDlg.ShowExtras( SfxShowExtras::CONFIRM );
+    if (RET_OK == aPasswdDlg.run() && !aPasswdDlg.GetPassword().isEmpty())
+    {
+        rPassword = aPasswdDlg.GetPassword();
+        bRes = true;
+    }
+    return bRes;
+}
+
+
+static bool lcl_IsPasswordCorrect( const OUString &rPassword )
+{
+    bool bRes = false;
+
+    SfxObjectShell* pCurDocShell = SfxObjectShell::Current();
+    uno::Sequence< sal_Int8 >   aPasswordHash;
+    pCurDocShell->GetProtectionHash( aPasswordHash );
+
+    // check if supplied password was correct
+    uno::Sequence< sal_Int8 > aNewPasswd( aPasswordHash );
+    SvPasswordHelper::GetHashPassword( aNewPasswd, rPassword );
+    if (SvPasswordHelper::CompareHashPassword( aPasswordHash, rPassword ))
+        bRes = true;    // password was correct
+    else
+    {
+        std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(nullptr,
+                                                      VclMessageType::Info, VclButtonsType::Ok,
+                                                      SfxResId(RID_SVXSTR_INCORRECT_PASSWORD)));
+        xInfoBox->run();
+    }
+
+    return bRes;
+}
+
+struct SfxSecurityPage_Impl
+{
+    SfxSecurityPage &   m_rMyTabPage;
+
+    RedliningMode       m_eRedlingMode;             // for record changes
+
+    bool                m_bOrigPasswordIsConfirmed;
+    bool                m_bNewPasswordIsValid;
+    OUString            m_aNewPassword;
+
+    OUString            m_aEndRedliningWarning;
+    bool                m_bEndRedliningWarningDone;
+
+    std::unique_ptr<weld::CheckButton> m_xOpenReadonlyCB;
+    std::unique_ptr<weld::CheckButton> m_xRecordChangesCB;         // for record changes
+    std::unique_ptr<weld::Button> m_xProtectPB;               // for record changes
+    std::unique_ptr<weld::Button> m_xUnProtectPB;             // for record changes
+
+    DECL_LINK(RecordChangesCBToggleHdl, weld::ToggleButton&, void);
+    DECL_LINK(ChangeProtectionPBHdl, weld::Button&, void);
+
+    SfxSecurityPage_Impl( SfxSecurityPage &rDlg );
+
+    bool    FillItemSet_Impl();
+    void    Reset_Impl();
+};
+
+SfxSecurityPage_Impl::SfxSecurityPage_Impl(SfxSecurityPage &rTabPage)
+    : m_rMyTabPage(rTabPage)
+    , m_eRedlingMode(RL_NONE)
+    , m_bOrigPasswordIsConfirmed(false)
+    , m_bNewPasswordIsValid(false)
+    , m_aEndRedliningWarning(SfxResId(RID_SVXSTR_END_REDLINING_WARNING))
+    , m_bEndRedliningWarningDone(false)
+    , m_xOpenReadonlyCB(rTabPage.GetBuilder().weld_check_button("readonly"))
+    , m_xRecordChangesCB(rTabPage.GetBuilder().weld_check_button("recordchanges"))
+    , m_xProtectPB(rTabPage.GetBuilder().weld_button("protect"))
+    , m_xUnProtectPB(rTabPage.GetBuilder().weld_button("unprotect"))
+{
+    m_xProtectPB->show();
+    m_xUnProtectPB->hide();
+
+    m_xRecordChangesCB->connect_toggled(LINK(this, SfxSecurityPage_Impl, RecordChangesCBToggleHdl));
+    m_xProtectPB->connect_clicked(LINK(this, SfxSecurityPage_Impl, ChangeProtectionPBHdl));
+    m_xUnProtectPB->connect_clicked(LINK(this, SfxSecurityPage_Impl, ChangeProtectionPBHdl));
+}
+
+bool SfxSecurityPage_Impl::FillItemSet_Impl()
+{
+    bool bModified = false;
+
+    SfxObjectShell* pCurDocShell = SfxObjectShell::Current();
+    if (pCurDocShell&& !pCurDocShell->IsReadOnly())
+    {
+        if (m_eRedlingMode != RL_NONE )
+        {
+            const bool bDoRecordChanges = m_xRecordChangesCB->get_active();
+            const bool bDoChangeProtection  = m_xUnProtectPB->get_visible();
+
+            // sanity checks
+            DBG_ASSERT( bDoRecordChanges || !bDoChangeProtection, "no change recording should imply no change protection" );
+            DBG_ASSERT( bDoChangeProtection || !bDoRecordChanges, "no change protection should imply no change recording" );
+            DBG_ASSERT( !bDoChangeProtection || !m_aNewPassword.isEmpty(), "change protection should imply password length is > 0" );
+            DBG_ASSERT( bDoChangeProtection || m_aNewPassword.isEmpty(), "no change protection should imply password length is 0" );
+
+            // change recording
+            if (bDoRecordChanges != pCurDocShell->IsChangeRecording())
+            {
+                pCurDocShell->SetChangeRecording( bDoRecordChanges );
+                bModified = true;
+            }
+
+            // change record protection
+            if (m_bNewPasswordIsValid &&
+                bDoChangeProtection != pCurDocShell->HasChangeRecordProtection())
+            {
+                DBG_ASSERT( !bDoChangeProtection || bDoRecordChanges,
+                        "change protection requires record changes to be active!" );
+                pCurDocShell->SetProtectionPassword( m_aNewPassword );
+                bModified = true;
+            }
+        }
+
+        // open read-only?
+        const bool bDoOpenReadonly = m_xOpenReadonlyCB->get_active();
+        if (bDoOpenReadonly != pCurDocShell->IsSecurityOptOpenReadOnly())
+        {
+            pCurDocShell->SetSecurityOptOpenReadOnly( bDoOpenReadonly );
+            bModified = true;
+        }
+    }
+
+    return bModified;
+}
+
+
+void SfxSecurityPage_Impl::Reset_Impl()
+{
+    SfxObjectShell* pCurDocShell = SfxObjectShell::Current();
+
+    if (!pCurDocShell)
+    {
+        // no doc -> hide document settings
+        m_xOpenReadonlyCB->set_sensitive(false);
+        m_xRecordChangesCB->set_sensitive(false);
+        m_xProtectPB->show();
+        m_xProtectPB->set_sensitive(false);
+        m_xUnProtectPB->hide();
+        m_xUnProtectPB->set_sensitive(false);
+    }
+    else
+    {
+        bool bIsHTMLDoc = false;
+        bool bProtect = true, bUnProtect = false;
+        SfxViewShell* pViewSh = SfxViewShell::Current();
+        if (pViewSh)
+        {
+            const SfxPoolItem* pItem;
+            SfxDispatcher* pDisp = pViewSh->GetDispatcher();
+            if (SfxItemState::DEFAULT <= pDisp->QueryState( SID_HTML_MODE, pItem ))
+            {
+                sal_uInt16 nMode = static_cast< const SfxUInt16Item* >( pItem )->GetValue();
+                bIsHTMLDoc = ( ( nMode & HTMLMODE_ON ) != 0 );
+            }
+        }
+
+        bool bIsReadonly = pCurDocShell->IsReadOnly();
+        if (!bIsHTMLDoc)
+        {
+            m_xOpenReadonlyCB->set_active(pCurDocShell->IsSecurityOptOpenReadOnly());
+            m_xOpenReadonlyCB->set_sensitive(!bIsReadonly);
+        }
+        else
+            m_xOpenReadonlyCB->set_sensitive(false);
+
+        bool bRecordChanges;
+        if (QueryRecordChangesState( RL_WRITER, bRecordChanges ) && !bIsHTMLDoc)
+            m_eRedlingMode = RL_WRITER;
+        else if (QueryRecordChangesState( RL_CALC, bRecordChanges ))
+            m_eRedlingMode = RL_CALC;
+        else
+            m_eRedlingMode = RL_NONE;
+
+        if (m_eRedlingMode != RL_NONE)
+        {
+            bool bProtection(false);
+            QueryRecordChangesProtectionState( m_eRedlingMode, bProtection );
+
+            m_xProtectPB->set_sensitive(!bIsReadonly);
+            m_xUnProtectPB->set_sensitive(!bIsReadonly);
+            // set the right text
+            if (bProtection)
+            {
+                bProtect = false;
+                bUnProtect = true;
+            }
+
+            m_xRecordChangesCB->set_active(bRecordChanges);
+            m_xRecordChangesCB->set_sensitive(/*!bProtection && */!bIsReadonly);
+
+            m_bOrigPasswordIsConfirmed = true;   // default case if no password is set
+            uno::Sequence< sal_Int8 > aPasswordHash;
+            // check if password is available
+            if (pCurDocShell->GetProtectionHash( aPasswordHash ) &&
+                aPasswordHash.hasElements())
+                m_bOrigPasswordIsConfirmed = false;  // password found, needs to be confirmed later on
+        }
+        else
+        {
+            // A Calc document that is shared will have 'm_eRedlingMode == RL_NONE'
+            // In shared documents change recording and protection must be disabled,
+            // similar to documents that do not support change recording at all.
+            m_xRecordChangesCB->set_active(false);
+            m_xRecordChangesCB->set_sensitive(false);
+            m_xProtectPB->set_sensitive(false);
+            m_xUnProtectPB->set_sensitive(false);
+        }
+
+        m_xProtectPB->set_visible(bProtect);
+        m_xUnProtectPB->set_visible(bUnProtect);
+    }
+}
+
+IMPL_LINK_NOARG(SfxSecurityPage_Impl, RecordChangesCBToggleHdl, weld::ToggleButton&, void)
+{
+    // when change recording gets disabled protection must be disabled as well
+    if (m_xRecordChangesCB->get_active())    // the new check state is already present, thus the '!'
+        return;
+
+    bool bAlreadyDone = false;
+    if (!m_bEndRedliningWarningDone)
+    {
+        std::unique_ptr<weld::MessageDialog> xWarn(Application::CreateMessageDialog(m_rMyTabPage.GetFrameWeld(),
+                                                   VclMessageType::Warning, VclButtonsType::YesNo,
+                                                   m_aEndRedliningWarning));
+        xWarn->set_default_response(RET_NO);
+        if (xWarn->run() != RET_YES)
+            bAlreadyDone = true;
+        else
+            m_bEndRedliningWarningDone = true;
+    }
+
+    const bool bNeedPasssword = !m_bOrigPasswordIsConfirmed
+            && m_xUnProtectPB->get_visible(); // tdf#128230 Require password if the Unprotect button is visible
+    if (!bAlreadyDone && bNeedPasssword)
+    {
+        OUString aPasswordText;
+
+        // dialog canceled or no password provided
+        if (!lcl_GetPassword( m_rMyTabPage.GetFrameWeld(), false, aPasswordText ))
+            bAlreadyDone = true;
+
+        // ask for password and if dialog is canceled or no password provided return
+        if (lcl_IsPasswordCorrect( aPasswordText ))
+            m_bOrigPasswordIsConfirmed = true;
+        else
+            bAlreadyDone = true;
+    }
+
+    if (bAlreadyDone)
+        m_xRecordChangesCB->set_active(true);     // restore original state
+    else
+    {
+        // remember required values to change protection and change recording in
+        // FillItemSet_Impl later on if password was correct.
+        m_bNewPasswordIsValid = true;
+        m_aNewPassword.clear();
+        m_xProtectPB->show();
+        m_xUnProtectPB->hide();
+    }
+}
+
+IMPL_LINK_NOARG(SfxSecurityPage_Impl, ChangeProtectionPBHdl, weld::Button&, void)
+{
+    if (m_eRedlingMode == RL_NONE)
+        return;
+
+    // the push button text is always the opposite of the current state. Thus:
+    const bool bCurrentProtection = m_xUnProtectPB->get_visible();
+
+    // ask user for password (if still necessary)
+    OUString aPasswordText;
+    bool bNewProtection = !bCurrentProtection;
+    const bool bNeedPassword = bNewProtection || !m_bOrigPasswordIsConfirmed;
+    if (bNeedPassword)
+    {
+        // ask for password and if dialog is canceled or no password provided return
+        if (!lcl_GetPassword(m_rMyTabPage.GetFrameWeld(), bNewProtection, aPasswordText))
+            return;
+
+        // provided password still needs to be checked?
+        if (!bNewProtection && !m_bOrigPasswordIsConfirmed)
+        {
+            if (lcl_IsPasswordCorrect( aPasswordText ))
+                m_bOrigPasswordIsConfirmed = true;
+            else
+                return;
+        }
+    }
+    DBG_ASSERT( m_bOrigPasswordIsConfirmed, "ooops... this should not have happened!" );
+
+    // remember required values to change protection and change recording in
+    // FillItemSet_Impl later on if password was correct.
+    m_bNewPasswordIsValid = true;
+    m_aNewPassword = bNewProtection? aPasswordText : OUString();
+
+    m_xRecordChangesCB->set_active(bNewProtection);
+
+    m_xUnProtectPB->set_visible(bNewProtection);
+    m_xProtectPB->set_visible(!bNewProtection);
+}
+
+std::unique_ptr<SfxTabPage> SfxSecurityPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet * rItemSet)
+{
+    return std::make_unique<SfxSecurityPage>(pPage, pController, *rItemSet);
+}
+
+SfxSecurityPage::SfxSecurityPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rItemSet)
+    : SfxTabPage(pPage, pController, "sfx/ui/securityinfopage.ui", "SecurityInfoPage", &rItemSet)
+{
+    m_pImpl.reset(new SfxSecurityPage_Impl( *this ));
+}
+
+bool SfxSecurityPage::FillItemSet( SfxItemSet * /*rItemSet*/ )
+{
+    bool bModified = false;
+    DBG_ASSERT(m_pImpl, "implementation pointer is 0. Still in c-tor?");
+    if (m_pImpl != nullptr)
+        bModified = m_pImpl->FillItemSet_Impl();
+    return bModified;
+}
+
+void SfxSecurityPage::Reset( const SfxItemSet * /*rItemSet*/ )
+{
+    DBG_ASSERT(m_pImpl, "implementation pointer is 0. Still in c-tor?");
+    if (m_pImpl != nullptr)
+        m_pImpl->Reset_Impl();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/securitypage.hxx b/sfx2/source/dialog/securitypage.hxx
new file mode 100644
index 000000000..b4ca1ddac
--- /dev/null
+++ b/sfx2/source/dialog/securitypage.hxx
@@ -0,0 +1,42 @@
+/* -*- 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_SECURITYPAGE_HXX
+#define INCLUDED_SFX2_SECURITYPAGE_HXX
+
+#include <sfx2/tabdlg.hxx>
+#include <memory>
+
+struct SfxSecurityPage_Impl;
+
+class SfxSecurityPage final : public SfxTabPage
+{
+    std::unique_ptr< SfxSecurityPage_Impl > m_pImpl;
+
+    virtual bool            FillItemSet( SfxItemSet* ) override;
+    virtual void            Reset( const SfxItemSet* ) override;
+
+public:
+    SfxSecurityPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet&);
+    static std::unique_ptr<SfxTabPage> Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet*);
+    weld::Builder& GetBuilder() const { return *m_xBuilder; }
+};
+
+#endif // INCLUDED_SFX2_SECURITYPAGE_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/sfxdlg.cxx b/sfx2/source/dialog/sfxdlg.cxx
new file mode 100644
index 000000000..734d00fcc
--- /dev/null
+++ b/sfx2/source/dialog/sfxdlg.cxx
@@ -0,0 +1,32 @@
+/* -*- 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/sfxdlg.hxx>
+
+SfxAbstractDialogFactory* SfxAbstractDialogFactory::Create()
+{
+    return dynamic_cast <SfxAbstractDialogFactory*>( VclAbstractDialogFactory::Create() );
+}
+
+SfxAbstractDialogFactory::~SfxAbstractDialogFactory()
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/splitwin.cxx b/sfx2/source/dialog/splitwin.cxx
new file mode 100644
index 000000000..2c29307b1
--- /dev/null
+++ b/sfx2/source/dialog/splitwin.cxx
@@ -0,0 +1,1153 @@
+/* -*- 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 .
+ */
+
+#ifdef __sun
+#include <ctime>
+#endif
+
+#include <unotools/viewoptions.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+
+#include <vcl/event.hxx>
+#include <vcl/menu.hxx>
+#include <vcl/timer.hxx>
+#include <vcl/svapp.hxx>
+
+#include <splitwin.hxx>
+#include <workwin.hxx>
+#include <sfx2/dockwin.hxx>
+
+#include <memory>
+#include <vector>
+#include <utility>
+
+using namespace ::com::sun::star::uno;
+
+#define VERSION 1
+#define nPixel  30L
+#define USERITEM_NAME           "UserItem"
+
+namespace {
+    // helper class to deactivate UpdateMode, if needed, for the life time of an instance
+    class DeactivateUpdateMode
+    {
+    public:
+        explicit DeactivateUpdateMode( SfxSplitWindow& rSplitWindow )
+            : mrSplitWindow( rSplitWindow )
+            , mbUpdateMode( rSplitWindow.IsUpdateMode() )
+        {
+            if ( mbUpdateMode )
+            {
+                mrSplitWindow.SetUpdateMode( false );
+            }
+        }
+
+        ~DeactivateUpdateMode()
+        {
+            if ( mbUpdateMode )
+            {
+                mrSplitWindow.SetUpdateMode( true );
+            }
+        }
+
+    private:
+        SfxSplitWindow& mrSplitWindow;
+        const bool mbUpdateMode;
+    };
+}
+
+class SfxEmptySplitWin_Impl : public SplitWindow
+{
+/*  [Description]
+
+    The SfxEmptySplitWin_Impldow is an empty SplitWindow, that replaces the
+    SfxSplitWindow AutoHide mode. It only serves as a placeholder to receive
+    mouse moves and if possible blend in the true SplitWindow display.
+*/
+friend class SfxSplitWindow;
+
+    VclPtr<SfxSplitWindow>  pOwner;
+    bool                    bFadeIn;
+    bool                    bAutoHide;
+    bool                    bSplit;
+    bool                    bEndAutoHide;
+    Timer                   aTimer;
+    Point                   aLastPos;
+    sal_uInt16              nState;
+
+public:
+   explicit             SfxEmptySplitWin_Impl( SfxSplitWindow *pParent )
+                            : SplitWindow( pParent->GetParent(), WinBits( WB_BORDER | WB_3DLOOK ) )
+                            , pOwner( pParent )
+                            , bFadeIn( false )
+                            , bAutoHide( false )
+                            , bSplit( false )
+                            , bEndAutoHide( false )
+                            , nState( 1 )
+                        {
+                            aTimer.SetInvokeHandler(
+                                LINK(pOwner, SfxSplitWindow, TimerHdl ) );
+                            aTimer.SetTimeout( 200 );
+                            SetAlign( pOwner->GetAlign() );
+                            Actualize();
+                            ShowFadeInHideButton();
+                        }
+
+                        virtual ~SfxEmptySplitWin_Impl() override
+                        { disposeOnce(); }
+   virtual void         dispose() override
+                        {
+                            aTimer.Stop();
+                            pOwner.clear();
+                            SplitWindow::dispose();
+                        }
+
+    virtual void        FadeIn() override;
+    void                Actualize();
+};
+
+void SfxEmptySplitWin_Impl::Actualize()
+{
+    Size aSize( pOwner->GetSizePixel() );
+    switch ( pOwner->GetAlign() )
+    {
+        case WindowAlign::Left:
+        case WindowAlign::Right:
+            aSize.setWidth( GetFadeInSize() );
+            break;
+        case WindowAlign::Top:
+        case WindowAlign::Bottom:
+            aSize.setHeight( GetFadeInSize() );
+            break;
+    }
+
+    SetSizePixel( aSize );
+}
+
+void SfxEmptySplitWin_Impl::FadeIn()
+{
+    if (!bAutoHide )
+        bAutoHide = IsFadeNoButtonMode();
+    pOwner->SetFadeIn_Impl( true );
+    if ( bAutoHide )
+    {
+        // Set Timer to close; the caller has to ensure themselves that the
+        // Window is not closed instantly (eg by setting the focus or a modal
+        // mode.
+        aLastPos = GetPointerPosPixel();
+        aTimer.Start();
+    }
+    else
+        pOwner->SaveConfig_Impl();
+}
+
+
+void SfxSplitWindow::MouseButtonDown( const MouseEvent& rMEvt )
+{
+    if ( rMEvt.GetClicks() != 2 )
+        SplitWindow::MouseButtonDown( rMEvt );
+}
+
+SfxSplitWindow::SfxSplitWindow( vcl::Window* pParent, SfxChildAlignment eAl,
+        SfxWorkWindow *pW, bool bWithButtons )
+
+/*  [Description]
+
+    A SfxSplitWindow brings the recursive structure of the SV-SplitWindows to
+    the outside by simulating a table-like structure with rows and columns
+    (maximum recursion depth 2). Furthermore, it ensures the persistence of
+    the arrangement of the SfxDockingWindows.
+*/
+
+:   SplitWindow ( pParent, WB_BORDER | WB_SIZEABLE | WB_3DLOOK | WB_HIDE ),
+    eAlign(eAl),
+    pWorkWin(pW),
+    bPinned(true),
+    pEmptyWin(nullptr),
+    pActive(nullptr)
+{
+    if (bWithButtons)
+    {
+        ShowFadeOutButton();
+    }
+
+    // Set SV-Alignment
+    WindowAlign eTbxAlign;
+    switch ( eAlign )
+    {
+        case SfxChildAlignment::LEFT:
+            eTbxAlign = WindowAlign::Left;
+            break;
+        case SfxChildAlignment::RIGHT:
+            eTbxAlign = WindowAlign::Right;
+            break;
+        case SfxChildAlignment::TOP:
+            eTbxAlign = WindowAlign::Top;
+            break;
+        case SfxChildAlignment::BOTTOM:
+            eTbxAlign = WindowAlign::Bottom;
+            bPinned = true;
+            break;
+        default:
+            eTbxAlign = WindowAlign::Top;  // some sort of default...
+            break;  // -Wall lots not handled...
+    }
+
+    SetAlign (eTbxAlign);
+    pEmptyWin = VclPtr<SfxEmptySplitWin_Impl>::Create( this );
+    if ( bPinned )
+    {
+        pEmptyWin->bFadeIn = true;
+        pEmptyWin->nState = 2;
+    }
+
+    if ( bWithButtons )
+    {
+        //  Read Configuration
+        const OUString aWindowId{ "SplitWindow" + OUString::number(static_cast<sal_Int32>(eTbxAlign)) };
+        SvtViewOptions aWinOpt( EViewType::Window, aWindowId );
+        OUString aWinData;
+        Any aUserItem = aWinOpt.GetUserItem( USERITEM_NAME );
+        OUString aTemp;
+        if ( aUserItem >>= aTemp )
+            aWinData = aTemp;
+        if ( aWinData.startsWith("V") )
+        {
+            sal_Int32 nIdx{ 0 };
+            pEmptyWin->nState = static_cast<sal_uInt16>(aWinData.getToken( 1, ',', nIdx ).toInt32());
+            if ( pEmptyWin->nState & 2 )
+                pEmptyWin->bFadeIn = true;
+            bPinned = true; // always assume pinned - floating mode not used anymore
+
+            const sal_Int32 nCount{ aWinData.getToken(0, ',', nIdx).toInt32() };
+            for ( sal_Int32 n=0; n<nCount; ++n )
+            {
+                std::unique_ptr<SfxDock_Impl> pDock(new SfxDock_Impl);
+                pDock->pWin = nullptr;
+                pDock->bNewLine = false;
+                pDock->bHide = true;
+                pDock->nType = static_cast<sal_uInt16>(aWinData.getToken(0, ',', nIdx).toInt32());
+                if ( !pDock->nType )
+                {
+                    // could mean NewLine
+                    pDock->nType = static_cast<sal_uInt16>(aWinData.getToken(0, ',', nIdx).toInt32());
+                    if ( !pDock->nType )
+                    {
+                        // Read error
+                        break;
+                    }
+                    else
+                        pDock->bNewLine = true;
+                }
+
+                maDockArr.insert(maDockArr.begin() + n, std::move(pDock));
+            }
+        }
+    }
+    else
+    {
+        bPinned = true;
+        pEmptyWin->bFadeIn = true;
+        pEmptyWin->nState = 2;
+    }
+}
+
+
+SfxSplitWindow::~SfxSplitWindow()
+{
+    disposeOnce();
+}
+
+void SfxSplitWindow::dispose()
+{
+    SaveConfig_Impl();
+
+    if ( pEmptyWin )
+    {
+        // Set pOwner to NULL, otherwise try to delete pEmptyWin once more. The
+        // window that is just being docked is always deleted from the outside.
+        pEmptyWin->pOwner = nullptr;
+    }
+    pEmptyWin.disposeAndClear();
+
+    maDockArr.clear();
+    pActive.clear();
+    SplitWindow::dispose();
+}
+
+void SfxSplitWindow::SaveConfig_Impl()
+{
+    // Save configuration
+    OUStringBuffer aWinData;
+    aWinData.append('V');
+    aWinData.append(static_cast<sal_Int32>(VERSION));
+    aWinData.append(',');
+    aWinData.append(static_cast<sal_Int32>(pEmptyWin->nState));
+    aWinData.append(',');
+
+    sal_uInt16 nCount = 0;
+    for ( auto const & rDock: maDockArr )
+    {
+        if ( rDock->bHide || rDock->pWin )
+            nCount++;
+    }
+
+    aWinData.append(static_cast<sal_Int32>(nCount));
+
+    for ( auto const & rDock: maDockArr )
+    {
+        if ( !rDock->bHide && !rDock->pWin )
+            continue;
+        if ( rDock->bNewLine )
+            aWinData.append(",0");
+        aWinData.append(',');
+        aWinData.append(static_cast<sal_Int32>(rDock->nType));
+    }
+
+    const OUString aWindowId{ "SplitWindow" + OUString::number(static_cast<sal_Int32>(GetAlign())) };
+    SvtViewOptions aWinOpt( EViewType::Window, aWindowId );
+    aWinOpt.SetUserItem( USERITEM_NAME, makeAny( aWinData.makeStringAndClear() ) );
+}
+
+
+void SfxSplitWindow::StartSplit()
+{
+    long nSize = 0;
+    Size aSize = GetSizePixel();
+
+    if ( pEmptyWin )
+    {
+        pEmptyWin->bFadeIn = true;
+        pEmptyWin->bSplit = true;
+    }
+
+    tools::Rectangle aRect = pWorkWin->GetFreeArea( !bPinned );
+    switch ( GetAlign() )
+    {
+        case WindowAlign::Left:
+        case WindowAlign::Right:
+            nSize = aSize.Width() + aRect.GetWidth();
+            break;
+        case WindowAlign::Top:
+        case WindowAlign::Bottom:
+            nSize = aSize.Height() + aRect.GetHeight();
+            break;
+    }
+
+    SetMaxSizePixel( nSize );
+}
+
+
+void SfxSplitWindow::SplitResize()
+{
+    if ( bPinned )
+    {
+        pWorkWin->ArrangeChildren_Impl();
+        pWorkWin->ShowChildren_Impl();
+    }
+    else
+        pWorkWin->ArrangeAutoHideWindows( this );
+}
+
+
+void SfxSplitWindow::Split()
+{
+    if ( pEmptyWin )
+        pEmptyWin->bSplit = false;
+
+    SplitWindow::Split();
+
+    std::vector< std::pair< sal_uInt16, long > > aNewOrgSizes;
+
+    sal_uInt16 nCount = maDockArr.size();
+    for ( sal_uInt16 n=0; n<nCount; n++ )
+    {
+        const SfxDock_Impl& rD = *maDockArr[n];
+        if ( rD.pWin )
+        {
+            const sal_uInt16 nId = rD.nType;
+            const long nSize    = GetItemSize( nId, SplitWindowItemFlags::Fixed );
+            const long nSetSize = GetItemSize( GetSet( nId ) );
+            Size aSize;
+
+            if ( IsHorizontal() )
+            {
+                aSize.setWidth( nSize );
+                aSize.setHeight( nSetSize );
+            }
+            else
+            {
+                aSize.setWidth( nSetSize );
+                aSize.setHeight( nSize );
+            }
+
+            rD.pWin->SetItemSize_Impl( aSize );
+
+            aNewOrgSizes.emplace_back( nId, nSize );
+        }
+    }
+
+    // workaround insufficiency of <SplitWindow> regarding dock layouting:
+    // apply FIXED item size as 'original' item size to improve layouting of undock-dock-cycle of a window
+    {
+        DeactivateUpdateMode aDeactivateUpdateMode( *this );
+        for (const std::pair< sal_uInt16, long > & rNewOrgSize : aNewOrgSizes)
+        {
+            SetItemSize( rNewOrgSize.first, rNewOrgSize.second );
+        }
+    }
+
+    SaveConfig_Impl();
+}
+
+
+void SfxSplitWindow::InsertWindow( SfxDockingWindow* pDockWin, const Size& rSize)
+
+/*
+    To insert SfxDockingWindows just pass no position. The SfxSplitWindow
+    searches the last marked one to the passed SfxDockingWindow or appends a
+    new one at the end.
+*/
+{
+    short nLine = -1;  // so that the first window cab set nline to 0
+    sal_uInt16 nL;
+    sal_uInt16 nPos = 0;
+    bool bNewLine = true;
+    bool bSaveConfig = false;
+    SfxDock_Impl *pFoundDock=nullptr;
+    sal_uInt16 nCount = maDockArr.size();
+    for ( sal_uInt16 n=0; n<nCount; n++ )
+    {
+        SfxDock_Impl& rDock = *maDockArr[n];
+        if ( rDock.bNewLine )
+        {
+            // The window opens a new line
+            if ( pFoundDock )
+                // But after the just inserted window
+                break;
+
+            // New line
+            nPos = 0;
+            bNewLine = true;
+        }
+
+        if ( rDock.pWin )
+        {
+            // Does there exist a window now at this position
+            if ( bNewLine && !pFoundDock )
+            {
+                // Not known until now in which real line it is located
+                GetWindowPos( rDock.pWin, nL, nPos );
+                nLine = static_cast<short>(nL);
+            }
+
+            if ( !pFoundDock )
+            {
+                // The window is located before the inserted one
+                nPos++;
+            }
+
+            // Line is opened
+            bNewLine = false;
+            if ( pFoundDock )
+                break;
+        }
+
+        if ( rDock.nType == pDockWin->GetType() )
+        {
+            DBG_ASSERT( !pFoundDock && !rDock.pWin, "Window already exists!");
+            pFoundDock = &rDock;
+            if ( !bNewLine )
+                break;
+            else
+            {
+                // A new line has been created but no window was found there;
+                // continue searching for a window in this line in-order to set
+                // bNewLine correctly. While doing so nline or nPos are not
+                // to be changed!
+                nLine++;
+            }
+        }
+    }
+
+    if ( !pFoundDock )
+    {
+        // Not found, insert at end
+        pFoundDock = new SfxDock_Impl;
+        pFoundDock->bHide = true;
+        maDockArr.push_back( std::unique_ptr<SfxDock_Impl>(pFoundDock) );
+        pFoundDock->nType = pDockWin->GetType();
+        nLine++;
+        nPos = 0;
+        bNewLine = true;
+        pFoundDock->bNewLine = bNewLine;
+        bSaveConfig = true;
+    }
+
+    pFoundDock->pWin = pDockWin;
+    pFoundDock->bHide = false;
+    InsertWindow_Impl( pFoundDock, rSize, nLine, nPos, bNewLine );
+    if ( bSaveConfig )
+        SaveConfig_Impl();
+}
+
+
+void SfxSplitWindow::ReleaseWindow_Impl(SfxDockingWindow const *pDockWin, bool bSave)
+{
+//  The docking window is no longer stored in the internal data.
+    sal_uInt16 nCount = maDockArr.size();
+    for ( sal_uInt16 n=0; n<nCount; n++ )
+    {
+        const SfxDock_Impl& rDock = *maDockArr[n];
+        if ( rDock.nType == pDockWin->GetType() )
+        {
+            if ( rDock.bNewLine && n<nCount-1 )
+                maDockArr[n+1]->bNewLine = true;
+
+            // Window has a position, this we forget
+            maDockArr.erase(maDockArr.begin() + n);
+            break;
+        }
+    }
+
+    if ( bSave )
+        SaveConfig_Impl();
+}
+
+
+void SfxSplitWindow::MoveWindow( SfxDockingWindow* pDockWin, const Size& rSize,
+                        sal_uInt16 nLine, sal_uInt16 nPos, bool bNewLine)
+
+/*  [Description]
+
+    The docking window is moved within the SplitWindows.
+*/
+
+{
+    sal_uInt16 nL, nP;
+    GetWindowPos( pDockWin, nL, nP );
+
+    if ( nLine > nL && GetItemCount( GetItemId( nL ) ) == 1 )
+    {
+        // If the last window is removed from its line, then everything slips
+        // one line to the front!
+        nLine--;
+    }
+    RemoveWindow( pDockWin );
+    InsertWindow( pDockWin, rSize, nLine, nPos, bNewLine );
+}
+
+
+void SfxSplitWindow::InsertWindow( SfxDockingWindow* pDockWin, const Size& rSize,
+                        sal_uInt16 nLine, sal_uInt16 nPos, bool bNewLine)
+
+/*  [Description]
+
+    The DockingWindow that is pushed on this SplitWindow and shall hold the
+    given position and size.
+*/
+{
+    ReleaseWindow_Impl( pDockWin, false );
+    SfxDock_Impl *pDock = new SfxDock_Impl;
+    pDock->bHide = false;
+    pDock->nType = pDockWin->GetType();
+    pDock->bNewLine = bNewLine;
+    pDock->pWin = pDockWin;
+
+    DBG_ASSERT( nPos==0 || !bNewLine, "Wrong Parameter!");
+    if ( bNewLine )
+        nPos = 0;
+
+    // The window must be inserted before the first window so that it has the
+    // same or a greater position than pDockWin.
+    sal_uInt16 nCount = maDockArr.size();
+    sal_uInt16 nLastWindowIdx(0);
+
+    // If no window is found, a first window is inserted
+    sal_uInt16 nInsertPos = 0;
+    for ( sal_uInt16 n=0; n<nCount; n++ )
+    {
+        SfxDock_Impl& rD = *maDockArr[n];
+
+        if (rD.pWin)
+        {
+            // A docked window has been found. If no suitable window behind
+            // the desired insertion point s found, then insertion is done at
+            // the end.
+            nInsertPos = nCount;
+            nLastWindowIdx = n;
+            sal_uInt16 nL=0, nP=0;
+            GetWindowPos( rD.pWin, nL, nP );
+
+            if ( (nL == nLine && nP == nPos) || nL > nLine )
+            {
+                DBG_ASSERT( nL == nLine || bNewLine || nPos > 0, "Wrong Parameter!" );
+                if ( nL == nLine && nPos == 0 && !bNewLine )
+                {
+                    DBG_ASSERT(rD.bNewLine, "No new line?");
+
+                    // The position is pushed to nPos==0
+                    rD.bNewLine = false;
+                    pDock->bNewLine = true;
+                }
+
+                nInsertPos = n != 0 ? nLastWindowIdx + 1 : 0;    // ignore all non-windows after the last window
+                break;
+            }
+        }
+    }
+    if (nCount != 0 && nInsertPos == nCount && nLastWindowIdx != nCount - 1)
+    {
+        nInsertPos = nLastWindowIdx + 1;    // ignore all non-windows after the last window
+    }
+
+    maDockArr.insert(maDockArr.begin() + nInsertPos, std::unique_ptr<SfxDock_Impl>(pDock));
+    InsertWindow_Impl( pDock, rSize, nLine, nPos, bNewLine );
+    SaveConfig_Impl();
+}
+
+
+void SfxSplitWindow::InsertWindow_Impl( SfxDock_Impl const * pDock,
+                        const Size& rSize,
+                        sal_uInt16 nLine, sal_uInt16 nPos, bool bNewLine)
+
+/*  [Description]
+
+    Adds a DockingWindow, and causes the recalculation of the size of
+    the SplitWindows.
+*/
+
+{
+    SfxDockingWindow* pDockWin = pDock->pWin;
+
+    SplitWindowItemFlags nItemBits = SplitWindowItemFlags::NONE;
+
+    long nWinSize, nSetSize;
+    if ( IsHorizontal() )
+    {
+        nWinSize = rSize.Width();
+        nSetSize = rSize.Height();
+    }
+    else
+    {
+        nSetSize = rSize.Width();
+        nWinSize = rSize.Height();
+    }
+
+    std::unique_ptr<DeactivateUpdateMode> pDeactivateUpdateMode(new DeactivateUpdateMode( *this ));
+
+    if ( bNewLine || nLine == GetItemCount() )
+    {
+        // An existing row should not be inserted, instead a new one
+        // will be created
+
+        sal_uInt16 nId = 1;
+        for ( sal_uInt16 n=0; n<GetItemCount(); n++ )
+        {
+            if ( GetItemId(n) >= nId )
+                nId = GetItemId(n)+1;
+        }
+
+        // Create a new nLine:th line
+        SplitWindowItemFlags nBits = nItemBits;
+        if ( GetAlign() == WindowAlign::Top || GetAlign() == WindowAlign::Bottom )
+            nBits |= SplitWindowItemFlags::ColSet;
+        InsertItem( nId, nSetSize, nLine, 0, nBits );
+    }
+
+    // Insert the window at line with the position nline. ItemWindowSize set to
+    // "percentage" share since the SV then does the re-sizing as expected,
+    // "pixel" actually only makes sense if also items with percentage or
+    // relative sizes are present.
+    nItemBits |= SplitWindowItemFlags::PercentSize;
+    sal_uInt16 nSet = GetItemId( nLine );
+    InsertItem( pDockWin->GetType(), pDockWin, nWinSize, nPos, nSet, nItemBits );
+
+    // SplitWindows are once created in SFX and when inserting the first
+    // DockingWindows is made visible.
+    if ( GetItemCount() == 1 && GetItemCount( 1 ) == 1 )
+    {
+        // The Rearranging in WorkWindow and a Show() on the SplitWindow is
+        // caused by SfxDockingwindow (->SfxWorkWindow::ConfigChild_Impl)
+        if ( !bPinned && !IsFloatingMode() )
+        {
+            bPinned = true;
+            bool bFadeIn = ( pEmptyWin->nState & 2 ) != 0;
+            pEmptyWin->bFadeIn = false;
+            SetPinned_Impl( false );
+            pEmptyWin->Actualize();
+            SAL_INFO("sfx", "SfxSplitWindow::InsertWindow_Impl - registering empty Splitwindow" );
+            pWorkWin->RegisterChild_Impl( *GetSplitWindow(), eAlign )->nVisible = SfxChildVisibility::VISIBLE;
+            // tdf#113539 FadeIn will call ArrangeChildren_Impl() for us, and avoiding extra calls to that
+            // can make a different to load times because it avoids extra accessibility calcs
+            if ( bFadeIn )
+                FadeIn();
+            else
+                pWorkWin->ArrangeChildren_Impl();
+        }
+        else
+        {
+            bool bFadeIn = ( pEmptyWin->nState & 2 ) != 0;
+            pEmptyWin->bFadeIn = false;
+            pEmptyWin->Actualize();
+            if ( !bPinned || !pEmptyWin->bFadeIn )
+            {
+                SAL_INFO("sfx", "SfxSplitWindow::InsertWindow_Impl - registering empty Splitwindow" );
+            }
+            else
+            {
+                SAL_INFO("sfx", "SfxSplitWindow::InsertWindow_Impl - registering real Splitwindow" );
+            }
+            pWorkWin->RegisterChild_Impl( *GetSplitWindow(), eAlign )->nVisible = SfxChildVisibility::VISIBLE;
+            // tdf#113539 FadeIn will call ArrangeChildren_Impl() for us, and avoiding extra calls to that
+            // can make a different to load times because it avoids extra accessibility calcs
+            if ( bFadeIn )
+                FadeIn();
+            else
+                pWorkWin->ArrangeChildren_Impl();
+        }
+
+        pWorkWin->ShowChildren_Impl();
+    }
+
+    pDeactivateUpdateMode.reset();
+
+    // workaround insufficiency of <SplitWindow> regarding dock layouting:
+    // apply FIXED item size as 'original' item size to improve layouting of undock-dock-cycle of a window
+    {
+        std::vector< std::pair< sal_uInt16, long > > aNewOrgSizes;
+        // get FIXED item sizes
+        sal_uInt16 nCount = maDockArr.size();
+        for ( sal_uInt16 n=0; n<nCount; ++n )
+        {
+            const SfxDock_Impl& rD = *maDockArr[n];
+            if ( rD.pWin )
+            {
+                const sal_uInt16 nId = rD.nType;
+                const long nSize    = GetItemSize( nId, SplitWindowItemFlags::Fixed );
+                aNewOrgSizes.emplace_back( nId, nSize );
+            }
+        }
+        // apply new item sizes
+        DeactivateUpdateMode aDeactivateUpdateMode( *this );
+        for (const std::pair< sal_uInt16, long > & rNewOrgSize : aNewOrgSizes)
+        {
+            SetItemSize( rNewOrgSize.first, rNewOrgSize.second );
+        }
+    }
+}
+
+
+void SfxSplitWindow::RemoveWindow( SfxDockingWindow const * pDockWin, bool bHide )
+
+/*  [Description]
+
+    Removes a DockingWindow. If it was the last one, then the SplitWindow is
+    being hidden.
+*/
+{
+    sal_uInt16 nSet = GetSet( pDockWin->GetType() );
+
+    // SplitWindows are once created in SFX and is made invisible after
+    // removing the last DockingWindows.
+    if ( GetItemCount( nSet ) == 1 && GetItemCount() == 1 )
+    {
+        // The Rearranging in WorkWindow is caused by SfxDockingwindow
+        Hide();
+        pEmptyWin->aTimer.Stop();
+        sal_uInt16 nRealState = pEmptyWin->nState;
+        FadeOut_Impl();
+        pEmptyWin->Hide();
+#ifdef DBG_UTIL
+        if ( !bPinned || !pEmptyWin->bFadeIn )
+        {
+            SAL_INFO("sfx", "SfxSplitWindow::RemoveWindow - releasing empty Splitwindow" );
+        }
+        else
+        {
+            SAL_INFO("sfx", "SfxSplitWindow::RemoveWindow - releasing real Splitwindow" );
+        }
+#endif
+        pWorkWin->ReleaseChild_Impl( *GetSplitWindow() );
+        pEmptyWin->nState = nRealState;
+        pWorkWin->ArrangeAutoHideWindows( this );
+    }
+
+    sal_uInt16 nCount = maDockArr.size();
+    for ( sal_uInt16 n=0; n<nCount; n++ )
+    {
+        SfxDock_Impl& rDock = *maDockArr[n];
+        if ( rDock.nType == pDockWin->GetType() )
+        {
+            rDock.pWin = nullptr;
+            rDock.bHide = bHide;
+            break;
+        }
+    }
+
+    // Remove Windows, and if it was the last of the line, then also remove
+    // the line (line = itemset)
+    DeactivateUpdateMode aDeactivateUpdateMode( *this );
+
+    RemoveItem( pDockWin->GetType() );
+
+    if ( nSet && !GetItemCount( nSet ) )
+        RemoveItem( nSet );
+};
+
+
+bool SfxSplitWindow::GetWindowPos( const SfxDockingWindow* pWindow,
+                                        sal_uInt16& rLine, sal_uInt16& rPos ) const
+/*  [Description]
+
+    Returns the ID of the item sets and items for the DockingWindow in
+    the position passed on the old row / column-name.
+*/
+
+{
+    sal_uInt16 nSet = GetSet ( pWindow->GetType() );
+    if ( nSet == SPLITWINDOW_ITEM_NOTFOUND )
+        return false;
+
+    rPos  = GetItemPos( pWindow->GetType(), nSet );
+    rLine = GetItemPos( nSet );
+    return true;
+}
+
+
+bool SfxSplitWindow::GetWindowPos( const Point& rTestPos,
+                                      sal_uInt16& rLine, sal_uInt16& rPos ) const
+/*  [Description]
+
+    Returns the ID of the item sets and items for the DockingWindow in
+    the position passed on the old row / column-name.
+*/
+
+{
+    sal_uInt16 nId = GetItemId( rTestPos );
+    if ( nId == 0 )
+        return false;
+
+    sal_uInt16 nSet = GetSet ( nId );
+    rPos  = GetItemPos( nId, nSet );
+    rLine = GetItemPos( nSet );
+    return true;
+}
+
+
+sal_uInt16 SfxSplitWindow::GetLineCount() const
+
+/*  [Description]
+
+    Returns the number of rows = number of sub-itemsets in the root set.
+*/
+{
+    return GetItemCount();
+}
+
+
+long SfxSplitWindow::GetLineSize( sal_uInt16 nLine ) const
+
+/*  [Description]
+
+    Returns the Row Height of nline itemset.
+*/
+{
+    sal_uInt16 nId = GetItemId( nLine );
+    return GetItemSize( nId );
+}
+
+
+sal_uInt16 SfxSplitWindow::GetWindowCount( sal_uInt16 nLine ) const
+
+/*  [Description]
+
+    Returns the total number of windows
+*/
+{
+    sal_uInt16 nId = GetItemId( nLine );
+    return GetItemCount( nId );
+}
+
+
+sal_uInt16 SfxSplitWindow::GetWindowCount() const
+
+/*  [Description]
+
+    Returns the total number of windows
+*/
+{
+    return GetItemCount();
+}
+
+
+IMPL_LINK( SfxSplitWindow, TimerHdl, Timer*, pTimer, void)
+{
+    if ( pTimer )
+        pTimer->Stop();
+
+    if ( CursorIsOverRect() || !pTimer )
+    {
+        // If the cursor is within the window, display the SplitWindow and set
+        // up the timer for close
+        pEmptyWin->bAutoHide = true;
+        if ( !IsVisible() )
+            pEmptyWin->FadeIn();
+
+        pEmptyWin->aLastPos = GetPointerPosPixel();
+        pEmptyWin->aTimer.Start();
+    }
+    else if ( pEmptyWin->bAutoHide )
+    {
+        if ( GetPointerPosPixel() != pEmptyWin->aLastPos )
+        {
+            // The mouse has moved within the running time of the timer, thus
+            // do nothing
+            pEmptyWin->aLastPos = GetPointerPosPixel();
+            pEmptyWin->aTimer.Start();
+            return;
+        }
+
+        // Especially for TF_AUTOSHOW_ON_MOUSEMOVE :
+        // If the window is not visible, there is nothing to do
+        // (user has simply moved the mouse over pEmptyWin)
+        if ( IsVisible() )
+        {
+            pEmptyWin->bEndAutoHide = false;
+            if ( !Application::IsInModalMode() &&
+                  !PopupMenu::IsInExecute() &&
+                  !pEmptyWin->bSplit && !HasChildPathFocus( true ) )
+            {
+                // While a modal dialog or a popup menu is open or while the
+                // Splitting is done, in any case, do not close. Even as long
+                // as one of the Children has the focus, the window remains
+                // open.
+                pEmptyWin->bEndAutoHide = true;
+            }
+
+            if ( pEmptyWin->bEndAutoHide )
+            {
+               // As far as I am concerned this can be the end of AutoShow
+               // But maybe some other SfxSplitWindow will remain open,
+               // then all others remain open too.
+                if ( !pWorkWin->IsAutoHideMode( this ) )
+                {
+                    FadeOut_Impl();
+                    pWorkWin->ArrangeAutoHideWindows( this );
+                }
+                else
+                {
+                    pEmptyWin->aLastPos = GetPointerPosPixel();
+                    pEmptyWin->aTimer.Start();
+                }
+            }
+            else
+            {
+                pEmptyWin->aLastPos = GetPointerPosPixel();
+                pEmptyWin->aTimer.Start();
+            }
+        }
+    }
+}
+
+
+bool SfxSplitWindow::CursorIsOverRect() const
+{
+    bool bVisible = IsVisible();
+
+    // Also, take the collapsed SplitWindow into account
+    Point aPos = pEmptyWin->GetParent()->OutputToScreenPixel( pEmptyWin->GetPosPixel() );
+    Size aSize = pEmptyWin->GetSizePixel();
+
+    tools::Rectangle aRect( aPos, aSize );
+
+    if ( bVisible )
+    {
+        Point aVisPos = GetPosPixel();
+        Size aVisSize = GetSizePixel();
+
+        // Extend with +/- a few pixels, otherwise it is too nervous
+        aVisPos.AdjustX( -(nPixel) );
+        aVisPos.AdjustY( -(nPixel) );
+        aVisSize.AdjustWidth(2 * nPixel );
+        aVisSize.AdjustHeight(2 * nPixel );
+
+        tools::Rectangle aVisRect( aVisPos, aVisSize );
+        aRect = aRect.GetUnion( aVisRect );
+    }
+
+    return aRect.IsInside( OutputToScreenPixel( static_cast<vcl::Window*>(const_cast<SfxSplitWindow *>(this))->GetPointerPosPixel() ) );
+}
+
+
+SplitWindow* SfxSplitWindow::GetSplitWindow()
+{
+    if ( !bPinned || !pEmptyWin->bFadeIn )
+        return pEmptyWin;
+    return this;
+}
+
+
+bool SfxSplitWindow::IsFadeIn() const
+{
+    return pEmptyWin->bFadeIn;
+}
+
+bool SfxSplitWindow::IsAutoHide( bool bSelf ) const
+{
+    return bSelf ? pEmptyWin->bAutoHide && !pEmptyWin->bEndAutoHide : pEmptyWin->bAutoHide;
+}
+
+
+void SfxSplitWindow::SetPinned_Impl( bool bOn )
+{
+    if ( bPinned == bOn )
+        return;
+
+    bPinned = bOn;
+    if ( GetItemCount() == 0 )
+        return;
+
+    if ( !bOn )
+    {
+        pEmptyWin->nState |= 1;
+        if ( pEmptyWin->bFadeIn )
+        {
+            // Unregister replacement windows
+            SAL_INFO("sfx", "SfxSplitWindow::SetPinned_Impl - releasing real Splitwindow" );
+            pWorkWin->ReleaseChild_Impl( *this );
+            Hide();
+            pEmptyWin->Actualize();
+            SAL_INFO("sfx", "SfxSplitWindow::SetPinned_Impl - registering empty Splitwindow" );
+            pWorkWin->RegisterChild_Impl( *pEmptyWin, eAlign )->nVisible = SfxChildVisibility::VISIBLE;
+        }
+
+        Point aPos( GetPosPixel() );
+        aPos = GetParent()->OutputToScreenPixel( aPos );
+        SetFloatingPos( aPos );
+        SetFloatingMode( true );
+        GetFloatingWindow()->SetOutputSizePixel( GetOutputSizePixel() );
+
+        if ( pEmptyWin->bFadeIn )
+            Show();
+    }
+    else
+    {
+        pEmptyWin->nState &= ~1;
+        SetOutputSizePixel( GetFloatingWindow()->GetOutputSizePixel() );
+        SetFloatingMode(false);
+
+        if ( pEmptyWin->bFadeIn )
+        {
+            // Unregister replacement windows
+            SAL_INFO("sfx", "SfxSplitWindow::SetPinned_Impl - releasing empty Splitwindow" );
+            pWorkWin->ReleaseChild_Impl( *pEmptyWin );
+            pEmptyWin->Hide();
+            SAL_INFO("sfx", "SfxSplitWindow::SetPinned_Impl - registering real Splitwindow" );
+            pWorkWin->RegisterChild_Impl( *this, eAlign )->nVisible = SfxChildVisibility::VISIBLE;
+        }
+    }
+}
+
+void SfxSplitWindow::SetFadeIn_Impl( bool bOn )
+{
+    if ( bOn == pEmptyWin->bFadeIn )
+        return;
+
+    if ( GetItemCount() == 0 )
+        return;
+
+    pEmptyWin->bFadeIn = bOn;
+    if ( bOn )
+    {
+        pEmptyWin->nState |= 2;
+        if ( IsFloatingMode() )
+        {
+            // FloatingWindow is not visible, thus display it
+            pWorkWin->ArrangeAutoHideWindows( this );
+            Show();
+        }
+        else
+        {
+            SAL_INFO("sfx", "SfxSplitWindow::SetFadeIn_Impl - releasing empty Splitwindow" );
+            pWorkWin->ReleaseChild_Impl( *pEmptyWin );
+            pEmptyWin->Hide();
+            SAL_INFO("sfx", "SfxSplitWindow::SetFadeIn_Impl - registering real Splitwindow" );
+            pWorkWin->RegisterChild_Impl( *this, eAlign )->nVisible = SfxChildVisibility::VISIBLE;
+            pWorkWin->ArrangeChildren_Impl();
+            pWorkWin->ShowChildren_Impl();
+        }
+    }
+    else
+    {
+        pEmptyWin->bAutoHide = false;
+        pEmptyWin->nState &= ~2;
+        if ( !IsFloatingMode() )
+        {
+            // The window is not "floating", should be hidden
+            SAL_INFO("sfx", "SfxSplitWindow::SetFadeIn_Impl - releasing real Splitwindow" );
+            pWorkWin->ReleaseChild_Impl( *this );
+            Hide();
+            pEmptyWin->Actualize();
+            SAL_INFO("sfx", "SfxSplitWindow::SetFadeIn_Impl - registering empty Splitwindow" );
+            pWorkWin->RegisterChild_Impl( *pEmptyWin, eAlign )->nVisible = SfxChildVisibility::VISIBLE;
+            pWorkWin->ArrangeChildren_Impl();
+            pWorkWin->ShowChildren_Impl();
+            pWorkWin->ArrangeAutoHideWindows( this );
+        }
+        else
+        {
+            Hide();
+            pWorkWin->ArrangeAutoHideWindows( this );
+        }
+    }
+}
+
+void SfxSplitWindow::FadeOut_Impl()
+{
+    if ( pEmptyWin->aTimer.IsActive() )
+    {
+        pEmptyWin->bAutoHide = false;
+        pEmptyWin->aTimer.Stop();
+    }
+
+    SetFadeIn_Impl( false );
+}
+
+void SfxSplitWindow::FadeOut()
+{
+    FadeOut_Impl();
+    SaveConfig_Impl();
+}
+
+void SfxSplitWindow::FadeIn()
+{
+    SetFadeIn_Impl( true );
+}
+
+void SfxSplitWindow::SetActiveWindow_Impl( SfxDockingWindow* pWin )
+{
+    pActive = pWin;
+    pWorkWin->SetActiveChild_Impl( this );
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/srchdlg.cxx b/sfx2/source/dialog/srchdlg.cxx
new file mode 100644
index 000000000..de5bde88d
--- /dev/null
+++ b/sfx2/source/dialog/srchdlg.cxx
@@ -0,0 +1,134 @@
+/* -*- 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 <srchdlg.hxx>
+#include <comphelper/string.hxx>
+
+#include <tools/debug.hxx>
+#include <unotools/viewoptions.hxx>
+
+using namespace ::com::sun::star::uno;
+
+
+namespace sfx2 {
+
+#define MAX_SAVE_COUNT      sal_uInt16(10)
+
+
+// SearchDialog
+
+
+SearchDialog::SearchDialog(weld::Window* pWindow, const OUString& rConfigName)
+    : GenericDialogController(pWindow, "sfx/ui/searchdialog.ui", "SearchDialog")
+    , m_sConfigName(rConfigName)
+    , m_xSearchEdit(m_xBuilder->weld_combo_box("searchterm"))
+    , m_xWholeWordsBox(m_xBuilder->weld_check_button("wholewords"))
+    , m_xMatchCaseBox(m_xBuilder->weld_check_button("matchcase"))
+    , m_xWrapAroundBox(m_xBuilder->weld_check_button("wrap"))
+    , m_xBackwardsBox(m_xBuilder->weld_check_button("backwards"))
+    , m_xFindBtn(m_xBuilder->weld_button("ok"))
+{
+    // set handler
+    m_xFindBtn->connect_clicked(LINK(this, SearchDialog, FindHdl));
+    // load config: old search strings and the status of the check boxes
+    LoadConfig();
+    // the search edit should have the focus
+    m_xSearchEdit->grab_focus();
+}
+
+SearchDialog::~SearchDialog()
+{
+    SaveConfig();
+}
+
+void SearchDialog::LoadConfig()
+{
+    SvtViewOptions aViewOpt( EViewType::Dialog, m_sConfigName );
+    if ( aViewOpt.Exists() )
+    {
+        Any aUserItem = aViewOpt.GetUserItem( "UserItem" );
+        OUString sUserData;
+        if ( aUserItem >>= sUserData )
+        {
+            DBG_ASSERT( comphelper::string::getTokenCount(sUserData, ';') == 5, "invalid config data" );
+            sal_Int32 nIdx = 0;
+            OUString sSearchText = sUserData.getToken( 0, ';', nIdx );
+            m_xWholeWordsBox->set_active( sUserData.getToken( 0, ';', nIdx ).toInt32() == 1 );
+            m_xMatchCaseBox->set_active( sUserData.getToken( 0, ';', nIdx ).toInt32() == 1 );
+            m_xWrapAroundBox->set_active( sUserData.getToken( 0, ';', nIdx ).toInt32() == 1 );
+            m_xBackwardsBox->set_active( sUserData.getToken( 0, ';', nIdx ).toInt32() == 1 );
+
+            nIdx = 0;
+            while ( nIdx != -1 )
+                m_xSearchEdit->append_text(sSearchText.getToken( 0, '\t', nIdx));
+            m_xSearchEdit->set_active(0);
+        }
+    }
+    else
+        m_xWrapAroundBox->set_active(true);
+}
+
+void SearchDialog::SaveConfig()
+{
+    SvtViewOptions aViewOpt( EViewType::Dialog, m_sConfigName );
+    OUString sUserData;
+    int i = 0, nCount = std::min(m_xSearchEdit->get_count(), static_cast<int>(MAX_SAVE_COUNT));
+    for ( ; i < nCount; ++i )
+    {
+        sUserData += m_xSearchEdit->get_text(i) + "\t";
+    }
+    sUserData = comphelper::string::stripStart(sUserData, '\t') + ";" +
+        OUString::number( m_xWholeWordsBox->get_active() ? 1 : 0 ) + ";" +
+        OUString::number( m_xMatchCaseBox->get_active() ? 1 : 0 ) + ";" +
+        OUString::number( m_xWrapAroundBox->get_active() ? 1 : 0 ) + ";" +
+        OUString::number( m_xBackwardsBox->get_active() ? 1 : 0 );
+
+    Any aUserItem = makeAny( sUserData );
+    aViewOpt.SetUserItem( "UserItem", aUserItem );
+}
+
+IMPL_LINK_NOARG(SearchDialog, FindHdl, weld::Button&, void)
+{
+    OUString sSrchTxt = m_xSearchEdit->get_active_text();
+    auto nPos = m_xSearchEdit->find_text(sSrchTxt);
+    if (nPos != 0)
+    {
+        if (nPos != -1)
+            m_xSearchEdit->remove(nPos);
+        m_xSearchEdit->insert_text(0, sSrchTxt);
+    }
+    m_aFindHdl.Call( *this );
+}
+
+void SearchDialog::SetFocusOnEdit()
+{
+    m_xSearchEdit->select_entry_region(0, -1);
+    m_xSearchEdit->grab_focus();
+}
+
+void SearchDialog::runAsync(const std::shared_ptr<SearchDialog>& rController)
+{
+    weld::DialogController::runAsync(rController, [=](sal_Int32 /*nResult*/){ rController->m_aCloseHdl.Call(nullptr); });
+}
+
+} // namespace sfx2
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/styfitem.cxx b/sfx2/source/dialog/styfitem.cxx
new file mode 100644
index 000000000..a1ff5ab78
--- /dev/null
+++ b/sfx2/source/dialog/styfitem.cxx
@@ -0,0 +1,32 @@
+/* -*- 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/styfitem.hxx>
+#include <unotools/resmgr.hxx>
+
+SfxStyleFamilyItem::SfxStyleFamilyItem(SfxStyleFamily nFamily_, const OUString &rName, const OUString& rImage, const std::pair<const char*, SfxStyleSearchBits>* pStringArray, const std::locale& rResLocale)
+    : nFamily(nFamily_)
+    , aText(rName)
+    , aImage(rImage)
+{
+    for (const std::pair<const char*, SfxStyleSearchBits>* pItem = pStringArray; pItem->first; ++pItem)
+        aFilterList.emplace_back(Translate::get(pItem->first, rResLocale), pItem->second);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/styledlg.cxx b/sfx2/source/dialog/styledlg.cxx
new file mode 100644
index 000000000..2614083f8
--- /dev/null
+++ b/sfx2/source/dialog/styledlg.cxx
@@ -0,0 +1,124 @@
+/* -*- 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/whiter.hxx>
+#include <svl/style.hxx>
+
+#include <sfx2/styledlg.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/strings.hrc>
+
+#include "mgetempl.hxx"
+
+/*  [Description]
+
+    Constructor: Add Manage TabPage, set ExampleSet from style.
+*/
+SfxStyleDialogController::SfxStyleDialogController
+(
+    weld::Window* pParent,           // Parent
+    const OUString& rUIXMLDescription, const OString& rID,
+    SfxStyleSheetBase& rStyle  // stylesheet to be processed
+)
+    : SfxTabDialogController(pParent, rUIXMLDescription, rID, &rStyle.GetItemSet(), true)
+    , m_rStyle(rStyle)
+{
+    // without ParentSupport suppress the standardButton
+    if (!rStyle.HasParentSupport())
+        RemoveStandardButton();
+
+    AddTabPage("organizer", SfxManageStyleSheetPage::Create, nullptr);
+
+    // With new template always set the management page as the current page
+    if (rStyle.GetName().isEmpty())
+        SetCurPageId("organizer");
+    else
+    {
+        OUString sTxt = m_xDialog->get_title() + ": " + rStyle.GetName();
+        m_xDialog->set_title(sTxt);
+    }
+    m_xExampleSet.reset(&m_rStyle.GetItemSet()); // in SfxTabDialog::Ctor() already created, reset will delete it
+
+    GetCancelButton().connect_clicked(LINK(this, SfxStyleDialogController, CancelHdl));
+}
+
+/*  [Description]
+
+    Destructor: set ExampleSet to NULL, so that SfxTabDialog does not delete
+    the Set from Style.
+*/
+SfxStyleDialogController::~SfxStyleDialogController()
+{
+    m_xExampleSet.release();
+}
+
+/*  [Description]
+
+    Override so that always RET_OK is returned.
+*/
+short SfxStyleDialogController::Ok()
+{
+    SfxTabDialogController::Ok();
+    return RET_OK;
+}
+
+/*  [Description]
+
+    If the dialogue was canceled, then all selected attributes must be reset
+    again.
+*/
+IMPL_LINK_NOARG(SfxStyleDialogController, CancelHdl, weld::Button&, void)
+{
+    SfxTabPage* pPage = GetTabPage("organizer");
+
+    const SfxItemSet* pInSet = GetInputSetImpl();
+    SfxWhichIter aIter(*pInSet);
+    sal_uInt16 nWhich = aIter.FirstWhich();
+
+    while (nWhich)
+    {
+        SfxItemState eState = pInSet->GetItemState(nWhich, false);
+
+        if (SfxItemState::DEFAULT == eState)
+            m_xExampleSet->ClearItem(nWhich);
+        else
+            m_xExampleSet->Put(pInSet->Get(nWhich));
+        nWhich = aIter.NextWhich();
+    }
+
+    if (pPage)
+        pPage->Reset(GetInputSetImpl());
+
+    m_xDialog->response(RET_CANCEL);
+}
+
+OUString SfxStyleDialogController::GenerateUnusedName(SfxStyleSheetBasePool &rPool, SfxStyleFamily eFam)
+{
+    OUString aNo(SfxResId(STR_NONAME));
+    sal_uInt16 i = 1;
+    OUString aNoName = aNo + OUString::number(i);
+    while (rPool.Find(aNoName, eFam))
+    {
+        ++i;
+        aNoName = aNo + OUString::number(i);
+    }
+    return aNoName;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/tabdlg.cxx b/sfx2/source/dialog/tabdlg.cxx
new file mode 100644
index 000000000..8ad06f98e
--- /dev/null
+++ b/sfx2/source/dialog/tabdlg.cxx
@@ -0,0 +1,1172 @@
+/* -*- 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 <stdlib.h>
+#include <algorithm>
+
+#include <sfx2/tabdlg.hxx>
+#include <sfx2/app.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/sfxdlg.hxx>
+#include <unotools/viewoptions.hxx>
+#include <vcl/virdev.hxx>
+#include <sal/log.hxx>
+#include <tools/debug.hxx>
+#include <comphelper/lok.hxx>
+
+#include <sfx2/strings.hrc>
+#include <helpids.h>
+
+using namespace ::com::sun::star::uno;
+
+#define USERITEM_NAME           "UserItem"
+
+
+struct TabPageImpl
+{
+    bool                        mbStandard;
+    SfxOkDialogController*      mpSfxDialogController;
+    css::uno::Reference< css::frame::XFrame > mxFrame;
+
+    TabPageImpl() : mbStandard(false), mpSfxDialogController(nullptr) {}
+};
+
+namespace {
+
+struct Data_Impl
+{
+    OString sId;                  // The ID
+    CreateTabPage fnCreatePage;   // Pointer to Factory
+    GetTabPageRanges fnGetRanges; // Pointer to Ranges-Function
+    std::unique_ptr<SfxTabPage> xTabPage;         // The TabPage itself
+    bool bRefresh;                // Flag: Page must be re-initialized
+
+    // Constructor
+    Data_Impl( const OString& rId, CreateTabPage fnPage,
+               GetTabPageRanges fnRanges ) :
+
+        sId         ( rId ),
+        fnCreatePage( fnPage ),
+        fnGetRanges ( fnRanges ),
+        bRefresh    ( false )
+    {
+    }
+};
+
+}
+
+SfxTabDialogItem::SfxTabDialogItem( const SfxTabDialogItem& rAttr, SfxItemPool* pItemPool )
+    : SfxSetItem( rAttr, pItemPool )
+{
+}
+
+SfxTabDialogItem::SfxTabDialogItem( sal_uInt16 nId, const SfxItemSet& rItemSet )
+    : SfxSetItem( nId, rItemSet )
+{
+}
+
+SfxTabDialogItem* SfxTabDialogItem::Clone(SfxItemPool* pToPool) const
+{
+    return new SfxTabDialogItem( *this, pToPool );
+}
+
+typedef std::vector<Data_Impl*> SfxTabDlgData_Impl;
+
+struct TabDlg_Impl
+{
+    bool                bHideResetBtn : 1;
+    bool                bStarted : 1;
+    SfxTabDlgData_Impl  aData;
+
+    explicit TabDlg_Impl(sal_uInt8 nCnt)
+        : bHideResetBtn(false)
+        , bStarted(false)
+    {
+        aData.reserve( nCnt );
+    }
+};
+
+static Data_Impl* Find( const SfxTabDlgData_Impl& rArr, const OString& rId, sal_uInt16* pPos = nullptr)
+{
+    const sal_uInt16 nCount = rArr.size();
+
+    for ( sal_uInt16 i = 0; i < nCount; ++i )
+    {
+        Data_Impl* pObj = rArr[i];
+
+        if ( pObj->sId == rId )
+        {
+            if ( pPos )
+                *pPos = i;
+            return pObj;
+        }
+    }
+    return nullptr;
+}
+
+void SfxTabPage::SetFrame(const css::uno::Reference< css::frame::XFrame >& xFrame)
+{
+    if (pImpl)
+        pImpl->mxFrame = xFrame;
+}
+
+css::uno::Reference< css::frame::XFrame > SfxTabPage::GetFrame() const
+{
+    if (pImpl)
+        return pImpl->mxFrame;
+    return css::uno::Reference< css::frame::XFrame >();
+}
+
+SfxTabPage::SfxTabPage(weld::Container* pPage, weld::DialogController* pController, const OUString& rUIXMLDescription, const OString& rID, const SfxItemSet *rAttrSet)
+    : BuilderPage(pPage, pController, rUIXMLDescription, rID)
+    , pSet                ( rAttrSet )
+    , bHasExchangeSupport ( false )
+    , pImpl               ( new TabPageImpl )
+{
+    pImpl->mpSfxDialogController = dynamic_cast<SfxOkDialogController*>(m_pDialogController);
+}
+
+SfxTabPage::~SfxTabPage()
+{
+    if (m_xContainer)
+    {
+        std::unique_ptr<weld::Container> xParent(m_xContainer->weld_parent());
+        if (xParent)
+            xParent->move(m_xContainer.get(), nullptr);
+    }
+    m_xContainer.reset();
+    pImpl.reset();
+    m_xBuilder.reset();
+}
+
+bool SfxTabPage::FillItemSet( SfxItemSet* )
+{
+    return false;
+}
+
+void SfxTabPage::Reset( const SfxItemSet* )
+{
+}
+
+void SfxTabPage::ActivatePage( const SfxItemSet& )
+/*  [Description]
+
+    Default implementation of the virtual ActivatePage method. This method is
+    called when a page of dialogue supports the exchange of data between pages.
+    <SfxTabPage::DeactivatePage(SfxItemSet *)>
+*/
+{
+}
+
+DeactivateRC SfxTabPage::DeactivatePage( SfxItemSet* )
+
+/*  [Description]
+
+    Default implementation of the virtual DeactivatePage method. This method is
+    called by Sfx when leaving a page; the application can, through the return
+    value, control whether to leave the page. If the page is displayed through
+    bHasExchangeSupport which supports data exchange between pages, then a
+    pointer to the exchange set is passed as parameter. This takes on data for
+    the exchange, then the set is available as a parameter in
+    <SfxTabPage::ActivatePage(const SfxItemSet &)>.
+
+    [Return value]
+
+    DeactivateRC::LeavePage; Allow leaving the page
+*/
+
+{
+    return DeactivateRC::LeavePage;
+}
+
+
+void SfxTabPage::FillUserData()
+
+/*  [Description]
+
+    Virtual method is called by the base class in the destructor to save
+    specific information of the TabPage in the ini-file. When overriding a
+    string must be compiled, which is then flushed with the <SetUserData()>.
+*/
+
+{
+}
+
+
+bool SfxTabPage::IsReadOnly() const
+{
+    return false;
+}
+
+
+const SfxPoolItem* SfxTabPage::GetItem( const SfxItemSet& rSet, sal_uInt16 nSlot, bool bDeep )
+
+/*  [Description]
+
+    static Method: hereby are the implementations of the TabPage code
+    being simplified.
+*/
+
+{
+    const SfxItemPool* pPool = rSet.GetPool();
+    sal_uInt16 nWh = pPool->GetWhich( nSlot, bDeep );
+    const SfxPoolItem* pItem = nullptr;
+    rSet.GetItemState( nWh, true, &pItem );
+
+    if ( !pItem && nWh != nSlot )
+        pItem = &pPool->GetDefaultItem( nWh );
+    return pItem;
+}
+
+
+const SfxPoolItem* SfxTabPage::GetOldItem( const SfxItemSet& rSet,
+                                           sal_uInt16 nSlot, bool bDeep )
+
+/*  [Description]
+
+    This method returns an attribute for comparison of the old value.
+*/
+
+{
+    const SfxItemSet& rOldSet = GetItemSet();
+    sal_uInt16 nWh = GetWhich( nSlot, bDeep );
+    const SfxPoolItem* pItem = nullptr;
+
+    if ( pImpl->mbStandard && rOldSet.GetParent() )
+        pItem = GetItem( *rOldSet.GetParent(), nSlot );
+    else if ( rSet.GetParent() &&
+              SfxItemState::DONTCARE == rSet.GetItemState( nWh ) )
+        pItem = GetItem( *rSet.GetParent(), nSlot );
+    else
+        pItem = GetItem( rOldSet, nSlot );
+    return pItem;
+}
+
+void SfxTabPage::PageCreated( const SfxAllItemSet& /*aSet*/ )
+{
+    SAL_WARN( "sfx.dialog", "SfxTabPage::PageCreated should not be called");
+}
+
+void SfxTabPage::ChangesApplied()
+{
+}
+
+void SfxTabPage::SetDialogController(SfxOkDialogController* pDialog)
+{
+    pImpl->mpSfxDialogController = pDialog;
+    m_pDialogController = pImpl->mpSfxDialogController;
+}
+
+SfxOkDialogController* SfxTabPage::GetDialogController() const
+{
+    return pImpl->mpSfxDialogController;
+}
+
+OString SfxTabPage::GetHelpId() const
+{
+    if (m_xContainer)
+        return m_xContainer->get_help_id();
+    return OString();
+}
+
+weld::Window* SfxTabPage::GetFrameWeld() const
+{
+    if (m_pDialogController)
+        return m_pDialogController->getDialog();
+    return nullptr;
+}
+
+const SfxItemSet* SfxTabPage::GetDialogExampleSet() const
+{
+    if (pImpl->mpSfxDialogController)
+        return pImpl->mpSfxDialogController->GetExampleSet();
+    return nullptr;
+}
+
+SfxTabDialogController::SfxTabDialogController
+(
+    weld::Widget* pParent,              // Parent Window
+    const OUString& rUIXMLDescription, const OString& rID, // Dialog .ui path, Dialog Name
+    const SfxItemSet* pItemSet,   // Itemset with the data;
+                                  // can be NULL, when Pages are onDemand
+    bool bEditFmt                 // when yes -> additional Button for standard
+)
+    : SfxOkDialogController(pParent, rUIXMLDescription, rID)
+    , m_xTabCtrl(m_xBuilder->weld_notebook("tabcontrol"))
+    , m_xOKBtn(m_xBuilder->weld_button("ok"))
+    , m_xApplyBtn(m_xBuilder->weld_button("apply"))
+    , m_xUserBtn(m_xBuilder->weld_button("user"))
+    , m_xCancelBtn(m_xBuilder->weld_button("cancel"))
+    , m_xResetBtn(m_xBuilder->weld_button("reset"))
+    , m_xBaseFmtBtn(m_xBuilder->weld_button("standard"))
+    , m_pSet(pItemSet ? new SfxItemSet(*pItemSet) : nullptr)
+    , m_bStandardPushed(false)
+{
+    m_pImpl.reset(new TabDlg_Impl(m_xTabCtrl->get_n_pages()));
+    m_pImpl->bHideResetBtn = !m_xResetBtn->get_visible();
+    m_xOKBtn->connect_clicked(LINK(this, SfxTabDialogController, OkHdl));
+    m_xCancelBtn->connect_clicked(LINK(this, SfxTabDialogController, CancelHdl));
+    m_xResetBtn->connect_clicked(LINK(this, SfxTabDialogController, ResetHdl));
+    m_xResetBtn->set_label(SfxResId(STR_RESET));
+    m_xTabCtrl->connect_enter_page(LINK(this, SfxTabDialogController, ActivatePageHdl));
+    m_xTabCtrl->connect_leave_page(LINK(this, SfxTabDialogController, DeactivatePageHdl));
+    m_xResetBtn->set_help_id(HID_TABDLG_RESET_BTN);
+
+    if (bEditFmt)
+    {
+        m_xBaseFmtBtn->set_label(SfxResId(STR_STANDARD_SHORTCUT));
+        m_xBaseFmtBtn->connect_clicked(LINK(this, SfxTabDialogController, BaseFmtHdl));
+        m_xBaseFmtBtn->set_help_id(HID_TABDLG_STANDARD_BTN);
+        m_xBaseFmtBtn->show();
+    }
+
+    if (m_xUserBtn)
+        m_xUserBtn->connect_clicked(LINK(this, SfxTabDialogController, UserHdl));
+
+    if (m_pSet)
+    {
+        m_xExampleSet.reset(new SfxItemSet(*m_pSet));
+        m_pOutSet.reset(new SfxItemSet(*m_pSet->GetPool(), m_pSet->GetRanges()));
+    }
+
+    // The reset functionality seems to be confusing to many; disable in LOK.
+    if (comphelper::LibreOfficeKit::isActive())
+        RemoveResetButton();
+}
+
+IMPL_LINK_NOARG(SfxTabDialogController, OkHdl, weld::Button&, void)
+
+/*  [Description]
+
+    Handler of the Ok-Buttons
+    This calls the current page <SfxTabPage::DeactivatePage(SfxItemSet *)>.
+    Returns <DeactivateRC::LeavePage>, <SfxTabDialog::Ok()> is called
+    and the Dialog is ended.
+*/
+
+{
+    if (PrepareLeaveCurrentPage())
+        m_xDialog->response(Ok());
+}
+
+IMPL_LINK_NOARG(SfxTabDialogController, UserHdl, weld::Button&, void)
+
+/*  [Description]
+
+    Handler of the User-Buttons
+    This calls the current page <SfxTabPage::DeactivatePage(SfxItemSet *)>.
+    returns this <DeactivateRC::LeavePage> and  <SfxTabDialog::Ok()> is called.
+    Then the Dialog is ended with the Return value <SfxTabDialog::Ok()>
+*/
+
+{
+    if (PrepareLeaveCurrentPage())
+    {
+        short nRet = Ok();
+        if (RET_OK == nRet)
+            nRet = RET_USER;
+        else
+            nRet = RET_CANCEL;
+        m_xDialog->response(nRet);
+    }
+}
+
+IMPL_LINK_NOARG(SfxTabDialogController, CancelHdl, weld::Button&, void)
+{
+    m_xDialog->response(RET_CANCEL);
+}
+
+IMPL_LINK_NOARG(SfxTabDialogController, ResetHdl, weld::Button&, void)
+
+/*  [Description]
+
+    Handler behind the reset button.
+    The Current Page is new initialized with their initial data, all the
+    settings that the user has made on this page are repealed.
+*/
+
+{
+    Data_Impl* pDataObject = Find(m_pImpl->aData, m_xTabCtrl->get_current_page_ident());
+    assert(pDataObject && "Id not known");
+
+    pDataObject->xTabPage->Reset(m_pSet.get());
+    // Also reset relevant items of ExampleSet and OutSet to initial state
+    if (!pDataObject->fnGetRanges)
+        return;
+
+    if (!m_xExampleSet)
+        m_xExampleSet.reset(new SfxItemSet(*m_pSet));
+
+    const SfxItemPool* pPool = m_pSet->GetPool();
+    const sal_uInt16* pTmpRanges = (pDataObject->fnGetRanges)();
+
+    while (*pTmpRanges)
+    {
+        const sal_uInt16* pU = pTmpRanges + 1;
+
+        // Correct Range with multiple values
+        sal_uInt16 nTmp = *pTmpRanges, nTmpEnd = *pU;
+        DBG_ASSERT(nTmp <= nTmpEnd, "Range is sorted the wrong way");
+
+        if (nTmp > nTmpEnd)
+        {
+            // If really sorted wrongly, then set new
+            std::swap(nTmp, nTmpEnd);
+        }
+
+        while (nTmp && nTmp <= nTmpEnd)
+        {
+            // Iterate over the Range and set the Items
+            sal_uInt16 nWh = pPool->GetWhich(nTmp);
+            const SfxPoolItem* pItem;
+            if (SfxItemState::SET == m_pSet->GetItemState(nWh, false, &pItem))
+            {
+                m_xExampleSet->Put(*pItem);
+                m_pOutSet->Put(*pItem);
+            }
+            else
+            {
+                m_xExampleSet->ClearItem(nWh);
+                m_pOutSet->ClearItem(nWh);
+            }
+            nTmp++;
+        }
+        // Go to the next pair
+        pTmpRanges += 2;
+    }
+}
+
+/*  [Description]
+
+    Handler behind the Standard-Button.
+    This button is available when editing style sheets. All the set attributes
+    in the edited stylesheet are deleted.
+*/
+IMPL_LINK_NOARG(SfxTabDialogController, BaseFmtHdl, weld::Button&, void)
+{
+    m_bStandardPushed = true;
+
+    Data_Impl* pDataObject = Find(m_pImpl->aData, m_xTabCtrl->get_current_page_ident());
+    assert(pDataObject && "Id not known");
+
+    if (!pDataObject->fnGetRanges)
+        return;
+
+    if (!m_xExampleSet)
+        m_xExampleSet.reset(new SfxItemSet(*m_pSet));
+
+    const SfxItemPool* pPool = m_pSet->GetPool();
+    const sal_uInt16* pTmpRanges = (pDataObject->fnGetRanges)();
+    SfxItemSet aTmpSet(*m_xExampleSet);
+
+    while (*pTmpRanges)
+    {
+        const sal_uInt16* pU = pTmpRanges + 1;
+
+        // Correct Range with multiple values
+        sal_uInt16 nTmp = *pTmpRanges, nTmpEnd = *pU;
+        DBG_ASSERT( nTmp <= nTmpEnd, "Range is sorted the wrong way" );
+
+        if ( nTmp > nTmpEnd )
+        {
+            // If really sorted wrongly, then set new
+            std::swap(nTmp, nTmpEnd);
+        }
+
+        while ( nTmp && nTmp <= nTmpEnd ) // guard against overflow
+        {
+            // Iterate over the Range and set the Items
+            sal_uInt16 nWh = pPool->GetWhich(nTmp);
+            m_xExampleSet->ClearItem(nWh);
+            aTmpSet.ClearItem(nWh);
+            // At the Outset of InvalidateItem,
+            // so that the change takes effect
+            m_pOutSet->InvalidateItem(nWh);
+            nTmp++;
+        }
+        // Go to the next pair
+        pTmpRanges += 2;
+    }
+    // Set all Items as new  -> the call the current Page Reset()
+    assert(pDataObject->xTabPage && "the Page is gone");
+    pDataObject->xTabPage->Reset( &aTmpSet );
+    pDataObject->xTabPage->pImpl->mbStandard = true;
+}
+
+IMPL_LINK(SfxTabDialogController, ActivatePageHdl, const OString&, rPage, void)
+
+/*  [Description]
+
+    Handler that is called by StarView for switching to a different page.
+    If possible the <SfxTabPage::Reset(const SfxItemSet &)> or
+    <SfxTabPage::ActivatePage(const SfxItemSet &)> is called on the new page
+*/
+
+{
+    assert(!m_pImpl->aData.empty() && "no Pages registered");
+    Data_Impl* pDataObject = Find(m_pImpl->aData, rPage);
+    if (!pDataObject)
+    {
+        SAL_WARN("sfx.dialog", "Tab Page ID not known, this is pretty serious and needs investigation");
+        return;
+    }
+
+    SfxTabPage* pTabPage = pDataObject->xTabPage.get();
+    if (!pTabPage)
+        return;
+
+    if (pDataObject->bRefresh)
+        pTabPage->Reset(m_pSet.get());
+    pDataObject->bRefresh = false;
+
+    if (m_xExampleSet)
+        pTabPage->ActivatePage(*m_xExampleSet);
+
+    if (pTabPage->IsReadOnly() || m_pImpl->bHideResetBtn)
+        m_xResetBtn->hide();
+    else
+        m_xResetBtn->show();
+}
+
+IMPL_LINK(SfxTabDialogController, DeactivatePageHdl, const OString&, rPage, bool)
+
+/*  [Description]
+
+    Handler that is called by StarView before leaving a page.
+
+    [Cross-reference]
+
+    <SfxTabPage::DeactivatePage(SfxItemSet *)>
+*/
+
+{
+    assert(!m_pImpl->aData.empty() && "no Pages registered");
+    Data_Impl* pDataObject = Find(m_pImpl->aData, rPage);
+    if (!pDataObject)
+    {
+        SAL_WARN("sfx.dialog", "Tab Page ID not known, this is pretty serious and needs investigation");
+        return false;
+    }
+
+    SfxTabPage* pPage = pDataObject->xTabPage.get();
+    if (!pPage)
+        return true;
+
+    DeactivateRC nRet = DeactivateRC::LeavePage;
+
+    if (!m_xExampleSet && pPage->HasExchangeSupport() && m_pSet)
+        m_xExampleSet.reset(new SfxItemSet(*m_pSet->GetPool(), m_pSet->GetRanges()));
+
+    if (m_pSet)
+    {
+        SfxItemSet aTmp( *m_pSet->GetPool(), m_pSet->GetRanges() );
+
+        if (pPage->HasExchangeSupport())
+            nRet = pPage->DeactivatePage(&aTmp);
+        else
+            nRet = pPage->DeactivatePage(nullptr);
+        if ( ( DeactivateRC::LeavePage & nRet ) == DeactivateRC::LeavePage &&
+             aTmp.Count() && m_xExampleSet)
+        {
+            m_xExampleSet->Put( aTmp );
+            m_pOutSet->Put( aTmp );
+        }
+    }
+    else
+    {
+        if ( pPage->HasExchangeSupport() ) //!!!
+        {
+            if (!m_xExampleSet)
+            {
+                SfxItemPool* pPool = pPage->GetItemSet().GetPool();
+                m_xExampleSet.reset(new SfxItemSet(*pPool, GetInputRanges(*pPool)));
+            }
+            nRet = pPage->DeactivatePage(m_xExampleSet.get());
+        }
+        else
+            nRet = pPage->DeactivatePage( nullptr );
+    }
+
+    if ( nRet & DeactivateRC::RefreshSet )
+    {
+        RefreshInputSet();
+        // Flag all Pages as to be initialized as new
+
+        for (auto const& elem : m_pImpl->aData)
+        {
+            elem->bRefresh = ( elem->xTabPage.get() != pPage ); // Do not refresh own Page anymore
+        }
+    }
+    return static_cast<bool>(nRet & DeactivateRC::LeavePage);
+}
+
+bool SfxTabDialogController::PrepareLeaveCurrentPage()
+{
+    const OString sId = m_xTabCtrl->get_current_page_ident();
+    Data_Impl* pDataObject = Find(m_pImpl->aData, sId);
+    DBG_ASSERT( pDataObject, "Id not known" );
+    SfxTabPage* pPage = pDataObject ? pDataObject->xTabPage.get() : nullptr;
+
+    bool bEnd = !pPage;
+
+    if ( pPage )
+    {
+        DeactivateRC nRet = DeactivateRC::LeavePage;
+        if ( m_pSet )
+        {
+            SfxItemSet aTmp( *m_pSet->GetPool(), m_pSet->GetRanges() );
+
+            if ( pPage->HasExchangeSupport() )
+                nRet = pPage->DeactivatePage( &aTmp );
+            else
+                nRet = pPage->DeactivatePage( nullptr );
+
+            if ( ( DeactivateRC::LeavePage & nRet ) == DeactivateRC::LeavePage
+                 && aTmp.Count() )
+            {
+                m_xExampleSet->Put( aTmp );
+                m_pOutSet->Put( aTmp );
+            }
+        }
+        else
+            nRet = pPage->DeactivatePage( nullptr );
+        bEnd = nRet != DeactivateRC::KeepPage;
+    }
+
+    return bEnd;
+}
+
+const sal_uInt16* SfxTabDialogController::GetInputRanges(const SfxItemPool& rPool)
+
+/*  [Description]
+
+    Makes the set over the range of all pages of the dialogue. Pages have the
+    static method for querying their range in AddTabPage, ie deliver their
+    sets onDemand.
+
+    [Return value]
+
+    Pointer to a null-terminated array of sal_uInt16. This array belongs to the
+    dialog and is deleted when the dialogue is destroy.
+
+    [Cross-reference]
+
+    <SfxTabDialog::AddTabPage(sal_uInt16, CreateTabPage, GetTabPageRanges, bool)>
+    <SfxTabDialog::AddTabPage(sal_uInt16, const String &, CreateTabPage, GetTabPageRanges, bool, sal_uInt16)>
+    <SfxTabDialog::AddTabPage(sal_uInt16, const Bitmap &, CreateTabPage, GetTabPageRanges, bool, sal_uInt16)>
+*/
+
+{
+    if ( m_pSet )
+    {
+        SAL_WARN( "sfx.dialog", "Set already exists!" );
+        return m_pSet->GetRanges();
+    }
+
+    if ( m_pRanges )
+        return m_pRanges.get();
+    std::vector<sal_uInt16> aUS;
+
+    for (auto const& elem : m_pImpl->aData)
+    {
+
+        if ( elem->fnGetRanges )
+        {
+            const sal_uInt16* pTmpRanges = (elem->fnGetRanges)();
+            const sal_uInt16* pIter = pTmpRanges;
+
+            sal_uInt16 nLen;
+            for( nLen = 0; *pIter; ++nLen, ++pIter )
+                ;
+            aUS.insert( aUS.end(), pTmpRanges, pTmpRanges + nLen );
+        }
+    }
+
+    //! Remove duplicated Ids?
+    {
+        for (auto & elem : aUS)
+            elem = rPool.GetWhich(elem);
+    }
+
+    // sort
+    if ( aUS.size() > 1 )
+    {
+        std::sort( aUS.begin(), aUS.end() );
+    }
+
+    m_pRanges.reset(new sal_uInt16[aUS.size() + 1]);
+    std::copy( aUS.begin(), aUS.end(), m_pRanges.get() );
+    m_pRanges[aUS.size()] = 0;
+    return m_pRanges.get();
+}
+
+SfxTabDialogController::~SfxTabDialogController()
+{
+    SavePosAndId();
+
+    for (auto & elem : m_pImpl->aData)
+    {
+        if ( elem->xTabPage )
+        {
+            // save settings of all pages (user data)
+            elem->xTabPage->FillUserData();
+            OUString aPageData( elem->xTabPage->GetUserData() );
+            if ( !aPageData.isEmpty() )
+            {
+                // save settings of all pages (user data)
+                OUString sConfigId = OStringToOUString(elem->xTabPage->GetConfigId(),
+                    RTL_TEXTENCODING_UTF8);
+                SvtViewOptions aPageOpt(EViewType::TabPage, sConfigId);
+                aPageOpt.SetUserItem( USERITEM_NAME, makeAny( aPageData ) );
+            }
+
+            elem->xTabPage.reset();
+        }
+        delete elem;
+        elem = nullptr;
+    }
+}
+
+short SfxTabDialogController::Ok()
+
+/*  [Description]
+
+    Ok handler for the Dialogue.
+
+    Dialog's current location and current page are saved for the next time
+    the dialog is shown.
+
+    The OutputSet is created and for each page this or the special OutputSet
+    is set by calling the method <SfxTabPage::FillItemSet(SfxItemSet &)>, to
+    insert the entered data by the user into the set.
+
+    [Return value]
+
+    RET_OK:       if at least one page has returned from FillItemSet,
+                  otherwise RET_CANCEL.
+*/
+{
+    SavePosAndId(); //See fdo#38828 "Apply" resetting window position
+
+    if ( !m_pOutSet )
+    {
+        if ( m_xExampleSet )
+            m_pOutSet.reset(new SfxItemSet( *m_xExampleSet ));
+        else if ( m_pSet )
+            m_pOutSet = m_pSet->Clone( false );  // without Items
+    }
+    bool bModified = false;
+
+    for (auto const& elem : m_pImpl->aData)
+    {
+        SfxTabPage* pTabPage = elem->xTabPage.get();
+
+        if ( pTabPage )
+        {
+            if ( m_pSet && !pTabPage->HasExchangeSupport() )
+            {
+                SfxItemSet aTmp( *m_pSet->GetPool(), m_pSet->GetRanges() );
+
+                if ( pTabPage->FillItemSet( &aTmp ) )
+                {
+                    bModified = true;
+                    if (m_xExampleSet)
+                        m_xExampleSet->Put( aTmp );
+                    m_pOutSet->Put( aTmp );
+                }
+            }
+        }
+    }
+
+    if (m_pOutSet && m_pOutSet->Count() > 0)
+        bModified = true;
+
+    if (m_bStandardPushed)
+        bModified = true;
+
+    return bModified ? RET_OK : RET_CANCEL;
+}
+
+void SfxTabDialogController::RefreshInputSet()
+
+/*  [Description]
+
+    Default implementation of the virtual Method.
+    This is called, when <SfxTabPage::DeactivatePage(SfxItemSet *)>
+    returns <DeactivateRC::RefreshSet>.
+*/
+
+{
+    SAL_INFO ( "sfx.dialog", "RefreshInputSet not implemented" );
+}
+
+void SfxTabDialogController::PageCreated
+
+/*  [Description]
+
+    Default implementation of the virtual method. This is called immediately
+    after creating a page. Here the dialogue can call the TabPage Method
+    directly.
+*/
+
+(
+    const OString&, // Id of the created page
+    SfxTabPage&     // Reference to the created page
+)
+{
+}
+
+void SfxTabDialogController::SavePosAndId()
+{
+    // save settings (screen position and current page)
+    SvtViewOptions aDlgOpt(EViewType::TabDialog, OStringToOUString(m_xDialog->get_help_id(), RTL_TEXTENCODING_UTF8));
+    aDlgOpt.SetPageID(m_xTabCtrl->get_current_page_ident());
+}
+
+/*
+    Adds a page to the dialog. The Name must correspond to an entry in the
+    TabControl in the dialog .ui
+*/
+void SfxTabDialogController::AddTabPage(const OString &rName /* Page ID */,
+                                        CreateTabPage pCreateFunc  /* Pointer to the Factory Method */,
+                                        GetTabPageRanges pRangesFunc /* Pointer to the Method for querying Ranges onDemand */)
+{
+    m_pImpl->aData.push_back(new Data_Impl(rName, pCreateFunc, pRangesFunc));
+}
+
+void SfxTabDialogController::AddTabPage(const OString &rName /* Page ID */,
+                                        sal_uInt16 nPageCreateId /* Identifier of the Factory Method to create the page */)
+{
+    SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
+    CreateTabPage pCreateFunc = pFact->GetTabPageCreatorFunc(nPageCreateId);
+    GetTabPageRanges pRangesFunc = pFact->GetTabPageRangesFunc(nPageCreateId);
+    AddTabPage(rName, pCreateFunc, pRangesFunc);
+}
+
+/*  [Description]
+
+    Add a page to the dialog. The Rider text is passed on, the page has no
+    counterpart in the TabControl in the resource of the dialogue.
+*/
+
+void SfxTabDialogController::AddTabPage(const OString &rName, /* Page ID */
+                                        const OUString& rRiderText,
+                                        CreateTabPage pCreateFunc  /* Pointer to the Factory Method */)
+{
+    assert(!m_xTabCtrl->get_page(rName) && "Double Page-Ids in the Tabpage");
+    m_xTabCtrl->append_page(rName, rRiderText);
+    AddTabPage(rName, pCreateFunc, nullptr);
+}
+
+void SfxTabDialogController::AddTabPage(const OString &rName, const OUString& rRiderText,
+                                        sal_uInt16 nPageCreateId /* Identifier of the Factory Method to create the page */)
+{
+    assert(!m_xTabCtrl->get_page(rName) && "Double Page-Ids in the Tabpage");
+    m_xTabCtrl->append_page(rName, rRiderText);
+    AddTabPage(rName, nPageCreateId);
+}
+
+/*  [Description]
+
+    Default implementation of the virtual Method.
+    This is called when pages create their sets onDemand.
+*/
+SfxItemSet* SfxTabDialogController::CreateInputItemSet(const OString&)
+{
+    SAL_WARN( "sfx.dialog", "CreateInputItemSet not implemented" );
+    return new SfxAllItemSet(SfxGetpApp()->GetPool());
+}
+
+void SfxTabDialogController::CreatePages()
+{
+    for (auto pDataObject : m_pImpl->aData)
+    {
+        if (pDataObject->xTabPage)
+           continue;
+        weld::Container* pPage = m_xTabCtrl->get_page(pDataObject->sId);
+        if (m_pSet)
+            pDataObject->xTabPage = (pDataObject->fnCreatePage)(pPage, this, m_pSet.get());
+        else
+            pDataObject->xTabPage = (pDataObject->fnCreatePage)(pPage, this, CreateInputItemSet(pDataObject->sId));
+        pDataObject->xTabPage->SetDialogController(this);
+        OUString sConfigId = OStringToOUString(pDataObject->xTabPage->GetConfigId(), RTL_TEXTENCODING_UTF8);
+        SvtViewOptions aPageOpt(EViewType::TabPage, sConfigId);
+        OUString sUserData;
+        Any aUserItem = aPageOpt.GetUserItem(USERITEM_NAME);
+        OUString aTemp;
+        if ( aUserItem >>= aTemp )
+            sUserData = aTemp;
+        pDataObject->xTabPage->SetUserData(sUserData);
+
+        PageCreated(pDataObject->sId, *pDataObject->xTabPage);
+        pDataObject->xTabPage->Reset(m_pSet.get());
+    }
+}
+
+void SfxTabDialogController::setPreviewsToSamePlace()
+{
+    //where tab pages have the same basic layout with a preview on the right,
+    //get both of their non-preview areas to request the same size so that the
+    //preview appears in the same place in each one so flipping between tabs
+    //isn't distracting as it jumps around
+    std::vector<std::unique_ptr<weld::Widget>> aGrids;
+    for (auto pDataObject : m_pImpl->aData)
+    {
+        if (!pDataObject->xTabPage)
+            continue;
+        if (!pDataObject->xTabPage->m_xBuilder)
+            continue;
+        std::unique_ptr<weld::Widget> pGrid = pDataObject->xTabPage->m_xBuilder->weld_widget("maingrid");
+        if (!pGrid)
+            continue;
+        aGrids.emplace_back(std::move(pGrid));
+    }
+
+    m_xSizeGroup.reset();
+
+    if (aGrids.size() <= 1)
+        return;
+
+    m_xSizeGroup = m_xBuilder->create_size_group();
+    m_xSizeGroup->set_mode(VclSizeGroupMode::Both);
+    for (auto& rGrid : aGrids)
+        m_xSizeGroup->add_widget(rGrid.get());
+}
+
+void SfxTabDialogController::RemoveTabPage(const OString& rId)
+
+/*  [Description]
+
+    Delete the TabPage with ID nId
+*/
+
+{
+    sal_uInt16 nPos = 0;
+    m_xTabCtrl->remove_page(rId);
+    Data_Impl* pDataObject = Find( m_pImpl->aData, rId, &nPos );
+
+    if ( pDataObject )
+    {
+        if ( pDataObject->xTabPage )
+        {
+            pDataObject->xTabPage->FillUserData();
+            OUString aPageData( pDataObject->xTabPage->GetUserData() );
+            if ( !aPageData.isEmpty() )
+            {
+                // save settings of this page (user data)
+                OUString sConfigId = OStringToOUString(pDataObject->xTabPage->GetConfigId(),
+                    RTL_TEXTENCODING_UTF8);
+                SvtViewOptions aPageOpt(EViewType::TabPage, sConfigId);
+                aPageOpt.SetUserItem( USERITEM_NAME, makeAny( aPageData ) );
+            }
+
+            pDataObject->xTabPage.reset();
+        }
+
+        delete pDataObject;
+        m_pImpl->aData.erase( m_pImpl->aData.begin() + nPos );
+    }
+    else
+    {
+        SAL_INFO( "sfx.dialog", "TabPage-Id not known" );
+    }
+}
+
+void SfxTabDialogController::Start_Impl()
+{
+    CreatePages();
+
+    setPreviewsToSamePlace();
+
+    assert(m_pImpl->aData.size() == static_cast<size_t>(m_xTabCtrl->get_n_pages())
+            && "not all pages registered");
+
+    // load old settings, when exists, setting SetCurPageId will override the settings,
+    // something that the sort dialog in calc depends on
+    if (m_sAppPageId.isEmpty())
+    {
+        SvtViewOptions aDlgOpt(EViewType::TabDialog, OStringToOUString(m_xDialog->get_help_id(), RTL_TEXTENCODING_UTF8));
+        if (aDlgOpt.Exists())
+            m_xTabCtrl->set_current_page(aDlgOpt.GetPageID());
+    }
+
+    ActivatePageHdl(m_xTabCtrl->get_current_page_ident());
+
+    m_pImpl->bStarted = true;
+}
+
+void SfxTabDialogController::SetCurPageId(const OString& rIdent)
+{
+    m_sAppPageId = rIdent;
+    m_xTabCtrl->set_current_page(m_sAppPageId);
+}
+
+/*  [Description]
+
+    The TabPage is activated with the specified Id.
+*/
+void SfxTabDialogController::ShowPage(const OString& rIdent)
+{
+    SetCurPageId(rIdent);
+    ActivatePageHdl(rIdent);
+}
+
+OString SfxTabDialogController::GetCurPageId() const
+{
+    return m_xTabCtrl->get_current_page_ident();
+}
+
+short SfxTabDialogController::run()
+{
+    Start_Impl();
+    return SfxDialogController::run();
+}
+
+bool SfxTabDialogController::runAsync(const std::shared_ptr<SfxTabDialogController>& rController,
+                                      const std::function<void(sal_Int32)>& rFunc)
+{
+    rController->Start_Impl();
+    return weld::DialogController::runAsync(rController, rFunc);
+}
+
+void SfxTabDialogController::SetInputSet( const SfxItemSet* pInSet )
+
+/*  [Description]
+
+    With this method the Input-Set can subsequently be set initially or re-set.
+*/
+
+{
+    bool bSet = ( m_pSet != nullptr );
+    m_pSet.reset(pInSet ? new SfxItemSet(*pInSet) : nullptr);
+
+    if (!bSet && !m_xExampleSet && !m_pOutSet && m_pSet)
+    {
+        m_xExampleSet.reset(new SfxItemSet(*m_pSet));
+        m_pOutSet.reset(new SfxItemSet( *m_pSet->GetPool(), m_pSet->GetRanges() ));
+    }
+}
+
+SfxItemSet* SfxTabDialogController::GetInputSetImpl()
+
+/*  [Description]
+
+    Derived classes may create new storage for the InputSet. This has to be
+    released in the Destructor. To do this, this method must be called.
+*/
+
+{
+    return m_pSet.get();
+}
+
+void SfxTabDialogController::RemoveResetButton()
+{
+    m_xResetBtn->hide();
+    m_pImpl->bHideResetBtn = true;
+}
+
+void SfxTabDialogController::RemoveStandardButton()
+{
+    m_xBaseFmtBtn->hide();
+}
+
+SfxTabPage* SfxTabDialogController::GetTabPage(const OString& rPageId) const
+
+/*  [Description]
+
+    Return TabPage with the specified Id.
+*/
+
+{
+    Data_Impl* pDataObject = Find(m_pImpl->aData, rPageId);
+    if (pDataObject)
+        return pDataObject->xTabPage.get();
+    return nullptr;
+}
+
+void SfxTabDialogController::SetApplyHandler(const Link<weld::Button&, void>& _rHdl)
+{
+    DBG_ASSERT( m_xApplyBtn, "SfxTabDialog::GetApplyHandler: no apply button enabled!" );
+    if (m_xApplyBtn)
+        m_xApplyBtn->connect_clicked(_rHdl);
+}
+
+bool SfxTabDialogController::Apply()
+{
+    bool bApplied = false;
+    if (PrepareLeaveCurrentPage())
+    {
+        bApplied = (Ok() == RET_OK);
+        //let the pages update their saved values
+        GetInputSetImpl()->Put(*GetOutputItemSet());
+        for (auto pDataObject : m_pImpl->aData)
+        {
+            if (!pDataObject->xTabPage)
+                continue;
+            pDataObject->xTabPage->ChangesApplied();
+        }
+    }
+    return bApplied;
+}
+
+std::vector<OString> SfxTabDialogController::getAllPageUIXMLDescriptions() const
+{
+    int nPages = m_xTabCtrl->get_n_pages();
+    std::vector<OString> aRet;
+    aRet.reserve(nPages);
+    for (int i = 0; i < nPages; ++i)
+        aRet.push_back(m_xTabCtrl->get_page_ident(i));
+    return aRet;
+}
+
+bool SfxTabDialogController::selectPageByUIXMLDescription(const OString& rUIXMLDescription)
+{
+    ShowPage(rUIXMLDescription);
+    return m_xTabCtrl->get_current_page_ident() == rUIXMLDescription;
+}
+
+BitmapEx SfxTabDialogController::createScreenshot() const
+{
+    // if we haven't run Start_Impl yet, do so now to create the initial pages
+    if (!m_pImpl->bStarted)
+    {
+        const_cast<SfxTabDialogController*>(this)->Start_Impl();
+    }
+
+    VclPtr<VirtualDevice> xDialogSurface(VclPtr<VirtualDevice>::Create(DeviceFormat::DEFAULT));
+    m_xDialog->draw(*xDialogSurface);
+    return xDialogSurface->GetBitmapEx(Point(), xDialogSurface->GetOutputSizePixel());
+}
+
+OString SfxTabDialogController::GetScreenshotId() const
+{
+    const OString sId = m_xTabCtrl->get_current_page_ident();
+    Data_Impl* pDataObject = Find(m_pImpl->aData, sId);
+    SfxTabPage* pPage = pDataObject ? pDataObject->xTabPage.get() : nullptr;
+    if (pPage)
+    {
+        OString sHelpId(pPage->GetHelpId());
+        if (!sHelpId.isEmpty())
+            return sHelpId;
+    }
+    return m_xDialog->get_help_id();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/templdlg.cxx b/sfx2/source/dialog/templdlg.cxx
new file mode 100644
index 000000000..40851576f
--- /dev/null
+++ b/sfx2/source/dialog/templdlg.cxx
@@ -0,0 +1,2334 @@
+/* -*- 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 <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <vcl/commandevent.hxx>
+#include <vcl/commandinfoprovider.hxx>
+#include <vcl/event.hxx>
+#include <vcl/help.hxx>
+#include <vcl/menu.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/weldutils.hxx>
+#include <svl/intitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/style.hxx>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/sequenceashashmap.hxx>
+#include <unotools/intlwrapper.hxx>
+#include <unotools/collatorwrapper.hxx>
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <com/sun/star/frame/ModuleManager.hpp>
+#include <com/sun/star/frame/UnknownModuleException.hpp>
+#include <officecfg/Office/Common.hxx>
+
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <sfx2/app.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/templdlg.hxx>
+#include <templdgi.hxx>
+#include <tplcitem.hxx>
+#include <sfx2/styfitem.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/viewsh.hxx>
+#include <sfx2/newstyle.hxx>
+#include <sfx2/tplpitem.hxx>
+#include <sfx2/sfxresid.hxx>
+
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/strings.hrc>
+#include <sfx2/docfac.hxx>
+#include <sfx2/module.hxx>
+#include <helpids.h>
+#include <bitmaps.hlst>
+#include <sfx2/viewfrm.hxx>
+
+#include <comphelper/string.hxx>
+
+#include <sfx2/StyleManager.hxx>
+#include <sfx2/StylePreviewRenderer.hxx>
+
+using namespace css;
+using namespace css::beans;
+using namespace css::frame;
+using namespace css::uno;
+
+class SfxCommonTemplateDialog_Impl::DeletionWatcher
+{
+    typedef void (DeletionWatcher::* bool_type)();
+
+public:
+    explicit DeletionWatcher(SfxCommonTemplateDialog_Impl& rDialog)
+        : m_pDialog(&rDialog)
+        , m_pPrevious(m_pDialog->impl_setDeletionWatcher(this))
+    {
+    }
+
+    ~DeletionWatcher()
+    {
+        if (m_pDialog)
+            m_pDialog->impl_setDeletionWatcher(m_pPrevious);
+    }
+
+    DeletionWatcher(const DeletionWatcher&) = delete;
+    DeletionWatcher& operator=(const DeletionWatcher&) = delete;
+
+    // Signal that the dialog was deleted
+    void signal()
+    {
+        m_pDialog = nullptr;
+        if (m_pPrevious)
+            m_pPrevious->signal();
+    }
+
+    // Return true if the dialog was deleted
+    operator bool_type() const
+    {
+        return m_pDialog ? nullptr : &DeletionWatcher::signal;
+    }
+
+private:
+    SfxCommonTemplateDialog_Impl* m_pDialog;
+    DeletionWatcher *const m_pPrevious; /// let's add more epicycles!
+};
+
+/** Drop is enabled as long as it is allowed to create a new style by example, i.e. to
+    create a style out of the current selection.
+*/
+sal_Int8 SfxCommonTemplateDialog_Impl::AcceptDrop(const AcceptDropEvent& rEvt, const DropTargetHelper& rHelper)
+{
+    if (rHelper.IsDropFormatSupported(SotClipboardFormatId::OBJECTDESCRIPTOR))
+    {
+        // special case: page styles are allowed to create new styles by example
+        // but not allowed to be created by drag and drop
+        if (GetActualFamily() == SfxStyleFamily::Page || bNewByExampleDisabled)
+            return DND_ACTION_NONE;
+        else
+            return DND_ACTION_COPY;
+    }
+
+    // to enable the autoscroll when we're close to the edges
+    weld::TreeView* pTreeView = mxTreeBox->get_visible() ? mxTreeBox.get() : mxFmtLb.get();
+    pTreeView->get_dest_row_at_pos(rEvt.maPosPixel, nullptr);
+    return DND_ACTION_MOVE;
+}
+
+sal_Int8 SfxCommonTemplateDialog_Impl::ExecuteDrop(const ExecuteDropEvent& rEvt)
+{
+    // handle drop of content into the treeview to create a new style
+    SfxObjectShell* pDocShell = GetObjectShell();
+    if (pDocShell)
+    {
+        TransferableDataHelper aHelper(rEvt.maDropEvent.Transferable);
+        sal_uInt32 nFormatCount = aHelper.GetFormatCount();
+
+        sal_Int8 nRet = DND_ACTION_NONE;
+
+        bool bFormatFound = false;
+
+        for ( sal_uInt32 i = 0; i < nFormatCount; ++i )
+        {
+            SotClipboardFormatId nId = aHelper.GetFormat(i);
+            TransferableObjectDescriptor aDesc;
+
+            if ( aHelper.GetTransferableObjectDescriptor( nId, aDesc ) )
+            {
+                if ( aDesc.maClassName == pDocShell->GetFactory().GetClassId() )
+                {
+                    Application::PostUserEvent(LINK(this, SfxCommonTemplateDialog_Impl, OnAsyncExecuteDrop));
+
+                    bFormatFound = true;
+                    nRet =  rEvt.mnAction;
+                    break;
+                }
+            }
+        }
+
+        if (bFormatFound)
+            return nRet;
+    }
+
+    if (!mxTreeBox->get_visible())
+        return DND_ACTION_NONE;
+
+    if (!bAllowReParentDrop)
+        return DND_ACTION_NONE;
+
+    // otherwise if we're dragging with the treeview to set a new parent of the dragged style
+    weld::TreeView* pSource = mxTreeBox->get_drag_source();
+    // only dragging within the same widget allowed
+    if (!pSource || pSource != mxTreeBox.get())
+        return DND_ACTION_NONE;
+
+    std::unique_ptr<weld::TreeIter> xSource(mxTreeBox->make_iterator());
+    if (!mxTreeBox->get_selected(xSource.get()))
+        return DND_ACTION_NONE;
+
+    std::unique_ptr<weld::TreeIter> xTarget(mxTreeBox->make_iterator());
+    if (!mxTreeBox->get_dest_row_at_pos(rEvt.maPosPixel, xTarget.get()))
+    {
+        // if nothing under the mouse, use the last row
+        int nChildren = mxTreeBox->n_children();
+        if (!nChildren)
+            return DND_ACTION_NONE;
+        if (!mxTreeBox->get_iter_first(*xTarget) || !mxTreeBox->iter_nth_sibling(*xTarget, nChildren - 1))
+            return DND_ACTION_NONE;
+        while (mxTreeBox->get_row_expanded(*xTarget))
+        {
+            nChildren = mxTreeBox->iter_n_children(*xTarget);
+            if (!mxTreeBox->iter_children(*xTarget) || !mxTreeBox->iter_nth_sibling(*xTarget, nChildren - 1))
+                return DND_ACTION_NONE;
+        }
+    }
+    OUString aTargetStyle = mxTreeBox->get_text(*xTarget);
+    DropHdl(mxTreeBox->get_text(*xSource), aTargetStyle);
+    mxTreeBox->unset_drag_dest_row();
+    FillTreeBox();
+    SelectStyle(aTargetStyle, false);
+    return DND_ACTION_NONE;
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, DragBeginHdl, bool&, rUnsetDragIcon, bool)
+{
+    rUnsetDragIcon = false;
+    // Allow normal processing. only if bAllowReParentDrop is true
+    return !bAllowReParentDrop;
+}
+
+IMPL_LINK_NOARG(SfxCommonTemplateDialog_Impl, OnAsyncExecuteDrop, void*, void)
+{
+    ActionSelect("new");
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
+{
+    bool bRet = false;
+    const vcl::KeyCode& rKeyCode = rKeyEvent.GetKeyCode();
+    if (bCanDel && !rKeyCode.GetModifier() && rKeyCode.GetCode() == KEY_DELETE)
+    {
+        DeleteHdl();
+        bRet =  true;
+    }
+    return bRet;
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, QueryTooltipHdl, const weld::TreeIter&, rEntry, OUString)
+{
+    weld::TreeView* pTreeView = mxTreeBox->get_visible() ? mxTreeBox.get() : mxFmtLb.get();
+    const OUString aTemplName(pTreeView->get_text(rEntry));
+    OUString sQuickHelpText(aTemplName);
+
+    const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+    if (!pItem)
+        return sQuickHelpText;
+    SfxStyleSheetBase* pStyle = pStyleSheetPool->Find(aTemplName, pItem->GetFamily());
+
+    if (pStyle && pStyle->IsUsed())  // pStyle is in use in the document?
+    {
+        OUString sUsedBy;
+        if (pStyle->GetFamily() == SfxStyleFamily::Pseudo)
+            sUsedBy = pStyle->GetUsedBy();
+
+        if (!sUsedBy.isEmpty())
+        {
+            const sal_Int32 nMaxLen = 80;
+            if (sUsedBy.getLength() > nMaxLen)
+            {
+                sUsedBy = sUsedBy.copy(0, nMaxLen) + "...";
+            }
+
+            OUString aMessage = SfxResId(STR_STYLEUSEDBY);
+            aMessage = aMessage.replaceFirst("%STYLELIST", sUsedBy);
+            sQuickHelpText = aTemplName + " " + aMessage;
+        }
+    }
+
+    return sQuickHelpText;
+}
+
+IMPL_STATIC_LINK(SfxCommonTemplateDialog_Impl, CustomGetSizeHdl, weld::TreeView::get_size_args, aPayload, Size)
+{
+    vcl::RenderContext& rRenderContext = aPayload.first;
+    return Size(42, 32 * rRenderContext.GetDPIScaleFactor());
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, CustomRenderHdl, weld::TreeView::render_args, aPayload, void)
+{
+    vcl::RenderContext& rRenderContext = std::get<0>(aPayload);
+    const ::tools::Rectangle& rRect = std::get<1>(aPayload);
+    ::tools::Rectangle aRect(rRect.TopLeft(), Size(rRenderContext.GetOutputSize().Width() - rRect.Left(), rRect.GetHeight()));
+    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());
+
+    bool bSuccess = false;
+
+    SfxObjectShell* pShell = SfxObjectShell::Current();
+    sfx2::StyleManager* pStyleManager = pShell ? pShell->GetStyleManager(): nullptr;
+
+    if (pStyleManager)
+    {
+        const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+        SfxStyleSheetBase* pStyleSheet = pStyleManager->Search(rId, pItem->GetFamily());
+
+        if (pStyleSheet)
+        {
+            rRenderContext.Push(PushFlags::ALL);
+            sal_Int32 nSize = aRect.GetHeight();
+            std::unique_ptr<sfx2::StylePreviewRenderer> pStylePreviewRenderer(
+                pStyleManager->CreateStylePreviewRenderer(rRenderContext, pStyleSheet, nSize));
+            bSuccess = pStylePreviewRenderer->recalculate() && pStylePreviewRenderer->render(aRect);
+            rRenderContext.Pop();
+        }
+    }
+
+    if (!bSuccess)
+        rRenderContext.DrawText(aRect, rId, DrawTextFlags::Left | DrawTextFlags::VCenter);
+
+    rRenderContext.Pop();
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, PopupFlatMenuHdl, const CommandEvent&, rCEvt, bool)
+{
+    if (rCEvt.GetCommand() != CommandEventId::ContextMenu)
+        return false;
+
+    PrepareMenu(rCEvt.GetMousePosPixel());
+
+    if (mxFmtLb->count_selected_rows() <= 0)
+    {
+        EnableEdit(false);
+        EnableDel(false);
+    }
+
+    ShowMenu(rCEvt);
+
+    return true;
+}
+
+void SfxCommonTemplateDialog_Impl::PrepareMenu(const Point& rPos)
+{
+    weld::TreeView* pTreeView = mxTreeBox->get_visible() ? mxTreeBox.get() : mxFmtLb.get();
+    std::unique_ptr<weld::TreeIter> xIter(pTreeView->make_iterator());
+    if (pTreeView->get_dest_row_at_pos(rPos, xIter.get(), false) && !pTreeView->is_selected(*xIter))
+    {
+        pTreeView->unselect_all();
+        pTreeView->set_cursor(*xIter);
+        pTreeView->select(*xIter);
+        FmtSelectHdl(*pTreeView);
+    }
+}
+
+void SfxCommonTemplateDialog_Impl::ShowMenu(const CommandEvent& rCEvt)
+{
+    CreateContextMenu();
+
+    weld::TreeView* pTreeView = mxTreeBox->get_visible() ? mxTreeBox.get() : mxFmtLb.get();
+    OString sCommand(mxMenu->popup_at_rect(pTreeView, tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1))));
+    MenuSelect(sCommand);
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, PopupTreeMenuHdl, const CommandEvent&, rCEvt, bool)
+{
+    if (rCEvt.GetCommand() != CommandEventId::ContextMenu)
+        return false;
+
+    PrepareMenu(rCEvt.GetMousePosPixel());
+
+    ShowMenu(rCEvt);
+
+    return true;
+}
+
+SfxTemplatePanelControl::SfxTemplatePanelControl(SfxBindings* pBindings, vcl::Window* pParentWindow)
+    : PanelLayout(pParentWindow, "TemplatePanel", "sfx/ui/templatepanel.ui", nullptr)
+    , pImpl(new SfxTemplateDialog_Impl(pBindings, this))
+{
+    OSL_ASSERT(pBindings!=nullptr);
+}
+
+SfxTemplatePanelControl::~SfxTemplatePanelControl()
+{
+    disposeOnce();
+}
+
+void SfxTemplatePanelControl::dispose()
+{
+    pImpl.reset();
+    PanelLayout::dispose();
+}
+
+static void MakeExpanded_Impl(weld::TreeView& rBox, std::vector<OUString>& rEntries)
+{
+    std::unique_ptr<weld::TreeIter> xEntry = rBox.make_iterator();
+    if (rBox.get_iter_first(*xEntry))
+    {
+        do
+        {
+            if (rBox.get_row_expanded(*xEntry))
+                rEntries.push_back(rBox.get_text(*xEntry));
+        } while (rBox.iter_next(*xEntry));
+    }
+}
+
+/** Internal structure for the establishment of the hierarchical view */
+namespace {
+
+class StyleTree_Impl;
+
+}
+
+typedef std::vector<std::unique_ptr<StyleTree_Impl>> StyleTreeArr_Impl;
+
+namespace {
+
+class StyleTree_Impl
+{
+private:
+    OUString aName;
+    OUString aParent;
+    StyleTreeArr_Impl pChildren;
+
+public:
+    bool HasParent() const { return !aParent.isEmpty(); }
+
+    StyleTree_Impl(const OUString &rName, const OUString &rParent):
+        aName(rName), aParent(rParent), pChildren(0) {}
+
+    const OUString& getName() const { return aName; }
+    const OUString& getParent() const { return aParent; }
+    StyleTreeArr_Impl& getChildren() { return pChildren; }
+};
+
+}
+
+static void MakeTree_Impl(StyleTreeArr_Impl& rArr, const OUString& aUIName)
+{
+    const comphelper::string::NaturalStringSorter aSorter(
+        ::comphelper::getProcessComponentContext(),
+        Application::GetSettings().GetLanguageTag().getLocale());
+
+    std::unordered_map<OUString, StyleTree_Impl*> styleFinder;
+    styleFinder.reserve(rArr.size());
+    for (const auto& pEntry : rArr)
+    {
+        styleFinder.emplace(pEntry->getName(), pEntry.get());
+    }
+
+    // Arrange all under their Parents
+    for (auto& pEntry : rArr)
+    {
+        if (!pEntry->HasParent())
+            continue;
+        auto it = styleFinder.find(pEntry->getParent());
+        if (it != styleFinder.end())
+        {
+            StyleTree_Impl* pCmp = it->second;
+            // Insert child entries sorted
+            auto iPos = std::lower_bound(pCmp->getChildren().begin(), pCmp->getChildren().end(), pEntry,
+                [&aSorter](std::unique_ptr<StyleTree_Impl> const & pEntry1, std::unique_ptr<StyleTree_Impl> const & pEntry2) { return aSorter.compare(pEntry1->getName(), pEntry2->getName()) < 0; });
+            pCmp->getChildren().insert(iPos, std::move(pEntry));
+        }
+    }
+
+    // Only keep tree roots in rArr, child elements can be accessed through the hierarchy
+    rArr.erase(std::remove_if(rArr.begin(), rArr.end(), [](std::unique_ptr<StyleTree_Impl> const & pEntry) { return !pEntry; }), rArr.end());
+
+    // tdf#91106 sort top level styles
+    std::sort(rArr.begin(), rArr.end());
+    std::sort(rArr.begin(), rArr.end(),
+        [&aSorter, &aUIName](std::unique_ptr<StyleTree_Impl> const & pEntry1, std::unique_ptr<StyleTree_Impl> const & pEntry2) {
+            if (pEntry2->getName() == aUIName)
+                return false;
+            if (pEntry1->getName() == aUIName)
+                return true; // default always first
+            return aSorter.compare(pEntry1->getName(), pEntry2->getName()) < 0;
+        });
+}
+
+static bool IsExpanded_Impl( const std::vector<OUString>& rEntries,
+                             const OUString &rStr)
+{
+    for (const auto & rEntry : rEntries)
+    {
+        if (rEntry == rStr)
+            return true;
+    }
+    return false;
+}
+
+static void FillBox_Impl(weld::TreeView& rBox,
+                         StyleTree_Impl* pEntry,
+                         const std::vector<OUString>& rEntries,
+                         SfxStyleFamily eStyleFamily,
+                         weld::TreeIter* pParent)
+{
+    std::unique_ptr<weld::TreeIter> xResult = rBox.make_iterator();
+    const OUString& rName = pEntry->getName();
+    rBox.insert(pParent, -1, &rName, &rName, nullptr, nullptr, nullptr, false, xResult.get());
+
+    for (size_t i = 0; i < pEntry->getChildren().size(); ++i)
+        FillBox_Impl(rBox, pEntry->getChildren()[i].get(), rEntries, eStyleFamily, xResult.get());
+}
+
+namespace SfxTemplate
+{
+    // converts from SFX_STYLE_FAMILY Ids to 1-6
+    static sal_uInt16 SfxFamilyIdToNId(SfxStyleFamily nFamily)
+    {
+        switch ( nFamily )
+        {
+            case SfxStyleFamily::Char:   return 1;
+            case SfxStyleFamily::Para:   return 2;
+            case SfxStyleFamily::Frame:  return 3;
+            case SfxStyleFamily::Page:   return 4;
+            case SfxStyleFamily::Pseudo: return 5;
+            case SfxStyleFamily::Table:  return 6;
+            default:                     return 0xffff;
+        }
+    }
+
+    // converts from 1-6 to SFX_STYLE_FAMILY Ids
+    static SfxStyleFamily NIdToSfxFamilyId(sal_uInt16 nId)
+    {
+        switch (nId)
+        {
+            case 1: return SfxStyleFamily::Char;
+            case 2: return SfxStyleFamily::Para;
+            case 3: return SfxStyleFamily::Frame;
+            case 4: return SfxStyleFamily::Page;
+            case 5: return SfxStyleFamily::Pseudo;
+            case 6: return SfxStyleFamily::Table;
+            default: return SfxStyleFamily::All;
+        }
+    }
+}
+
+// Constructor
+
+SfxCommonTemplateDialog_Impl::SfxCommonTemplateDialog_Impl(SfxBindings* pB, vcl::Window* pW, weld::Builder* pBuilder)
+    : pBindings(pB)
+    , pWindow(pW)
+    , pModule(nullptr)
+    , pStyleSheetPool(nullptr)
+    , pCurObjShell(nullptr)
+    , xModuleManager(frame::ModuleManager::create(::comphelper::getProcessComponentContext()))
+    , m_pDeletionWatcher(nullptr)
+    , mxFmtLb(pBuilder->weld_tree_view("flatview"))
+    , mxTreeBox(pBuilder->weld_tree_view("treeview"))
+    , mxPreviewCheckbox(pBuilder->weld_check_button("showpreview"))
+    , mxFilterLb(pBuilder->weld_combo_box("filter"))
+
+    , nActFamily(0xffff)
+    , nActFilter(0)
+    , nAppFilter(SfxStyleSearchBits::Auto)
+
+    , m_nModifier(0)
+    , bDontUpdate(false)
+    , bIsWater(false)
+    , bUpdate(false)
+    , bUpdateFamily(false)
+    , bCanEdit(false)
+    , bCanDel(false)
+    , bCanNew(true)
+    , bCanHide(true)
+    , bCanShow(false)
+    , bWaterDisabled(false)
+    , bNewByExampleDisabled(false)
+    , bUpdateByExampleDisabled(false)
+    , bTreeDrag(true)
+    , bAllowReParentDrop(false)
+    , bHierarchical(false)
+    , m_bWantHierarchical(false)
+    , bBindingUpdate(true)
+{
+    mxFmtLb->set_help_id(HID_TEMPLATE_FMT);
+    mxFilterLb->set_help_id(HID_TEMPLATE_FILTER);
+    mxPreviewCheckbox->set_active(officecfg::Office::Common::StylesAndFormatting::Preview::get());
+}
+
+sal_uInt16 SfxCommonTemplateDialog_Impl::StyleNrToInfoOffset(sal_uInt16 nId)
+{
+    const SfxStyleFamilyItem& rItem = pStyleFamilies->at( nId );
+    return SfxTemplate::SfxFamilyIdToNId(rItem.GetFamily())-1;
+}
+
+void SfxTemplateDialog_Impl::EnableEdit(bool bEnable)
+{
+    SfxCommonTemplateDialog_Impl::EnableEdit( bEnable );
+    if( !bEnable || !bUpdateByExampleDisabled )
+        EnableItem("update", bEnable);
+}
+
+void SfxCommonTemplateDialog_Impl::ReadResource()
+{
+    // Read global user resource
+    for (auto & i : pFamilyState)
+        i.reset();
+
+    SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
+    pCurObjShell = pViewFrame->GetObjectShell();
+    pModule = pCurObjShell ? pCurObjShell->GetModule() : nullptr;
+    if (pModule)
+        pStyleFamilies = pModule->CreateStyleFamilies();
+    if (!pStyleFamilies)
+        pStyleFamilies.reset(new SfxStyleFamilies);
+
+    nActFilter = 0xffff;
+    if (pCurObjShell)
+    {
+        nActFilter = static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pCurObjShell ) );
+        if ( 0xffff == nActFilter )
+            nActFilter = pCurObjShell->GetAutoStyleFilterIndex();
+    }
+
+    // Paste in the toolbox
+    // reverse order, since always inserted at the head
+    size_t nCount = pStyleFamilies->size();
+
+    pBindings->ENTERREGISTRATIONS();
+
+    size_t i;
+    for (i = 0; i < nCount; ++i)
+    {
+        sal_uInt16 nSlot = 0;
+        switch (pStyleFamilies->at(i).GetFamily())
+        {
+            case SfxStyleFamily::Char:
+                nSlot = SID_STYLE_FAMILY1; break;
+            case SfxStyleFamily::Para:
+                nSlot = SID_STYLE_FAMILY2; break;
+            case SfxStyleFamily::Frame:
+                nSlot = SID_STYLE_FAMILY3; break;
+            case SfxStyleFamily::Page:
+                nSlot = SID_STYLE_FAMILY4; break;
+            case SfxStyleFamily::Pseudo:
+                nSlot = SID_STYLE_FAMILY5; break;
+            case SfxStyleFamily::Table:
+                nSlot = SID_STYLE_FAMILY6; break;
+            default: OSL_FAIL("unknown StyleFamily"); break;
+        }
+        pBoundItems[i].reset(
+            new SfxTemplateControllerItem(nSlot, *this, *pBindings) );
+    }
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_WATERCAN, *this, *pBindings) );
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_NEW_BY_EXAMPLE, *this, *pBindings) );
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_UPDATE_BY_EXAMPLE, *this, *pBindings) );
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_NEW, *this, *pBindings) );
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_DRAGHIERARCHIE, *this, *pBindings) );
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_EDIT, *this, *pBindings) );
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_DELETE, *this, *pBindings) );
+    pBoundItems[i++].reset( new SfxTemplateControllerItem(
+        SID_STYLE_FAMILY, *this, *pBindings) );
+    pBindings->LEAVEREGISTRATIONS();
+
+    for(; i < COUNT_BOUND_FUNC; ++i)
+        pBoundItems[i] = nullptr;
+
+    StartListening(*pBindings);
+
+// Insert in the reverse order of occurrence in the Style Families. This is for
+// the toolbar of the designer. The list box of the catalog respects the
+// correct order by itself.
+
+// Sequences: the order of Resource = the order of Toolbar for example list box.
+// Order of ascending SIDs: Low SIDs are displayed first when templates of
+// several families are active.
+
+    // in the Writer the UpdateStyleByExample Toolbox button is removed and
+    // the NewStyle button gets a PopupMenu
+    if(nCount > 4)
+        ReplaceUpdateButtonByMenu();
+
+    for( ; nCount--; )
+    {
+        const SfxStyleFamilyItem &rItem = pStyleFamilies->at( nCount );
+        sal_uInt16 nId = SfxTemplate::SfxFamilyIdToNId( rItem.GetFamily() );
+        InsertFamilyItem(nId, rItem);
+    }
+
+    for ( i = SID_STYLE_FAMILY1; i <= SID_STYLE_FAMILY4; i++ )
+        pBindings->Update(i);
+}
+
+void SfxCommonTemplateDialog_Impl::ClearResource()
+{
+    ClearFamilyList();
+    impl_clear();
+}
+
+void SfxCommonTemplateDialog_Impl::impl_clear()
+{
+    pStyleFamilies.reset();
+    for (auto & i : pFamilyState)
+        i.reset();
+    for (auto & i : pBoundItems)
+        i.reset();
+    pCurObjShell = nullptr;
+}
+
+SfxCommonTemplateDialog_Impl::DeletionWatcher *
+SfxCommonTemplateDialog_Impl::impl_setDeletionWatcher(
+        DeletionWatcher *const pNewWatcher)
+{
+    DeletionWatcher *const pRet(m_pDeletionWatcher);
+    m_pDeletionWatcher = pNewWatcher;
+    return pRet;
+}
+
+class TreeViewDropTarget final : public DropTargetHelper
+{
+private:
+    SfxCommonTemplateDialog_Impl& m_rParent;
+
+public:
+    TreeViewDropTarget(SfxCommonTemplateDialog_Impl& rDialog, weld::TreeView& rTreeView)
+        : DropTargetHelper(rTreeView.get_drop_target())
+        , m_rParent(rDialog)
+    {
+    }
+
+    virtual sal_Int8 AcceptDrop(const AcceptDropEvent& rEvt) override
+    {
+        return m_rParent.AcceptDrop(rEvt, *this);
+    }
+
+    virtual sal_Int8 ExecuteDrop(const ExecuteDropEvent& rEvt) override
+    {
+        return m_rParent.ExecuteDrop(rEvt);
+    }
+};
+
+void SfxCommonTemplateDialog_Impl::Initialize()
+{
+    // Read global user resource
+    ReadResource();
+    pBindings->Invalidate( SID_STYLE_FAMILY );
+    pBindings->Update( SID_STYLE_FAMILY );
+
+    mxFilterLb->connect_changed(LINK(this, SfxCommonTemplateDialog_Impl, FilterSelectHdl));
+    mxFmtLb->connect_row_activated(LINK( this, SfxCommonTemplateDialog_Impl, TreeListApplyHdl));
+    mxFmtLb->connect_mouse_press(LINK(this, SfxCommonTemplateDialog_Impl, MousePressHdl));
+    mxFmtLb->connect_query_tooltip(LINK(this, SfxCommonTemplateDialog_Impl, QueryTooltipHdl));
+    mxFmtLb->connect_changed(LINK(this, SfxCommonTemplateDialog_Impl, FmtSelectHdl));
+    mxFmtLb->connect_popup_menu(LINK(this, SfxCommonTemplateDialog_Impl, PopupFlatMenuHdl));
+    mxFmtLb->connect_key_press(LINK(this, SfxCommonTemplateDialog_Impl, KeyInputHdl));
+    mxFmtLb->set_selection_mode(SelectionMode::Multiple);
+    mxTreeBox->connect_changed(LINK(this, SfxCommonTemplateDialog_Impl, FmtSelectHdl));
+    mxTreeBox->connect_row_activated(LINK( this, SfxCommonTemplateDialog_Impl, TreeListApplyHdl));
+    mxTreeBox->connect_mouse_press(LINK(this, SfxCommonTemplateDialog_Impl, MousePressHdl));
+    mxTreeBox->connect_query_tooltip(LINK(this, SfxCommonTemplateDialog_Impl, QueryTooltipHdl));
+    mxTreeBox->connect_popup_menu(LINK(this, SfxCommonTemplateDialog_Impl, PopupTreeMenuHdl));
+    mxTreeBox->connect_key_press(LINK(this, SfxCommonTemplateDialog_Impl, KeyInputHdl));
+    mxTreeBox->connect_drag_begin(LINK(this, SfxCommonTemplateDialog_Impl, DragBeginHdl));
+    mxPreviewCheckbox->connect_clicked(LINK(this, SfxCommonTemplateDialog_Impl, PreviewHdl));
+    m_xTreeView1DropTargetHelper.reset(new TreeViewDropTarget(*this, *mxFmtLb));
+    m_xTreeView2DropTargetHelper.reset(new TreeViewDropTarget(*this, *mxTreeBox));
+
+    int nTreeHeight = mxFmtLb->get_height_rows(8);
+    mxFmtLb->set_size_request(-1, nTreeHeight);
+    mxTreeBox->set_size_request(-1, nTreeHeight);
+
+    mxFmtLb->connect_custom_get_size(LINK(this, SfxCommonTemplateDialog_Impl, CustomGetSizeHdl));
+    mxFmtLb->connect_custom_render(LINK(this, SfxCommonTemplateDialog_Impl, CustomRenderHdl));
+    mxTreeBox->connect_custom_get_size(LINK(this, SfxCommonTemplateDialog_Impl, CustomGetSizeHdl));
+    mxTreeBox->connect_custom_render(LINK(this, SfxCommonTemplateDialog_Impl, CustomRenderHdl));
+    bool bCustomPreview = officecfg::Office::Common::StylesAndFormatting::Preview::get();
+    mxFmtLb->set_column_custom_renderer(0, bCustomPreview);
+    mxTreeBox->set_column_custom_renderer(0, bCustomPreview);
+
+    mxFmtLb->set_visible(!bHierarchical);
+    mxTreeBox->set_visible(bHierarchical);
+
+    Update_Impl();
+}
+
+SfxCommonTemplateDialog_Impl::~SfxCommonTemplateDialog_Impl()
+{
+    if ( bIsWater )
+        Execute_Impl(SID_STYLE_WATERCAN, "", "", 0);
+    GetWindow()->Hide();
+    impl_clear();
+    if ( pStyleSheetPool )
+        EndListening(*pStyleSheetPool);
+    pStyleSheetPool = nullptr;
+    m_xTreeView1DropTargetHelper.reset();
+    m_xTreeView2DropTargetHelper.reset();
+    mxTreeBox.reset();
+    pIdle.reset();
+    if ( m_pDeletionWatcher )
+        m_pDeletionWatcher->signal();
+    mxFmtLb.reset();
+    mxPreviewCheckbox.reset();
+    mxFilterLb.reset();
+}
+
+// Helper function: Access to the current family item
+const SfxStyleFamilyItem *SfxCommonTemplateDialog_Impl::GetFamilyItem_Impl() const
+{
+    const size_t nCount = pStyleFamilies->size();
+    for(size_t i = 0; i < nCount; ++i)
+    {
+        const SfxStyleFamilyItem &rItem = pStyleFamilies->at( i );
+        sal_uInt16 nId = SfxTemplate::SfxFamilyIdToNId(rItem.GetFamily());
+        if(nId == nActFamily)
+            return &rItem;
+    }
+    return nullptr;
+}
+
+void SfxCommonTemplateDialog_Impl::GetSelectedStyle() const
+{
+    if (!IsInitialized() || !pStyleSheetPool || !HasSelectedStyle())
+        return;
+    const OUString aTemplName( GetSelectedEntry() );
+    const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+    pStyleSheetPool->Find( aTemplName, pItem->GetFamily() );
+}
+
+/**
+ * Is it safe to show the water-can / fill icon. If we've a
+ * hierarchical widget - we have only single select, otherwise
+ * we need to check if we have a multi-selection. We either have
+ * a mxTreeBox showing or an mxFmtLb (which we hide when not shown)
+ */
+bool SfxCommonTemplateDialog_Impl::IsSafeForWaterCan() const
+{
+    if (mxTreeBox->get_visible())
+        return mxTreeBox->get_selected_index() != -1;
+    else
+        return mxFmtLb->count_selected_rows() == 1;
+}
+
+void SfxCommonTemplateDialog_Impl::SelectStyle(const OUString &rStr, bool bIsCallback)
+{
+    const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+    if ( !pItem )
+        return;
+    const SfxStyleFamily eFam = pItem->GetFamily();
+    SfxStyleSheetBase* pStyle = pStyleSheetPool->Find( rStr, eFam );
+    if( pStyle )
+    {
+        bool bReadWrite = !(pStyle->GetMask() & SfxStyleSearchBits::ReadOnly);
+        EnableEdit( bReadWrite );
+        EnableHide( bReadWrite && !pStyle->IsHidden( ) && !pStyle->IsUsed( ) );
+        EnableShow( bReadWrite && pStyle->IsHidden( ) );
+    }
+    else
+    {
+        EnableEdit(false);
+        EnableHide(false);
+        EnableShow(false);
+    }
+
+    if (!bIsCallback)
+    {
+        if (mxTreeBox->get_visible())
+        {
+            if (!rStr.isEmpty())
+            {
+                std::unique_ptr<weld::TreeIter> xEntry = mxTreeBox->make_iterator();
+                bool bEntry = mxTreeBox->get_iter_first(*xEntry);
+                while (bEntry)
+                {
+                    if (mxTreeBox->get_text(*xEntry) == rStr)
+                    {
+                        mxTreeBox->scroll_to_row(*xEntry);
+                        mxTreeBox->select(*xEntry);
+                        break;
+                    }
+                    bEntry = mxTreeBox->iter_next(*xEntry);
+                }
+            }
+            else
+                mxTreeBox->unselect_all();
+        }
+        else
+        {
+            bool bSelect = !rStr.isEmpty();
+            if (bSelect)
+            {
+                std::unique_ptr<weld::TreeIter> xEntry = mxFmtLb->make_iterator();
+                bool bEntry = mxFmtLb->get_iter_first(*xEntry);
+                while (bEntry && mxFmtLb->get_text(*xEntry) != rStr)
+                    bEntry = mxFmtLb->iter_next(*xEntry);
+                if (!bEntry)
+                    bSelect = false;
+                else
+                {
+                    if (!mxFmtLb->is_selected(*xEntry))
+                    {
+                        mxFmtLb->unselect_all();
+                        mxFmtLb->scroll_to_row(*xEntry);
+                        mxFmtLb->select(*xEntry);
+                    }
+                }
+            }
+
+            if (!bSelect)
+            {
+                mxFmtLb->unselect_all();
+                EnableEdit(false);
+                EnableHide(false);
+                EnableShow(false);
+            }
+        }
+    }
+
+    bWaterDisabled = !IsSafeForWaterCan();
+
+    if (!bIsCallback)
+    {
+        // tdf#134598 call FmtSelect to update watercan
+        FmtSelect(nullptr, false);
+    }
+}
+
+OUString SfxCommonTemplateDialog_Impl::GetSelectedEntry() const
+{
+    OUString aRet;
+    if (mxTreeBox->get_visible())
+        aRet = mxTreeBox->get_selected_text();
+    else
+        aRet = mxFmtLb->get_selected_text();
+    return aRet;
+}
+
+void SfxCommonTemplateDialog_Impl::EnableTreeDrag(bool bEnable)
+{
+    if (pStyleSheetPool)
+    {
+        const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+        SfxStyleSheetBase* pStyle = pItem ? pStyleSheetPool->First(pItem->GetFamily()) : nullptr;
+        bAllowReParentDrop = pStyle && pStyle->HasParentSupport() && bEnable;
+    }
+    bTreeDrag = bEnable;
+}
+
+static OUString lcl_GetStyleFamilyName( SfxStyleFamily nFamily )
+{
+    if(nFamily == SfxStyleFamily::Char)
+        return "CharacterStyles" ;
+    if(nFamily == SfxStyleFamily::Para)
+        return "ParagraphStyles";
+    if(nFamily == SfxStyleFamily::Page)
+        return "PageStyles";
+    if(nFamily == SfxStyleFamily::Table)
+        return "TableStyles";
+    return OUString();
+}
+
+OUString SfxCommonTemplateDialog_Impl::getDefaultStyleName( const SfxStyleFamily eFam )
+{
+    OUString sDefaultStyle;
+    OUString aFamilyName = lcl_GetStyleFamilyName(eFam);
+    if( aFamilyName == "TableStyles" )
+        sDefaultStyle = "Default Style";
+    else
+        sDefaultStyle = "Standard";
+    uno::Reference< style::XStyleFamiliesSupplier > xModel(GetObjectShell()->GetModel(), uno::UNO_QUERY);
+    OUString aUIName;
+    try
+    {
+        uno::Reference< container::XNameAccess > xStyles;
+        uno::Reference< container::XNameAccess > xCont = xModel->getStyleFamilies();
+        xCont->getByName( aFamilyName ) >>= xStyles;
+        uno::Reference< beans::XPropertySet > xInfo;
+        xStyles->getByName( sDefaultStyle ) >>= xInfo;
+        xInfo->getPropertyValue("DisplayName") >>= aUIName;
+    }
+    catch (const uno::Exception&)
+    {
+    }
+    return aUIName;
+}
+
+void SfxCommonTemplateDialog_Impl::FillTreeBox()
+{
+    assert(mxTreeBox && "FillTreeBox() without treebox");
+    if (!pStyleSheetPool || nActFamily == 0xffff)
+        return;
+
+    const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+    if (!pItem)
+        return;
+    const SfxStyleFamily eFam = pItem->GetFamily();
+    StyleTreeArr_Impl aArr;
+    SfxStyleSheetBase* pStyle = pStyleSheetPool->First(eFam, SfxStyleSearchBits::AllVisible);
+
+    bAllowReParentDrop = pStyle && pStyle->HasParentSupport() && bTreeDrag;
+
+    while (pStyle)
+    {
+        StyleTree_Impl* pNew = new StyleTree_Impl(pStyle->GetName(), pStyle->GetParent());
+        aArr.emplace_back(pNew);
+        pStyle = pStyleSheetPool->Next();
+    }
+    OUString aUIName = getDefaultStyleName(eFam);
+    MakeTree_Impl(aArr, aUIName);
+    std::vector<OUString> aEntries;
+    MakeExpanded_Impl(*mxTreeBox, aEntries);
+    mxTreeBox->freeze();
+    mxTreeBox->clear();
+    const sal_uInt16 nCount = aArr.size();
+
+    for (sal_uInt16 i = 0; i < nCount; ++i)
+    {
+        FillBox_Impl(*mxTreeBox, aArr[i].get(), aEntries, eFam, nullptr);
+        aArr[i].reset();
+    }
+
+    EnableItem("watercan", false);
+
+    SfxTemplateItem* pState = pFamilyState[nActFamily - 1].get();
+
+    mxTreeBox->thaw();
+
+    std::unique_ptr<weld::TreeIter> xEntry = mxTreeBox->make_iterator();
+    bool bEntry = mxTreeBox->get_iter_first(*xEntry);
+    if (bEntry && nCount)
+        mxTreeBox->expand_row(*xEntry);
+
+    while (bEntry)
+    {
+        if (IsExpanded_Impl(aEntries, mxTreeBox->get_text(*xEntry)))
+            mxTreeBox->expand_row(*xEntry);
+        bEntry = mxTreeBox->iter_next(*xEntry);
+    }
+
+    OUString aStyle;
+    if(pState)  // Select current entry
+        aStyle = pState->GetStyleName();
+    SelectStyle(aStyle, false);
+    EnableDelete();
+}
+
+bool SfxCommonTemplateDialog_Impl::HasSelectedStyle() const
+{
+    return mxTreeBox->get_visible() ? mxTreeBox->get_selected_index() != -1
+                                    : mxFmtLb->count_selected_rows() != 0;
+}
+
+// internal: Refresh the display
+// nFlags: what we should update.
+void SfxCommonTemplateDialog_Impl::UpdateStyles_Impl(StyleFlags nFlags)
+{
+    OSL_ENSURE(nFlags != StyleFlags::NONE, "nothing to do");
+    const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
+    if (!pItem)
+    {
+        // Is the case for the template catalog
+        const size_t nFamilyCount = pStyleFamilies->size();
+        size_t n;
+        for( n = 0; n < nFamilyCount; n++ )
+            if( pFamilyState[ StyleNrToInfoOffset(n) ] ) break;
+        if ( n == nFamilyCount )
+            // It happens sometimes, God knows why
+            return;
+        nAppFilter = pFamilyState[StyleNrToInfoOffset(n)]->GetValue();
+        FamilySelect(  StyleNrToInfoOffset(n)+1 );
+        pItem = GetFamilyItem_Impl();
+    }
+
+    const SfxStyleFamily eFam = pItem->GetFamily();
+
+    SfxStyleSearchBits nFilter (nActFilter < pItem->GetFilterList().size() ? pItem->GetFilterList()[nActFilter].nFlags : SfxStyleSearchBits::Auto);
+    if (nFilter == SfxStyleSearchBits::Auto)   // automatic
+        nFilter = nAppFilter;
+
+    OSL_ENSURE(pStyleSheetPool, "no StyleSheetPool");
+    if(!pStyleSheetPool)
+        return;
+
+    pItem = GetFamilyItem_Impl();
+    if(nFlags & StyleFlags::UpdateFamily)   // Update view type list (Hierarchical, All, etc.
+    {
+        CheckItem(OString::number(nActFamily));    // check Button in Toolbox
+
+        mxFilterLb->freeze();
+        mxFilterLb->clear();
+
+        //insert hierarchical at the beginning
+        mxFilterLb->append(OUString::number(static_cast<int>(SfxStyleSearchBits::All)), SfxResId(STR_STYLE_FILTER_HIERARCHICAL));
+        const SfxStyleFilter& rFilter = pItem->GetFilterList();
+        for (const SfxFilterTuple& i : rFilter)
+            mxFilterLb->append(OUString::number(static_cast<int>(i.nFlags)), i.aName);
+        mxFilterLb->thaw();
+
+        if (nActFilter < mxFilterLb->get_count() - 1)
+            mxFilterLb->set_active(nActFilter + 1);
+        else
+        {
+            nActFilter = 0;
+            mxFilterLb->set_active(1);
+            nFilter = (nActFilter < rFilter.size()) ? rFilter[nActFilter].nFlags : SfxStyleSearchBits::Auto;
+        }
+
+        // if the tree view again, select family hierarchy
+        if (mxTreeBox->get_visible() || m_bWantHierarchical)
+        {
+            mxFilterLb->set_active_text(SfxResId(STR_STYLE_FILTER_HIERARCHICAL));
+            EnableHierarchical(true);
+        }
+    }
+    else
+    {
+        if (nActFilter < mxFilterLb->get_count() - 1)
+            mxFilterLb->set_active(nActFilter + 1);
+        else
+        {
+            nActFilter = 0;
+            mxFilterLb->set_active(1);
+        }
+    }
+
+    if(!(nFlags & StyleFlags::UpdateFamilyList))
+        return;
+
+    EnableItem("watercan", false);
+
+    SfxStyleSheetBase *pStyle = pStyleSheetPool->First(eFam, nFilter);
+
+    std::unique_ptr<weld::TreeIter> xEntry = mxFmtLb->make_iterator();
+    bool bEntry = mxFmtLb->get_iter_first(*xEntry);
+    std::vector<OUString> aStrings;
+
+    comphelper::string::NaturalStringSorter aSorter(
+        ::comphelper::getProcessComponentContext(),
+        Application::GetSettings().GetLanguageTag().getLocale());
+
+    while( pStyle )
+    {
+        aStrings.push_back(pStyle->GetName());
+        pStyle = pStyleSheetPool->Next();
+    }
+    OUString aUIName = getDefaultStyleName(eFam);
+
+    // Paradoxically, with a list and non-Latin style names,
+    // sorting twice is faster than sorting once.
+    // The first sort has a cheap comparator, and gets the list into mostly-sorted order.
+    // Then the second sort needs to call its (much more expensive) comparator less often.
+    std::sort(aStrings.begin(), aStrings.end());
+    std::sort(aStrings.begin(), aStrings.end(),
+       [&aSorter, &aUIName](const OUString& rLHS, const OUString& rRHS) {
+            if(rRHS == aUIName)
+                return false;
+            if(rLHS == aUIName)
+                return true; // default always first
+            return aSorter.compare(rLHS, rRHS) < 0;
+       });
+
+    size_t nCount = aStrings.size();
+    size_t nPos = 0;
+    while (nPos < nCount && bEntry &&
+           aStrings[nPos] == mxFmtLb->get_text(*xEntry))
+    {
+        ++nPos;
+        bEntry = mxFmtLb->iter_next(*xEntry);
+    }
+
+    if (nPos < nCount || bEntry)
+    {
+        // Fills the display box
+        mxFmtLb->freeze();
+        mxFmtLb->clear();
+
+        for (nPos = 0; nPos < nCount; ++nPos)
+            mxFmtLb->append(aStrings[nPos], aStrings[nPos]);
+
+        mxFmtLb->thaw();
+    }
+    // Selects the current style if any
+    SfxTemplateItem *pState = pFamilyState[nActFamily-1].get();
+    OUString aStyle;
+    if(pState)
+        aStyle = pState->GetStyleName();
+    SelectStyle(aStyle, false);
+    EnableDelete();
+}
+
+// Updated display: Watering the house
+void SfxCommonTemplateDialog_Impl::SetWaterCanState(const SfxBoolItem *pItem)
+{
+    bWaterDisabled = (pItem == nullptr);
+
+    if(!bWaterDisabled)
+        //make sure the watercan is only activated when there is (only) one selection
+        bWaterDisabled = !IsSafeForWaterCan();
+
+    if(pItem && !bWaterDisabled)
+    {
+        CheckItem("watercan", pItem->GetValue());
+        EnableItem("watercan");
+    }
+    else
+    {
+        if(!bWaterDisabled)
+            EnableItem("watercan");
+        else
+            EnableItem("watercan", false);
+    }
+
+// Ignore while in watercan mode statusupdates
+
+    size_t nCount = pStyleFamilies->size();
+    pBindings->EnterRegistrations();
+    for(size_t n = 0; n < nCount; n++)
+    {
+        SfxControllerItem *pCItem=pBoundItems[n].get();
+        bool bChecked = pItem && pItem->GetValue();
+        if( pCItem->IsBound() == bChecked )
+        {
+            if( !bChecked )
+                pCItem->ReBind();
+            else
+                pCItem->UnBind();
+        }
+    }
+    pBindings->LeaveRegistrations();
+}
+
+// Item with the status of a Family is copied and noted
+// (is updated when all states have also been updated.)
+// See also: <SfxBindings::AddDoneHdl(const Link &)>
+void SfxCommonTemplateDialog_Impl::SetFamilyState( sal_uInt16 nSlotId, const SfxTemplateItem* pItem )
+{
+    sal_uInt16 nIdx = nSlotId - SID_STYLE_FAMILY_START;
+    pFamilyState[nIdx].reset();
+    if ( pItem )
+        pFamilyState[nIdx].reset( new SfxTemplateItem(*pItem) );
+    bUpdate = true;
+
+    // If used templates (how the hell you find this out??)
+    bUpdateFamily = true;
+}
+
+// Notice from SfxBindings that the update is completed. Pushes out the update
+// of the display.
+void SfxCommonTemplateDialog_Impl::Update_Impl()
+{
+    bool bDocChanged=false;
+    SfxStyleSheetBasePool* pNewPool = nullptr;
+    SfxViewFrame* pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
+    SfxObjectShell* pDocShell = pViewFrame->GetObjectShell();
+    if( pDocShell )
+        pNewPool = pDocShell->GetStyleSheetPool();
+
+    if ( pNewPool != pStyleSheetPool && pDocShell )
+    {
+        SfxModule* pNewModule = pDocShell->GetModule();
+        if( pNewModule && pNewModule != pModule )
+        {
+            ClearResource();
+            ReadResource();
+        }
+        if ( pStyleSheetPool )
+        {
+            EndListening(*pStyleSheetPool);
+            pStyleSheetPool = nullptr;
+        }
+
+        if ( pNewPool )
+        {
+            StartListening(*pNewPool);
+            pStyleSheetPool = pNewPool;
+            bDocChanged=true;
+        }
+    }
+
+    if (bUpdateFamily)
+        UpdateFamily_Impl();
+
+    sal_uInt16 i;
+    for(i = 0; i < MAX_FAMILIES; ++i)
+        if(pFamilyState[i])
+            break;
+    if(i == MAX_FAMILIES || !pNewPool)
+        // nothing is allowed
+        return;
+
+    SfxTemplateItem *pItem = nullptr;
+    // current region not within the allowed region or default
+    if(nActFamily == 0xffff || nullptr == (pItem = pFamilyState[nActFamily-1].get() ) )
+    {
+         CheckItem(OString::number(nActFamily), false);
+         const size_t nFamilyCount = pStyleFamilies->size();
+         size_t n;
+         for( n = 0; n < nFamilyCount; n++ )
+             if( pFamilyState[ StyleNrToInfoOffset(n) ] ) break;
+
+         std::unique_ptr<SfxTemplateItem> & pNewItem = pFamilyState[StyleNrToInfoOffset(n)];
+         nAppFilter = pNewItem->GetValue();
+         FamilySelect( StyleNrToInfoOffset(n) + 1 );
+         pItem = pNewItem.get();
+    }
+    else if( bDocChanged )
+    {
+         // other DocShell -> all new
+         CheckItem(OString::number(nActFamily));
+         nActFilter = static_cast< sal_uInt16 >( LoadFactoryStyleFilter( pDocShell ) );
+         if ( 0xffff == nActFilter )
+            nActFilter = pDocShell->GetAutoStyleFilterIndex();
+
+         nAppFilter = pItem->GetValue();
+         if (!mxTreeBox->get_visible())
+         {
+             UpdateStyles_Impl(StyleFlags::UpdateFamilyList);
+         }
+         else
+             FillTreeBox();
+    }
+    else
+    {
+         // other filters for automatic
+         CheckItem(OString::number(nActFamily));
+         const SfxStyleFamilyItem *pStyleItem =  GetFamilyItem_Impl();
+         if ( pStyleItem && SfxStyleSearchBits::Auto == pStyleItem->GetFilterList()[nActFilter].nFlags
+            && nAppFilter != pItem->GetValue())
+         {
+             nAppFilter = pItem->GetValue();
+             if (!mxTreeBox->get_visible())
+                 UpdateStyles_Impl(StyleFlags::UpdateFamilyList);
+             else
+                 FillTreeBox();
+         }
+         else
+             nAppFilter = pItem->GetValue();
+    }
+    const OUString aStyle(pItem->GetStyleName());
+    SelectStyle(aStyle, false);
+    EnableDelete();
+    EnableNew( bCanNew );
+}
+
+IMPL_LINK_NOARG( SfxCommonTemplateDialog_Impl, TimeOut, Timer *, void )
+{
+    if(!bDontUpdate)
+    {
+        bDontUpdate=true;
+        if (!mxTreeBox->get_visible())
+            UpdateStyles_Impl(StyleFlags::UpdateFamilyList);
+        else
+        {
+            FillTreeBox();
+            SfxTemplateItem *pState = pFamilyState[nActFamily-1].get();
+            if(pState)
+            {
+                SelectStyle(pState->GetStyleName(), false);
+                EnableDelete();
+            }
+        }
+        bDontUpdate=false;
+        pIdle.reset();
+    }
+    else
+        pIdle->Start();
+}
+
+void SfxCommonTemplateDialog_Impl::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint)
+{
+    const SfxHintId nId = rHint.GetId();
+
+    // tap update
+    switch(nId)
+    {
+        case SfxHintId::UpdateDone:
+            {
+                SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
+                SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
+                if (
+                        bUpdate &&
+                        (
+                         !IsCheckedItem("watercan") ||
+                         (pDocShell && pDocShell->GetStyleSheetPool() != pStyleSheetPool)
+                        )
+                   )
+                {
+                    bUpdate = false;
+                    Update_Impl();
+                }
+                else if ( bUpdateFamily )
+                {
+                    UpdateFamily_Impl();
+                }
+
+                if( pStyleSheetPool )
+                {
+                    OUString aStr = GetSelectedEntry();
+                    if (!aStr.isEmpty())
+                    {
+                        const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
+                        if( !pItem ) break;
+                        const SfxStyleFamily eFam = pItem->GetFamily();
+                        SfxStyleSheetBase *pStyle = pStyleSheetPool->Find( aStr, eFam );
+                        if( pStyle )
+                        {
+                            bool bReadWrite = !(pStyle->GetMask() & SfxStyleSearchBits::ReadOnly);
+                            EnableEdit( bReadWrite );
+                            EnableHide( bReadWrite && !pStyle->IsUsed( ) && !pStyle->IsHidden( ) );
+                            EnableShow( bReadWrite && pStyle->IsHidden( ) );
+                        }
+                        else
+                        {
+                            EnableEdit(false);
+                            EnableHide(false);
+                            EnableShow(false);
+                        }
+                    }
+                }
+                break;
+            }
+
+            // Necessary if switching between documents and in both documents
+            // the same template is used. Do not immediately call Update_Impl,
+            // for the case that one of the documents is an internal InPlaceObject!
+        case SfxHintId::DocChanged:
+            bUpdate = true;
+        break;
+        case SfxHintId::Dying:
+            {
+                EndListening(*pStyleSheetPool);
+                pStyleSheetPool=nullptr;
+                break;
+            }
+        default: break;
+    }
+
+    // Do not set timer when the stylesheet pool is in the box, because it is
+    // possible that a new one is registered after the timer is up -
+    // works bad in UpdateStyles_Impl ()!
+
+    if(!bDontUpdate && nId != SfxHintId::Dying &&
+       (dynamic_cast<const SfxStyleSheetPoolHint*>(&rHint) ||
+        dynamic_cast<const SfxStyleSheetHint*>(&rHint) ||
+        dynamic_cast<const SfxStyleSheetModifiedHint*>(&rHint) ||
+        nId == SfxHintId::StyleSheetModified))
+    {
+        if(!pIdle)
+        {
+            pIdle.reset(new Idle("SfxCommonTemplate"));
+            pIdle->SetPriority(TaskPriority::LOWEST);
+            pIdle->SetInvokeHandler(LINK(this,SfxCommonTemplateDialog_Impl,TimeOut));
+        }
+        pIdle->Start();
+
+    }
+}
+
+// Other filters; can be switched by the users or as a result of new or
+// editing, if the current document has been assigned a different filter.
+void SfxCommonTemplateDialog_Impl::FilterSelect(
+                sal_uInt16 nEntry,  // Idx of the new Filters
+                bool bForce )   // Force update, even if the new filter is
+                                // equal to the current
+{
+    if( nEntry == nActFilter && !bForce )
+        return;
+
+    nActFilter = nEntry;
+    SfxObjectShell *const pDocShell = SaveSelection();
+    SfxStyleSheetBasePool *pOldStyleSheetPool = pStyleSheetPool;
+    pStyleSheetPool = pDocShell? pDocShell->GetStyleSheetPool(): nullptr;
+    if ( pOldStyleSheetPool != pStyleSheetPool )
+    {
+        if ( pOldStyleSheetPool )
+            EndListening(*pOldStyleSheetPool);
+        if ( pStyleSheetPool )
+            StartListening(*pStyleSheetPool);
+    }
+
+    UpdateStyles_Impl(StyleFlags::UpdateFamilyList);
+}
+
+// Internal: Perform functions through the Dispatcher
+bool SfxCommonTemplateDialog_Impl::Execute_Impl(
+    sal_uInt16 nId, const OUString &rStr, const OUString& rRefStr, sal_uInt16 nFamily,
+    SfxStyleSearchBits nMask, sal_uInt16 *pIdx, const sal_uInt16* pModifier)
+{
+    SfxDispatcher &rDispatcher = *SfxGetpApp()->GetDispatcher_Impl();
+    SfxStringItem aItem(nId, rStr);
+    SfxUInt16Item aFamily(SID_STYLE_FAMILY, nFamily);
+    SfxUInt16Item aMask( SID_STYLE_MASK, static_cast<sal_uInt16>(nMask) );
+    SfxStringItem aUpdName(SID_STYLE_UPD_BY_EX_NAME, rStr);
+    SfxStringItem aRefName( SID_STYLE_REFERENCE, rRefStr );
+    const SfxPoolItem* pItems[ 6 ];
+    sal_uInt16 nCount = 0;
+    if( !rStr.isEmpty() )
+        pItems[ nCount++ ] = &aItem;
+    pItems[ nCount++ ] = &aFamily;
+    if( nMask != SfxStyleSearchBits::Auto )
+        pItems[ nCount++ ] = &aMask;
+    if(SID_STYLE_UPDATE_BY_EXAMPLE == nId)
+    {
+        // Special solution for Numbering update in Writer
+        const OUString aTemplName(GetSelectedEntry());
+        aUpdName.SetValue(aTemplName);
+        pItems[ nCount++ ] = &aUpdName;
+    }
+
+    if ( !rRefStr.isEmpty() )
+        pItems[ nCount++ ] = &aRefName;
+
+    pItems[ nCount++ ] = nullptr;
+
+    DeletionWatcher aDeleted(*this);
+    sal_uInt16 nModi = pModifier ? *pModifier : 0;
+    const SfxPoolItem* pItem = rDispatcher.Execute(
+        nId, SfxCallMode::SYNCHRON | SfxCallMode::RECORD,
+        pItems, nModi );
+
+    // Dialog can be destroyed while in Execute() because started
+    // subdialogs are not modal to it (#i97888#).
+    if ( !pItem || aDeleted )
+        return false;
+
+    if ( (nId == SID_STYLE_NEW || SID_STYLE_EDIT == nId) && (mxTreeBox->get_visible() || mxFmtLb->count_selected_rows() <= 1) )
+    {
+        const SfxUInt16Item *pFilterItem = dynamic_cast< const SfxUInt16Item* >(pItem);
+        assert(pFilterItem);
+        SfxStyleSearchBits nFilterFlags = static_cast<SfxStyleSearchBits>(pFilterItem->GetValue()) & ~SfxStyleSearchBits::UserDefined;
+        if(nFilterFlags == SfxStyleSearchBits::Auto)       // User Template?
+            nFilterFlags = static_cast<SfxStyleSearchBits>(pFilterItem->GetValue());
+        const SfxStyleFamilyItem *pFamilyItem = GetFamilyItem_Impl();
+        const size_t nFilterCount = pFamilyItem->GetFilterList().size();
+
+        for ( size_t i = 0; i < nFilterCount; ++i )
+        {
+            const SfxFilterTuple &rTupel = pFamilyItem->GetFilterList()[ i ];
+
+            if ( ( rTupel.nFlags & nFilterFlags ) == nFilterFlags && pIdx )
+                *pIdx = i;
+        }
+    }
+
+    return true;
+}
+
+// Handler Listbox of Filter
+void SfxCommonTemplateDialog_Impl::EnableHierarchical(bool const bEnable)
+{
+    if (bEnable)
+    {
+        if (!bHierarchical)
+        {
+            // Turn on treeView
+            bHierarchical=true;
+            m_bWantHierarchical = true;
+            SaveSelection(); // fdo#61429 store "hierarchical"
+            const OUString aSelectEntry( GetSelectedEntry());
+            mxFmtLb->hide();
+            FillTreeBox();
+            SelectStyle(aSelectEntry, false);
+            mxTreeBox->show();
+        }
+    }
+    else
+    {
+        mxTreeBox->hide();
+        mxFmtLb->show();
+        // If bHierarchical, then the family can have changed
+        // minus one since hierarchical is inserted at the start
+        m_bWantHierarchical = false; // before FilterSelect
+        FilterSelect(mxFilterLb->get_active() - 1, bHierarchical );
+        bHierarchical=false;
+    }
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, FilterSelectHdl, weld::ComboBox&, rBox, void)
+{
+    if (SfxResId(STR_STYLE_FILTER_HIERARCHICAL) == rBox.get_active_text())
+    {
+        EnableHierarchical(true);
+    }
+    else
+    {
+        EnableHierarchical(false);
+    }
+}
+
+// Select-Handler for the Toolbox
+void SfxCommonTemplateDialog_Impl::FamilySelect(sal_uInt16 nEntry, bool bPreviewRefresh)
+{
+    assert((0 < nEntry && nEntry <= MAX_FAMILIES) || 0xffff == nEntry);
+    if( nEntry != nActFamily || bPreviewRefresh )
+    {
+        CheckItem(OString::number(nActFamily), false);
+        nActFamily = nEntry;
+        SfxDispatcher* pDispat = pBindings->GetDispatcher_Impl();
+        SfxUInt16Item const aItem(SID_STYLE_FAMILY,
+                static_cast<sal_uInt16>(SfxTemplate::NIdToSfxFamilyId(nEntry)));
+        pDispat->ExecuteList(SID_STYLE_FAMILY, SfxCallMode::SYNCHRON, { &aItem });
+        pBindings->Invalidate( SID_STYLE_FAMILY );
+        pBindings->Update( SID_STYLE_FAMILY );
+        UpdateFamily_Impl();
+    }
+}
+
+void SfxCommonTemplateDialog_Impl::ActionSelect(const OString& rEntry)
+{
+    if (rEntry == "watercan")
+    {
+        const bool bOldState = !IsCheckedItem(rEntry);
+        bool bCheck;
+        SfxBoolItem aBool;
+        // when a template is chosen.
+        if (!bOldState && HasSelectedStyle())
+        {
+            const OUString aTemplName(
+                GetSelectedEntry());
+            Execute_Impl(
+                SID_STYLE_WATERCAN, aTemplName, "",
+                static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()) );
+            bCheck = true;
+        }
+        else
+        {
+            Execute_Impl(SID_STYLE_WATERCAN, "", "", 0);
+            bCheck = false;
+        }
+        CheckItem(rEntry, bCheck);
+        aBool.SetValue(bCheck);
+        SetWaterCanState(&aBool);
+    }
+    else if (rEntry == "new" || rEntry == "newmenu")
+    {
+        if(pStyleSheetPool && nActFamily != 0xffff)
+        {
+            const SfxStyleFamily eFam=GetFamilyItem_Impl()->GetFamily();
+            const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
+            SfxStyleSearchBits nFilter(SfxStyleSearchBits::Auto);
+            if (pItem && nActFilter != 0xffff)
+                nFilter = pItem->GetFilterList()[nActFilter].nFlags;
+            if (nFilter == SfxStyleSearchBits::Auto)    // automatic
+                nFilter = nAppFilter;
+
+            // why? : FloatingWindow must not be parent of a modal dialog
+            SfxNewStyleDlg aDlg(pWindow ? pWindow->GetFrameWeld() : nullptr, *pStyleSheetPool, eFam);
+            auto nResult = aDlg.run();
+            if (nResult ==  RET_OK)
+            {
+                const OUString aTemplName(aDlg.GetName());
+                Execute_Impl(SID_STYLE_NEW_BY_EXAMPLE,
+                             aTemplName, "",
+                             static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()),
+                             nFilter);
+                UpdateFamily_Impl();
+            }
+        }
+    }
+    else if (rEntry == "update")
+    {
+        Execute_Impl(SID_STYLE_UPDATE_BY_EXAMPLE,
+                "", "",
+                static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()));
+    }
+    else if (rEntry == "load")
+        SfxGetpApp()->GetDispatcher_Impl()->Execute(SID_TEMPLATE_LOAD);
+    else
+        SAL_WARN("sfx", "not implemented: " << rEntry);
+}
+
+static OUString getModuleIdentifier( const Reference< XModuleManager2 >& i_xModMgr, SfxObjectShell const * i_pObjSh )
+{
+    OSL_ENSURE( i_xModMgr.is(), "getModuleIdentifier(): no XModuleManager" );
+    OSL_ENSURE( i_pObjSh, "getModuleIdentifier(): no ObjectShell" );
+
+    OUString sIdentifier;
+
+    try
+    {
+        sIdentifier = i_xModMgr->identify( i_pObjSh->GetModel() );
+    }
+    catch ( css::frame::UnknownModuleException& )
+    {
+        SAL_WARN("sfx", "getModuleIdentifier(): unknown module" );
+    }
+    catch ( Exception& )
+    {
+        OSL_FAIL( "getModuleIdentifier(): exception of XModuleManager::identify()" );
+    }
+
+    return sIdentifier;
+}
+
+sal_Int32 SfxCommonTemplateDialog_Impl::LoadFactoryStyleFilter( SfxObjectShell const * i_pObjSh )
+{
+    OSL_ENSURE( i_pObjSh, "SfxCommonTemplateDialog_Impl::LoadFactoryStyleFilter(): no ObjectShell" );
+
+    ::comphelper::SequenceAsHashMap aFactoryProps(
+        xModuleManager->getByName( getModuleIdentifier( xModuleManager, i_pObjSh ) ) );
+    sal_Int32 nFilter = aFactoryProps.getUnpackedValueOrDefault( "ooSetupFactoryStyleFilter", sal_Int32(-1) );
+
+    m_bWantHierarchical = (nFilter & 0x1000) != 0;
+    nFilter &= ~0x1000; // clear it
+
+    return nFilter;
+}
+
+void SfxCommonTemplateDialog_Impl::SaveFactoryStyleFilter( SfxObjectShell const * i_pObjSh, sal_Int32 i_nFilter )
+{
+    OSL_ENSURE( i_pObjSh, "SfxCommonTemplateDialog_Impl::LoadFactoryStyleFilter(): no ObjectShell" );
+    Sequence< PropertyValue > lProps(1);
+    lProps[0].Name = "ooSetupFactoryStyleFilter";
+    lProps[0].Value <<= i_nFilter | (m_bWantHierarchical ? 0x1000 : 0);
+    xModuleManager->replaceByName( getModuleIdentifier( xModuleManager, i_pObjSh ), makeAny( lProps ) );
+}
+
+SfxObjectShell* SfxCommonTemplateDialog_Impl::SaveSelection()
+{
+    SfxViewFrame *const pViewFrame(pBindings->GetDispatcher_Impl()->GetFrame());
+    SfxObjectShell *const pDocShell(pViewFrame->GetObjectShell());
+    if (pDocShell)
+    {
+        pDocShell->SetAutoStyleFilterIndex(nActFilter);
+        SaveFactoryStyleFilter( pDocShell, nActFilter );
+    }
+    return pDocShell;
+}
+
+void SfxCommonTemplateDialog_Impl::DropHdl(const OUString& rStyle, const OUString& rParent)
+{
+    bDontUpdate = true;
+    const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
+    const SfxStyleFamily eFam = pItem->GetFamily();
+    pStyleSheetPool->SetParent(eFam, rStyle, rParent);
+    bDontUpdate = false;
+}
+
+// Handler for the New-Buttons
+void SfxCommonTemplateDialog_Impl::NewHdl()
+{
+    if ( nActFamily == 0xffff || !(mxTreeBox->get_visible() || mxFmtLb->count_selected_rows() <= 1))
+        return;
+
+    const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
+    const SfxStyleFamily eFam = pItem->GetFamily();
+    SfxStyleSearchBits nMask(SfxStyleSearchBits::Auto);
+    if (nActFilter != 0xffff)
+        nMask = pItem->GetFilterList()[nActFilter].nFlags;
+    if (nMask == SfxStyleSearchBits::Auto)    // automatic
+        nMask = nAppFilter;
+
+    Execute_Impl(SID_STYLE_NEW,
+                 "", GetSelectedEntry(),
+                 static_cast<sal_uInt16>(eFam),
+                 nMask);
+}
+
+// Handler for the edit-Buttons
+void SfxCommonTemplateDialog_Impl::EditHdl()
+{
+    if(IsInitialized() && HasSelectedStyle())
+    {
+        sal_uInt16 nFilter = nActFilter;
+        OUString aTemplName(GetSelectedEntry());
+        GetSelectedStyle(); // -Wall required??
+        Execute_Impl( SID_STYLE_EDIT, aTemplName, OUString(),
+                          static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()), SfxStyleSearchBits::Auto, &nFilter );
+    }
+}
+
+// Handler for the Delete-Buttons
+void SfxCommonTemplateDialog_Impl::DeleteHdl()
+{
+    if ( !IsInitialized() || !HasSelectedStyle() )
+        return;
+
+    bool bUsedStyle = false;     // one of the selected styles are used in the document?
+
+    std::vector<std::unique_ptr<weld::TreeIter>> aList;
+    weld::TreeView* pTreeView = mxTreeBox->get_visible() ? mxTreeBox.get() : mxFmtLb.get();
+    const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+
+    OUStringBuffer aMsg;
+    aMsg.append(SfxResId(STR_DELETE_STYLE_USED)).append(SfxResId(STR_DELETE_STYLE));
+
+    pTreeView->selected_foreach([this, pTreeView, pItem, &aList, &bUsedStyle, &aMsg](weld::TreeIter& rEntry){
+        aList.emplace_back(pTreeView->make_iterator(&rEntry));
+        // check the style is used or not
+        const OUString aTemplName(pTreeView->get_text(rEntry));
+
+        SfxStyleSheetBase* pStyle = pStyleSheetPool->Find( aTemplName, pItem->GetFamily() );
+
+        if ( pStyle->IsUsed() )  // pStyle is in use in the document?
+        {
+            if (bUsedStyle) // add a separator for the second and later styles
+                aMsg.append(", ");
+            aMsg.append(aTemplName);
+            bUsedStyle = true;
+        }
+
+        return false;
+    });
+
+    bool aApproved = false;
+
+    // we only want to show the dialog once and if we want to delete a style in use (UX-advice)
+    if (bUsedStyle)
+    {
+        std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pTreeView,
+                                                  VclMessageType::Question, VclButtonsType::YesNo,
+                                                  aMsg.makeStringAndClear()));
+        aApproved = xBox->run() == RET_YES;
+    }
+
+    // if there are no used styles selected or the user approved the changes
+    if ( !(!bUsedStyle || aApproved) )
+        return;
+
+    for (auto const& elem : aList)
+    {
+        const OUString aTemplName(pTreeView->get_text(*elem));
+        bDontUpdate = true; // To prevent the Treelistbox to shut down while deleting
+        Execute_Impl( SID_STYLE_DELETE, aTemplName,
+                      OUString(), static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()) );
+
+        if (mxTreeBox->get_visible())
+        {
+            weld::RemoveParentKeepChildren(*mxTreeBox, *elem);
+            bDontUpdate = false;
+        }
+    }
+    bDontUpdate = false; //if everything is deleted set bDontUpdate back to false
+    UpdateStyles_Impl(StyleFlags::UpdateFamilyList); //and force-update the list
+}
+
+void SfxCommonTemplateDialog_Impl::HideHdl()
+{
+    if ( !IsInitialized() || !HasSelectedStyle() )
+        return;
+
+    weld::TreeView* pTreeView = mxTreeBox->get_visible() ? mxTreeBox.get() : mxFmtLb.get();
+    pTreeView->selected_foreach([this, pTreeView](weld::TreeIter& rEntry){
+        OUString aTemplName = pTreeView->get_text(rEntry);
+
+        Execute_Impl( SID_STYLE_HIDE, aTemplName,
+                      OUString(), static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()) );
+
+        return false;
+    });
+}
+
+void SfxCommonTemplateDialog_Impl::ShowHdl()
+{
+    if ( !IsInitialized() || !HasSelectedStyle() )
+        return;
+
+    weld::TreeView* pTreeView = mxTreeBox->get_visible() ? mxTreeBox.get() : mxFmtLb.get();
+    pTreeView->selected_foreach([this, pTreeView](weld::TreeIter& rEntry){
+        OUString aTemplName = pTreeView->get_text(rEntry);
+
+        Execute_Impl( SID_STYLE_SHOW, aTemplName,
+                      OUString(), static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()) );
+
+        return false;
+    });
+}
+
+void SfxCommonTemplateDialog_Impl::EnableDelete()
+{
+    bool bEnableDelete(false);
+    if(IsInitialized() && HasSelectedStyle())
+    {
+        OSL_ENSURE(pStyleSheetPool, "No StyleSheetPool");
+        const OUString aTemplName(GetSelectedEntry());
+        const SfxStyleFamilyItem *pItem = GetFamilyItem_Impl();
+        const SfxStyleFamily eFam = pItem->GetFamily();
+        SfxStyleSearchBits nFilter = SfxStyleSearchBits::Auto;
+        if (pItem->GetFilterList().size() > nActFilter)
+            nFilter = pItem->GetFilterList()[nActFilter].nFlags;
+        if(nFilter == SfxStyleSearchBits::Auto)    // automatic
+            nFilter = nAppFilter;
+        const SfxStyleSheetBase *pStyle =
+            pStyleSheetPool->Find(aTemplName,eFam, mxTreeBox->get_visible() ? SfxStyleSearchBits::All : nFilter);
+
+        OSL_ENSURE(pStyle, "Style not found");
+        if (pStyle && pStyle->IsUserDefined())
+        {
+            if (pStyle->HasClearParentSupport() || !pStyle->IsUsed())
+            {
+                bEnableDelete = true;
+            }
+            else if (pStyle->GetFamily() == SfxStyleFamily::Page)
+            {
+                // Hack to allow Calc page styles to be deleted,
+                // remove when IsUsed is fixed for Calc page styles.
+                SfxViewFrame* pFrame = GetObjectShell()->GetFrame();
+                if (pFrame)
+                {
+                    uno::Reference<frame::XFrame > xFrame = pFrame->GetFrame().GetFrameInterface();
+                    if (vcl::CommandInfoProvider::GetModuleIdentifier(xFrame) == "com.sun.star.sheet.SpreadsheetDocument")
+                    {
+                        bEnableDelete = true;
+                    }
+                }
+            }
+        }
+    }
+    EnableDel(bEnableDelete);
+}
+
+IMPL_LINK(SfxCommonTemplateDialog_Impl, MousePressHdl, const MouseEvent&, rMEvt, bool)
+{
+    m_nModifier = rMEvt.GetModifier();
+    return false;
+}
+
+// Double-click on a style sheet in the ListBox is applied.
+IMPL_LINK_NOARG(SfxCommonTemplateDialog_Impl, TreeListApplyHdl, weld::TreeView&, bool)
+{
+    // only if that region is allowed
+    if ( IsInitialized() && nullptr != pFamilyState[nActFamily-1] &&
+         !GetSelectedEntry().isEmpty() )
+    {
+        Execute_Impl(SID_STYLE_APPLY,
+                     GetSelectedEntry(), OUString(),
+                     static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()),
+                     SfxStyleSearchBits::Auto, nullptr, &m_nModifier);
+    }
+    // After selecting a focused item if possible again on the app window
+    if ( dynamic_cast< const SfxTemplateDialog_Impl* >(this) !=  nullptr )
+    {
+        SfxViewFrame *pViewFrame = pBindings->GetDispatcher_Impl()->GetFrame();
+        SfxViewShell *pVu = pViewFrame->GetViewShell();
+        vcl::Window *pAppWin = pVu ? pVu->GetWindow(): nullptr;
+        if(pAppWin)
+            pAppWin->GrabFocus();
+    }
+
+    return true;
+}
+
+IMPL_LINK_NOARG(SfxCommonTemplateDialog_Impl, PreviewHdl, weld::Button&, void)
+{
+    std::shared_ptr<comphelper::ConfigurationChanges> batch( comphelper::ConfigurationChanges::create() );
+    bool bCustomPreview = mxPreviewCheckbox->get_active();
+    officecfg::Office::Common::StylesAndFormatting::Preview::set(bCustomPreview, batch );
+    batch->commit();
+
+    mxFmtLb->clear();
+    mxFmtLb->set_column_custom_renderer(0, bCustomPreview);
+    mxTreeBox->clear();
+    mxTreeBox->set_column_custom_renderer(0, bCustomPreview);
+
+    FamilySelect(nActFamily, true);
+}
+
+// Selection of a template during the Watercan-Status
+IMPL_LINK(SfxCommonTemplateDialog_Impl, FmtSelectHdl, weld::TreeView&, rListBox, void)
+{
+    FmtSelect(&rListBox, true);
+}
+
+void SfxCommonTemplateDialog_Impl::FmtSelect(weld::TreeView* pListBox, bool bIsCallback)
+{
+    std::unique_ptr<weld::TreeIter> xHdlEntry;
+    if (pListBox)
+    {
+        xHdlEntry = pListBox->make_iterator();
+        if (!pListBox->get_cursor(xHdlEntry.get()))
+            return;
+    }
+
+    // Trigger Help PI, if this is permitted of call handlers and field
+    if (!pListBox || pListBox->is_selected(*xHdlEntry))
+    {
+        // Only when the watercan is on
+        if ( IsInitialized() &&
+             IsCheckedItem("watercan") &&
+             // only if that region is allowed
+             nullptr != pFamilyState[nActFamily-1] && (mxTreeBox || mxFmtLb->count_selected_rows() <= 1) )
+        {
+            Execute_Impl(SID_STYLE_WATERCAN,
+                         "", "", 0);
+            Execute_Impl(SID_STYLE_WATERCAN,
+                         GetSelectedEntry(), "",
+                         static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()));
+        }
+        EnableItem("watercan", !bWaterDisabled);
+        EnableDelete();
+    }
+    if( !pListBox )
+        return;
+
+    SelectStyle(pListBox->get_text(*xHdlEntry), bIsCallback);
+}
+
+void SfxCommonTemplateDialog_Impl::MenuSelect(const OString& rIdent)
+{
+    sLastItemIdent = rIdent;
+    if (sLastItemIdent.isEmpty())
+        return;
+    Application::PostUserEvent(
+        LINK(this, SfxCommonTemplateDialog_Impl, MenuSelectAsyncHdl));
+}
+
+IMPL_LINK_NOARG(SfxCommonTemplateDialog_Impl, MenuSelectAsyncHdl, void*, void)
+{
+    if (sLastItemIdent == "new")
+        NewHdl();
+    else if (sLastItemIdent == "edit")
+        EditHdl();
+    else if (sLastItemIdent == "delete")
+        DeleteHdl();
+    else if (sLastItemIdent == "hide")
+        HideHdl();
+    else if (sLastItemIdent == "show")
+        ShowHdl();
+}
+
+SfxStyleFamily SfxCommonTemplateDialog_Impl::GetActualFamily() const
+{
+    const SfxStyleFamilyItem *pFamilyItem = GetFamilyItem_Impl();
+    if( !pFamilyItem || nActFamily == 0xffff )
+        return SfxStyleFamily::Para;
+    else
+        return pFamilyItem->GetFamily();
+}
+
+void SfxCommonTemplateDialog_Impl::EnableExample_Impl(sal_uInt16 nId, bool bEnable)
+{
+    bool bDisable = !bEnable || !IsSafeForWaterCan();
+    if (nId == SID_STYLE_NEW_BY_EXAMPLE)
+    {
+        bNewByExampleDisabled = bDisable;
+        EnableItem("new", bEnable);
+        EnableItem("newmenu", bEnable);
+    }
+    else if( nId == SID_STYLE_UPDATE_BY_EXAMPLE )
+    {
+        bUpdateByExampleDisabled = bDisable;
+        EnableItem("update", bEnable);
+    }
+}
+
+void SfxCommonTemplateDialog_Impl::CreateContextMenu()
+{
+    if ( bBindingUpdate )
+    {
+        pBindings->Invalidate( SID_STYLE_NEW, true );
+        pBindings->Update( SID_STYLE_NEW );
+        bBindingUpdate = false;
+    }
+    mxMenu.reset();
+    mxMenuBuilder.reset(Application::CreateBuilder(nullptr, "sfx/ui/stylecontextmenu.ui"));
+    mxMenu = mxMenuBuilder->weld_menu("menu");
+    mxMenu->set_sensitive("edit", bCanEdit);
+    mxMenu->set_sensitive("delete", bCanDel);
+    mxMenu->set_sensitive("new", bCanNew);
+    mxMenu->set_sensitive("hide", bCanHide);
+    mxMenu->set_sensitive("show", bCanShow);
+
+    const SfxStyleFamilyItem* pItem = GetFamilyItem_Impl();
+    if (pItem && pItem->GetFamily() == SfxStyleFamily::Table) //tdf#101648, no ui for this yet
+    {
+        mxMenu->set_sensitive("edit", false);
+        mxMenu->set_sensitive("new", false);
+    }
+}
+
+SfxTemplateDialog_Impl::SfxTemplateDialog_Impl(SfxBindings* pB, SfxTemplatePanelControl* pDlgWindow)
+    : SfxCommonTemplateDialog_Impl(pB, pDlgWindow, pDlgWindow->get_builder())
+    , m_xActionTbL(pDlgWindow->get_builder()->weld_toolbar("left"))
+    , m_xActionTbR(pDlgWindow->get_builder()->weld_toolbar("right"))
+    , m_xToolMenu(pDlgWindow->get_builder()->weld_menu("toolmenu"))
+    , m_nActionTbLVisible(0)
+{
+    m_xActionTbR->set_item_help_id("watercan", HID_TEMPLDLG_WATERCAN);
+    // shown/hidden in SfxTemplateDialog_Impl::ReplaceUpdateButtonByMenu()
+    m_xActionTbR->set_item_help_id("new", HID_TEMPLDLG_NEWBYEXAMPLE);
+    m_xActionTbR->set_item_help_id("newmenu", HID_TEMPLDLG_NEWBYEXAMPLE);
+    m_xActionTbR->set_item_menu("newmenu", m_xToolMenu.get());
+    m_xToolMenu->connect_activate(LINK(this, SfxTemplateDialog_Impl, ToolMenuSelectHdl));
+    m_xActionTbR->set_item_help_id("update", HID_TEMPLDLG_UPDATEBYEXAMPLE);
+
+    Initialize();
+}
+
+class ToolbarDropTarget final : public DropTargetHelper
+{
+private:
+    SfxTemplateDialog_Impl& m_rParent;
+
+public:
+    ToolbarDropTarget(SfxTemplateDialog_Impl& rDialog, weld::Toolbar& rToolbar)
+        : DropTargetHelper(rToolbar.get_drop_target())
+        , m_rParent(rDialog)
+    {
+    }
+
+    virtual sal_Int8 AcceptDrop(const AcceptDropEvent& rEvt) override
+    {
+        return m_rParent.AcceptToolbarDrop(rEvt, *this);
+    }
+
+    virtual sal_Int8 ExecuteDrop(const ExecuteDropEvent& rEvt) override
+    {
+        return m_rParent.ExecuteDrop(rEvt);
+    }
+};
+
+void SfxTemplateDialog_Impl::Initialize()
+{
+    SfxCommonTemplateDialog_Impl::Initialize();
+
+    m_xActionTbL->connect_clicked(LINK(this, SfxTemplateDialog_Impl, ToolBoxLSelect));
+    m_xActionTbR->connect_clicked(LINK(this, SfxTemplateDialog_Impl, ToolBoxRSelect));
+    m_xActionTbL->set_help_id(HID_TEMPLDLG_TOOLBOX_LEFT);
+
+    m_xToolbarDropTargetHelper.reset(new ToolbarDropTarget(*this, *m_xActionTbL));
+}
+
+void SfxTemplateDialog_Impl::EnableFamilyItem(sal_uInt16 nId, bool bEnable)
+{
+    m_xActionTbL->set_item_sensitive(OString::number(nId), bEnable);
+}
+
+// Insert element into dropdown filter "Frame Styles", "List Styles", etc.
+void SfxTemplateDialog_Impl::InsertFamilyItem(sal_uInt16 nId, const SfxStyleFamilyItem &rItem)
+{
+    OString sHelpId;
+    switch( rItem.GetFamily() )
+    {
+        case SfxStyleFamily::Char:     sHelpId = ".uno:CharStyle"; break;
+        case SfxStyleFamily::Para:     sHelpId = ".uno:ParaStyle"; break;
+        case SfxStyleFamily::Frame:    sHelpId = ".uno:FrameStyle"; break;
+        case SfxStyleFamily::Page:     sHelpId = ".uno:PageStyle"; break;
+        case SfxStyleFamily::Pseudo:   sHelpId = ".uno:ListStyle"; break;
+        case SfxStyleFamily::Table:    sHelpId = ".uno:TableStyle"; break;
+        default: OSL_FAIL("unknown StyleFamily"); break;
+    }
+
+    OString sId(OString::number(nId));
+    m_xActionTbL->set_item_visible(sId, true);
+    m_xActionTbL->set_item_icon_name(sId, rItem.GetImage());
+    m_xActionTbL->set_item_tooltip_text(sId, rItem.GetText());
+    m_xActionTbL->set_item_help_id(sId, sHelpId);
+    ++m_nActionTbLVisible;
+}
+
+void SfxTemplateDialog_Impl::ReplaceUpdateButtonByMenu()
+{
+    m_xActionTbR->set_item_visible("update", false);
+    m_xActionTbR->set_item_visible("new", false);
+    m_xActionTbR->set_item_visible("newmenu", true);
+    FillToolMenu();
+}
+
+void SfxTemplateDialog_Impl::ClearFamilyList()
+{
+    for (int i = 0, nCount = m_xActionTbL->get_n_items(); i < nCount; ++i)
+        m_xActionTbL->set_item_visible(m_xActionTbL->get_item_ident(i), false);
+
+}
+
+void SfxCommonTemplateDialog_Impl::InvalidateBindings()
+{
+    pBindings->Invalidate(SID_STYLE_NEW_BY_EXAMPLE, true);
+    pBindings->Update( SID_STYLE_NEW_BY_EXAMPLE );
+    pBindings->Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE, true);
+    pBindings->Update( SID_STYLE_UPDATE_BY_EXAMPLE );
+    pBindings->Invalidate( SID_STYLE_WATERCAN, true);
+    pBindings->Update( SID_STYLE_WATERCAN );
+    pBindings->Invalidate( SID_STYLE_NEW, true);
+    pBindings->Update( SID_STYLE_NEW );
+    pBindings->Invalidate( SID_STYLE_DRAGHIERARCHIE, true);
+    pBindings->Update( SID_STYLE_DRAGHIERARCHIE );
+}
+
+SfxTemplateDialog_Impl::~SfxTemplateDialog_Impl()
+{
+    m_xToolbarDropTargetHelper.reset();
+    m_xActionTbL.reset();
+    m_xActionTbR.reset();
+}
+
+void SfxTemplateDialog_Impl::EnableItem(const OString& rMesId, bool bCheck)
+{
+    if (rMesId == "watercan" && !bCheck && IsCheckedItem("watercan"))
+        Execute_Impl(SID_STYLE_WATERCAN, "", "", 0);
+    m_xActionTbR->set_item_sensitive(rMesId, bCheck);
+}
+
+void SfxTemplateDialog_Impl::CheckItem(const OString &rMesId, bool bCheck)
+{
+    if (rMesId == "watercan")
+    {
+        bIsWater=bCheck;
+        m_xActionTbR->set_item_active("watercan", bCheck);
+    }
+    else
+        m_xActionTbL->set_item_active(rMesId, bCheck);
+}
+
+bool SfxTemplateDialog_Impl::IsCheckedItem(const OString& rMesId)
+{
+    if (rMesId == "watercan")
+        return m_xActionTbR->get_item_active("watercan");
+    return m_xActionTbL->get_item_active(rMesId);
+}
+
+IMPL_LINK( SfxTemplateDialog_Impl, ToolBoxLSelect, const OString&, rEntry, void)
+{
+    FamilySelect(rEntry.toUInt32());
+}
+
+IMPL_LINK(SfxTemplateDialog_Impl, ToolBoxRSelect, const OString&, rEntry, void)
+{
+    if (rEntry == "newmenu")
+        m_xActionTbR->set_menu_item_active(rEntry, !m_xActionTbR->get_menu_item_active(rEntry));
+    else
+        ActionSelect(rEntry);
+}
+
+void SfxTemplateDialog_Impl::FillToolMenu()
+{
+    //create a popup menu in Writer
+    OUString sTextDoc("com.sun.star.text.TextDocument");
+
+    auto aProperties = vcl::CommandInfoProvider::GetCommandProperties(".uno:StyleNewByExample", sTextDoc);
+    OUString sLabel = vcl::CommandInfoProvider::GetPopupLabelForCommand(aProperties);
+    m_xToolMenu->append("new", sLabel);
+    aProperties = vcl::CommandInfoProvider::GetCommandProperties(".uno:StyleUpdateByExample", sTextDoc);
+    sLabel = vcl::CommandInfoProvider::GetPopupLabelForCommand(aProperties);
+    m_xToolMenu->append("update", sLabel);
+    m_xToolMenu->append_separator("separator");
+
+    aProperties = vcl::CommandInfoProvider::GetCommandProperties(".uno:LoadStyles", sTextDoc);
+    sLabel = vcl::CommandInfoProvider::GetPopupLabelForCommand(aProperties);
+    m_xToolMenu->append("load", sLabel);
+}
+
+IMPL_LINK(SfxTemplateDialog_Impl, ToolMenuSelectHdl, const OString&, rMenuId, void)
+{
+    if (rMenuId.isEmpty())
+        return;
+    ActionSelect(rMenuId);
+}
+
+void SfxCommonTemplateDialog_Impl::SetFamily(SfxStyleFamily const nFamily)
+{
+    sal_uInt16 const nId(SfxTemplate::SfxFamilyIdToNId(nFamily));
+    assert((0 < nId && nId <= MAX_FAMILIES) || 0xffff == nId);
+    if ( nId != nActFamily )
+    {
+        if ( nActFamily != 0xFFFF )
+            CheckItem(OString::number(nActFamily), false);
+        nActFamily = nId;
+        if ( nId != 0xFFFF )
+            bUpdateFamily = true;
+    }
+}
+
+void SfxCommonTemplateDialog_Impl::UpdateFamily_Impl()
+{
+    bUpdateFamily = false;
+
+    SfxDispatcher* pDispat = pBindings->GetDispatcher_Impl();
+    SfxViewFrame *pViewFrame = pDispat->GetFrame();
+    SfxObjectShell *pDocShell = pViewFrame->GetObjectShell();
+
+    SfxStyleSheetBasePool *pOldStyleSheetPool = pStyleSheetPool;
+    pStyleSheetPool = pDocShell? pDocShell->GetStyleSheetPool(): nullptr;
+    if ( pOldStyleSheetPool != pStyleSheetPool )
+    {
+        if ( pOldStyleSheetPool )
+            EndListening(*pOldStyleSheetPool);
+        if ( pStyleSheetPool )
+            StartListening(*pStyleSheetPool);
+    }
+
+    bWaterDisabled = false;
+    bCanNew = mxTreeBox->get_visible() || mxFmtLb->count_selected_rows() <= 1;
+    bTreeDrag = true;
+    bUpdateByExampleDisabled = false;
+
+    if (pStyleSheetPool)
+    {
+        if (!mxTreeBox->get_visible())
+            UpdateStyles_Impl(StyleFlags::UpdateFamily | StyleFlags::UpdateFamilyList);
+        else
+        {
+            UpdateStyles_Impl(StyleFlags::UpdateFamily);
+            FillTreeBox();
+        }
+    }
+
+    InvalidateBindings();
+
+    if (IsCheckedItem("watercan") &&
+         // only if that area is allowed
+         nullptr != pFamilyState[nActFamily - 1])
+    {
+        Execute_Impl(SID_STYLE_APPLY,
+                     GetSelectedEntry(),
+                     OUString(),
+                     static_cast<sal_uInt16>(GetFamilyItem_Impl()->GetFamily()));
+    }
+}
+
+void SfxCommonTemplateDialog_Impl::ReplaceUpdateButtonByMenu()
+{
+    //does nothing
+}
+
+sal_Int8 SfxTemplateDialog_Impl::AcceptToolbarDrop(const AcceptDropEvent& rEvt, const DropTargetHelper& rHelper)
+{
+    sal_Int8 nReturn = DND_ACTION_NONE;
+
+    // auto flip to the category under the mouse
+    int nIndex = m_xActionTbL->get_drop_index(rEvt.maPosPixel);
+    if (nIndex >= m_nActionTbLVisible)
+        nIndex = m_nActionTbLVisible - 1;
+
+    OString sIdent = m_xActionTbL->get_item_ident(nIndex);
+    if (!sIdent.isEmpty() && !m_xActionTbL->get_item_active(sIdent))
+        ToolBoxLSelect(sIdent);
+
+    // special case: page styles are allowed to create new styles by example
+    // but not allowed to be created by drag and drop
+    if (sIdent.toUInt32() != SfxTemplate::SfxFamilyIdToNId(SfxStyleFamily::Page) &&
+        rHelper.IsDropFormatSupported(SotClipboardFormatId::OBJECTDESCRIPTOR) &&
+        !bNewByExampleDisabled)
+    {
+        nReturn = DND_ACTION_COPY;
+    }
+    return nReturn;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/titledockwin.cxx b/sfx2/source/dialog/titledockwin.cxx
new file mode 100644
index 000000000..104abcc9e
--- /dev/null
+++ b/sfx2/source/dialog/titledockwin.cxx
@@ -0,0 +1,276 @@
+/* -*- 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/titledockwin.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/strings.hrc>
+#include <bitmaps.hlst>
+#include <sfx2/sfxresid.hxx>
+
+#include <svl/eitem.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/event.hxx>
+
+
+namespace sfx2
+{
+    //= TitledDockingWindow
+    TitledDockingWindow::TitledDockingWindow( SfxBindings* i_pBindings, SfxChildWindow* i_pChildWindow, vcl::Window* i_pParent )
+        :SfxDockingWindow( i_pBindings, i_pChildWindow, i_pParent, WB_MOVEABLE|WB_CLOSEABLE|WB_DOCKABLE|WB_HIDE|WB_3DLOOK )
+        ,m_sTitle()
+        ,m_aToolbox( VclPtr<ToolBox>::Create(this) )
+        ,m_aContentWindow( VclPtr<vcl::Window>::Create(this, WB_DIALOGCONTROL) )
+        ,m_aBorder( 3, 1, 3, 3 )
+        ,m_bLayoutPending( false )
+        ,m_nTitleBarHeight(0)
+    {
+        SetBackground( Wallpaper() );
+
+        m_aToolbox->SetSelectHdl( LINK( this, TitledDockingWindow, OnToolboxItemSelected ) );
+        m_aToolbox->SetOutStyle( TOOLBOX_STYLE_FLAT );
+        m_aToolbox->SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetDialogColor() ) );
+        m_aToolbox->Show();
+        impl_resetToolBox();
+
+        m_aContentWindow->Show();
+    }
+
+    TitledDockingWindow::~TitledDockingWindow()
+    {
+        disposeOnce();
+    }
+
+    void TitledDockingWindow::dispose()
+    {
+        m_aToolbox.disposeAndClear();
+        m_aContentWindow.disposeAndClear();
+        SfxDockingWindow::dispose();
+    }
+
+    void TitledDockingWindow::SetTitle( const OUString& i_rTitle )
+    {
+        m_sTitle = i_rTitle;
+        Invalidate();
+    }
+
+
+    void TitledDockingWindow::SetText( const OUString& i_rText )
+    {
+        SfxDockingWindow::SetText( i_rText );
+        if ( m_sTitle.isEmpty() )
+            // our text is used as title, too => repaint
+            Invalidate();
+    }
+
+
+    void TitledDockingWindow::Resize()
+    {
+        SfxDockingWindow::Resize();
+        impl_scheduleLayout();
+    }
+
+
+    void TitledDockingWindow::impl_scheduleLayout()
+    {
+        m_bLayoutPending = true;
+    }
+
+
+    void TitledDockingWindow::impl_layout()
+    {
+        m_bLayoutPending = false;
+
+        m_aToolbox->ShowItem( 1, !IsFloatingMode() );
+
+        const Size aToolBoxSize( m_aToolbox->CalcWindowSizePixel() );
+        Size aWindowSize( GetOutputSizePixel() );
+
+        // position the tool box
+        m_nTitleBarHeight = GetSettings().GetStyleSettings().GetTitleHeight();
+        if ( aToolBoxSize.Height() > m_nTitleBarHeight )
+            m_nTitleBarHeight = aToolBoxSize.Height();
+        m_aToolbox->SetPosSizePixel(
+            Point(
+                aWindowSize.Width() - aToolBoxSize.Width(),
+                ( m_nTitleBarHeight - aToolBoxSize.Height() ) / 2
+            ),
+            aToolBoxSize
+        );
+
+        // Place the content window.
+        if ( m_nTitleBarHeight < aToolBoxSize.Height() )
+            m_nTitleBarHeight = aToolBoxSize.Height();
+        aWindowSize.AdjustHeight( -m_nTitleBarHeight );
+        m_aContentWindow->SetPosSizePixel(
+            Point( m_aBorder.Left(), m_nTitleBarHeight + m_aBorder.Top() ),
+            Size(
+                aWindowSize.Width() - m_aBorder.Left() - m_aBorder.Right(),
+                aWindowSize.Height() - m_aBorder.Top() - m_aBorder.Bottom()
+            )
+        );
+    }
+
+    void TitledDockingWindow::ApplySettings(vcl::RenderContext& rRenderContext)
+    {
+        const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
+
+        // Font
+        ApplyControlFont(rRenderContext, rStyleSettings.GetAppFont());
+
+        // Color
+        ApplyControlForeground(rRenderContext, rStyleSettings.GetButtonTextColor());
+        rRenderContext.SetTextFillColor();
+    }
+
+    void TitledDockingWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& i_rArea)
+    {
+        const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
+
+        if (m_bLayoutPending)
+            impl_layout();
+
+        SfxDockingWindow::Paint(rRenderContext, i_rArea);
+
+        rRenderContext.Push(PushFlags::FONT | PushFlags::FILLCOLOR | PushFlags::LINECOLOR);
+
+        rRenderContext.SetFillColor(rStyleSettings.GetDialogColor());
+        rRenderContext.SetLineColor();
+
+        // bold font
+        vcl::Font aFont(rRenderContext.GetFont());
+        aFont.SetWeight(WEIGHT_BOLD);
+        rRenderContext.SetFont(aFont);
+
+        // Set border values.
+        Size aWindowSize(GetOutputSizePixel());
+        int nOuterLeft = 0;
+        int nInnerLeft = nOuterLeft + m_aBorder.Left() - 1;
+        int nOuterRight = aWindowSize.Width() - 1;
+        int nInnerRight = nOuterRight - m_aBorder.Right() + 1;
+        int nInnerTop = m_nTitleBarHeight + m_aBorder.Top() - 1;
+        int nOuterBottom = aWindowSize.Height() - 1;
+        int nInnerBottom = nOuterBottom - m_aBorder.Bottom() + 1;
+
+        // Paint title bar background.
+        tools::Rectangle aTitleBarBox(tools::Rectangle(nOuterLeft, 0, nOuterRight, nInnerTop - 1));
+        rRenderContext.DrawRect(aTitleBarBox);
+
+        if (nInnerLeft > nOuterLeft)
+            rRenderContext.DrawRect(tools::Rectangle(nOuterLeft, nInnerTop, nInnerLeft, nInnerBottom));
+        if (nOuterRight > nInnerRight)
+            rRenderContext.DrawRect(tools::Rectangle(nInnerRight, nInnerTop, nOuterRight, nInnerBottom));
+        if (nInnerBottom < nOuterBottom)
+            rRenderContext.DrawRect(tools::Rectangle(nOuterLeft, nInnerBottom, nOuterRight, nOuterBottom));
+
+        // Paint bevel border.
+        rRenderContext.SetFillColor();
+        rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
+        if (m_aBorder.Top() > 0)
+            rRenderContext.DrawLine(Point(nInnerLeft, nInnerTop), Point(nInnerLeft, nInnerBottom));
+        if (m_aBorder.Left() > 0)
+            rRenderContext.DrawLine(Point(nInnerLeft, nInnerTop), Point(nInnerRight, nInnerTop));
+
+        rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
+        if (m_aBorder.Bottom() > 0)
+            rRenderContext.DrawLine(Point(nInnerRight, nInnerBottom), Point(nInnerLeft, nInnerBottom));
+        if (m_aBorder.Right() > 0)
+            rRenderContext.DrawLine(Point(nInnerRight, nInnerBottom), Point(nInnerRight, nInnerTop));
+
+        // Paint title bar text.
+        rRenderContext.SetLineColor(rStyleSettings.GetActiveTextColor());
+        aTitleBarBox.AdjustLeft(3 );
+        rRenderContext.DrawText(aTitleBarBox,
+                                !m_sTitle.isEmpty() ? m_sTitle : GetText(),
+                                DrawTextFlags::Left | DrawTextFlags::VCenter | DrawTextFlags::MultiLine | DrawTextFlags::WordBreak);
+
+        // Restore original values of the output device.
+        rRenderContext.Pop();
+    }
+
+
+    void TitledDockingWindow::impl_resetToolBox()
+    {
+        m_aToolbox->Clear();
+
+        // Get the closer bitmap and set it as right most button.
+        m_aToolbox->InsertItem(1, Image(StockImage::Yes, SFX_BMP_CLOSE_DOC));
+        m_aToolbox->SetQuickHelpText(1, SfxResId(STR_CLOSE_PANE));
+        m_aToolbox->ShowItem( 1 );
+    }
+
+
+    IMPL_LINK( TitledDockingWindow, OnToolboxItemSelected, ToolBox*, pToolBox, void )
+    {
+        const sal_uInt16 nId = pToolBox->GetCurItemId();
+
+        if ( nId == 1 )
+        {
+            // the closer
+            EndTracking();
+            const sal_uInt16 nChildWindowId( GetChildWindow_Impl()->GetType() );
+            const SfxBoolItem aVisibility( nChildWindowId, false );
+            GetBindings().GetDispatcher()->ExecuteList(
+                nChildWindowId,
+                SfxCallMode::ASYNCHRON | SfxCallMode::RECORD,
+                { &aVisibility }
+            );
+        }
+    }
+
+
+    void TitledDockingWindow::StateChanged( StateChangedType i_nType )
+    {
+        switch ( i_nType )
+        {
+            case StateChangedType::InitShow:
+                impl_scheduleLayout();
+                break;
+            default:;
+        }
+        SfxDockingWindow::StateChanged( i_nType );
+    }
+
+    void TitledDockingWindow::DataChanged( const DataChangedEvent& i_rDataChangedEvent )
+    {
+        SfxDockingWindow::DataChanged( i_rDataChangedEvent );
+
+        switch ( i_rDataChangedEvent.GetType() )
+        {
+            case DataChangedEventType::SETTINGS:
+                if ( !( i_rDataChangedEvent.GetFlags() & AllSettingsFlags::STYLE ) )
+                    break;
+                [[fallthrough]];
+            case DataChangedEventType::FONTS:
+            case DataChangedEventType::FONTSUBSTITUTION:
+            {
+                impl_scheduleLayout();
+                Invalidate();
+            }
+            break;
+            default: break;
+        }
+    }
+
+
+} // namespace sfx2
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/tplcitem.cxx b/sfx2/source/dialog/tplcitem.cxx
new file mode 100644
index 000000000..2a1a1d28a
--- /dev/null
+++ b/sfx2/source/dialog/tplcitem.cxx
@@ -0,0 +1,169 @@
+/* -*- 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/intitem.hxx>
+#include <vcl/svapp.hxx>
+#include <osl/diagnose.h>
+
+#include <sfx2/bindings.hxx>
+#include <sfx2/tplpitem.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <tplcitem.hxx>
+#include <templdgi.hxx>
+
+// Constructor
+
+SfxTemplateControllerItem::SfxTemplateControllerItem(
+        sal_uInt16 nSlotId,                 // ID
+        SfxCommonTemplateDialog_Impl &rDlg,  // Controller-Instance,
+                                             // which is assigned to this item.
+        SfxBindings &rBindings):
+    SfxControllerItem(nSlotId, rBindings),
+    rTemplateDlg(rDlg),
+    nWaterCanState(0xff),
+    nUserEventId(nullptr)
+{
+}
+
+SfxTemplateControllerItem::~SfxTemplateControllerItem()
+{
+    if(nUserEventId)
+        Application::RemoveUserEvent(nUserEventId);
+}
+
+
+// Notice about change of status, is  propagated through the Controller
+// passed on by the constructor
+
+void SfxTemplateControllerItem::StateChanged( sal_uInt16 nSID, SfxItemState eState,
+                                              const SfxPoolItem* pItem )
+{
+    switch(nSID)
+    {
+        case SID_STYLE_FAMILY1:
+        case SID_STYLE_FAMILY2:
+        case SID_STYLE_FAMILY3:
+        case SID_STYLE_FAMILY4:
+        case SID_STYLE_FAMILY5:
+        case SID_STYLE_FAMILY6:
+        {
+            bool bAvailable = SfxItemState::DEFAULT == eState;
+            if ( !bAvailable )
+                rTemplateDlg.SetFamilyState(GetId(), nullptr);
+            else {
+                const SfxTemplateItem *pStateItem = dynamic_cast< const SfxTemplateItem* >(pItem);
+                DBG_ASSERT(pStateItem != nullptr, "SfxTemplateItem expected");
+                rTemplateDlg.SetFamilyState( GetId(), pStateItem );
+            }
+            bool bDisable = eState == SfxItemState::DISABLED;
+            // Disable Family
+            sal_uInt16 nFamily = 0;
+            switch( GetId())
+            {
+                case SID_STYLE_FAMILY1:
+                    nFamily = 1; break;
+                case SID_STYLE_FAMILY2:
+                    nFamily = 2; break;
+                case SID_STYLE_FAMILY3:
+                    nFamily = 3; break;
+                case SID_STYLE_FAMILY4:
+                    nFamily = 4; break;
+                case SID_STYLE_FAMILY5:
+                    nFamily = 5; break;
+                case SID_STYLE_FAMILY6:
+                    nFamily = 6; break;
+
+                default: OSL_FAIL("unknown StyleFamily"); break;
+            }
+            rTemplateDlg.EnableFamilyItem( nFamily, !bDisable );
+            break;
+        }
+        case SID_STYLE_WATERCAN:
+        {
+            if ( eState == SfxItemState::DISABLED )
+                nWaterCanState = 0xff;
+            else if( eState == SfxItemState::DEFAULT )
+            {
+                const SfxBoolItem& rStateItem = dynamic_cast<const SfxBoolItem&>(*pItem);
+                nWaterCanState = rStateItem.GetValue() ? 1 : 0;
+            }
+            //not necessary if the last event is still on the way
+            if(!nUserEventId)
+                nUserEventId = Application::PostUserEvent( LINK(
+                            this, SfxTemplateControllerItem, SetWaterCanStateHdl_Impl ) );
+            break;
+        }
+        case SID_STYLE_EDIT:
+            rTemplateDlg.EnableEdit( SfxItemState::DISABLED != eState );
+            break;
+        case SID_STYLE_DELETE:
+            rTemplateDlg.EnableDel( SfxItemState::DISABLED != eState );
+            break;
+        case SID_STYLE_HIDE:
+            rTemplateDlg.EnableHide( SfxItemState::DISABLED != eState );
+            break;
+        case SID_STYLE_SHOW:
+            rTemplateDlg.EnableShow( SfxItemState::DISABLED != eState );
+            break;
+        case SID_STYLE_NEW_BY_EXAMPLE:
+
+            rTemplateDlg.EnableExample_Impl(nSID, SfxItemState::DISABLED != eState);
+            break;
+        case SID_STYLE_UPDATE_BY_EXAMPLE:
+        {
+            rTemplateDlg.EnableExample_Impl(nSID, eState != SfxItemState::DISABLED);
+            break;
+        }
+        case SID_STYLE_NEW:
+        {
+            rTemplateDlg.EnableNew( SfxItemState::DISABLED != eState );
+            break;
+        }
+        case SID_STYLE_DRAGHIERARCHIE:
+        {
+            rTemplateDlg.EnableTreeDrag( SfxItemState::DISABLED != eState );
+            break;
+        }
+        case SID_STYLE_FAMILY :
+        {
+            const SfxUInt16Item *pStateItem = dynamic_cast< const SfxUInt16Item* >(pItem);
+            if (pStateItem)
+            {
+                rTemplateDlg.SetFamily(static_cast<SfxStyleFamily>(pStateItem->GetValue()));
+            }
+            break;
+        }
+    }
+}
+
+IMPL_LINK_NOARG(SfxTemplateControllerItem, SetWaterCanStateHdl_Impl, void*, void)
+{
+    nUserEventId = nullptr;
+    std::unique_ptr<SfxBoolItem> pState;
+    switch(nWaterCanState)
+    {
+        case 0 :
+        case 1 :
+            pState.reset(new SfxBoolItem(SID_STYLE_WATERCAN, nWaterCanState != 0));
+        break;
+    }
+    rTemplateDlg.SetWaterCanState(pState.get());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/tplpitem.cxx b/sfx2/source/dialog/tplpitem.cxx
new file mode 100644
index 000000000..66f378620
--- /dev/null
+++ b/sfx2/source/dialog/tplpitem.cxx
@@ -0,0 +1,86 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sfx2/tplpitem.hxx>
+#include <com/sun/star/frame/status/Template.hpp>
+
+SfxPoolItem* SfxTemplateItem::CreateDefault() { return new SfxTemplateItem; }
+
+
+SfxTemplateItem::SfxTemplateItem() :
+    SfxFlagItem()
+{
+}
+
+SfxTemplateItem::SfxTemplateItem
+(
+    sal_uInt16 nWhichId,      // Slot-ID
+    const OUString& rStyle    // Name of the current Styles
+) : SfxFlagItem( nWhichId, static_cast<sal_uInt16>(SfxStyleSearchBits::All) ),
+    aStyle( rStyle )
+{
+}
+
+// op ==
+
+bool SfxTemplateItem::operator==( const SfxPoolItem& rCmp ) const
+{
+    return ( SfxFlagItem::operator==( rCmp ) &&
+             aStyle == static_cast<const SfxTemplateItem&>(rCmp).aStyle );
+}
+
+SfxTemplateItem* SfxTemplateItem::Clone( SfxItemPool *) const
+{
+    return new SfxTemplateItem(*this);
+}
+
+bool SfxTemplateItem::QueryValue( css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+    css::frame::status::Template aTemplate;
+
+    aTemplate.Value = static_cast<sal_uInt16>(GetValue());
+    aTemplate.StyleName = aStyle;
+    rVal <<= aTemplate;
+
+    return true;
+}
+
+
+bool SfxTemplateItem::PutValue( const css::uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+    css::frame::status::Template aTemplate;
+
+    if ( rVal >>= aTemplate )
+    {
+        SetValue( static_cast<SfxStyleSearchBits>(aTemplate.Value) );
+        aStyle = aTemplate.StyleName;
+        return true;
+    }
+
+    return false;
+}
+
+
+sal_uInt8 SfxTemplateItem::GetFlagCount() const
+{
+    return sizeof(sal_uInt16) * 8;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sfx2/source/dialog/versdlg.cxx b/sfx2/source/dialog/versdlg.cxx
new file mode 100644
index 000000000..68abca31b
--- /dev/null
+++ b/sfx2/source/dialog/versdlg.cxx
@@ -0,0 +1,472 @@
+/* -*- 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/document/XCmisDocument.hpp>
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/util/RevisionTag.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+
+#include <unotools/localedatawrapper.hxx>
+#include <svl/intitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/itemset.hxx>
+#include <unotools/useroptions.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/settings.hxx>
+#include <tools/datetime.hxx>
+#include <svtools/miscopt.hxx>
+
+#include <versdlg.hxx>
+#include <sfx2/strings.hrc>
+#include <sfx2/dialoghelper.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/sfxresid.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/objsh.hxx>
+#include <sfx2/sfxsids.hrc>
+#include <sfx2/dispatch.hxx>
+
+#include <sfx2/sfxuno.hxx>
+#include <memory>
+#include <vector>
+
+using namespace com::sun::star;
+
+struct SfxVersionInfo
+{
+    OUString                aName;
+    OUString                aComment;
+    OUString                aAuthor;
+    DateTime                aCreationDate;
+
+                            SfxVersionInfo();
+};
+
+class SfxVersionTableDtor
+{
+private:
+    std::vector<std::unique_ptr<SfxVersionInfo>> aTableList;
+public:
+    explicit                SfxVersionTableDtor( const uno::Sequence < util::RevisionTag >& rInfo );
+    explicit                SfxVersionTableDtor( const uno::Sequence < document::CmisVersion > & rInfo );
+                            SfxVersionTableDtor(const SfxVersionTableDtor&) = delete;
+    SfxVersionTableDtor&    operator=(const SfxVersionTableDtor&) = delete;
+
+    size_t                  size() const
+                            { return aTableList.size(); }
+
+    SfxVersionInfo*         at( size_t i ) const
+                            { return aTableList[ i ].get(); }
+};
+
+SfxVersionTableDtor::SfxVersionTableDtor( const uno::Sequence < util::RevisionTag >& rInfo )
+{
+    for ( const auto& rItem : rInfo )
+    {
+        std::unique_ptr<SfxVersionInfo> pInfo(new SfxVersionInfo);
+        pInfo->aName = rItem.Identifier;
+        pInfo->aComment = rItem.Comment;
+        pInfo->aAuthor = rItem.Author;
+
+        pInfo->aCreationDate = DateTime( rItem.TimeStamp );
+        aTableList.push_back( std::move(pInfo) );
+    }
+}
+
+SfxVersionTableDtor::SfxVersionTableDtor( const uno::Sequence < document::CmisVersion >& rInfo )
+{
+    for ( const auto& rItem : rInfo )
+    {
+        std::unique_ptr<SfxVersionInfo> pInfo(new SfxVersionInfo);
+        pInfo->aName = rItem.Id;
+        pInfo->aComment = rItem.Comment;
+        pInfo->aAuthor = rItem.Author;
+
+        pInfo->aCreationDate = DateTime( rItem.TimeStamp );
+        aTableList.push_back( std::move(pInfo) );
+    }
+}
+
+SfxVersionInfo::SfxVersionInfo()
+    : aCreationDate( DateTime::EMPTY )
+{
+}
+
+namespace
+{
+    void setColSizes(weld::TreeView& rVersionBox)
+    {
+        // recalculate the datetime column width
+        int nWidestTime(rVersionBox.get_pixel_size(getWidestTime(Application::GetSettings().GetLocaleDataWrapper())).Width());
+        int nW1 = rVersionBox.get_pixel_size(rVersionBox.get_column_title(1)).Width();
+
+        int nMax = std::max(nWidestTime, nW1) + 12; // max width + a little offset
+        const int nRest = rVersionBox.get_preferred_size().Width() - nMax;
+
+        std::set<OUString> aAuthors;
+        aAuthors.insert(SvtUserOptions().GetFullName());
+
+        for (int i = 0; i < rVersionBox.n_children(); ++i)
+        {
+            aAuthors.insert(reinterpret_cast<SfxVersionInfo*>(rVersionBox.get_id(i).toInt64())->aAuthor);
+        }
+
+        int nMaxAuthorWidth = nRest/4;
+        for (auto const& author : aAuthors)
+        {
+            nMaxAuthorWidth = std::max<int>(nMaxAuthorWidth, rVersionBox.get_pixel_size(author).Width());
+            if (nMaxAuthorWidth > nRest/2)
+            {
+                nMaxAuthorWidth = nRest/2;
+                break;
+            }
+        }
+
+        std::vector<int> aWidths;
+        aWidths.push_back(nMax);
+        aWidths.push_back(nMaxAuthorWidth);
+        rVersionBox.set_column_fixed_widths(aWidths);
+    }
+}
+
+SfxVersionDialog::SfxVersionDialog(weld::Window* pParent, SfxViewFrame* pVwFrame, bool bIsSaveVersionOnClose)
+    : SfxDialogController(pParent, "sfx/ui/versionsofdialog.ui", "VersionsOfDialog")
+    , m_pViewFrame(pVwFrame)
+    , m_bIsSaveVersionOnClose(bIsSaveVersionOnClose)
+    , m_xSaveButton(m_xBuilder->weld_button("save"))
+    , m_xSaveCheckBox(m_xBuilder->weld_check_button("always"))
+    , m_xOpenButton(m_xBuilder->weld_button("open"))
+    , m_xViewButton(m_xBuilder->weld_button("show"))
+    , m_xDeleteButton(m_xBuilder->weld_button("delete"))
+    , m_xCompareButton(m_xBuilder->weld_button("compare"))
+    , m_xCmisButton(m_xBuilder->weld_button("cmis"))
+    , m_xVersionBox(m_xBuilder->weld_tree_view("versions"))
+{
+    m_xVersionBox->set_size_request(m_xVersionBox->get_approximate_digit_width() * 90,
+                                    m_xVersionBox->get_height_rows(15));
+    setColSizes(*m_xVersionBox);
+
+    Link<weld::Button&,void> aClickLink = LINK( this, SfxVersionDialog, ButtonHdl_Impl );
+    m_xViewButton->connect_clicked( aClickLink );
+    m_xSaveButton->connect_clicked( aClickLink );
+    m_xDeleteButton->connect_clicked( aClickLink );
+    m_xCompareButton->connect_clicked( aClickLink );
+    m_xOpenButton->connect_clicked( aClickLink );
+    m_xSaveCheckBox->connect_clicked( aClickLink );
+    m_xCmisButton->connect_clicked( aClickLink );
+
+    m_xVersionBox->connect_changed( LINK( this, SfxVersionDialog, SelectHdl_Impl ) );
+    m_xVersionBox->connect_row_activated( LINK( this, SfxVersionDialog, DClickHdl_Impl ) );
+
+    m_xVersionBox->grab_focus();
+
+    // set dialog title (filename or docinfo title)
+    OUString sText = m_xDialog->get_title() +
+                    " " + m_pViewFrame->GetObjectShell()->GetTitle();
+    m_xDialog->set_title(sText);
+
+    Init_Impl();
+}
+
+static OUString ConvertWhiteSpaces_Impl( const OUString& rText )
+{
+    // converted linebreaks and tabs to blanks; it's necessary for the display
+    OUStringBuffer sConverted;
+    const sal_Unicode* pChars = rText.getStr();
+    while ( *pChars )
+    {
+        switch ( *pChars )
+        {
+            case '\n' :
+            case '\t' :
+                sConverted.append(' ');
+                break;
+
+            default:
+                sConverted.append(*pChars);
+        }
+
+        ++pChars;
+    }
+
+    return sConverted.makeStringAndClear();
+}
+
+void SfxVersionDialog::Init_Impl()
+{
+    SfxObjectShell *pObjShell = m_pViewFrame->GetObjectShell();
+    SfxMedium* pMedium = pObjShell->GetMedium();
+    uno::Sequence < util::RevisionTag > aVersions = pMedium->GetVersionList( true );
+    m_pTable.reset(new SfxVersionTableDtor( aVersions ));
+    m_xVersionBox->freeze();
+    for (size_t n = 0; n < m_pTable->size(); ++n)
+    {
+        SfxVersionInfo *pInfo = m_pTable->at( n );
+        OUString aEntry = formatTime(pInfo->aCreationDate, Application::GetSettings().GetLocaleDataWrapper());
+        m_xVersionBox->append(OUString::number(reinterpret_cast<sal_Int64>(pInfo)), aEntry);
+        auto nLastRow = m_xVersionBox->n_children() - 1;
+        m_xVersionBox->set_text(nLastRow, pInfo->aAuthor, 1);
+        m_xVersionBox->set_text(nLastRow, ConvertWhiteSpaces_Impl(pInfo->aComment), 2);
+    }
+    m_xVersionBox->thaw();
+
+    if (auto nCount = m_pTable->size())
+        m_xVersionBox->select(nCount - 1);
+
+    m_xSaveCheckBox->set_active(m_bIsSaveVersionOnClose);
+
+    bool bEnable = !pObjShell->IsReadOnly();
+    m_xSaveButton->set_sensitive( bEnable );
+    m_xSaveCheckBox->set_sensitive( bEnable );
+
+    m_xOpenButton->set_sensitive(false);
+    m_xViewButton->set_sensitive(false);
+    m_xDeleteButton->set_sensitive(false);
+    m_xCompareButton->set_sensitive(false);
+
+    SvtMiscOptions miscOptions;
+    if ( !miscOptions.IsExperimentalMode() )
+        m_xCmisButton->hide( );
+    uno::Reference<document::XCmisDocument> xCmisDoc(pObjShell->GetModel(), uno::UNO_QUERY);
+    if (xCmisDoc && xCmisDoc->isVersionable())
+        m_xCmisButton->set_sensitive(true);
+    else
+        m_xCmisButton->set_sensitive(false);
+
+    SelectHdl_Impl(*m_xVersionBox);
+}
+
+SfxVersionDialog::~SfxVersionDialog()
+{
+}
+
+void SfxVersionDialog::Open_Impl()
+{
+    SfxObjectShell *pObjShell = m_pViewFrame->GetObjectShell();
+
+    auto nPos = m_xVersionBox->get_selected_index();
+    SfxInt16Item aItem( SID_VERSION, nPos + 1);
+    SfxStringItem aTarget( SID_TARGETNAME, "_blank" );
+    SfxStringItem aReferer( SID_REFERER, "private:user" );
+    SfxStringItem aFile( SID_FILE_NAME, pObjShell->GetMedium()->GetName() );
+
+    uno::Sequence< beans::NamedValue > aEncryptionData;
+    if ( GetEncryptionData_Impl( pObjShell->GetMedium()->GetItemSet(), aEncryptionData ) )
+    {
+        // there is a password, it should be used during the opening
+        SfxUnoAnyItem aEncryptionDataItem( SID_ENCRYPTIONDATA, uno::makeAny( aEncryptionData ) );
+        m_pViewFrame->GetDispatcher()->ExecuteList(
+            SID_OPENDOC, SfxCallMode::ASYNCHRON,
+            { &aFile, &aItem, &aTarget, &aReferer, &aEncryptionDataItem });
+    }
+    else
+    {
+        m_pViewFrame->GetDispatcher()->ExecuteList(
+            SID_OPENDOC, SfxCallMode::ASYNCHRON,
+            { &aFile, &aItem, &aTarget, &aReferer });
+    }
+
+    m_xDialog->response(RET_OK);
+}
+
+IMPL_LINK_NOARG(SfxVersionDialog, DClickHdl_Impl, weld::TreeView&, bool)
+{
+    Open_Impl();
+    return true;
+}
+
+IMPL_LINK_NOARG(SfxVersionDialog, SelectHdl_Impl, weld::TreeView&, void)
+{
+    bool bEnable = m_xVersionBox->get_selected_index() != -1;
+    SfxObjectShell* pObjShell = m_pViewFrame->GetObjectShell();
+    m_xDeleteButton->set_sensitive(bEnable && !pObjShell->IsReadOnly());
+    m_xOpenButton->set_sensitive(bEnable);
+    m_xViewButton->set_sensitive(bEnable);
+
+    const SfxPoolItem *pDummy=nullptr;
+    m_pViewFrame->GetDispatcher()->QueryState( SID_DOCUMENT_MERGE, pDummy );
+    SfxItemState eState = m_pViewFrame->GetDispatcher()->QueryState( SID_DOCUMENT_COMPARE, pDummy );
+    m_xCompareButton->set_sensitive(bEnable && eState >= SfxItemState::DEFAULT);
+}
+
+IMPL_LINK(SfxVersionDialog, ButtonHdl_Impl, weld::Button&, rButton, void)
+{
+    SfxObjectShell *pObjShell = m_pViewFrame->GetObjectShell();
+
+    int nEntry = m_xVersionBox->get_selected_index();
+
+    if (&rButton == m_xSaveCheckBox.get())
+    {
+        m_bIsSaveVersionOnClose = m_xSaveCheckBox->get_active();
+    }
+    else if (&rButton == m_xSaveButton.get())
+    {
+        SfxVersionInfo aInfo;
+        aInfo.aAuthor = SvtUserOptions().GetFullName();
+        SfxViewVersionDialog_Impl aDlg(m_xDialog.get(), aInfo, true);
+        short nRet = aDlg.run();
+        if (nRet == RET_OK)
+        {
+            SfxStringItem aComment( SID_DOCINFO_COMMENTS, aInfo.aComment );
+            pObjShell->SetModified();
+            const SfxPoolItem* aItems[2];
+            aItems[0] = &aComment;
+            aItems[1] = nullptr;
+            m_pViewFrame->GetBindings().ExecuteSynchron( SID_SAVEDOC, aItems );
+            m_xVersionBox->freeze();
+            m_xVersionBox->clear();
+            m_xVersionBox->thaw();
+            Init_Impl();
+        }
+    }
+    else if (&rButton == m_xDeleteButton.get() && nEntry != -1)
+    {
+        SfxVersionInfo* pInfo = reinterpret_cast<SfxVersionInfo*>(m_xVersionBox->get_id(nEntry).toInt64());
+        pObjShell->GetMedium()->RemoveVersion_Impl(pInfo->aName);
+        pObjShell->SetModified();
+        m_xVersionBox->freeze();
+        m_xVersionBox->clear();
+        m_xVersionBox->thaw();
+        Init_Impl();
+    }
+    else if (&rButton == m_xOpenButton.get() && nEntry != -1)
+    {
+        Open_Impl();
+    }
+    else if (&rButton == m_xViewButton.get() && nEntry != -1)
+    {
+        SfxVersionInfo* pInfo = reinterpret_cast<SfxVersionInfo*>(m_xVersionBox->get_id(nEntry).toInt64());
+        SfxViewVersionDialog_Impl aDlg(m_xDialog.get(), *pInfo, false);
+        aDlg.run();
+    }
+    else if (&rButton == m_xCompareButton.get() && nEntry != -1)
+    {
+        SfxAllItemSet aSet( pObjShell->GetPool() );
+        aSet.Put(SfxInt16Item(SID_VERSION, nEntry + 1));
+        aSet.Put(SfxStringItem(SID_FILE_NAME, pObjShell->GetMedium()->GetName()));
+
+        SfxItemSet* pSet = pObjShell->GetMedium()->GetItemSet();
+        const SfxStringItem* pFilterItem = SfxItemSet::GetItem<SfxStringItem>(pSet, SID_FILTER_NAME, false);
+        const SfxStringItem* pFilterOptItem = SfxItemSet::GetItem<SfxStringItem>(pSet, SID_FILE_FILTEROPTIONS, false);
+        if ( pFilterItem )
+            aSet.Put( *pFilterItem );
+        if ( pFilterOptItem )
+            aSet.Put( *pFilterOptItem );
+
+        m_pViewFrame->GetDispatcher()->Execute( SID_DOCUMENT_COMPARE, SfxCallMode::ASYNCHRON, aSet );
+        m_xDialog->response(RET_CLOSE);
+    }
+    else if (&rButton == m_xCmisButton.get())
+    {
+        SfxCmisVersionsDialog aDlg(m_xDialog.get(), m_pViewFrame);
+        aDlg.run();
+    }
+}
+
+SfxViewVersionDialog_Impl::SfxViewVersionDialog_Impl(weld::Window *pParent, SfxVersionInfo& rInfo, bool bEdit)
+    : SfxDialogController(pParent, "sfx/ui/versioncommentdialog.ui", "VersionCommentDialog")
+    , m_rInfo(rInfo)
+    , m_xDateTimeText(m_xBuilder->weld_label("timestamp"))
+    , m_xSavedByText(m_xBuilder->weld_label("author"))
+    , m_xEdit(m_xBuilder->weld_text_view("textview"))
+    , m_xOKButton(m_xBuilder->weld_button("ok"))
+    , m_xCancelButton(m_xBuilder->weld_button("cancel"))
+    , m_xCloseButton(m_xBuilder->weld_button("close"))
+{
+    OUString sAuthor = rInfo.aAuthor.isEmpty() ? SfxResId(STR_NO_NAME_SET) : rInfo.aAuthor;
+
+    const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() );
+    m_xDateTimeText->set_label(m_xDateTimeText->get_label() + formatTime(rInfo.aCreationDate, rLocaleWrapper));
+    m_xSavedByText->set_label(m_xSavedByText->get_label() + sAuthor);
+    m_xEdit->set_text(rInfo.aComment);
+    m_xEdit->set_size_request(40 * m_xEdit->get_approximate_digit_width(),
+                              7 * m_xEdit->get_text_height());
+    m_xOKButton->connect_clicked(LINK(this, SfxViewVersionDialog_Impl, ButtonHdl));
+
+    if (!bEdit)
+    {
+        m_xOKButton->hide();
+        m_xCancelButton->hide();
+        m_xEdit->set_editable(false);
+        m_xDialog->set_title(SfxResId(STR_VIEWVERSIONCOMMENT));
+        m_xCloseButton->grab_focus();
+    }
+    else
+    {
+        m_xDateTimeText->hide();
+        m_xCloseButton->hide();
+        m_xEdit->grab_focus();
+    }
+}
+
+IMPL_LINK(SfxViewVersionDialog_Impl, ButtonHdl, weld::Button&, rButton, void)
+{
+    assert(&rButton == m_xOKButton.get());
+    (void)rButton;
+    m_rInfo.aComment = m_xEdit->get_text();
+    m_xDialog->response(RET_OK);
+}
+
+SfxCmisVersionsDialog::SfxCmisVersionsDialog(weld::Window* pParent, SfxViewFrame* pVwFrame)
+    : SfxDialogController(pParent, "sfx/ui/versionscmis.ui", "VersionsCmisDialog")
+    , m_pViewFrame(pVwFrame)
+    , m_xOpenButton(m_xBuilder->weld_button("open"))
+    , m_xViewButton(m_xBuilder->weld_button("show"))
+    , m_xDeleteButton(m_xBuilder->weld_button("delete"))
+    , m_xCompareButton(m_xBuilder->weld_button("compare"))
+{
+    m_xVersionBox->set_size_request(m_xVersionBox->get_approximate_digit_width() * 90,
+                                    m_xVersionBox->get_height_rows(15));
+    setColSizes(*m_xVersionBox);
+
+    m_xVersionBox->grab_focus();
+
+    OUString sText = m_xDialog->get_title() +
+                    " " + m_pViewFrame->GetObjectShell()->GetTitle();
+    m_xDialog->set_title(sText);
+
+    LoadVersions();
+}
+
+SfxCmisVersionsDialog::~SfxCmisVersionsDialog()
+{
+}
+
+void SfxCmisVersionsDialog::LoadVersions()
+{
+    SfxObjectShell *pObjShell = m_pViewFrame->GetObjectShell();
+    uno::Sequence < document::CmisVersion > aVersions = pObjShell->GetCmisVersions( );
+    m_pTable.reset(new SfxVersionTableDtor( aVersions ));
+    for (size_t n = 0; n < m_pTable->size(); ++n)
+    {
+        SfxVersionInfo *pInfo = m_pTable->at( n );
+        OUString aEntry = formatTime(pInfo->aCreationDate, Application::GetSettings().GetLocaleDataWrapper());
+        m_xVersionBox->append(OUString::number(reinterpret_cast<sal_Int64>(pInfo)), aEntry);
+        auto nLastRow = m_xVersionBox->n_children() - 1;
+        m_xVersionBox->set_text(nLastRow, pInfo->aAuthor, 1);
+        m_xVersionBox->set_text(nLastRow, ConvertWhiteSpaces_Impl(pInfo->aComment), 2);
+    }
+
+    if (auto nCount = m_pTable->size())
+        m_xVersionBox->select(nCount - 1);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */