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

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

20 files changed, 11174 insertions, 0 deletions

diff --git a/sw/source/uibase/utlui/attrdesc.cxx b/sw/source/uibase/utlui/attrdesc.cxx
new file mode 100644
index 000000000..a839c436f
--- /dev/null
+++ b/sw/source/uibase/utlui/attrdesc.cxx
@@ -0,0 +1,844 @@
+/* -*- 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 <i18nutil/unicode.hxx>
+#include <svl/itemiter.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/GraphicObject.hxx>
+
+#include <editeng/itemtype.hxx>
+#include <editeng/eerdll.hxx>
+#include <unotools/intlwrapper.hxx>
+#include <unotools/syslocale.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <fmtanchr.hxx>
+#include <fmtfsize.hxx>
+#include <fmtinfmt.hxx>
+#include <fchrfmt.hxx>
+#include <fmtautofmt.hxx>
+#include <fmtsrnd.hxx>
+#include <fmtornt.hxx>
+#include <fmtlsplt.hxx>
+#include <fmtrowsplt.hxx>
+#include <fmtpdsc.hxx>
+#include <fmtclds.hxx>
+#include <fmteiro.hxx>
+#include <fmturl.hxx>
+#include <fmthdft.hxx>
+#include <fmtcnct.hxx>
+#include <fmtline.hxx>
+#include <tgrditem.hxx>
+#include <hfspacingitem.hxx>
+#include <fmtruby.hxx>
+#include <paratr.hxx>
+#include <grfatr.hxx>
+#include <pagedesc.hxx>
+#include <charfmt.hxx>
+#include <strings.hrc>
+#include <fmtftntx.hxx>
+#include <fmtfollowtextflow.hxx>
+#include <libxml/xmlwriter.h>
+
+using namespace com::sun::star;
+
+
+// query the attribute descriptions
+void SwAttrSet::GetPresentation(
+        SfxItemPresentation ePres,
+        MapUnit eCoreMetric,
+        MapUnit ePresMetric,
+        OUString &rText ) const
+{
+    rText.clear();
+    OUString aStr;
+    if( Count() )
+    {
+        SfxItemIter aIter( *this );
+        const SfxPoolItem* pItem = aIter.GetCurItem();
+        const IntlWrapper aInt(SvtSysLocale().GetUILanguageTag());
+        do
+        {
+            pItem->GetPresentation(ePres, eCoreMetric, ePresMetric, aStr, aInt);
+            if( rText.getLength() && aStr.getLength() )
+                rText += ", ";
+            rText += aStr;
+            pItem = aIter.NextItem();
+        } while (pItem);
+    }
+}
+
+bool SwFormatCharFormat::GetPresentation
+(
+    SfxItemPresentation ePres,
+    MapUnit             eCoreUnit,
+    MapUnit             ePresUnit,
+    OUString&           rText,
+    const IntlWrapper& /*rIntl*/
+)   const
+{
+    const SwCharFormat *pCharFormat = GetCharFormat();
+    if ( pCharFormat )
+    {
+        OUString aStr;
+        pCharFormat->GetPresentation( ePres, eCoreUnit, ePresUnit, aStr );
+        rText = SwResId( STR_CHARFMT ) + "(" + aStr + ")";
+    }
+    else
+        rText = SwResId( STR_NO_CHARFMT );
+    return true;
+}
+
+bool SwFormatAutoFormat::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    rText.clear(); //TODO
+    return true;
+}
+
+bool SwFormatINetFormat::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    rText = GetValue();
+    return true;
+}
+
+bool SwFormatRuby::GetPresentation( SfxItemPresentation /*ePres*/,
+                                    MapUnit /*eCoreMetric*/, MapUnit /*ePresMetric*/,
+                                    OUString &rText, const IntlWrapper& /*rIntl*/ ) const
+{
+    rText.clear();
+    return true;
+}
+
+bool SwFormatDrop::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    rText.clear();
+    if ( GetLines() > 1 )
+    {
+        if ( GetChars() > 1 )
+        {
+            rText = OUString::number( GetChars() ) + " ";
+        }
+        rText += SwResId( STR_DROP_OVER ) +
+                " " +
+                OUString::number( GetLines() ) +
+                " " +
+                SwResId( STR_DROP_LINES );
+    }
+    else
+        rText = SwResId( STR_NO_DROP_LINES );
+    return true;
+}
+
+bool SwRegisterItem::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const char* pId = GetValue() ? STR_REGISTER_ON : STR_REGISTER_OFF;
+    rText = SwResId(pId);
+    return true;
+}
+
+bool SwNumRuleItem::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    if( !GetValue().isEmpty() )
+        rText = SwResId( STR_NUMRULE_ON ) +
+            "(" + GetValue() + ")";
+    else
+        rText = SwResId( STR_NUMRULE_OFF );
+    return true;
+}
+
+bool SwParaConnectBorderItem::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const char* pId = GetValue() ? STR_CONNECT_BORDER_ON : STR_CONNECT_BORDER_OFF;
+    rText = SwResId(pId);
+    return true;
+}
+
+// Frame attribute
+
+bool SwFormatFrameSize::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             eCoreUnit,
+    MapUnit             ePresUnit,
+    OUString&           rText,
+    const IntlWrapper&  rIntl
+)   const
+{
+    rText = SwResId( STR_FRM_WIDTH ) + " ";
+    if ( GetWidthPercent() )
+    {
+        rText += unicode::formatPercent(GetWidthPercent(),
+            Application::GetSettings().GetUILanguageTag());
+    }
+    else
+    {
+        rText += ::GetMetricText( GetWidth(), eCoreUnit, ePresUnit, &rIntl ) +
+            " " + ::EditResId( ::GetMetricId( ePresUnit ) );
+    }
+    if ( SwFrameSize::Variable != GetHeightSizeType() )
+    {
+        const char* pId = SwFrameSize::Fixed == m_eFrameHeightType ?
+                                STR_FRM_FIXEDHEIGHT : STR_FRM_MINHEIGHT;
+        rText += ", " + SwResId(pId) + " ";
+        if ( GetHeightPercent() )
+        {
+            rText += unicode::formatPercent(GetHeightPercent(),
+                Application::GetSettings().GetUILanguageTag());
+        }
+        else
+        {
+            rText = ::GetMetricText( GetHeight(), eCoreUnit, ePresUnit, &rIntl ) +
+                    " " + EditResId( ::GetMetricId( ePresUnit ) );
+        }
+    }
+    return true;
+}
+
+//Header for page formats.
+//Client of FrameFormat which describes the header.
+
+bool SwFormatHeader::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const char* pId = GetHeaderFormat() ? STR_HEADER : STR_NO_HEADER;
+    rText = SwResId(pId);
+    return true;
+}
+
+//Footer for page formats.
+//Client of FrameFormat which describes the footer.
+
+bool SwFormatFooter::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const char* pId = GetFooterFormat() ? STR_FOOTER : STR_NO_FOOTER;
+    rText = SwResId(pId);
+    return true;
+}
+
+bool SwFormatSurround::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const char* pId = nullptr;
+    switch ( GetValue() )
+    {
+        case css::text::WrapTextMode_NONE:
+            pId = STR_SURROUND_NONE;
+        break;
+        case css::text::WrapTextMode_THROUGH:
+            pId = STR_SURROUND_THROUGH;
+        break;
+        case css::text::WrapTextMode_PARALLEL:
+            pId = STR_SURROUND_PARALLEL;
+        break;
+        case css::text::WrapTextMode_DYNAMIC:
+            pId = STR_SURROUND_IDEAL;
+        break;
+        case css::text::WrapTextMode_LEFT:
+            pId = STR_SURROUND_LEFT;
+        break;
+        case css::text::WrapTextMode_RIGHT:
+            pId = STR_SURROUND_RIGHT;
+        break;
+        default:;//prevent warning
+    }
+    if (pId)
+        rText = SwResId(pId);
+
+    if ( IsAnchorOnly() )
+    {
+        rText += " " + SwResId( STR_SURROUND_ANCHORONLY );
+    }
+    return true;
+}
+
+//VertOrientation, how and by what orientate the FlyFrame in the vertical?
+
+bool SwFormatVertOrient::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             eCoreUnit,
+    MapUnit             ePresUnit,
+    OUString&           rText,
+    const IntlWrapper&  rIntl
+)   const
+{
+    const char* pId = nullptr;
+    switch ( GetVertOrient() )
+    {
+        case text::VertOrientation::NONE:
+        {
+            rText += SwResId( STR_POS_Y ) + " " +
+                    ::GetMetricText( GetPos(), eCoreUnit, ePresUnit, &rIntl ) +
+                    " " + EditResId( ::GetMetricId( ePresUnit ) );
+        }
+        break;
+        case text::VertOrientation::TOP:
+            pId = STR_VERT_TOP;
+            break;
+        case text::VertOrientation::CENTER:
+            pId = STR_VERT_CENTER;
+            break;
+        case text::VertOrientation::BOTTOM:
+            pId = STR_VERT_BOTTOM;
+            break;
+        case text::VertOrientation::LINE_TOP:
+            pId = STR_LINE_TOP;
+            break;
+        case text::VertOrientation::LINE_CENTER:
+            pId = STR_LINE_CENTER;
+            break;
+        case text::VertOrientation::LINE_BOTTOM:
+            pId = STR_LINE_BOTTOM;
+            break;
+        default:;//prevent warning
+    }
+    if (pId)
+        rText += SwResId(pId);
+    return true;
+}
+
+//HoriOrientation, how and by what orientate the FlyFrame in the horizontal?
+
+bool SwFormatHoriOrient::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             eCoreUnit,
+    MapUnit             ePresUnit,
+    OUString&           rText,
+    const IntlWrapper&  rIntl
+)   const
+{
+    const char* pId = nullptr;
+    switch ( GetHoriOrient() )
+    {
+        case text::HoriOrientation::NONE:
+        {
+            rText += SwResId( STR_POS_X ) + " " +
+                    ::GetMetricText( GetPos(), eCoreUnit, ePresUnit, &rIntl ) +
+                    " " + EditResId( ::GetMetricId( ePresUnit ) );
+        }
+        break;
+        case text::HoriOrientation::RIGHT:
+            pId = STR_HORI_RIGHT;
+        break;
+        case text::HoriOrientation::CENTER:
+            pId = STR_HORI_CENTER;
+        break;
+        case text::HoriOrientation::LEFT:
+            pId = STR_HORI_LEFT;
+        break;
+        case text::HoriOrientation::INSIDE:
+            pId = STR_HORI_INSIDE;
+        break;
+        case text::HoriOrientation::OUTSIDE:
+            pId = STR_HORI_OUTSIDE;
+        break;
+        case text::HoriOrientation::FULL:
+            pId = STR_HORI_FULL;
+        break;
+        default:;//prevent warning
+    }
+    if (pId)
+        rText += SwResId(pId);
+    return true;
+}
+
+// FlyAnchor, Anchor of the free-flying frame
+
+bool SwFormatAnchor::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const char* pId = nullptr;
+    switch ( GetAnchorId() )
+    {
+        case RndStdIds::FLY_AT_PARA:
+            pId = STR_FLY_AT_PARA;
+            break;
+        case RndStdIds::FLY_AS_CHAR:
+            pId = STR_FLY_AS_CHAR;
+            break;
+        case RndStdIds::FLY_AT_PAGE:
+            pId = STR_FLY_AT_PAGE;
+            break;
+        default:;//prevent warning
+    }
+    if (pId)
+        rText += SwResId(pId);
+    return true;
+}
+
+bool SwFormatPageDesc::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const SwPageDesc *pPageDesc = GetPageDesc();
+    if ( pPageDesc )
+        rText = pPageDesc->GetName();
+    else
+        rText = SwResId( STR_NO_PAGEDESC );
+    return true;
+}
+
+//The ColumnDescriptor
+
+bool SwFormatCol::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             eCoreUnit,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  rIntl
+)   const
+{
+    sal_uInt16 nCnt = GetNumCols();
+    if ( nCnt > 1 )
+    {
+        rText = OUString::number(nCnt) + " " + SwResId( STR_COLUMNS );
+        if ( COLADJ_NONE != GetLineAdj() )
+        {
+            const long nWdth = static_cast<long>(GetLineWidth());
+            rText += " " + SwResId( STR_LINE_WIDTH ) + " " +
+                    ::GetMetricText( nWdth, eCoreUnit,
+                                      MapUnit::MapPoint, &rIntl );
+        }
+    }
+    else
+        rText.clear();
+    return true;
+}
+
+//URL's and maps
+
+bool SwFormatURL::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    rText.clear();
+    if ( m_pMap )
+        rText += "Client-Map";
+    if ( !m_sURL.isEmpty() )
+    {
+        if ( m_pMap )
+            rText += " - ";
+        rText += "URL: " + m_sURL;
+        if ( m_bIsServerMap )
+            rText += " (Server-Map)";
+    }
+    if ( !m_sTargetFrameName.isEmpty() )
+    {
+        rText += ", Target: " + m_sTargetFrameName;
+    }
+    return true;
+}
+
+bool SwFormatEditInReadonly::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    rText.clear();
+    if ( GetValue() )
+        rText = SwResId(STR_EDIT_IN_READONLY);
+    return true;
+}
+
+void SwFormatEditInReadonly::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatEditInReadonly"));
+    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
+    xmlTextWriterEndElement(pWriter);
+}
+
+bool SwFormatLayoutSplit::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    if ( GetValue() )
+        rText = SwResId(STR_LAYOUT_SPLIT);
+    return true;
+}
+
+bool SwFormatRowSplit::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           /*rText*/,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    return false;
+}
+
+bool SwFormatFootnoteEndAtTextEnd::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           /*rText*/,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    return true;
+}
+
+bool SwFormatChain::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    if ( GetPrev() || GetNext() )
+    {
+        rText = SwResId(STR_CONNECT1);
+        if ( GetPrev() )
+        {
+            rText += GetPrev()->GetName();
+            if ( GetNext() )
+                rText += SwResId(STR_CONNECT2);
+        }
+        if ( GetNext() )
+            rText += GetNext()->GetName();
+    }
+    return true;
+}
+
+bool SwFormatLineNumber::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    if ( IsCount() )
+        rText += SwResId(STR_LINECOUNT);
+    else
+        rText += SwResId(STR_DONTLINECOUNT);
+    if ( GetStartValue() )
+    {
+        rText += " " + SwResId(STR_LINCOUNT_START) +
+                OUString::number( GetStartValue() );
+    }
+    return true;
+}
+
+bool SwTextGridItem::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           rText,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    const char* pId = nullptr;
+
+    switch ( GetGridType() )
+    {
+    case GRID_NONE :
+        pId = STR_GRID_NONE;
+        break;
+    case GRID_LINES_ONLY :
+        pId = STR_GRID_LINES_ONLY;
+        break;
+    case GRID_LINES_CHARS :
+        pId = STR_GRID_LINES_CHARS;
+        break;
+    }
+    if (pId)
+        rText += SwResId(pId);
+    return true;
+}
+
+bool SwHeaderAndFooterEatSpacingItem::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             /*eCoreUnit*/,
+    MapUnit             /*ePresUnit*/,
+    OUString&           /*rText*/,
+    const IntlWrapper&  /*rIntl*/
+)   const
+{
+    return false;
+}
+
+// Graphic attributes
+
+bool SwMirrorGrf::GetPresentation(
+    SfxItemPresentation /*ePres*/, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString& rText, const IntlWrapper& /*rIntl*/ ) const
+{
+    const char* pId;
+    switch( GetValue() )
+    {
+    case MirrorGraph::Dont:     pId = STR_NO_MIRROR;    break;
+    case MirrorGraph::Vertical: pId = STR_VERT_MIRROR;  break;
+    case MirrorGraph::Horizontal:  pId = STR_HORI_MIRROR;  break;
+    case MirrorGraph::Both:     pId = STR_BOTH_MIRROR;  break;
+    default:                    pId = nullptr;    break;
+    }
+    if (pId)
+    {
+        rText = SwResId(pId);
+        if (m_bGrfToggle)
+            rText += SwResId( STR_MIRROR_TOGGLE );
+    }
+    return true;
+}
+
+bool SwRotationGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    if( SfxItemPresentation::Complete == ePres )
+        rText = SwResId( STR_ROTATION );
+    else if( rText.getLength() )
+        rText.clear();
+    rText += OUString::number( GetValue() ) + "\xB0";
+    return true;
+}
+
+bool SwLuminanceGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    if( SfxItemPresentation::Complete == ePres )
+        rText = SwResId( STR_LUMINANCE );
+    else if( rText.getLength() )
+        rText.clear();
+    rText += unicode::formatPercent(GetValue(),
+                Application::GetSettings().GetUILanguageTag());
+    return true;
+}
+
+bool SwContrastGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    if( SfxItemPresentation::Complete == ePres )
+        rText = SwResId( STR_CONTRAST );
+    else if( rText.getLength() )
+        rText.clear();
+    rText += unicode::formatPercent(GetValue(),
+                Application::GetSettings().GetUILanguageTag());
+    return true;
+}
+
+bool SwChannelGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    if( SfxItemPresentation::Complete == ePres )
+    {
+        const char* pId;
+        switch ( Which() )
+        {
+        case RES_GRFATR_CHANNELR:   pId = STR_CHANNELR; break;
+        case RES_GRFATR_CHANNELG:   pId = STR_CHANNELG; break;
+        case RES_GRFATR_CHANNELB:   pId = STR_CHANNELB; break;
+        default:                    pId = nullptr; break;
+        }
+        if (pId)
+            rText = SwResId(pId);
+        else if( rText.getLength() )
+            rText.clear();
+    }
+    else if( rText.getLength() )
+        rText.clear();
+    rText += unicode::formatPercent(GetValue(),
+                Application::GetSettings().GetUILanguageTag());
+    return true;
+}
+
+bool SwGammaGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    OUStringBuffer aText;
+    if( SfxItemPresentation::Complete == ePres )
+        aText.append(SwResId(STR_GAMMA));
+    aText.append(unicode::formatPercent(GetValue(),
+        Application::GetSettings().GetUILanguageTag()));
+    rText = aText.makeStringAndClear();
+    return true;
+}
+
+bool SwInvertGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    rText.clear();
+    if( SfxItemPresentation::Complete == ePres )
+    {
+        const char* pId = GetValue() ? STR_INVERT : STR_INVERT_NOT;
+        rText = SwResId(pId);
+    }
+    return true;
+}
+
+bool SwTransparencyGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    if( SfxItemPresentation::Complete == ePres )
+        rText = SwResId( STR_TRANSPARENCY );
+    else if( rText.getLength() )
+        rText.clear();
+    rText += unicode::formatPercent(GetValue(),
+        Application::GetSettings().GetUILanguageTag());
+    return true;
+}
+
+bool SwDrawModeGrf::GetPresentation(
+    SfxItemPresentation ePres, MapUnit /*eCoreUnit*/, MapUnit /*ePresUnit*/,
+    OUString &rText, const IntlWrapper& /*rIntl*/) const
+{
+    rText.clear();
+    if( SfxItemPresentation::Complete == ePres )
+    {
+        const char* pId;
+        switch ( GetValue() )
+        {
+
+        case GraphicDrawMode::Greys:     pId = STR_DRAWMODE_GREY; break;
+        case GraphicDrawMode::Mono:      pId = STR_DRAWMODE_BLACKWHITE; break;
+        case GraphicDrawMode::Watermark: pId = STR_DRAWMODE_WATERMARK; break;
+        default:                         pId = STR_DRAWMODE_STD; break;
+        }
+        rText = SwResId( STR_DRAWMODE ) + SwResId(pId);
+    }
+    return true;
+}
+
+bool SwFormatFollowTextFlow::GetPresentation( SfxItemPresentation ePres,
+                                              MapUnit /*eCoreMetric*/,
+                                              MapUnit /*ePresMetric*/,
+                                              OUString &rText,
+                                              const IntlWrapper& /*rIntl*/ ) const
+{
+    rText.clear();
+    if( SfxItemPresentation::Complete == ePres )
+    {
+        const char* pId = GetValue() ? STR_FOLLOW_TEXT_FLOW : STR_DONT_FOLLOW_TEXT_FLOW;
+        rText = SwResId(pId);
+    }
+    return true;
+}
+
+void SwFormatFollowTextFlow::dumpAsXml(xmlTextWriterPtr pWriter) const
+{
+    xmlTextWriterStartElement(pWriter, BAD_CAST("SwFormatFollowTextFlow"));
+    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("whichId"), BAD_CAST(OString::number(Which()).getStr()));
+    xmlTextWriterWriteAttribute(pWriter, BAD_CAST("value"), BAD_CAST(OString::boolean(GetValue()).getStr()));
+    xmlTextWriterEndElement(pWriter);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/bookctrl.cxx b/sw/source/uibase/utlui/bookctrl.cxx
new file mode 100644
index 000000000..ea9c1d742
--- /dev/null
+++ b/sw/source/uibase/utlui/bookctrl.cxx
@@ -0,0 +1,141 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <swtypes.hxx>
+#include <strings.hrc>
+
+#include <svl/intitem.hxx>
+#include <svl/stritem.hxx>
+#include <svl/eitem.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/event.hxx>
+#include <vcl/status.hxx>
+#include <vcl/menu.hxx>
+#include <cmdid.h>
+#include <swmodule.hxx>
+#include <wrtsh.hxx>
+#include <IMark.hxx>
+#include <bookctrl.hxx>
+#include <map>
+
+SFX_IMPL_STATUSBAR_CONTROL( SwBookmarkControl, SfxStringItem );
+
+namespace {
+
+class BookmarkPopup_Impl : public PopupMenu
+{
+public:
+    BookmarkPopup_Impl();
+
+    sal_uInt16          GetCurId() const { return nCurId; }
+
+private:
+    sal_uInt16          nCurId;
+
+    virtual void    Select() override;
+};
+
+}
+
+BookmarkPopup_Impl::BookmarkPopup_Impl() :
+    PopupMenu(),
+    nCurId(USHRT_MAX)
+{
+}
+
+void BookmarkPopup_Impl::Select()
+{
+    nCurId = GetCurItemId();
+}
+
+SwBookmarkControl::SwBookmarkControl( sal_uInt16 _nSlotId,
+                                      sal_uInt16 _nId,
+                                      StatusBar& rStb ) :
+    SfxStatusBarControl( _nSlotId, _nId, rStb )
+{
+}
+
+SwBookmarkControl::~SwBookmarkControl()
+{
+}
+
+void SwBookmarkControl::StateChanged(
+    sal_uInt16 /*nSID*/, SfxItemState eState, const SfxPoolItem* pState )
+{
+    if( eState != SfxItemState::DEFAULT || pState->IsVoidItem() )
+        GetStatusBar().SetItemText( GetId(), OUString() );
+    else if (const SfxStringItem* pStringItem = dynamic_cast<const SfxStringItem*>(pState))
+    {
+        sPageNumber = pStringItem->GetValue();
+        GetStatusBar().SetItemText(GetId(), sPageNumber);
+    }
+    else if (const SfxBoolItem* pBoolItem = dynamic_cast<const SfxBoolItem*>(pState))
+    {
+        if (pBoolItem->GetValue()) // Indicates whether to show extended tooltip
+            GetStatusBar().SetQuickHelpText(GetId(), SwResId(STR_BOOKCTRL_HINT_EXTENDED));
+        else
+            GetStatusBar().SetQuickHelpText(GetId(), SwResId(STR_BOOKCTRL_HINT));
+    }
+
+}
+
+void SwBookmarkControl::Paint( const UserDrawEvent&  )
+{
+}
+
+void SwBookmarkControl::Command( const CommandEvent& rCEvt )
+{
+    if ( rCEvt.GetCommand() == CommandEventId::ContextMenu &&
+            !GetStatusBar().GetItemText( GetId() ).isEmpty() )
+    {
+        ScopedVclPtrInstance<BookmarkPopup_Impl> aPop;
+        SwWrtShell* pWrtShell = ::GetActiveWrtShell();
+        if( pWrtShell && pWrtShell->getIDocumentMarkAccess()->getAllMarksCount() > 0 )
+        {
+            IDocumentMarkAccess* const pMarkAccess = pWrtShell->getIDocumentMarkAccess();
+            IDocumentMarkAccess::const_iterator_t ppBookmarkStart = pMarkAccess->getBookmarksBegin();
+            sal_uInt16 nPopupId = 1;
+            std::map<sal_Int32, sal_uInt16> aBookmarkIdx;
+            for(IDocumentMarkAccess::const_iterator_t ppBookmark = ppBookmarkStart;
+                ppBookmark != pMarkAccess->getBookmarksEnd();
+                ++ppBookmark)
+            {
+                if(IDocumentMarkAccess::MarkType::BOOKMARK == IDocumentMarkAccess::GetType(**ppBookmark))
+                {
+                    aPop->InsertItem( nPopupId, (*ppBookmark)->GetName() );
+                    aBookmarkIdx[nPopupId] = static_cast<sal_uInt16>(ppBookmark - ppBookmarkStart);
+                    nPopupId++;
+                }
+            }
+            aPop->Execute( &GetStatusBar(), rCEvt.GetMousePosPixel());
+            sal_uInt16 nCurrId = aPop->GetCurId();
+            if( nCurrId != USHRT_MAX)
+            {
+                SfxUInt16Item aBookmark( FN_STAT_BOOKMARK, aBookmarkIdx[nCurrId] );
+                SfxViewFrame::Current()->GetDispatcher()->ExecuteList(FN_STAT_BOOKMARK,
+                    SfxCallMode::ASYNCHRON|SfxCallMode::RECORD,
+                    { &aBookmark });
+            }
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/condedit.cxx b/sw/source/uibase/utlui/condedit.cxx
new file mode 100644
index 000000000..df50c63ac
--- /dev/null
+++ b/sw/source/uibase/utlui/condedit.cxx
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <condedit.hxx>
+#include <svx/dbaexchange.hxx>
+
+using namespace ::svx;
+using namespace ::com::sun::star::uno;
+
+ConditionEdit::ConditionEdit(std::unique_ptr<weld::Entry> xControl)
+    : m_xControl(std::move(xControl))
+    , m_aDropTargetHelper(*this)
+    , bBrackets(true)
+    , bEnableDrop(true)
+{
+}
+
+sal_Int8 ConditionEditDropTarget::AcceptDrop( const AcceptDropEvent& /*rEvt*/ )
+{
+    return OColumnTransferable::canExtractColumnDescriptor
+        ( GetDataFlavorExVector(),
+                                ColumnTransferFormatFlags::COLUMN_DESCRIPTOR )
+                ? DND_ACTION_COPY
+                : DND_ACTION_NONE;
+}
+
+ConditionEditDropTarget::ConditionEditDropTarget(ConditionEdit& rEdit)
+    : DropTargetHelper(rEdit.get_widget().get_drop_target())
+    , m_rEdit(rEdit)
+{
+}
+
+sal_Int8 ConditionEditDropTarget::ExecuteDrop( const ExecuteDropEvent& rEvt )
+{
+    sal_Int8 nRet = DND_ACTION_NONE;
+    if (m_rEdit.GetDropEnable())
+    {
+        TransferableDataHelper aData( rEvt.maDropEvent.Transferable );
+
+        const DataFlavorExVector& rVector = aData.GetDataFlavorExVector();
+        if (OColumnTransferable::canExtractColumnDescriptor(rVector, ColumnTransferFormatFlags::COLUMN_DESCRIPTOR))
+        {
+            ODataAccessDescriptor aColDesc = OColumnTransferable::extractColumnDescriptor(
+                                                                aData);
+            OUString sDBName;
+            bool bBrackets = m_rEdit.GetBrackets();
+            if (bBrackets)
+                sDBName += "[";
+            OUString sTmp = aColDesc.getDataSource();
+            sDBName += sTmp + ".";
+
+            aColDesc[DataAccessDescriptorProperty::Command] >>= sTmp;
+            sDBName += sTmp + ".";
+
+            aColDesc[DataAccessDescriptorProperty::ColumnName] >>= sTmp;
+            sDBName += sTmp;
+            if (bBrackets)
+                sDBName += "]";
+
+            m_rEdit.get_widget().set_text( sDBName );
+            nRet = DND_ACTION_COPY;
+        }
+    }
+    return nRet;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/content.cxx b/sw/source/uibase/utlui/content.cxx
new file mode 100644
index 000000000..4729818da
--- /dev/null
+++ b/sw/source/uibase/utlui/content.cxx
@@ -0,0 +1,4033 @@
+/* -*- 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 <svl/urlbmk.hxx>
+#include <osl/thread.h>
+#include <sal/log.hxx>
+#include <tools/urlobj.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/event.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <o3tl/enumrange.hxx>
+#include <o3tl/sorted_vector.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/help.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/weldutils.hxx>
+#include <sot/formats.hxx>
+#include <uiitems.hxx>
+#include <fmtinfmt.hxx>
+#include <txtinet.hxx>
+#include <fmtfld.hxx>
+#include <swmodule.hxx>
+#include <wrtsh.hxx>
+#include <view.hxx>
+#include <docsh.hxx>
+#include <drawdoc.hxx>
+#include <content.hxx>
+#include <frmfmt.hxx>
+#include <fldbas.hxx>
+#include <IMark.hxx>
+#include <section.hxx>
+#include <tox.hxx>
+#include <navipi.hxx>
+#include <navicont.hxx>
+#include <navicfg.hxx>
+#include <edtwin.hxx>
+#include <doc.hxx>
+#include <IDocumentSettingAccess.hxx>
+#include <IDocumentDrawModelAccess.hxx>
+#include <IDocumentOutlineNodes.hxx>
+#include <unotxvw.hxx>
+#include <cmdid.h>
+#include <helpids.h>
+#include <strings.hrc>
+#include <com/sun/star/text/XTextSectionsSupplier.hpp>
+#include <com/sun/star/text/XTextGraphicObjectsSupplier.hpp>
+#include <com/sun/star/text/XTextTablesSupplier.hpp>
+#include <com/sun/star/text/XDocumentIndexesSupplier.hpp>
+#include <com/sun/star/text/XDocumentIndex.hpp>
+#include <com/sun/star/text/XBookmarksSupplier.hpp>
+#include <com/sun/star/text/XTextEmbeddedObjectsSupplier.hpp>
+#include <com/sun/star/text/XTextFramesSupplier.hpp>
+#include <dcontact.hxx>
+#include <svx/svdpage.hxx>
+#include <svx/svdview.hxx>
+#include <SwRewriter.hxx>
+#include <hints.hxx>
+#include <numrule.hxx>
+#include <swundo.hxx>
+#include <ndtxt.hxx>
+#include <PostItMgr.hxx>
+#include <postithelper.hxx>
+
+#include <swabstdlg.hxx>
+#include <bitmaps.hlst>
+
+#include <navmgr.hxx>
+#include <AnnotationWin.hxx>
+#include <memory>
+
+#include <fmtcntnt.hxx>
+#include <docstat.hxx>
+
+#define CTYPE_CNT   0
+#define CTYPE_CTT   1
+
+using namespace ::std;
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::text;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::container;
+
+namespace {
+
+constexpr char NAVI_BOOKMARK_DELIM = '\x01';
+
+}
+
+class SwContentArr
+    : public o3tl::sorted_vector<std::unique_ptr<SwContent>, o3tl::less_uniqueptr_to<SwContent>,
+                o3tl::find_partialorder_ptrequals>
+{
+};
+
+namespace
+{
+    bool lcl_IsContent(const weld::TreeIter& rEntry, const weld::TreeView& rTreeView)
+    {
+        return reinterpret_cast<const SwTypeNumber*>(rTreeView.get_id(rEntry).toInt64())->GetTypeId() == CTYPE_CNT;
+    }
+
+    bool lcl_IsContentType(const weld::TreeIter& rEntry, const weld::TreeView& rTreeView)
+    {
+        return reinterpret_cast<const SwTypeNumber*>(rTreeView.get_id(rEntry).toInt64())->GetTypeId() == CTYPE_CTT;
+    }
+
+    bool lcl_FindShell(SwWrtShell const * pShell)
+    {
+        bool bFound = false;
+        SwView *pView = SwModule::GetFirstView();
+        while (pView)
+        {
+            if(pShell == &pView->GetWrtShell())
+            {
+                bFound = true;
+                break;
+            }
+            pView = SwModule::GetNextView(pView);
+        }
+        return bFound;
+    }
+
+    bool lcl_IsUiVisibleBookmark(const ::sw::mark::IMark* pMark)
+    {
+        return IDocumentMarkAccess::GetType(*pMark) == IDocumentMarkAccess::MarkType::BOOKMARK;
+    }
+
+    size_t lcl_InsertURLFieldContent(
+        SwContentArr *pMember,
+        SwWrtShell* pWrtShell,
+        const SwContentType *pCntType)
+    {
+        SwGetINetAttrs aArr;
+        pWrtShell->GetINetAttrs( aArr );
+        const SwGetINetAttrs::size_type nCount {aArr.size()};
+        for( SwGetINetAttrs::size_type n = 0; n < nCount; ++n )
+        {
+            SwGetINetAttr* p = &aArr[ n ];
+            std::unique_ptr<SwURLFieldContent> pCnt(new SwURLFieldContent(
+                                pCntType,
+                                p->sText,
+                                INetURLObject::decode(
+                                    p->rINetAttr.GetINetFormat().GetValue(),
+                                    INetURLObject::DecodeMechanism::Unambiguous ),
+                                &p->rINetAttr,
+                                n ));
+            pMember->insert( std::move(pCnt) );
+        }
+        return nCount;
+    }
+}
+
+// Content, contains names and reference at the content type.
+
+SwContent::SwContent(const SwContentType* pCnt, const OUString& rName, long nYPos) :
+    SwTypeNumber(CTYPE_CNT),
+    pParent(pCnt),
+    sContentName(rName),
+    nYPosition(nYPos),
+    bInvisible(false)
+{
+}
+
+
+SwTypeNumber::~SwTypeNumber()
+{
+}
+
+bool SwContent::IsProtect() const
+{
+    return false;
+}
+
+bool SwPostItContent::IsProtect() const
+{
+    return pField->IsProtect();
+}
+
+bool SwURLFieldContent::IsProtect() const
+{
+    return pINetAttr->IsProtect();
+}
+
+SwGraphicContent::~SwGraphicContent()
+{
+}
+
+SwTOXBaseContent::~SwTOXBaseContent()
+{
+}
+
+static const char* STR_CONTENT_TYPE_ARY[] =
+{
+    STR_CONTENT_TYPE_OUTLINE,
+    STR_CONTENT_TYPE_TABLE,
+    STR_CONTENT_TYPE_FRAME,
+    STR_CONTENT_TYPE_GRAPHIC,
+    STR_CONTENT_TYPE_OLE,
+    STR_CONTENT_TYPE_BOOKMARK,
+    STR_CONTENT_TYPE_REGION,
+    STR_CONTENT_TYPE_URLFIELD,
+    STR_CONTENT_TYPE_REFERENCE,
+    STR_CONTENT_TYPE_INDEX,
+    STR_CONTENT_TYPE_POSTIT,
+    STR_CONTENT_TYPE_DRAWOBJECT
+};
+
+static const char* STR_CONTENT_TYPE_SINGLE_ARY[] =
+{
+    STR_CONTENT_TYPE_SINGLE_OUTLINE,
+    STR_CONTENT_TYPE_SINGLE_TABLE,
+    STR_CONTENT_TYPE_SINGLE_FRAME,
+    STR_CONTENT_TYPE_SINGLE_GRAPHIC,
+    STR_CONTENT_TYPE_SINGLE_OLE,
+    STR_CONTENT_TYPE_SINGLE_BOOKMARK,
+    STR_CONTENT_TYPE_SINGLE_REGION,
+    STR_CONTENT_TYPE_SINGLE_URLFIELD,
+    STR_CONTENT_TYPE_SINGLE_REFERENCE,
+    STR_CONTENT_TYPE_SINGLE_INDEX,
+    STR_CONTENT_TYPE_SINGLE_POSTIT,
+    STR_CONTENT_TYPE_SINGLE_DRAWOBJECT
+};
+
+namespace
+{
+    bool checkVisibilityChanged(
+        const SwContentArr& rSwContentArrA,
+        const SwContentArr& rSwContentArrB)
+    {
+        if(rSwContentArrA.size() != rSwContentArrB.size())
+        {
+            return true;
+        }
+
+        for(size_t a(0); a < rSwContentArrA.size(); a++)
+        {
+            if(rSwContentArrA[a]->IsInvisible() != rSwContentArrB[a]->IsInvisible())
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+} // end of anonymous namespace
+
+SwContentType::SwContentType(SwWrtShell* pShell, ContentTypeId nType, sal_uInt8 nLevel) :
+    SwTypeNumber(CTYPE_CTT),
+    m_pWrtShell(pShell),
+    m_sContentTypeName(SwResId(STR_CONTENT_TYPE_ARY[static_cast<int>(nType)])),
+    m_sSingleContentTypeName(SwResId(STR_CONTENT_TYPE_SINGLE_ARY[static_cast<int>(nType)])),
+    m_nMemberCount(0),
+    m_nContentType(nType),
+    m_nOutlineLevel(nLevel),
+    m_bDataValid(false),
+    m_bEdit(false),
+    m_bDelete(true)
+{
+    Init();
+}
+
+void SwContentType::Init(bool* pbInvalidateWindow)
+{
+    // if the MemberCount is changing ...
+    size_t nOldMemberCount = m_nMemberCount;
+    m_nMemberCount = 0;
+    switch(m_nContentType)
+    {
+        case ContentTypeId::OUTLINE   :
+        {
+            m_sTypeToken = "outline";
+            m_nMemberCount = m_pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNodesCount();
+            if (m_nMemberCount < MAXLEVEL)
+            {
+                const size_t nOutlineCount = m_nMemberCount;
+                for(size_t j = 0; j < nOutlineCount; ++j)
+                {
+                    if (m_pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineLevel(j) > m_nOutlineLevel
+                        || !m_pWrtShell->getIDocumentOutlineNodesAccess()->isOutlineInLayout(j, *m_pWrtShell->GetLayout()))
+                    {
+                        m_nMemberCount --;
+                    }
+                }
+            }
+        }
+        break;
+
+        case ContentTypeId::TABLE     :
+            m_sTypeToken = "table";
+            m_nMemberCount = m_pWrtShell->GetTableFrameFormatCount(true);
+            m_bEdit = true;
+        break;
+
+        case ContentTypeId::FRAME     :
+        case ContentTypeId::GRAPHIC   :
+        case ContentTypeId::OLE       :
+        {
+            FlyCntType eType = FLYCNTTYPE_FRM;
+            m_sTypeToken = "frame";
+            if(m_nContentType == ContentTypeId::OLE)
+            {
+                eType = FLYCNTTYPE_OLE;
+                m_sTypeToken = "ole";
+            }
+            else if(m_nContentType == ContentTypeId::GRAPHIC)
+            {
+                eType = FLYCNTTYPE_GRF;
+                m_sTypeToken = "graphic";
+            }
+            m_nMemberCount = m_pWrtShell->GetFlyCount(eType, /*bIgnoreTextBoxes=*/true);
+            m_bEdit = true;
+        }
+        break;
+        case ContentTypeId::BOOKMARK:
+        {
+            IDocumentMarkAccess* const pMarkAccess = m_pWrtShell->getIDocumentMarkAccess();
+            m_nMemberCount = count_if(
+                pMarkAccess->getBookmarksBegin(),
+                pMarkAccess->getBookmarksEnd(),
+                &lcl_IsUiVisibleBookmark);
+            m_sTypeToken.clear();
+            const bool bProtectedBM = m_pWrtShell->getIDocumentSettingAccess().get(DocumentSettingId::PROTECT_BOOKMARKS);
+            m_bEdit = !bProtectedBM;
+            m_bDelete = !bProtectedBM;
+        }
+        break;
+        case ContentTypeId::REGION :
+        {
+            std::unique_ptr<SwContentArr> pOldMember;
+            if(!m_pMember)
+                m_pMember.reset( new SwContentArr );
+            else if(!m_pMember->empty())
+            {
+                pOldMember = std::move(m_pMember);
+                m_pMember.reset( new SwContentArr );
+            }
+            const Point aNullPt;
+            m_nMemberCount = m_pWrtShell->GetSectionFormatCount();
+            for(size_t i = 0; i < m_nMemberCount; ++i)
+            {
+                const SwSectionFormat* pFormat;
+                SectionType eTmpType;
+                if( (pFormat = &m_pWrtShell->GetSectionFormat(i))->IsInNodesArr() &&
+                (eTmpType = pFormat->GetSection()->GetType()) != SectionType::ToxContent
+                && SectionType::ToxHeader != eTmpType )
+                {
+                    const OUString& rSectionName =
+                        pFormat->GetSection()->GetSectionName();
+                    sal_uInt8 nLevel = 0;
+                    SwSectionFormat* pParentFormat = pFormat->GetParent();
+                    while(pParentFormat)
+                    {
+                        nLevel++;
+                        pParentFormat = pParentFormat->GetParent();
+                    }
+
+                    std::unique_ptr<SwContent> pCnt(new SwRegionContent(this, rSectionName,
+                            nLevel,
+                            pFormat->FindLayoutRect( false, &aNullPt ).Top()));
+
+                    SwPtrMsgPoolItem aAskItem( RES_CONTENT_VISIBLE, nullptr );
+                    if( !pFormat->GetInfo( aAskItem ) &&
+                        !aAskItem.pObject )     // not visible
+                        pCnt->SetInvisible();
+                    m_pMember->insert(std::move(pCnt));
+                }
+            }
+            m_nMemberCount = m_pMember->size();
+            m_sTypeToken = "region";
+            m_bEdit = true;
+            m_bDelete = false;
+            if(pOldMember)
+            {
+                if(nullptr != pbInvalidateWindow)
+                {
+                    // need to check visibility (and equal entry number) after
+                    // creation due to a sorted list being used here (before,
+                    // entries with same index were compared already at creation
+                    // time what worked before a sorted list was used)
+                    *pbInvalidateWindow = checkVisibilityChanged(
+                        *pOldMember,
+                        *m_pMember);
+                }
+            }
+        }
+        break;
+        case ContentTypeId::INDEX:
+        {
+            m_nMemberCount = m_pWrtShell->GetTOXCount();
+            m_bEdit = true;
+            m_bDelete = false;
+        }
+        break;
+        case ContentTypeId::REFERENCE:
+        {
+            m_nMemberCount = m_pWrtShell->GetRefMarks();
+            m_bDelete = false;
+        }
+        break;
+        case ContentTypeId::URLFIELD:
+        {
+            m_nMemberCount = 0;
+            if(!m_pMember)
+                m_pMember.reset( new SwContentArr );
+            else
+                m_pMember->clear();
+
+            m_nMemberCount = lcl_InsertURLFieldContent(m_pMember.get(), m_pWrtShell, this);
+
+            m_bEdit = true;
+            nOldMemberCount = m_nMemberCount;
+            m_bDelete = true;
+        }
+        break;
+        case ContentTypeId::POSTIT:
+        {
+            m_nMemberCount = 0;
+            if(!m_pMember)
+                m_pMember.reset( new SwContentArr );
+            else
+                m_pMember->clear();
+
+            SwPostItMgr* aMgr = m_pWrtShell->GetView().GetPostItMgr();
+            if (aMgr)
+            {
+                for(SwPostItMgr::const_iterator i = aMgr->begin(); i != aMgr->end(); ++i)
+                {
+                    if (const SwFormatField* pFormatField = dynamic_cast<const SwFormatField *>((*i)->GetBroadcaster())) // SwPostit
+                    {
+                        if (pFormatField->GetTextField() && pFormatField->IsFieldInDoc() &&
+                            (*i)->mLayoutStatus!=SwPostItHelper::INVISIBLE )
+                        {
+                            OUString sEntry = pFormatField->GetField()->GetPar2();
+                            sEntry = RemoveNewline(sEntry);
+                            std::unique_ptr<SwPostItContent> pCnt(new SwPostItContent(
+                                                this,
+                                                sEntry,
+                                                pFormatField,
+                                                m_nMemberCount));
+                            m_pMember->insert(std::move(pCnt));
+                            m_nMemberCount++;
+                        }
+                    }
+                }
+            }
+            m_sTypeToken.clear();
+            m_bEdit = true;
+            nOldMemberCount = m_nMemberCount;
+        }
+        break;
+        case ContentTypeId::DRAWOBJECT:
+        {
+            m_sTypeToken.clear();
+            m_bEdit = true;
+            m_nMemberCount = 0;
+            SwDrawModel* pModel = m_pWrtShell->getIDocumentDrawModelAccess().GetDrawModel();
+            if(pModel)
+            {
+                SdrPage* pPage = pModel->GetPage(0);
+                const size_t nCount = pPage->GetObjCount();
+                for( size_t i=0; i<nCount; ++i )
+                {
+                    SdrObject* pTemp = pPage->GetObj(i);
+                    // #i51726# - all drawing objects can be named now
+                    if (!pTemp->GetName().isEmpty())
+                        m_nMemberCount++;
+                }
+            }
+        }
+        break;
+        default: break;
+    }
+    // ... then, the data can also no longer be valid,
+    // apart from those which have already been corrected,
+    // then nOldMemberCount is nevertheless not so old.
+    if( nOldMemberCount != m_nMemberCount )
+        m_bDataValid = false;
+}
+
+SwContentType::~SwContentType()
+{
+}
+
+const SwContent* SwContentType::GetMember(size_t nIndex)
+{
+    if(!m_bDataValid || !m_pMember)
+    {
+        FillMemberList();
+    }
+    if(nIndex < m_pMember->size())
+        return (*m_pMember)[nIndex].get();
+
+    return nullptr;
+}
+
+void SwContentType::Invalidate()
+{
+    m_bDataValid = false;
+}
+
+void SwContentType::FillMemberList(bool* pbLevelOrVisibilityChanged)
+{
+    std::unique_ptr<SwContentArr> pOldMember;
+    size_t nOldMemberCount = 0;
+    SwPtrMsgPoolItem aAskItem( RES_CONTENT_VISIBLE, nullptr );
+    if(m_pMember && pbLevelOrVisibilityChanged)
+    {
+        pOldMember = std::move(m_pMember);
+        nOldMemberCount = pOldMember->size();
+        m_pMember.reset( new SwContentArr );
+        *pbLevelOrVisibilityChanged = false;
+    }
+    else if(!m_pMember)
+        m_pMember.reset( new SwContentArr );
+    else
+        m_pMember->clear();
+    switch(m_nContentType)
+    {
+        case ContentTypeId::OUTLINE   :
+        {
+            const size_t nOutlineCount = m_nMemberCount =
+                m_pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNodesCount();
+
+            size_t nPos = 0;
+            for (size_t i = 0; i < nOutlineCount; ++i)
+            {
+                const sal_uInt8 nLevel = m_pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineLevel(i);
+                if(nLevel >= m_nOutlineLevel )
+                    m_nMemberCount--;
+                else
+                {
+                    if (!m_pWrtShell->getIDocumentOutlineNodesAccess()->isOutlineInLayout(i, *m_pWrtShell->GetLayout()))
+                    {
+                        --m_nMemberCount;
+                        continue; // don't hide it, just skip it
+                    }
+                    OUString aEntry(comphelper::string::stripStart(
+                        m_pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineText(i, m_pWrtShell->GetLayout()), ' '));
+                    aEntry = SwNavigationPI::CleanEntry(aEntry);
+                    std::unique_ptr<SwOutlineContent> pCnt(new SwOutlineContent(this, aEntry, i, nLevel,
+                                                        m_pWrtShell->IsOutlineMovable( i ), nPos ));
+                    m_pMember->insert(std::move(pCnt));
+                    // with the same number and existing "pOldMember" the
+                    // old one is compared with the new OutlinePos.
+                    if (nOldMemberCount > nPos && static_cast<SwOutlineContent*>((*pOldMember)[nPos].get())->GetOutlineLevel() != nLevel)
+                        *pbLevelOrVisibilityChanged = true;
+
+                    nPos++;
+                }
+            }
+
+        }
+        break;
+
+        case ContentTypeId::TABLE     :
+        {
+            const size_t nCount = m_pWrtShell->GetTableFrameFormatCount(true);
+            OSL_ENSURE(m_nMemberCount == nCount, "MemberCount differs");
+            Point aNullPt;
+            m_nMemberCount = nCount;
+            for(size_t i = 0; i < m_nMemberCount; ++i)
+            {
+                const SwFrameFormat& rTableFormat = m_pWrtShell->GetTableFrameFormat(i, true);
+                const OUString& sTableName( rTableFormat.GetName() );
+
+                SwContent* pCnt = new SwContent(this, sTableName,
+                        rTableFormat.FindLayoutRect(false, &aNullPt).Top() );
+                if( !rTableFormat.GetInfo( aAskItem ) &&
+                    !aAskItem.pObject )     // not visible
+                    pCnt->SetInvisible();
+
+                m_pMember->insert(std::unique_ptr<SwContent>(pCnt));
+
+                if(nOldMemberCount > i &&
+                    (*pOldMember)[i]->IsInvisible() != pCnt->IsInvisible())
+                        *pbLevelOrVisibilityChanged = true;
+            }
+        }
+        break;
+        case ContentTypeId::OLE       :
+        case ContentTypeId::FRAME     :
+        case ContentTypeId::GRAPHIC   :
+        {
+            FlyCntType eType = FLYCNTTYPE_FRM;
+            if(m_nContentType == ContentTypeId::OLE)
+                eType = FLYCNTTYPE_OLE;
+            else if(m_nContentType == ContentTypeId::GRAPHIC)
+                eType = FLYCNTTYPE_GRF;
+            Point aNullPt;
+            m_nMemberCount = m_pWrtShell->GetFlyCount(eType, /*bIgnoreTextBoxes=*/true);
+            std::vector<SwFrameFormat const*> formats(m_pWrtShell->GetFlyFrameFormats(eType, /*bIgnoreTextBoxes=*/true));
+            SAL_WARN_IF(m_nMemberCount != formats.size(), "sw.ui", "MemberCount differs");
+            m_nMemberCount = formats.size();
+            for (size_t i = 0; i < m_nMemberCount; ++i)
+            {
+                SwFrameFormat const*const pFrameFormat = formats[i];
+                const OUString sFrameName = pFrameFormat->GetName();
+
+                SwContent* pCnt;
+                if(ContentTypeId::GRAPHIC == m_nContentType)
+                {
+                    OUString sLink;
+                    m_pWrtShell->GetGrfNms( &sLink, nullptr, static_cast<const SwFlyFrameFormat*>( pFrameFormat));
+                    pCnt = new SwGraphicContent(this, sFrameName,
+                                INetURLObject::decode( sLink,
+                                           INetURLObject::DecodeMechanism::Unambiguous ),
+                                pFrameFormat->FindLayoutRect(false, &aNullPt).Top());
+                }
+                else
+                {
+                    pCnt = new SwContent(this, sFrameName,
+                            pFrameFormat->FindLayoutRect(false, &aNullPt).Top() );
+                }
+                if( !pFrameFormat->GetInfo( aAskItem ) &&
+                    !aAskItem.pObject )     // not visible
+                    pCnt->SetInvisible();
+                m_pMember->insert(std::unique_ptr<SwContent>(pCnt));
+                if (nOldMemberCount > i &&
+                    (*pOldMember)[i]->IsInvisible() != pCnt->IsInvisible())
+                        *pbLevelOrVisibilityChanged = true;
+            }
+        }
+        break;
+        case ContentTypeId::BOOKMARK:
+        {
+            IDocumentMarkAccess* const pMarkAccess = m_pWrtShell->getIDocumentMarkAccess();
+            for(IDocumentMarkAccess::const_iterator_t ppBookmark = pMarkAccess->getBookmarksBegin();
+                ppBookmark != pMarkAccess->getBookmarksEnd();
+                ++ppBookmark)
+            {
+                if(lcl_IsUiVisibleBookmark(*ppBookmark))
+                {
+                    const OUString& rBkmName = (*ppBookmark)->GetName();
+                    //nYPos from 0 -> text::Bookmarks will be sorted alphabetically
+                    std::unique_ptr<SwContent> pCnt(new SwContent(this, rBkmName, 0));
+                    m_pMember->insert(std::move(pCnt));
+                }
+            }
+        }
+        break;
+        case ContentTypeId::REGION    :
+        {
+            const Point aNullPt;
+            m_nMemberCount = m_pWrtShell->GetSectionFormatCount();
+            for(size_t i = 0; i < m_nMemberCount; ++i)
+            {
+                const SwSectionFormat* pFormat;
+                SectionType eTmpType;
+                if( (pFormat = &m_pWrtShell->GetSectionFormat(i))->IsInNodesArr() &&
+                (eTmpType = pFormat->GetSection()->GetType()) != SectionType::ToxContent
+                && SectionType::ToxHeader != eTmpType )
+                {
+                    OUString sSectionName = pFormat->GetSection()->GetSectionName();
+
+                    sal_uInt8 nLevel = 0;
+                    SwSectionFormat* pParentFormat = pFormat->GetParent();
+                    while(pParentFormat)
+                    {
+                        nLevel++;
+                        pParentFormat = pParentFormat->GetParent();
+                    }
+
+                    std::unique_ptr<SwContent> pCnt(new SwRegionContent(this, sSectionName,
+                            nLevel,
+                            pFormat->FindLayoutRect( false, &aNullPt ).Top()));
+                    if( !pFormat->GetInfo( aAskItem ) &&
+                        !aAskItem.pObject )     // not visible
+                        pCnt->SetInvisible();
+                    m_pMember->insert(std::move(pCnt));
+                }
+
+                if(nullptr != pbLevelOrVisibilityChanged)
+                {
+                    assert(pOldMember);
+                    // need to check visibility (and equal entry number) after
+                    // creation due to a sorted list being used here (before,
+                    // entries with same index were compared already at creation
+                    // time what worked before a sorted list was used)
+                    *pbLevelOrVisibilityChanged = checkVisibilityChanged(
+                        *pOldMember,
+                        *m_pMember);
+                }
+            }
+            m_nMemberCount = m_pMember->size();
+        }
+        break;
+        case ContentTypeId::REFERENCE:
+        {
+            std::vector<OUString> aRefMarks;
+            m_nMemberCount = m_pWrtShell->GetRefMarks( &aRefMarks );
+
+            for (const auto& rRefMark : aRefMarks)
+            {
+                // References sorted alphabetically
+                m_pMember->insert(std::make_unique<SwContent>(this, rRefMark, 0));
+            }
+        }
+        break;
+        case ContentTypeId::URLFIELD:
+            m_nMemberCount = lcl_InsertURLFieldContent(m_pMember.get(), m_pWrtShell, this);
+        break;
+        case ContentTypeId::INDEX:
+        {
+
+            const sal_uInt16 nCount = m_pWrtShell->GetTOXCount();
+            m_nMemberCount = nCount;
+            for ( sal_uInt16 nTox = 0; nTox < nCount; nTox++ )
+            {
+                const SwTOXBase* pBase = m_pWrtShell->GetTOX( nTox );
+                OUString sTOXNm( pBase->GetTOXName() );
+
+                SwContent* pCnt = new SwTOXBaseContent(
+                        this, sTOXNm, nTox, *pBase);
+
+                if( !pBase->GetInfo( aAskItem ) &&
+                    !aAskItem.pObject )     // not visible
+                    pCnt->SetInvisible();
+
+                m_pMember->insert( std::unique_ptr<SwContent>(pCnt) );
+                const size_t nPos = m_pMember->size() - 1;
+                if(nOldMemberCount > nPos &&
+                    (*pOldMember)[nPos]->IsInvisible()
+                            != pCnt->IsInvisible())
+                        *pbLevelOrVisibilityChanged = true;
+            }
+        }
+        break;
+        case ContentTypeId::POSTIT:
+        {
+            m_nMemberCount = 0;
+            m_pMember->clear();
+            SwPostItMgr* aMgr = m_pWrtShell->GetView().GetPostItMgr();
+            if (aMgr)
+            {
+                for(SwPostItMgr::const_iterator i = aMgr->begin(); i != aMgr->end(); ++i)
+                {
+                    if (const SwFormatField* pFormatField = dynamic_cast<const SwFormatField *>((*i)->GetBroadcaster())) // SwPostit
+                    {
+                        if (pFormatField->GetTextField() && pFormatField->IsFieldInDoc() &&
+                            (*i)->mLayoutStatus!=SwPostItHelper::INVISIBLE )
+                        {
+                            OUString sEntry = pFormatField->GetField()->GetPar2();
+                            sEntry = RemoveNewline(sEntry);
+                            std::unique_ptr<SwPostItContent> pCnt(new SwPostItContent(
+                                                this,
+                                                sEntry,
+                                                pFormatField,
+                                                m_nMemberCount));
+                            m_pMember->insert(std::move(pCnt));
+                            m_nMemberCount++;
+                        }
+                    }
+                }
+            }
+        }
+        break;
+        case ContentTypeId::DRAWOBJECT:
+        {
+            m_nMemberCount = 0;
+            m_pMember->clear();
+
+            IDocumentDrawModelAccess& rIDDMA = m_pWrtShell->getIDocumentDrawModelAccess();
+            SwDrawModel* pModel = rIDDMA.GetDrawModel();
+            if(pModel)
+            {
+                SdrPage* pPage = pModel->GetPage(0);
+                const size_t nCount = pPage->GetObjCount();
+                for( size_t i=0; i<nCount; ++i )
+                {
+                    SdrObject* pTemp = pPage->GetObj(i);
+                    // #i51726# - all drawing objects can be named now
+                    if (!pTemp->GetName().isEmpty())
+                    {
+                        SwContact* pContact = static_cast<SwContact*>(pTemp->GetUserCall());
+                        long nYPos = 0;
+                        const Point aNullPt;
+                        if(pContact && pContact->GetFormat())
+                            nYPos = pContact->GetFormat()->FindLayoutRect(false, &aNullPt).Top();
+                        SwContent* pCnt = new SwContent(
+                                            this,
+                                            pTemp->GetName(),
+                                            nYPos);
+                        if(!rIDDMA.IsVisibleLayerId(pTemp->GetLayer()))
+                            pCnt->SetInvisible();
+                        m_pMember->insert(std::unique_ptr<SwContent>(pCnt));
+                        m_nMemberCount++;
+                        if (nOldMemberCount > i &&
+                            (*pOldMember)[i]->IsInvisible() != pCnt->IsInvisible() )
+                                *pbLevelOrVisibilityChanged = true;
+                    }
+                }
+            }
+        }
+        break;
+        default: break;
+    }
+    m_bDataValid = true;
+}
+
+namespace {
+
+enum STR_CONTEXT_IDX
+{
+    IDX_STR_OUTLINE_LEVEL = 0,
+    IDX_STR_DRAGMODE = 1,
+    IDX_STR_HYPERLINK = 2,
+    IDX_STR_LINK_REGION = 3,
+    IDX_STR_COPY_REGION = 4,
+    IDX_STR_DISPLAY = 5,
+    IDX_STR_ACTIVE_VIEW = 6,
+    IDX_STR_HIDDEN = 7,
+    IDX_STR_ACTIVE = 8,
+    IDX_STR_INACTIVE = 9,
+    IDX_STR_EDIT_ENTRY = 10,
+    IDX_STR_DELETE_ENTRY = 11,
+    IDX_STR_SEND_OUTLINE_TO_CLIPBOARD_ENTRY = 12,
+    IDX_STR_OUTLINE_TRACKING = 13,
+    IDX_STR_OUTLINE_TRACKING_DEFAULT = 14,
+    IDX_STR_OUTLINE_TRACKING_FOCUS = 15,
+    IDX_STR_OUTLINE_TRACKING_OFF = 16
+};
+
+}
+
+static const char* STR_CONTEXT_ARY[] =
+{
+    STR_OUTLINE_LEVEL,
+    STR_DRAGMODE,
+    STR_HYPERLINK,
+    STR_LINK_REGION,
+    STR_COPY_REGION,
+    STR_DISPLAY,
+    STR_ACTIVE_VIEW,
+    STR_HIDDEN,
+    STR_ACTIVE,
+    STR_INACTIVE,
+    STR_EDIT_ENTRY,
+    STR_DELETE_ENTRY,
+    STR_SEND_OUTLINE_TO_CLIPBOARD_ENTRY,
+    STR_OUTLINE_TRACKING,
+    STR_OUTLINE_TRACKING_DEFAULT,
+    STR_OUTLINE_TRACKING_FOCUS,
+    STR_OUTLINE_TRACKING_OFF
+};
+
+SwContentTree::SwContentTree(std::unique_ptr<weld::TreeView> xTreeView, SwNavigationPI* pDialog)
+    : m_xTreeView(std::move(xTreeView))
+    , m_aDropTargetHelper(*this)
+    , m_xDialog(pDialog)
+    , m_sSpace(OUString("                    "))
+    , m_sInvisible(SwResId(STR_INVISIBLE))
+    , m_pHiddenShell(nullptr)
+    , m_pActiveShell(nullptr)
+    , m_pConfig(SW_MOD()->GetNavigationConfig())
+    , m_nActiveBlock(0)
+    , m_nHiddenBlock(0)
+    , m_nEntryCount(0)
+    , m_nRootType(ContentTypeId::UNKNOWN)
+    , m_nLastSelType(ContentTypeId::UNKNOWN)
+    , m_nOutlineLevel(MAXLEVEL)
+    , m_eState(State::ACTIVE)
+    , m_bIsRoot(false)
+    , m_bIsIdleClear(false)
+    , m_bIsLastReadOnly(false)
+    , m_bIsOutlineMoveable(true)
+    , m_bViewHasChanged(false)
+{
+    Size aSize(m_xDialog->LogicToPixel(Size(110, 112), MapMode(MapUnit::MapAppFont)));
+    m_xTreeView->set_size_request(aSize.Width(), aSize.Height());
+
+    m_xTreeView->set_help_id(HID_NAVIGATOR_TREELIST);
+
+    m_xTreeView->connect_expanding(LINK(this, SwContentTree, ExpandHdl));
+    m_xTreeView->connect_collapsing(LINK(this, SwContentTree, CollapseHdl));
+    m_xTreeView->connect_row_activated(LINK(this, SwContentTree, ContentDoubleClickHdl));
+    m_xTreeView->connect_changed(LINK(this, SwContentTree, SelectHdl));
+    m_xTreeView->connect_focus_in(LINK(this, SwContentTree, FocusHdl));
+    m_xTreeView->connect_key_press(LINK(this, SwContentTree, KeyInputHdl));
+    m_xTreeView->connect_popup_menu(LINK(this, SwContentTree, CommandHdl));
+    m_xTreeView->connect_query_tooltip(LINK(this, SwContentTree, QueryTooltipHdl));
+    m_xTreeView->connect_drag_begin(LINK(this, SwContentTree, DragBeginHdl));
+
+    for (ContentTypeId i : o3tl::enumrange<ContentTypeId>())
+    {
+        m_aActiveContentArr[i] = nullptr;
+        m_aHiddenContentArr[i] = nullptr;
+    }
+    for (int i = 0; i < CONTEXT_COUNT; ++i)
+    {
+        m_aContextStrings[i] = SwResId(STR_CONTEXT_ARY[i]);
+    }
+    m_nActiveBlock = m_pConfig->GetActiveBlock();
+    m_aUpdTimer.SetInvokeHandler(LINK(this, SwContentTree, TimerUpdate));
+    m_aUpdTimer.SetTimeout(1000);
+}
+
+SwContentTree::~SwContentTree()
+{
+    clear(); // If applicable erase content types previously.
+    m_aUpdTimer.Stop();
+    SetActiveShell(nullptr);
+    m_xDialog.clear();
+}
+
+// Drag&Drop methods
+IMPL_LINK(SwContentTree, DragBeginHdl, bool&, rUnsetDragIcon, bool)
+{
+    rUnsetDragIcon = true;
+
+    bool bDisallow = true;
+
+    // don't allow if tree root is selected
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    bool bEntry = m_xTreeView->get_selected(xEntry.get());
+    if (!bEntry || lcl_IsContentType(*xEntry, *m_xTreeView))
+    {
+        return true; // disallow
+    }
+
+    rtl::Reference<TransferDataContainer> xContainer = new TransferDataContainer;
+    sal_Int8 nDragMode = DND_ACTION_COPYMOVE | DND_ACTION_LINK;
+
+    if (FillTransferData(*xContainer, nDragMode))
+        bDisallow = false;
+
+    if (m_bIsRoot && m_nRootType == ContentTypeId::OUTLINE)
+    {
+        // Only move drag entry and continuous selected siblings:
+        m_aDndOutlinesSelected.clear();
+
+        std::unique_ptr<weld::TreeIter> xScratch(m_xTreeView->make_iterator());
+
+        // Find first selected of continuous siblings
+        while (true)
+        {
+            m_xTreeView->copy_iterator(*xEntry, *xScratch);
+            if (!m_xTreeView->iter_previous_sibling(*xScratch))
+                break;
+            if (!m_xTreeView->is_selected(*xScratch))
+                break;
+            m_xTreeView->copy_iterator(*xScratch, *xEntry);
+        }
+        // Record continuous selected siblings
+        do
+        {
+            m_aDndOutlinesSelected.push_back(m_xTreeView->make_iterator(xEntry.get()));
+        }
+        while (m_xTreeView->iter_next_sibling(*xEntry) && m_xTreeView->is_selected(*xEntry));
+        bDisallow = false;
+    }
+
+    if (!bDisallow)
+        m_xTreeView->enable_drag_source(xContainer, nDragMode);
+    return bDisallow;
+}
+
+SwContentTreeDropTarget::SwContentTreeDropTarget(SwContentTree& rTreeView)
+    : DropTargetHelper(rTreeView.get_widget().get_drop_target())
+    , m_rTreeView(rTreeView)
+{
+}
+
+sal_Int8 SwContentTreeDropTarget::AcceptDrop(const AcceptDropEvent& rEvt)
+{
+    sal_Int8 nAccept = m_rTreeView.AcceptDrop(rEvt);
+
+    if (nAccept != DND_ACTION_NONE)
+    {
+        // to enable the autoscroll when we're close to the edges
+        weld::TreeView& rWidget = m_rTreeView.get_widget();
+        rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr);
+    }
+
+    return nAccept;
+}
+
+bool SwContentTree::IsInDrag() const
+{
+    return m_xTreeView->get_drag_source() == m_xTreeView.get();
+}
+
+// QueryDrop will be executed in the navigator
+sal_Int8 SwContentTree::AcceptDrop(const AcceptDropEvent& rEvt)
+{
+    sal_Int8 nRet = DND_ACTION_NONE;
+    if( m_bIsRoot )
+    {
+        if( m_bIsOutlineMoveable )
+            nRet = rEvt.mnAction;
+    }
+    else if (!IsInDrag())
+        nRet = GetParentWindow()->AcceptDrop();
+    return nRet;
+}
+
+// Drop will be executed in the navigator
+static void* lcl_GetOutlineKey(SwContentTree& rTree, SwOutlineContent const * pContent)
+{
+    void* key = nullptr;
+    if (pContent)
+    {
+        SwWrtShell* pShell = rTree.GetWrtShell();
+        auto const nPos = pContent->GetOutlinePos();
+
+        key = static_cast<void*>(pShell->getIDocumentOutlineNodesAccess()->getOutlineNode( nPos ));
+    }
+    return key;
+}
+
+sal_Int8 SwContentTreeDropTarget::ExecuteDrop(const ExecuteDropEvent& rEvt)
+{
+    return m_rTreeView.ExecuteDrop(rEvt);
+}
+
+sal_Int8 SwContentTree::ExecuteDrop(const ExecuteDropEvent& rEvt)
+{
+    std::unique_ptr<weld::TreeIter> xDropEntry(m_xTreeView->make_iterator());
+    if (!m_xTreeView->get_dest_row_at_pos(rEvt.maPosPixel, xDropEntry.get()))
+        xDropEntry.reset();
+
+    if (m_nRootType == ContentTypeId::OUTLINE)
+    {
+        if (xDropEntry && lcl_IsContent(*xDropEntry, *m_xTreeView))
+        {
+            assert(dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xDropEntry).toInt64())));
+            SwOutlineContent* pOutlineContent = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xDropEntry).toInt64());
+            assert(pOutlineContent);
+
+            void* key = lcl_GetOutlineKey(*this, pOutlineContent);
+            assert(key);
+            if (!mOutLineNodeMap[key])
+            {
+                while (m_xTreeView->iter_has_child(*xDropEntry))
+                {
+                    std::unique_ptr<weld::TreeIter> xChildEntry(m_xTreeView->make_iterator(xDropEntry.get()));
+                    bool bChildEntry = m_xTreeView->iter_children(*xChildEntry);
+                    while (bChildEntry)
+                    {
+                        m_xTreeView->copy_iterator(*xChildEntry, *xDropEntry);
+                        bChildEntry = m_xTreeView->iter_next_sibling(*xChildEntry);
+                    }
+                }
+            }
+        }
+
+        SwOutlineNodes::size_type nTargetPos = 0;
+        if (!xDropEntry)
+        {
+            // dropped in blank space -> move to bottom
+            nTargetPos = GetWrtShell()->getIDocumentOutlineNodesAccess()->getOutlineNodesCount() - 1;
+        }
+        else if (!lcl_IsContent(*xDropEntry, *m_xTreeView))
+        {
+            // dropped on "heading" parent -> move to start
+            nTargetPos = SwOutlineNodes::npos;
+        }
+        else
+        {
+            assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xDropEntry).toInt64())));
+            nTargetPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xDropEntry).toInt64())->GetOutlinePos();
+        }
+
+        if( MAXLEVEL > m_nOutlineLevel && // Not all layers are displayed.
+                        nTargetPos != SwOutlineNodes::npos)
+        {
+            std::unique_ptr<weld::TreeIter> xNext(m_xTreeView->make_iterator(xDropEntry.get()));
+            bool bNext = m_xTreeView->iter_next(*xNext);
+            if (bNext)
+            {
+                assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xNext).toInt64())));
+                nTargetPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xNext).toInt64())->GetOutlinePos() - 1;
+            }
+            else
+                nTargetPos = GetWrtShell()->getIDocumentOutlineNodesAccess()->getOutlineNodesCount() - 1;
+        }
+
+        // remove the drop highlight before we change the contents of the tree so we don't
+        // try and dereference a removed entry in post-processing drop
+        m_xTreeView->unset_drag_dest_row();
+        MoveOutline(nTargetPos);
+
+    }
+    return IsInDrag() ? DND_ACTION_NONE : GetParentWindow()->ExecuteDrop(rEvt);
+}
+
+namespace
+{
+    bool IsAllExpanded(const weld::TreeView& rContentTree, const weld::TreeIter& rEntry)
+    {
+        if (!rContentTree.get_row_expanded(rEntry))
+            return false;
+
+        if (!rContentTree.iter_has_child(rEntry))
+            return false;
+
+        std::unique_ptr<weld::TreeIter> xChild(rContentTree.make_iterator(&rEntry));
+        (void)rContentTree.iter_children(*xChild);
+
+        do
+        {
+            if (rContentTree.iter_has_child(*xChild) || rContentTree.get_children_on_demand(*xChild))
+            {
+                if (!IsAllExpanded(rContentTree, *xChild))
+                    return false;
+            }
+        }
+        while (rContentTree.iter_next_sibling(*xChild));
+        return true;
+    }
+
+    void ExpandOrCollapseAll(weld::TreeView& rContentTree, weld::TreeIter& rEntry)
+    {
+        bool bExpand = !IsAllExpanded(rContentTree, rEntry);
+        bExpand ? rContentTree.expand_row(rEntry) : rContentTree.collapse_row(rEntry);
+        int nRefDepth = rContentTree.get_iter_depth(rEntry);
+        while (rContentTree.iter_next(rEntry) && rContentTree.get_iter_depth(rEntry) > nRefDepth)
+        {
+            if (rContentTree.iter_has_child(rEntry))
+                bExpand ? rContentTree.expand_row(rEntry) : rContentTree.collapse_row(rEntry);
+        }
+    }
+}
+
+// Handler for Dragging and ContextMenu
+static bool lcl_InsertExpandCollapseAllItem(weld::TreeView& rContentTree, weld::TreeIter& rEntry, weld::Menu& rPop)
+{
+    if (rContentTree.iter_has_child(rEntry) || rContentTree.get_children_on_demand(rEntry))
+    {
+        rPop.set_label(OString::number(800), IsAllExpanded(rContentTree, rEntry) ? SwResId(STR_COLLAPSEALL) : SwResId(STR_EXPANDALL));
+        return false;
+    }
+    return true;
+}
+
+IMPL_LINK(SwContentTree, CommandHdl, const CommandEvent&, rCEvt, bool)
+{
+    if (rCEvt.GetCommand() != CommandEventId::ContextMenu)
+        return false;
+
+    std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "modules/swriter/ui/navigatorcontextmenu.ui"));
+    std::unique_ptr<weld::Menu> xPop = xBuilder->weld_menu("navmenu");
+
+    bool bOutline(false);
+    std::unique_ptr<weld::Menu> xSubPop1 = xBuilder->weld_menu("outlinelevel");
+    std::unique_ptr<weld::Menu> xSubPop2 = xBuilder->weld_menu("dragmodemenu");
+    std::unique_ptr<weld::Menu> xSubPop3 = xBuilder->weld_menu("displaymenu");
+    std::unique_ptr<weld::Menu> xSubPopOutlineTracking = xBuilder->weld_menu("outlinetracking");
+
+    for(int i = 1; i <= 3; ++i)
+        xSubPopOutlineTracking->append_radio(OUString::number(i + 10), m_aContextStrings[IDX_STR_OUTLINE_TRACKING + i]);
+    xSubPopOutlineTracking->set_active(OString::number(10 + m_nOutlineTracking), true);
+
+    for (int i = 1; i <= MAXLEVEL; ++i)
+        xSubPop1->append_radio(OUString::number(i + 100), OUString::number(i));
+    xSubPop1->set_active(OString::number(100 + m_nOutlineLevel), true);
+
+    for (int i=0; i < 3; ++i)
+        xSubPop2->append_radio(OUString::number(i + 201), m_aContextStrings[IDX_STR_HYPERLINK + i]);
+    xSubPop2->set_active(OString::number(201 + static_cast<int>(GetParentWindow()->GetRegionDropMode())), true);
+
+    // Insert the list of the open files
+    sal_uInt16 nId = 301;
+    const SwView* pActiveView = ::GetActiveView();
+    SwView *pView = SwModule::GetFirstView();
+    while (pView)
+    {
+        OUString sInsert = pView->GetDocShell()->GetTitle();
+        if (pView == pActiveView)
+        {
+            sInsert += "(" +
+                m_aContextStrings[IDX_STR_ACTIVE] +
+                ")";
+        }
+        xSubPop3->append_radio(OUString::number(nId), sInsert);
+        if (State::CONSTANT == m_eState && m_pActiveShell == &pView->GetWrtShell())
+            xSubPop3->set_active(OString::number(nId), true);
+        pView = SwModule::GetNextView(pView);
+        nId++;
+    }
+    xSubPop3->append_radio(OUString::number(nId++), m_aContextStrings[IDX_STR_ACTIVE_VIEW]);
+    if (m_pHiddenShell)
+    {
+        OUString sHiddenEntry = m_pHiddenShell->GetView().GetDocShell()->GetTitle() +
+            " ( " +
+            m_aContextStrings[IDX_STR_HIDDEN] +
+            " )";
+        xSubPop3->append_radio(OUString::number(nId), sHiddenEntry);
+    }
+
+    if (State::ACTIVE == m_eState)
+        xSubPop3->set_active(OString::number(--nId), true);
+    else if (State::HIDDEN == m_eState)
+        xSubPop3->set_active(OString::number(nId), true);
+
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    if (!m_xTreeView->get_selected(xEntry.get()))
+        xEntry.reset();
+
+    if (!xEntry || !lcl_IsContent(*xEntry, *m_xTreeView))
+        xPop->remove(OString::number(900)); // go to
+
+    bool bRemovePostItEntries = true;
+    bool bRemoveIndexEntries = true;
+    bool bRemoveEditEntry = true;
+    bool bRemoveUnprotectEntry = true;
+    bool bRemoveDeleteEntry = true;
+    bool bRemoveRenameEntry = true;
+    bool bRemoveSelectEntry = true;
+    bool bRemoveToggleExpandEntry = true;
+    bool bRemoveChapterEntries = true;
+    bool bRemoveSendOutlineEntry = true;
+
+    // Edit only if the shown content is coming from the current view.
+    if ((State::ACTIVE == m_eState || m_pActiveShell == pActiveView->GetWrtShellPtr())
+            && xEntry && lcl_IsContent(*xEntry, *m_xTreeView))
+    {
+        assert(dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+        const SwContentType* pContType = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetParent();
+        const ContentTypeId nContentType = pContType->GetType();
+        const bool bReadonly = m_pActiveShell->GetView().GetDocShell()->IsReadOnly();
+        const bool bVisible = !reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64())->IsInvisible();
+        const bool bProtected = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64())->IsProtect();
+        const bool bProtectBM = (ContentTypeId::BOOKMARK == nContentType)
+            && m_pActiveShell->getIDocumentSettingAccess().get(DocumentSettingId::PROTECT_BOOKMARKS);
+        const bool bEditable = pContType->IsEditable() &&
+            ((bVisible && !bProtected && !bProtectBM) || ContentTypeId::REGION == nContentType);
+        const bool bDeletable = pContType->IsDeletable() &&
+            ((bVisible && !bProtected && !bProtectBM) || ContentTypeId::REGION == nContentType);
+        const bool bRenamable = bEditable && !bReadonly &&
+            (ContentTypeId::TABLE == nContentType ||
+                ContentTypeId::FRAME == nContentType ||
+                ContentTypeId::GRAPHIC == nContentType ||
+                ContentTypeId::OLE == nContentType ||
+                (ContentTypeId::BOOKMARK == nContentType && !bProtectBM) ||
+                ContentTypeId::REGION == nContentType ||
+                ContentTypeId::INDEX == nContentType ||
+                ContentTypeId::DRAWOBJECT == nContentType);
+
+        if (!bReadonly && (bEditable || bDeletable))
+        {
+            if(ContentTypeId::INDEX == nContentType)
+            {
+                bRemoveIndexEntries = false;
+
+                const SwTOXBase* pBase = reinterpret_cast<SwTOXBaseContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetTOXBase();
+                if (!pBase->IsTOXBaseInReadonly())
+                    bRemoveEditEntry = false;
+
+                xPop->set_active(OString::number(405), SwEditShell::IsTOXBaseReadonly(*pBase));
+                bRemoveDeleteEntry = false;
+            }
+            else if(ContentTypeId::TABLE == nContentType)
+            {
+                bRemoveSelectEntry = false;
+                bRemoveEditEntry = false;
+                bRemoveUnprotectEntry = false;
+                bool bFull = false;
+                OUString sTableName = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetName();
+                bool bProt = m_pActiveShell->HasTableAnyProtection( &sTableName, &bFull );
+                xPop->set_sensitive(OString::number(403), !bFull);
+                xPop->set_sensitive(OString::number(404), bProt);
+                bRemoveDeleteEntry = false;
+            }
+            else if(ContentTypeId::OUTLINE == nContentType)
+            {
+                bOutline = true;
+                bRemoveToggleExpandEntry = lcl_InsertExpandCollapseAllItem(*m_xTreeView, *xEntry, *xPop);
+                bRemoveSelectEntry = false;
+                bRemoveChapterEntries = false;
+            }
+            else if(ContentTypeId::DRAWOBJECT == nContentType)
+            {
+                bRemoveDeleteEntry = false;
+            }
+            else if(ContentTypeId::REGION == nContentType)
+            {
+                bRemoveSelectEntry = false;
+                bRemoveEditEntry = false;
+            }
+            else
+            {
+                if (bEditable && bDeletable)
+                {
+                    bRemoveEditEntry = false;
+                    bRemoveDeleteEntry = false;
+                }
+                else if (bEditable)
+                    bRemoveEditEntry = false;
+                else if (bDeletable)
+                {
+                    bRemoveDeleteEntry = false;
+                }
+            }
+            //Rename object
+            if (bRenamable)
+                bRemoveRenameEntry = false;
+        }
+    }
+    else if (xEntry)
+    {
+        assert(dynamic_cast<SwContentType*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+        SwContentType* pType = reinterpret_cast<SwContentType*>(m_xTreeView->get_id(*xEntry).toInt64());
+        if (ContentTypeId::OUTLINE == pType->GetType())
+        {
+            bOutline = true;
+            bRemoveToggleExpandEntry = lcl_InsertExpandCollapseAllItem(*m_xTreeView, *xEntry, *xPop);
+            bRemoveSendOutlineEntry = false;
+        }
+        if ( (pType->GetType() == ContentTypeId::POSTIT) &&  (!m_pActiveShell->GetView().GetDocShell()->IsReadOnly()) && ( pType->GetMemberCount() > 0) )
+            bRemovePostItEntries = false;
+    }
+
+    if (bRemoveToggleExpandEntry)
+    {
+        xPop->remove("separator3");
+        xPop->remove(OString::number(800));
+    }
+
+    if (bRemoveSelectEntry)
+        xPop->remove(OString::number(805));
+
+    if (bRemoveChapterEntries)
+    {
+        xPop->remove("separator2");
+        xPop->remove(OString::number(806));
+        xPop->remove(OString::number(801));
+        xPop->remove(OString::number(802));
+        xPop->remove(OString::number(803));
+        xPop->remove(OString::number(804));
+    }
+
+    if (bRemoveSendOutlineEntry)
+        xPop->remove(OString::number(700));
+
+    if (bRemovePostItEntries)
+    {
+        xPop->remove(OString::number(600));
+        xPop->remove(OString::number(601));
+        xPop->remove(OString::number(602));
+    }
+
+    if (bRemoveDeleteEntry)
+        xPop->remove(OString::number(501));
+
+    if (bRemoveRenameEntry)
+        xPop->remove(OString::number(502));
+
+    if (bRemoveIndexEntries)
+    {
+        xPop->remove(OString::number(401));
+        xPop->remove(OString::number(402));
+        xPop->remove(OString::number(405));
+    }
+
+    if (bRemoveUnprotectEntry)
+        xPop->remove(OString::number(404));
+
+    if (bRemoveEditEntry)
+        xPop->remove(OString::number(403));
+
+    if (bRemoveToggleExpandEntry &&
+        bRemoveSelectEntry &&
+        bRemoveChapterEntries &&
+        bRemoveSendOutlineEntry &&
+        bRemovePostItEntries &&
+        bRemoveDeleteEntry &&
+        bRemoveRenameEntry &&
+        bRemoveIndexEntries &&
+        bRemoveUnprotectEntry &&
+        bRemoveEditEntry)
+    {
+        xPop->remove("separator1");
+    }
+
+    if (!bOutline)
+    {
+        xSubPop1.reset();
+        xPop->remove(OString::number(1)); // outline level menu
+        xSubPopOutlineTracking.reset();
+        xPop->remove(OString::number(4)); // outline tracking menu
+    }
+
+    OString sCommand = xPop->popup_at_rect(m_xTreeView.get(), tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1)));
+    if (!sCommand.isEmpty())
+        ExecuteContextMenuAction(sCommand);
+
+    return true;
+}
+
+void SwContentTree::insert(const weld::TreeIter* pParent, const OUString& rStr, const OUString& rId,
+                           const OUString* pExpanderName, bool bChildrenOnDemand, weld::TreeIter* pRet)
+{
+    m_xTreeView->insert(pParent, -1, &rStr, &rId, nullptr, nullptr, pExpanderName, bChildrenOnDemand, pRet);
+    ++m_nEntryCount;
+}
+
+void SwContentTree::remove(const weld::TreeIter& rIter)
+{
+    if (m_xTreeView->iter_has_child(rIter))
+    {
+        std::unique_ptr<weld::TreeIter> xChild = m_xTreeView->make_iterator(&rIter);
+        (void)m_xTreeView->iter_children(*xChild);
+        remove(*xChild);
+    }
+    m_xTreeView->remove(rIter);
+    --m_nEntryCount;
+}
+
+// Content will be integrated into the Box only on demand.
+bool SwContentTree::RequestingChildren(const weld::TreeIter& rParent)
+{
+    bool bChild = m_xTreeView->iter_has_child(rParent);
+    if (bChild || !m_xTreeView->get_children_on_demand(rParent))
+        return bChild;
+
+    // Is this a content type?
+    if (lcl_IsContentType(rParent, *m_xTreeView))
+    {
+        std::unique_ptr<weld::TreeIter> xChild = m_xTreeView->make_iterator();
+
+        assert(dynamic_cast<SwContentType*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(rParent).toInt64())));
+        SwContentType* pCntType = reinterpret_cast<SwContentType*>(m_xTreeView->get_id(rParent).toInt64());
+
+        const size_t nCount = pCntType->GetMemberCount();
+        // Add for outline plus/minus
+        if (pCntType->GetType() == ContentTypeId::OUTLINE)
+        {
+            for(size_t i = 0; i < nCount; ++i)
+            {
+                const SwContent* pCnt = pCntType->GetMember(i);
+                if(pCnt)
+                {
+                    const auto nLevel = static_cast<const SwOutlineContent*>(pCnt)->GetOutlineLevel();
+                    OUString sEntry = pCnt->GetName();
+                    if(sEntry.isEmpty())
+                        sEntry = m_sSpace;
+                    OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pCnt)));
+                    if (!bChild || (nLevel == 0))
+                    {
+                        insert(&rParent, sEntry, sId, nullptr, false, xChild.get());
+                        m_xTreeView->set_sensitive(*xChild, !pCnt->IsInvisible());
+                        m_xTreeView->set_extra_row_indent(*xChild, nLevel + 1 - m_xTreeView->get_iter_depth(*xChild));
+                        bChild = true;
+                    }
+                    else
+                    {
+                        //back search parent.
+                        if(static_cast<const SwOutlineContent*>(pCntType->GetMember(i-1))->GetOutlineLevel() < nLevel)
+                        {
+                            insert(xChild.get(), sEntry, sId, nullptr, false, xChild.get());
+                            m_xTreeView->set_sensitive(*xChild, !pCnt->IsInvisible());
+                            m_xTreeView->set_extra_row_indent(*xChild, nLevel + 1 - m_xTreeView->get_iter_depth(*xChild));
+                            bChild = true;
+                        }
+                        else
+                        {
+                            bChild = m_xTreeView->iter_previous(*xChild);
+                            assert(!bChild || lcl_IsContentType(*xChild, *m_xTreeView) || dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xChild).toInt64())));
+                            while (bChild &&
+                                    lcl_IsContent(*xChild, *m_xTreeView) &&
+                                    (reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xChild).toInt64())->GetOutlineLevel() >= nLevel)
+                                )
+                            {
+                                bChild = m_xTreeView->iter_previous(*xChild);
+                            }
+                            if (bChild)
+                            {
+                                insert(xChild.get(), sEntry, sId, nullptr, false, xChild.get());
+                                m_xTreeView->set_sensitive(*xChild, !pCnt->IsInvisible());
+                                m_xTreeView->set_extra_row_indent(*xChild, nLevel + 1 - m_xTreeView->get_iter_depth(*xChild));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            bool bRegion = pCntType->GetType() == ContentTypeId::REGION;
+            for(size_t i = 0; i < nCount; ++i)
+            {
+                const SwContent* pCnt = pCntType->GetMember(i);
+                if (pCnt)
+                {
+                    OUString sEntry = pCnt->GetName();
+                    if (sEntry.isEmpty())
+                        sEntry = m_sSpace;
+                    OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pCnt)));
+                    insert(&rParent, sEntry, sId, nullptr, false, xChild.get());
+                    m_xTreeView->set_sensitive(*xChild, !pCnt->IsInvisible());
+                    if (bRegion)
+                        m_xTreeView->set_extra_row_indent(*xChild, static_cast<const SwRegionContent*>(pCnt)->GetRegionLevel());
+                    bChild = true;
+                }
+            }
+        }
+    }
+
+    return bChild;
+}
+
+SdrObject* SwContentTree::GetDrawingObjectsByContent(const SwContent *pCnt)
+{
+    SdrObject *pRetObj = nullptr;
+    switch(pCnt->GetParent()->GetType())
+    {
+        case ContentTypeId::DRAWOBJECT:
+        {
+            SdrView* pDrawView = m_pActiveShell->GetDrawView();
+            if (pDrawView)
+            {
+                SwDrawModel* pDrawModel = m_pActiveShell->GetDoc()->getIDocumentDrawModelAccess().GetDrawModel();
+                SdrPage* pPage = pDrawModel->GetPage(0);
+                const size_t nCount = pPage->GetObjCount();
+
+                for( size_t i=0; i<nCount; ++i )
+                {
+                    SdrObject* pTemp = pPage->GetObj(i);
+                    if( pTemp->GetName() == pCnt->GetName())
+                    {
+                        pRetObj = pTemp;
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+        default:
+            pRetObj = nullptr;
+    }
+    return pRetObj;
+}
+
+void SwContentTree::Expand(const weld::TreeIter& rParent, std::vector<std::unique_ptr<weld::TreeIter>>* pNodesToExpand)
+{
+    if (!(m_xTreeView->iter_has_child(rParent) || m_xTreeView->get_children_on_demand(rParent)))
+        return;
+
+    if (!m_bIsRoot
+        || (lcl_IsContentType(rParent, *m_xTreeView) &&
+            reinterpret_cast<SwContentType*>(m_xTreeView->get_id(rParent).toInt64())->GetType() == ContentTypeId::OUTLINE)
+        || (m_nRootType == ContentTypeId::OUTLINE))
+    {
+        if (lcl_IsContentType(rParent, *m_xTreeView))
+        {
+            SwContentType* pCntType = reinterpret_cast<SwContentType*>(m_xTreeView->get_id(rParent).toInt64());
+            const sal_Int32 nOr = 1 << static_cast<int>(pCntType->GetType()); //linear -> Bitposition
+            if (State::HIDDEN != m_eState)
+            {
+                m_nActiveBlock |= nOr;
+                m_pConfig->SetActiveBlock(m_nActiveBlock);
+            }
+            else
+                m_nHiddenBlock |= nOr;
+            if (pCntType->GetType() == ContentTypeId::OUTLINE)
+            {
+                std::map< void*, bool > aCurrOutLineNodeMap;
+
+                SwWrtShell* pShell = GetWrtShell();
+                bool bParentHasChild = RequestingChildren(rParent);
+                if (pNodesToExpand)
+                    pNodesToExpand->emplace_back(m_xTreeView->make_iterator(&rParent));
+                if (bParentHasChild)
+                {
+                    std::unique_ptr<weld::TreeIter> xChild(m_xTreeView->make_iterator(&rParent));
+                    bool bChild = m_xTreeView->iter_next(*xChild);
+                    while (bChild && lcl_IsContent(*xChild, *m_xTreeView))
+                    {
+                        if (m_xTreeView->iter_has_child(*xChild))
+                        {
+                            assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xChild).toInt64())));
+                            auto const nPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xChild).toInt64())->GetOutlinePos();
+                            void* key = static_cast<void*>(pShell->getIDocumentOutlineNodesAccess()->getOutlineNode( nPos ));
+                            aCurrOutLineNodeMap.emplace( key, false );
+                            std::map<void*, bool>::iterator iter = mOutLineNodeMap.find( key );
+                            if( iter != mOutLineNodeMap.end() && mOutLineNodeMap[key])
+                            {
+                                aCurrOutLineNodeMap[key] = true;
+                                RequestingChildren(*xChild);
+                                if (pNodesToExpand)
+                                    pNodesToExpand->emplace_back(m_xTreeView->make_iterator(xChild.get()));
+                                m_xTreeView->set_children_on_demand(*xChild, false);
+                            }
+                        }
+                        bChild = m_xTreeView->iter_next(*xChild);
+                    }
+                }
+                mOutLineNodeMap = aCurrOutLineNodeMap;
+                return;
+            }
+        }
+        else
+        {
+            if (lcl_IsContent(rParent, *m_xTreeView))
+            {
+                SwWrtShell* pShell = GetWrtShell();
+                // paranoid assert now that outline type is checked
+                assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(rParent).toInt64())));
+                auto const nPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(rParent).toInt64())->GetOutlinePos();
+                void* key = static_cast<void*>(pShell->getIDocumentOutlineNodesAccess()->getOutlineNode( nPos ));
+                mOutLineNodeMap[key] = true;
+            }
+        }
+    }
+
+    RequestingChildren(rParent);
+    if (pNodesToExpand)
+        pNodesToExpand->emplace_back(m_xTreeView->make_iterator(&rParent));
+}
+
+IMPL_LINK(SwContentTree, ExpandHdl, const weld::TreeIter&, rParent, bool)
+{
+    Expand(rParent, nullptr);
+    return true;
+}
+
+IMPL_LINK(SwContentTree, CollapseHdl, const weld::TreeIter&, rParent, bool)
+{
+    if (!m_xTreeView->iter_has_child(rParent) || m_xTreeView->get_children_on_demand(rParent))
+        return true;
+
+    if (lcl_IsContentType(rParent, *m_xTreeView))
+    {
+        if (m_bIsRoot)
+        {
+            // collapse to children of root node
+            std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator(&rParent));
+            if (m_xTreeView->iter_children(*xEntry))
+            {
+                do
+                {
+                    m_xTreeView->collapse_row(*xEntry);
+                }
+                while (m_xTreeView->iter_next(*xEntry));
+            }
+            return false; // return false to notify caller not to do collapse
+        }
+        SwContentType* pCntType = reinterpret_cast<SwContentType*>(m_xTreeView->get_id(rParent).toInt64());
+        const sal_Int32 nAnd = ~(1 << static_cast<int>(pCntType->GetType()));
+        if (State::HIDDEN != m_eState)
+        {
+            m_nActiveBlock &= nAnd;
+            m_pConfig->SetActiveBlock(m_nActiveBlock);
+        }
+        else
+            m_nHiddenBlock &= nAnd;
+    }
+    else if (lcl_IsContent(rParent, *m_xTreeView))
+    {
+        SwWrtShell* pShell = GetWrtShell();
+        assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(rParent).toInt64())));
+        auto const nPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(rParent).toInt64())->GetOutlinePos();
+        void* key = static_cast<void*>(pShell->getIDocumentOutlineNodesAccess()->getOutlineNode( nPos ));
+        mOutLineNodeMap[key] = false;
+    }
+
+    return true;
+}
+
+// Also on double click will be initially opened only.
+IMPL_LINK_NOARG(SwContentTree, ContentDoubleClickHdl, weld::TreeView&, bool)
+{
+    bool bConsumed = false;
+
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    bool bEntry = m_xTreeView->get_cursor(xEntry.get());
+    // Is it a content type?
+    OSL_ENSURE(bEntry, "no current entry!");
+    if (bEntry)
+    {
+        if (lcl_IsContentType(*xEntry, *m_xTreeView) && !m_xTreeView->iter_has_child(*xEntry))
+        {
+            RequestingChildren(*xEntry);
+            m_xTreeView->set_children_on_demand(*xEntry, false);
+        }
+        else if (!lcl_IsContentType(*xEntry, *m_xTreeView) && (State::HIDDEN != m_eState))
+        {
+            if (State::CONSTANT == m_eState)
+            {
+                m_pActiveShell->GetView().GetViewFrame()->GetWindow().ToTop();
+            }
+            //Jump to content type:
+            assert(dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+            SwContent* pCnt = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64());
+            assert(pCnt && "no UserData");
+            GotoContent(pCnt);
+            const ContentTypeId nActType = pCnt->GetParent()->GetType();
+            if (nActType == ContentTypeId::FRAME)
+                m_pActiveShell->EnterStdMode();
+            // fdo#36308 don't expand outlines on double-click
+            bConsumed = nActType == ContentTypeId::OUTLINE;
+        }
+    }
+
+    return bConsumed; // false/true == allow/disallow more to be done, i.e. expand/collapse children
+}
+
+namespace
+{
+    OUString GetImageIdForContentTypeId(ContentTypeId eType)
+    {
+        OUString sResId;
+
+        switch (eType)
+        {
+            case ContentTypeId::OUTLINE:
+                sResId = RID_BMP_NAVI_OUTLINE;
+                break;
+            case ContentTypeId::TABLE:
+                sResId = RID_BMP_NAVI_TABLE;
+                break;
+            case ContentTypeId::FRAME:
+                sResId = RID_BMP_NAVI_FRAME;
+                break;
+            case ContentTypeId::GRAPHIC:
+                sResId = RID_BMP_NAVI_GRAPHIC;
+                break;
+            case ContentTypeId::OLE:
+                sResId = RID_BMP_NAVI_OLE;
+                break;
+            case ContentTypeId::BOOKMARK:
+                sResId = RID_BMP_NAVI_BOOKMARK;
+                break;
+            case ContentTypeId::REGION:
+                sResId = RID_BMP_NAVI_REGION;
+                break;
+            case ContentTypeId::URLFIELD:
+                sResId = RID_BMP_NAVI_URLFIELD;
+                break;
+            case ContentTypeId::REFERENCE:
+                sResId = RID_BMP_NAVI_REFERENCE;
+                break;
+            case ContentTypeId::INDEX:
+                sResId = RID_BMP_NAVI_INDEX;
+                break;
+            case ContentTypeId::POSTIT:
+                sResId = RID_BMP_NAVI_POSTIT;
+                break;
+            case ContentTypeId::DRAWOBJECT:
+                sResId = RID_BMP_NAVI_DRAWOBJECT;
+                break;
+            case ContentTypeId::UNKNOWN:
+                SAL_WARN("sw.ui", "ContentTypeId::UNKNOWN has no bitmap preview");
+                break;
+        }
+
+        return sResId;
+    };
+}
+
+size_t SwContentTree::GetAbsPos(const weld::TreeIter& rIter)
+{
+    return weld::GetAbsPos(*m_xTreeView, rIter);
+}
+
+size_t SwContentTree::GetEntryCount() const
+{
+    return m_nEntryCount;
+}
+
+size_t SwContentTree::GetChildCount(const weld::TreeIter& rParent) const
+{
+    if (!m_xTreeView->iter_has_child(rParent))
+        return 0;
+
+    std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rParent));
+
+    size_t nCount = 0;
+    auto nRefDepth = m_xTreeView->get_iter_depth(*xParent);
+    auto nActDepth = nRefDepth;
+    do
+    {
+        if (!m_xTreeView->iter_next(*xParent))
+            xParent.reset();
+        else
+            nActDepth = m_xTreeView->get_iter_depth(*xParent);
+        nCount++;
+    } while(xParent && nRefDepth < nActDepth);
+
+    nCount--;
+    return nCount;
+}
+
+std::unique_ptr<weld::TreeIter> SwContentTree::GetEntryAtAbsPos(size_t nAbsPos) const
+{
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    if (!m_xTreeView->get_iter_first(*xEntry))
+        xEntry.reset();
+
+    while (nAbsPos && xEntry)
+    {
+        if (!m_xTreeView->iter_next(*xEntry))
+            xEntry.reset();
+        nAbsPos--;
+    }
+    return xEntry;
+}
+
+void SwContentTree::Display( bool bActive )
+{
+    // First read the selected entry to select it later again if necessary
+    // -> the user data here are no longer valid!
+    std::unique_ptr<weld::TreeIter> xOldSelEntry(m_xTreeView->make_iterator());
+    if (!m_xTreeView->get_selected(xOldSelEntry.get()))
+        xOldSelEntry.reset();
+    OUString sEntryName;  // Name of the entry
+    size_t nEntryRelPos = 0; // relative position to their parent
+    size_t nOldEntryCount = GetEntryCount();
+    sal_Int32 nOldScrollPos = 0;
+    if (xOldSelEntry)
+    {
+        UpdateLastSelType();
+
+        nOldScrollPos = m_xTreeView->vadjustment_get_value();
+        sEntryName = m_xTreeView->get_text(*xOldSelEntry);
+        std::unique_ptr<weld::TreeIter> xParentEntry = m_xTreeView->make_iterator(xOldSelEntry.get());
+        while (m_xTreeView->get_iter_depth(*xParentEntry))
+            m_xTreeView->iter_parent(*xParentEntry);
+        if (m_xTreeView->get_iter_depth(*xOldSelEntry))
+            nEntryRelPos = GetAbsPos(*xOldSelEntry) - GetAbsPos(*xParentEntry);
+    }
+
+    clear();
+
+    if (!bActive)
+        m_eState = State::HIDDEN;
+    else if (State::HIDDEN == m_eState)
+        m_eState = State::ACTIVE;
+    SwWrtShell* pShell = GetWrtShell();
+    const bool bReadOnly = !pShell || pShell->GetView().GetDocShell()->IsReadOnly();
+    if(bReadOnly != m_bIsLastReadOnly)
+    {
+        m_bIsLastReadOnly = bReadOnly;
+        bool bDisable =  pShell == nullptr || bReadOnly;
+        SwNavigationPI* pNavi = GetParentWindow();
+        pNavi->m_xContent3ToolBox->set_item_sensitive("chapterup", !bDisable);
+        pNavi->m_xContent3ToolBox->set_item_sensitive("chapterdown", !bDisable);
+        pNavi->m_xContent3ToolBox->set_item_sensitive("promote", !bDisable);
+        pNavi->m_xContent3ToolBox->set_item_sensitive("demote", !bDisable);
+        pNavi->m_xContent2ToolBox->set_item_sensitive("reminder", !bDisable);
+    }
+
+    if (pShell)
+    {
+        std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
+        std::unique_ptr<weld::TreeIter> xSelEntry;
+        // all content navigation view
+        if(m_nRootType == ContentTypeId::UNKNOWN)
+        {
+            m_xTreeView->freeze();
+
+            std::vector<std::unique_ptr<weld::TreeIter>> aNodesToExpand;
+
+            for( ContentTypeId nCntType : o3tl::enumrange<ContentTypeId>() )
+            {
+                std::unique_ptr<SwContentType>& rpContentT = bActive ?
+                                    m_aActiveContentArr[nCntType] :
+                                    m_aHiddenContentArr[nCntType];
+                if(!rpContentT)
+                    rpContentT.reset(new SwContentType(pShell, nCntType, m_nOutlineLevel ));
+
+                OUString sEntry = rpContentT->GetName();
+                OUString aImage(GetImageIdForContentTypeId(nCntType));
+                bool bChOnDemand = 0 != rpContentT->GetMemberCount();
+                OUString sId(OUString::number(reinterpret_cast<sal_Int64>(rpContentT.get())));
+                insert(nullptr, sEntry, sId, &aImage, bChOnDemand, xEntry.get());
+
+                m_xTreeView->set_sensitive(*xEntry, bChOnDemand);
+
+                if (nCntType == m_nLastSelType)
+                    xSelEntry = m_xTreeView->make_iterator(xEntry.get());
+                sal_Int32 nExpandOptions = (State::HIDDEN == m_eState)
+                                            ? m_nHiddenBlock
+                                            : m_nActiveBlock;
+                if (nExpandOptions & (1 << static_cast<int>(nCntType)))
+                {
+                    // fill contents of to-be expanded entries while frozen
+                    Expand(*xEntry, &aNodesToExpand);
+                    m_xTreeView->set_children_on_demand(*xEntry, false);
+                }
+            }
+
+            m_xTreeView->thaw();
+
+            // restore visual expanded tree state
+            for (const auto& rNode : aNodesToExpand)
+                m_xTreeView->expand_row(*rNode);
+
+            (void)m_xTreeView->get_iter_first(*xEntry);
+            for (ContentTypeId nCntType : o3tl::enumrange<ContentTypeId>())
+            {
+                sal_Int32 nExpandOptions = (State::HIDDEN == m_eState)
+                                            ? m_nHiddenBlock
+                                            : m_nActiveBlock;
+                if (nExpandOptions & (1 << static_cast<int>(nCntType)))
+                {
+                    if (nEntryRelPos && nCntType == m_nLastSelType)
+                    {
+                        // reselect the entry
+                        std::unique_ptr<weld::TreeIter> xChild(m_xTreeView->make_iterator(xEntry.get()));
+                        std::unique_ptr<weld::TreeIter> xTemp;
+                        sal_uLong nPos = 1;
+                        while (m_xTreeView->iter_next(*xChild))
+                        {
+                            // The old text will be slightly favored
+                            if (sEntryName == m_xTreeView->get_text(*xChild) ||
+                                nPos == nEntryRelPos)
+                            {
+                                m_xTreeView->copy_iterator(*xChild, *xSelEntry);
+                                break;
+                            }
+                            xTemp = m_xTreeView->make_iterator(xChild.get());
+                            nPos++;
+                        }
+                        if (!xSelEntry || lcl_IsContentType(*xSelEntry, *m_xTreeView))
+                            xSelEntry = std::move(xTemp);
+                    }
+                }
+
+                (void)m_xTreeView->iter_next_sibling(*xEntry);
+            }
+
+            if (!xSelEntry)
+            {
+                nOldScrollPos = 0;
+                xSelEntry = m_xTreeView->make_iterator();
+                if (!m_xTreeView->get_iter_first(*xSelEntry))
+                    xSelEntry.reset();
+            }
+
+            if (xSelEntry)
+            {
+                m_xTreeView->set_cursor(*xSelEntry);
+                Select();
+            }
+        }
+        // root content navigation view
+        else
+        {
+            m_xTreeView->freeze();
+
+            std::unique_ptr<SwContentType>& rpRootContentT = bActive ?
+                                    m_aActiveContentArr[m_nRootType] :
+                                    m_aHiddenContentArr[m_nRootType];
+            if(!rpRootContentT)
+                rpRootContentT.reset(new SwContentType(pShell, m_nRootType, m_nOutlineLevel ));
+            OUString aImage(GetImageIdForContentTypeId(m_nRootType));
+            bool bChOnDemand = m_nRootType == ContentTypeId::OUTLINE;
+            OUString sId(OUString::number(reinterpret_cast<sal_Int64>(rpRootContentT.get())));
+            insert(nullptr, rpRootContentT->GetName(), sId, &aImage, bChOnDemand, xEntry.get());
+
+            if (!bChOnDemand)
+            {
+                bool bRegion = rpRootContentT->GetType() == ContentTypeId::REGION;
+
+                std::unique_ptr<weld::TreeIter> xChild = m_xTreeView->make_iterator();
+                for (size_t i = 0; i < rpRootContentT->GetMemberCount(); ++i)
+                {
+                    const SwContent* pCnt = rpRootContentT->GetMember(i);
+                    if (pCnt)
+                    {
+                        OUString sEntry = pCnt->GetName();
+                        if(sEntry.isEmpty())
+                            sEntry = m_sSpace;
+                        OUString sSubId(OUString::number(reinterpret_cast<sal_Int64>(pCnt)));
+                        insert(xEntry.get(), sEntry, sSubId, nullptr, false, xChild.get());
+                        m_xTreeView->set_sensitive(*xChild, !pCnt->IsInvisible());
+                        if (bRegion)
+                            m_xTreeView->set_extra_row_indent(*xChild, static_cast<const SwRegionContent*>(pCnt)->GetRegionLevel());
+                    }
+                }
+            }
+            else
+            {
+                RequestingChildren(*xEntry);
+                m_xTreeView->set_children_on_demand(*xEntry, false);
+            }
+
+            m_xTreeView->set_sensitive(*xEntry, m_xTreeView->iter_has_child(*xEntry));
+
+            m_xTreeView->thaw();
+
+            m_xTreeView->expand_row(*xEntry);
+
+            // reselect the entry
+            if (nEntryRelPos)
+            {
+                std::unique_ptr<weld::TreeIter> xChild(m_xTreeView->make_iterator(xEntry.get()));
+                sal_uLong nPos = 1;
+                while (m_xTreeView->iter_next(*xChild))
+                {
+                    // The old text will be slightly favored
+                    if (sEntryName == m_xTreeView->get_text(*xChild) || nPos == nEntryRelPos)
+                    {
+                        xSelEntry = std::move(xChild);
+                        break;
+                    }
+                    nPos++;
+                }
+                if (xSelEntry)
+                {
+                    m_xTreeView->set_cursor(*xSelEntry); // unselect all entries, make pSelEntry visible, and select
+                    Select();
+                }
+            }
+            else
+            {
+                m_xTreeView->set_cursor(*xEntry);
+                Select();
+            }
+        }
+    }
+
+    if (!m_bIsInPromoteDemote && GetEntryCount() == nOldEntryCount)
+    {
+        m_xTreeView->vadjustment_set_value(nOldScrollPos);
+    }
+}
+
+void SwContentTree::clear()
+{
+    m_xTreeView->freeze();
+    m_xTreeView->clear();
+    m_nEntryCount = 0;
+    m_xTreeView->thaw();
+}
+
+bool SwContentTree::FillTransferData( TransferDataContainer& rTransfer,
+                                            sal_Int8& rDragMode )
+{
+    bool bRet = false;
+    SwWrtShell* pWrtShell = GetWrtShell();
+    OSL_ENSURE(pWrtShell, "no Shell!");
+
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    bool bEntry = m_xTreeView->get_cursor(xEntry.get());
+    if (!bEntry || lcl_IsContentType(*xEntry, *m_xTreeView) || !pWrtShell)
+        return false;
+    OUString sEntry;
+    assert(dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+    SwContent* pCnt = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64());
+
+    const ContentTypeId nActType = pCnt->GetParent()->GetType();
+    OUString sUrl;
+    bool bOutline = false;
+    OUString sOutlineText;
+    switch( nActType )
+    {
+        case ContentTypeId::OUTLINE:
+        {
+            const SwOutlineNodes::size_type nPos = static_cast<SwOutlineContent*>(pCnt)->GetOutlinePos();
+            OSL_ENSURE(nPos < pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNodesCount(),
+                       "outlinecnt changed");
+
+            // make sure outline may actually be copied
+            if( pWrtShell->IsOutlineCopyable( nPos ) )
+            {
+                const SwNumRule* pOutlRule = pWrtShell->GetOutlineNumRule();
+                const SwTextNode* pTextNd =
+                        pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineNode(nPos);
+                if (pTextNd && pOutlRule && pTextNd->IsNumbered(pWrtShell->GetLayout()))
+                {
+                    SwNumberTree::tNumberVector aNumVector =
+                        pTextNd->GetNumberVector(pWrtShell->GetLayout());
+                    for( int nLevel = 0;
+                         nLevel <= pTextNd->GetActualListLevel();
+                         nLevel++ )
+                    {
+                        const SwNumberTree::tSwNumTreeNumber nVal = aNumVector[nLevel] + 1;
+                        sEntry += OUString::number( nVal - pOutlRule->Get(nLevel).GetStart() ) + ".";
+                    }
+                }
+                sEntry += pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineText(nPos, pWrtShell->GetLayout(), false);
+                sOutlineText = pWrtShell->getIDocumentOutlineNodesAccess()->getOutlineText(nPos, pWrtShell->GetLayout());
+                m_bIsOutlineMoveable = static_cast<SwOutlineContent*>(pCnt)->IsMoveable();
+                bOutline = true;
+            }
+        }
+        break;
+        case ContentTypeId::POSTIT:
+        case ContentTypeId::INDEX:
+        case ContentTypeId::REFERENCE :
+            // cannot be inserted, neither as URL nor as section
+        break;
+        case ContentTypeId::URLFIELD:
+            sUrl = static_cast<SwURLFieldContent*>(pCnt)->GetURL();
+            [[fallthrough]];
+        case ContentTypeId::OLE:
+        case ContentTypeId::GRAPHIC:
+            if(GetParentWindow()->GetRegionDropMode() != RegionMode::NONE)
+                break;
+            else
+                rDragMode &= ~( DND_ACTION_MOVE | DND_ACTION_LINK );
+            [[fallthrough]];
+        default:
+            sEntry = m_xTreeView->get_text(*xEntry);
+    }
+
+    if(!sEntry.isEmpty())
+    {
+        const SwDocShell* pDocShell = pWrtShell->GetView().GetDocShell();
+        if(sUrl.isEmpty())
+        {
+            if(pDocShell->HasName())
+            {
+                SfxMedium* pMedium = pDocShell->GetMedium();
+                sUrl = pMedium->GetURLObject().GetURLNoMark();
+                // only if a primarily link shall be integrated.
+                bRet = true;
+            }
+            else if ( nActType == ContentTypeId::REGION || nActType == ContentTypeId::BOOKMARK )
+            {
+                // For field and bookmarks a link is also allowed
+                // without a filename into its own document.
+                bRet = true;
+            }
+            else if (State::CONSTANT == m_eState &&
+                    ( !::GetActiveView() ||
+                        m_pActiveShell != ::GetActiveView()->GetWrtShellPtr()))
+            {
+                // Urls of inactive views cannot dragged without
+                // file names, also.
+                bRet = false;
+            }
+            else
+            {
+                bRet = GetParentWindow()->GetRegionDropMode() == RegionMode::NONE;
+                rDragMode = DND_ACTION_MOVE;
+            }
+
+            const OUString& rToken = pCnt->GetParent()->GetTypeToken();
+            sUrl += "#" + sEntry;
+            if(!rToken.isEmpty())
+            {
+                sUrl += OUStringChar(cMarkSeparator) + rToken;
+            }
+        }
+        else
+            bRet = true;
+
+        if( bRet )
+        {
+            // In Outlines of heading text must match
+            // the real number into the description.
+            if(bOutline)
+                sEntry = sOutlineText;
+
+            {
+                NaviContentBookmark aBmk( sUrl, sEntry,
+                                    GetParentWindow()->GetRegionDropMode(),
+                                    pDocShell);
+                aBmk.Copy( rTransfer );
+            }
+
+            // An INetBookmark must a be delivered to foreign DocShells
+            if( pDocShell->HasName() )
+            {
+                INetBookmark aBkmk( sUrl, sEntry );
+                rTransfer.CopyINetBookmark( aBkmk );
+            }
+        }
+    }
+    return bRet;
+}
+
+void SwContentTree::ToggleToRoot()
+{
+    if(!m_bIsRoot)
+    {
+        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+        bool bEntry = m_xTreeView->get_cursor(xEntry.get());
+        const SwContentType* pCntType;
+        if (bEntry)
+        {
+            if (lcl_IsContentType(*xEntry, *m_xTreeView))
+            {
+                assert(dynamic_cast<SwContentType*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+                pCntType = reinterpret_cast<SwContentType*>(m_xTreeView->get_id(*xEntry).toInt64());
+            }
+            else
+            {
+                assert(dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+                pCntType = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetParent();
+            }
+            m_nRootType = pCntType->GetType();
+            m_bIsRoot = true;
+            Display(State::HIDDEN != m_eState);
+            if (m_nRootType == ContentTypeId::OUTLINE)
+            {
+                m_xTreeView->set_selection_mode(SelectionMode::Multiple);
+            }
+        }
+    }
+    else
+    {
+        m_xTreeView->set_selection_mode(SelectionMode::Single);
+        m_nRootType = ContentTypeId::UNKNOWN;
+        m_bIsRoot = false;
+        FindActiveTypeAndRemoveUserData();
+        Display(State::HIDDEN != m_eState);
+    }
+    m_pConfig->SetRootType( m_nRootType );
+    weld::Toolbar* pBox = GetParentWindow()->m_xContent2ToolBox.get();
+    pBox->set_item_active("root", m_bIsRoot);
+}
+
+bool SwContentTree::HasContentChanged()
+{
+    bool bContentChanged = false;
+
+//  - Run through the local array and the Treelistbox in parallel.
+//  - Are the records not expanded, they are discarded only in the array
+//    and the content type will be set as the new UserData.
+//  - Is the root mode is active only this will be updated.
+
+//  Valid for the displayed content types is:
+//  the Memberlist will be erased and the membercount will be updated
+//  If content will be checked, the memberlists will be replenished
+//  at the same time. Once a difference occurs it will be only replenished
+//  no longer checked. Finally, the box is filled again.
+
+    // bVisibilityChanged gets set to true if some element, like a section,
+    // changed visibility and should have its name rerendered with a new
+    // grayed-out state
+    bool bVisibilityChanged = false;
+
+    if (State::HIDDEN == m_eState)
+    {
+        for(ContentTypeId i : o3tl::enumrange<ContentTypeId>())
+        {
+            if(m_aActiveContentArr[i])
+                m_aActiveContentArr[i]->Invalidate();
+        }
+    }
+    // root content navigation view
+    else if(m_bIsRoot)
+    {
+        std::unique_ptr<weld::TreeIter> xRootEntry(m_xTreeView->make_iterator());
+        if (!m_xTreeView->get_iter_first(*xRootEntry))
+            bContentChanged = true;
+        else
+        {
+            assert(dynamic_cast<SwContentType*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xRootEntry).toInt64())));
+            const ContentTypeId nType = reinterpret_cast<SwContentType*>(m_xTreeView->get_id(*xRootEntry).toInt64())->GetType();
+            SwContentType* pArrType = m_aActiveContentArr[nType].get();
+            if (!pArrType)
+                bContentChanged = true;
+            else
+            {
+                // start check if first selected outline level has changed
+                bool bCheckChanged = m_nRootType == ContentTypeId::OUTLINE && !m_xTreeView->has_focus();
+                if (bCheckChanged)
+                {
+                    std::unique_ptr<weld::TreeIter> xFirstSel(m_xTreeView->make_iterator());
+                    bool bFirstSel = m_xTreeView->get_selected(xFirstSel.get());
+                    if (bFirstSel && lcl_IsContent(*xFirstSel, *m_xTreeView))
+                    {
+                        assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xFirstSel).toInt64())));
+                        const auto nSelLevel = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xFirstSel).toInt64())->GetOutlineLevel();
+                        SwWrtShell* pSh = GetWrtShell();
+                        const SwOutlineNodes::size_type nOutlinePos = pSh->GetOutlinePos(MAXLEVEL);
+                        if (nOutlinePos != SwOutlineNodes::npos && pSh->getIDocumentOutlineNodesAccess()->getOutlineLevel(nOutlinePos) != nSelLevel)
+                            bContentChanged = true;
+                    }
+                }
+                // end check if first selected outline level has changed
+
+                pArrType->Init(&bVisibilityChanged);
+                pArrType->FillMemberList();
+                OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pArrType)));
+                m_xTreeView->set_id(*xRootEntry, sId);
+                if (!bContentChanged)
+                {
+                    const size_t nChildCount = GetChildCount(*xRootEntry);
+                    if (nChildCount != pArrType->GetMemberCount())
+                        bContentChanged = true;
+                    else
+                    {
+                        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator(xRootEntry.get()));
+                        for (size_t j = 0; j < nChildCount; ++j)
+                        {
+                            m_xTreeView->iter_next(*xEntry);
+                            const SwContent* pCnt = pArrType->GetMember(j);
+                            OUString sSubId(OUString::number(reinterpret_cast<sal_Int64>(pCnt)));
+                            m_xTreeView->set_id(*xEntry, sSubId);
+                            OUString sEntryText = m_xTreeView->get_text(*xEntry);
+                            if( sEntryText != pCnt->GetName() &&
+                                !(sEntryText == m_sSpace && pCnt->GetName().isEmpty()))
+                                bContentChanged = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // all content navigation view
+    else
+    {
+        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+        bool bEntry = m_xTreeView->get_iter_first(*xEntry);
+        while (bEntry)
+        {
+            bool bNext = true; // at least a next must be
+            assert(dynamic_cast<SwContentType*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+            SwContentType* pCntType = reinterpret_cast<SwContentType*>(m_xTreeView->get_id(*xEntry).toInt64());
+            const size_t nCntCount = pCntType->GetMemberCount();
+            const ContentTypeId nType = pCntType->GetType();
+            SwContentType* pArrType = m_aActiveContentArr[nType].get();
+            if (!pArrType)
+                bContentChanged = true;
+            else
+            {
+                pArrType->Init(&bVisibilityChanged);
+                OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pArrType)));
+                m_xTreeView->set_id(*xEntry, sId);
+                if (m_xTreeView->get_row_expanded(*xEntry))
+                {
+                    bool bLevelOrVisibilityChanged = false;
+                    // bLevelOrVisibilityChanged is set if outlines have changed their level
+                    // or if the visibility of objects (frames, sections, tables) has changed
+                    // i.e. in header/footer
+                    pArrType->FillMemberList(&bLevelOrVisibilityChanged);
+                    const size_t nChildCount = GetChildCount(*xEntry);
+                    if (bLevelOrVisibilityChanged)
+                    {
+                        if (nType == ContentTypeId::OUTLINE)
+                            bContentChanged = true;
+                        else
+                            bVisibilityChanged = true;
+                    }
+
+                    if(nChildCount != pArrType->GetMemberCount())
+                        bContentChanged = true;
+                    else
+                    {
+                        for(size_t j = 0; j < nChildCount; ++j)
+                        {
+                            bEntry = m_xTreeView->iter_next(*xEntry);
+                            bNext = false;
+                            const SwContent* pCnt = pArrType->GetMember(j);
+                            OUString sSubId(OUString::number(reinterpret_cast<sal_Int64>(pCnt)));
+                            m_xTreeView->set_id(*xEntry, sSubId);
+                            OUString sEntryText = m_xTreeView->get_text(*xEntry);
+                            if( sEntryText != pCnt->GetName() &&
+                                !(sEntryText == m_sSpace && pCnt->GetName().isEmpty()))
+                                bContentChanged = true;
+                        }
+                    }
+                }
+                // not expanded and has children
+                else if (m_xTreeView->iter_has_child(*xEntry))
+                {
+                    // was the entry once opened, then must also the
+                    // invisible records be examined.
+                    // At least the user data must be updated.
+                    bool bLevelOrVisibilityChanged = false;
+                    // bLevelOrVisibilityChanged is set if outlines have changed their level
+                    // or if the visibility of objects (frames, sections, tables) has changed
+                    // i.e. in header/footer
+                    pArrType->FillMemberList(&bLevelOrVisibilityChanged);
+                    bool bRemoveChildren = false;
+                    const size_t nOldChildCount = GetChildCount(*xEntry);
+                    const size_t nNewChildCount = pArrType->GetMemberCount();
+                    if (nOldChildCount != nNewChildCount)
+                    {
+                        bRemoveChildren = true;
+                    }
+                    else
+                    {
+                        std::unique_ptr<weld::TreeIter> xChild(m_xTreeView->make_iterator(xEntry.get()));
+                        (void)m_xTreeView->iter_children(*xChild);
+                        for (size_t j = 0; j < nOldChildCount; ++j)
+                        {
+                            const SwContent* pCnt = pArrType->GetMember(j);
+                            OUString sSubId(OUString::number(reinterpret_cast<sal_Int64>(pCnt)));
+                            m_xTreeView->set_id(*xChild, sSubId);
+                            OUString sEntryText = m_xTreeView->get_text(*xChild);
+                            if( sEntryText != pCnt->GetName() &&
+                                !(sEntryText == m_sSpace && pCnt->GetName().isEmpty()))
+                                bRemoveChildren = true;
+                            (void)m_xTreeView->iter_next(*xChild);
+                        }
+                    }
+                    if (bRemoveChildren)
+                    {
+                        std::unique_ptr<weld::TreeIter> xRemove(m_xTreeView->make_iterator(xEntry.get()));
+                        while (m_xTreeView->iter_children(*xRemove))
+                        {
+                            remove(*xRemove);
+                            m_xTreeView->copy_iterator(*xEntry, *xRemove);
+                        }
+                        m_xTreeView->set_children_on_demand(*xEntry, nNewChildCount != 0);
+                    }
+                }
+                else if((nCntCount != 0)
+                            != (pArrType->GetMemberCount()!=0))
+                {
+                    bContentChanged = true;
+                }
+            }
+            // The Root-Entry has to be found now
+            while (bEntry && (bNext || m_xTreeView->get_iter_depth(*xEntry)))
+            {
+                bEntry = m_xTreeView->iter_next(*xEntry);
+                bNext = false;
+            }
+        }
+    }
+
+    if (!bContentChanged && bVisibilityChanged)
+        m_aUpdTimer.Start();
+
+    return bContentChanged || bVisibilityChanged;
+}
+
+void SwContentTree::UpdateLastSelType()
+{
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    if (m_xTreeView->get_selected(xEntry.get()))
+    {
+        while (m_xTreeView->get_iter_depth(*xEntry))
+            m_xTreeView->iter_parent(*xEntry);
+        sal_Int64 nId = m_xTreeView->get_id(*xEntry).toInt64();
+        if (nId && lcl_IsContentType(*xEntry, *m_xTreeView))
+        {
+            assert(dynamic_cast<SwContentType*>(reinterpret_cast<SwTypeNumber*>(nId)));
+            m_nLastSelType = reinterpret_cast<SwContentType*>(nId)->GetType();
+        }
+    }
+}
+
+void SwContentTree::FindActiveTypeAndRemoveUserData()
+{
+    UpdateLastSelType();
+
+    // If clear is called by TimerUpdate:
+    // Only for root can the validity of the UserData be guaranteed.
+    m_xTreeView->all_foreach([this](weld::TreeIter& rEntry){
+        m_xTreeView->set_id(rEntry, "");
+        return false;
+    });
+}
+
+void SwContentTree::SetHiddenShell(SwWrtShell* pSh)
+{
+    m_pHiddenShell = pSh;
+    m_eState = State::HIDDEN;
+    FindActiveTypeAndRemoveUserData();
+    for(ContentTypeId i : o3tl::enumrange<ContentTypeId>())
+    {
+        m_aHiddenContentArr[i].reset();
+    }
+    Display(false);
+
+    GetParentWindow()->UpdateListBox();
+}
+
+void SwContentTree::SetActiveShell(SwWrtShell* pSh)
+{
+    bool bClear = m_pActiveShell != pSh;
+    if (State::ACTIVE == m_eState && bClear)
+    {
+        if (m_pActiveShell)
+            EndListening(*m_pActiveShell->GetView().GetDocShell());
+        m_pActiveShell = pSh;
+        FindActiveTypeAndRemoveUserData();
+        clear();
+    }
+    else if (State::CONSTANT == m_eState)
+    {
+        if (m_pActiveShell)
+            EndListening(*m_pActiveShell->GetView().GetDocShell());
+        m_pActiveShell = pSh;
+        m_eState = State::ACTIVE;
+        bClear = true;
+    }
+    // Only if it is the active view, the array will be deleted and
+    // the screen filled new.
+    if (State::ACTIVE == m_eState && bClear)
+    {
+        if (m_pActiveShell)
+            StartListening(*m_pActiveShell->GetView().GetDocShell());
+        FindActiveTypeAndRemoveUserData();
+        for(ContentTypeId i : o3tl::enumrange<ContentTypeId>())
+        {
+            m_aActiveContentArr[i].reset();
+        }
+        Display(true);
+    }
+}
+
+void SwContentTree::SetConstantShell(SwWrtShell* pSh)
+{
+    if (m_pActiveShell)
+        EndListening(*m_pActiveShell->GetView().GetDocShell());
+    m_pActiveShell = pSh;
+    m_eState = State::CONSTANT;
+    StartListening(*m_pActiveShell->GetView().GetDocShell());
+    FindActiveTypeAndRemoveUserData();
+    for(ContentTypeId i : o3tl::enumrange<ContentTypeId>())
+    {
+        m_aActiveContentArr[i].reset();
+    }
+    Display(true);
+}
+
+void SwContentTree::Notify(SfxBroadcaster & rBC, SfxHint const& rHint)
+{
+    SfxViewEventHint const*const pVEHint(dynamic_cast<SfxViewEventHint const*>(&rHint));
+    SwXTextView* pDyingShell = nullptr;
+    if (m_pActiveShell && pVEHint && pVEHint->GetEventName() == "OnViewClosed")
+        pDyingShell = dynamic_cast<SwXTextView*>(pVEHint->GetController().get());
+    if (pDyingShell && pDyingShell->GetView() == &m_pActiveShell->GetView())
+    {
+        SetActiveShell(nullptr); // our view is dying, clear our pointers to it
+    }
+    else
+    {
+        SfxListener::Notify(rBC, rHint);
+    }
+    switch (rHint.GetId())
+    {
+        case SfxHintId::DocChanged:
+            if (!m_bIsInPromoteDemote)
+            {
+                m_bViewHasChanged = true;
+                TimerUpdate(&m_aUpdTimer);
+            }
+            break;
+        case SfxHintId::ModeChanged:
+            if (SwWrtShell* pShell = GetWrtShell())
+            {
+                const bool bReadOnly = pShell->GetView().GetDocShell()->IsReadOnly();
+                if (bReadOnly != m_bIsLastReadOnly)
+                {
+                    m_bIsLastReadOnly = bReadOnly;
+
+                    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+                    if (m_xTreeView->get_cursor(xEntry.get()))
+                    {
+                        m_xTreeView->select(*xEntry);
+                        Select();
+                    }
+                    else
+                        m_xTreeView->unselect_all();
+                }
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+void SwContentTree::ExecCommand(const OString& rCmd, bool bOutlineWithChildren)
+{
+    const bool bUp = rCmd == "chapterup";
+    const bool bUpDown = bUp || rCmd == "chapterdown";
+    const bool bLeft = rCmd == "promote";
+    const bool bLeftRight = bLeft || rCmd == "demote";
+    if (!bUpDown && !bLeftRight)
+        return;
+    if (GetWrtShell()->GetView().GetDocShell()->IsReadOnly() ||
+        (State::ACTIVE != m_eState &&
+         (State::CONSTANT != m_eState || m_pActiveShell != GetParentWindow()->GetCreateView()->GetWrtShellPtr())))
+    {
+        return;
+    }
+
+    m_bIsInPromoteDemote = true;
+
+    SwWrtShell *const pShell = GetWrtShell();
+    sal_Int8 nActOutlineLevel = m_nOutlineLevel;
+    SwOutlineNodes::size_type nActPos = pShell->GetOutlinePos(nActOutlineLevel);
+
+    std::vector<SwTextNode*> selectedOutlineNodes;
+    std::vector<std::unique_ptr<weld::TreeIter>> selected;
+
+    m_xTreeView->selected_foreach([this, pShell, &bLeftRight, &bOutlineWithChildren, &selected, &selectedOutlineNodes](weld::TreeIter& rEntry){
+        // it's possible to select the root node too which is a really bad idea
+        bool bSkip = lcl_IsContentType(rEntry, *m_xTreeView);
+        // filter out children of selected parents so they don't get promoted
+        // or moved twice (except if there is Ctrl modifier, since in that
+        // case children are re-parented)
+        if ((bLeftRight || bOutlineWithChildren) && !selected.empty())
+        {
+            std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(&rEntry));
+            for (bool bParent = m_xTreeView->iter_parent(*xParent); bParent; bParent = m_xTreeView->iter_parent(*xParent))
+            {
+                if (m_xTreeView->iter_compare(*selected.back(), *xParent) == 0)
+                {
+                    bSkip = true;
+                    break;
+                }
+            }
+        }
+        if (!bSkip)
+        {
+            selected.emplace_back(m_xTreeView->make_iterator(&rEntry));
+            const SwNodes& rNodes = pShell->GetNodes();
+            const size_t nPos = GetAbsPos(rEntry) - 1;
+            if (nPos < rNodes.GetOutLineNds().size())
+            {
+                SwNode* pNode = rNodes.GetOutLineNds()[ nPos ];
+                if (pNode)
+                {
+                    selectedOutlineNodes.push_back(pNode->GetTextNode());
+                }
+            }
+        }
+        return false;
+    });
+
+    if (bUpDown && !bUp)
+    {   // to move down, start at the end!
+        std::reverse(selected.begin(), selected.end());
+    }
+
+    SwOutlineNodes::difference_type nDirLast = bUp ? -1 : 1;
+    bool bStartedAction = false;
+    for (auto const& pCurrentEntry : selected)
+    {
+        assert(pCurrentEntry && lcl_IsContent(*pCurrentEntry, *m_xTreeView));
+        if (lcl_IsContent(*pCurrentEntry, *m_xTreeView))
+        {
+            assert(dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*pCurrentEntry).toInt64())));
+            if ((m_bIsRoot && m_nRootType == ContentTypeId::OUTLINE) ||
+                reinterpret_cast<SwContent*>(m_xTreeView->get_id(*pCurrentEntry).toInt64())->GetParent()->GetType()
+                                            ==  ContentTypeId::OUTLINE)
+            {
+                nActPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*pCurrentEntry).toInt64())->GetOutlinePos();
+            }
+        }
+        if (nActPos == SwOutlineNodes::npos || (bUpDown && !pShell->IsOutlineMovable(nActPos)))
+        {
+            continue;
+        }
+
+        if (!bStartedAction)
+        {
+            pShell->StartAllAction();
+            pShell->StartUndo(bLeftRight ? SwUndoId::OUTLINE_LR : SwUndoId::OUTLINE_UD);
+            bStartedAction = true;
+        }
+        pShell->GotoOutline( nActPos); // If text selection != box selection
+        pShell->Push();
+        pShell->MakeOutlineSel(nActPos, nActPos, bOutlineWithChildren);
+        if (bUpDown)
+        {
+            const size_t nEntryAbsPos(GetAbsPos(*pCurrentEntry));
+            SwOutlineNodes::difference_type nDir = bUp ? -1 : 1;
+            if (!bOutlineWithChildren && ((nDir == -1 && nActPos > 0) ||
+                       (nDir == 1 && nEntryAbsPos < GetEntryCount() - 2)))
+            {
+                pShell->MoveOutlinePara( nDir );
+                // Set cursor back to the current position
+                pShell->GotoOutline( nActPos + nDir);
+            }
+            else if (bOutlineWithChildren)
+            {
+                SwOutlineNodes::size_type nActEndPos = nActPos;
+                std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator(pCurrentEntry.get()));
+                assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*pCurrentEntry).toInt64())));
+                const auto nActLevel = reinterpret_cast<SwOutlineContent*>(
+                        m_xTreeView->get_id(*pCurrentEntry).toInt64())->GetOutlineLevel();
+                bool bEntry = m_xTreeView->iter_next(*xEntry);
+                while (bEntry && lcl_IsContent(*xEntry, *m_xTreeView))
+                {
+                    assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+                    if (nActLevel >= reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetOutlineLevel())
+                        break;
+                    nActEndPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetOutlinePos();
+                    bEntry = m_xTreeView->iter_next(*xEntry);
+                }
+                if (nDir == 1) // move down
+                {
+                    std::unique_ptr<weld::TreeIter> xNextSibling(m_xTreeView->make_iterator(pCurrentEntry.get()));
+                    if (m_xTreeView->iter_next_sibling(*xNextSibling) && m_xTreeView->is_selected(*xNextSibling))
+                        nDir = nDirLast;
+                    else
+                    {
+                    // If the last entry is to be moved we're done
+                    if (bEntry && lcl_IsContent(*xEntry, *m_xTreeView))
+                    {
+                        // xEntry now points to the entry following the last
+                        // selected entry.
+                        SwOutlineNodes::size_type nDest = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetOutlinePos();
+                        // here needs to found the next entry after next.
+                        // The selection must be inserted in front of that.
+                        while (bEntry)
+                        {
+                            bEntry = m_xTreeView->iter_next(*xEntry);
+                            assert(!bEntry || !lcl_IsContent(*xEntry, *m_xTreeView)||
+                                   dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+                            // nDest++ may only executed if bEntry
+                            if (bEntry)
+                            {
+                                if (!lcl_IsContent(*xEntry, *m_xTreeView))
+                                    break;
+                                else if (nActLevel >= reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetOutlineLevel())
+                                {
+                                    // nDest needs adjusted if there are selected entries (including ancestral lineage)
+                                    // immediately before the current moved entry.
+                                    std::unique_ptr<weld::TreeIter> xTmp(m_xTreeView->make_iterator(xEntry.get()));
+                                    bool bTmp = m_xTreeView->iter_previous(*xTmp);
+                                    while (bTmp && lcl_IsContent(*xTmp, *m_xTreeView) &&
+                                           nActLevel < reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlineLevel())
+                                    {
+                                        while (bTmp && lcl_IsContent(*xTmp, *m_xTreeView) && !m_xTreeView->is_selected(*xTmp) &&
+                                               nActLevel < reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlineLevel())
+                                        {
+                                            bTmp = m_xTreeView->iter_parent(*xTmp);
+                                        }
+                                        if (!bTmp || !m_xTreeView->is_selected(*xTmp))
+                                            break;
+                                        bTmp = m_xTreeView->iter_previous(*xTmp);
+                                        nDest = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlinePos();
+                                    }
+                                    std::unique_ptr<weld::TreeIter> xPrevSibling(m_xTreeView->make_iterator(xEntry.get()));
+                                    if (!m_xTreeView->iter_previous_sibling(*xPrevSibling) || !m_xTreeView->is_selected(*xPrevSibling))
+                                        break;
+                                }
+                                else
+                                {
+                                    nDest = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetOutlinePos();
+                                }
+                            }
+                        }
+                        nDirLast = nDir = nDest - nActEndPos;
+                        // If no entry was found that allows insertion before
+                        // it, we just move it to the end.
+                    }
+                    else
+                        nDirLast = nDir = 0;
+                    }
+                }
+                else // move up
+                {
+                    std::unique_ptr<weld::TreeIter> xPrevSibling(m_xTreeView->make_iterator(pCurrentEntry.get()));
+                    if (m_xTreeView->iter_previous_sibling(*xPrevSibling) && m_xTreeView->is_selected(*xPrevSibling))
+                        nDir = nDirLast;
+                    else
+                    {
+                        SwOutlineNodes::size_type nDest = nActPos;
+                        bEntry = true;
+                        m_xTreeView->copy_iterator(*pCurrentEntry, *xEntry);
+                        while (bEntry && nDest)
+                        {
+                            bEntry = m_xTreeView->iter_previous(*xEntry);
+                            assert(!bEntry || !lcl_IsContent(*xEntry, *m_xTreeView) ||
+                                   dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+                            if (bEntry && lcl_IsContent(*xEntry, *m_xTreeView))
+                            {
+                                nDest = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetOutlinePos();
+                            }
+                            else
+                            {
+                                nDest = 0; // presumably?
+                            }
+                            if (bEntry)
+                            {
+                                if (!lcl_IsContent(*xEntry, *m_xTreeView))
+                                    break;
+                                else if (nActLevel >= reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetOutlineLevel())
+                                {
+                                    // nDest needs adjusted if there are selected entries immediately
+                                    // after the level change.
+                                    std::unique_ptr<weld::TreeIter> xTmp(m_xTreeView->make_iterator(xEntry.get()));
+                                    bool bTmp = m_xTreeView->iter_next(*xTmp);
+                                    while (bTmp && lcl_IsContent(*xTmp, *m_xTreeView) &&
+                                           nActLevel < reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlineLevel() &&
+                                           m_xTreeView->is_selected(*xTmp))
+                                    {
+                                        nDest = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlinePos();
+                                        const auto nLevel = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlineLevel();
+                                        // account for selected entries' descendent lineage
+                                        bTmp = m_xTreeView->iter_next(*xTmp);
+                                        while (bTmp && lcl_IsContent(*xTmp, *m_xTreeView) &&
+                                               nLevel < reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlineLevel())
+                                        {
+                                            nDest = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xTmp).toInt64())->GetOutlinePos();
+                                            bTmp = m_xTreeView->iter_next(*xTmp);
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                        nDirLast = nDir = nDest - nActPos;
+                    }
+                }
+                if (nDir)
+                {
+                    pShell->MoveOutlinePara( nDir );
+                    // Set cursor back to the current position
+                    pShell->GotoOutline(nActPos + nDir);
+                }
+            }
+        }
+        else
+        {
+            if (!pShell->IsProtectedOutlinePara())
+                pShell->OutlineUpDown(bLeft ? -1 : 1);
+        }
+
+        pShell->ClearMark();
+        pShell->Pop(SwCursorShell::PopMode::DeleteCurrent); // Cursor is now back at the current heading.
+    }
+
+    if (bStartedAction)
+    {
+        pShell->EndUndo();
+        pShell->EndAllAction();
+        if (m_aActiveContentArr[ContentTypeId::OUTLINE])
+            m_aActiveContentArr[ContentTypeId::OUTLINE]->Invalidate();
+
+        // clear all selections to prevent the Display function from trying to reselect selected entries
+        m_xTreeView->unselect_all();
+        Display(true);
+
+        // reselect entries
+        const SwOutlineNodes::size_type nCurrPos = pShell->GetOutlinePos(MAXLEVEL);
+        std::unique_ptr<weld::TreeIter> xListEntry(m_xTreeView->make_iterator());
+        bool bListEntry = m_xTreeView->get_iter_first(*xListEntry);
+        while ((bListEntry = m_xTreeView->iter_next(*xListEntry)) && lcl_IsContent(*xListEntry, *m_xTreeView))
+        {
+            assert(dynamic_cast<SwOutlineContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xListEntry).toInt64())));
+            if (reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*xListEntry).toInt64())->GetOutlinePos() == nCurrPos)
+            {
+                std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(xListEntry.get()));
+                if (m_xTreeView->iter_parent(*xParent) && !m_xTreeView->get_row_expanded(*xParent))
+                    m_xTreeView->expand_row(*xParent);
+                m_xTreeView->set_cursor(*xListEntry); // unselect all entries, make entry visible, set focus, and select
+                Select();
+                break;
+            }
+        }
+
+        if (m_bIsRoot)
+        {
+            const SwOutlineNodes& rOutLineNds = pShell->GetNodes().GetOutLineNds();
+            for (SwTextNode* pNode : selectedOutlineNodes)
+            {
+                SwOutlineNodes::const_iterator aFndIt = rOutLineNds.find(pNode);
+                if(aFndIt == rOutLineNds.end())
+                    continue;
+                const size_t nFndPos = aFndIt - rOutLineNds.begin();
+                std::unique_ptr<weld::TreeIter> xEntry = GetEntryAtAbsPos(nFndPos + 1);
+                if (xEntry)
+                {
+                    m_xTreeView->select(*xEntry);
+                    std::unique_ptr<weld::TreeIter> xParent(m_xTreeView->make_iterator(xEntry.get()));
+                    if (m_xTreeView->iter_parent(*xParent) && !m_xTreeView->get_row_expanded(*xParent))
+                        m_xTreeView->expand_row(*xParent);
+                }
+            }
+        }
+    }
+    m_bIsInPromoteDemote = false;
+}
+
+void SwContentTree::ShowTree()
+{
+    m_xTreeView->show();
+    m_aUpdTimer.Start();
+}
+
+void SwContentTree::HideTree()
+{
+    // folded together will not be idled
+    m_aUpdTimer.Stop();
+    m_xTreeView->hide();
+}
+
+/** No idle with focus or while dragging */
+IMPL_LINK_NOARG(SwContentTree, TimerUpdate, Timer *, void)
+{
+    // No update while focus is not in document.
+    // No update while drag and drop.
+    // Query view because the Navigator is cleared too late.
+    SwView* pView = GetParentWindow()->GetCreateView();
+    if(pView && pView->GetWrtShellPtr() && pView->GetWrtShellPtr()->GetWin() &&
+        (pView->GetWrtShellPtr()->GetWin()->HasFocus() || m_bViewHasChanged) &&
+        !IsInDrag() && !pView->GetWrtShellPtr()->ActionPend())
+    {
+        m_bViewHasChanged = false;
+        m_bIsIdleClear = false;
+        SwWrtShell* pActShell = pView->GetWrtShellPtr();
+        if (State::CONSTANT == m_eState && !lcl_FindShell(m_pActiveShell))
+        {
+            SetActiveShell(pActShell);
+            GetParentWindow()->UpdateListBox();
+        }
+
+        if (State::ACTIVE == m_eState && pActShell != GetWrtShell())
+        {
+            SetActiveShell(pActShell);
+        }
+        else if ((State::ACTIVE == m_eState || (State::CONSTANT == m_eState && pActShell == GetWrtShell())) &&
+                    HasContentChanged())
+        {
+            FindActiveTypeAndRemoveUserData();
+            Display(true);
+        }
+
+        // track document outline position at cursor
+        if (m_nOutlineTracking == 3) // no outline tracking
+            return;
+
+        const SwOutlineNodes::size_type nActPos = GetWrtShell()->GetOutlinePos(MAXLEVEL); // find out where the cursor is
+        if (nActPos == SwOutlineNodes::npos)
+            return;
+
+        // only track if selection is already an outline
+        std::unique_ptr<weld::TreeIter> xFirstSelected(m_xTreeView->make_iterator());
+        if (!m_xTreeView->get_selected(xFirstSelected.get()))
+            xFirstSelected.reset();
+        if (xFirstSelected && lcl_IsContent(*xFirstSelected, *m_xTreeView) &&
+                reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xFirstSelected).toInt64())->GetParent()->GetType() != ContentTypeId::OUTLINE)
+            return;
+        if (xFirstSelected && lcl_IsContentType(*xFirstSelected, *m_xTreeView) &&
+                reinterpret_cast<SwContentType*>(m_xTreeView->get_id(*xFirstSelected).toInt64())->GetType() != ContentTypeId::OUTLINE)
+            return;
+
+        int nSelectedRows = m_xTreeView->count_selected_rows();
+
+        // find the outline in the tree and select it
+        m_xTreeView->all_foreach([this, nSelectedRows, nActPos, &xFirstSelected](weld::TreeIter& rEntry){
+            bool bRet = false;
+
+            if (lcl_IsContent(rEntry, *m_xTreeView) &&
+                    reinterpret_cast<SwContent*>(m_xTreeView->get_id(rEntry).toInt64())->GetParent()->GetType() == ContentTypeId::OUTLINE)
+            {
+                // might have been scrolled out of view by the user so leave it that way
+                if (reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(rEntry).toInt64())->GetOutlinePos() == nActPos)
+                {
+                    // only select if not already selected or tree has multiple entries selected
+                    if (nSelectedRows != 1 || m_xTreeView->iter_compare(rEntry, *xFirstSelected) != 0)
+                    {
+                        if (m_nOutlineTracking == 2) // focused outline tracking
+                        {
+                            // collapse to children of root node
+                            std::unique_ptr<weld::TreeIter> xChildEntry(m_xTreeView->make_iterator());
+                            if (m_xTreeView->get_iter_first(*xChildEntry) && m_xTreeView->iter_children(*xChildEntry))
+                            {
+                                do
+                                {
+                                    if (reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xChildEntry).toInt64())->GetParent()->GetType() == ContentTypeId::OUTLINE)
+                                        m_xTreeView->collapse_row(*xChildEntry);
+                                    else
+                                        break;
+                                }
+                                while (m_xTreeView->iter_next(*xChildEntry));
+                            }
+                        }
+                        m_xTreeView->set_cursor(rEntry); // unselect all entries, make pEntry visible, and select
+                        Select();
+                    }
+                    bRet = true;
+                }
+            }
+            else
+            {
+                // use of this break assumes outline content type is first in tree
+                if (lcl_IsContentType(rEntry, *m_xTreeView) &&
+                        reinterpret_cast<SwContentType*>(m_xTreeView->get_id(rEntry).toInt64())->GetType() != ContentTypeId::OUTLINE)
+                    bRet = true;
+            }
+
+            return bRet;
+        });
+    }
+    else if (!pView && State::ACTIVE == m_eState && !m_bIsIdleClear)
+    {
+        if(m_pActiveShell)
+        {
+            SetActiveShell(nullptr);
+        }
+        clear();
+        m_bIsIdleClear = true;
+    }
+}
+
+void SwContentTree::MoveOutline(SwOutlineNodes::size_type nTargetPos)
+{
+    SwWrtShell *const pShell = GetWrtShell();
+    pShell->StartAllAction();
+    pShell->StartUndo(SwUndoId::OUTLINE_UD);
+
+    SwOutlineNodes::size_type nPrevSourcePos = SwOutlineNodes::npos;
+    SwOutlineNodes::size_type nPrevTargetPosOrOffset = SwOutlineNodes::npos;
+
+    bool bFirstMove = true;
+
+    for (const auto& source : m_aDndOutlinesSelected)
+    {
+        SwOutlineNodes::size_type nSourcePos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(*source).toInt64())->GetOutlinePos();
+
+        // Done on the first selection move
+        if (bFirstMove) // only do once
+        {
+            if (nTargetPos == SwOutlineNodes::npos || nSourcePos > nTargetPos)
+            {
+                // Up moves
+                // The first up move sets the up move amount for the remaining selected outlines to be moved
+                if (nTargetPos != SwOutlineNodes::npos)
+                    nPrevTargetPosOrOffset = nSourcePos - nTargetPos;
+                else
+                    nPrevTargetPosOrOffset = nSourcePos + 1;
+            }
+            else if (nSourcePos < nTargetPos)
+            {
+                // Down moves
+                // The first down move sets the source and target positions for the remaining selected outlines to be moved
+                nPrevSourcePos = nSourcePos;
+                nPrevTargetPosOrOffset = nTargetPos;
+            }
+            bFirstMove = false;
+        }
+        else
+        {
+            if (nTargetPos == SwOutlineNodes::npos || nSourcePos > nTargetPos)
+            {
+                // Move up
+                nTargetPos = nSourcePos - nPrevTargetPosOrOffset;
+            }
+            else if (nSourcePos < nTargetPos)
+            {
+                // Move down
+                nSourcePos = nPrevSourcePos;
+                nTargetPos = nPrevTargetPosOrOffset;
+            }
+        }
+        GetParentWindow()->MoveOutline(nSourcePos, nTargetPos);
+    }
+
+    pShell->EndUndo();
+    pShell->EndAllAction();
+    m_aActiveContentArr[ContentTypeId::OUTLINE]->Invalidate();
+    Display(true);
+    m_aDndOutlinesSelected.clear();
+}
+
+// Update immediately
+IMPL_LINK_NOARG(SwContentTree, FocusHdl, weld::Widget&, void)
+{
+    SwView* pActView = GetParentWindow()->GetCreateView();
+    if(pActView)
+    {
+        SwWrtShell* pActShell = pActView->GetWrtShellPtr();
+        if (State::CONSTANT == m_eState && !lcl_FindShell(m_pActiveShell))
+        {
+            SetActiveShell(pActShell);
+        }
+
+        if (State::ACTIVE == m_eState && pActShell != GetWrtShell())
+            SetActiveShell(pActShell);
+        else if ((State::ACTIVE == m_eState || (State::CONSTANT == m_eState && pActShell == GetWrtShell())) &&
+                    HasContentChanged())
+        {
+            Display(true);
+        }
+    }
+    else if (State::ACTIVE == m_eState)
+        clear();
+}
+
+IMPL_LINK(SwContentTree, KeyInputHdl, const KeyEvent&, rEvent, bool)
+{
+    bool bConsumed = true;
+
+    const vcl::KeyCode aCode = rEvent.GetKeyCode();
+    if (aCode.GetCode() == KEY_MULTIPLY && aCode.IsMod1())
+    {
+        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+        if (m_xTreeView->get_selected(xEntry.get()))
+            ExpandOrCollapseAll(*m_xTreeView, *xEntry);
+    }
+    else if (aCode.GetCode() == KEY_RETURN)
+    {
+        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+        if (m_xTreeView->get_selected(xEntry.get()))
+        {
+            switch(aCode.GetModifier())
+            {
+                case KEY_MOD2:
+                    // Switch boxes
+                    GetParentWindow()->ToggleTree();
+                break;
+                case KEY_MOD1:
+                    // Switch RootMode
+                    ToggleToRoot();
+                break;
+                case 0:
+                    if (lcl_IsContentType(*xEntry, *m_xTreeView))
+                    {
+                        m_xTreeView->get_row_expanded(*xEntry) ? m_xTreeView->collapse_row(*xEntry)
+                                                               : m_xTreeView->expand_row(*xEntry);
+                    }
+                    else
+                        ContentDoubleClickHdl(*m_xTreeView);
+                break;
+            }
+        }
+    }
+    else if(aCode.GetCode() == KEY_DELETE && 0 == aCode.GetModifier())
+    {
+        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+        if (m_xTreeView->get_selected(xEntry.get()) && lcl_IsContent(*xEntry, *m_xTreeView))
+        {
+            assert(dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64())));
+            if (reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetParent()->IsDeletable() &&
+                    !m_pActiveShell->GetView().GetDocShell()->IsReadOnly())
+            {
+                EditEntry(*xEntry, EditEntryMode::DELETE);
+            }
+        }
+    }
+    //Make KEY_SPACE has same function as DoubleClick ,
+    //and realize multi-selection .
+    else if (aCode.GetCode() == KEY_SPACE && 0 == aCode.GetModifier())
+    {
+        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+        if (m_xTreeView->get_cursor(xEntry.get()))
+        {
+            if (State::HIDDEN != m_eState)
+            {
+                if (State::CONSTANT == m_eState)
+                {
+                    m_pActiveShell->GetView().GetViewFrame()->GetWindow().ToTop();
+                }
+
+                SwContent* pCnt = dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64()));
+
+                if (pCnt && pCnt->GetParent()->GetType() == ContentTypeId::DRAWOBJECT)
+                {
+                    SdrView* pDrawView = m_pActiveShell->GetDrawView();
+                    if (pDrawView)
+                    {
+                        pDrawView->SdrEndTextEdit();
+
+                        SwDrawModel* pDrawModel = m_pActiveShell->GetDoc()->getIDocumentDrawModelAccess().GetDrawModel();
+                        SdrPage* pPage = pDrawModel->GetPage(0);
+                        const size_t nCount = pPage->GetObjCount();
+                        bool hasObjectMarked = false;
+
+                        if (SdrObject* pObject = GetDrawingObjectsByContent(pCnt))
+                        {
+                            SdrPageView* pPV = pDrawView->GetSdrPageView/*GetPageViewPvNum*/(/*0*/);
+                            if( pPV )
+                            {
+                                bool bUnMark = pDrawView->IsObjMarked(pObject);
+                                pDrawView->MarkObj( pObject, pPV, bUnMark);
+
+                            }
+                        }
+                        for( size_t i=0; i<nCount; ++i )
+                        {
+                            SdrObject* pTemp = pPage->GetObj(i);
+                            bool bMark = pDrawView->IsObjMarked(pTemp);
+                            switch( pTemp->GetObjIdentifier() )
+                            {
+                                case OBJ_GRUP:
+                                case OBJ_TEXT:
+                                case OBJ_LINE:
+                                case OBJ_RECT:
+                                case OBJ_CIRC:
+                                case OBJ_SECT:
+                                case OBJ_CARC:
+                                case OBJ_CCUT:
+                                case OBJ_POLY:
+                                case OBJ_PLIN:
+                                case OBJ_PATHLINE:
+                                case OBJ_PATHFILL:
+                                case OBJ_FREELINE:
+                                case OBJ_FREEFILL:
+                                case OBJ_PATHPOLY:
+                                case OBJ_PATHPLIN:
+                                case OBJ_CAPTION:
+                                case OBJ_CUSTOMSHAPE:
+                                    if( bMark )
+                                        hasObjectMarked = true;
+                                    break;
+                                default:
+                                    if ( bMark )
+                                    {
+                                        SdrPageView* pPV = pDrawView->GetSdrPageView/*GetPageViewPvNum*/(/*0*/);
+                                        if (pPV)
+                                        {
+                                            pDrawView->MarkObj(pTemp, pPV, true);
+                                        }
+                                    }
+                            }
+                            //mod end
+                        }
+                        if ( !hasObjectMarked )
+                        {
+                            SwEditWin& rEditWindow = m_pActiveShell->GetView().GetEditWin();
+                            vcl::KeyCode tempKeycode( KEY_ESCAPE );
+                            KeyEvent rKEvt( 0 , tempKeycode );
+                            static_cast<vcl::Window*>(&rEditWindow)->KeyInput( rKEvt );
+                        }
+                    }
+                }
+
+                m_bViewHasChanged = true;
+            }
+        }
+    }
+    else
+    {
+        std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+        if (m_xTreeView->get_cursor(xEntry.get()))
+        {
+            SwContent* pCnt = dynamic_cast<SwContent*>(reinterpret_cast<SwTypeNumber*>(m_xTreeView->get_id(*xEntry).toInt64()));
+            if (pCnt && pCnt->GetParent()->GetType() == ContentTypeId::OUTLINE)
+            {
+                if (m_bIsRoot && aCode.GetCode() == KEY_LEFT && aCode.GetModifier() == 0)
+                {
+                    m_xTreeView->unselect_all();
+                    bConsumed = false;
+                }
+                else if (aCode.IsMod1())
+                {
+                    if (aCode.GetCode() == KEY_LEFT)
+                        ExecCommand("promote", !aCode.IsShift());
+                    else if (aCode.GetCode() == KEY_RIGHT)
+                        ExecCommand("demote", !aCode.IsShift());
+                    else if (aCode.GetCode() == KEY_UP)
+                        ExecCommand("chapterup", !aCode.IsShift());
+                    else if (aCode.GetCode() == KEY_DOWN)
+                        ExecCommand("chapterdown", !aCode.IsShift());
+                    else
+                        bConsumed = false;
+                }
+                else
+                    bConsumed = false;
+            }
+            else
+                bConsumed = false;
+        }
+        else
+            bConsumed = false;
+    }
+    return bConsumed;
+}
+
+IMPL_LINK(SwContentTree, QueryTooltipHdl, const weld::TreeIter&, rEntry, OUString)
+{
+    ContentTypeId nType;
+    bool bContent = false;
+    void* pUserData = reinterpret_cast<void*>(m_xTreeView->get_id(rEntry).toInt64());
+    if (lcl_IsContentType(rEntry, *m_xTreeView))
+    {
+        assert(dynamic_cast<SwContentType*>(static_cast<SwTypeNumber*>(pUserData)));
+        nType = static_cast<SwContentType*>(pUserData)->GetType();
+    }
+    else
+    {
+        assert(dynamic_cast<SwContent*>(static_cast<SwTypeNumber*>(pUserData)));
+        nType = static_cast<SwContent*>(pUserData)->GetParent()->GetType();
+        bContent = true;
+    }
+    OUString sEntry;
+    if(bContent)
+    {
+        switch( nType )
+        {
+            case ContentTypeId::URLFIELD:
+                assert(dynamic_cast<SwURLFieldContent*>(static_cast<SwTypeNumber*>(pUserData)));
+                sEntry = static_cast<SwURLFieldContent*>(pUserData)->GetURL();
+            break;
+
+            case ContentTypeId::POSTIT:
+                assert(dynamic_cast<SwPostItContent*>(static_cast<SwTypeNumber*>(pUserData)));
+                sEntry = static_cast<SwPostItContent*>(pUserData)->GetName();
+            break;
+            case ContentTypeId::OUTLINE:
+                assert(dynamic_cast<SwOutlineContent*>(static_cast<SwTypeNumber*>(pUserData)));
+                sEntry = static_cast<SwOutlineContent*>(pUserData)->GetName();
+            break;
+            case ContentTypeId::GRAPHIC:
+                assert(dynamic_cast<SwGraphicContent*>(static_cast<SwTypeNumber*>(pUserData)));
+                sEntry = static_cast<SwGraphicContent*>(pUserData)->GetLink();
+            break;
+            case ContentTypeId::REGION:
+            {
+                assert(dynamic_cast<SwRegionContent*>(static_cast<SwTypeNumber*>(pUserData)));
+                sEntry = static_cast<SwRegionContent*>(pUserData)->GetName();
+                const SwSectionFormats& rFormats = GetWrtShell()->GetDoc()->GetSections();
+                for (SwSectionFormats::size_type n = rFormats.size(); n;)
+                {
+                    const SwNodeIndex* pIdx = nullptr;
+                    const SwSectionFormat* pFormat = rFormats[--n];
+                    const SwSection* pSect;
+                    if (nullptr != (pSect = pFormat->GetSection()) &&
+                        pSect->GetSectionName() == sEntry &&
+                        nullptr != (pIdx = pFormat->GetContent().GetContentIdx()) &&
+                        pIdx->GetNode().GetNodes().IsDocNodes())
+                    {
+                        SwDocStat aDocStat;
+                        SwPaM aPaM(*pIdx, *pIdx->GetNode().EndOfSectionNode());
+                        SwDoc::CountWords(aPaM, aDocStat);
+                        sEntry = SwResId(STR_REGION_DEFNAME) + ": " + sEntry + "\n" +
+                                 SwResId(FLD_STAT_WORD) + ": " + OUString::number(aDocStat.nWord) + "\n" +
+                                 SwResId(FLD_STAT_CHAR) + ": " + OUString::number(aDocStat.nChar);
+                        break;
+                    }
+                }
+            }
+            break;
+            default: break;
+        }
+        if(static_cast<SwContent*>(pUserData)->IsInvisible())
+        {
+            if(!sEntry.isEmpty())
+                sEntry += ", ";
+            sEntry += m_sInvisible;
+        }
+    }
+    else
+    {
+        const size_t nMemberCount = static_cast<SwContentType*>(pUserData)->GetMemberCount();
+        sEntry = OUString::number(nMemberCount) + " " +
+            (nMemberCount == 1
+                    ? static_cast<SwContentType*>(pUserData)->GetSingleName()
+                    : static_cast<SwContentType*>(pUserData)->GetName());
+    }
+
+    return sEntry;
+}
+
+void SwContentTree::ExecuteContextMenuAction(const OString& rSelectedPopupEntry)
+{
+    std::unique_ptr<weld::TreeIter> xFirst(m_xTreeView->make_iterator());
+    if (!m_xTreeView->get_selected(xFirst.get()))
+        xFirst.reset();
+
+    auto nSelectedPopupEntry = rSelectedPopupEntry.toUInt32();
+    switch (nSelectedPopupEntry)
+    {
+        case 11:
+        case 12:
+        case 13:
+            nSelectedPopupEntry -= 10;
+            if(m_nOutlineTracking != nSelectedPopupEntry)
+                m_nOutlineTracking = nSelectedPopupEntry;
+        break;
+        //Outlinelevel
+        case 101:
+        case 102:
+        case 103:
+        case 104:
+        case 105:
+        case 106:
+        case 107:
+        case 108:
+        case 109:
+        case 110:
+            nSelectedPopupEntry -= 100;
+            if(m_nOutlineLevel != nSelectedPopupEntry )
+                SetOutlineLevel(static_cast<sal_Int8>(nSelectedPopupEntry));
+        break;
+        case 201:
+        case 202:
+        case 203:
+            GetParentWindow()->SetRegionDropMode(static_cast<RegionMode>(nSelectedPopupEntry - 201));
+        break;
+        case 401:
+        case 402:
+            EditEntry(*xFirst, nSelectedPopupEntry == 401 ? EditEntryMode::RMV_IDX : EditEntryMode::UPD_IDX);
+        break;
+        // Edit entry
+        case 403:
+            EditEntry(*xFirst, EditEntryMode::EDIT);
+        break;
+        case 404:
+            EditEntry(*xFirst, EditEntryMode::UNPROTECT_TABLE);
+        break;
+        case 405 :
+        {
+            const SwTOXBase* pBase = reinterpret_cast<SwTOXBaseContent*>(m_xTreeView->get_id(*xFirst).toInt64())
+                                                                ->GetTOXBase();
+            m_pActiveShell->SetTOXBaseReadonly(*pBase, !SwEditShell::IsTOXBaseReadonly(*pBase));
+        }
+        break;
+        case 4:
+        break;
+        case 501:
+            EditEntry(*xFirst, EditEntryMode::DELETE);
+        break;
+        case 502 :
+            EditEntry(*xFirst, EditEntryMode::RENAME);
+        break;
+        case 600:
+            m_pActiveShell->GetView().GetPostItMgr()->Show();
+            break;
+        case 601:
+            m_pActiveShell->GetView().GetPostItMgr()->Hide();
+            break;
+        case 602:
+            {
+                m_pActiveShell->GetView().GetPostItMgr()->SetActiveSidebarWin(nullptr);
+                m_pActiveShell->GetView().GetPostItMgr()->Delete();
+                break;
+            }
+        case 700:
+            {
+                m_pActiveShell->GetView().GetViewFrame()->GetDispatcher()->Execute(FN_OUTLINE_TO_CLIPBOARD);
+                break;
+            }
+        case 800:
+            ExpandOrCollapseAll(*m_xTreeView, *xFirst);
+            break;
+        case 801:
+            ExecCommand("chapterup", true);
+            break;
+        case 802:
+            ExecCommand("chapterdown", true);
+            break;
+        case 803:
+            ExecCommand("promote", true);
+            break;
+        case 804:
+            ExecCommand("demote", true);
+            break;
+        case 805:
+        {
+            m_pActiveShell->KillPams();
+            m_pActiveShell->ClearMark();
+            m_pActiveShell->EnterAddMode();
+            SwContent* pCnt = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xFirst).toInt64());
+            const ContentTypeId eTypeId = pCnt->GetParent()->GetType();
+            if (eTypeId == ContentTypeId::OUTLINE)
+            {
+                m_xTreeView->selected_foreach([this](weld::TreeIter& rEntry){
+                    m_pActiveShell->SttSelect();
+                    SwOutlineNodes::size_type nActPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(rEntry).toInt64())->GetOutlinePos();
+                    m_pActiveShell->MakeOutlineSel(nActPos, nActPos, !m_xTreeView->get_row_expanded(rEntry), false); // select children if not expanded
+                    m_pActiveShell->EndSelect();
+                    return false;
+                });
+            }
+            else if (eTypeId == ContentTypeId::TABLE)
+            {
+                m_pActiveShell->GotoTable(pCnt->GetName());
+                m_pActiveShell->SelAll();
+            }
+            else if (eTypeId == ContentTypeId::REGION)
+            {
+                m_pActiveShell->EnterStdMode();
+                m_pActiveShell->GotoRegion(pCnt->GetName());
+                GotoCurrRegionAndSkip(m_pActiveShell->GetCurrentShellCursor(), fnRegionEnd, m_pActiveShell->IsReadOnlyAvailable());
+                m_pActiveShell->SttSelect();
+                GotoCurrRegionAndSkip(m_pActiveShell->GetCurrentShellCursor(), fnRegionStart, m_pActiveShell->IsReadOnlyAvailable());
+                m_pActiveShell->EndSelect();
+                m_pActiveShell->UpdateCursor();
+            }
+            m_pActiveShell->LeaveAddMode();
+        }
+        break;
+        case 806:
+            // Delete outline selections
+            EditEntry(*xFirst, EditEntryMode::DELETE);
+            break;
+        case 900:
+        {
+            SwContent* pCnt = reinterpret_cast<SwContent*>(m_xTreeView->get_id(*xFirst).toInt64());
+            GotoContent(pCnt);
+        }
+        break;
+        //Display
+        default:
+        if(nSelectedPopupEntry > 300 && nSelectedPopupEntry < 400)
+        {
+            nSelectedPopupEntry -= 300;
+            SwView *pView = SwModule::GetFirstView();
+            while (pView)
+            {
+                nSelectedPopupEntry --;
+                if(nSelectedPopupEntry == 0)
+                {
+                    SetConstantShell(&pView->GetWrtShell());
+                    break;
+                }
+                pView = SwModule::GetNextView(pView);
+            }
+            if(nSelectedPopupEntry)
+            {
+                m_bViewHasChanged = nSelectedPopupEntry == 1;
+                m_eState = (nSelectedPopupEntry == 1) ? State::ACTIVE : State::HIDDEN;
+                Display(nSelectedPopupEntry == 1);
+            }
+        }
+    }
+    GetParentWindow()->UpdateListBox();
+}
+
+void SwContentTree::DeleteOutlineSelections()
+{
+    m_pActiveShell->StartAction();
+    m_pActiveShell->EnterAddMode();
+    auto nChapters(0);
+
+    m_xTreeView->selected_foreach([this, &nChapters](weld::TreeIter& rEntry){
+        ++nChapters;
+        if (m_xTreeView->iter_has_child(rEntry) &&
+            !m_xTreeView->get_row_expanded(rEntry)) // only count children if not expanded
+        {
+            nChapters += m_xTreeView->iter_n_children(rEntry);
+        }
+        m_pActiveShell->SttSelect();
+        SwOutlineNodes::size_type nActPos = reinterpret_cast<SwOutlineContent*>(m_xTreeView->get_id(rEntry).toInt64())->GetOutlinePos();
+        m_pActiveShell->MakeOutlineSel(nActPos, nActPos, !m_xTreeView->get_row_expanded(rEntry), false); // select children if not expanded
+        m_pActiveShell->EndSelect();
+        return false;
+    });
+    m_pActiveShell->LeaveAddMode();
+    SwRewriter aRewriter;
+    aRewriter.AddRule(UndoArg1, SwResId(STR_CHAPTERS, nChapters));
+    m_pActiveShell->StartUndo(SwUndoId::DELETE, &aRewriter);
+    m_pActiveShell->SetTextFormatColl(nullptr);
+    m_pActiveShell->Delete();
+    m_pActiveShell->ClearMark();
+    m_pActiveShell->EndUndo();
+    m_pActiveShell->EndAction();
+}
+
+void SwContentTree::SetOutlineLevel(sal_uInt8 nSet)
+{
+    m_nOutlineLevel = nSet;
+    m_pConfig->SetOutlineLevel( m_nOutlineLevel );
+    std::unique_ptr<SwContentType>& rpContentT = (State::ACTIVE == m_eState)
+            ? m_aActiveContentArr[ContentTypeId::OUTLINE]
+            : m_aHiddenContentArr[ContentTypeId::OUTLINE];
+    if(rpContentT)
+    {
+        rpContentT->SetOutlineLevel(m_nOutlineLevel);
+        rpContentT->Init();
+    }
+    Display(State::ACTIVE == m_eState);
+}
+
+// Mode Change: Show dropped Doc
+void SwContentTree::ShowHiddenShell()
+{
+    if(m_pHiddenShell)
+    {
+        m_eState = State::HIDDEN;
+        Display(false);
+    }
+}
+
+// Mode Change: Show active view
+void SwContentTree::ShowActualView()
+{
+    m_eState = State::ACTIVE;
+    Display(true);
+    GetParentWindow()->UpdateListBox();
+}
+
+IMPL_LINK_NOARG(SwContentTree, SelectHdl, weld::TreeView&, void)
+{
+    Select();
+}
+
+// Here the buttons for moving outlines are en-/disabled.
+void SwContentTree::Select()
+{
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    if (!m_xTreeView->get_selected(xEntry.get()))
+        return;
+
+    bool bEnable = false;
+    std::unique_ptr<weld::TreeIter> xParentEntry(m_xTreeView->make_iterator(xEntry.get()));
+    bool bParentEntry = m_xTreeView->iter_parent(*xParentEntry);
+    while (bParentEntry && (!lcl_IsContentType(*xParentEntry, *m_xTreeView)))
+        bParentEntry = m_xTreeView->iter_parent(*xParentEntry);
+    if (!m_bIsLastReadOnly)
+    {
+        if (!m_xTreeView->get_visible())
+            bEnable = true;
+        else if (bParentEntry)
+        {
+            if ((m_bIsRoot && m_nRootType == ContentTypeId::OUTLINE) ||
+                (lcl_IsContent(*xEntry, *m_xTreeView) &&
+                    reinterpret_cast<SwContentType*>(m_xTreeView->get_id(*xParentEntry).toInt64())->GetType() == ContentTypeId::OUTLINE))
+            {
+                bEnable = true;
+            }
+        }
+    }
+    SwNavigationPI* pNavi = GetParentWindow();
+    pNavi->m_xContent3ToolBox->set_item_sensitive("chapterup",  bEnable);
+    pNavi->m_xContent3ToolBox->set_item_sensitive("chapterdown", bEnable);
+    pNavi->m_xContent3ToolBox->set_item_sensitive("promote", bEnable);
+    pNavi->m_xContent3ToolBox->set_item_sensitive("demote", bEnable);
+}
+
+void SwContentTree::SetRootType(ContentTypeId nType)
+{
+    m_nRootType = nType;
+    m_bIsRoot = true;
+    m_pConfig->SetRootType( m_nRootType );
+}
+
+OUString SwContentType::RemoveNewline(const OUString& rEntry)
+{
+    if (rEntry.isEmpty())
+        return rEntry;
+
+    OUStringBuffer aEntry(rEntry);
+    for (sal_Int32 i = 0; i < rEntry.getLength(); ++i)
+        if(aEntry[i] == 10 || aEntry[i] == 13)
+            aEntry[i] = 0x20;
+
+    return aEntry.makeStringAndClear();
+}
+
+void SwContentTree::EditEntry(const weld::TreeIter& rEntry, EditEntryMode nMode)
+{
+    SwContent* pCnt = reinterpret_cast<SwContent*>(m_xTreeView->get_id(rEntry).toInt64());
+    GotoContent(pCnt);
+    const ContentTypeId nType = pCnt->GetParent()->GetType();
+    sal_uInt16 nSlot = 0;
+
+    uno::Reference< container::XNameAccess >  xNameAccess, xSecond, xThird;
+    switch(nType)
+    {
+        case ContentTypeId::OUTLINE :
+            if(nMode == EditEntryMode::DELETE)
+            {
+                DeleteOutlineSelections();
+            }
+        break;
+
+        case ContentTypeId::TABLE     :
+            if(nMode == EditEntryMode::UNPROTECT_TABLE)
+            {
+                m_pActiveShell->GetView().GetDocShell()->
+                        GetDoc()->UnProtectCells( pCnt->GetName());
+            }
+            else if(nMode == EditEntryMode::DELETE)
+            {
+                m_pActiveShell->StartAction();
+                OUString sTable = SwResId(STR_TABLE_NAME);
+                SwRewriter aRewriterTableName;
+                aRewriterTableName.AddRule(UndoArg1, SwResId(STR_START_QUOTE));
+                aRewriterTableName.AddRule(UndoArg2, pCnt->GetName());
+                aRewriterTableName.AddRule(UndoArg3, SwResId(STR_END_QUOTE));
+                sTable = aRewriterTableName.Apply(sTable);
+
+                SwRewriter aRewriter;
+                aRewriter.AddRule(UndoArg1, sTable);
+                m_pActiveShell->StartUndo(SwUndoId::DELETE, &aRewriter);
+                m_pActiveShell->GetView().GetViewFrame()->GetDispatcher()->Execute(FN_TABLE_SELECT_ALL);
+                m_pActiveShell->DeleteRow();
+                m_pActiveShell->EndUndo();
+                m_pActiveShell->EndAction();
+            }
+            else if(nMode == EditEntryMode::RENAME)
+            {
+                uno::Reference< frame::XModel >  xModel = m_pActiveShell->GetView().GetDocShell()->GetBaseModel();
+                uno::Reference< text::XTextTablesSupplier >  xTables(xModel, uno::UNO_QUERY);
+                xNameAccess = xTables->getTextTables();
+            }
+            else
+                nSlot = FN_FORMAT_TABLE_DLG;
+        break;
+
+        case ContentTypeId::GRAPHIC   :
+            if(nMode == EditEntryMode::DELETE)
+            {
+                m_pActiveShell->DelRight();
+            }
+            else if(nMode == EditEntryMode::RENAME)
+            {
+                uno::Reference< frame::XModel >  xModel = m_pActiveShell->GetView().GetDocShell()->GetBaseModel();
+                uno::Reference< text::XTextGraphicObjectsSupplier >  xGraphics(xModel, uno::UNO_QUERY);
+                xNameAccess = xGraphics->getGraphicObjects();
+                uno::Reference< text::XTextFramesSupplier >  xFrames(xModel, uno::UNO_QUERY);
+                xSecond = xFrames->getTextFrames();
+                uno::Reference< text::XTextEmbeddedObjectsSupplier >  xObjs(xModel, uno::UNO_QUERY);
+                xThird = xObjs->getEmbeddedObjects();
+            }
+            else
+                nSlot = FN_FORMAT_GRAFIC_DLG;
+        break;
+
+        case ContentTypeId::FRAME     :
+        case ContentTypeId::OLE       :
+            if(nMode == EditEntryMode::DELETE)
+            {
+                m_pActiveShell->DelRight();
+            }
+            else if(nMode == EditEntryMode::RENAME)
+            {
+                uno::Reference< frame::XModel >  xModel = m_pActiveShell->GetView().GetDocShell()->GetBaseModel();
+                uno::Reference< text::XTextFramesSupplier >  xFrames(xModel, uno::UNO_QUERY);
+                uno::Reference< text::XTextEmbeddedObjectsSupplier >  xObjs(xModel, uno::UNO_QUERY);
+                if(ContentTypeId::FRAME == nType)
+                {
+                    xNameAccess = xFrames->getTextFrames();
+                    xSecond = xObjs->getEmbeddedObjects();
+                }
+                else
+                {
+                    xNameAccess = xObjs->getEmbeddedObjects();
+                    xSecond = xFrames->getTextFrames();
+                }
+                uno::Reference< text::XTextGraphicObjectsSupplier >  xGraphics(xModel, uno::UNO_QUERY);
+                xThird = xGraphics->getGraphicObjects();
+            }
+            else
+                nSlot = FN_FORMAT_FRAME_DLG;
+        break;
+        case ContentTypeId::BOOKMARK  :
+            assert(!m_pActiveShell->getIDocumentSettingAccess().get(DocumentSettingId::PROTECT_BOOKMARKS));
+            if(nMode == EditEntryMode::DELETE)
+            {
+                IDocumentMarkAccess* const pMarkAccess = m_pActiveShell->getIDocumentMarkAccess();
+                pMarkAccess->deleteMark( pMarkAccess->findMark(pCnt->GetName()) );
+            }
+            else if(nMode == EditEntryMode::RENAME)
+            {
+                uno::Reference< frame::XModel >  xModel = m_pActiveShell->GetView().GetDocShell()->GetBaseModel();
+                uno::Reference< text::XBookmarksSupplier >  xBkms(xModel, uno::UNO_QUERY);
+                xNameAccess = xBkms->getBookmarks();
+            }
+            else
+                nSlot = FN_INSERT_BOOKMARK;
+        break;
+
+        case ContentTypeId::REGION    :
+            if(nMode == EditEntryMode::RENAME)
+            {
+                uno::Reference< frame::XModel >  xModel = m_pActiveShell->GetView().GetDocShell()->GetBaseModel();
+                uno::Reference< text::XTextSectionsSupplier >  xSects(xModel, uno::UNO_QUERY);
+                xNameAccess = xSects->getTextSections();
+            }
+            else
+                nSlot = FN_EDIT_REGION;
+        break;
+
+        case ContentTypeId::URLFIELD:
+            if (nMode == EditEntryMode::DELETE)
+                nSlot = SID_REMOVE_HYPERLINK;
+            else
+                nSlot = SID_EDIT_HYPERLINK;
+        break;
+        case ContentTypeId::REFERENCE:
+            nSlot = FN_EDIT_FIELD;
+        break;
+
+        case ContentTypeId::POSTIT:
+            m_pActiveShell->GetView().GetPostItMgr()->AssureStdModeAtShell();
+            if(nMode == EditEntryMode::DELETE)
+            {
+                m_pActiveShell->GetView().GetPostItMgr()->SetActiveSidebarWin(nullptr);
+                m_pActiveShell->DelRight();
+            }
+            else
+            {
+                nSlot = FN_POSTIT;
+            }
+        break;
+        case ContentTypeId::INDEX:
+        {
+            const SwTOXBase* pBase = static_cast<SwTOXBaseContent*>(pCnt)->GetTOXBase();
+            switch(nMode)
+            {
+                case EditEntryMode::EDIT:
+                    if(pBase)
+                    {
+                        SwPtrItem aPtrItem( FN_INSERT_MULTI_TOX, const_cast<SwTOXBase *>(pBase));
+                        m_pActiveShell->GetView().GetViewFrame()->
+                            GetDispatcher()->ExecuteList(FN_INSERT_MULTI_TOX,
+                                SfxCallMode::ASYNCHRON, { &aPtrItem });
+
+                    }
+                break;
+                case EditEntryMode::RMV_IDX:
+                case EditEntryMode::DELETE:
+                {
+                    if( pBase )
+                        m_pActiveShell->DeleteTOX(*pBase, EditEntryMode::DELETE == nMode);
+                }
+                break;
+                case EditEntryMode::UPD_IDX:
+                case EditEntryMode::RENAME:
+                {
+                    Reference< frame::XModel >  xModel = m_pActiveShell->GetView().GetDocShell()->GetBaseModel();
+                    Reference< XDocumentIndexesSupplier >  xIndexes(xModel, UNO_QUERY);
+                    Reference< XIndexAccess> xIdxAcc(xIndexes->getDocumentIndexes());
+                    Reference< XNameAccess >xLocalNameAccess(xIdxAcc, UNO_QUERY);
+                    if(EditEntryMode::RENAME == nMode)
+                        xNameAccess = xLocalNameAccess;
+                    else if(xLocalNameAccess.is() && xLocalNameAccess->hasByName(pBase->GetTOXName()))
+                    {
+                        Any aIdx = xLocalNameAccess->getByName(pBase->GetTOXName());
+                        Reference< XDocumentIndex> xIdx;
+                        if(aIdx >>= xIdx)
+                            xIdx->update();
+                    }
+                }
+                break;
+                default: break;
+            }
+        }
+        break;
+        case ContentTypeId::DRAWOBJECT :
+            if(EditEntryMode::DELETE == nMode)
+                nSlot = SID_DELETE;
+            else if(nMode == EditEntryMode::RENAME)
+                nSlot = FN_NAME_SHAPE;
+        break;
+        default: break;
+    }
+    if(nSlot)
+        m_pActiveShell->GetView().GetViewFrame()->
+                    GetDispatcher()->Execute(nSlot, SfxCallMode::ASYNCHRON);
+    else if(xNameAccess.is())
+    {
+        uno::Any aObj = xNameAccess->getByName(pCnt->GetName());
+        uno::Reference< uno::XInterface >  xTmp;
+        aObj >>= xTmp;
+        uno::Reference< container::XNamed >  xNamed(xTmp, uno::UNO_QUERY);
+        SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+        ScopedVclPtr<AbstractSwRenameXNamedDlg> pDlg(pFact->CreateSwRenameXNamedDlg(GetParentWindow()->GetFrameWeld(), xNamed, xNameAccess));
+        if(xSecond.is())
+            pDlg->SetAlternativeAccess( xSecond, xThird);
+
+        OUString sForbiddenChars;
+        if(ContentTypeId::BOOKMARK == nType)
+        {
+            sForbiddenChars = "/\\@:*?\";,.#";
+        }
+        else if(ContentTypeId::TABLE == nType)
+        {
+            sForbiddenChars = " .<>";
+        }
+        pDlg->SetForbiddenChars(sForbiddenChars);
+        pDlg->Execute();
+    }
+    if(EditEntryMode::DELETE == nMode)
+    {
+        m_bViewHasChanged = true;
+        GetParentWindow()->UpdateListBox();
+        TimerUpdate(&m_aUpdTimer);
+        grab_focus();
+    }
+}
+
+void SwContentTree::GotoContent(const SwContent* pCnt)
+{
+    m_pActiveShell->EnterStdMode();
+
+    bool bSel = false;
+    switch(pCnt->GetParent()->GetType())
+    {
+        case ContentTypeId::OUTLINE   :
+        {
+            m_pActiveShell->GotoOutline(static_cast<const SwOutlineContent*>(pCnt)->GetOutlinePos());
+        }
+        break;
+        case ContentTypeId::TABLE     :
+        {
+            m_pActiveShell->GotoTable(pCnt->GetName());
+        }
+        break;
+        case ContentTypeId::FRAME     :
+        case ContentTypeId::GRAPHIC   :
+        case ContentTypeId::OLE       :
+        {
+            if(m_pActiveShell->GotoFly(pCnt->GetName()))
+                bSel = true;
+        }
+        break;
+        case ContentTypeId::BOOKMARK:
+        {
+            m_pActiveShell->GotoMark(pCnt->GetName());
+        }
+        break;
+        case ContentTypeId::REGION    :
+        {
+            m_pActiveShell->GotoRegion(pCnt->GetName());
+        }
+        break;
+        case ContentTypeId::URLFIELD:
+        {
+            if(m_pActiveShell->GotoINetAttr(
+                            *static_cast<const SwURLFieldContent*>(pCnt)->GetINetAttr() ))
+            {
+                m_pActiveShell->Right( CRSR_SKIP_CHARS, true, 1, false);
+                m_pActiveShell->SwCursorShell::SelectTextAttr( RES_TXTATR_INETFMT, true );
+            }
+
+        }
+        break;
+        case ContentTypeId::REFERENCE:
+        {
+            m_pActiveShell->GotoRefMark(pCnt->GetName());
+        }
+        break;
+        case ContentTypeId::INDEX:
+        {
+            const OUString& sName(pCnt->GetName());
+            if (!m_pActiveShell->GotoNextTOXBase(&sName))
+                m_pActiveShell->GotoPrevTOXBase(&sName);
+        }
+        break;
+        case ContentTypeId::POSTIT:
+            m_pActiveShell->GetView().GetPostItMgr()->AssureStdModeAtShell();
+            m_pActiveShell->GotoFormatField(*static_cast<const SwPostItContent*>(pCnt)->GetPostIt());
+        break;
+        case ContentTypeId::DRAWOBJECT:
+        {
+            SwPosition aPos = *m_pActiveShell->GetCursor()->GetPoint();
+            SdrView* pDrawView = m_pActiveShell->GetDrawView();
+            if (pDrawView)
+            {
+                pDrawView->SdrEndTextEdit();
+                pDrawView->UnmarkAll();
+                SwDrawModel* _pModel = m_pActiveShell->getIDocumentDrawModelAccess().GetDrawModel();
+                SdrPage* pPage = _pModel->GetPage(0);
+                const size_t nCount = pPage->GetObjCount();
+                for( size_t i=0; i<nCount; ++i )
+                {
+                    SdrObject* pTemp = pPage->GetObj(i);
+                    if (pTemp->GetName() == pCnt->GetName())
+                    {
+                        SdrPageView* pPV = pDrawView->GetSdrPageView();
+                        if( pPV )
+                        {
+                            pDrawView->MarkObj( pTemp, pPV );
+                        }
+                    }
+                }
+                m_pActiveShell->GetNavigationMgr().addEntry(aPos);
+                m_pActiveShell->EnterStdMode();
+                bSel = true;
+            }
+        }
+        break;
+        default: break;
+    }
+    if(bSel)
+    {
+        m_pActiveShell->HideCursor();
+        m_pActiveShell->EnterSelFrameMode();
+    }
+    SwView& rView = m_pActiveShell->GetView();
+    rView.StopShellTimer();
+    rView.GetPostItMgr()->SetActiveSidebarWin(nullptr);
+    rView.GetEditWin().GrabFocus();
+
+    // force scroll to cursor position when navigating to inactive document
+    if(!bSel)
+    {
+        Point rPoint = m_pActiveShell->GetCursorDocPos();
+        rPoint.setX(0);
+        rView.SetVisArea(rPoint);
+    }
+}
+
+// Now even the matching text::Bookmark
+NaviContentBookmark::NaviContentBookmark()
+    :
+    nDocSh(0),
+    nDefDrag( RegionMode::NONE )
+{
+}
+
+NaviContentBookmark::NaviContentBookmark( const OUString &rUrl,
+                    const OUString& rDesc,
+                    RegionMode nDragType,
+                    const SwDocShell* pDocSh ) :
+    aUrl( rUrl ),
+    aDescr(rDesc),
+    nDocSh(reinterpret_cast<sal_IntPtr>(pDocSh)),
+    nDefDrag( nDragType )
+{
+}
+
+void NaviContentBookmark::Copy( TransferDataContainer& rData ) const
+{
+    rtl_TextEncoding eSysCSet = osl_getThreadTextEncoding();
+
+    OString sStrBuf(OUStringToOString(aUrl, eSysCSet) + OStringChar(NAVI_BOOKMARK_DELIM) +
+                    OUStringToOString(aDescr, eSysCSet) + OStringChar(NAVI_BOOKMARK_DELIM) +
+                    OString::number(static_cast<int>(nDefDrag)) + OStringChar(NAVI_BOOKMARK_DELIM) +
+                    OString::number(nDocSh));
+    rData.CopyByteString(SotClipboardFormatId::SONLK, sStrBuf);
+}
+
+bool NaviContentBookmark::Paste( TransferableDataHelper& rData )
+{
+    OUString sStr;
+    bool bRet = rData.GetString( SotClipboardFormatId::SONLK, sStr );
+    if( bRet )
+    {
+        sal_Int32 nPos = 0;
+        aUrl    = sStr.getToken(0, NAVI_BOOKMARK_DELIM, nPos );
+        aDescr  = sStr.getToken(0, NAVI_BOOKMARK_DELIM, nPos );
+        nDefDrag= static_cast<RegionMode>( sStr.getToken(0, NAVI_BOOKMARK_DELIM, nPos ).toInt32() );
+        nDocSh  = sStr.getToken(0, NAVI_BOOKMARK_DELIM, nPos ).toInt32();
+    }
+    return bRet;
+}
+
+SwNavigationPI* SwContentTree::GetParentWindow()
+{
+    return m_xDialog;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/glbltree.cxx b/sw/source/uibase/utlui/glbltree.cxx
new file mode 100644
index 000000000..3261050f3
--- /dev/null
+++ b/sw/source/uibase/utlui/glbltree.cxx
@@ -0,0 +1,1088 @@
+/* -*- 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 <o3tl/safeint.hxx>
+#include <svl/stritem.hxx>
+#include <sfx2/fcontnr.hxx>
+#include <sfx2/linkmgr.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <sfx2/docfile.hxx>
+#include <sfx2/docfilt.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/event.hxx>
+#include <vcl/help.hxx>
+#include <sot/filelist.hxx>
+#include <svl/eitem.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <vcl/settings.hxx>
+
+#include <sfx2/docinsert.hxx>
+#include <sfx2/filedlghelper.hxx>
+
+#include <wrtsh.hxx>
+#include <view.hxx>
+#include <docsh.hxx>
+#include <edglbldc.hxx>
+#include <section.hxx>
+#include <tox.hxx>
+#include <navipi.hxx>
+#include <edtwin.hxx>
+#include <toxmgr.hxx>
+
+#include <cmdid.h>
+#include <helpids.h>
+#include <strings.hrc>
+#include <bitmaps.hlst>
+#include <swabstdlg.hxx>
+#include <memory>
+
+using namespace ::com::sun::star::uno;
+
+#define GLOBAL_UPDATE_TIMEOUT 2000
+
+const SfxObjectShell* SwGlobalTree::pShowShell = nullptr;
+
+namespace {
+
+class SwGlobalFrameListener_Impl : public SfxListener
+{
+    bool bValid;
+public:
+    explicit SwGlobalFrameListener_Impl(SfxViewFrame& rFrame)
+        : bValid(true)
+    {
+        StartListening(rFrame);
+    }
+
+    virtual void        Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) override;
+
+    bool                IsValid() const {return bValid;}
+};
+
+}
+
+void SwGlobalFrameListener_Impl::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
+{
+    if( rHint.GetId() == SfxHintId::Dying)
+        bValid = false;
+}
+
+namespace {
+
+enum GLOBAL_CONTEXT_IDX
+{
+    IDX_STR_UPDATE = 0,
+    IDX_STR_EDIT_CONTENT = 1,
+    IDX_STR_EDIT_INSERT = 2,
+    IDX_STR_INDEX = 3,
+    IDX_STR_FILE = 4,
+    IDX_STR_NEW_FILE = 5,
+    IDX_STR_INSERT_TEXT = 6,
+    IDX_STR_DELETE = 7,
+    IDX_STR_UPDATE_SEL = 8,
+    IDX_STR_UPDATE_INDEX = 9,
+    IDX_STR_UPDATE_LINK = 10,
+    IDX_STR_UPDATE_ALL = 11,
+    IDX_STR_BROKEN_LINK = 12,
+    IDX_STR_EDIT_LINK = 13
+};
+
+}
+
+static const char* GLOBAL_CONTEXT_ARY[] =
+{
+    STR_UPDATE,
+    STR_EDIT_CONTENT,
+    STR_EDIT_INSERT,
+    STR_INDEX,
+    STR_FILE,
+    STR_NEW_FILE,
+    STR_INSERT_TEXT,
+    STR_DELETE,
+    STR_UPDATE_SEL,
+    STR_UPDATE_INDEX,
+    STR_UPDATE_LINK,
+    STR_UPDATE_ALL,
+    STR_BROKEN_LINK,
+    STR_EDIT_LINK
+};
+
+SwGlobalTree::SwGlobalTree(std::unique_ptr<weld::TreeView> xTreeView, SwNavigationPI* pDialog)
+    : m_xTreeView(std::move(xTreeView))
+    , m_aDropTargetHelper(*this)
+    , m_xDialog(pDialog)
+    , m_pActiveShell(nullptr)
+{
+    Size aSize(m_xDialog->LogicToPixel(Size(110, 112), MapMode(MapUnit::MapAppFont)));;
+    m_xTreeView->set_size_request(aSize.Width(), aSize.Height());
+
+    m_aUpdateTimer.SetTimeout(GLOBAL_UPDATE_TIMEOUT);
+    m_aUpdateTimer.SetInvokeHandler(LINK(this, SwGlobalTree, Timeout));
+    m_aUpdateTimer.Start();
+    for (sal_uInt16 i = 0; i < GLOBAL_CONTEXT_COUNT; i++)
+    {
+        m_aContextStrings[i] = SwResId(GLOBAL_CONTEXT_ARY[i]);
+    }
+    m_xTreeView->set_help_id(HID_NAVIGATOR_GLOB_TREELIST);
+    Select();
+    m_xTreeView->connect_row_activated(LINK(this, SwGlobalTree, DoubleClickHdl));
+    m_xTreeView->connect_changed(LINK(this, SwGlobalTree, SelectHdl));
+    m_xTreeView->connect_focus_in(LINK(this, SwGlobalTree, FocusInHdl));
+    m_xTreeView->connect_key_press(LINK(this, SwGlobalTree, KeyInputHdl));
+    m_xTreeView->connect_popup_menu(LINK(this, SwGlobalTree, CommandHdl));
+    m_xTreeView->connect_query_tooltip(LINK(this, SwGlobalTree, QueryTooltipHdl));
+}
+
+SwGlobalTree::~SwGlobalTree()
+{
+    m_pSwGlblDocContents.reset();
+    m_pDocInserter.reset();
+    m_aUpdateTimer.Stop();
+    m_xDialog.clear();
+}
+
+SwGlobalTreeDropTarget::SwGlobalTreeDropTarget(SwGlobalTree& rTreeView)
+    : DropTargetHelper(rTreeView.get_widget().get_drop_target())
+    , m_rTreeView(rTreeView)
+{
+}
+
+sal_Int8 SwGlobalTreeDropTarget::ExecuteDrop( const ExecuteDropEvent& rEvt )
+{
+    sal_Int8 nRet = DND_ACTION_NONE;
+
+    weld::TreeView& rWidget = m_rTreeView.get_widget();
+    std::unique_ptr<weld::TreeIter> xDropEntry(rWidget.make_iterator());
+    if (!rWidget.get_dest_row_at_pos(rEvt.maPosPixel, xDropEntry.get()))
+        xDropEntry.reset();
+
+    if (rWidget.get_drag_source() == &rWidget)  // internal drag
+        m_rTreeView.MoveSelectionTo(xDropEntry.get());
+    else
+    {
+        TransferableDataHelper aData( rEvt.maDropEvent.Transferable );
+
+        OUString sFileName;
+        const SwGlblDocContent* pCnt = xDropEntry ?
+                    reinterpret_cast<const SwGlblDocContent*>(rWidget.get_id(*xDropEntry).toInt64()) :
+                            nullptr;
+        if( aData.HasFormat( SotClipboardFormatId::FILE_LIST ))
+        {
+            nRet = rEvt.mnAction;
+            std::unique_ptr<SwGlblDocContents> pTempContents(new SwGlblDocContents);
+            int nAbsContPos = xDropEntry ?
+                                rWidget.get_iter_index_in_parent(*xDropEntry):
+                                    - 1;
+            size_t nEntryCount = rWidget.n_children();
+
+            // Get data
+            FileList aFileList;
+            aData.GetFileList( SotClipboardFormatId::FILE_LIST, aFileList );
+            for ( size_t n = aFileList.Count(); n--; )
+            {
+                sFileName = aFileList.GetFile(n);
+                m_rTreeView.InsertRegion(pCnt, &sFileName);
+                // The list of contents must be newly fetched after inserting,
+                // to not work on an old content.
+                if(n)
+                {
+                    m_rTreeView.GetActiveWrtShell()->GetGlobalDocContent(*pTempContents);
+                    // If the file was successfully inserted,
+                    // then the next content must also be fetched.
+                    if(nEntryCount < pTempContents->size())
+                    {
+                        nEntryCount++;
+                        nAbsContPos++;
+                        pCnt = (*pTempContents)[ nAbsContPos ].get();
+                    }
+                }
+            }
+        }
+        else if( !(sFileName =
+                        SwNavigationPI::CreateDropFileName( aData )).isEmpty())
+        {
+            INetURLObject aTemp(sFileName);
+            GraphicDescriptor aDesc(aTemp);
+            if( !aDesc.Detect() )   // accept no graphics
+            {
+                nRet = rEvt.mnAction;
+                m_rTreeView.InsertRegion(pCnt, &sFileName);
+            }
+        }
+    }
+    return nRet;
+}
+
+sal_Int8 SwGlobalTreeDropTarget::AcceptDrop( const AcceptDropEvent& rEvt )
+{
+    // to enable the autoscroll when we're close to the edges
+    weld::TreeView& rWidget = m_rTreeView.get_widget();
+    rWidget.get_dest_row_at_pos(rEvt.maPosPixel, nullptr);
+
+    sal_Int8 nRet = rEvt.mnAction;
+
+    if (rWidget.get_drag_source() == &rWidget)  // internal drag
+        return nRet;
+
+    if (IsDropFormatSupported( SotClipboardFormatId::SIMPLE_FILE) ||
+        IsDropFormatSupported( SotClipboardFormatId::STRING) ||
+        IsDropFormatSupported( SotClipboardFormatId::FILE_LIST) ||
+        IsDropFormatSupported( SotClipboardFormatId::SOLK) ||
+        IsDropFormatSupported( SotClipboardFormatId::NETSCAPE_BOOKMARK )||
+        IsDropFormatSupported( SotClipboardFormatId::FILECONTENT) ||
+        IsDropFormatSupported( SotClipboardFormatId::FILEGRPDESCRIPTOR) ||
+        IsDropFormatSupported( SotClipboardFormatId::UNIFORMRESOURCELOCATOR) ||
+        IsDropFormatSupported( SotClipboardFormatId::FILENAME))
+    {
+        nRet = DND_ACTION_LINK;
+    }
+
+    return nRet;
+}
+
+IMPL_LINK(SwGlobalTree, CommandHdl, const CommandEvent&, rCEvt, bool)
+{
+    if (rCEvt.GetCommand() != CommandEventId::ContextMenu)
+        return false;
+
+    bool bPop = false;
+    if (m_pActiveShell && !m_pActiveShell->GetView().GetDocShell()->IsReadOnly())
+    {
+        std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xTreeView.get(), "modules/swriter/ui/mastercontextmenu.ui"));
+        std::unique_ptr<weld::Menu> xPopup = xBuilder->weld_menu("navmenu");
+
+        const MenuEnableFlags nEnableFlags = GetEnableFlags();
+
+        xPopup->set_sensitive("updatesel", bool(nEnableFlags & MenuEnableFlags::UpdateSel));
+
+        xPopup->set_sensitive("editlink", bool(nEnableFlags & MenuEnableFlags::EditLink));
+
+        //disabling if applicable
+        xPopup->set_sensitive("insertindex", bool(nEnableFlags & MenuEnableFlags::InsertIdx ));
+        xPopup->set_sensitive("insertfile", bool(nEnableFlags & MenuEnableFlags::InsertFile));
+        xPopup->set_sensitive("insertnewfile", bool(nEnableFlags & MenuEnableFlags::InsertFile));
+        xPopup->set_sensitive("inserttext", bool(nEnableFlags & MenuEnableFlags::InsertText));
+
+        xPopup->set_sensitive("update", bool(nEnableFlags & MenuEnableFlags::Update));
+        xPopup->set_sensitive("insert", bool(nEnableFlags & MenuEnableFlags::InsertIdx));
+        xPopup->set_sensitive("editcontent", bool(nEnableFlags & MenuEnableFlags::Edit));
+        xPopup->set_sensitive("deleteentry", bool(nEnableFlags & MenuEnableFlags::Delete));
+
+        OString sCommand = xPopup->popup_at_rect(m_xTreeView.get(), tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1)));
+        if (!sCommand.isEmpty())
+            ExecuteContextMenuAction(sCommand);
+    }
+    return bPop;
+}
+
+void SwGlobalTree::TbxMenuHdl(const OString& rCommand, weld::Menu& rMenu)
+{
+    const MenuEnableFlags nEnableFlags = GetEnableFlags();
+    if (rCommand == "insert")
+    {
+        rMenu.set_sensitive("insertindex", bool(nEnableFlags & MenuEnableFlags::InsertIdx));
+        rMenu.set_sensitive("insertfile", bool(nEnableFlags & MenuEnableFlags::InsertFile));
+        rMenu.set_sensitive("insertnewfile", bool(nEnableFlags & MenuEnableFlags::InsertFile));
+        rMenu.set_sensitive("inserttext", bool(nEnableFlags & MenuEnableFlags::InsertText));
+    }
+    else if (rCommand == "update")
+    {
+        rMenu.set_sensitive("updatesel", bool(nEnableFlags & MenuEnableFlags::UpdateSel));
+    }
+}
+
+MenuEnableFlags SwGlobalTree::GetEnableFlags() const
+{
+    std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
+    bool bEntry = m_xTreeView->get_selected(xEntry.get());
+
+    sal_uLong nSelCount = m_xTreeView->count_selected_rows();
+    size_t nEntryCount = m_xTreeView->n_children();
+    std::unique_ptr<weld::TreeIter> xPrevEntry;
+    bool bPrevEntry = false;
+    if (bEntry)
+    {
+        xPrevEntry = m_xTreeView->make_iterator(xEntry.get());
+        bPrevEntry = m_xTreeView->iter_previous(*xPrevEntry);
+    }
+
+    MenuEnableFlags nRet = MenuEnableFlags::NONE;
+    if(nSelCount == 1 || !nEntryCount)
+        nRet |= MenuEnableFlags::InsertIdx|MenuEnableFlags::InsertFile;
+    if(nSelCount == 1)
+    {
+        nRet |= MenuEnableFlags::Edit;
+        if (bEntry && reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetType() != GLBLDOC_UNKNOWN &&
+                    (!bPrevEntry || reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(*xPrevEntry).toInt64())->GetType() != GLBLDOC_UNKNOWN))
+            nRet |= MenuEnableFlags::InsertText;
+        if (bEntry && GLBLDOC_SECTION == reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(*xEntry).toInt64())->GetType())
+            nRet |= MenuEnableFlags::EditLink;
+    }
+    else if(!nEntryCount)
+    {
+        nRet |= MenuEnableFlags::InsertText;
+    }
+    if(nEntryCount)
+        nRet |= MenuEnableFlags::Update|MenuEnableFlags::Delete;
+    if(nSelCount)
+        nRet |= MenuEnableFlags::UpdateSel;
+    return nRet;
+}
+
+IMPL_LINK(SwGlobalTree, QueryTooltipHdl, const weld::TreeIter&, rIter, OUString)
+{
+    OUString sEntry;
+
+    const SwGlblDocContent* pCont = reinterpret_cast<const SwGlblDocContent*>(m_xTreeView->get_id(rIter).toInt64());
+    if (pCont && GLBLDOC_SECTION == pCont->GetType())
+    {
+        const SwSection* pSect = pCont->GetSection();
+        sEntry = pSect->GetLinkFileName().getToken(0, sfx2::cTokenSeparator);
+        if (!pSect->IsConnectFlag())
+            sEntry = m_aContextStrings[IDX_STR_BROKEN_LINK] + sEntry;
+    }
+
+    return sEntry;
+}
+
+IMPL_LINK_NOARG(SwGlobalTree, SelectHdl, weld::TreeView&, void)
+{
+    Select();
+}
+
+void SwGlobalTree::Select()
+{
+    int nSelCount = m_xTreeView->count_selected_rows();
+    int nSel = m_xTreeView->get_selected_index();
+    int nAbsPos = nSel != -1 ? nSel : 0;
+    SwNavigationPI* pNavi = GetParentWindow();
+    bool bReadonly = !m_pActiveShell ||
+                m_pActiveShell->GetView().GetDocShell()->IsReadOnly();
+    pNavi->m_xGlobalToolBox->set_item_sensitive("edit",  nSelCount == 1 && !bReadonly);
+    pNavi->m_xGlobalToolBox->set_item_sensitive("insert",  nSelCount <= 1 && !bReadonly);
+    pNavi->m_xGlobalToolBox->set_item_sensitive("update",  m_xTreeView->n_children() > 0 && !bReadonly);
+    pNavi->m_xGlobalToolBox->set_item_sensitive("moveup",
+                    nSelCount == 1 && nAbsPos && !bReadonly);
+    pNavi->m_xGlobalToolBox->set_item_sensitive("movedown",
+                    nSelCount == 1 && nAbsPos < m_xTreeView->n_children() - 1 && !bReadonly);
+
+}
+
+void SwGlobalTree::MoveSelectionTo(weld::TreeIter* pDropEntry)
+{
+    int nSource = m_xTreeView->get_selected_index();
+
+    int nDest = pDropEntry ? m_xTreeView->get_iter_index_in_parent(*pDropEntry)
+                           : m_pSwGlblDocContents->size();
+
+    if (m_pActiveShell->MoveGlobalDocContent(
+            *m_pSwGlblDocContents, nSource, nSource + 1, nDest ) &&
+            Update( false ))
+        Display();
+}
+
+IMPL_LINK_NOARG(SwGlobalTree, FocusInHdl, weld::Widget&, void)
+{
+    if (Update(false))
+        Display();
+}
+
+IMPL_LINK(SwGlobalTree, KeyInputHdl, const KeyEvent&, rKEvt, bool)
+{
+    bool bHandled = false;
+    const vcl::KeyCode aCode = rKEvt.GetKeyCode();
+    if (aCode.GetCode() == KEY_RETURN)
+    {
+        switch (aCode.GetModifier())
+        {
+            case KEY_MOD2:
+                // Switch boxes
+                GetParentWindow()->ToggleTree();
+                bHandled = true;
+            break;
+        }
+    }
+    return bHandled;
+}
+
+void SwGlobalTree::Display(bool bOnlyUpdateUserData)
+{
+    size_t nCount = m_pSwGlblDocContents->size();
+    size_t nChildren = m_xTreeView->n_children();
+    if (bOnlyUpdateUserData && nChildren == m_pSwGlblDocContents->size())
+    {
+        std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
+        bool bEntry = m_xTreeView->get_iter_first(*xEntry);
+        for (size_t i = 0; i < nCount && bEntry; i++)
+        {
+            const SwGlblDocContent* pCont = (*m_pSwGlblDocContents)[i].get();
+            OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pCont)));
+            m_xTreeView->set_id(*xEntry, sId);
+            if (pCont->GetType() == GLBLDOC_SECTION && !pCont->GetSection()->IsConnectFlag())
+                m_xTreeView->set_font_color(*xEntry, COL_LIGHTRED);
+            else
+                m_xTreeView->set_font_color(*xEntry, COL_AUTO);
+            bEntry = m_xTreeView->iter_next(*xEntry);
+            assert(bEntry || i == nCount - 1);
+        }
+    }
+    else
+    {
+        int nOldSelEntry = m_xTreeView->get_selected_index();
+        OUString sEntryName;  // Name of the entry
+        int nSelPos = -1;
+        if (nOldSelEntry != -1)
+        {
+            sEntryName = m_xTreeView->get_text(nOldSelEntry);
+            nSelPos = nOldSelEntry;
+        }
+        m_xTreeView->freeze();
+        m_xTreeView->clear();
+        if (!m_pSwGlblDocContents)
+            Update( false );
+
+        int nSelEntry = -1;
+        for (size_t i = 0; i < nCount; ++i)
+        {
+            const SwGlblDocContent* pCont = (*m_pSwGlblDocContents)[i].get();
+
+            OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pCont)));
+            OUString sEntry;
+            OUString aImage;
+            switch (pCont->GetType())
+            {
+                case GLBLDOC_UNKNOWN:
+                    sEntry = m_aContextStrings[IDX_STR_INSERT_TEXT];
+                break;
+                case GLBLDOC_TOXBASE:
+                {
+                    const SwTOXBase* pBase = pCont->GetTOX();
+                    sEntry = pBase->GetTitle();
+                    aImage = RID_BMP_NAVI_INDEX;
+                }
+                break;
+                case GLBLDOC_SECTION:
+                {
+                    const SwSection* pSect = pCont->GetSection();
+                    sEntry = pSect->GetSectionName();
+                    aImage = RID_BMP_DROP_REGION;
+                }
+                break;
+            }
+
+            m_xTreeView->append(sId, sEntry);
+            if (!aImage.isEmpty())
+                m_xTreeView->set_image(i, aImage);
+
+            if (pCont->GetType() == GLBLDOC_SECTION && !pCont->GetSection()->IsConnectFlag())
+                m_xTreeView->set_font_color(i, COL_LIGHTRED);
+
+            if (sEntry == sEntryName)
+                nSelEntry = i;
+        }
+        m_xTreeView->thaw();
+        if (nSelEntry != -1)
+            m_xTreeView->select(nSelEntry);
+        else if (nSelPos != -1 && o3tl::make_unsigned(nSelPos) < nCount)
+            m_xTreeView->select(nSelPos);
+        else if (nCount)
+            m_xTreeView->select(0);
+        Select();
+    }
+}
+
+void SwGlobalTree::InsertRegion( const SwGlblDocContent* pCont, const OUString* pFileName )
+{
+    Sequence< OUString > aFileNames;
+    if ( !pFileName )
+    {
+        m_pDocInserter.reset(new ::sfx2::DocumentInserter(GetParentWindow()->GetFrameWeld(), "swriter", sfx2::DocumentInserter::Mode::InsertMulti));
+        m_pDocInserter->StartExecuteModal( LINK( this, SwGlobalTree, DialogClosedHdl ) );
+    }
+    else if ( !pFileName->isEmpty() )
+    {
+        aFileNames.realloc(1);
+        INetURLObject aFileName;
+        aFileName.SetSmartURL( *pFileName );
+        aFileNames.getArray()[0] = aFileName.GetMainURL( INetURLObject::DecodeMechanism::NONE );
+        InsertRegion( pCont, aFileNames );
+    }
+}
+
+void SwGlobalTree::EditContent(const SwGlblDocContent* pCont )
+{
+    sal_uInt16 nSlot = 0;
+    switch( pCont->GetType() )
+    {
+        case GLBLDOC_UNKNOWN:
+            m_pActiveShell->GetView().GetEditWin().GrabFocus();
+        break;
+        case GLBLDOC_TOXBASE:
+        {
+            const SwTOXBase* pBase = pCont->GetTOX();
+            if(pBase)
+                nSlot = FN_INSERT_MULTI_TOX;
+        }
+        break;
+        case GLBLDOC_SECTION:
+        {
+            OpenDoc(pCont);
+
+            nSlot = 0;
+            pCont = nullptr;
+        }
+        break;
+    }
+    if(pCont)
+        GotoContent(pCont);
+    if(nSlot)
+    {
+        m_pActiveShell->GetView().GetViewFrame()->GetDispatcher()->Execute(nSlot);
+        if(Update( false ))
+            Display();
+    }
+}
+
+void SwGlobalTree::ExecuteContextMenuAction(const OString& rSelectedPopupEntry)
+{
+    bool bUpdateHard = false;
+
+    int nEntry = m_xTreeView->get_selected_index();
+    SwGlblDocContent* pCont = nEntry != -1 ? reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(nEntry).toInt64()) : nullptr;
+    // If a RequestHelp is called during the dialogue,
+    // then the content gets lost. Because of that a copy
+    // is created in which only the DocPos is set correctly.
+    std::unique_ptr<SwGlblDocContent> pContCopy;
+    if(pCont)
+        pContCopy.reset(new SwGlblDocContent(pCont->GetDocPos()));
+    SfxDispatcher& rDispatch = *m_pActiveShell->GetView().GetViewFrame()->GetDispatcher();
+    sal_uInt16 nSlot = 0;
+    if (rSelectedPopupEntry == "updatesel")
+    {
+        // Two passes: first update the areas, then the directories.
+        m_xTreeView->selected_foreach([this](weld::TreeIter& rSelEntry){
+            SwGlblDocContent* pContent = reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(rSelEntry).toInt64());
+            if (GLBLDOC_SECTION == pContent->GetType() &&
+                pContent->GetSection()->IsConnected())
+            {
+                const_cast<SwSection*>(pContent->GetSection())->UpdateNow();
+            }
+            return false;
+        });
+        m_xTreeView->selected_foreach([this](weld::TreeIter& rSelEntry){
+            SwGlblDocContent* pContent = reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(rSelEntry).toInt64());
+            if (GLBLDOC_TOXBASE == pContent->GetType())
+                m_pActiveShell->UpdateTableOf(*pContent->GetTOX());
+            return false;
+        });
+
+        bUpdateHard = true;
+    }
+    else if (rSelectedPopupEntry == "updateindex")
+    {
+        nSlot = FN_UPDATE_TOX;
+        bUpdateHard = true;
+    }
+    else if (rSelectedPopupEntry == "updatelinks" || rSelectedPopupEntry == "updateall")
+    {
+        m_pActiveShell->GetLinkManager().UpdateAllLinks(true, false, nullptr);
+        if (rSelectedPopupEntry == "updateall")
+            nSlot = FN_UPDATE_TOX;
+        pCont = nullptr;
+        bUpdateHard = true;
+    }
+    else if (rSelectedPopupEntry == "edit")
+    {
+        OSL_ENSURE(pCont, "edit without entry ? " );
+        if (pCont)
+        {
+            EditContent(pCont);
+        }
+    }
+    else if (rSelectedPopupEntry == "editlink")
+    {
+        OSL_ENSURE(pCont, "edit without entry ? " );
+        if (pCont)
+        {
+            SfxStringItem aName(FN_EDIT_REGION,
+                    pCont->GetSection()->GetSectionName());
+            rDispatch.ExecuteList(FN_EDIT_REGION, SfxCallMode::ASYNCHRON,
+                    { &aName });
+        }
+    }
+    else if (rSelectedPopupEntry == "deleteentry")
+    {
+        // If several entries selected, then after each delete the array
+        // must be refilled. So you do not have to remember anything,
+        // deleting begins at the end.
+        std::vector<int> aRows = m_xTreeView->get_selected_rows();
+        std::sort(aRows.begin(), aRows.end());
+
+        std::unique_ptr<SwGlblDocContents> pTempContents;
+        m_pActiveShell->StartAction();
+        for (auto iter = aRows.rbegin(); iter != aRows.rend(); ++iter)
+        {
+            m_pActiveShell->DeleteGlobalDocContent(
+                pTempContents ? *pTempContents : *m_pSwGlblDocContents,
+                                 *iter);
+            pTempContents.reset(new SwGlblDocContents);
+            m_pActiveShell->GetGlobalDocContent(*pTempContents);
+        }
+        pTempContents.reset();
+        m_pActiveShell->EndAction();
+        pCont = nullptr;
+    }
+    else if (rSelectedPopupEntry == "insertindex")
+    {
+        if(pContCopy)
+        {
+            SfxItemSet aSet(
+                m_pActiveShell->GetView().GetPool(),
+                svl::Items<
+                    RES_FRM_SIZE, RES_FRM_SIZE,
+                    RES_LR_SPACE, RES_LR_SPACE,
+                    RES_BACKGROUND, RES_BACKGROUND,
+                    RES_COL, RES_COL,
+                    SID_ATTR_PAGE_SIZE, SID_ATTR_PAGE_SIZE,
+                    FN_PARAM_TOX_TYPE, FN_PARAM_TOX_TYPE>{});
+
+            SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+            ScopedVclPtr<AbstractMultiTOXTabDialog> pDlg(pFact->CreateMultiTOXTabDialog(
+                                                    m_xDialog->GetFrameWeld(), aSet,
+                                                    *m_pActiveShell,
+                                                    nullptr,
+                                                    true));
+            if(RET_OK == pDlg->Execute())
+            {
+                SwTOXDescription&  rDesc = pDlg->GetTOXDescription(
+                                            pDlg->GetCurrentTOXType());
+                SwTOXMgr aMgr(m_pActiveShell);
+                SwTOXBase* pToInsert = nullptr;
+                if(aMgr.UpdateOrInsertTOX(rDesc, &pToInsert, pDlg->GetOutputItemSet()))
+                    m_pActiveShell->InsertGlobalDocContent( *pContCopy, *pToInsert );
+            }
+            pCont = nullptr;
+        }
+    }
+    else if (rSelectedPopupEntry == "insertfile")
+    {
+        m_pDocContent = std::move(pContCopy);
+        InsertRegion( m_pDocContent.get() );
+        pCont = nullptr;
+    }
+    else if (rSelectedPopupEntry == "insertnewfile")
+    {
+        SfxViewFrame* pGlobFrame = m_pActiveShell->GetView().GetViewFrame();
+        SwGlobalFrameListener_Impl aFrameListener(*pGlobFrame);
+
+        // Creating a new doc
+        SfxStringItem aFactory(SID_NEWDOCDIRECT,
+                        SwDocShell::Factory().GetFilterContainer()->GetName());
+
+        const SfxFrameItem* pItem = static_cast<const SfxFrameItem*>(
+                        rDispatch.ExecuteList(SID_NEWDOCDIRECT,
+                            SfxCallMode::SYNCHRON, { &aFactory }));
+
+        // save at
+        SfxFrame* pFrame = pItem ? pItem->GetFrame() : nullptr;
+        SfxViewFrame* pViewFrame = pFrame ? pFrame->GetCurrentViewFrame() : nullptr;
+        if (pViewFrame)
+        {
+            const SfxBoolItem* pBool = static_cast<const SfxBoolItem*>(
+                    pViewFrame->GetDispatcher()->Execute(
+                            SID_SAVEASDOC, SfxCallMode::SYNCHRON ));
+            SfxObjectShell& rObj = *pViewFrame->GetObjectShell();
+            const SfxMedium* pMedium = rObj.GetMedium();
+            OUString sNewFile(pMedium->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::ToIUri));
+            // Insert the area with the Doc-Name
+            // Bring the own Doc in the foreground
+            if(aFrameListener.IsValid() && !sNewFile.isEmpty())
+            {
+                pGlobFrame->ToTop();
+                // Due to the update the entries are invalid
+                if (nEntry != -1)
+                {
+                    Update( false );
+                    Display();
+                    m_xTreeView->select(nEntry);
+                    Select();
+                    nEntry = m_xTreeView->get_selected_index();
+                    pCont = nEntry != -1 ? reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(nEntry).toInt64()) : nullptr;
+                }
+                else
+                {
+                    nEntry = -1;
+                    pCont = nullptr;
+                }
+                if(pBool->GetValue())
+                {
+                    InsertRegion(pCont, &sNewFile);
+                    pViewFrame->ToTop();
+                }
+                else
+                    pViewFrame->GetDispatcher()->Execute(SID_CLOSEWIN, SfxCallMode::SYNCHRON);
+            }
+            else
+            {
+                pViewFrame->ToTop();
+                return;
+            }
+        }
+    }
+    else if (rSelectedPopupEntry == "inserttext")
+    {
+        if (pCont)
+            m_pActiveShell->InsertGlobalDocContent(*pCont);
+        else
+        {
+            m_pActiveShell->SplitNode(); // Empty document
+            m_pActiveShell->Up( false );
+        }
+        m_pActiveShell->GetView().GetEditWin().GrabFocus();
+    }
+    else if (rSelectedPopupEntry == "update")
+        pCont = nullptr;
+
+    if (pCont)
+        GotoContent(pCont);
+    if (nSlot)
+        rDispatch.Execute(nSlot);
+    if (Update(bUpdateHard))
+        Display();
+}
+
+IMPL_LINK_NOARG(SwGlobalTree, Timeout, Timer *, void)
+{
+    if (!m_xTreeView->has_focus() && Update(false))
+        Display();
+}
+
+void SwGlobalTree::GotoContent(const SwGlblDocContent* pCont)
+{
+    m_pActiveShell->EnterStdMode();
+
+    switch( pCont->GetType()  )
+    {
+        case GLBLDOC_UNKNOWN:
+            m_pActiveShell->GotoGlobalDocContent(*pCont);
+        break;
+        case GLBLDOC_TOXBASE:
+        {
+            const OUString sName = pCont->GetTOX()->GetTOXName();
+            if (!m_pActiveShell->GotoNextTOXBase(&sName))
+                m_pActiveShell->GotoPrevTOXBase(&sName);
+        }
+        break;
+        case GLBLDOC_SECTION:
+        break;
+    }
+
+}
+
+void SwGlobalTree::ShowTree()
+{
+    m_aUpdateTimer.Start();
+    m_xTreeView->show();
+}
+
+void SwGlobalTree::HideTree()
+{
+    m_aUpdateTimer.Stop();
+    m_xTreeView->hide();
+}
+
+void SwGlobalTree::ExecCommand(const OString &rCmd)
+{
+    int nEntry = m_xTreeView->get_selected_index();
+    if (nEntry == -1)
+        return;
+    if (rCmd == "edit")
+    {
+        const SwGlblDocContent* pCont = reinterpret_cast<const SwGlblDocContent*>(
+                                                m_xTreeView->get_id(nEntry).toInt64());
+        EditContent(pCont);
+    }
+    else
+    {
+        if (m_xTreeView->count_selected_rows() == 1)
+        {
+            bool bMove = false;
+            sal_uLong nSource = nEntry;
+            sal_uLong nDest = nSource;
+            if (rCmd == "movedown")
+            {
+                size_t nEntryCount = m_xTreeView->n_children();
+                bMove = nEntryCount > nSource + 1;
+                nDest+= 2;
+            }
+            else if (rCmd == "moveup")
+            {
+                bMove = 0 != nSource;
+                nDest--;
+            }
+            if( bMove && m_pActiveShell->MoveGlobalDocContent(
+                *m_pSwGlblDocContents, nSource, nSource + 1, nDest ) &&
+                    Update( false ))
+                Display();
+        }
+    }
+}
+
+bool SwGlobalTree::Update(bool bHard)
+{
+    SwView* pActView = GetParentWindow()->GetCreateView();
+    bool bRet = false;
+    if (pActView && pActView->GetWrtShellPtr())
+    {
+        const SwWrtShell* pOldShell = m_pActiveShell;
+        m_pActiveShell = pActView->GetWrtShellPtr();
+        if(m_pActiveShell != pOldShell)
+        {
+            m_pSwGlblDocContents.reset();
+        }
+        if(!m_pSwGlblDocContents)
+        {
+            m_pSwGlblDocContents.reset(new SwGlblDocContents);
+            bRet = true;
+            m_pActiveShell->GetGlobalDocContent(*m_pSwGlblDocContents);
+        }
+        else
+        {
+            bool bCopy = false;
+            std::unique_ptr<SwGlblDocContents> pTempContents(new SwGlblDocContents);
+            m_pActiveShell->GetGlobalDocContent(*pTempContents);
+            size_t nChildren = m_xTreeView->n_children();
+            if (pTempContents->size() != m_pSwGlblDocContents->size() ||
+                    pTempContents->size() != nChildren)
+            {
+                bRet = true;
+                bCopy = true;
+            }
+            else
+            {
+                for(size_t i = 0; i < pTempContents->size() && !bCopy; i++)
+                {
+                    SwGlblDocContent* pLeft = (*pTempContents)[i].get();
+                    SwGlblDocContent* pRight = (*m_pSwGlblDocContents)[i].get();
+                    GlobalDocContentType eType = pLeft->GetType();
+                    OUString sTemp = m_xTreeView->get_text(i);
+                    if (
+                         eType != pRight->GetType() ||
+                         (
+                           eType == GLBLDOC_SECTION &&
+                           pLeft->GetSection()->GetSectionName() != sTemp
+                         ) ||
+                         (
+                           eType == GLBLDOC_TOXBASE &&
+                           pLeft->GetTOX()->GetTitle() != sTemp
+                         )
+                       )
+                    {
+                        bCopy = true;
+                    }
+                }
+            }
+            if (bCopy || bHard)
+            {
+                *m_pSwGlblDocContents = std::move( *pTempContents );
+                bRet = true;
+            }
+        }
+    }
+    else
+    {
+        m_xTreeView->clear();
+        if(m_pSwGlblDocContents)
+            m_pSwGlblDocContents->clear();
+    }
+    // FIXME: Implement a test for changes!
+    return bRet;
+}
+
+void SwGlobalTree::OpenDoc(const SwGlblDocContent* pCont)
+{
+    const OUString sFileName(pCont->GetSection()->GetLinkFileName().getToken(0,
+            sfx2::cTokenSeparator));
+    bool bFound = false;
+    const SfxObjectShell* pCurr = SfxObjectShell::GetFirst();
+    while( !bFound && pCurr )
+    {
+        if(pCurr->GetMedium() &&
+           pCurr->GetMedium()->GetURLObject().GetMainURL(INetURLObject::DecodeMechanism::ToIUri) == sFileName)
+        {
+            bFound = true;
+            SwGlobalTree::SetShowShell(pCurr);
+            Application::PostUserEvent(LINK(this, SwGlobalTree, ShowFrameHdl));
+            pCurr = nullptr;
+        }
+        else
+            pCurr = SfxObjectShell::GetNext(*pCurr);
+    }
+    if(!bFound)
+    {
+        SfxStringItem aURL(SID_FILE_NAME, sFileName);
+        SfxBoolItem aReadOnly(SID_DOC_READONLY, false);
+        SfxStringItem aTargetFrameName( SID_TARGETNAME, "_blank" );
+        SfxStringItem aReferer(SID_REFERER, m_pActiveShell->GetView().GetDocShell()->GetTitle());
+        m_pActiveShell->GetView().GetViewFrame()->GetDispatcher()->
+                ExecuteList(SID_OPENDOC, SfxCallMode::ASYNCHRON,
+                        { &aURL, &aReadOnly, &aReferer, &aTargetFrameName });
+    }
+}
+
+IMPL_LINK_NOARG( SwGlobalTree, DoubleClickHdl, weld::TreeView&, bool)
+{
+    int nEntry = m_xTreeView->get_cursor_index();
+    SwGlblDocContent* pCont = reinterpret_cast<SwGlblDocContent*>(m_xTreeView->get_id(nEntry).toInt64());
+    if (pCont->GetType() == GLBLDOC_SECTION)
+        OpenDoc(pCont);
+    else
+    {
+        GotoContent(pCont);
+        m_pActiveShell->GetView().GetEditWin().GrabFocus();
+    }
+    return false;
+}
+
+SwNavigationPI* SwGlobalTree::GetParentWindow()
+{
+    return m_xDialog;
+}
+
+IMPL_STATIC_LINK_NOARG(SwGlobalTree, ShowFrameHdl, void*, void)
+{
+    SfxViewFrame* pFirst = pShowShell ? SfxViewFrame::GetFirst(pShowShell) : nullptr;
+    if (pFirst)
+        pFirst->ToTop();
+    SwGlobalTree::SetShowShell(nullptr);
+}
+
+void SwGlobalTree::InsertRegion( const SwGlblDocContent* _pContent, const Sequence< OUString >& _rFiles )
+{
+    sal_Int32 nFiles = _rFiles.getLength();
+    if (!nFiles)
+        return;
+
+    size_t nEntryCount = m_xTreeView->n_children();
+
+    bool bMove = _pContent == nullptr;
+    const OUString* pFileNames = _rFiles.getConstArray();
+    SwWrtShell& rSh = GetParentWindow()->GetCreateView()->GetWrtShell();
+    rSh.StartAction();
+    // after insertion of the first new content the 'pCont' parameter becomes invalid
+    // find the index of the 'anchor' content to always use a current anchor content
+    size_t nAnchorContent = m_pSwGlblDocContents->size() - 1;
+    if (!bMove)
+    {
+        for (size_t nContent = 0; nContent < m_pSwGlblDocContents->size();
+                ++nContent)
+        {
+            if( *_pContent == *(*m_pSwGlblDocContents)[ nContent ] )
+            {
+                nAnchorContent = nContent;
+                break;
+            }
+        }
+    }
+    SwGlblDocContents aTempContents;
+    for ( sal_Int32 nFile = 0; nFile < nFiles; ++nFile )
+    {
+        //update the global document content after each inserted document
+        rSh.GetGlobalDocContent(aTempContents);
+        SwGlblDocContent* pAnchorContent = nullptr;
+        OSL_ENSURE(aTempContents.size() > (nAnchorContent + nFile), "invalid anchor content -> last insertion failed");
+        if ( aTempContents.size() > (nAnchorContent + nFile) )
+            pAnchorContent = aTempContents[nAnchorContent + nFile].get();
+        else
+            pAnchorContent = aTempContents.back().get();
+        OUString sFileName(pFileNames[nFile]);
+        INetURLObject aFileUrl;
+        aFileUrl.SetSmartURL( sFileName );
+        OUString sSectionName(aFileUrl.GetLastName(
+            INetURLObject::DecodeMechanism::Unambiguous).getToken(0, sfx2::cTokenSeparator));
+        sal_uInt16 nSectCount = rSh.GetSectionFormatCount();
+        OUString sTempSectionName(sSectionName);
+        sal_uInt16 nAddNumber = 0;
+        sal_uInt16 nCount = 0;
+        // if applicable: add index if the range name is already in use.
+        while ( nCount < nSectCount )
+        {
+            const SwSectionFormat& rFormat = rSh.GetSectionFormat(nCount);
+            if ((rFormat.GetSection()->GetSectionName() == sTempSectionName)
+                && rFormat.IsInNodesArr())
+            {
+                nCount = 0;
+                nAddNumber++;
+                sTempSectionName = sSectionName + ":" + OUString::number( nAddNumber );
+            }
+            else
+                nCount++;
+        }
+
+        if ( nAddNumber )
+            sSectionName = sTempSectionName;
+
+        SwSectionData aSectionData(SectionType::Content, sSectionName);
+        aSectionData.SetProtectFlag(true);
+        aSectionData.SetHidden(false);
+
+        aSectionData.SetLinkFileName(sFileName);
+        aSectionData.SetType(SectionType::FileLink);
+        aSectionData.SetLinkFilePassword( OUString() );
+
+        rSh.InsertGlobalDocContent( *pAnchorContent, aSectionData );
+    }
+    if (bMove)
+    {
+        Update( false );
+        rSh.MoveGlobalDocContent(
+            *m_pSwGlblDocContents, nEntryCount, nEntryCount + nFiles, nEntryCount - nFiles );
+    }
+    rSh.EndAction();
+    Update( false );
+    Display();
+
+}
+
+IMPL_LINK( SwGlobalTree, DialogClosedHdl, sfx2::FileDialogHelper*, _pFileDlg, void )
+{
+    if ( ERRCODE_NONE != _pFileDlg->GetError() )
+        return;
+
+    SfxMediumList aMedList(m_pDocInserter->CreateMediumList());
+    if ( !aMedList.empty() )
+    {
+        Sequence< OUString >aFileNames( aMedList.size() );
+        OUString* pFileNames = aFileNames.getArray();
+        sal_Int32 nPos = 0;
+        for (const std::unique_ptr<SfxMedium>& pMed : aMedList)
+        {
+            OUString sFileName = pMed->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::NONE )
+                + OUStringChar(sfx2::cTokenSeparator)
+                + pMed->GetFilter()->GetFilterName()
+                + OUStringChar(sfx2::cTokenSeparator);
+            pFileNames[nPos++] = sFileName;
+        }
+        InsertRegion( m_pDocContent.get(), aFileNames );
+        m_pDocContent.reset();
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/gloslst.cxx b/sw/source/uibase/utlui/gloslst.cxx
new file mode 100644
index 000000000..b58335850
--- /dev/null
+++ b/sw/source/uibase/utlui/gloslst.cxx
@@ -0,0 +1,441 @@
+/* -*- 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/weld.hxx>
+#include <svl/fstathelper.hxx>
+#include <unotools/pathoptions.hxx>
+#include <unotools/transliterationwrapper.hxx>
+#include <swtypes.hxx>
+#include <swmodule.hxx>
+#include <shellio.hxx>
+#include <initui.hxx>
+#include <glosdoc.hxx>
+#include <gloslst.hxx>
+#include <swunohelper.hxx>
+#include <view.hxx>
+
+#include <vector>
+
+#define STRING_DELIM char(0x0A)
+#define GLOS_TIMEOUT 30000   // update every 30 seconds
+#define FIND_MAX_GLOS 20
+
+namespace {
+
+struct TripleString
+{
+    OUString sGroup;
+    OUString sBlock;
+    OUString sShort;
+};
+
+class SwGlossDecideDlg : public weld::GenericDialogController
+{
+    std::unique_ptr<weld::Button> m_xOk;
+    std::unique_ptr<weld::TreeView> m_xListLB;
+
+    DECL_LINK(DoubleClickHdl, weld::TreeView&, bool);
+    DECL_LINK(SelectHdl, weld::TreeView&, void);
+
+public:
+    explicit SwGlossDecideDlg(weld::Window* pParent);
+
+    weld::TreeView& GetTreeView() {return *m_xListLB;}
+};
+
+}
+
+SwGlossDecideDlg::SwGlossDecideDlg(weld::Window* pParent)
+    : GenericDialogController(pParent, "modules/swriter/ui/selectautotextdialog.ui", "SelectAutoTextDialog")
+    , m_xOk(m_xBuilder->weld_button("ok"))
+    , m_xListLB(m_xBuilder->weld_tree_view("treeview"))
+{
+    m_xListLB->set_size_request(m_xListLB->get_approximate_digit_width() * 32,
+                                m_xListLB->get_height_rows(8));
+    m_xListLB->connect_row_activated(LINK(this, SwGlossDecideDlg, DoubleClickHdl));
+    m_xListLB->connect_changed(LINK(this, SwGlossDecideDlg, SelectHdl));
+}
+
+IMPL_LINK_NOARG(SwGlossDecideDlg, DoubleClickHdl, weld::TreeView&, bool)
+{
+    m_xDialog->response(RET_OK);
+    return true;
+}
+
+IMPL_LINK_NOARG(SwGlossDecideDlg, SelectHdl, weld::TreeView&, void)
+{
+    m_xOk->set_sensitive(m_xListLB->get_selected_index() != -1);
+}
+
+SwGlossaryList::SwGlossaryList() :
+    bFilled(false)
+{
+    SvtPathOptions aPathOpt;
+    sPath = aPathOpt.GetAutoTextPath();
+    SetTimeout(GLOS_TIMEOUT);
+}
+
+SwGlossaryList::~SwGlossaryList()
+{
+    ClearGroups();
+}
+
+// If the GroupName is already known, then only rShortName
+// will be filled. Otherwise also rGroupName will be set and
+// on demand asked for the right group.
+
+bool SwGlossaryList::GetShortName(const OUString& rLongName,
+                                  OUString& rShortName, OUString& rGroupName )
+{
+    if(!bFilled)
+        Update();
+
+    std::vector<TripleString> aTripleStrings;
+
+    size_t nCount = aGroupArr.size();
+    for(size_t i = 0; i < nCount; i++ )
+    {
+        AutoTextGroup* pGroup = aGroupArr[i].get();
+        if(!rGroupName.isEmpty() && rGroupName != pGroup->sName)
+            continue;
+
+        sal_Int32 nPosLong = 0;
+        for(sal_uInt16 j = 0; j < pGroup->nCount; j++)
+        {
+            const OUString sLong = pGroup->sLongNames.getToken(0, STRING_DELIM, nPosLong);
+            if(rLongName != sLong)
+                continue;
+
+            TripleString aTriple;
+            aTriple.sGroup = pGroup->sName;
+            aTriple.sBlock = sLong;
+            aTriple.sShort = pGroup->sShortNames.getToken(j, STRING_DELIM);
+            aTripleStrings.push_back(aTriple);
+        }
+    }
+
+    bool bRet = false;
+    nCount = aTripleStrings.size();
+    if(1 == nCount)
+    {
+        const TripleString& rTriple(aTripleStrings.front());
+        rShortName = rTriple.sShort;
+        rGroupName = rTriple.sGroup;
+        bRet = true;
+    }
+    else if(1 < nCount)
+    {
+        SwView *pView  = ::GetActiveView();
+        SwGlossDecideDlg aDlg(pView ? pView->GetFrameWeld() : nullptr);
+        OUString sTitle = aDlg.get_title() + " " + aTripleStrings.front().sBlock;
+        aDlg.set_title(sTitle);
+
+        weld::TreeView& rLB = aDlg.GetTreeView();
+        for (const auto& rTriple : aTripleStrings)
+            rLB.append_text(rTriple.sGroup.getToken(0, GLOS_DELIM));
+
+        rLB.select(0);
+        if (aDlg.run() == RET_OK && rLB.get_selected_index() != -1)
+        {
+            const TripleString& rTriple(aTripleStrings[rLB.get_selected_index()]);
+            rShortName = rTriple.sShort;
+            rGroupName = rTriple.sGroup;
+            bRet = true;
+        }
+        else
+            bRet = false;
+    }
+    return bRet;
+}
+
+size_t SwGlossaryList::GetGroupCount()
+{
+    if(!bFilled)
+        Update();
+    return aGroupArr.size();
+}
+
+OUString SwGlossaryList::GetGroupName(size_t nPos)
+{
+    OSL_ENSURE(aGroupArr.size() > nPos, "group not available");
+    if(nPos < aGroupArr.size())
+    {
+        AutoTextGroup* pGroup = aGroupArr[nPos].get();
+        OUString sRet = pGroup->sName;
+        return sRet;
+    }
+    return OUString();
+}
+
+OUString SwGlossaryList::GetGroupTitle(size_t nPos)
+{
+    OSL_ENSURE(aGroupArr.size() > nPos, "group not available");
+    if(nPos < aGroupArr.size())
+    {
+        AutoTextGroup* pGroup = aGroupArr[nPos].get();
+        return pGroup->sTitle;
+    }
+    return OUString();
+}
+
+sal_uInt16 SwGlossaryList::GetBlockCount(size_t nGroup)
+{
+    OSL_ENSURE(aGroupArr.size() > nGroup, "group not available");
+    if(nGroup < aGroupArr.size())
+    {
+        AutoTextGroup* pGroup = aGroupArr[nGroup].get();
+        return pGroup->nCount;
+    }
+    return 0;
+}
+
+OUString SwGlossaryList::GetBlockLongName(size_t nGroup, sal_uInt16 nBlock)
+{
+    OSL_ENSURE(aGroupArr.size() > nGroup, "group not available");
+    if(nGroup < aGroupArr.size())
+    {
+        AutoTextGroup* pGroup = aGroupArr[nGroup].get();
+        return pGroup->sLongNames.getToken(nBlock, STRING_DELIM);
+    }
+    return OUString();
+}
+
+OUString SwGlossaryList::GetBlockShortName(size_t nGroup, sal_uInt16 nBlock)
+{
+    OSL_ENSURE(aGroupArr.size() > nGroup, "group not available");
+    if(nGroup < aGroupArr.size())
+    {
+        AutoTextGroup* pGroup = aGroupArr[nGroup].get();
+        return pGroup->sShortNames.getToken(nBlock, STRING_DELIM);
+    }
+    return OUString();
+}
+
+void SwGlossaryList::Update()
+{
+    if(!IsActive())
+        Start();
+
+    SvtPathOptions aPathOpt;
+    const OUString& sTemp( aPathOpt.GetAutoTextPath() );
+    if(sTemp != sPath)
+    {
+        sPath = sTemp;
+        bFilled = false;
+        ClearGroups();
+    }
+    SwGlossaries* pGlossaries = ::GetGlossaries();
+    const std::vector<OUString> & rPathArr = pGlossaries->GetPathArray();
+    const OUString sExt( SwGlossaries::GetExtension() );
+    if(!bFilled)
+    {
+        const size_t nGroupCount = pGlossaries->GetGroupCnt();
+        for(size_t i = 0; i < nGroupCount; ++i)
+        {
+            OUString sGrpName = pGlossaries->GetGroupName(i);
+            const size_t nPath = static_cast<size_t>(
+                sGrpName.getToken(1, GLOS_DELIM).toInt32());
+            if( nPath < rPathArr.size() )
+            {
+                std::unique_ptr<AutoTextGroup> pGroup(new AutoTextGroup);
+                pGroup->sName = sGrpName;
+
+                FillGroup(pGroup.get(), pGlossaries);
+                OUString sName = rPathArr[nPath] + "/" +
+                    pGroup->sName.getToken(0, GLOS_DELIM) + sExt;
+                FStatHelper::GetModifiedDateTimeOfFile( sName,
+                                                &pGroup->aDateModified,
+                                                &pGroup->aDateModified );
+
+                aGroupArr.insert( aGroupArr.begin(), std::move(pGroup) );
+            }
+        }
+        bFilled = true;
+    }
+    else
+    {
+        for( size_t nPath = 0; nPath < rPathArr.size(); nPath++ )
+        {
+            std::vector<OUString> aFoundGroupNames;
+            std::vector<OUString> aFiles;
+            std::vector<DateTime> aDateTimeArr;
+
+            SWUnoHelper::UCB_GetFileListOfFolder( rPathArr[nPath], aFiles,
+                                                    &sExt, &aDateTimeArr );
+            for( size_t nFiles = 0; nFiles < aFiles.size(); ++nFiles )
+            {
+                const OUString aTitle = aFiles[ nFiles ];
+                ::DateTime& rDT = aDateTimeArr[ nFiles ];
+
+                OUString sName( aTitle.copy( 0, aTitle.getLength() - sExt.getLength() ));
+
+                aFoundGroupNames.push_back(sName);
+                sName += OUStringChar(GLOS_DELIM) + OUString::number( static_cast<sal_uInt16>(nPath) );
+                AutoTextGroup* pFound = FindGroup( sName );
+                if( !pFound )
+                {
+                    pFound = new AutoTextGroup;
+                    pFound->sName = sName;
+                    FillGroup( pFound, pGlossaries );
+                    pFound->aDateModified = rDT;
+
+                    aGroupArr.push_back(std::unique_ptr<AutoTextGroup>(pFound));
+                }
+                else if( pFound->aDateModified < rDT )
+                {
+                    FillGroup(pFound, pGlossaries);
+                    pFound->aDateModified = rDT;
+                }
+            }
+
+            for( size_t i = aGroupArr.size(); i>0; )
+            {
+                --i;
+                // maybe remove deleted groups
+                AutoTextGroup* pGroup = aGroupArr[i].get();
+                const size_t nGroupPath = static_cast<size_t>(
+                    pGroup->sName.getToken( 1, GLOS_DELIM).toInt32());
+                // Only the groups will be checked which are registered
+                // for the current subpath.
+                if( nGroupPath == nPath )
+                {
+                    OUString sCompareGroup = pGroup->sName.getToken(0, GLOS_DELIM);
+                    bool bFound = std::any_of(aFoundGroupNames.begin(), aFoundGroupNames.end(),
+                        [&sCompareGroup](const OUString& rGroupName) { return sCompareGroup == rGroupName; });
+
+                    if(!bFound)
+                    {
+                        aGroupArr.erase(aGroupArr.begin() + i);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void SwGlossaryList::Invoke()
+{
+    // Only update automatically if a SwView has the focus.
+    if(::GetActiveView())
+        Update();
+}
+
+AutoTextGroup* SwGlossaryList::FindGroup(const OUString& rGroupName)
+{
+    for(const auto & pRet : aGroupArr)
+    {
+        if(pRet->sName == rGroupName)
+            return pRet.get();
+    }
+    return nullptr;
+}
+
+void SwGlossaryList::FillGroup(AutoTextGroup* pGroup, SwGlossaries* pGlossaries)
+{
+    std::unique_ptr<SwTextBlocks> pBlock = pGlossaries->GetGroupDoc(pGroup->sName);
+    pGroup->nCount = pBlock ? pBlock->GetCount() : 0;
+    pGroup->sLongNames.clear();
+    pGroup->sShortNames.clear();
+    if(pBlock)
+        pGroup->sTitle = pBlock->GetName();
+
+    for(sal_uInt16 j = 0; j < pGroup->nCount; j++)
+    {
+        pGroup->sLongNames += pBlock->GetLongName(j)
+            + OUStringChar(STRING_DELIM);
+        pGroup->sShortNames += pBlock->GetShortName(j)
+            + OUStringChar(STRING_DELIM);
+    }
+}
+
+// Give back all (not exceeding FIND_MAX_GLOS) found modules
+// with matching beginning.
+
+void SwGlossaryList::HasLongName(const std::vector<OUString>& rBeginCandidates,
+                                 std::vector<std::pair<OUString, sal_uInt16>>& rLongNames)
+{
+    if(!bFilled)
+        Update();
+    const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
+    // We store results for all candidate words in separate lists, so that later
+    // we can sort them according to the candidate position
+    std::vector<std::vector<OUString>> aResults(rBeginCandidates.size());
+
+    // We can't break after FIND_MAX_GLOS items found, since first items may have ended up in
+    // lower-priority lists, and those from higher-priority lists are yet to come. So process all.
+    for (const auto& pGroup : aGroupArr)
+    {
+        sal_Int32 nIdx{ 0 };
+        for(sal_uInt16 j = 0; j < pGroup->nCount; j++)
+        {
+            OUString sBlock = pGroup->sLongNames.getToken(0, STRING_DELIM, nIdx);
+            for (size_t i = 0; i < rBeginCandidates.size(); ++i)
+            {
+                const OUString& s = rBeginCandidates[i];
+                if (s.getLength() + 1 < sBlock.getLength()
+                    && rSCmp.isEqual(sBlock.copy(0, s.getLength()), s))
+                {
+                    aResults[i].push_back(sBlock);
+                }
+            }
+        }
+    }
+
+    std::vector<std::pair<OUString, sal_uInt16>> aAllResults;
+    // Sort and concatenate all result lists. See QuickHelpData::SortAndFilter
+    for (size_t i = 0; i < rBeginCandidates.size(); ++i)
+    {
+        std::sort(aResults[i].begin(), aResults[i].end(),
+                  [origWord = rBeginCandidates[i]](const OUString& s1, const OUString& s2) {
+                      int nRet = s1.compareToIgnoreAsciiCase(s2);
+                      if (nRet == 0)
+                      {
+                          // fdo#61251 sort stuff that starts with the exact rOrigWord before
+                          // another ignore-case candidate
+                          int n1StartsWithOrig = s1.startsWith(origWord) ? 0 : 1;
+                          int n2StartsWithOrig = s2.startsWith(origWord) ? 0 : 1;
+                          return n1StartsWithOrig < n2StartsWithOrig;
+                      }
+                      return nRet < 0;
+                  });
+        // All suggestions must be accompanied with length of the text they would replace
+        std::transform(aResults[i].begin(), aResults[i].end(), std::back_inserter(aAllResults),
+                       [nLen = sal_uInt16(rBeginCandidates[i].getLength())](const OUString& s) {
+                           return std::make_pair(s, nLen);
+                       });
+    }
+
+    const auto& it = std::unique(
+        aAllResults.begin(), aAllResults.end(),
+        [](const std::pair<OUString, sal_uInt16>& s1, const std::pair<OUString, sal_uInt16>& s2) {
+            return s1.first.equalsIgnoreAsciiCase(s2.first);
+        });
+    if (const auto nCount = std::min<size_t>(std::distance(aAllResults.begin(), it), FIND_MAX_GLOS))
+    {
+        rLongNames.insert(rLongNames.end(), aAllResults.begin(), aAllResults.begin() + nCount);
+    }
+}
+
+void    SwGlossaryList::ClearGroups()
+{
+    aGroupArr.clear();
+    bFilled = false;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/gotodlg.cxx b/sw/source/uibase/utlui/gotodlg.cxx
new file mode 100644
index 000000000..63e7c424c
--- /dev/null
+++ b/sw/source/uibase/utlui/gotodlg.cxx
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <swmodule.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <gotodlg.hxx>
+#include <sfx2/bindings.hxx>
+#include <sfx2/viewfrm.hxx>
+
+using namespace com::sun::star;
+
+SwGotoPageDlg::SwGotoPageDlg(weld::Window* pParent, SfxBindings* _pBindings)
+    : GenericDialogController(pParent, "modules/swriter/ui/gotopagedialog.ui", "GotoPageDialog")
+    , m_pCreateView(nullptr)
+    , m_rBindings(_pBindings)
+    , mnMaxPageCnt(1)
+    , mxMtrPageCtrl(m_xBuilder->weld_entry("page"))
+    , mxPageNumberLbl(m_xBuilder->weld_label("page_count"))
+{
+    sal_uInt16 nTotalPage = GetPageInfo();
+
+    if(nTotalPage)
+    {
+        OUString sStr = mxPageNumberLbl->get_label();
+        mxPageNumberLbl->set_label(sStr.replaceFirst("$1", OUString::number(nTotalPage)));
+        mnMaxPageCnt = nTotalPage;
+    }
+    mxMtrPageCtrl->connect_changed(LINK(this, SwGotoPageDlg, PageModifiedHdl));
+    mxMtrPageCtrl->set_position(-1);
+    mxMtrPageCtrl->select_region(0, -1);
+}
+
+IMPL_LINK_NOARG(SwGotoPageDlg, PageModifiedHdl, weld::Entry&, void)
+{
+    if (!mxMtrPageCtrl->get_text().isEmpty())
+    {
+        int page_value = mxMtrPageCtrl->get_text().toInt32();
+
+        if (page_value <= 0)
+            mxMtrPageCtrl->set_text(OUString::number(1));
+        else if(page_value > mnMaxPageCnt)
+            mxMtrPageCtrl->set_text(OUString::number(mnMaxPageCnt));
+
+        mxMtrPageCtrl->set_position(-1);
+    }
+}
+
+SwView*  SwGotoPageDlg::GetCreateView() const
+{
+    if(!m_pCreateView)
+    {
+        SwView* pView = SwModule::GetFirstView();
+        while(pView)
+        {
+            if(&pView->GetViewFrame()->GetBindings() == m_rBindings)
+            {
+                const_cast<SwGotoPageDlg*>(this)->m_pCreateView = pView;
+                break;
+            }
+            pView = SwModule::GetNextView(pView);
+        }
+    }
+
+    return m_pCreateView;
+}
+
+// If the page can be set here, the maximum is set.
+
+sal_uInt16 SwGotoPageDlg::GetPageInfo()
+{
+    SwView *pView = GetCreateView();
+    SwWrtShell *pSh = pView ? &pView->GetWrtShell() : nullptr;
+    mxMtrPageCtrl->set_text(OUString::number(1));
+    if (pSh)
+    {
+        const sal_uInt16 nPageCnt = pSh->GetPageCnt();
+        sal_uInt16 nPhyPage, nVirPage;
+        pSh->GetPageNum(nPhyPage, nVirPage);
+        mxMtrPageCtrl->set_text(OUString::number(nPhyPage));
+        return nPageCnt;
+    }
+    return 0;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/initui.cxx b/sw/source/uibase/utlui/initui.cxx
new file mode 100644
index 000000000..f9567ec4a
--- /dev/null
+++ b/sw/source/uibase/utlui/initui.cxx
@@ -0,0 +1,289 @@
+/* -*- 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/localedatawrapper.hxx>
+#include <viewsh.hxx>
+#include <initui.hxx>
+#include <edtwin.hxx>
+#include <shellres.hxx>
+#include <fldbas.hxx>
+#include <glosdoc.hxx>
+#include <gloslst.hxx>
+#include <comcore.hxx>
+#include <strings.hrc>
+#include <utlui.hrc>
+#include <authfld.hxx>
+#include <unotools/syslocale.hxx>
+
+// Global Pointer
+
+static std::unique_ptr<SwGlossaries> pGlossaries;
+
+// Provides all needed paths. Is initialized by UI.
+static SwGlossaryList* pGlossaryList = nullptr;
+
+namespace
+{
+OUString CurrGlosGroup;
+}
+
+const OUString& GetCurrGlosGroup()
+{
+    return CurrGlosGroup;
+}
+
+void SetCurrGlosGroup(const OUString& sStr)
+{
+    CurrGlosGroup = sStr;
+}
+
+namespace
+{
+
+std::vector<OUString>* pAuthFieldNameList = nullptr;
+std::vector<OUString>* pAuthFieldTypeList = nullptr;
+
+}
+
+// Finish UI
+
+void FinitUI()
+{
+    delete SwViewShell::GetShellRes();
+    SwViewShell::SetShellRes( nullptr );
+
+    SwEditWin::FinitStaticData();
+
+    pGlossaries.reset();
+
+    delete SwFieldType::s_pFieldNames;
+
+    delete pGlossaryList;
+    delete pAuthFieldNameList;
+    delete pAuthFieldTypeList;
+
+}
+
+// Initialise
+
+void InitUI()
+{
+    // ShellResource gives the CORE the possibility to work with resources.
+    SwViewShell::SetShellRes( new ShellResource );
+    SwEditWin::InitStaticData();
+}
+
+static const char* FLD_DOCINFO_ARY[] =
+{
+    FLD_DOCINFO_TITLE,
+    FLD_DOCINFO_SUBJECT,
+    FLD_DOCINFO_KEYS,
+    FLD_DOCINFO_COMMENT,
+    FLD_DOCINFO_CREATE,
+    FLD_DOCINFO_CHANGE,
+    FLD_DOCINFO_PRINT,
+    FLD_DOCINFO_DOCNO,
+    FLD_DOCINFO_EDIT
+};
+
+ShellResource::ShellResource()
+    : aPostItAuthor( SwResId( STR_POSTIT_AUTHOR ) ),
+    aPostItPage( SwResId( STR_POSTIT_PAGE ) ),
+    aPostItLine( SwResId( STR_POSTIT_LINE ) ),
+
+    aCalc_Syntax( SwResId( STR_CALC_SYNTAX ) ),
+    aCalc_ZeroDiv( SwResId( STR_CALC_ZERODIV ) ),
+    aCalc_Brack( SwResId( STR_CALC_BRACK ) ),
+    aCalc_Pow( SwResId( STR_CALC_POW ) ),
+    aCalc_Overflow( SwResId( STR_CALC_OVERFLOW ) ),
+    aCalc_Default( SwResId( STR_CALC_DEFAULT ) ),
+    aCalc_Error( SwResId( STR_CALC_ERROR ) ),
+
+    // #i81002#
+    aGetRefField_RefItemNotFound( SwResId( STR_GETREFFLD_REFITEMNOTFOUND ) ),
+    aStrNone( SwResId( STR_TEMPLATE_NONE )),
+    aFixedStr( SwResId( STR_FIELD_FIXED )),
+    sDurationFormat( SwResId( STR_DURATION_FORMAT )),
+
+    aTOXIndexName(          SwResId(STR_TOI)),
+    aTOXUserName(           SwResId(STR_TOU)),
+    aTOXContentName(        SwResId(STR_TOC)),
+    aTOXIllustrationsName(  SwResId(STR_TOX_ILL)),
+    aTOXObjectsName(        SwResId(STR_TOX_OBJ)),
+    aTOXTablesName(         SwResId(STR_TOX_TBL)),
+    aTOXAuthoritiesName(    SwResId(STR_TOX_AUTH)),
+    aTOXCitationName(    SwResId(STR_TOX_CITATION)),
+    sPageDescFirstName(     SwResId(STR_PAGEDESC_FIRSTNAME)),
+    sPageDescFollowName(    SwResId(STR_PAGEDESC_FOLLOWNAME)),
+    sPageDescName(          SwResId(STR_PAGEDESC_NAME))
+{
+    for (size_t i = 0; i < SAL_N_ELEMENTS(FLD_DOCINFO_ARY); ++i)
+        aDocInfoLst.push_back(SwResId(FLD_DOCINFO_ARY[i]));
+}
+
+OUString ShellResource::GetPageDescName(sal_uInt16 nNo, PageNameMode eMode)
+{
+    OUString sRet;
+
+    switch (eMode)
+    {
+        case NORMAL_PAGE:
+            sRet = sPageDescName;
+            break;
+        case FIRST_PAGE:
+            sRet = sPageDescFirstName;
+            break;
+        case FOLLOW_PAGE:
+            sRet = sPageDescFollowName;
+            break;
+    }
+
+    return sRet.replaceFirst( "$(ARG1)", OUString::number( nNo ));
+}
+
+SwGlossaries* GetGlossaries()
+{
+    if (!pGlossaries)
+        pGlossaries.reset( new SwGlossaries );
+    return pGlossaries.get();
+}
+
+bool HasGlossaryList()
+{
+    return pGlossaryList != nullptr;
+}
+
+SwGlossaryList* GetGlossaryList()
+{
+    if(!pGlossaryList)
+        pGlossaryList = new SwGlossaryList();
+
+    return pGlossaryList;
+}
+
+void ShellResource::GetAutoFormatNameLst_() const
+{
+    assert(!pAutoFormatNameLst);
+    pAutoFormatNameLst.reset( new std::vector<OUString> );
+    pAutoFormatNameLst->reserve(STR_AUTOFMTREDL_END);
+
+    assert(SAL_N_ELEMENTS(RID_SHELLRES_AUTOFMTSTRS) == STR_AUTOFMTREDL_END);
+    for (sal_uInt16 n = 0; n < STR_AUTOFMTREDL_END; ++n)
+    {
+        OUString p(SwResId(RID_SHELLRES_AUTOFMTSTRS[n]));
+        if (STR_AUTOFMTREDL_TYPO == n)
+        {
+            const SvtSysLocale aSysLocale;
+            const LocaleDataWrapper& rLclD = aSysLocale.GetLocaleData();
+            p = p.replaceFirst("%1", rLclD.getDoubleQuotationMarkStart());
+            p = p.replaceFirst("%2", rLclD.getDoubleQuotationMarkEnd());
+        }
+        pAutoFormatNameLst->push_back(p);
+    }
+}
+
+namespace
+{
+    const char* STR_AUTH_FIELD_ARY[] =
+    {
+        STR_AUTH_FIELD_IDENTIFIER,
+        STR_AUTH_FIELD_AUTHORITY_TYPE,
+        STR_AUTH_FIELD_ADDRESS,
+        STR_AUTH_FIELD_ANNOTE,
+        STR_AUTH_FIELD_AUTHOR,
+        STR_AUTH_FIELD_BOOKTITLE,
+        STR_AUTH_FIELD_CHAPTER,
+        STR_AUTH_FIELD_EDITION,
+        STR_AUTH_FIELD_EDITOR,
+        STR_AUTH_FIELD_HOWPUBLISHED,
+        STR_AUTH_FIELD_INSTITUTION,
+        STR_AUTH_FIELD_JOURNAL,
+        STR_AUTH_FIELD_MONTH,
+        STR_AUTH_FIELD_NOTE,
+        STR_AUTH_FIELD_NUMBER,
+        STR_AUTH_FIELD_ORGANIZATIONS,
+        STR_AUTH_FIELD_PAGES,
+        STR_AUTH_FIELD_PUBLISHER,
+        STR_AUTH_FIELD_SCHOOL,
+        STR_AUTH_FIELD_SERIES,
+        STR_AUTH_FIELD_TITLE,
+        STR_AUTH_FIELD_TYPE,
+        STR_AUTH_FIELD_VOLUME,
+        STR_AUTH_FIELD_YEAR,
+        STR_AUTH_FIELD_URL,
+        STR_AUTH_FIELD_CUSTOM1,
+        STR_AUTH_FIELD_CUSTOM2,
+        STR_AUTH_FIELD_CUSTOM3,
+        STR_AUTH_FIELD_CUSTOM4,
+        STR_AUTH_FIELD_CUSTOM5,
+        STR_AUTH_FIELD_ISBN
+    };
+}
+
+OUString const & SwAuthorityFieldType::GetAuthFieldName(ToxAuthorityField eType)
+{
+    if(!pAuthFieldNameList)
+    {
+        pAuthFieldNameList = new std::vector<OUString>;
+        pAuthFieldNameList->reserve(AUTH_FIELD_END);
+        for (sal_uInt16 i = 0; i < AUTH_FIELD_END; ++i)
+            pAuthFieldNameList->push_back(SwResId(STR_AUTH_FIELD_ARY[i]));
+    }
+    return (*pAuthFieldNameList)[static_cast< sal_uInt16 >(eType)];
+}
+
+static const char* STR_AUTH_TYPE_ARY[] =
+{
+    STR_AUTH_TYPE_ARTICLE,
+    STR_AUTH_TYPE_BOOK,
+    STR_AUTH_TYPE_BOOKLET,
+    STR_AUTH_TYPE_CONFERENCE,
+    STR_AUTH_TYPE_INBOOK,
+    STR_AUTH_TYPE_INCOLLECTION,
+    STR_AUTH_TYPE_INPROCEEDINGS,
+    STR_AUTH_TYPE_JOURNAL,
+    STR_AUTH_TYPE_MANUAL,
+    STR_AUTH_TYPE_MASTERSTHESIS,
+    STR_AUTH_TYPE_MISC,
+    STR_AUTH_TYPE_PHDTHESIS,
+    STR_AUTH_TYPE_PROCEEDINGS,
+    STR_AUTH_TYPE_TECHREPORT,
+    STR_AUTH_TYPE_UNPUBLISHED,
+    STR_AUTH_TYPE_EMAIL,
+    STR_AUTH_TYPE_WWW,
+    STR_AUTH_TYPE_CUSTOM1,
+    STR_AUTH_TYPE_CUSTOM2,
+    STR_AUTH_TYPE_CUSTOM3,
+    STR_AUTH_TYPE_CUSTOM4,
+    STR_AUTH_TYPE_CUSTOM5
+};
+
+OUString const & SwAuthorityFieldType::GetAuthTypeName(ToxAuthorityType eType)
+{
+    if(!pAuthFieldTypeList)
+    {
+        pAuthFieldTypeList = new std::vector<OUString>;
+        pAuthFieldTypeList->reserve(AUTH_TYPE_END);
+        for (sal_uInt16 i = 0; i < AUTH_TYPE_END; ++i)
+            pAuthFieldTypeList->push_back(SwResId(STR_AUTH_TYPE_ARY[i]));
+    }
+    return (*pAuthFieldTypeList)[static_cast< sal_uInt16 >(eType)];
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/navicfg.cxx b/sw/source/uibase/utlui/navicfg.cxx
new file mode 100644
index 000000000..f1b4f3983
--- /dev/null
+++ b/sw/source/uibase/utlui/navicfg.cxx
@@ -0,0 +1,128 @@
+/* -*- 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 <swtypes.hxx>
+#include <navicfg.hxx>
+#include <swcont.hxx>
+#include <o3tl/any.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <com/sun/star/uno/Sequence.hxx>
+
+using namespace ::utl;
+using namespace ::com::sun::star::uno;
+
+Sequence<OUString> SwNavigationConfig::GetPropertyNames()
+{
+    return css::uno::Sequence<OUString>{
+        OUString("RootType"),
+        OUString("SelectedPosition"),
+        OUString("OutlineLevel"),
+        OUString("InsertMode"),
+        OUString("ActiveBlock"),
+        OUString("ShowListBox"),
+        OUString("GlobalDocMode")};
+}
+
+SwNavigationConfig::SwNavigationConfig() :
+    utl::ConfigItem("Office.Writer/Navigator"),
+    nRootType(ContentTypeId::UNKNOWN),
+    nSelectedPos(0),
+    nOutlineLevel(MAXLEVEL),
+    nRegionMode(RegionMode::NONE),
+    nActiveBlock(0),
+    bIsSmall(false),
+    bIsGlobalActive(true)
+{
+    Sequence<OUString> aNames = GetPropertyNames();
+    Sequence<Any> aValues = GetProperties(aNames);
+    const Any* pValues = aValues.getConstArray();
+    OSL_ENSURE(aValues.getLength() == aNames.getLength(), "GetProperties failed");
+    if(aValues.getLength() == aNames.getLength())
+    {
+        for(int nProp = 0; nProp < aNames.getLength(); nProp++)
+        {
+            if(pValues[nProp].hasValue())
+            {
+                switch(nProp)
+                {
+                    case 0:
+                    {
+                        sal_Int32 nTmp = {}; // spurious -Werror=maybe-uninitialized
+                        if (pValues[nProp] >>= nTmp)
+                        {
+                            if (nTmp < sal_Int32(ContentTypeId::UNKNOWN)
+                                || nTmp > sal_Int32(ContentTypeId::LAST))
+                            {
+                                SAL_WARN(
+                                    "sw",
+                                    "out-of-bounds ContentTypeId " << nTmp);
+                                nTmp = sal_Int32(ContentTypeId::UNKNOWN);
+                            }
+                            nRootType = static_cast<ContentTypeId>(nTmp);
+                        }
+                        break;
+                    }
+                    case 1: pValues[nProp] >>= nSelectedPos;   break;
+                    case 2: pValues[nProp] >>= nOutlineLevel;  break;
+                    case 3:
+                    {
+                            sal_uInt16 nTmp;
+                            if (pValues[nProp] >>= nTmp)
+                                nRegionMode = static_cast<RegionMode>(nTmp);
+                            break;
+                    }
+                    case 4: pValues[nProp] >>= nActiveBlock;    break;
+                    case 5: bIsSmall        = *o3tl::doAccess<bool>(pValues[nProp]);  break;
+                    case 6: bIsGlobalActive = *o3tl::doAccess<bool>(pValues[nProp]);  break;
+                }
+            }
+        }
+    }
+}
+
+SwNavigationConfig::~SwNavigationConfig()
+{
+}
+
+void SwNavigationConfig::ImplCommit()
+{
+    Sequence<OUString> aNames = GetPropertyNames();
+    Sequence<Any> aValues(aNames.getLength());
+    Any* pValues = aValues.getArray();
+
+    for(int nProp = 0; nProp < aNames.getLength(); nProp++)
+    {
+        switch(nProp)
+        {
+            case 0: pValues[nProp] <<= static_cast<sal_Int32>(nRootType);     break;
+            case 1: pValues[nProp] <<= nSelectedPos;  break;
+            case 2: pValues[nProp] <<= nOutlineLevel; break;
+            case 3: pValues[nProp] <<= static_cast<sal_uInt16>(nRegionMode); break;
+            case 4: pValues[nProp] <<= nActiveBlock;    break;
+            case 5: pValues[nProp] <<= bIsSmall; break;
+            case 6: pValues[nProp] <<= bIsGlobalActive; break;
+        }
+    }
+    PutProperties(aNames, aValues);
+}
+
+void SwNavigationConfig::Notify( const css::uno::Sequence< OUString >& ) {}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/navipi.cxx b/sw/source/uibase/utlui/navipi.cxx
new file mode 100644
index 000000000..577aba8fc
--- /dev/null
+++ b/sw/source/uibase/utlui/navipi.cxx
@@ -0,0 +1,1128 @@
+/* -*- 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 <svl/urlbmk.hxx>
+#include <svl/stritem.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <sot/formats.hxx>
+#include <sot/filelist.hxx>
+#include <sfx2/event.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/navigat.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <tools/urlobj.hxx>
+#include <vcl/toolbox.hxx>
+#include <swtypes.hxx>
+#include <swmodule.hxx>
+#include <view.hxx>
+#include <navicfg.hxx>
+#include <wrtsh.hxx>
+#include <docsh.hxx>
+#include <navipi.hxx>
+#include <workctrl.hxx>
+#include <edtwin.hxx>
+#include <sfx2/app.hxx>
+#include <cmdid.h>
+#include <helpids.h>
+
+#include <strings.hrc>
+#include <bitmaps.hlst>
+
+#include <memory>
+
+#include <uiobject.hxx>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::frame;
+
+//! soon obsolete !
+std::unique_ptr<SfxChildWindowContext> SwNavigationChild::CreateImpl( vcl::Window *pParent,
+        SfxBindings *pBindings, SfxChildWinInfo* /*pInfo*/ )
+{
+    return std::make_unique<SwNavigationChild>(pParent,
+            /* cast is safe here! */static_cast< sal_uInt16 >(SwView::GetInterfaceId()),
+            pBindings);
+}
+void    SwNavigationChild::RegisterChildWindowContext(SfxModule* pMod)
+{
+    auto pFact = std::make_unique<SfxChildWinContextFactory>(
+       SwNavigationChild::CreateImpl,
+       /* cast is safe here! */static_cast< sal_uInt16 >(SwView::GetInterfaceId()) );
+    SfxChildWindowContext::RegisterChildWindowContext(pMod, SID_NAVIGATOR, std::move(pFact));
+}
+
+
+// Filter the control characters out of the Outline-Entry
+
+OUString SwNavigationPI::CleanEntry(const OUString& rEntry)
+{
+    if (rEntry.isEmpty())
+        return rEntry;
+
+    OUStringBuffer aEntry(rEntry);
+    for (sal_Int32 i = 0; i < rEntry.getLength(); ++i)
+        if(aEntry[i] == 10 || aEntry[i] == 9)
+            aEntry[i] = 0x20;
+
+    return aEntry.makeStringAndClear();
+}
+
+// Execution of the drag operation with and without the children.
+
+void SwNavigationPI::MoveOutline(SwOutlineNodes::size_type nSource, SwOutlineNodes::size_type nTarget)
+{
+    SwView *pView = GetCreateView();
+    SwWrtShell &rSh = pView->GetWrtShell();
+    if(nTarget < nSource || nTarget == SwOutlineNodes::npos)
+        nTarget ++;
+    if ( rSh.IsOutlineMovable( nSource ))
+    {
+
+        SwOutlineNodes::difference_type nMove = nTarget-nSource; //( nDir<0 ) ? 1 : 0 ;
+        rSh.GotoOutline(nSource);
+        rSh.MakeOutlineSel(nSource, nSource, true);
+        // While moving, the selected children does not counting.
+        const SwOutlineNodes::size_type nLastOutlinePos = rSh.GetOutlinePos(MAXLEVEL);
+        if(nMove > 1 && nLastOutlinePos < nTarget)
+        {
+            if(!rSh.IsCursorPtAtEnd())
+                rSh.SwapPam();
+            nMove -= nLastOutlinePos - nSource;
+        }
+        if( nMove < 1 || nLastOutlinePos < nTarget )
+            rSh.MoveOutlinePara( nMove );
+        rSh.ClearMark();
+        rSh.GotoOutline( nSource + nMove);
+    }
+
+}
+
+// After goto cancel the status frame selection
+static void lcl_UnSelectFrame(SwWrtShell *pSh)
+{
+    if (pSh->IsFrameSelected())
+    {
+        pSh->UnSelectFrame();
+        pSh->LeaveSelFrameMode();
+    }
+}
+
+// Select the document view
+IMPL_LINK(SwNavigationPI, DocListBoxSelectHdl, weld::ComboBox&, rBox, void)
+{
+    int nEntryIdx = rBox.get_active();
+    SwView *pView ;
+    pView = SwModule::GetFirstView();
+    while (nEntryIdx-- && pView)
+    {
+        pView = SwModule::GetNextView(pView);
+    }
+    if(!pView)
+    {
+        nEntryIdx == 0 ?
+            m_xContentTree->ShowHiddenShell():
+                m_xContentTree->ShowActualView();
+
+    }
+    else
+    {
+        m_xContentTree->SetConstantShell(pView->GetWrtShellPtr());
+    }
+}
+
+// Filling of the list box for outline view or documents
+// The PI will be set to full size
+void SwNavigationPI::FillBox()
+{
+    if(m_pContentWrtShell)
+    {
+        m_xContentTree->SetHiddenShell( m_pContentWrtShell );
+        m_xContentTree->Display(  false );
+    }
+    else
+    {
+        SwView *pView = GetCreateView();
+        if(!pView)
+        {
+            m_xContentTree->SetActiveShell(nullptr);
+        }
+        else if( pView != m_pActContView)
+        {
+            SwWrtShell* pWrtShell = pView->GetWrtShellPtr();
+            m_xContentTree->SetActiveShell(pWrtShell);
+        }
+        else
+            m_xContentTree->Display( true );
+        m_pActContView = pView;
+    }
+}
+
+void SwNavigationPI::UsePage()
+{
+    SwView *pView = GetCreateView();
+    SwWrtShell *pSh = pView ? &pView->GetWrtShell() : nullptr;
+    m_xEdit->set_value(1);
+    if (pSh)
+    {
+        const sal_uInt16 nPageCnt = pSh->GetPageCnt();
+        sal_uInt16 nPhyPage, nVirPage;
+        pSh->GetPageNum(nPhyPage, nVirPage);
+
+        m_xEdit->set_max(nPageCnt);
+        m_xEdit->set_width_chars(3);
+        m_xEdit->set_value(nPhyPage);
+    }
+}
+
+// Select handler of the toolboxes
+IMPL_LINK(SwNavigationPI, ToolBoxSelectHdl, const OString&, rCommand, void)
+{
+    SwView *pView = GetCreateView();
+    if (!pView)
+        return;
+    SwWrtShell &rSh = pView->GetWrtShell();
+    // Get MouseModifier for Outline-Move
+
+    int nFuncId = 0;
+    bool bFocusToDoc = false;
+    if (rCommand == ".uno:ScrollToPrevious")
+    {
+        rSh.GetView().GetViewFrame()->GetDispatcher()->Execute(FN_SCROLL_PREV, SfxCallMode::ASYNCHRON);
+    }
+    else if (rCommand == ".uno:ScrollToNext")
+    {
+        rSh.GetView().GetViewFrame()->GetDispatcher()->Execute(FN_SCROLL_NEXT, SfxCallMode::ASYNCHRON);
+    }
+    else if (rCommand == "root")
+    {
+        m_xContentTree->ToggleToRoot();
+    }
+    else if (rCommand == "listbox")
+    {
+        if (SfxChildWindowContext::GetFloatingWindow(GetParent()))
+        {
+            if (IsZoomedIn())
+            {
+                ZoomOut();
+            }
+            else
+            {
+                ZoomIn();
+            }
+        }
+        return;
+    }
+    // Functions that will trigger a direct action.
+    else if (rCommand == "footer")
+    {
+        rSh.MoveCursor();
+        const FrameTypeFlags eType = rSh.GetFrameType(nullptr,false);
+        if (eType & FrameTypeFlags::FOOTER)
+        {
+            if (rSh.EndPg())
+                nFuncId = FN_END_OF_PAGE;
+        }
+        else if (rSh.GotoFooterText())
+            nFuncId = FN_TO_FOOTER;
+        bFocusToDoc = true;
+    }
+    else if (rCommand == "header")
+    {
+        rSh.MoveCursor();
+        const FrameTypeFlags eType = rSh.GetFrameType(nullptr,false);
+        if (eType & FrameTypeFlags::HEADER)
+        {
+            if (rSh.SttPg())
+                nFuncId = FN_START_OF_PAGE;
+        }
+        else if (rSh.GotoHeaderText())
+            nFuncId = FN_TO_HEADER;
+        bFocusToDoc = true;
+    }
+    else if (rCommand == "anchor")
+    {
+        rSh.MoveCursor();
+        const FrameTypeFlags eFrameType = rSh.GetFrameType(nullptr,false);
+            // Jump from the footnote to the anchor.
+        if (eFrameType & FrameTypeFlags::FOOTNOTE)
+        {
+            if (rSh.GotoFootnoteAnchor())
+                nFuncId = FN_FOOTNOTE_TO_ANCHOR;
+        }
+            // Otherwise, jump to the first footnote text;
+            // go to the next footnote if this is not possible;
+            // if this is also not possible got to the footnote before.
+        else
+        {
+            if (rSh.GotoFootnoteText())
+                nFuncId = FN_FOOTNOTE_TO_ANCHOR;
+            else if (rSh.GotoNextFootnoteAnchor())
+                nFuncId = FN_NEXT_FOOTNOTE;
+            else if (rSh.GotoPrevFootnoteAnchor())
+                nFuncId = FN_PREV_FOOTNOTE;
+        }
+        bFocusToDoc = true;
+    }
+    else if (rCommand == "reminder")
+    {
+        rSh.GetView().GetViewFrame()->GetDispatcher()->Execute(FN_SET_REMINDER, SfxCallMode::ASYNCHRON);
+    }
+    else if (rCommand == "chapterdown" ||
+             rCommand == "movedown" ||
+             rCommand == "chapterup" ||
+             rCommand == "moveup" ||
+             rCommand == "promote" ||
+             rCommand == "demote" ||
+             rCommand == "edit")
+    {
+        if (IsGlobalMode())
+            m_xGlobalTree->ExecCommand(rCommand);
+        else
+        {
+            // Standard: sublevels are taken
+            // do not take sublevels with Ctrl
+            bool bOutlineWithChildren = (KEY_MOD1 != m_xContent3ToolBox->get_modifier_state());
+            m_xContentTree->ExecCommand(rCommand, bOutlineWithChildren);
+        }
+    }
+    else if (rCommand == "contenttoggle" || rCommand == "globaltoggle")
+    {
+        ToggleTree();
+        bool bGlobalMode = IsGlobalMode();
+        m_pConfig->SetGlobalActive(bGlobalMode);
+        m_xGlobalToolBox->set_item_active("globaltoggle", bGlobalMode);
+        m_xContent1ToolBox->set_item_active("contenttoggle", bGlobalMode);
+    }
+    else if (rCommand == "save")
+    {
+        bool bSave = rSh.IsGlblDocSaveLinks();
+        rSh.SetGlblDocSaveLinks( !bSave );
+        m_xGlobalToolBox->set_item_active(rCommand, !bSave);
+    }
+    else if (rCommand == "dragmode")
+        m_xContent3ToolBox->set_menu_item_active("dragmode", !m_xContent3ToolBox->get_menu_item_active("dragmode"));
+    else if (rCommand == "headings")
+        m_xContent2ToolBox->set_menu_item_active("headings", !m_xContent2ToolBox->get_menu_item_active("headings"));
+    else if (rCommand == "update")
+        m_xGlobalToolBox->set_menu_item_active("update", !m_xGlobalToolBox->get_menu_item_active("update"));
+    else if (rCommand == "insert")
+        m_xGlobalToolBox->set_menu_item_active("insert", !m_xGlobalToolBox->get_menu_item_active("insert"));
+
+    if (nFuncId)
+        lcl_UnSelectFrame(&rSh);
+    if (bFocusToDoc)
+        pView->GetEditWin().GrabFocus();
+}
+
+// Click handler of the toolboxes
+IMPL_LINK(SwNavigationPI, ToolBoxClickHdl, const OString&, rCommand, void)
+{
+    if (!m_xGlobalToolBox->get_menu_item_active(rCommand))
+        return;
+
+    if (rCommand == "update")
+        m_xGlobalTree->TbxMenuHdl(rCommand, *m_xUpdateMenu);
+    else if (rCommand == "insert")
+        m_xGlobalTree->TbxMenuHdl(rCommand, *m_xInsertMenu);
+}
+
+IMPL_LINK(SwNavigationPI, ToolBox3DropdownClickHdl, const OString&, rCommand, void)
+{
+    if (!m_xContent3ToolBox->get_menu_item_active(rCommand))
+        return;
+
+    if (rCommand == "dragmode")
+    {
+        switch (m_nRegionMode)
+        {
+            case RegionMode::NONE:
+                m_xDragModeMenu->set_active("hyperlink", true);
+                break;
+            case RegionMode::LINK:
+                m_xDragModeMenu->set_active("link", true);
+                break;
+            case RegionMode::EMBEDDED:
+                m_xDragModeMenu->set_active("copy", true);
+                break;
+        }
+    }
+}
+
+IMPL_LINK(SwNavigationPI, DropModeMenuSelectHdl, const OString&, rIdent, void)
+{
+    if (rIdent == "hyperlink")
+        SetRegionDropMode(RegionMode::NONE);
+    else if (rIdent == "link")
+        SetRegionDropMode(RegionMode::LINK);
+    else if (rIdent == "copy")
+        SetRegionDropMode(RegionMode::EMBEDDED);
+}
+
+IMPL_LINK(SwNavigationPI, GlobalMenuSelectHdl, const OString&, rIdent, void)
+{
+    m_xGlobalTree->ExecuteContextMenuAction(rIdent);
+}
+
+IMPL_LINK(SwNavigationPI, ToolBox2DropdownClickHdl, const OString&, rCommand, void)
+{
+    if (!m_xContent2ToolBox->get_menu_item_active(rCommand))
+        return;
+
+    if (rCommand == "headings")
+        m_xHeadingsMenu->set_active(OString::number(m_xContentTree->GetOutlineLevel()), true);
+}
+
+FactoryFunction SwNavigationPI::GetUITestFactory() const
+{
+    return SwNavigationPIUIObject::create;
+}
+
+// Action-Handler Edit:
+// Switches to the page if the structure view is not turned on.
+bool SwNavigationPI::EditAction()
+{
+    SwView *pView = GetCreateView();
+    if (!pView)
+        return false;
+
+    if (m_aPageChgIdle.IsActive())
+        m_aPageChgIdle.Stop();
+
+    // if the user has clicked into the document, forget about changing the page
+    if (pView->GetEditWin().HasFocus())
+        return false;
+
+    SwWrtShell &rSh = m_pCreateView->GetWrtShell();
+    sal_uInt16 nNewPage = m_xEdit->get_value();
+
+    rSh.GotoPage(nNewPage, true);
+    m_pCreateView->GetViewFrame()->GetBindings().Invalidate(FN_STAT_PAGE);
+
+    return true;
+}
+
+void SwNavigationPI::ZoomOut()
+{
+    if (!IsZoomedIn())
+        return;
+    SfxNavigator* pNav = dynamic_cast<SfxNavigator*>(GetParent());
+    if (!pNav)
+        return;
+    m_bIsZoomedIn = false;
+    FillBox();
+    if (IsGlobalMode())
+    {
+        m_xGlobalBox->show();
+        m_xGlobalTree->ShowTree();
+    }
+    else
+    {
+        m_xContentBox->show();
+        m_xContentTree->ShowTree();
+        m_xDocListBox->show();
+    }
+
+    Size aOptimalSize(GetOptimalSize());
+    Size aNewSize(pNav->GetOutputSizePixel());
+    aNewSize.setHeight( m_aExpandedSize.Height() );
+    pNav->SetMinOutputSizePixel(aOptimalSize);
+    pNav->SetOutputSizePixel(aNewSize);
+
+    m_xContentTree->Select(); // Enable toolbox
+    m_pConfig->SetSmall(false);
+    m_xContent3ToolBox->set_item_active("listbox", true);
+}
+
+void SwNavigationPI::ZoomIn()
+{
+    if (IsZoomedIn())
+        return;
+    SfxNavigator* pNav = dynamic_cast<SfxNavigator*>(GetParent());
+    if (!pNav)
+        return;
+
+    m_aExpandedSize = GetSizePixel();
+
+    m_xContentBox->hide();
+    m_xContentTree->HideTree();
+    m_xGlobalBox->hide();
+    m_xGlobalTree->HideTree();
+    m_xDocListBox->hide();
+    m_bIsZoomedIn = true;
+
+    Size aOptimalSize(GetOptimalSize());
+    Size aNewSize(pNav->GetOutputSizePixel());
+    aNewSize.setHeight( aOptimalSize.Height() );
+    pNav->SetMinOutputSizePixel(aOptimalSize);
+    pNav->SetOutputSizePixel(aNewSize);
+
+    m_xContentTree->Select(); // Enable toolbox
+
+    m_pConfig->SetSmall(true);
+    m_xContent3ToolBox->set_item_active("listbox", false);
+}
+
+namespace {
+
+enum StatusIndex
+{
+    IDX_STR_HIDDEN = 0,
+    IDX_STR_ACTIVE = 1,
+    IDX_STR_INACTIVE = 2
+};
+
+}
+
+VclPtr<vcl::Window> SwNavigationPI::Create(vcl::Window* pParent,
+    const css::uno::Reference<css::frame::XFrame>& rxFrame,
+    SfxBindings* pBindings)
+{
+    if( pParent == nullptr )
+        throw css::lang::IllegalArgumentException("no parent window given to SwNavigationPI::Create", nullptr, 0);
+    if( !rxFrame.is() )
+        throw css::lang::IllegalArgumentException("no XFrame given to SwNavigationPI::Create", nullptr, 0);
+    if( pBindings == nullptr )
+        throw css::lang::IllegalArgumentException("no SfxBindings given to SwNavigationPI::Create", nullptr, 0);
+    return VclPtr<SwNavigationPI>::Create(pParent, rxFrame, pBindings);
+}
+
+SwNavigationPI::SwNavigationPI(vcl::Window* pParent,
+    const css::uno::Reference<css::frame::XFrame>& rxFrame,
+    SfxBindings* _pBindings)
+    : PanelLayout(pParent, "NavigatorPanel", "modules/swriter/ui/navigatorpanel.ui", rxFrame)
+    , m_aDocFullName(SID_DOCFULLNAME, *_pBindings, *this)
+    , m_aPageStats(FN_STAT_PAGE, *_pBindings, *this)
+    , m_xContent1ToolBox(m_xBuilder->weld_toolbar("content1"))
+    , m_xContent2ToolBox(m_xBuilder->weld_toolbar("content2"))
+    , m_xContent3ToolBox(m_xBuilder->weld_toolbar("content3"))
+    , m_xContent1Dispatch(new ToolbarUnoDispatcher(*m_xContent1ToolBox, *m_xBuilder, rxFrame))
+    , m_xHeadingsMenu(m_xBuilder->weld_menu("headingsmenu"))
+    , m_xDragModeMenu(m_xBuilder->weld_menu("dragmodemenu"))
+    , m_xUpdateMenu(m_xBuilder->weld_menu("updatemenu"))
+    , m_xInsertMenu(m_xBuilder->weld_menu("insertmenu"))
+    , m_xGlobalToolBox(m_xBuilder->weld_toolbar("global"))
+    , m_xEdit(m_xBuilder->weld_spin_button("spinbutton"))
+    , m_xContentBox(m_xBuilder->weld_widget("contentbox"))
+    , m_xContentTree(new SwContentTree(m_xBuilder->weld_tree_view("contenttree"), this))
+    , m_xGlobalBox(m_xBuilder->weld_widget("globalbox"))
+    , m_xGlobalTree(new SwGlobalTree(m_xBuilder->weld_tree_view("globaltree"), this))
+    , m_xDocListBox(m_xBuilder->weld_combo_box("documents"))
+    , m_pContentView(nullptr)
+    , m_pContentWrtShell(nullptr)
+    , m_pActContView(nullptr)
+    , m_pCreateView(nullptr)
+    , m_pConfig(SW_MOD()->GetNavigationConfig())
+    , m_rBindings(*_pBindings)
+    , m_nRegionMode(RegionMode::NONE)
+    , m_bIsZoomedIn(false)
+    , m_bGlobalMode(false)
+{
+    set_id("NavigatorPanelParent"); // for uitest/writer_tests5/tdf114724.py
+
+    GetCreateView();
+
+    m_xContent1ToolBox->set_help_id(HID_NAVIGATOR_TOOLBOX);
+    m_xContent2ToolBox->set_help_id(HID_NAVIGATOR_TOOLBOX);
+    m_xContent3ToolBox->set_help_id(HID_NAVIGATOR_TOOLBOX);
+    m_xGlobalToolBox->set_help_id(HID_NAVIGATOR_GLOBAL_TOOLBOX);
+    m_xDocListBox->set_help_id(HID_NAVIGATOR_LISTBOX);
+    m_xDocListBox->set_size_request(42, -1); // set a nominal width so it takes width of surroundings
+
+    // Insert the numeric field in the toolbox.
+    m_xEdit->set_accessible_name(m_xEdit->get_tooltip_text());
+    m_xEdit->set_width_chars(3);
+    m_xEdit->connect_activate(LINK(this, SwNavigationPI, EditActionHdl));
+    m_xEdit->connect_value_changed(LINK(this, SwNavigationPI, PageEditModifyHdl));
+    m_xEdit->set_help_id("modules/swriter/ui/navigatorpanel/numericfield");
+
+    if (!IsGlobalDoc())
+    {
+        m_xContent1ToolBox->set_item_visible("contenttoggle", false);
+    }
+
+    const char* REGIONNAME_ARY[] =
+    {
+        STR_HYPERLINK,
+        STR_LINK_REGION,
+        STR_COPY_REGION
+    };
+
+    const char* REGIONMODE_ARY[] =
+    {
+        STR_HIDDEN,
+        STR_ACTIVE,
+        STR_INACTIVE
+    };
+
+    static_assert(SAL_N_ELEMENTS(REGIONNAME_ARY) == SAL_N_ELEMENTS(REGIONMODE_ARY), "### unexpected size!");
+    static_assert(SAL_N_ELEMENTS(REGIONNAME_ARY) == static_cast<sal_uInt16>(RegionMode::EMBEDDED) + 1, "### unexpected size!");
+
+    for (sal_uInt16 i = 0; i <= static_cast<sal_uInt16>(RegionMode::EMBEDDED); ++i)
+    {
+        m_aStatusArr[i] = SwResId(REGIONMODE_ARY[i]);
+    }
+
+    m_aStatusArr[3] = SwResId(STR_ACTIVE_VIEW);
+
+    bool bFloatingNavigator = SfxChildWindowContext::GetFloatingWindow(GetParent()) != nullptr;
+
+    m_xContentTree->set_selection_mode(SelectionMode::Single);
+    m_xContentTree->ShowTree();
+    m_xContent3ToolBox->set_item_active("listbox", true);
+    m_xContent3ToolBox->set_item_sensitive("listbox", bFloatingNavigator);
+
+//  TreeListBox for global document
+    m_xGlobalTree->set_selection_mode(SelectionMode::Multiple);
+
+//  Handler
+    Link<const OString&, void> aLk = LINK(this, SwNavigationPI, ToolBoxSelectHdl);
+    m_xContent1ToolBox->connect_clicked(aLk);
+    m_xContent2ToolBox->connect_clicked(aLk);
+    m_xContent3ToolBox->connect_clicked(aLk);
+    m_xGlobalToolBox->connect_clicked(aLk);
+    m_xDocListBox->connect_changed(LINK(this, SwNavigationPI, DocListBoxSelectHdl));
+    m_xContent2ToolBox->set_item_menu("headings", m_xHeadingsMenu.get());
+    m_xHeadingsMenu->connect_activate(LINK(this, SwNavigationPI, HeadingsMenuSelectHdl));
+    m_xContent2ToolBox->connect_menu_toggled(LINK(this, SwNavigationPI, ToolBox2DropdownClickHdl));
+    m_xContent3ToolBox->set_item_menu("dragmode", m_xDragModeMenu.get());
+    m_xDragModeMenu->connect_activate(LINK(this, SwNavigationPI, DropModeMenuSelectHdl));
+    m_xContent3ToolBox->connect_menu_toggled(LINK(this, SwNavigationPI, ToolBox3DropdownClickHdl));
+    m_xGlobalToolBox->set_item_menu("update", m_xUpdateMenu.get());
+    m_xUpdateMenu->connect_activate(LINK(this, SwNavigationPI, GlobalMenuSelectHdl));
+    m_xGlobalToolBox->set_item_menu("insert", m_xInsertMenu.get());
+    m_xInsertMenu->connect_activate(LINK(this, SwNavigationPI, GlobalMenuSelectHdl));
+    m_xGlobalToolBox->connect_menu_toggled(LINK(this, SwNavigationPI, ToolBoxClickHdl));
+    m_xGlobalToolBox->set_item_active("globaltoggle", true);
+
+//  set toolbar of both modes to widest of each
+    m_xGlobalToolBox->set_size_request(m_xContent1ToolBox->get_preferred_size().Width(), -1);
+
+    StartListening(*SfxGetpApp());
+
+    if(IsGlobalDoc())
+    {
+        SwView *pActView = GetCreateView();
+        m_xGlobalToolBox->set_item_active("save",
+                    pActView->GetWrtShellPtr()->IsGlblDocSaveLinks());
+        if (m_pConfig->IsGlobalActive())
+            ToggleTree();
+        if (bFloatingNavigator)
+            m_xGlobalTree->grab_focus();
+    }
+    else if (bFloatingNavigator)
+        m_xContentTree->grab_focus();
+    UsePage();
+    m_aPageChgIdle.SetInvokeHandler(LINK(this, SwNavigationPI, ChangePageHdl));
+    m_aPageChgIdle.SetPriority(TaskPriority::LOWEST);
+
+    m_xContentTree->set_accessible_name(SwResId(STR_ACCESS_TL_CONTENT));
+    m_xGlobalTree->set_accessible_name(SwResId(STR_ACCESS_TL_GLOBAL));
+    m_xDocListBox->set_accessible_name(m_aStatusArr[3]);
+
+    m_aExpandedSize = GetOptimalSize();
+}
+
+SwNavigationPI::~SwNavigationPI()
+{
+    disposeOnce();
+}
+
+void SwNavigationPI::dispose()
+{
+    if (IsGlobalDoc() && !IsGlobalMode())
+    {
+        SwView *pView = GetCreateView();
+        SwWrtShell &rSh = pView->GetWrtShell();
+        if (!rSh.IsAllProtect())
+            pView->GetDocShell()->SetReadOnlyUI(false);
+    }
+
+    EndListening(*SfxGetpApp());
+
+    if (m_pxObjectShell)
+    {
+        if (m_pxObjectShell->Is())
+            (*m_pxObjectShell)->DoClose();
+        m_pxObjectShell.reset();
+    }
+
+    m_xDocListBox.reset();
+    m_xGlobalTree.reset();
+    m_xGlobalBox.reset();
+    m_xContentTree.reset();
+    m_xContentBox.reset();
+    m_xGlobalToolBox.reset();
+    m_xEdit.reset();
+    m_xHeadingsMenu.reset();
+    m_xDragModeMenu.reset();
+    m_xUpdateMenu.reset();
+    m_xInsertMenu.reset();
+    m_xContent1Dispatch.reset();
+    m_xContent1ToolBox.reset();
+    m_xContent2ToolBox.reset();
+    m_xContent3ToolBox.reset();
+
+    m_aPageChgIdle.Stop();
+
+    m_aDocFullName.dispose();
+    m_aPageStats.dispose();
+
+    PanelLayout::dispose();
+}
+
+void SwNavigationPI::NotifyItemUpdate(sal_uInt16 nSID, SfxItemState /*eState*/,
+                                      const SfxPoolItem* /*pState*/)
+{
+    if (nSID == SID_DOCFULLNAME)
+    {
+        SwView *pActView = GetCreateView();
+        if(pActView)
+        {
+            SwWrtShell* pWrtShell = pActView->GetWrtShellPtr();
+            m_xContentTree->SetActiveShell(pWrtShell);
+            bool bGlobal = IsGlobalDoc();
+            m_xContent1ToolBox->set_item_visible("contenttoggle", bGlobal);
+            if ((!bGlobal && IsGlobalMode()) || (!IsGlobalMode() && m_pConfig->IsGlobalActive()))
+            {
+                ToggleTree();
+            }
+            if (bGlobal)
+            {
+                m_xGlobalToolBox->set_item_active("save", pWrtShell->IsGlblDocSaveLinks());
+            }
+        }
+        else
+        {
+            m_xContentTree->SetActiveShell(nullptr);
+        }
+        UpdateListBox();
+    }
+    else if (nSID == FN_STAT_PAGE)
+    {
+        SwView *pActView = GetCreateView();
+        if(pActView)
+        {
+            SwWrtShell &rSh = pActView->GetWrtShell();
+            m_xEdit->set_max(rSh.GetPageCnt());
+            m_xEdit->set_width_chars(3);
+        }
+    }
+}
+
+void SwNavigationPI::StateChanged(StateChangedType nStateChange)
+{
+    PanelLayout::StateChanged(nStateChange);
+    if (nStateChange == StateChangedType::InitShow)
+    {
+        // if the parent isn't a float, then the navigator is displayed in
+        // the sidebar or is otherwise docked. While the navigator could change
+        // its size, the sidebar can not, and the navigator would just waste
+        // space. Therefore disable this button.
+        m_xContent3ToolBox->set_item_sensitive("listbox", SfxChildWindowContext::GetFloatingWindow(GetParent()) != nullptr);
+        // show content if docked
+        if (SfxChildWindowContext::GetFloatingWindow(GetParent()) == nullptr && IsZoomedIn())
+            ZoomOut();
+    }
+    else if (nStateChange == StateChangedType::ControlFocus)
+    {
+        if (m_xContentTree)
+        {
+            // update documents listbox
+            UpdateListBox();
+        }
+    }
+}
+
+// Notification on modified DocInfo
+void SwNavigationPI::Notify( SfxBroadcaster& rBrdc, const SfxHint& rHint )
+{
+    if(&rBrdc == m_pCreateView)
+    {
+        if (rHint.GetId() == SfxHintId::Dying)
+        {
+            EndListening(*m_pCreateView);
+            m_pCreateView = nullptr;
+        }
+    }
+    else
+    {
+        if (const SfxEventHint* pHint = dynamic_cast<const SfxEventHint*>(&rHint))
+        {
+            SfxEventHintId eEventId = pHint->GetEventId();
+            if (eEventId == SfxEventHintId::OpenDoc)
+            {
+                SwView *pActView = GetCreateView();
+                if(pActView)
+                {
+                    SwWrtShell* pWrtShell = pActView->GetWrtShellPtr();
+                    m_xContentTree->SetActiveShell(pWrtShell);
+                    if (m_xGlobalTree->get_visible())
+                    {
+                        bool bUpdateAll = m_xGlobalTree->Update(false);
+                        // If no update is needed, then update the font colors
+                        // at the entries of broken links.
+                        m_xGlobalTree->Display(!bUpdateAll);
+                    }
+                }
+            }
+        }
+    }
+}
+
+IMPL_LINK( SwNavigationPI, HeadingsMenuSelectHdl, const OString&, rMenuId, void )
+{
+    if (!rMenuId.isEmpty())
+        m_xContentTree->SetOutlineLevel(rMenuId.toUInt32());
+}
+
+void SwNavigationPI::UpdateListBox()
+{
+    if (isDisposed())
+        return;
+
+    m_xDocListBox->freeze();
+    m_xDocListBox->clear();
+    SwView *pActView = GetCreateView();
+    bool bDisable = pActView == nullptr;
+    SwView *pView = SwModule::GetFirstView();
+    sal_Int32 nCount = 0;
+    sal_Int32 nAct = 0;
+    sal_Int32 nConstPos = 0;
+    const SwView* pConstView = m_xContentTree->IsConstantView() &&
+                                m_xContentTree->GetActiveWrtShell() ?
+                                    &m_xContentTree->GetActiveWrtShell()->GetView():
+                                        nullptr;
+    while (pView)
+    {
+        SfxObjectShell* pDoc = pView->GetDocShell();
+        // #i53333# don't show help pages here
+        if ( !pDoc->IsHelpDocument() )
+        {
+            OUString sEntry = pDoc->GetTitle() + " (";
+            if (pView == pActView)
+            {
+                nAct = nCount;
+                sEntry += m_aStatusArr[IDX_STR_ACTIVE];
+            }
+            else
+                sEntry += m_aStatusArr[IDX_STR_INACTIVE];
+            sEntry += ")";
+            m_xDocListBox->append_text(sEntry);
+
+            if (pConstView && pView == pConstView)
+                nConstPos = nCount;
+
+            nCount++;
+        }
+        pView = SwModule::GetNextView(pView);
+    }
+    m_xDocListBox->append_text(m_aStatusArr[3]); // "Active Window"
+    nCount++;
+
+    if(m_xContentTree->GetHiddenWrtShell())
+    {
+        OUString sEntry = m_xContentTree->GetHiddenWrtShell()->GetView().
+                                        GetDocShell()->GetTitle() +
+            " (" +
+            m_aStatusArr[IDX_STR_HIDDEN] +
+            ")";
+        m_xDocListBox->append_text(sEntry);
+        bDisable = false;
+    }
+
+    m_xDocListBox->thaw();
+
+    if(m_xContentTree->IsActiveView())
+    {
+        //Either the name of the current Document or "Active Document".
+        m_xDocListBox->set_active(pActView ? nAct : --nCount);
+    }
+    else if(m_xContentTree->IsHiddenView())
+    {
+        m_xDocListBox->set_active(nCount);
+    }
+    else
+        m_xDocListBox->set_active(nConstPos);
+
+    m_xDocListBox->set_sensitive(!bDisable);
+}
+
+IMPL_LINK(SwNavigationPI, DoneLink, SfxPoolItem const *, pItem, void)
+{
+    const SfxViewFrameItem* pFrameItem = dynamic_cast<SfxViewFrameItem const *>( pItem  );
+    if( pFrameItem )
+    {
+        SfxViewFrame* pFrame =  pFrameItem->GetFrame();
+        if(pFrame)
+        {
+            m_xContentTree->clear();
+            m_pContentView = dynamic_cast<SwView*>( pFrame->GetViewShell() );
+            OSL_ENSURE(m_pContentView, "no SwView");
+            if(m_pContentView)
+                m_pContentWrtShell = m_pContentView->GetWrtShellPtr();
+            else
+                m_pContentWrtShell = nullptr;
+            m_pxObjectShell.reset( new SfxObjectShellLock(pFrame->GetObjectShell()) );
+            FillBox();
+        }
+    }
+}
+
+OUString SwNavigationPI::CreateDropFileName( TransferableDataHelper& rData )
+{
+    OUString sFileName;
+    SotClipboardFormatId nFormat;
+    if( rData.HasFormat( nFormat = SotClipboardFormatId::FILE_LIST ))
+    {
+        FileList aFileList;
+        rData.GetFileList( nFormat, aFileList );
+        sFileName = aFileList.GetFile( 0 );
+    }
+    else if( rData.HasFormat( nFormat = SotClipboardFormatId::STRING ) ||
+              rData.HasFormat( nFormat = SotClipboardFormatId::SIMPLE_FILE ) ||
+             rData.HasFormat( nFormat = SotClipboardFormatId::FILENAME ))
+    {
+        (void)rData.GetString(nFormat, sFileName);
+    }
+    else if( rData.HasFormat( nFormat = SotClipboardFormatId::SOLK ) ||
+                rData.HasFormat( nFormat = SotClipboardFormatId::NETSCAPE_BOOKMARK )||
+                rData.HasFormat( nFormat = SotClipboardFormatId::FILECONTENT ) ||
+                rData.HasFormat( nFormat = SotClipboardFormatId::FILEGRPDESCRIPTOR ) ||
+                rData.HasFormat( nFormat = SotClipboardFormatId::UNIFORMRESOURCELOCATOR ))
+    {
+        INetBookmark aBkmk { OUString(), OUString() };
+        if (rData.GetINetBookmark(nFormat, aBkmk))
+            sFileName = aBkmk.GetURL();
+    }
+    if( !sFileName.isEmpty() )
+    {
+        sFileName = INetURLObject( sFileName ).GetMainURL( INetURLObject::DecodeMechanism::NONE );
+    }
+    return sFileName;
+}
+
+sal_Int8 SwNavigationPI::AcceptDrop()
+{
+    return ( !m_xContentTree->IsInDrag() &&
+        ( m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::SIMPLE_FILE ) ||
+          m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::STRING ) ||
+          m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::SOLK ) ||
+           m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::NETSCAPE_BOOKMARK )||
+           m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::FILECONTENT ) ||
+           m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::FILEGRPDESCRIPTOR ) ||
+           m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::UNIFORMRESOURCELOCATOR ) ||
+           m_xContentTree->IsDropFormatSupported( SotClipboardFormatId::FILENAME )))
+        ? DND_ACTION_COPY
+        : DND_ACTION_NONE;
+}
+
+sal_Int8 SwNavigationPI::ExecuteDrop( const ExecuteDropEvent& rEvt )
+{
+    TransferableDataHelper aData( rEvt.maDropEvent.Transferable );
+    sal_Int8 nRet = DND_ACTION_NONE;
+    if (m_xContentTree->IsInDrag())
+        return nRet;
+
+    OUString sFileName = SwNavigationPI::CreateDropFileName(aData);
+    if (sFileName.isEmpty())
+        return nRet;
+
+    INetURLObject aTemp(sFileName);
+    GraphicDescriptor aDesc(aTemp);
+    if (aDesc.Detect())   // accept no graphics
+        return nRet;
+
+    if (-1 != sFileName.indexOf('#'))
+        return nRet;
+
+    if (m_sContentFileName.isEmpty() || m_sContentFileName != sFileName)
+    {
+        nRet = rEvt.mnAction;
+        sFileName = comphelper::string::stripEnd(sFileName, 0);
+        m_sContentFileName = sFileName;
+        if(m_pxObjectShell)
+        {
+            m_xContentTree->SetHiddenShell( nullptr );
+            (*m_pxObjectShell)->DoClose();
+            m_pxObjectShell.reset();
+        }
+        SfxStringItem aFileItem(SID_FILE_NAME, sFileName );
+        SfxStringItem aOptionsItem( SID_OPTIONS, "HRC" );
+        SfxLinkItem aLink( SID_DONELINK,
+                            LINK( this, SwNavigationPI, DoneLink ) );
+        GetActiveView()->GetViewFrame()->GetDispatcher()->ExecuteList(
+                    SID_OPENDOC, SfxCallMode::ASYNCHRON,
+                    { &aFileItem, &aOptionsItem, &aLink });
+    }
+    return nRet;
+}
+
+void SwNavigationPI::SetRegionDropMode(RegionMode nNewMode)
+{
+    m_nRegionMode = nNewMode;
+    m_pConfig->SetRegionMode( m_nRegionMode );
+
+    OUString sImageId;
+    switch (nNewMode)
+    {
+        case RegionMode::NONE:
+            sImageId = RID_BMP_DROP_REGION;
+            break;
+        case RegionMode::LINK:
+            sImageId = RID_BMP_DROP_LINK;
+            break;
+        case RegionMode::EMBEDDED:
+            sImageId = RID_BMP_DROP_COPY;
+            break;
+    }
+    m_xContent3ToolBox->set_item_icon_name("dragmode", sImageId);
+}
+
+void SwNavigationPI::ToggleTree()
+{
+    bool bGlobalDoc = IsGlobalDoc();
+    if (!IsGlobalMode() && bGlobalDoc)
+    {
+        SetUpdateMode(false);
+        if (IsZoomedIn())
+            ZoomOut();
+        m_xGlobalBox->show();
+        m_xGlobalTree->ShowTree();
+        m_xGlobalToolBox->show();
+        m_xContentBox->hide();
+        m_xContentTree->HideTree();
+        m_xContent1ToolBox->hide();
+        m_xContent2ToolBox->hide();
+        m_xContent3ToolBox->hide();
+        m_xDocListBox->hide();
+        SetGlobalMode(true);
+        SetUpdateMode(true);
+    }
+    else
+    {
+        m_xGlobalBox->hide();
+        m_xGlobalTree->HideTree();
+        m_xGlobalToolBox->hide();
+        if (!IsZoomedIn())
+        {
+            m_xContentBox->show();
+            m_xContentTree->ShowTree();
+            m_xContent1ToolBox->show();
+            m_xContent2ToolBox->show();
+            m_xContent3ToolBox->show();
+            m_xDocListBox->show();
+        }
+        SetGlobalMode(false);
+    }
+}
+
+bool SwNavigationPI::IsGlobalDoc() const
+{
+    bool bRet = false;
+    SwView *pView = GetCreateView();
+    if (pView)
+    {
+        SwWrtShell &rSh = pView->GetWrtShell();
+        bRet = rSh.IsGlobalDoc();
+    }
+    return bRet;
+}
+
+IMPL_LINK_NOARG(SwNavigationPI, ChangePageHdl, Timer *, void)
+{
+    if (IsDisposed())
+        return;
+    // tdf#134959 if the SpinButton changed value this Timer was launched, now
+    // change to the desired page, but we leave focus where it currently is,
+    // i.e. typically remaining in the spinbutton, or whatever other widget the
+    // user moved to in the meantime
+    EditAction();
+}
+
+IMPL_LINK_NOARG(SwNavigationPI, EditActionHdl, weld::Entry&, bool)
+{
+    // tdf#134959 if the user presses enter to activate the Entry
+    // go to the page, and on success we move focus to the document
+    if (EditAction())
+        m_pCreateView->GetEditWin().GrabFocus();
+    return true;
+}
+
+IMPL_LINK_NOARG(SwNavigationPI, PageEditModifyHdl, weld::SpinButton&, void)
+{
+    if (m_aPageChgIdle.IsActive())
+        m_aPageChgIdle.Stop();
+    m_aPageChgIdle.Start();
+}
+
+SwView*  SwNavigationPI::GetCreateView() const
+{
+    if (!m_pCreateView)
+    {
+        SwView* pView = SwModule::GetFirstView();
+        while (pView)
+        {
+            if(&pView->GetViewFrame()->GetBindings() == &m_rBindings)
+            {
+                const_cast<SwNavigationPI*>(this)->m_pCreateView = pView;
+                const_cast<SwNavigationPI*>(this)->StartListening(*m_pCreateView);
+                break;
+            }
+            pView = SwModule::GetNextView(pView);
+        }
+    }
+    return m_pCreateView;
+}
+
+SwNavigationChild::SwNavigationChild( vcl::Window* pParent,
+                        sal_uInt16 nId,
+                        SfxBindings* _pBindings )
+    : SfxChildWindowContext( nId )
+{
+    Reference< XFrame > xFrame = _pBindings->GetActiveFrame();
+    VclPtr< SwNavigationPI > pNavi = VclPtr< SwNavigationPI >::Create( pParent, xFrame, _pBindings );
+    _pBindings->Invalidate(SID_NAVIGATOR);
+
+    SwNavigationConfig* pNaviConfig = SW_MOD()->GetNavigationConfig();
+
+    const ContentTypeId nRootType = pNaviConfig->GetRootType();
+    if( nRootType != ContentTypeId::UNKNOWN )
+    {
+        pNavi->m_xContentTree->SetRootType(nRootType);
+        pNavi->m_xContent2ToolBox->set_item_active("root", true);
+        if (nRootType == ContentTypeId::OUTLINE)
+        {
+            pNavi->m_xContentTree->set_selection_mode(SelectionMode::Multiple);
+        }
+    }
+    pNavi->m_xContentTree->SetOutlineLevel( static_cast< sal_uInt8 >( pNaviConfig->GetOutlineLevel() ) );
+    pNavi->SetRegionDropMode( pNaviConfig->GetRegionMode() );
+
+    if (SfxNavigator* pNav = dynamic_cast<SfxNavigator*>(pParent))
+    {
+        pNav->SetMinOutputSizePixel(pNavi->GetOptimalSize());
+        if (pNaviConfig->IsSmall())
+            pNavi->ZoomIn();
+    }
+
+    SetWindow(pNavi);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/numfmtlb.cxx b/sw/source/uibase/utlui/numfmtlb.cxx
new file mode 100644
index 000000000..4b4b6acb7
--- /dev/null
+++ b/sw/source/uibase/utlui/numfmtlb.cxx
@@ -0,0 +1,473 @@
+/* -*- 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 <i18nlangtag/lang.h>
+#include <svl/zformat.hxx>
+#include <svl/eitem.hxx>
+#include <svx/svxids.hrc>
+#include <svx/numinf.hxx>
+#include <svx/flagsdef.hxx>
+#include <svl/itemset.hxx>
+#include <docsh.hxx>
+#include <swtypes.hxx>
+#include <swmodule.hxx>
+#include <view.hxx>
+#include <wrtsh.hxx>
+#include <numfmtlb.hxx>
+#include <strings.hrc>
+#include <swabstdlg.hxx>
+#include <memory>
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+
+/**
+ *  Description:
+ *     nFormatType: Display the formats of this Type
+ *     nDefaultFormat: Select this format and possibly insert it
+ */
+
+namespace
+{
+
+bool lcl_isSystemFormat(sal_uInt32 nDefaultFormat, SvNumberFormatter* pFormatter, LanguageType eCurLanguage)
+{
+    const sal_uInt32 nSysNumFormat = pFormatter->GetFormatIndex(NF_NUMBER_SYSTEM, eCurLanguage);
+    if (nDefaultFormat == nSysNumFormat)
+        return true;
+    const sal_uInt32 nSysShortDateFormat = pFormatter->GetFormatIndex(NF_DATE_SYSTEM_SHORT, eCurLanguage);
+    if (nDefaultFormat == nSysShortDateFormat)
+        return true;
+    const sal_uInt32 nSysLongDateFormat = pFormatter->GetFormatIndex(NF_DATE_SYSTEM_LONG, eCurLanguage);
+    if (nDefaultFormat == nSysLongDateFormat)
+        return true;
+
+    if ( eCurLanguage != GetAppLanguage() )
+        return false;
+
+    if (nDefaultFormat == pFormatter->GetFormatForLanguageIfBuiltIn(nSysNumFormat, LANGUAGE_SYSTEM))
+        return true;
+    if (nDefaultFormat == pFormatter->GetFormatForLanguageIfBuiltIn(nSysShortDateFormat, LANGUAGE_SYSTEM))
+        return true;
+    if (nDefaultFormat == pFormatter->GetFormatForLanguageIfBuiltIn(nSysLongDateFormat, LANGUAGE_SYSTEM))
+        return true;
+
+    return false;
+}
+
+}
+
+double SwNumFormatBase::GetDefValue(const SvNumFormatType nFormatType)
+{
+    SvxNumValCategory nDefValue = SvxNumValCategory::Standard;
+
+    switch (nFormatType)
+    {
+        case SvNumFormatType::DATE:
+        case SvNumFormatType::DATE|SvNumFormatType::TIME:
+            nDefValue = SvxNumValCategory::Date;
+            break;
+
+        case SvNumFormatType::TIME:
+            nDefValue = SvxNumValCategory::Time;
+            break;
+
+        case SvNumFormatType::TEXT:
+        case SvNumFormatType::UNDEFINED:
+            nDefValue = SvxNumValCategory::Standard;
+            break;
+
+        case SvNumFormatType::CURRENCY:
+            nDefValue = SvxNumValCategory::Currency;
+            break;
+
+        case SvNumFormatType::PERCENT:
+            nDefValue = SvxNumValCategory::Percent;
+            break;
+
+        case SvNumFormatType::LOGICAL:
+            nDefValue = SvxNumValCategory::Boolean;
+            break;
+
+        default:
+            nDefValue = SvxNumValCategory::Standard;
+            break;
+    }
+
+    return fSvxNumValConst[nDefValue];
+}
+
+SwNumFormatBase::SwNumFormatBase()
+    : nCurrFormatType(SvNumFormatType::ALL)
+    , mbCurrFormatTypeNeedsInit(true)
+    , nStdEntry(0)
+    , bOneArea(false)
+    , nDefFormat(0)
+    , bShowLanguageControl(false)
+    , bUseAutomaticLanguage(true)
+{
+}
+
+NumFormatListBox::NumFormatListBox(std::unique_ptr<weld::ComboBox> xControl)
+    : mxControl(std::move(xControl))
+{
+    Init();
+}
+
+SwNumFormatTreeView::SwNumFormatTreeView(std::unique_ptr<weld::TreeView> xControl)
+    : mxControl(std::move(xControl))
+{
+    Init();
+}
+
+void SwNumFormatBase::Init()
+{
+    SwView *pView = GetActiveView();
+
+    if (pView)
+        eCurLanguage = pView->GetWrtShell().GetCurLang();
+    else
+        eCurLanguage = SvtSysLocale().GetLanguageTag().getLanguageType();
+
+    SetFormatType(SvNumFormatType::NUMBER);
+    SetDefFormat(nDefFormat);
+}
+
+void NumFormatListBox::Init()
+{
+    SwNumFormatBase::Init();
+
+    mxControl->connect_changed(LINK(this, NumFormatListBox, SelectHdl));
+}
+
+void SwNumFormatTreeView::Init()
+{
+    SwNumFormatBase::Init();
+
+    mxControl->connect_changed(LINK(this, SwNumFormatTreeView, SelectHdl));
+}
+
+void SwNumFormatBase::SetFormatType(const SvNumFormatType nFormatType)
+{
+    if (!mbCurrFormatTypeNeedsInit &&
+        (nCurrFormatType & nFormatType))   // there are mixed formats, like for example DateTime
+        return;
+
+    SwView *pView = GetActiveView();
+    OSL_ENSURE(pView, "no view found");
+    if(!pView)
+        return;
+    SwWrtShell &rSh = pView->GetWrtShell();
+    SvNumberFormatter* pFormatter = rSh.GetNumberFormatter();
+
+    clear();    // Remove all entries from the Listbox
+
+    NfIndexTableOffset eOffsetStart = NF_NUMBER_START;
+    NfIndexTableOffset eOffsetEnd = NF_NUMBER_START;
+
+    switch( nFormatType )
+    {
+    case SvNumFormatType::NUMBER:
+        eOffsetStart=NF_NUMBER_START;
+        eOffsetEnd=NF_NUMBER_END;
+        break;
+
+    case SvNumFormatType::PERCENT:
+        eOffsetStart=NF_PERCENT_START;
+        eOffsetEnd=NF_PERCENT_END;
+        break;
+
+    case SvNumFormatType::CURRENCY:
+        eOffsetStart=NF_CURRENCY_START;
+        eOffsetEnd=NF_CURRENCY_END;
+        break;
+
+    case SvNumFormatType::DATETIME:
+        eOffsetStart=NF_DATE_START;
+        eOffsetEnd=NF_TIME_END;
+        break;
+
+    case SvNumFormatType::DATE:
+        eOffsetStart=NF_DATE_START;
+        eOffsetEnd=NF_DATE_END;
+        break;
+
+    case SvNumFormatType::TIME:
+        eOffsetStart=NF_TIME_START;
+        eOffsetEnd=NF_TIME_END;
+        break;
+
+    case SvNumFormatType::SCIENTIFIC:
+        eOffsetStart=NF_SCIENTIFIC_START;
+        eOffsetEnd=NF_SCIENTIFIC_END;
+        break;
+
+    case SvNumFormatType::FRACTION:
+        eOffsetStart=NF_FRACTION_START;
+        eOffsetEnd=NF_FRACTION_END;
+        break;
+
+    case SvNumFormatType::LOGICAL:
+        eOffsetStart=NF_BOOLEAN;
+        eOffsetEnd=NF_BOOLEAN;
+        break;
+
+    case SvNumFormatType::TEXT:
+        eOffsetStart=NF_TEXT;
+        eOffsetEnd=NF_TEXT;
+        break;
+
+    case SvNumFormatType::ALL:
+        eOffsetStart=NF_NUMERIC_START;
+        eOffsetEnd = NfIndexTableOffset( NF_INDEX_TABLE_ENTRIES - 1 );
+        break;
+
+    default:
+        OSL_FAIL("what a format?");
+        break;
+    }
+
+    const SvNumberformat* pFormat;
+    sal_Int32 i = 0;
+    Color* pCol;
+    double fVal = SwNumFormatBase::GetDefValue(nFormatType);
+    OUString sValue;
+
+    const sal_uInt32 nSysNumFormat = pFormatter->GetFormatIndex(
+                                    NF_NUMBER_SYSTEM, eCurLanguage );
+    const sal_uInt32 nSysShortDateFormat = pFormatter->GetFormatIndex(
+                                    NF_DATE_SYSTEM_SHORT, eCurLanguage );
+    const sal_uInt32 nSysLongDateFormat = pFormatter->GetFormatIndex(
+                                    NF_DATE_SYSTEM_LONG, eCurLanguage );
+
+    for( long nIndex = eOffsetStart; nIndex <= eOffsetEnd; ++nIndex )
+    {
+        const sal_uInt32 nFormat = pFormatter->GetFormatIndex(
+                        static_cast<NfIndexTableOffset>(nIndex), eCurLanguage );
+        pFormat = pFormatter->GetEntry( nFormat );
+
+        if( nFormat == pFormatter->GetFormatIndex( NF_NUMBER_STANDARD,
+                                                    eCurLanguage )
+            || const_cast<SvNumberformat*>(pFormat)->GetOutputString( fVal, sValue, &pCol )
+            || nFormatType == SvNumFormatType::UNDEFINED )
+        {
+            sValue = pFormat->GetFormatstring();
+        }
+        else if( nFormatType == SvNumFormatType::TEXT )
+        {
+            pFormatter->GetOutputString( "\"ABC\"", nFormat, sValue, &pCol);
+        }
+
+        if (nFormat != nSysNumFormat       &&
+            nFormat != nSysShortDateFormat &&
+            nFormat != nSysLongDateFormat)
+        {
+            append(OUString::number(nFormat), sValue);
+
+            if( nFormat == pFormatter->GetStandardFormat(
+                                    nFormatType, eCurLanguage ) )
+                nStdEntry = i;
+            ++i;
+        }
+    }
+
+    append_text(SwResId(STR_DEFINE_NUMBERFORMAT));
+
+    set_active(nStdEntry);
+
+    nCurrFormatType = nFormatType;
+    mbCurrFormatTypeNeedsInit = false;
+
+}
+
+void SwNumFormatBase::SetDefFormat(const sal_uInt32 nDefaultFormat)
+{
+    if (nDefaultFormat == NUMBERFORMAT_ENTRY_NOT_FOUND)
+    {
+        nDefFormat = nDefaultFormat;
+        return;
+    }
+
+    SwView *pView = GetActiveView();
+    OSL_ENSURE(pView, "no view found");
+    if(!pView)
+        return;
+    SwWrtShell &rSh = pView->GetWrtShell();
+    SvNumberFormatter* pFormatter = rSh.GetNumberFormatter();
+
+    SvNumFormatType nType = pFormatter->GetType(nDefaultFormat);
+
+    SetFormatType(nType);
+
+    sal_uInt32 nFormat = pFormatter->GetFormatForLanguageIfBuiltIn(nDefaultFormat, eCurLanguage);
+
+    for (sal_Int32 i = 0, nCount = get_count(); i < nCount; ++i)
+    {
+        if (nFormat == get_id(i).toUInt32())
+        {
+            set_active(i);
+            nStdEntry = i;
+            nDefFormat = GetFormat();
+            return;
+        }
+    }
+
+    // No entry found:
+    OUString sValue;
+    Color* pCol = nullptr;
+
+    if (nType == SvNumFormatType::TEXT)
+    {
+        pFormatter->GetOutputString("\"ABC\"", nDefaultFormat, sValue, &pCol);
+    }
+    else
+    {
+        pFormatter->GetOutputString(SwNumFormatBase::GetDefValue(nType), nDefaultFormat, sValue, &pCol);
+    }
+
+    sal_Int32 nPos = 0;
+    while (get_id(nPos).toUInt32() == NUMBERFORMAT_ENTRY_NOT_FOUND)
+        nPos++;
+
+    if ( lcl_isSystemFormat(nDefaultFormat, pFormatter, eCurLanguage) )
+    {
+        sValue += SwResId(RID_STR_SYSTEM);
+    }
+
+    insert_text(nPos, sValue);   // Insert as first numeric entry
+    set_id(nPos, OUString::number(nDefaultFormat));
+    set_active(nPos);
+    nDefFormat = GetFormat();
+}
+
+sal_uInt32 NumFormatListBox::GetFormat() const
+{
+    return mxControl->get_active_id().toUInt32();
+}
+
+sal_uInt32 SwNumFormatTreeView::GetFormat() const
+{
+    return mxControl->get_selected_id().toUInt32();
+}
+
+void SwNumFormatBase::CallSelectHdl()
+{
+    const sal_Int32 nPos = get_active();
+    OUString sDefine(SwResId( STR_DEFINE_NUMBERFORMAT ));
+    SwView *pView = GetActiveView();
+
+    if (!pView || nPos != get_count() - 1 || get_text(nPos) != sDefine)
+        return;
+
+    SwWrtShell &rSh = pView->GetWrtShell();
+    SvNumberFormatter* pFormatter = rSh.GetNumberFormatter();
+
+    SfxItemSet aCoreSet(
+        rSh.GetAttrPool(),
+        svl::Items<
+            SID_ATTR_NUMBERFORMAT_VALUE, SID_ATTR_NUMBERFORMAT_INFO,
+            SID_ATTR_NUMBERFORMAT_ONE_AREA, SID_ATTR_NUMBERFORMAT_ONE_AREA,
+            SID_ATTR_NUMBERFORMAT_NOLANGUAGE,
+                SID_ATTR_NUMBERFORMAT_NOLANGUAGE,
+            SID_ATTR_NUMBERFORMAT_ADD_AUTO,
+                SID_ATTR_NUMBERFORMAT_ADD_AUTO>{});
+
+    double fValue = SwNumFormatBase::GetDefValue(nCurrFormatType);
+
+    sal_uInt32 nFormat = pFormatter->GetStandardFormat( nCurrFormatType, eCurLanguage);
+    aCoreSet.Put( SfxUInt32Item( SID_ATTR_NUMBERFORMAT_VALUE, nFormat ));
+
+    aCoreSet.Put( SvxNumberInfoItem( pFormatter, fValue,
+                                        SID_ATTR_NUMBERFORMAT_INFO ) );
+
+    if( (SvNumFormatType::DATE | SvNumFormatType::TIME) & nCurrFormatType )
+        aCoreSet.Put(SfxBoolItem(SID_ATTR_NUMBERFORMAT_ONE_AREA, bOneArea));
+
+    aCoreSet.Put(SfxBoolItem(SID_ATTR_NUMBERFORMAT_NOLANGUAGE, !bShowLanguageControl));
+    aCoreSet.Put(SfxBoolItem(SID_ATTR_NUMBERFORMAT_ADD_AUTO, bUseAutomaticLanguage));
+
+    // force deselect to break mouse lock on selected entry
+    set_active(-1);
+
+    SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
+    ScopedVclPtr<SfxAbstractDialog> pDlg(pFact->CreateNumFormatDialog(&get_widget(), aCoreSet));
+
+    if (RET_OK == pDlg->Execute())
+    {
+        const SfxPoolItem* pItem = pView->GetDocShell()->
+                        GetItem( SID_ATTR_NUMBERFORMAT_INFO );
+
+        if( pItem )
+        {
+            for ( sal_uInt32 key : static_cast<const SvxNumberInfoItem*>(pItem)->GetDelFormats() )
+                pFormatter->DeleteEntry( key );
+        }
+
+        const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
+        if( SfxItemState::SET == pOutSet->GetItemState(
+            SID_ATTR_NUMBERFORMAT_VALUE, false, &pItem ))
+        {
+            sal_uInt32 nNumberFormat = static_cast<const SfxUInt32Item*>(pItem)->GetValue();
+            // oj #105473# change order of calls
+            const SvNumberformat* pFormat = pFormatter->GetEntry(nNumberFormat);
+            if( pFormat )
+                eCurLanguage = pFormat->GetLanguage();
+            // SetDefFormat uses eCurLanguage to look for if this format already in the list
+            SetDefFormat(nNumberFormat);
+        }
+        if( bShowLanguageControl && SfxItemState::SET == pOutSet->GetItemState(
+            SID_ATTR_NUMBERFORMAT_ADD_AUTO, false, &pItem ))
+        {
+            bUseAutomaticLanguage = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        }
+    }
+    else
+        SetDefFormat(nFormat);
+
+}
+
+IMPL_LINK_NOARG(NumFormatListBox, SelectHdl, weld::ComboBox&, void)
+{
+    CallSelectHdl();
+}
+
+IMPL_LINK_NOARG(SwNumFormatTreeView, SelectHdl, weld::TreeView&, void)
+{
+    CallSelectHdl();
+}
+
+void SwNumFormatBase::clear()
+{
+    mbCurrFormatTypeNeedsInit = true;
+    nCurrFormatType = SvNumFormatType::ALL;
+}
+
+void NumFormatListBox::clear()
+{
+    mxControl->clear();
+    SwNumFormatBase::clear();
+}
+
+void SwNumFormatTreeView::clear()
+{
+    mxControl->clear();
+    SwNumFormatBase::clear();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/prcntfld.cxx b/sw/source/uibase/utlui/prcntfld.cxx
new file mode 100644
index 000000000..2cefdc4ff
--- /dev/null
+++ b/sw/source/uibase/utlui/prcntfld.cxx
@@ -0,0 +1,228 @@
+/* -*- 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 <prcntfld.hxx>
+#include <vcl/fieldvalues.hxx>
+
+SwPercentField::SwPercentField(std::unique_ptr<weld::MetricSpinButton> pControl)
+    : m_pField(std::move(pControl))
+    , nOldMax(0)
+    , nOldMin(0)
+    , nLastPercent(-1)
+    , nLastValue(-1)
+    , nOldDigits(m_pField->get_digits())
+    , eOldUnit(FieldUnit::NONE)
+    , bLockAutoCalculation(false)
+{
+    int nMin, nMax;
+    m_pField->get_range(nMin, nMax, FieldUnit::TWIP);
+    nRefValue = DenormalizePercent(nMax);
+    m_pField->get_increments(nOldSpinSize, nOldPageSize, FieldUnit::NONE);
+}
+
+void SwPercentField::SetRefValue(int nValue)
+{
+    int nRealValue = GetRealValue(eOldUnit);
+
+    nRefValue = nValue;
+
+    if (!bLockAutoCalculation && (m_pField->get_unit() == FieldUnit::PERCENT))
+        set_value(nRealValue, eOldUnit);
+}
+
+void SwPercentField::ShowPercent(bool bPercent)
+{
+    if ((bPercent && m_pField->get_unit() == FieldUnit::PERCENT) ||
+        (!bPercent && m_pField->get_unit() != FieldUnit::PERCENT))
+        return;
+
+    int nOldValue;
+
+    if (bPercent)
+    {
+        nOldValue = get_value();
+
+        eOldUnit = m_pField->get_unit();
+        nOldDigits = m_pField->get_digits();
+        m_pField->get_range(nOldMin, nOldMax, FieldUnit::NONE);
+        m_pField->get_increments(nOldSpinSize, nOldPageSize, FieldUnit::NONE);
+        m_pField->set_unit(FieldUnit::PERCENT);
+        m_pField->set_digits(0);
+
+        int nCurrentWidth = vcl::ConvertValue(nOldMin, 0, nOldDigits, eOldUnit, FieldUnit::TWIP);
+        // round to 0.5 percent
+        int nPercent = nRefValue ? (((nCurrentWidth * 10) / nRefValue + 5) / 10) : 0;
+
+        m_pField->set_range(std::max(1, nPercent), 100, FieldUnit::NONE);
+        m_pField->set_increments(5, 10, FieldUnit::NONE);
+        if (nOldValue != nLastValue)
+        {
+            nCurrentWidth = vcl::ConvertValue(nOldValue, 0, nOldDigits, eOldUnit, FieldUnit::TWIP);
+            nPercent = nRefValue ? (((nCurrentWidth * 10) / nRefValue + 5) / 10) : 0;
+            m_pField->set_value(nPercent, FieldUnit::NONE);
+            nLastPercent = nPercent;
+            nLastValue = nOldValue;
+        }
+        else
+            m_pField->set_value(nLastPercent, FieldUnit::NONE);
+    }
+    else
+    {
+        int nOldPercent = get_value(FieldUnit::PERCENT);
+
+        nOldValue = Convert(get_value(), m_pField->get_unit(), eOldUnit);
+
+        m_pField->set_unit(eOldUnit);
+        m_pField->set_digits(nOldDigits);
+        m_pField->set_range(nOldMin, nOldMax, FieldUnit::NONE);
+        m_pField->set_increments(nOldSpinSize, nOldPageSize, FieldUnit::NONE);
+
+        if (nOldPercent != nLastPercent)
+        {
+            set_value(nOldValue, eOldUnit);
+            nLastPercent = nOldPercent;
+            nLastValue = nOldValue;
+        }
+        else
+            set_value(nLastValue, eOldUnit);
+    }
+}
+
+void SwPercentField::set_value(int nNewValue, FieldUnit eInUnit)
+{
+    if (m_pField->get_unit() != FieldUnit::PERCENT || eInUnit == FieldUnit::PERCENT)
+        m_pField->set_value(Convert(nNewValue, eInUnit, m_pField->get_unit()), FieldUnit::NONE);
+    else
+    {
+        // Overwrite output value, do not restore later
+        int nPercent, nCurrentWidth;
+        if(eInUnit == FieldUnit::TWIP)
+        {
+            nCurrentWidth = vcl::ConvertValue(nNewValue, 0, nOldDigits, FieldUnit::TWIP, FieldUnit::TWIP);
+        }
+        else
+        {
+            int nValue = Convert(nNewValue, eInUnit, eOldUnit);
+            nCurrentWidth = vcl::ConvertValue(nValue, 0, nOldDigits, eOldUnit, FieldUnit::TWIP);
+        }
+        nPercent = nRefValue ? (((nCurrentWidth * 10) / nRefValue + 5) / 10) : 0;
+        m_pField->set_value(nPercent, FieldUnit::NONE);
+    }
+}
+
+int SwPercentField::get_value(FieldUnit eOutUnit)
+{
+    return Convert(m_pField->get_value(FieldUnit::NONE), m_pField->get_unit(), eOutUnit);
+}
+
+void SwPercentField::set_min(int nNewMin, FieldUnit eInUnit)
+{
+    if (m_pField->get_unit() != FieldUnit::PERCENT)
+        m_pField->set_min(nNewMin, eInUnit);
+    else
+    {
+        if (eInUnit == FieldUnit::NONE)
+            eInUnit = eOldUnit;
+        nOldMin = Convert(nNewMin, eInUnit, eOldUnit);
+
+        int nPercent = Convert(nNewMin, eInUnit, FieldUnit::PERCENT);
+        m_pField->set_min(std::max(1, nPercent), FieldUnit::NONE);
+    }
+}
+
+void SwPercentField::set_max(int nNewMax, FieldUnit eInUnit)
+{
+    if (m_pField->get_unit() != FieldUnit::PERCENT)
+        m_pField->set_max(nNewMax, eInUnit);
+}
+
+int SwPercentField::NormalizePercent(int nValue)
+{
+    if (m_pField->get_unit() != FieldUnit::PERCENT)
+        nValue = m_pField->normalize(nValue);
+    else
+        nValue = nValue * ImpPower10(nOldDigits);
+    return nValue;
+}
+
+int SwPercentField::DenormalizePercent(int nValue)
+{
+    if (m_pField->get_unit() != FieldUnit::PERCENT)
+        nValue = m_pField->denormalize(nValue);
+    else
+    {
+        int nFactor = ImpPower10(nOldDigits);
+        nValue = ((nValue+(nFactor/2)) / nFactor);
+    }
+    return nValue;
+}
+
+int SwPercentField::ImpPower10(sal_uInt16 n)
+{
+    int nValue = 1;
+
+    for (sal_uInt16 i=0; i < n; ++i)
+        nValue *= 10;
+
+    return nValue;
+}
+
+int SwPercentField::GetRealValue(FieldUnit eOutUnit)
+{
+    if (m_pField->get_unit() != FieldUnit::PERCENT)
+        return get_value(eOutUnit);
+    else
+        return Convert(get_value(), m_pField->get_unit(), eOutUnit);
+}
+
+int SwPercentField::Convert(int nValue, FieldUnit eInUnit, FieldUnit eOutUnit)
+{
+    if (eInUnit == eOutUnit ||
+        (eInUnit == FieldUnit::NONE && eOutUnit == m_pField->get_unit()) ||
+        (eOutUnit == FieldUnit::NONE && eInUnit == m_pField->get_unit()))
+        return nValue;
+
+    if (eInUnit == FieldUnit::PERCENT)
+    {
+        // Convert to metric
+        int nTwipValue = (nRefValue * nValue + 50) / 100;
+
+        if (eOutUnit == FieldUnit::TWIP) // Only convert if necessary
+            return NormalizePercent(nTwipValue);
+        else
+            return vcl::ConvertValue(NormalizePercent(nTwipValue), 0, nOldDigits, FieldUnit::TWIP, eOutUnit);
+    }
+
+    if (eOutUnit == FieldUnit::PERCENT)
+    {
+        // Convert to percent
+        int nCurrentWidth;
+        nValue = DenormalizePercent(nValue);
+
+        if (eInUnit == FieldUnit::TWIP)  // Only convert if necessary
+            nCurrentWidth = nValue;
+        else
+            nCurrentWidth = vcl::ConvertValue(nValue, 0, nOldDigits, eInUnit, FieldUnit::TWIP);
+        // Round to 0.5 percent
+        return nRefValue ? (((nCurrentWidth * 1000) / nRefValue + 5) / 10) : 0;
+    }
+
+    return vcl::ConvertValue(nValue, 0, nOldDigits, eInUnit, eOutUnit);
+}
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/shdwcrsr.cxx b/sw/source/uibase/utlui/shdwcrsr.cxx
new file mode 100644
index 000000000..dbdf78b49
--- /dev/null
+++ b/sw/source/uibase/utlui/shdwcrsr.cxx
@@ -0,0 +1,119 @@
+/* -*- 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/text/HoriOrientation.hpp>
+#include <vcl/window.hxx>
+#include <shdwcrsr.hxx>
+
+using namespace ::com::sun::star;
+
+SwShadowCursor::~SwShadowCursor()
+{
+    if( USHRT_MAX != nOldMode )
+        DrawCursor( aOldPt, nOldHeight, nOldMode );
+}
+
+void SwShadowCursor::SetPos( const Point& rPt, long nHeight, sal_uInt16 nMode )
+{
+    Point aPt( pWin->LogicToPixel( rPt ));
+    nHeight = pWin->LogicToPixel( Size( 0, nHeight )).Height();
+    if( aOldPt != aPt || nOldHeight != nHeight || nOldMode != nMode )
+    {
+        if( USHRT_MAX != nOldMode )
+            DrawCursor( aOldPt, nOldHeight, nOldMode );
+
+        DrawCursor( aPt, nHeight, nMode );
+        nOldMode = nMode;
+        nOldHeight = nHeight;
+        aOldPt = aPt;
+    }
+}
+
+void SwShadowCursor::DrawTri( const Point& rPt, long nHeight, bool bLeft )
+{
+    long nLineDiff = nHeight / 2;
+    long nLineDiffHalf = nLineDiff / 2;
+
+    // Dot above
+    Point aPt1( (bLeft ? rPt.X() - 3 : rPt.X() + 3),
+                rPt.Y() + nLineDiffHalf );
+    // Dot below
+    Point aPt2( aPt1.X(), aPt1.Y() + nHeight - nLineDiff - 1 );
+    long nDiff = bLeft ? -1 : 1;
+    while( aPt1.Y() <= aPt2.Y() )
+    {
+        pWin->DrawLine( aPt1, aPt2 );
+        aPt1.AdjustY( 1 );
+        aPt2.AdjustY( -1 );
+        aPt2.setX( aPt1.AdjustX(nDiff ) );
+    }
+}
+
+void SwShadowCursor::DrawCursor( const Point& rPt, long nHeight, sal_uInt16 nMode )
+{
+    nHeight = (((nHeight / 4)+1) * 4) + 1;
+
+    pWin->Push();
+
+    pWin->SetMapMode(MapMode(MapUnit::MapPixel));
+    pWin->SetRasterOp( RasterOp::Xor );
+
+    pWin->SetLineColor( Color( sal_uInt32(aCol) ^ sal_uInt32(COL_WHITE) ) );
+
+    // 1. The Line:
+    pWin->DrawLine( Point( rPt.X(), rPt.Y() + 1),
+              Point( rPt.X(), rPt.Y() - 2 + nHeight ));
+
+    // 2. The Triangle
+    if( text::HoriOrientation::LEFT == nMode || text::HoriOrientation::CENTER == nMode )    // Arrow to the right
+        DrawTri( rPt, nHeight, false );
+    if( text::HoriOrientation::RIGHT == nMode || text::HoriOrientation::CENTER == nMode )   // Arrow to the left
+        DrawTri( rPt, nHeight, true );
+
+    pWin->Pop();
+}
+
+void SwShadowCursor::Paint()
+{
+    if( USHRT_MAX != nOldMode )
+        DrawCursor( aOldPt, nOldHeight, nOldMode );
+}
+
+tools::Rectangle SwShadowCursor::GetRect() const
+{
+    long nH = nOldHeight;
+    Point aPt( aOldPt );
+
+    nH = (((nH / 4)+1) * 4) + 1;
+    long nWidth = nH / 4 + 3 + 1;
+
+    Size aSz( nWidth, nH );
+
+    if( text::HoriOrientation::RIGHT == nOldMode )
+        aPt.AdjustX( -(aSz.Width()) );
+    else if( text::HoriOrientation::CENTER == nOldMode )
+    {
+        aPt.AdjustX( -(aSz.Width()) );
+        aSz.setWidth( aSz.Width() * 2 );
+    }
+
+    return pWin->PixelToLogic( tools::Rectangle( aPt, aSz ) );
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/tmplctrl.cxx b/sw/source/uibase/utlui/tmplctrl.cxx
new file mode 100644
index 000000000..2220c776e
--- /dev/null
+++ b/sw/source/uibase/utlui/tmplctrl.cxx
@@ -0,0 +1,142 @@
+/* -*- 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 <vcl/menu.hxx>
+#include <svl/stritem.hxx>
+#include <sfx2/dispatch.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/status.hxx>
+
+#include <swtypes.hxx>
+#include <strings.hrc>
+
+#include <wrtsh.hxx>
+#include <view.hxx>
+#include <swmodule.hxx>
+#include <cmdid.h>
+#include <docsh.hxx>
+#include <tmplctrl.hxx>
+
+SFX_IMPL_STATUSBAR_CONTROL( SwTemplateControl, SfxStringItem );
+
+namespace {
+
+class SwTemplatePopup_Impl : public PopupMenu
+{
+public:
+    SwTemplatePopup_Impl();
+
+    sal_uInt16          GetCurId() const { return nCurId; }
+
+private:
+    sal_uInt16          nCurId;
+
+    virtual void    Select() override;
+};
+
+}
+
+SwTemplatePopup_Impl::SwTemplatePopup_Impl() :
+    PopupMenu(),
+    nCurId(USHRT_MAX)
+{
+}
+
+void SwTemplatePopup_Impl::Select()
+{
+    nCurId = GetCurItemId();
+}
+
+SwTemplateControl::SwTemplateControl( sal_uInt16 _nSlotId,
+                                      sal_uInt16 _nId,
+                                      StatusBar& rStb ) :
+    SfxStatusBarControl( _nSlotId, _nId, rStb )
+{
+    GetStatusBar().SetQuickHelpText(GetId(), SwResId(STR_TMPLCTRL_HINT));
+}
+
+SwTemplateControl::~SwTemplateControl()
+{
+}
+
+void SwTemplateControl::StateChanged(
+    sal_uInt16 /*nSID*/, SfxItemState eState, const SfxPoolItem* pState )
+{
+    const SfxStringItem* pItem = nullptr;
+    if (SfxItemState::DEFAULT == eState && (pItem = dynamic_cast<const SfxStringItem*>(pState)))
+    {
+        sTemplate = pItem->GetValue();
+        GetStatusBar().SetItemText(GetId(), sTemplate);
+    }
+    else
+        GetStatusBar().SetItemText(GetId(), OUString());
+}
+
+void SwTemplateControl::Paint( const UserDrawEvent&  )
+{
+}
+
+void SwTemplateControl::Command( const CommandEvent& rCEvt )
+{
+    if ( rCEvt.GetCommand() == CommandEventId::ContextMenu &&
+            !GetStatusBar().GetItemText( GetId() ).isEmpty() )
+    {
+        ScopedVclPtrInstance<SwTemplatePopup_Impl> aPop;
+        {
+            SwView* pView = ::GetActiveView();
+            SwWrtShell *const pWrtShell(pView ? pView->GetWrtShellPtr() : nullptr);
+            if (nullptr != pWrtShell &&
+                !pWrtShell->SwCursorShell::HasSelection()&&
+                !pWrtShell->IsSelFrameMode() &&
+                !pWrtShell->IsObjSelected())
+            {
+                SfxStyleSheetBasePool* pPool = pView->GetDocShell()->
+                                                            GetStyleSheetPool();
+                auto xIter = pPool->CreateIterator(SfxStyleFamily::Page);
+                if (xIter->Count() > 1)
+                {
+                    sal_uInt16 nCount = 0;
+                    SfxStyleSheetBase* pStyle = xIter->First();
+                    while( pStyle )
+                    {
+                        aPop->InsertItem( ++nCount, pStyle->GetName() );
+                        pStyle = xIter->Next();
+                    }
+
+                    aPop->Execute( &GetStatusBar(), rCEvt.GetMousePosPixel());
+                    const sal_uInt16 nCurrId = aPop->GetCurId();
+                    if( nCurrId != USHRT_MAX)
+                    {
+                        // looks a bit awkward, but another way is not possible
+                        pStyle = xIter->operator[]( nCurrId - 1 );
+                        SfxStringItem aStyle( FN_SET_PAGE_STYLE, pStyle->GetName() );
+                        pWrtShell->GetView().GetViewFrame()->GetDispatcher()->ExecuteList(
+                                    FN_SET_PAGE_STYLE,
+                                    SfxCallMode::SLOT|SfxCallMode::RECORD,
+                                    { &aStyle });
+                    }
+                }
+            }
+        }
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/uiitems.cxx b/sw/source/uibase/utlui/uiitems.cxx
new file mode 100644
index 000000000..e6673587c
--- /dev/null
+++ b/sw/source/uibase/utlui/uiitems.cxx
@@ -0,0 +1,275 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <editeng/itemtype.hxx>
+#include <unosett.hxx>
+
+#include <swtypes.hxx>
+#include <cmdid.h>
+#include <uiitems.hxx>
+
+#include <strings.hrc>
+#include <unomid.h>
+#include <numrule.hxx>
+
+#include <editeng/eerdll.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+
+SwPageFootnoteInfoItem::SwPageFootnoteInfoItem( SwPageFootnoteInfo const & rInfo) :
+    SfxPoolItem( FN_PARAM_FTN_INFO ),
+    aFootnoteInfo(rInfo)
+{
+}
+
+SwPageFootnoteInfoItem::~SwPageFootnoteInfoItem()
+{
+}
+
+SwPageFootnoteInfoItem* SwPageFootnoteInfoItem::Clone( SfxItemPool * /*pPool*/ ) const
+{
+    return new SwPageFootnoteInfoItem( *this );
+}
+
+bool SwPageFootnoteInfoItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    return SfxPoolItem::operator==(rAttr)
+        && aFootnoteInfo == static_cast<const SwPageFootnoteInfoItem&>(rAttr).aFootnoteInfo;
+}
+
+bool SwPageFootnoteInfoItem::GetPresentation
+(
+    SfxItemPresentation /*ePres*/,
+    MapUnit             eCoreUnit,
+    MapUnit             ePresUnit,
+    OUString&           rText,
+    const IntlWrapper&  rIntl
+)   const
+{
+    const SwTwips nHght = GetPageFootnoteInfo().GetHeight();
+    if ( nHght )
+    {
+        rText = SwResId( STR_MAX_FTN_HEIGHT ) + " " +
+                ::GetMetricText( nHght, eCoreUnit, ePresUnit, &rIntl ) + " " +
+                EditResId( ::GetMetricId( ePresUnit ) );
+    }
+    return true;
+}
+
+bool SwPageFootnoteInfoItem::QueryValue( Any& rVal, sal_uInt8 nMemberId ) const
+{
+    bool bRet = true;
+    switch(nMemberId & ~CONVERT_TWIPS)
+    {
+        case MID_FTN_HEIGHT        :     rVal <<= static_cast<sal_Int32>(convertTwipToMm100(aFootnoteInfo.GetHeight()));break;
+        case MID_LINE_WEIGHT       :     rVal <<= static_cast<sal_Int16>(convertTwipToMm100(aFootnoteInfo.GetLineWidth()));break;
+        case MID_LINE_COLOR        :     rVal <<= aFootnoteInfo.GetLineColor();break;
+        case MID_LINE_RELWIDTH     :
+        {
+            Fraction aTmp( 100, 1 );
+            aTmp *= aFootnoteInfo.GetWidth();
+            rVal <<= static_cast<sal_Int8>(static_cast<long>(aTmp));
+        }
+        break;
+        case MID_LINE_ADJUST       :     rVal <<= static_cast<sal_Int16>(aFootnoteInfo.GetAdj());break;//text::HorizontalAdjust
+        case MID_LINE_TEXT_DIST    :     rVal <<= static_cast<sal_Int32>(convertTwipToMm100(aFootnoteInfo.GetTopDist()));break;
+        case MID_LINE_FOOTNOTE_DIST:     rVal <<= static_cast<sal_Int32>(convertTwipToMm100(aFootnoteInfo.GetBottomDist()));break;
+        case MID_FTN_LINE_STYLE    :
+        {
+            switch ( aFootnoteInfo.GetLineStyle( ) )
+            {
+                default:
+                case SvxBorderLineStyle::NONE : rVal <<= sal_Int8(0); break;
+                case SvxBorderLineStyle::SOLID: rVal <<= sal_Int8(1); break;
+                case SvxBorderLineStyle::DOTTED: rVal <<= sal_Int8(2); break;
+                case SvxBorderLineStyle::DASHED: rVal <<= sal_Int8(3); break;
+            }
+            break;
+        }
+        default:
+            bRet = false;
+    }
+    return bRet;
+}
+
+bool SwPageFootnoteInfoItem::PutValue(const Any& rVal, sal_uInt8 nMemberId)
+{
+    sal_Int32 nSet32 = 0;
+    Color aColor;
+    bool bRet = true;
+    switch(nMemberId  & ~CONVERT_TWIPS)
+    {
+        case MID_LINE_COLOR        :
+            rVal >>= aColor;
+            aFootnoteInfo.SetLineColor(aColor);
+        break;
+        case MID_FTN_HEIGHT:
+        case MID_LINE_TEXT_DIST    :
+        case MID_LINE_FOOTNOTE_DIST:
+                rVal >>= nSet32;
+                if(nSet32 < 0)
+                    bRet = false;
+                else
+                {
+                    nSet32 = convertMm100ToTwip(nSet32);
+                    switch(nMemberId & ~CONVERT_TWIPS)
+                    {
+                        case MID_FTN_HEIGHT:            aFootnoteInfo.SetHeight(nSet32);    break;
+                        case MID_LINE_TEXT_DIST:        aFootnoteInfo.SetTopDist(nSet32);break;
+                        case MID_LINE_FOOTNOTE_DIST:    aFootnoteInfo.SetBottomDist(nSet32);break;
+                    }
+                }
+        break;
+        case MID_LINE_WEIGHT       :
+        {
+            sal_Int16 nSet = 0;
+            rVal >>= nSet;
+            if(nSet >= 0)
+                aFootnoteInfo.SetLineWidth(convertMm100ToTwip(nSet));
+            else
+                bRet = false;
+        }
+        break;
+        case MID_LINE_RELWIDTH     :
+        {
+            sal_Int8 nSet = 0;
+            rVal >>= nSet;
+            if(nSet < 0)
+                bRet = false;
+            else
+                aFootnoteInfo.SetWidth(Fraction(nSet, 100));
+        }
+        break;
+        case MID_LINE_ADJUST       :
+        {
+            sal_Int16 nSet = 0;
+            rVal >>= nSet;
+            if(nSet >= 0 && nSet < 3) //text::HorizontalAdjust
+                aFootnoteInfo.SetAdj(static_cast<css::text::HorizontalAdjust>(nSet));
+            else
+                bRet = false;
+        }
+        break;
+        case MID_FTN_LINE_STYLE:
+        {
+            SvxBorderLineStyle eStyle = SvxBorderLineStyle::NONE;
+            sal_Int8 nSet = 0;
+            rVal >>= nSet;
+            switch ( nSet )
+            {
+                case 1: eStyle = SvxBorderLineStyle::SOLID; break;
+                case 2: eStyle = SvxBorderLineStyle::DOTTED; break;
+                case 3: eStyle = SvxBorderLineStyle::DASHED; break;
+                default: break;
+            }
+            aFootnoteInfo.SetLineStyle( eStyle );
+        }
+        break;
+        default:
+            bRet = false;
+    }
+    return bRet;
+}
+
+SwPtrItem::SwPtrItem( const sal_uInt16 nId, void* pPtr ) :
+    SfxPoolItem( nId ),
+    pMisc(pPtr)
+{
+}
+
+// Cloning
+
+SwPtrItem* SwPtrItem::Clone( SfxItemPool * /*pPool*/ ) const
+{
+    return new SwPtrItem( *this );
+}
+
+bool SwPtrItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    return SfxPoolItem::operator==(rAttr)
+        && pMisc == static_cast<const SwPtrItem&>(rAttr).pMisc;
+}
+
+// SwUINumRuleItem for the NumTabPages of the FormatNumRule/Styleists
+
+SwUINumRuleItem::SwUINumRuleItem( const SwNumRule& rRul )
+    : SfxPoolItem( FN_PARAM_ACT_NUMBER ), pRule( new SwNumRule( rRul ) )
+{
+}
+
+SwUINumRuleItem::SwUINumRuleItem( const SwUINumRuleItem& rItem )
+    : SfxPoolItem( rItem ),
+    pRule( new SwNumRule( *rItem.pRule ))
+{
+}
+
+SwUINumRuleItem::~SwUINumRuleItem()
+{
+}
+
+SwUINumRuleItem* SwUINumRuleItem::Clone( SfxItemPool * /*pPool*/ ) const
+{
+    return new SwUINumRuleItem( *this );
+}
+
+bool SwUINumRuleItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    return SfxPoolItem::operator==(rAttr)
+        && *pRule == *static_cast<const SwUINumRuleItem&>(rAttr).pRule;
+}
+
+bool SwUINumRuleItem::QueryValue( uno::Any& rVal, sal_uInt8 /*nMemberId*/ ) const
+{
+    uno::Reference< container::XIndexReplace >xRules = new SwXNumberingRules(*pRule);
+    rVal <<= xRules;
+    return true;
+}
+bool SwUINumRuleItem::PutValue( const uno::Any& rVal, sal_uInt8 /*nMemberId*/ )
+{
+    uno::Reference< container::XIndexReplace> xRulesRef;
+    if(rVal >>= xRulesRef)
+    {
+        auto pSwXRules = comphelper::getUnoTunnelImplementation<SwXNumberingRules>(xRulesRef);
+        if(pSwXRules)
+        {
+            *pRule = *pSwXRules->GetNumRule();
+        }
+    }
+    return true;
+}
+
+SwPaMItem::SwPaMItem( const sal_uInt16 nId, SwPaM* pPaM ) :
+    SfxPoolItem( nId ),
+    m_pPaM(pPaM)
+{
+}
+
+SwPaMItem* SwPaMItem::Clone( SfxItemPool * /*pPool*/ ) const
+{
+    return new SwPaMItem( *this );
+}
+
+bool SwPaMItem::operator==( const SfxPoolItem& rAttr ) const
+{
+    return SfxPoolItem::operator==(rAttr)
+        && m_pPaM ==  static_cast<const SwPaMItem&>(rAttr).m_pPaM;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/uitool.cxx b/sw/source/uibase/utlui/uitool.cxx
new file mode 100644
index 000000000..fb41aaa6f
--- /dev/null
+++ b/sw/source/uibase/utlui/uitool.cxx
@@ -0,0 +1,848 @@
+/* -*- 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 <hintids.hxx>
+
+#include <osl/diagnose.h>
+#include <tools/datetime.hxx>
+#include <vcl/weld.hxx>
+#include <unotools/collatorwrapper.hxx>
+#include <svl/stritem.hxx>
+#include <svl/grabbagitem.hxx>
+#include <unotools/syslocale.hxx>
+#include <IDocumentStylePoolAccess.hxx>
+#include <editeng/pmdlitem.hxx>
+#include <editeng/tstpitem.hxx>
+#include <editeng/boxitem.hxx>
+#include <editeng/sizeitem.hxx>
+#include <editeng/brushitem.hxx>
+#include <svx/pageitem.hxx>
+#include <editeng/lrspitem.hxx>
+#include <svl/style.hxx>
+#include <unotools/localedatawrapper.hxx>
+#include <com/sun/star/frame/XDispatch.hpp>
+#include <com/sun/star/frame/XDispatchProvider.hpp>
+#include <com/sun/star/frame/XFrame.hpp>
+#include <com/sun/star/util/URLTransformer.hpp>
+#include <com/sun/star/util/XURLTransformer.hpp>
+#include <comphelper/processfactory.hxx>
+#include <sfx2/viewfrm.hxx>
+#include <fmtornt.hxx>
+#include <tabcol.hxx>
+#include <fmtfsize.hxx>
+#include <fmthdft.hxx>
+#include <fmtpdsc.hxx>
+#include <uiitems.hxx>
+#include <docsh.hxx>
+#include <wrtsh.hxx>
+#include <swmodule.hxx>
+#include <view.hxx>
+#include <uitool.hxx>
+#include <frmatr.hxx>
+#include <paratr.hxx>
+#include <fmtcol.hxx>
+#include <poolfmt.hxx>
+#include <usrpref.hxx>
+
+#include <cmdid.h>
+#include <doc.hxx>
+#include <docary.hxx>
+#include <charfmt.hxx>
+#include <SwStyleNameMapper.hxx>
+#include <strings.hrc>
+// 50 cm 28350
+
+#define MAXHEIGHT 28350
+#define MAXWIDTH  28350
+
+using namespace ::com::sun::star;
+
+// General list of string pointer
+
+// Set boxinfo attribute
+
+void PrepareBoxInfo(SfxItemSet& rSet, const SwWrtShell& rSh)
+{
+    std::shared_ptr<SvxBoxInfoItem> aBoxInfo(std::make_shared<SvxBoxInfoItem>(SID_ATTR_BORDER_INNER));
+    const SfxPoolItem *pBoxInfo;
+
+    if ( SfxItemState::SET == rSet.GetItemState( SID_ATTR_BORDER_INNER, true, &pBoxInfo))
+    {
+        aBoxInfo.reset(static_cast<SvxBoxInfoItem*>(pBoxInfo->Clone()));
+    }
+
+        // Table variant: If more than one table cells are selected
+    rSh.GetCursor();                  //So that GetCursorCnt() returns the right thing
+    aBoxInfo->SetTable          (rSh.IsTableMode() && rSh.GetCursorCnt() > 1);
+        // Always show the distance field
+    aBoxInfo->SetDist           (true);
+        // Set minimal size in tables and paragraphs
+    aBoxInfo->SetMinDist        (rSh.IsTableMode() || rSh.GetSelectionType() & (SelectionType::Text | SelectionType::Table));
+        // Set always the default distance
+    aBoxInfo->SetDefDist        (MIN_BORDER_DIST);
+        // Single lines can have only in tables DontCare-Status
+    aBoxInfo->SetValid(SvxBoxInfoItemValidFlags::DISABLE, !rSh.IsTableMode());
+
+    rSet.Put(*aBoxInfo);
+}
+
+void ConvertAttrCharToGen(SfxItemSet& rSet)
+{
+    // Background / highlight
+    {
+        // Always use the visible background
+        const SfxPoolItem *pTmpBrush;
+        if( SfxItemState::SET == rSet.GetItemState( RES_CHRATR_HIGHLIGHT, true, &pTmpBrush ) )
+        {
+            SvxBrushItem aTmpBrush( *static_cast<const SvxBrushItem*>(pTmpBrush) );
+            if( aTmpBrush.GetColor() != COL_TRANSPARENT )
+            {
+                aTmpBrush.SetWhich( RES_CHRATR_BACKGROUND );
+                rSet.Put( aTmpBrush );
+            }
+        }
+    }
+
+    // Tell dialogs to use character-specific slots/whichIds
+    // tdf#126684: We use RES_PARATR_GRABBAG, because RES_CHRATR_GRABBAG may be overwritten later in
+    // SwDocStyleSheet::GetItemSet when applying attributes from char format
+    assert(SfxItemState::SET != rSet.GetItemState(RES_PARATR_GRABBAG, false));
+    SfxGrabBagItem aGrabBag(RES_PARATR_GRABBAG);
+    aGrabBag.GetGrabBag()["DialogUseCharAttr"] <<= true;
+    // Store initial ranges to allow restoring later
+    const sal_uInt16* pRanges = rSet.GetRanges();
+    const sal_uInt16* pEnd = pRanges;
+    while (*pEnd)
+        ++pEnd;
+    const uno::Sequence<sal_uInt16> aOrigRanges(pRanges, pEnd - pRanges + 1);
+    aGrabBag.GetGrabBag()["OrigItemSetRanges"] <<= aOrigRanges;
+    rSet.MergeRange(RES_PARATR_GRABBAG, RES_PARATR_GRABBAG);
+    rSet.Put(aGrabBag);
+}
+
+void ConvertAttrGenToChar(SfxItemSet& rSet, const SfxItemSet& rOrigSet)
+{
+    // Background / highlighting
+    const SfxPoolItem *pTmpItem;
+    if( SfxItemState::SET == rSet.GetItemState( RES_CHRATR_BACKGROUND, false, &pTmpItem ) )
+    {
+        // Highlight is an MS specific thing, so remove it at the first time when LO modifies
+        // this part of the imported document.
+        rSet.Put( SvxBrushItem(RES_CHRATR_HIGHLIGHT) );
+
+        // Remove shading marker
+        if (SfxItemState::SET == rOrigSet.GetItemState(RES_CHRATR_GRABBAG, false, &pTmpItem))
+        {
+            SfxGrabBagItem aGrabBag(*static_cast<const SfxGrabBagItem*>(pTmpItem));
+            std::map<OUString, css::uno::Any>& rMap = aGrabBag.GetGrabBag();
+            auto aIterator = rMap.find("CharShadingMarker");
+            if( aIterator != rMap.end() )
+            {
+                aIterator->second <<= false;
+            }
+            rSet.Put( aGrabBag );
+        }
+    }
+    rSet.ClearItem( RES_BACKGROUND );
+
+    if (SfxItemState::SET == rOrigSet.GetItemState(RES_PARATR_GRABBAG, false, &pTmpItem))
+    {
+        SfxGrabBagItem aGrabBag(*static_cast<const SfxGrabBagItem*>(pTmpItem));
+        std::map<OUString, css::uno::Any>& rMap = aGrabBag.GetGrabBag();
+        auto aIterator = rMap.find("OrigItemSetRanges");
+        if (aIterator != rMap.end())
+        {
+            if (uno::Sequence<sal_uInt16> aOrigRanges; (aIterator->second >>= aOrigRanges)
+                                                       && aOrigRanges.getLength() % 2 == 1
+                                                       && *(std::cend(aOrigRanges) - 1) == 0)
+                rSet.SetRanges(aOrigRanges.getConstArray());
+        }
+    }
+    assert(SfxItemState::SET != rSet.GetItemState(RES_PARATR_GRABBAG, false));
+}
+
+void ApplyCharBackground(const Color& rBackgroundColor, SwWrtShell& rShell)
+{
+    rShell.StartUndo(SwUndoId::INSATTR);
+
+    SfxItemSet aCoreSet(rShell.GetView().GetPool(), svl::Items<
+        RES_CHRATR_GRABBAG, RES_CHRATR_GRABBAG>{});
+
+    rShell.GetCurAttr(aCoreSet);
+
+    // Set char background
+    rShell.SetAttrItem(SvxBrushItem(rBackgroundColor, RES_CHRATR_BACKGROUND));
+
+    // Highlight is an MS specific thing, so remove it at the first time when LO modifies
+    // this part of the imported document.
+    rShell.SetAttrItem(SvxBrushItem(RES_CHRATR_HIGHLIGHT));
+
+    // Remove shading marker
+    const SfxPoolItem *pTmpItem;
+    if (SfxItemState::SET == aCoreSet.GetItemState(RES_CHRATR_GRABBAG, false, &pTmpItem))
+    {
+        SfxGrabBagItem aGrabBag(*static_cast<const SfxGrabBagItem*>(pTmpItem));
+        std::map<OUString, css::uno::Any>& rMap = aGrabBag.GetGrabBag();
+        auto aIterator = rMap.find("CharShadingMarker");
+        if (aIterator != rMap.end())
+        {
+            aIterator->second <<= false;
+        }
+        rShell.SetAttrItem(aGrabBag);
+    }
+
+    rShell.EndUndo(SwUndoId::INSATTR);
+}
+
+// Fill header footer
+
+static void FillHdFt(SwFrameFormat* pFormat, const  SfxItemSet& rSet)
+{
+    SwAttrSet aSet(pFormat->GetAttrSet());
+    aSet.Put(rSet);
+
+    const SvxSizeItem& rSize = rSet.Get(SID_ATTR_PAGE_SIZE);
+    const SfxBoolItem& rDynamic = rSet.Get(SID_ATTR_PAGE_DYNAMIC);
+
+    // Convert size
+    SwFormatFrameSize aFrameSize(rDynamic.GetValue() ? SwFrameSize::Minimum : SwFrameSize::Fixed,
+                            rSize.GetSize().Width(),
+                            rSize.GetSize().Height());
+    aSet.Put(aFrameSize);
+    pFormat->SetFormatAttr(aSet);
+}
+
+/// Convert from UseOnPage to SvxPageUsage.
+static SvxPageUsage lcl_convertUseToSvx(UseOnPage nUse)
+{
+    SvxPageUsage nRet = SvxPageUsage::NONE;
+    if (nUse & UseOnPage::Left)
+        nRet = SvxPageUsage::Left;
+    if (nUse & UseOnPage::Right)
+        nRet = SvxPageUsage::Right;
+    if ((nUse & UseOnPage::All) == UseOnPage::All)
+        nRet = SvxPageUsage::All;
+    if ((nUse & UseOnPage::Mirror) == UseOnPage::Mirror)
+        nRet = SvxPageUsage::Mirror;
+    return nRet;
+}
+
+/// Convert from SvxPageUsage to UseOnPage.
+static UseOnPage lcl_convertUseFromSvx(SvxPageUsage nUse)
+{
+    UseOnPage nRet = UseOnPage::NONE;
+    if (nUse == SvxPageUsage::Left)
+        nRet = UseOnPage::Left;
+    else if (nUse == SvxPageUsage::Right)
+        nRet = UseOnPage::Right;
+    else if (nUse == SvxPageUsage::All)
+        nRet = UseOnPage::All;
+    else if (nUse == SvxPageUsage::Mirror)
+        nRet = UseOnPage::Mirror;
+    return nRet;
+}
+
+// PageDesc <-> convert into sets and back
+
+void ItemSetToPageDesc( const SfxItemSet& rSet, SwPageDesc& rPageDesc )
+{
+    SwFrameFormat& rMaster = rPageDesc.GetMaster();
+    bool bFirstShare = false;
+
+    // Transfer all general frame attributes
+    rMaster.SetFormatAttr(rSet);
+
+    // PageData
+    if(rSet.GetItemState(SID_ATTR_PAGE) == SfxItemState::SET)
+    {
+        const SvxPageItem& rPageItem = rSet.Get(SID_ATTR_PAGE);
+
+        const SvxPageUsage nUse = rPageItem.GetPageUsage();
+        if(nUse != SvxPageUsage::NONE)
+            rPageDesc.SetUseOn( lcl_convertUseFromSvx(nUse) );
+        rPageDesc.SetLandscape(rPageItem.IsLandscape());
+        SvxNumberType aNumType;
+        aNumType.SetNumberingType( rPageItem.GetNumType() );
+        rPageDesc.SetNumType(aNumType);
+    }
+    // Size
+    if(rSet.GetItemState(SID_ATTR_PAGE_SIZE) == SfxItemState::SET)
+    {
+        const SvxSizeItem& rSizeItem = rSet.Get(SID_ATTR_PAGE_SIZE);
+        SwFormatFrameSize aSize(SwFrameSize::Fixed);
+        aSize.SetSize(rSizeItem.GetSize());
+        rMaster.SetFormatAttr(aSize);
+    }
+    // Evaluate header attributes
+    const SfxPoolItem* pItem;
+    if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_PAGE_HEADERSET,
+            false, &pItem ) )
+    {
+        const SfxItemSet& rHeaderSet = static_cast<const SvxSetItem*>(pItem)->GetItemSet();
+        const SfxBoolItem& rHeaderOn = rHeaderSet.Get(SID_ATTR_PAGE_ON);
+
+        if(rHeaderOn.GetValue())
+        {
+            // Take over values
+            if(!rMaster.GetHeader().IsActive())
+                rMaster.SetFormatAttr(SwFormatHeader(true));
+
+            // Pick out everything and adapt the header format
+            SwFormatHeader aHeaderFormat(rMaster.GetHeader());
+            SwFrameFormat *pHeaderFormat = aHeaderFormat.GetHeaderFormat();
+            OSL_ENSURE(pHeaderFormat != nullptr, "no header format");
+
+            ::FillHdFt(pHeaderFormat, rHeaderSet);
+
+            rPageDesc.ChgHeaderShare(rHeaderSet.Get(SID_ATTR_PAGE_SHARED).GetValue());
+            rPageDesc.ChgFirstShare(static_cast<const SfxBoolItem&>(
+                            rHeaderSet.Get(SID_ATTR_PAGE_SHARED_FIRST)).GetValue());
+            bFirstShare = true;
+        }
+        else
+        {
+            // Disable header
+            if(rMaster.GetHeader().IsActive())
+            {
+                rMaster.SetFormatAttr(SwFormatHeader(false));
+                rPageDesc.ChgHeaderShare(false);
+            }
+        }
+    }
+
+    // Evaluate footer attributes
+    if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_PAGE_FOOTERSET,
+            false, &pItem ) )
+    {
+        const SfxItemSet& rFooterSet = static_cast<const SvxSetItem*>(pItem)->GetItemSet();
+        const SfxBoolItem& rFooterOn = rFooterSet.Get(SID_ATTR_PAGE_ON);
+
+        if(rFooterOn.GetValue())
+        {
+            // Take over values
+            if(!rMaster.GetFooter().IsActive())
+                rMaster.SetFormatAttr(SwFormatFooter(true));
+
+            // Pick out everything and adapt the footer format
+            SwFormatFooter aFooterFormat(rMaster.GetFooter());
+            SwFrameFormat *pFooterFormat = aFooterFormat.GetFooterFormat();
+            OSL_ENSURE(pFooterFormat != nullptr, "no footer format");
+
+            ::FillHdFt(pFooterFormat, rFooterSet);
+
+            rPageDesc.ChgFooterShare(rFooterSet.Get(SID_ATTR_PAGE_SHARED).GetValue());
+            if (!bFirstShare)
+            {
+                rPageDesc.ChgFirstShare(static_cast<const SfxBoolItem&>(
+                            rFooterSet.Get(SID_ATTR_PAGE_SHARED_FIRST)).GetValue());
+            }
+        }
+        else
+        {
+            // Disable footer
+            if(rMaster.GetFooter().IsActive())
+            {
+                rMaster.SetFormatAttr(SwFormatFooter(false));
+                rPageDesc.ChgFooterShare(false);
+            }
+        }
+    }
+
+    // Footnotes
+
+    if( SfxItemState::SET == rSet.GetItemState( FN_PARAM_FTN_INFO,
+            false, &pItem ) )
+        rPageDesc.SetFootnoteInfo( static_cast<const SwPageFootnoteInfoItem*>(pItem)->GetPageFootnoteInfo() );
+
+    // Columns
+
+    // Register compliant
+
+    if(SfxItemState::SET == rSet.GetItemState(
+                            SID_SWREGISTER_MODE, false, &pItem))
+    {
+        bool bSet = static_cast<const SfxBoolItem*>(pItem)->GetValue();
+        if(!bSet)
+            rPageDesc.SetRegisterFormatColl(nullptr);
+        else if(SfxItemState::SET == rSet.GetItemState(
+                                SID_SWREGISTER_COLLECTION, false, &pItem))
+        {
+            const OUString& rColl = static_cast<const SfxStringItem*>(pItem)->GetValue();
+            SwDoc& rDoc = *rMaster.GetDoc();
+            SwTextFormatColl* pColl = rDoc.FindTextFormatCollByName( rColl );
+            if( !pColl )
+            {
+                const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(
+                    rColl, SwGetPoolIdFromName::TxtColl );
+                if( USHRT_MAX != nId )
+                    pColl = rDoc.getIDocumentStylePoolAccess().GetTextCollFromPool( nId );
+                else
+                    pColl = rDoc.MakeTextFormatColl( rColl,
+                                rDoc.GetDfltTextFormatColl() );
+            }
+            if( pColl )
+                pColl->SetFormatAttr( SwRegisterItem ( true ));
+            rPageDesc.SetRegisterFormatColl( pColl );
+        }
+    }
+}
+
+void PageDescToItemSet( const SwPageDesc& rPageDesc, SfxItemSet& rSet)
+{
+    const SwFrameFormat& rMaster = rPageDesc.GetMaster();
+
+    // Page data
+    SvxPageItem aPageItem(SID_ATTR_PAGE);
+    aPageItem.SetDescName(rPageDesc.GetName());
+    aPageItem.SetPageUsage(lcl_convertUseToSvx(rPageDesc.GetUseOn()));
+    aPageItem.SetLandscape(rPageDesc.GetLandscape());
+    aPageItem.SetNumType(rPageDesc.GetNumType().GetNumberingType());
+    rSet.Put(aPageItem);
+
+    // Size
+    SvxSizeItem aSizeItem(SID_ATTR_PAGE_SIZE, rMaster.GetFrameSize().GetSize());
+    rSet.Put(aSizeItem);
+
+    // Maximum size
+    SvxSizeItem aMaxSizeItem(SID_ATTR_PAGE_MAXSIZE, Size(MAXWIDTH, MAXHEIGHT));
+    rSet.Put(aMaxSizeItem);
+
+    // Margins, border and the other stuff.
+    rSet.Put(rMaster.GetAttrSet());
+
+    std::shared_ptr<SvxBoxInfoItem> aBoxInfo(std::make_shared<SvxBoxInfoItem>(SID_ATTR_BORDER_INNER));
+    const SfxPoolItem *pBoxInfo;
+
+    if ( SfxItemState::SET == rSet.GetItemState( SID_ATTR_BORDER_INNER, true, &pBoxInfo) )
+    {
+        aBoxInfo.reset(static_cast<SvxBoxInfoItem*>(pBoxInfo->Clone()));
+    }
+
+    aBoxInfo->SetTable( false );
+        // Show always the distance field
+    aBoxInfo->SetDist( true);
+        // Set minimal size in tables and paragraphs
+    aBoxInfo->SetMinDist( false );
+        // Set always the default distance
+    aBoxInfo->SetDefDist( MIN_BORDER_DIST );
+        // Single lines can have only in tables DontCare-Status
+    aBoxInfo->SetValid( SvxBoxInfoItemValidFlags::DISABLE );
+    rSet.Put( *aBoxInfo );
+
+    SfxStringItem aFollow(SID_ATTR_PAGE_EXT1, OUString());
+    if(rPageDesc.GetFollow())
+        aFollow.SetValue(rPageDesc.GetFollow()->GetName());
+    rSet.Put(aFollow);
+
+    // Header
+    if(rMaster.GetHeader().IsActive())
+    {
+        const SwFormatHeader &rHeaderFormat = rMaster.GetHeader();
+        const SwFrameFormat *pHeaderFormat = rHeaderFormat.GetHeaderFormat();
+        OSL_ENSURE(pHeaderFormat != nullptr, "no header format");
+
+        // HeaderInfo, margins, background, border
+        SfxItemSet aHeaderSet(*rSet.GetPool(),
+            svl::Items<RES_FRMATR_BEGIN,RES_FRMATR_END - 1,            // [82
+
+            // FillAttribute support
+            XATTR_FILL_FIRST, XATTR_FILL_LAST,              // [1014
+
+            SID_ATTR_BORDER_INNER,SID_ATTR_BORDER_INNER,    // [10023
+            SID_ATTR_PAGE_SIZE,SID_ATTR_PAGE_SIZE,          // [10051
+            SID_ATTR_PAGE_ON,SID_ATTR_PAGE_SHARED,          // [10060
+            SID_ATTR_PAGE_SHARED_FIRST,SID_ATTR_PAGE_SHARED_FIRST>{});
+
+        // set correct parent to get the XFILL_NONE FillStyle as needed
+        aHeaderSet.SetParent(&rMaster.GetDoc()->GetDfltFrameFormat()->GetAttrSet());
+
+        // Dynamic or fixed height
+        SfxBoolItem aOn(SID_ATTR_PAGE_ON, true);
+        aHeaderSet.Put(aOn);
+
+        const SwFormatFrameSize &rFrameSize = pHeaderFormat->GetFrameSize();
+        const SwFrameSize eSizeType = rFrameSize.GetHeightSizeType();
+        SfxBoolItem aDynamic(SID_ATTR_PAGE_DYNAMIC, eSizeType != SwFrameSize::Fixed);
+        aHeaderSet.Put(aDynamic);
+
+        // Left equal right
+        SfxBoolItem aShared(SID_ATTR_PAGE_SHARED, rPageDesc.IsHeaderShared());
+        aHeaderSet.Put(aShared);
+        SfxBoolItem aFirstShared(SID_ATTR_PAGE_SHARED_FIRST, rPageDesc.IsFirstShared());
+        aHeaderSet.Put(aFirstShared);
+
+        // Size
+        SvxSizeItem aSize(SID_ATTR_PAGE_SIZE, rFrameSize.GetSize());
+        aHeaderSet.Put(aSize);
+
+        // Shifting frame attributes
+        aHeaderSet.Put(pHeaderFormat->GetAttrSet());
+        aHeaderSet.Put( *aBoxInfo );
+
+        // Create SetItem
+        SvxSetItem aSetItem(SID_ATTR_PAGE_HEADERSET, aHeaderSet);
+        rSet.Put(aSetItem);
+    }
+
+    // Footer
+    if(rMaster.GetFooter().IsActive())
+    {
+        const SwFormatFooter &rFooterFormat = rMaster.GetFooter();
+        const SwFrameFormat *pFooterFormat = rFooterFormat.GetFooterFormat();
+        OSL_ENSURE(pFooterFormat != nullptr, "no footer format");
+
+        // FooterInfo, margins, background, border
+        SfxItemSet aFooterSet(*rSet.GetPool(),
+            svl::Items<RES_FRMATR_BEGIN,RES_FRMATR_END - 1,            // [82
+
+            // FillAttribute support
+            XATTR_FILL_FIRST, XATTR_FILL_LAST,              // [1014
+
+            SID_ATTR_BORDER_INNER,SID_ATTR_BORDER_INNER,    // [10023
+            SID_ATTR_PAGE_SIZE,SID_ATTR_PAGE_SIZE,          // [10051
+            SID_ATTR_PAGE_ON,SID_ATTR_PAGE_SHARED,          // [10060
+            SID_ATTR_PAGE_SHARED_FIRST,SID_ATTR_PAGE_SHARED_FIRST>{});
+
+        // set correct parent to get the XFILL_NONE FillStyle as needed
+        aFooterSet.SetParent(&rMaster.GetDoc()->GetDfltFrameFormat()->GetAttrSet());
+
+        // Dynamic or fixed height
+        SfxBoolItem aOn(SID_ATTR_PAGE_ON, true);
+        aFooterSet.Put(aOn);
+
+        const SwFormatFrameSize &rFrameSize = pFooterFormat->GetFrameSize();
+        const SwFrameSize eSizeType = rFrameSize.GetHeightSizeType();
+        SfxBoolItem aDynamic(SID_ATTR_PAGE_DYNAMIC, eSizeType != SwFrameSize::Fixed);
+        aFooterSet.Put(aDynamic);
+
+        // Left equal right
+        SfxBoolItem aShared(SID_ATTR_PAGE_SHARED, rPageDesc.IsFooterShared());
+        aFooterSet.Put(aShared);
+        SfxBoolItem aFirstShared(SID_ATTR_PAGE_SHARED_FIRST, rPageDesc.IsFirstShared());
+        aFooterSet.Put(aFirstShared);
+
+        // Size
+        SvxSizeItem aSize(SID_ATTR_PAGE_SIZE, rFrameSize.GetSize());
+        aFooterSet.Put(aSize);
+
+        // Shifting Frame attributes
+        aFooterSet.Put(pFooterFormat->GetAttrSet());
+        aFooterSet.Put( *aBoxInfo );
+
+        // Create SetItem
+        SvxSetItem aSetItem(SID_ATTR_PAGE_FOOTERSET, aFooterSet);
+        rSet.Put(aSetItem);
+    }
+
+    // Integrate footnotes
+    SwPageFootnoteInfo& rInfo = const_cast<SwPageFootnoteInfo&>(rPageDesc.GetFootnoteInfo());
+    SwPageFootnoteInfoItem aFootnoteItem(rInfo);
+    rSet.Put(aFootnoteItem);
+
+    // Register compliant
+    const SwTextFormatColl* pCol = rPageDesc.GetRegisterFormatColl();
+    SwRegisterItem aReg(pCol != nullptr);
+    aReg.SetWhich(SID_SWREGISTER_MODE);
+    rSet.Put(aReg);
+    if(pCol)
+        rSet.Put(SfxStringItem(SID_SWREGISTER_COLLECTION, pCol->GetName()));
+
+}
+
+// Set DefaultTabs
+
+void MakeDefTabs(SwTwips nDefDist, SvxTabStopItem& rTabs)
+{
+    if( rTabs.Count() )
+        return;
+    {
+        SvxTabStop aSwTabStop( nDefDist, SvxTabAdjust::Default );
+        rTabs.Insert( aSwTabStop );
+    }
+}
+
+// Distance between two tabs
+
+SwTwips GetTabDist(const SvxTabStopItem& rTabs)
+{
+    return rTabs.Count() ? rTabs[0].GetTabPos() : 1134; // 1134 = 2 cm
+}
+
+// Inquire if in the set is a Sfx-PageDesc combination present and return it.
+void SfxToSwPageDescAttr( const SwWrtShell& rShell, SfxItemSet& rSet )
+{
+    const SfxPoolItem* pItem;
+    SwFormatPageDesc aPgDesc;
+
+    bool bChanged = false;
+    // Page number
+    switch (rSet.GetItemState(SID_ATTR_PARA_PAGENUM, false, &pItem))
+    {
+        case SfxItemState::SET:
+        {
+            aPgDesc.SetNumOffset(static_cast<const SfxUInt16Item*>(pItem)->GetValue());
+            bChanged = true;
+            break;
+        }
+        case SfxItemState::DISABLED:
+        {
+            bChanged = true; // default initialised aPgDesc clears the number
+            break;
+        }
+        case SfxItemState::UNKNOWN:
+        case SfxItemState::DEFAULT:
+            break;
+        default:
+            assert(false); // unexpected
+            break;
+    }
+    if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_PARA_MODEL, false, &pItem ))
+    {
+        const OUString& rDescName = static_cast<const SvxPageModelItem*>(pItem)->GetValue();
+        if( !rDescName.isEmpty() )   // No name -> disable PageDesc!
+        {
+            // Delete only, if PageDesc will be enabled!
+            rSet.ClearItem( RES_BREAK );
+            SwPageDesc* pDesc = const_cast<SwWrtShell&>(rShell).FindPageDescByName(
+                                                    rDescName, true );
+            if( pDesc )
+                aPgDesc.RegisterToPageDesc( *pDesc );
+        }
+        rSet.ClearItem( SID_ATTR_PARA_MODEL );
+        bChanged = true;
+    }
+    else
+    {
+        SfxItemSet aCoreSet(rShell.GetView().GetPool(), svl::Items<RES_PAGEDESC, RES_PAGEDESC>{} );
+        rShell.GetCurAttr( aCoreSet );
+        if(SfxItemState::SET == aCoreSet.GetItemState( RES_PAGEDESC, true, &pItem ) )
+        {
+            if( static_cast<const SwFormatPageDesc*>(pItem)->GetPageDesc() )
+            {
+                aPgDesc.RegisterToPageDesc( *const_cast<SwFormatPageDesc*>(static_cast<const SwFormatPageDesc*>(pItem))->GetPageDesc() );
+            }
+        }
+    }
+
+    if(bChanged)
+        rSet.Put( aPgDesc );
+}
+
+// Inquire if in the set is a Sfx-PageDesc combination present and return it.
+void SwToSfxPageDescAttr( SfxItemSet& rCoreSet )
+{
+    const SfxPoolItem* pItem = nullptr;
+    OUString aName;
+    ::std::optional<sal_uInt16> oNumOffset;
+    bool bPut = true;
+    switch( rCoreSet.GetItemState( RES_PAGEDESC, true, &pItem ) )
+    {
+    case SfxItemState::SET:
+        {
+            if( static_cast<const SwFormatPageDesc*>(pItem)->GetPageDesc() )
+            {
+                aName = static_cast<const SwFormatPageDesc*>(pItem)->GetPageDesc()->GetName();
+                oNumOffset = static_cast<const SwFormatPageDesc*>(pItem)->GetNumOffset();
+            }
+            rCoreSet.ClearItem( RES_PAGEDESC );
+            // Page number
+        }
+        break;
+
+    case SfxItemState::DEFAULT:
+        break;
+
+    default:
+        bPut = false;
+    }
+
+    if (oNumOffset)
+    {
+        SfxUInt16Item aPageNum( SID_ATTR_PARA_PAGENUM, *oNumOffset );
+        rCoreSet.Put( aPageNum );
+    }
+
+    if(bPut)
+        rCoreSet.Put( SvxPageModelItem( aName, true, SID_ATTR_PARA_MODEL ) );
+}
+
+// Determine metric
+
+FieldUnit   GetDfltMetric(bool bWeb)
+{
+    return SW_MOD()->GetUsrPref(bWeb)->GetMetric();
+}
+
+// Determine metric
+
+void    SetDfltMetric( FieldUnit eMetric, bool bWeb )
+{
+    SW_MOD()->ApplyUserMetric(eMetric, bWeb);
+}
+
+void InsertStringSorted(const OUString& rId, const OUString& rEntry, weld::ComboBox& rToFill, int nOffset)
+{
+    CollatorWrapper& rCaseColl = ::GetAppCaseCollator();
+    const int nCount = rToFill.get_count();
+    while (nOffset < nCount)
+    {
+        if (0 < rCaseColl.compareString(rToFill.get_text(nOffset), rEntry))
+            break;
+        ++nOffset;
+    }
+    rToFill.insert(nOffset, rEntry, &rId, nullptr, nullptr);
+}
+
+void FillCharStyleListBox(weld::ComboBox& rToFill, SwDocShell* pDocSh, bool bSorted, bool bWithDefault)
+{
+    const int nOffset = rToFill.get_count() > 0 ? 1 : 0;
+    rToFill.freeze();
+    SfxStyleSheetBasePool* pPool = pDocSh->GetStyleSheetPool();
+    SwDoc* pDoc = pDocSh->GetDoc();
+    const SfxStyleSheetBase* pBase = pPool->First(SfxStyleFamily::Char);
+    const OUString sStandard(SwResId(STR_POOLCHR_STANDARD));
+    while(pBase)
+    {
+        if(bWithDefault || pBase->GetName() !=  sStandard)
+        {
+            sal_IntPtr nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( pBase->GetName(), SwGetPoolIdFromName::ChrFmt );
+            OUString sId(OUString::number(nPoolId));
+            if (bSorted)
+                InsertStringSorted(sId, pBase->GetName(), rToFill, nOffset);
+            else
+                rToFill.append(sId, pBase->GetName());
+        }
+        pBase = pPool->Next();
+    }
+    // non-pool styles
+    const SwCharFormats* pFormats = pDoc->GetCharFormats();
+    for(size_t i = 0; i < pFormats->size(); ++i)
+    {
+        const SwCharFormat* pFormat = (*pFormats)[i];
+        if(pFormat->IsDefault())
+            continue;
+        const OUString& rName = pFormat->GetName();
+        if (rToFill.find_text(rName) == -1)
+        {
+            OUString sId(OUString::number(USHRT_MAX));
+            if (bSorted)
+                InsertStringSorted(sId, rName, rToFill, nOffset);
+            else
+                rToFill.append(sId, rName);
+        }
+    }
+    rToFill.thaw();
+};
+
+SwTwips GetTableWidth( SwFrameFormat const * pFormat, SwTabCols const & rCols, sal_uInt16 *pPercent,
+            SwWrtShell* pSh )
+{
+    // To get the width is slightly more complicated.
+    SwTwips nWidth = 0;
+    const sal_Int16 eOri = pFormat->GetHoriOrient().GetHoriOrient();
+    switch(eOri)
+    {
+        case text::HoriOrientation::FULL: nWidth = rCols.GetRight(); break;
+        case text::HoriOrientation::LEFT_AND_WIDTH:
+        case text::HoriOrientation::LEFT:
+        case text::HoriOrientation::RIGHT:
+        case text::HoriOrientation::CENTER:
+            nWidth = pFormat->GetFrameSize().GetWidth();
+        break;
+        default:
+        {
+            if(pSh)
+            {
+                if ( nullptr == pSh->GetFlyFrameFormat() )
+                {
+                    nWidth = pSh->GetAnyCurRect(CurRectType::PagePrt).Width();
+                }
+                else
+                {
+                    nWidth = pSh->GetAnyCurRect(CurRectType::FlyEmbeddedPrt).Width();
+                }
+            }
+            else
+            {
+                OSL_FAIL("where to get the actual width from?");
+            }
+            const SvxLRSpaceItem& rLRSpace = pFormat->GetLRSpace();
+            nWidth -= (rLRSpace.GetRight() + rLRSpace.GetLeft());
+        }
+    }
+    if (pPercent)
+        *pPercent = pFormat->GetFrameSize().GetWidthPercent();
+    return nWidth;
+}
+
+OUString GetAppLangDateTimeString( const DateTime& rDT )
+{
+    const SvtSysLocale aSysLocale;
+    const LocaleDataWrapper& rAppLclData = aSysLocale.GetLocaleData();
+    OUString sRet = rAppLclData.getDate( rDT ) + " " + rAppLclData.getTime( rDT );
+    return sRet;
+}
+
+// Add a new function which can get and set the current "SID_ATTR_APPLYCHARUNIT" value
+
+bool HasCharUnit( bool bWeb)
+{
+    return SW_MOD()->GetUsrPref(bWeb)->IsApplyCharUnit();
+}
+
+void SetApplyCharUnit(bool bApplyChar, bool bWeb)
+{
+    SW_MOD()->ApplyUserCharUnit(bApplyChar, bWeb);
+}
+
+bool ExecuteMenuCommand( PopupMenu const & rMenu, SfxViewFrame const & rViewFrame, sal_uInt16 nId )
+{
+    bool bRet = false;
+    const sal_uInt16 nItemCount = rMenu.GetItemCount();
+    OUString sCommand;
+    for( sal_uInt16 nItem = 0; nItem < nItemCount; ++nItem)
+    {
+        PopupMenu* pPopup = rMenu.GetPopupMenu( rMenu.GetItemId( nItem ) );
+        if(pPopup)
+        {
+            sCommand = pPopup->GetItemCommand(nId);
+            if(!sCommand.isEmpty())
+                break;
+        }
+    }
+    if(!sCommand.isEmpty())
+    {
+        uno::Reference< frame::XFrame >  xFrame = rViewFrame.GetFrame().GetFrameInterface();
+        uno::Reference < frame::XDispatchProvider > xProv( xFrame, uno::UNO_QUERY );
+        util::URL aURL;
+        aURL.Complete = sCommand;
+        uno::Reference < util::XURLTransformer > xTrans( util::URLTransformer::create(::comphelper::getProcessComponentContext() ) );
+        xTrans->parseStrict( aURL );
+        uno::Reference< frame::XDispatch >  xDisp = xProv->queryDispatch( aURL, OUString(), 0 );
+        if( xDisp.is() )
+        {
+            uno::Sequence< beans::PropertyValue > aSeq;
+            xDisp->dispatch( aURL, aSeq );
+            bRet = true;
+        }
+    }
+    return bRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/unotools.cxx b/sw/source/uibase/utlui/unotools.cxx
new file mode 100644
index 000000000..fbad314f1
--- /dev/null
+++ b/sw/source/uibase/utlui/unotools.cxx
@@ -0,0 +1,510 @@
+/* -*- 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 <swtypes.hxx>
+
+#include <strings.hrc>
+#include <unotools.hxx>
+#include <unoprnms.hxx>
+#include <i18nutil/unicode.hxx>
+#include <svtools/colorcfg.hxx>
+#include <vcl/commandevent.hxx>
+#include <vcl/jobset.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/weld.hxx>
+#include <com/sun/star/frame/Desktop.hpp>
+#include <com/sun/star/text/XTextViewCursorSupplier.hpp>
+#include <com/sun/star/view/XScreenCursor.hpp>
+#include <com/sun/star/view/DocumentZoomType.hpp>
+#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
+#include <com/sun/star/style/XStyle.hpp>
+#include <com/sun/star/text/XTextDocument.hpp>
+#include <com/sun/star/awt/PosSize.hpp>
+#include <com/sun/star/view/XViewSettingsSupplier.hpp>
+#include <com/sun/star/container/XNameContainer.hpp>
+#include <com/sun/star/frame/XLayoutManager.hpp>
+#include <comphelper/processfactory.hxx>
+#include <comphelper/propertysequence.hxx>
+#include <comphelper/servicehelper.hxx>
+#include <docsh.hxx>
+#include <editsh.hxx>
+#include <swmodule.hxx>
+#include <TextCursorHelper.hxx>
+#include <doc.hxx>
+
+using namespace ::com::sun::star;
+
+const char cFactory[] = "private:factory/swriter";
+
+static void disableScrollBars(uno::Reference< beans::XPropertySet > const & xViewProps,
+    bool bEnableOnlineMode)
+{
+    //the scrollbar logic is kind of busted looking in writer, when the hori scrollbar
+    //property is changed then the hori scrollbar is enabled if the property is
+    //true or browse (online) mode is enabled. So...
+    //disable online mode
+    //turn off scrollbars
+    //turn back on online mode if that's what we want
+    //which subverts the (dodgy/buggy) scrollbar setting
+
+    //To reproduce this problem, in edit->autotext and click through
+    //the examples and see if the preview gets a horizontal scrollbar
+    uno::Any aFalseSet(uno::makeAny(false));
+    xViewProps->setPropertyValue(UNO_NAME_SHOW_ONLINE_LAYOUT, aFalseSet);
+
+    xViewProps->setPropertyValue(UNO_NAME_SHOW_HORI_SCROLL_BAR, aFalseSet);
+    xViewProps->setPropertyValue(UNO_NAME_SHOW_VERT_SCROLL_BAR, aFalseSet);
+
+    if (bEnableOnlineMode)
+    {
+        xViewProps->setPropertyValue(UNO_NAME_SHOW_ONLINE_LAYOUT, uno::makeAny(true));
+    }
+}
+
+static const sal_Int16 nZoomValues[] =
+{
+    20,
+    40,
+    50,
+    75,
+    100
+};
+
+SwOneExampleFrame::SwOneExampleFrame(sal_uInt32 nFlags,
+                                 const Link<SwOneExampleFrame&,void>* pInitializedLink,
+                                 const OUString* pURL)
+    : m_aLoadedIdle("sw uibase SwOneExampleFrame Loaded")
+    , m_pModuleView(SW_MOD()->GetView())
+    , m_nStyleFlags(nFlags)
+    , m_bIsInitialized(false)
+{
+    if (pURL && !pURL->isEmpty())
+        m_sArgumentURL = *pURL;
+
+    if( pInitializedLink )
+        m_aInitializedLink = *pInitializedLink;
+
+    // the controller is asynchronously set
+    m_aLoadedIdle.SetInvokeHandler(LINK(this, SwOneExampleFrame, TimeoutHdl));
+    m_aLoadedIdle.SetPriority(TaskPriority::HIGH_IDLE);
+}
+
+void SwOneExampleFrame::SetDrawingArea(weld::DrawingArea* pDrawingArea)
+{
+    CustomWidgetController::SetDrawingArea(pDrawingArea);
+    m_xVirDev = VclPtr<VirtualDevice>::Create();
+    Size aSize(m_xVirDev->LogicToPixel(Size(150, 188), MapMode(MapUnit::MapAppFont)));
+    pDrawingArea->set_size_request(aSize.Width(), aSize.Height());
+    SetOutputSizePixel(aSize);
+    CreateControl();
+}
+
+bool SwOneExampleFrame::Command(const CommandEvent& rCEvt)
+{
+    switch (rCEvt.GetCommand())
+    {
+        case CommandEventId::ContextMenu:
+        {
+            //#125881# quickly clicking crashes because the control is not fully initialized
+            if (m_xController.is())
+                return CreatePopup(rCEvt.GetMousePosPixel());
+        }
+        break;
+        default:;
+        break;
+    }
+    return CustomWidgetController::Command(rCEvt);
+}
+
+void SwOneExampleFrame::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
+{
+    Size aSize(GetOutputSizePixel());
+    // m_xVirDev instead of rRenderContext just to avoid overlays in writer re-triggering
+    // invalidate on rRenderContext if it is a vcl::Window, which is the "classic" gen mode
+    m_xVirDev->SetOutputSizePixel(aSize);
+
+    Color aBgColor = SW_MOD()->GetColorConfig().GetColorValue(::svtools::DOCCOLOR).nColor;
+    m_xVirDev->DrawWallpaper(tools::Rectangle(Point(), aSize), aBgColor);
+
+    auto pCursor = comphelper::getUnoTunnelImplementation<OTextCursorHelper>(m_xCursor);
+    if (pCursor)
+    {
+        uno::Reference<view::XViewSettingsSupplier> xSettings(m_xController, uno::UNO_QUERY);
+        uno::Reference<beans::XPropertySet>  xViewProps = xSettings->getViewSettings();
+        uno::Any aZoom = xViewProps->getPropertyValue(UNO_NAME_ZOOM_VALUE);
+        sal_Int16 nZoom = 100;
+        aZoom >>= nZoom;
+
+        double fZoom = 100.0 / nZoom;
+
+        m_xVirDev->Push(PushFlags::ALL);
+        m_xVirDev->SetMapMode(MapMode(MapUnit::MapTwip));
+        SwDoc *pDoc = pCursor->GetDoc();
+        SwDocShell* pShell = pDoc->GetDocShell();
+        tools::Rectangle aRect(Point(), m_xVirDev->PixelToLogic(aSize));
+        pShell->SetVisArea(tools::Rectangle(Point(), Size(aRect.GetWidth() * fZoom,
+                                                          aRect.GetHeight() * fZoom)));
+        pShell->DoDraw(m_xVirDev.get(), aRect.TopLeft(), aRect.GetSize(), JobSetup(), ASPECT_CONTENT);
+        m_xVirDev->Pop();
+    }
+
+    rRenderContext.DrawOutDev(Point(), aSize, Point(), aSize, *m_xVirDev);
+}
+
+SwOneExampleFrame::~SwOneExampleFrame()
+{
+    DisposeControl();
+}
+
+void SwOneExampleFrame::CreateControl()
+{
+    // create new doc
+    OUString sTempURL(cFactory);
+    if(!m_sArgumentURL.isEmpty())
+        sTempURL = m_sArgumentURL;
+
+    uno::Reference<frame::XDesktop2> xDesktop = frame::Desktop::create(::comphelper::getProcessComponentContext());
+    uno::Sequence<beans::PropertyValue> args( comphelper::InitPropertySequence({
+            { "DocumentService", uno::Any(OUString("com.sun.star.text.TextDocument")) },
+            { "OpenFlags", uno::Any(OUString("-RB")) },
+            { "Referer", uno::Any(OUString("private:user")) },
+            { "ReadOnly", uno::Any(true) },
+            { "Hidden", uno::Any(true) }
+        }));
+
+    m_xModel.set(xDesktop->loadComponentFromURL(sTempURL, "_blank", 0, args), uno::UNO_QUERY);
+
+    m_aLoadedIdle.Start();
+}
+
+void SwOneExampleFrame::DisposeControl()
+{
+    m_aLoadedIdle.Stop();
+    m_xCursor = nullptr;
+    if (m_xModel)
+    {
+        m_xModel->dispose();
+        m_xModel = nullptr;
+    }
+    m_xController = nullptr;
+}
+
+IMPL_LINK( SwOneExampleFrame, TimeoutHdl, Timer*, pTimer, void )
+{
+    if (!m_xModel.is())
+        return;
+
+    m_xController = m_xModel->getCurrentController();
+
+    if (m_xController.is())
+    {
+        uno::Reference<frame::XFrame> xFrame = m_xController->getFrame();
+        uno::Reference< beans::XPropertySet > xPropSet( xFrame, uno::UNO_QUERY );
+        if ( xPropSet.is() )
+        {
+            try
+            {
+                uno::Reference< frame::XLayoutManager > xLayoutManager;
+                uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
+                aValue >>= xLayoutManager;
+                if ( xLayoutManager.is() )
+                    xLayoutManager->setVisible( false );
+            }
+            catch (const uno::Exception&)
+            {
+            }
+        }
+
+        //now the ViewOptions should be set properly
+        uno::Reference< view::XViewSettingsSupplier >  xSettings(m_xController, uno::UNO_QUERY);
+        uno::Reference< beans::XPropertySet >  xViewProps = xSettings->getViewSettings();
+
+        const uno::Any aTrueSet( true );
+        const uno::Any aFalseSet( false );
+
+        if( !m_bIsInitialized )
+        {
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_BREAKS, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_DRAWINGS, aTrueSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_FIELD_COMMANDS, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_GRAPHICS, aTrueSet);
+            xViewProps->setPropertyValue(UNO_NAME_HIDE_WHITESPACE, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_HIDDEN_PARAGRAPHS, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_HIDDEN_TEXT, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_HORI_RULER, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_PARA_BREAKS, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_PROTECTED_SPACES, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_SOFT_HYPHENS, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_SPACES, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_TABLES, aTrueSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_TABSTOPS, aFalseSet);
+            xViewProps->setPropertyValue(UNO_NAME_SHOW_VERT_RULER, aFalseSet);
+
+            if(0 ==(m_nStyleFlags&EX_SHOW_ONLINE_LAYOUT))
+            {
+                uno::Any aZoom;
+                aZoom <<= sal_Int16(view::DocumentZoomType::PAGE_WIDTH_EXACT);
+                xViewProps->setPropertyValue(UNO_NAME_ZOOM_TYPE, aZoom);
+            }
+            else
+            {
+                uno::Any aZoom;
+                aZoom <<= sal_Int16(view::DocumentZoomType::BY_VALUE);
+                xViewProps->setPropertyValue(UNO_NAME_ZOOM_TYPE, aZoom);
+
+                sal_Int16 nZoomValue = 75;
+                if(EX_SHOW_BUSINESS_CARDS == m_nStyleFlags)
+                {
+                    nZoomValue = 80;
+                }
+                aZoom <<= nZoomValue;
+                xViewProps->setPropertyValue(UNO_NAME_ZOOM_VALUE, aZoom);
+            }
+
+            // set onlinelayout property after setting the zoom
+            disableScrollBars(xViewProps, (m_nStyleFlags&EX_SHOW_ONLINE_LAYOUT) != 0);
+            m_bIsInitialized = true;
+        }
+
+        uno::Reference< text::XTextDocument >  xDoc(m_xModel, uno::UNO_QUERY);
+        uno::Reference< text::XText >  xText = xDoc->getText();
+        m_xCursor = xText->createTextCursor();
+
+        //From here, a cursor is defined, which goes through the template,
+        //and overwrites the template words where it is necessary.
+
+        auto pCursor = comphelper::getUnoTunnelImplementation<OTextCursorHelper>(m_xCursor);
+
+        SwDoc *pDoc = pCursor ? pCursor->GetDoc() : nullptr;
+        if (pDoc && (m_nStyleFlags & EX_LOCALIZE_TOC_STRINGS))
+        {
+            SwEditShell* pSh = pDoc->GetEditShell();
+
+            do
+            {
+              if (pSh->GetCurWord() == "HEADING1")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_HEADING1));
+              }
+              else if (pSh->GetCurWord() == "ENTRY1")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_ENTRY1));
+              }
+              else if (pSh->GetCurWord() == "HEADING11")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_HEADING11));
+              }
+              else if (pSh->GetCurWord() == "ENTRY11")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_ENTRY11));
+              }
+              else if (pSh->GetCurWord() == "HEADING12")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_HEADING12));
+              }
+              else if (pSh->GetCurWord() == "ENTRY12")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_ENTRY12));
+              }
+              else if (pSh->GetCurWord() == "TABLE1")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_TABLE1));
+              }
+              else if (pSh->GetCurWord() == "IMAGE1")
+              {
+                pSh->Overwrite(SwResId(STR_IDXEXAMPLE_IDXTXT_IMAGE1));
+              }
+            }
+            while(pSh->Right(sal_uInt16(1), sal_uInt16(1), true));
+
+            TOXTypes eTypes[] = { TOX_INDEX, TOX_USER, TOX_CONTENT };
+            for (auto eType : eTypes)
+            {
+                const SwTOXType* pTOXType = pDoc->GetTOXType(eType, 0);
+                SwTOXMarks aMarks;
+                SwTOXMark::InsertTOXMarks(aMarks, *pTOXType);
+                for (auto pMark : aMarks)
+                {
+                    if (pMark->GetAlternativeText() == "Chapter")
+                        pMark->SetAlternativeText(SwResId(STR_IDXEXAMPLE_IDXMARK_CHAPTER));
+                    else if (pMark->GetAlternativeText() == "Keyword")
+                        pMark->SetAlternativeText(SwResId(STR_IDXEXAMPLE_IDXMARK_KEYWORD));
+                    else if (pMark->GetAlternativeText() == "this")
+                        pMark->SetAlternativeText(SwResId(STR_IDXEXAMPLE_IDXMARK_THIS));
+                    else if (pMark->GetAlternativeText() == "User Directory Entry")
+                        pMark->SetAlternativeText(SwResId(STR_IDXEXAMPLE_IDXMARK_USER_DIR_ENTRY));
+                    else if (pMark->GetAlternativeText() == "Entry")
+                        pMark->SetAlternativeText(SwResId(STR_IDXEXAMPLE_IDXMARK_ENTRY));
+
+                    if (pMark->GetPrimaryKey() == "Primary key")
+                        pMark->SetPrimaryKey(SwResId(STR_IDXEXAMPLE_IDXMARK_PRIMARY_KEY));
+
+                    if (pMark->GetSecondaryKey() == "Secondary key")
+                        pMark->SetSecondaryKey(SwResId(STR_IDXEXAMPLE_IDXMARK_SECONDARY_KEY));
+                }
+            }
+        }
+
+        uno::Reference< beans::XPropertySet >  xCursorProp(m_xCursor, uno::UNO_QUERY);
+        uno::Any aPageStyle = xCursorProp->getPropertyValue(UNO_NAME_PAGE_STYLE_NAME);
+        OUString sPageStyle;
+        aPageStyle >>= sPageStyle;
+
+        uno::Reference< style::XStyleFamiliesSupplier >  xSSupp( xDoc, uno::UNO_QUERY);
+        uno::Reference< container::XNameAccess >  xStyles = xSSupp->getStyleFamilies();
+        uno::Any aPFamily = xStyles->getByName( "PageStyles" );
+        uno::Reference< container::XNameContainer >  xPFamily;
+
+        if( EX_SHOW_DEFAULT_PAGE != m_nStyleFlags
+                && (aPFamily >>= xPFamily) && !sPageStyle.isEmpty() )
+        {
+            uno::Any aPStyle = xPFamily->getByName( sPageStyle );
+            uno::Reference< style::XStyle >  xPStyle;
+            aPStyle >>= xPStyle;
+            uno::Reference< beans::XPropertySet >  xPProp(xPStyle, uno::UNO_QUERY);
+            uno::Any aSize = xPProp->getPropertyValue(UNO_NAME_SIZE);
+            awt::Size aPSize;
+            aSize >>= aPSize;
+            //TODO: set page width to card width
+            aPSize.Width = 10000;
+            aSize <<= aPSize;
+            xPProp->setPropertyValue(UNO_NAME_SIZE, aSize);
+
+            uno::Any aZero; aZero <<= sal_Int32(0);
+            xPProp->setPropertyValue(UNO_NAME_LEFT_MARGIN, aZero);
+            xPProp->setPropertyValue(UNO_NAME_RIGHT_MARGIN, aZero);
+        }
+
+        uno::Reference<awt::XWindow> xWin = xFrame->getContainerWindow();
+        Size aWinSize(GetOutputSizePixel());
+        xWin->setPosSize(0, 0, aWinSize.Width(), aWinSize.Height(), awt::PosSize::SIZE);
+
+        // can only be done here - the SFX changes the ScrollBar values
+        disableScrollBars(xViewProps, (m_nStyleFlags&EX_SHOW_ONLINE_LAYOUT) != 0);
+
+        m_aInitializedLink.Call(*this);
+
+        uno::Reference< text::XTextViewCursorSupplier >  xCursorSupp(m_xController, uno::UNO_QUERY);
+        uno::Reference< view::XScreenCursor >  xScrCursor(xCursorSupp->getViewCursor(), uno::UNO_QUERY);
+        if(xScrCursor.is())
+            xScrCursor->screenUp();
+
+        if (pDoc)
+        {
+            SwEditShell* pSh = pDoc->GetEditShell();
+            if( pSh->ActionCount() )
+            {
+                pSh->EndAllAction();
+                pSh->UnlockPaint();
+            }
+        }
+
+        SW_MOD()->SetView(m_pModuleView);
+
+        Invalidate();
+    }
+    else
+        pTimer->Start();
+}
+
+void SwOneExampleFrame::ClearDocument()
+{
+    uno::Reference< lang::XUnoTunnel> xTunnel( m_xCursor, uno::UNO_QUERY);
+    if( xTunnel.is() )
+    {
+        OTextCursorHelper* pCursor = reinterpret_cast<OTextCursorHelper*>(xTunnel->getSomething(
+                                        OTextCursorHelper::getUnoTunnelId()) );
+        if( pCursor )
+        {
+            SwDoc* pDoc = pCursor->GetDoc();
+            SwEditShell* pSh = pDoc->GetEditShell();
+            pSh->LockPaint();
+            pSh->StartAllAction();
+            pSh->KillPams();
+            pSh->ClearMark();
+            pDoc->ClearDoc();
+            pSh->ClearUpCursors();
+
+            if( m_aLoadedIdle.IsActive())
+            {
+                pSh->EndAllAction();
+                pSh->UnlockPaint();
+            }
+            m_aLoadedIdle.Start();
+        }
+        else
+        {
+            m_xCursor->gotoStart(false);
+            m_xCursor->gotoEnd(true);
+            m_xCursor->setString(OUString());
+        }
+    }
+}
+
+bool SwOneExampleFrame::CreatePopup(const Point& rPt)
+{
+    if (EX_SHOW_ONLINE_LAYOUT != m_nStyleFlags)
+        return false;
+
+    std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(nullptr, "modules/swriter/ui/previewmenu.ui"));
+    std::unique_ptr<weld::Menu> xPop(xBuilder->weld_menu("previewmenu"));
+
+    uno::Reference< view::XViewSettingsSupplier >  xSettings(m_xController, uno::UNO_QUERY);
+    uno::Reference< beans::XPropertySet >  xViewProps = xSettings->getViewSettings();
+
+    uno::Any aZoom = xViewProps->getPropertyValue(UNO_NAME_ZOOM_VALUE);
+    sal_Int16 nZoom = 0;
+    aZoom >>= nZoom;
+
+    for (size_t i = 0; i < SAL_N_ELEMENTS(nZoomValues); ++i)
+    {
+        OUString sTemp = unicode::formatPercent(nZoomValues[i],
+            Application::GetSettings().GetUILanguageTag());
+        OString sIdent = "zoom" + OString::number(nZoomValues[i]);
+        xPop->set_label(sIdent, sTemp);
+        if (nZoom == nZoomValues[i])
+            xPop->set_active(sIdent, true);
+    }
+
+    PopupHdl(xPop->popup_at_rect(GetDrawingArea(), tools::Rectangle(rPt, Size(1, 1))));
+
+    return true;
+}
+
+void SwOneExampleFrame::PopupHdl(const OString& rId)
+{
+    OString sZoomValue;
+    if (rId.startsWith("zoom", &sZoomValue))
+    {
+        sal_Int16 nZoom = sZoomValue.toInt32();
+        uno::Reference< view::XViewSettingsSupplier >  xSettings(m_xController, uno::UNO_QUERY);
+        uno::Reference< beans::XPropertySet >  xViewProps = xSettings->getViewSettings();
+
+        uno::Any aZoom;
+        aZoom <<= nZoom;
+        xViewProps->setPropertyValue(UNO_NAME_ZOOM_VALUE, aZoom);
+        aZoom <<= sal_Int16(view::DocumentZoomType::BY_VALUE);
+        xViewProps->setPropertyValue(UNO_NAME_ZOOM_TYPE, aZoom);
+    }
+    Invalidate();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/viewlayoutctrl.cxx b/sw/source/uibase/utlui/viewlayoutctrl.cxx
new file mode 100644
index 000000000..bdb18bbb3
--- /dev/null
+++ b/sw/source/uibase/utlui/viewlayoutctrl.cxx
@@ -0,0 +1,197 @@
+/* -*- 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 <viewlayoutctrl.hxx>
+
+#include <com/sun/star/beans/PropertyValue.hpp>
+#include <vcl/event.hxx>
+#include <vcl/status.hxx>
+#include <vcl/image.hxx>
+#include <svx/viewlayoutitem.hxx>
+#include <strings.hrc>
+#include <bitmaps.hlst>
+#include <swtypes.hxx>
+
+SFX_IMPL_STATUSBAR_CONTROL( SwViewLayoutControl, SvxViewLayoutItem );
+
+struct SwViewLayoutControl::SwViewLayoutControl_Impl
+{
+    sal_uInt16      mnState; // 0 = auto, 1= single, 2 = book, 3 = none
+    Image       maImageSingleColumn;
+    Image       maImageSingleColumn_Active;
+    Image       maImageAutomatic;
+    Image       maImageAutomatic_Active;
+    Image       maImageBookMode;
+    Image       maImageBookMode_Active;
+};
+
+SwViewLayoutControl::SwViewLayoutControl( sal_uInt16 _nSlotId, sal_uInt16 _nId, StatusBar& rStatusBar ) :
+    SfxStatusBarControl( _nSlotId, _nId, rStatusBar ),
+    mpImpl( new SwViewLayoutControl_Impl )
+{
+    mpImpl->mnState = 1;
+
+    mpImpl->maImageSingleColumn         = Image(StockImage::Yes, RID_BMP_VIEWLAYOUT_SINGLECOLUMN);
+    mpImpl->maImageSingleColumn_Active  = Image(StockImage::Yes, RID_BMP_VIEWLAYOUT_SINGLECOLUMN_ACTIVE);
+    mpImpl->maImageAutomatic            = Image(StockImage::Yes, RID_BMP_VIEWLAYOUT_AUTOMATIC);
+    mpImpl->maImageAutomatic_Active     = Image(StockImage::Yes, RID_BMP_VIEWLAYOUT_AUTOMATIC_ACTIVE);
+    mpImpl->maImageBookMode             = Image(StockImage::Yes, RID_BMP_VIEWLAYOUT_BOOKMODE);
+    mpImpl->maImageBookMode_Active      = Image(StockImage::Yes, RID_BMP_VIEWLAYOUT_BOOKMODE_ACTIVE);
+}
+
+SwViewLayoutControl::~SwViewLayoutControl()
+{
+}
+
+void SwViewLayoutControl::StateChanged( sal_uInt16 /*nSID*/, SfxItemState eState, const SfxPoolItem* pState )
+{
+    if ( SfxItemState::DEFAULT != eState || pState->IsVoidItem() )
+        GetStatusBar().SetItemText( GetId(), OUString() );
+    else
+    {
+        OSL_ENSURE( dynamic_cast< const SvxViewLayoutItem *>( pState ) !=  nullptr, "invalid item type" );
+        const sal_uInt16 nColumns  = static_cast<const SvxViewLayoutItem*>( pState )->GetValue();
+        const bool   bBookMode = static_cast<const SvxViewLayoutItem*>( pState )->IsBookMode();
+
+        // SingleColumn Mode
+        if ( 1 == nColumns )
+            mpImpl->mnState = 0;
+        // Automatic Mode
+        else if ( 0 == nColumns )
+            mpImpl->mnState = 1;
+        // Book Mode
+        else if ( bBookMode && 2 == nColumns )
+            mpImpl->mnState = 2;
+        else
+            mpImpl->mnState = 3;
+    }
+
+    GetStatusBar().SetItemData( GetId(), nullptr );    // force repaint
+}
+
+void SwViewLayoutControl::Paint( const UserDrawEvent& rUsrEvt )
+{
+    vcl::RenderContext* pDev = rUsrEvt.GetRenderContext();
+    tools::Rectangle aRect(rUsrEvt.GetRect());
+
+    const tools::Rectangle aControlRect = getControlRect();
+
+    const bool bSingleColumn    = 0 == mpImpl->mnState;
+    const bool bAutomatic       = 1 == mpImpl->mnState;
+    const bool bBookMode        = 2 == mpImpl->mnState;
+
+    const long nImageWidthSum = mpImpl->maImageSingleColumn.GetSizePixel().Width() +
+                                mpImpl->maImageAutomatic.GetSizePixel().Width() +
+                                mpImpl->maImageBookMode.GetSizePixel().Width();
+
+    const long nXOffset = (aRect.GetWidth() - nImageWidthSum) / 2;
+    const long nYOffset = (aControlRect.GetHeight() - mpImpl->maImageSingleColumn.GetSizePixel().Height()) / 2;
+
+    aRect.AdjustLeft( nXOffset );
+    aRect.AdjustTop( nYOffset );
+
+    // draw single column image:
+    pDev->DrawImage( aRect.TopLeft(), bSingleColumn ? mpImpl->maImageSingleColumn_Active : mpImpl->maImageSingleColumn );
+
+    // draw automatic image:
+    aRect.AdjustLeft(mpImpl->maImageSingleColumn.GetSizePixel().Width() );
+    pDev->DrawImage( aRect.TopLeft(), bAutomatic ? mpImpl->maImageAutomatic_Active       : mpImpl->maImageAutomatic );
+
+    // draw bookmode image:
+    aRect.AdjustLeft(mpImpl->maImageAutomatic.GetSizePixel().Width() );
+    pDev->DrawImage( aRect.TopLeft(), bBookMode ? mpImpl->maImageBookMode_Active         : mpImpl->maImageBookMode );
+}
+
+bool SwViewLayoutControl::MouseButtonDown( const MouseEvent & rEvt )
+{
+    const tools::Rectangle aRect = getControlRect();
+    const Point aPoint = rEvt.GetPosPixel();
+    const long nXDiff = aPoint.X() - aRect.Left();
+
+    sal_uInt16 nColumns = 1;
+    bool bBookMode = false;
+
+    const long nImageWidthSingle = mpImpl->maImageSingleColumn.GetSizePixel().Width();
+    const long nImageWidthAuto = mpImpl->maImageAutomatic.GetSizePixel().Width();
+    const long nImageWidthBook = mpImpl->maImageBookMode.GetSizePixel().Width();
+    const long nImageWidthSum = nImageWidthSingle + nImageWidthAuto + nImageWidthBook;
+
+    const long nXOffset = (aRect.GetWidth() - nImageWidthSum)/2;
+
+    if ( nXDiff < nXOffset + nImageWidthSingle )
+    {
+        mpImpl->mnState = 0; // single
+        nColumns = 1;
+    }
+    else if ( nXDiff < nXOffset + nImageWidthSingle + nImageWidthAuto )
+    {
+        mpImpl->mnState = 1; // auto
+        nColumns = 0;
+    }
+    else
+    {
+        mpImpl->mnState = 2; // book
+        nColumns = 2;
+        bBookMode = true;
+    }
+
+    // commit state change
+    SvxViewLayoutItem aViewLayout( nColumns, bBookMode );
+
+    css::uno::Any a;
+    aViewLayout.QueryValue( a );
+
+    css::uno::Sequence< css::beans::PropertyValue > aArgs( 1 );
+    aArgs[0].Name = "ViewLayout";
+    aArgs[0].Value = a;
+
+    execute( aArgs );
+
+    return true;
+}
+
+bool SwViewLayoutControl::MouseMove( const MouseEvent & rEvt )
+{
+    const tools::Rectangle aRect = getControlRect();
+    const Point aPoint = rEvt.GetPosPixel();
+    const long nXDiff = aPoint.X() - aRect.Left();
+
+    const long nImageWidthSingle = mpImpl->maImageSingleColumn.GetSizePixel().Width();
+    const long nImageWidthAuto = mpImpl->maImageAutomatic.GetSizePixel().Width();
+    const long nImageWidthBook = mpImpl->maImageBookMode.GetSizePixel().Width();
+    const long nImageWidthSum = nImageWidthSingle + nImageWidthAuto + nImageWidthBook;
+
+    const long nXOffset = (aRect.GetWidth() - nImageWidthSum)/2;
+
+    if ( nXDiff < nXOffset + nImageWidthSingle )
+    {
+        GetStatusBar().SetQuickHelpText(GetId(), SwResId(STR_VIEWLAYOUT_ONE));
+    }
+    else if ( nXDiff < nXOffset + nImageWidthSingle + nImageWidthAuto )
+    {
+        GetStatusBar().SetQuickHelpText(GetId(), SwResId(STR_VIEWLAYOUT_MULTI));
+    }
+    else
+    {
+        GetStatusBar().SetQuickHelpText(GetId(), SwResId(STR_VIEWLAYOUT_BOOK));
+    }
+    return true;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/wordcountctrl.cxx b/sw/source/uibase/utlui/wordcountctrl.cxx
new file mode 100644
index 000000000..93eba3c73
--- /dev/null
+++ b/sw/source/uibase/utlui/wordcountctrl.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 <swtypes.hxx>
+#include <strings.hrc>
+#include <wordcountctrl.hxx>
+#include <svl/stritem.hxx>
+#include <vcl/status.hxx>
+
+SFX_IMPL_STATUSBAR_CONTROL(SwWordCountStatusBarControl, SfxStringItem);
+
+SwWordCountStatusBarControl::SwWordCountStatusBarControl(
+        sal_uInt16 _nSlotId,
+        sal_uInt16 _nId,
+        StatusBar& rStb) :
+    SfxStatusBarControl(_nSlotId, _nId, rStb)
+{
+}
+
+SwWordCountStatusBarControl::~SwWordCountStatusBarControl()
+{
+}
+
+void SwWordCountStatusBarControl::StateChanged(
+    sal_uInt16 /*nSID*/, SfxItemState eState, const SfxPoolItem* pState )
+{
+    if (eState == SfxItemState::DEFAULT) // Can access pState
+        GetStatusBar().SetItemText( GetId(), static_cast<const SfxStringItem*>(pState)->GetValue() );
+
+    GetStatusBar().SetQuickHelpText(GetId(), SwResId(STR_WORDCOUNT_HINT));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sw/source/uibase/utlui/zoomctrl.cxx b/sw/source/uibase/utlui/zoomctrl.cxx
new file mode 100644
index 000000000..493b2f9b7
--- /dev/null
+++ b/sw/source/uibase/utlui/zoomctrl.cxx
@@ -0,0 +1,65 @@
+/* -*- 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/status.hxx>
+#include <svl/stritem.hxx>
+#include <sfx2/zoomitem.hxx>
+
+#include <zoomctrl.hxx>
+
+SFX_IMPL_STATUSBAR_CONTROL( SwZoomControl, SvxZoomItem );
+
+SwZoomControl::SwZoomControl( sal_uInt16 _nSlotId,
+                              sal_uInt16 _nId,
+                              StatusBar& rStb ) :
+    SvxZoomStatusBarControl( _nSlotId, _nId, rStb )
+{
+}
+
+SwZoomControl::~SwZoomControl()
+{
+}
+
+void SwZoomControl::StateChanged( sal_uInt16 nSID, SfxItemState eState,
+                                  const SfxPoolItem* pState )
+{
+    const SfxStringItem* pItem = nullptr;
+    if (SfxItemState::DEFAULT == eState && (pItem = dynamic_cast<const SfxStringItem*>(pState)))
+    {
+        sPreviewZoom = pItem->GetValue();
+        GetStatusBar().SetItemText(GetId(), sPreviewZoom);
+    }
+    else
+    {
+        sPreviewZoom.clear();
+        SvxZoomStatusBarControl::StateChanged(nSID, eState, pState);
+    }
+}
+
+void SwZoomControl::Paint( const UserDrawEvent& )
+{
+}
+
+void SwZoomControl::Command( const CommandEvent& rCEvt )
+{
+    if (sPreviewZoom.isEmpty())
+        SvxZoomStatusBarControl::Command(rCEvt);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */