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

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

1 files changed, 2595 insertions, 0 deletions

diff --git a/cui/source/tabpages/paragrph.cxx b/cui/source/tabpages/paragrph.cxx
new file mode 100644
index 0000000000..132b125f02
--- /dev/null
+++ b/cui/source/tabpages/paragrph.cxx
@@ -0,0 +1,2595 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <memory>
+#include <osl/diagnose.h>
+#include <svl/style.hxx>
+#include <sfx2/objsh.hxx>
+#include <vcl/mnemonic.hxx>
+#include <vcl/settings.hxx>
+#include <svx/flagsdef.hxx>
+#include <svx/svxids.hrc>
+#include <svx/sdtaitm.hxx>
+
+#include <svl/cjkoptions.hxx>
+#include <editeng/pgrditem.hxx>
+#include <svx/strings.hrc>
+#include <svx/dialmgr.hxx>
+#include <paragrph.hxx>
+#include <editeng/frmdiritem.hxx>
+#include <editeng/lspcitem.hxx>
+#include <editeng/adjustitem.hxx>
+#include <editeng/orphitem.hxx>
+#include <editeng/widwitem.hxx>
+#include <editeng/tstpitem.hxx>
+#include <editeng/pmdlitem.hxx>
+#include <editeng/spltitem.hxx>
+#include <editeng/hyphenzoneitem.hxx>
+#include <editeng/ulspitem.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/formatbreakitem.hxx>
+#include <editeng/keepitem.hxx>
+#include <editeng/scriptspaceitem.hxx>
+#include <editeng/hngpnctitem.hxx>
+#include <editeng/forbiddenruleitem.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <i18nlangtag/mslangid.hxx>
+#include <svx/dlgutil.hxx>
+#include <sfx2/htmlmode.hxx>
+#include <editeng/paravertalignitem.hxx>
+#include <svl/eitem.hxx>
+#include <svl/intitem.hxx>
+#include <unotools/syslocaleoptions.hxx>
+
+const WhichRangesContainer SvxStdParagraphTabPage::pStdRanges(
+    svl::Items<
+    SID_ATTR_PARA_LINESPACE, SID_ATTR_PARA_LINESPACE, // 10033
+    SID_ATTR_PARA_LEFTSPACE, SID_ATTR_PARA_FIRSTLINESPACE,
+    SID_ATTR_LRSPACE, SID_ATTR_ULSPACE,              // 10048 - 10049
+    SID_ATTR_PARA_REGISTER, SID_ATTR_PARA_REGISTER  // 10413
+    >);
+
+const WhichRangesContainer SvxParaAlignTabPage::pAlignRanges(
+    svl::Items<
+    SID_ATTR_PARA_ADJUST, SID_ATTR_PARA_ADJUST, // 10027
+    // tdf#154543 - reset snap to grid to parent
+    SID_ATTR_PARA_SNAPTOGRID, SID_ATTR_PARA_SNAPTOGRID // 10945
+    >);
+
+const WhichRangesContainer SvxParaAlignTabPage::pSdrAlignRanges(
+    svl::Items<
+    SDRATTR_TEXT_VERTADJUST, SDRATTR_TEXT_VERTADJUST, // 1076
+    SID_ATTR_PARA_ADJUST, SID_ATTR_PARA_ADJUST ,      // 10027
+    SID_ATTR_FRAMEDIRECTION, SID_ATTR_FRAMEDIRECTION  // 10944
+    >);
+
+const WhichRangesContainer SvxExtParagraphTabPage::pExtRanges(svl::Items<
+    SID_ATTR_PARA_PAGEBREAK, SID_ATTR_PARA_WIDOWS, // 10037 - 10041
+    SID_ATTR_PARA_MODEL, SID_ATTR_PARA_KEEP        // 10065 - 10066
+>);
+
+#define MAX_DURCH 31680     // tdf#68335: 1584 pt for UX interoperability with Word
+#define FIX_DIST_DEF 283    // standard fix distance 0,5 cm
+
+namespace {
+
+enum LineSpaceList
+{
+    LLINESPACE_1    = 0,
+    LLINESPACE_115  = 1,
+    LLINESPACE_15   = 2,
+    LLINESPACE_2    = 3,
+    LLINESPACE_PROP = 4,
+    LLINESPACE_MIN  = 5,
+    LLINESPACE_DURCH= 6,
+    LLINESPACE_FIX  = 7
+};
+
+}
+
+static void SetLineSpace_Impl( SvxLineSpacingItem&, int, tools::Long lValue = 0 );
+
+void SetLineSpace_Impl( SvxLineSpacingItem& rLineSpace,
+                        int eSpace, tools::Long lValue )
+{
+    switch ( eSpace )
+    {
+        case LLINESPACE_1:
+            rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto );
+            rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off );
+            break;
+
+        case LLINESPACE_115:
+            rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto );
+            rLineSpace.SetPropLineSpace( 115 );
+            break;
+
+        case LLINESPACE_15:
+            rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto );
+            rLineSpace.SetPropLineSpace( 150 );
+            break;
+
+        case LLINESPACE_2:
+            rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto );
+            rLineSpace.SetPropLineSpace( 200 );
+            break;
+
+        case LLINESPACE_PROP:
+            rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto );
+            rLineSpace.SetPropLineSpace( static_cast<sal_uInt16>(lValue) );
+            break;
+
+        case LLINESPACE_MIN:
+            rLineSpace.SetLineHeight( static_cast<sal_uInt16>(lValue) );
+            rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off );
+            break;
+
+        case LLINESPACE_DURCH:
+            rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto );
+            rLineSpace.SetInterLineSpace( static_cast<sal_uInt16>(lValue) );
+            break;
+
+        case LLINESPACE_FIX:
+            rLineSpace.SetLineHeight(static_cast<sal_uInt16>(lValue));
+            rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Fix );
+            rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off );
+        break;
+    }
+}
+
+static sal_uInt16 GetHtmlMode_Impl(const SfxItemSet& rSet)
+{
+    sal_uInt16 nHtmlMode = 0;
+    const SfxUInt16Item* pItem = rSet.GetItemIfSet(SID_HTML_MODE, false);
+    if (!pItem)
+    {
+        if (SfxObjectShell* pShell = SfxObjectShell::Current())
+            pItem = pShell->GetItem(SID_HTML_MODE);
+    }
+    if(pItem)
+    {
+        nHtmlMode = pItem->GetValue();
+    }
+    return nHtmlMode;
+
+}
+
+void SvxStdParagraphTabPage::ELRLoseFocus()
+{
+    SfxItemPool* pPool = GetItemSet().GetPool();
+    DBG_ASSERT( pPool, "Where is the pool?" );
+    FieldUnit eUnit =
+        MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
+
+    sal_Int64 nL = m_aLeftIndent.denormalize(m_aLeftIndent.get_value(eUnit));
+    sal_Int64 nR = m_aRightIndent.denormalize(m_aRightIndent.get_value(eUnit));
+    OUString aTmp = m_aFLineIndent.get_text();
+
+    if (m_aLeftIndent.get_min(FieldUnit::NONE) < 0)
+        m_aFLineIndent.set_min(-99999, FieldUnit::MM);
+    else
+        m_aFLineIndent.set_min(m_aFLineIndent.normalize(-nL), eUnit);
+
+    // Check only for concrete width (Shell)
+    sal_Int64 nTmp = nWidth - nL - nR - MM50;
+    m_aFLineIndent.set_max(m_aFLineIndent.normalize(nTmp), eUnit);
+
+    if (aTmp.isEmpty())
+        m_aFLineIndent.set_text(OUString());
+    // maximum left right
+    aTmp = m_aLeftIndent.get_text();
+    nTmp = nWidth - nR - MM50;
+    m_aLeftIndent.set_max(m_aLeftIndent.normalize(nTmp), eUnit);
+
+    if ( aTmp.isEmpty() )
+        m_aLeftIndent.set_text(OUString());
+    aTmp = m_aRightIndent.get_text();
+    nTmp = nWidth - nL - MM50;
+    m_aRightIndent.set_max(m_aRightIndent.normalize(nTmp), eUnit);
+
+    if ( aTmp.isEmpty() )
+        m_aRightIndent.set_text(OUString());
+
+    UpdateExample_Impl();
+}
+
+IMPL_LINK_NOARG(SvxStdParagraphTabPage, ELRLoseFocusHdl, weld::MetricSpinButton&, void)
+{
+    ELRLoseFocus();
+}
+
+std::unique_ptr<SfxTabPage> SvxStdParagraphTabPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet)
+{
+    return std::make_unique<SvxStdParagraphTabPage>(pPage, pController, *rSet);
+}
+
+bool SvxStdParagraphTabPage::FillItemSet( SfxItemSet* rOutSet )
+{
+    const SfxPoolItem* pOld = nullptr;
+    SfxItemPool* pPool = rOutSet->GetPool();
+    DBG_ASSERT( pPool, "Where is the pool?" );
+
+    bool bModified = false;
+    sal_uInt16 nWhich;
+    int nPos = m_xLineDist->get_active();
+
+    if ( nPos != -1 &&
+         ( m_bLineDistToggled ||
+           m_xLineDist->get_value_changed_from_saved() ||
+           m_xLineDistAtPercentBox->get_value_changed_from_saved() ||
+           m_xLineDistAtMetricBox->get_value_changed_from_saved() ) )
+    {
+        nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
+        MapUnit eUnit = pPool->GetMetric( nWhich );
+        SvxLineSpacingItem aSpacing(
+            static_cast<const SvxLineSpacingItem&>(GetItemSet().Get( nWhich )) );
+
+        switch ( nPos )
+        {
+            case LLINESPACE_1:
+            case LLINESPACE_115:
+            case LLINESPACE_15:
+            case LLINESPACE_2:
+                SetLineSpace_Impl( aSpacing, nPos );
+                break;
+
+            case LLINESPACE_PROP:
+                SetLineSpace_Impl( aSpacing, nPos,
+                                   static_cast<tools::Long>(m_xLineDistAtPercentBox->denormalize(
+                                   m_xLineDistAtPercentBox->get_value(FieldUnit::NONE) )) );
+                break;
+
+            case LLINESPACE_MIN:
+            case LLINESPACE_DURCH:
+            case LLINESPACE_FIX:
+                SetLineSpace_Impl( aSpacing, nPos,
+                    GetCoreValue( *m_xLineDistAtMetricBox, eUnit ) );
+            break;
+
+            default:
+                OSL_FAIL( "unknown LineDist entry" );
+                break;
+        }
+        pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_LINESPACE );
+
+        if ( m_bLineDistToggled ||
+             !pOld || !( *static_cast<const SvxLineSpacingItem*>(pOld) == aSpacing ) ||
+             SfxItemState::DONTCARE == GetItemSet().GetItemState( nWhich ) )
+        {
+            rOutSet->Put( aSpacing );
+            bModified = true;
+        }
+    }
+
+    if ( m_aTopDist.get_value_changed_from_saved() || m_aBottomDist.get_value_changed_from_saved()
+         || m_xContextualCB->get_state_changed_from_saved())
+    {
+        nWhich = GetWhich( SID_ATTR_ULSPACE );
+        MapUnit eUnit = pPool->GetMetric( nWhich );
+        pOld = GetOldItem( *rOutSet, SID_ATTR_ULSPACE );
+        SvxULSpaceItem aMargin( nWhich );
+
+        if ( bRelativeMode )
+        {
+            DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
+
+            const SvxULSpaceItem& rOldItem =
+                static_cast<const SvxULSpaceItem&>(GetItemSet().GetParent()->Get( nWhich ));
+
+            if ( m_aTopDist.IsRelative() )
+                aMargin.SetUpper( rOldItem.GetUpper(),
+                                  static_cast<sal_uInt16>(m_aTopDist.get_value(FieldUnit::NONE)) );
+            else
+                aMargin.SetUpper( static_cast<sal_uInt16>(m_aTopDist.GetCoreValue(eUnit)) );
+
+            if ( m_aBottomDist.IsRelative() )
+                aMargin.SetLower( rOldItem.GetLower(),
+                                  static_cast<sal_uInt16>(m_aBottomDist.get_value(FieldUnit::NONE)) );
+            else
+                aMargin.SetLower( static_cast<sal_uInt16>(m_aBottomDist.GetCoreValue(eUnit)) );
+
+        }
+        else
+        {
+            aMargin.SetUpper(static_cast<sal_uInt16>(m_aTopDist.GetCoreValue(eUnit)));
+            aMargin.SetLower(static_cast<sal_uInt16>(m_aBottomDist.GetCoreValue(eUnit)));
+        }
+        aMargin.SetContextValue(m_xContextualCB->get_active());
+
+        if ( !pOld || *static_cast<const SvxULSpaceItem*>(pOld) != aMargin ||
+             SfxItemState::DONTCARE == GetItemSet().GetItemState( nWhich ) )
+        {
+            rOutSet->Put( aMargin );
+            bModified = true;
+        }
+    }
+    bool bNullTab = false;
+
+    if (m_bSplitLRSpace && m_aLeftIndent.get_value_changed_from_saved())
+    {
+        nWhich = GetWhich(SID_ATTR_PARA_LEFTSPACE);
+        MapUnit const eUnit = pPool->GetMetric(nWhich);
+        SvxTextLeftMarginItem item(nWhich);
+        pOld = GetOldItem(*rOutSet, SID_ATTR_PARA_LEFTSPACE);
+
+        if (bRelativeMode)
+        {
+            assert(GetItemSet().GetParent());
+
+            const SvxTextLeftMarginItem & rOldItem(
+                static_cast<const SvxTextLeftMarginItem&>(GetItemSet().GetParent()->Get(nWhich)));
+
+            if (m_aLeftIndent.IsRelative())
+            {
+                item.SetTextLeft(rOldItem.GetTextLeft(),
+                    static_cast<sal_uInt16>(m_aLeftIndent.get_value(FieldUnit::NONE)));
+            }
+            else
+            {
+                item.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit));
+            }
+        }
+        else
+        {
+            item.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit));
+        }
+        if (!pOld || *static_cast<const SvxTextLeftMarginItem*>(pOld) != item
+            || SfxItemState::DONTCARE == GetItemSet().GetItemState(nWhich))
+        {
+            rOutSet->Put(item);
+            bModified = true;
+        }
+    }
+
+    if (m_bSplitLRSpace && m_aRightIndent.get_value_changed_from_saved())
+    {
+        nWhich = GetWhich(SID_ATTR_PARA_RIGHTSPACE);
+        MapUnit const eUnit = pPool->GetMetric(nWhich);
+        SvxRightMarginItem item(nWhich);
+        pOld = GetOldItem(*rOutSet, SID_ATTR_PARA_RIGHTSPACE);
+
+        if (bRelativeMode)
+        {
+            assert(GetItemSet().GetParent());
+
+            const SvxRightMarginItem & rOldItem(
+                static_cast<const SvxRightMarginItem&>(GetItemSet().GetParent()->Get(nWhich)));
+
+            if (m_aRightIndent.IsRelative())
+            {
+                item.SetRight(rOldItem.GetRight(),
+                    static_cast<sal_uInt16>(m_aRightIndent.get_value(FieldUnit::NONE)));
+            }
+            else
+            {
+                item.SetRight(m_aRightIndent.GetCoreValue(eUnit));
+            }
+        }
+        else
+        {
+            item.SetRight(m_aRightIndent.GetCoreValue(eUnit));
+        }
+        if (!pOld || *static_cast<const SvxRightMarginItem*>(pOld) != item
+            || SfxItemState::DONTCARE == GetItemSet().GetItemState(nWhich))
+        {
+            rOutSet->Put(item);
+            bModified = true;
+        }
+    }
+
+    if (m_bSplitLRSpace && (m_aFLineIndent.get_value_changed_from_saved()
+                            || m_xAutoCB->get_state_changed_from_saved()))
+    {
+        nWhich = GetWhich(SID_ATTR_PARA_FIRSTLINESPACE);
+        MapUnit const eUnit = pPool->GetMetric(nWhich);
+        SvxFirstLineIndentItem item(nWhich);
+        pOld = GetOldItem(*rOutSet, SID_ATTR_PARA_FIRSTLINESPACE);
+
+        if (bRelativeMode)
+        {
+            assert(GetItemSet().GetParent());
+
+            const SvxFirstLineIndentItem & rOldItem(
+                static_cast<const SvxFirstLineIndentItem&>(GetItemSet().GetParent()->Get(nWhich)));
+
+            if (m_aFLineIndent.IsRelative())
+            {
+                item.SetTextFirstLineOffset(rOldItem.GetTextFirstLineOffset(),
+                    static_cast<sal_uInt16>(m_aFLineIndent.get_value(FieldUnit::NONE)));
+            }
+            else
+            {
+                item.SetTextFirstLineOffset(static_cast<sal_uInt16>(m_aFLineIndent.GetCoreValue(eUnit)));
+            }
+        }
+        else
+        {
+            item.SetTextFirstLineOffset(static_cast<sal_uInt16>(m_aFLineIndent.GetCoreValue(eUnit)));
+        }
+        item.SetAutoFirst(m_xAutoCB->get_active());
+        if (item.GetTextFirstLineOffset() < 0)
+        {
+            bNullTab = true;
+        }
+
+        if (!pOld || *static_cast<const SvxFirstLineIndentItem*>(pOld) != item
+            || SfxItemState::DONTCARE == GetItemSet().GetItemState(nWhich))
+        {
+            rOutSet->Put(item);
+            bModified = true;
+        }
+    }
+
+    if (!m_bSplitLRSpace &&
+        (m_aLeftIndent.get_value_changed_from_saved() ||
+         m_aFLineIndent.get_value_changed_from_saved() ||
+         m_aRightIndent.get_value_changed_from_saved() ||
+         m_xAutoCB->get_state_changed_from_saved()))
+    {
+        nWhich = GetWhich( SID_ATTR_LRSPACE );
+        MapUnit eUnit = pPool->GetMetric( nWhich );
+        SvxLRSpaceItem aMargin( nWhich );
+        pOld = GetOldItem( *rOutSet, SID_ATTR_LRSPACE );
+
+        if ( bRelativeMode )
+        {
+            DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
+
+            const SvxLRSpaceItem& rOldItem =
+                static_cast<const SvxLRSpaceItem&>(GetItemSet().GetParent()->Get( nWhich ));
+
+            if (m_aLeftIndent.IsRelative())
+                aMargin.SetTextLeft( rOldItem.GetTextLeft(),
+                                    static_cast<sal_uInt16>(m_aLeftIndent.get_value(FieldUnit::NONE)) );
+            else
+                aMargin.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit));
+
+            if ( m_aRightIndent.IsRelative() )
+                aMargin.SetRight( rOldItem.GetRight(),
+                                  static_cast<sal_uInt16>(m_aRightIndent.get_value(FieldUnit::NONE)) );
+            else
+                aMargin.SetRight(m_aRightIndent.GetCoreValue(eUnit));
+
+            if ( m_aFLineIndent.IsRelative() )
+                aMargin.SetTextFirstLineOffset( rOldItem.GetTextFirstLineOffset(),
+                                             static_cast<sal_uInt16>(m_aFLineIndent.get_value(FieldUnit::NONE)) );
+            else
+                aMargin.SetTextFirstLineOffset(static_cast<sal_uInt16>(m_aFLineIndent.GetCoreValue(eUnit)));
+        }
+        else
+        {
+            aMargin.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit));
+            aMargin.SetRight(m_aRightIndent.GetCoreValue(eUnit));
+            aMargin.SetTextFirstLineOffset(static_cast<sal_uInt16>(m_aFLineIndent.GetCoreValue(eUnit)));
+        }
+        aMargin.SetAutoFirst(m_xAutoCB->get_active());
+        if ( aMargin.GetTextFirstLineOffset() < 0 )
+            bNullTab = true;
+
+        if ( !pOld || *static_cast<const SvxLRSpaceItem*>(pOld) != aMargin ||
+             SfxItemState::DONTCARE == GetItemSet().GetItemState( nWhich ) )
+        {
+            rOutSet->Put( aMargin );
+            bModified = true;
+        }
+    }
+
+    if ( bNullTab )
+    {
+        MapUnit eUnit = pPool->GetMetric( GetWhich( SID_ATTR_TABSTOP ) );
+        if ( MapUnit::Map100thMM != eUnit )
+        {
+
+            // negative first line indent -> set null default tabstob if applicable
+            sal_uInt16 _nWhich = GetWhich( SID_ATTR_TABSTOP );
+            const SfxItemSet& rInSet = GetItemSet();
+
+            if ( rInSet.GetItemState( _nWhich ) >= SfxItemState::DEFAULT )
+            {
+                const SvxTabStopItem& rTabItem =
+                    static_cast<const SvxTabStopItem&>(rInSet.Get( _nWhich ));
+                SvxTabStopItem aNullTab( rTabItem );
+                SvxTabStop aNull( 0, SvxTabAdjust::Default );
+                aNullTab.Insert( aNull );
+                rOutSet->Put( aNullTab );
+            }
+        }
+    }
+    if (m_xRegisterCB->get_visible())
+    {
+        const SfxBoolItem* pBoolItem = static_cast<const SfxBoolItem*>(GetOldItem(
+                            *rOutSet, SID_ATTR_PARA_REGISTER));
+        if (!pBoolItem)
+            return bModified;
+        sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
+        bool bSet = pBoolItem->GetValue();
+
+        if (m_xRegisterCB->get_active() != bSet)
+        {
+            std::unique_ptr<SfxBoolItem> pRegItem(pBoolItem->Clone());
+            pRegItem->SetValue(!bSet);
+            rOutSet->Put(std::move(pRegItem));
+            bModified = true;
+        }
+        else if ( SfxItemState::DEFAULT == GetItemSet().GetItemState( _nWhich, false ) )
+            rOutSet->ClearItem(_nWhich);
+    }
+
+    return bModified;
+}
+
+static bool UseCharUnitInUI(const SfxItemSet& rSet)
+{
+    const bool bApplyCharUnit = GetApplyCharUnit(rSet);
+    if (!bApplyCharUnit)
+        return false;
+    if (!SvtCJKOptions::IsAsianTypographyEnabled())
+        return false;
+    // tdf#101895 Given that we choose to show cm vs inch based on this Locale
+    // setting, also choose to use ch[ar] and line based on that locale when
+    // bApplyCharUnit is enabled.
+    return MsLangId::isCJK(SvtSysLocaleOptions().GetRealLanguageTag().getLanguageType());
+}
+
+void SvxStdParagraphTabPage::Reset( const SfxItemSet* rSet )
+{
+    SfxItemPool* pPool = rSet->GetPool();
+    DBG_ASSERT( pPool, "Where is the pool?" );
+
+    // adjust metric
+    FieldUnit eFUnit = GetModuleFieldUnit( *rSet );
+    if (UseCharUnitInUI(*rSet))
+        eFUnit = FieldUnit::CHAR;
+
+    m_aLeftIndent.SetFieldUnit(eFUnit);
+    m_aRightIndent.SetFieldUnit(eFUnit);
+    m_aFLineIndent.SetFieldUnit(eFUnit);
+    if ( eFUnit == FieldUnit::CHAR )
+    {
+        m_aTopDist.SetFieldUnit(FieldUnit::LINE);
+        m_aBottomDist.SetFieldUnit(FieldUnit::LINE);
+        SetFieldUnit(*m_xLineDistAtMetricBox, FieldUnit::POINT);
+    }
+    else
+    {
+        m_aTopDist.SetFieldUnit(eFUnit);
+        m_aBottomDist.SetFieldUnit(eFUnit);
+        SetFieldUnit(*m_xLineDistAtMetricBox, eFUnit);
+    }
+
+    sal_uInt16 const nWhichFL(GetWhich(SID_ATTR_PARA_FIRSTLINESPACE));
+    m_bSplitLRSpace = (nWhichFL != SID_ATTR_PARA_FIRSTLINESPACE);
+    SfxItemState const eItemStateFL(rSet->GetItemState(nWhichFL));
+    sal_uInt16 const nWhichLM(GetWhich(SID_ATTR_PARA_LEFTSPACE));
+    SfxItemState const eItemStateLM(rSet->GetItemState(nWhichLM));
+    sal_uInt16 const nWhichRM(GetWhich(SID_ATTR_PARA_RIGHTSPACE));
+    SfxItemState const eItemStateRM(rSet->GetItemState(nWhichRM));
+
+    if (m_bSplitLRSpace && SfxItemState::DEFAULT <= eItemStateLM)
+    {
+        const SvxTextLeftMarginItem & rOldLeftMargin(
+            static_cast<const SvxTextLeftMarginItem &>(rSet->Get(nWhichLM)));
+
+        MapUnit const eUnit = pPool->GetMetric(nWhichLM);
+
+        if (bRelativeMode)
+        {
+            if (rOldLeftMargin.GetPropLeft() != 100)
+            {
+                m_aLeftIndent.SetRelative( true );
+                m_aLeftIndent.set_value(rOldLeftMargin.GetPropLeft(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aLeftIndent.SetRelative(false);
+                m_aLeftIndent.SetFieldUnit(eFUnit);
+                m_aLeftIndent.SetMetricValue(rOldLeftMargin.GetTextLeft(), eUnit);
+            }
+        }
+        else
+        {
+            m_aLeftIndent.SetMetricValue(rOldLeftMargin.GetTextLeft(), eUnit);
+        }
+    }
+    else if (m_bSplitLRSpace)
+    {
+        m_aLeftIndent.set_text(OUString());
+    }
+
+    if (m_bSplitLRSpace && SfxItemState::DEFAULT <= eItemStateRM)
+    {
+        const SvxRightMarginItem & rOldRightMargin(
+            static_cast<const SvxRightMarginItem &>(rSet->Get(nWhichRM)));
+
+        MapUnit const eUnit = pPool->GetMetric(nWhichRM);
+
+        if (bRelativeMode)
+        {
+            if (rOldRightMargin.GetPropRight() != 100)
+            {
+                m_aRightIndent.SetRelative( true );
+                m_aRightIndent.set_value(rOldRightMargin.GetPropRight(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aRightIndent.SetRelative(false);
+                m_aRightIndent.SetFieldUnit(eFUnit);
+                m_aRightIndent.SetMetricValue(rOldRightMargin.GetRight(), eUnit);
+            }
+        }
+        else
+        {
+            m_aRightIndent.SetMetricValue(rOldRightMargin.GetRight(), eUnit);
+        }
+    }
+    else if (m_bSplitLRSpace)
+    {
+        m_aRightIndent.set_text(OUString());
+    }
+
+    if (m_bSplitLRSpace && SfxItemState::DEFAULT <= eItemStateFL)
+    {
+        const SvxFirstLineIndentItem & rOldFirstLine(
+            static_cast<const SvxFirstLineIndentItem &>(rSet->Get(nWhichFL)));
+
+        MapUnit const eUnit = pPool->GetMetric(nWhichFL);
+
+        if (bRelativeMode)
+        {
+            if (rOldFirstLine.GetPropTextFirstLineOffset() != 100)
+            {
+                m_aFLineIndent.SetRelative(true);
+                m_aFLineIndent.set_value(rOldFirstLine.GetPropTextFirstLineOffset(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aFLineIndent.SetRelative(false);
+                m_aFLineIndent.set_min(-9999, FieldUnit::NONE);
+                m_aFLineIndent.SetFieldUnit(eFUnit);
+                m_aFLineIndent.SetMetricValue(rOldFirstLine.GetTextFirstLineOffset(), eUnit);
+            }
+            m_xAutoCB->set_active(rOldFirstLine.IsAutoFirst());
+        }
+        else
+        {
+            m_aFLineIndent.SetMetricValue(rOldFirstLine.GetTextFirstLineOffset(), eUnit);
+            m_xAutoCB->set_active(rOldFirstLine.IsAutoFirst());
+        }
+        AutoHdl_Impl(*m_xAutoCB);
+    }
+    else if (m_bSplitLRSpace)
+    {
+        m_aFLineIndent.set_text(OUString());
+    }
+
+    sal_uInt16 _nWhich = GetWhich( SID_ATTR_LRSPACE );
+    SfxItemState eItemState = rSet->GetItemState( _nWhich );
+
+    if (!m_bSplitLRSpace && SfxItemState::DEFAULT <= eItemState)
+    {
+        MapUnit eUnit = pPool->GetMetric( _nWhich );
+
+        if ( bRelativeMode )
+        {
+            const SvxLRSpaceItem& rOldItem =
+                static_cast<const SvxLRSpaceItem&>(rSet->Get( _nWhich ));
+
+            if ( rOldItem.GetPropLeft() != 100 )
+            {
+                m_aLeftIndent.SetRelative( true );
+                m_aLeftIndent.set_value(rOldItem.GetPropLeft(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aLeftIndent.SetRelative(false);
+                m_aLeftIndent.SetFieldUnit(eFUnit);
+                m_aLeftIndent.SetMetricValue(rOldItem.GetTextLeft(), eUnit);
+            }
+
+            if ( rOldItem.GetPropRight() != 100 )
+            {
+                m_aRightIndent.SetRelative( true );
+                m_aRightIndent.set_value(rOldItem.GetPropRight(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aRightIndent.SetRelative(false);
+                m_aRightIndent.SetFieldUnit(eFUnit);
+                m_aRightIndent.SetMetricValue(rOldItem.GetRight(), eUnit);
+            }
+
+            if ( rOldItem.GetPropTextFirstLineOffset() != 100 )
+            {
+                m_aFLineIndent.SetRelative(true);
+                m_aFLineIndent.set_value(rOldItem.GetPropTextFirstLineOffset(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aFLineIndent.SetRelative(false);
+                m_aFLineIndent.set_min(-9999, FieldUnit::NONE);
+                m_aFLineIndent.SetFieldUnit(eFUnit);
+                m_aFLineIndent.SetMetricValue(rOldItem.GetTextFirstLineOffset(), eUnit);
+            }
+            m_xAutoCB->set_active(rOldItem.IsAutoFirst());
+        }
+        else
+        {
+            const SvxLRSpaceItem& rSpace =
+                static_cast<const SvxLRSpaceItem&>(rSet->Get( _nWhich ));
+
+            m_aLeftIndent.SetMetricValue(rSpace.GetTextLeft(), eUnit);
+            m_aRightIndent.SetMetricValue(rSpace.GetRight(), eUnit);
+            m_aFLineIndent.SetMetricValue(rSpace.GetTextFirstLineOffset(), eUnit);
+            m_xAutoCB->set_active(rSpace.IsAutoFirst());
+        }
+        AutoHdl_Impl(*m_xAutoCB);
+    }
+    else if (!m_bSplitLRSpace)
+    {
+        m_aLeftIndent.set_text(OUString());
+        m_aRightIndent.set_text(OUString());
+        m_aFLineIndent.set_text(OUString());
+    }
+
+    _nWhich = GetWhich( SID_ATTR_ULSPACE );
+    eItemState = rSet->GetItemState( _nWhich );
+
+    if ( eItemState >= SfxItemState::DEFAULT )
+    {
+        MapUnit eUnit = pPool->GetMetric( _nWhich );
+
+        const SvxULSpaceItem& rOldItem =
+            static_cast<const SvxULSpaceItem&>(rSet->Get( _nWhich ));
+        if ( bRelativeMode )
+        {
+
+            if ( rOldItem.GetPropUpper() != 100 )
+            {
+                m_aTopDist.SetRelative( true );
+                m_aTopDist.set_value(rOldItem.GetPropUpper(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aTopDist.SetRelative(false);
+                if (eFUnit == FieldUnit::CHAR)
+                    m_aTopDist.SetFieldUnit(FieldUnit::LINE);
+                else
+                    m_aTopDist.SetFieldUnit(eFUnit);
+                m_aTopDist.SetMetricValue(rOldItem.GetUpper(), eUnit);
+            }
+
+            if ( rOldItem.GetPropLower() != 100 )
+            {
+                m_aBottomDist.SetRelative( true );
+                m_aBottomDist.set_value(rOldItem.GetPropLower(), FieldUnit::NONE);
+            }
+            else
+            {
+                m_aBottomDist.SetRelative(false);
+                if (eFUnit == FieldUnit::CHAR)
+                    m_aBottomDist.SetFieldUnit(FieldUnit::LINE);
+                else
+                    m_aBottomDist.SetFieldUnit(eFUnit);
+                m_aBottomDist.SetMetricValue(rOldItem.GetLower(), eUnit);
+            }
+        }
+        else
+        {
+            m_aTopDist.SetMetricValue(rOldItem.GetUpper(), eUnit);
+            m_aBottomDist.SetMetricValue(rOldItem.GetLower(), eUnit);
+        }
+        m_xContextualCB->set_active(rOldItem.GetContext());
+    }
+    else
+    {
+        m_aTopDist.set_text(OUString());
+        m_aBottomDist.set_text(OUString());
+    }
+
+    _nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
+    eItemState = rSet->GetItemState( _nWhich );
+
+    if ( eItemState >= SfxItemState::DEFAULT )
+        SetLineSpacing_Impl( static_cast<const SvxLineSpacingItem &>(rSet->Get( _nWhich )) );
+    else
+        m_xLineDist->set_active(-1);
+
+    _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
+    eItemState = rSet->GetItemState( _nWhich );
+
+    if ( eItemState >= SfxItemState::DEFAULT )
+        m_xRegisterCB->set_active( static_cast<const SfxBoolItem &>(rSet->Get( _nWhich )).GetValue());
+    m_xRegisterCB->save_state();
+    sal_uInt16 nHtmlMode = GetHtmlMode_Impl(*rSet);
+    if(nHtmlMode & HTMLMODE_ON)
+    {
+        m_xRegisterCB->hide();
+        m_xAutoCB->hide();
+    }
+
+    // this sets the min/max limits; do this _after_ setting the values,
+    // because for Impress the min of first-line indent depends on value of
+    // left-indent!
+    ELRLoseFocus();
+    ChangesApplied();
+}
+
+void SvxStdParagraphTabPage::ChangesApplied()
+{
+    m_aLeftIndent.save_value();
+    m_aRightIndent.save_value();
+    m_aFLineIndent.save_value();
+    m_xLineDist->save_value();
+    m_xLineDistAtPercentBox->save_value();
+    m_xLineDistAtMetricBox->save_value();
+    m_xRegisterCB->save_state();
+    m_aTopDist.save_value();
+    m_aBottomDist.save_value();
+    m_xContextualCB->save_state();
+    m_xAutoCB->save_state();
+}
+
+void SvxStdParagraphTabPage::EnableRelativeMode()
+{
+    DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no parent-set!" );
+
+    m_aLeftIndent.EnableRelativeMode( 0, 999 );
+    m_aFLineIndent.EnableRelativeMode( 0, 999 );
+    m_aRightIndent.EnableRelativeMode( 0, 999 );
+    m_aTopDist.EnableRelativeMode( 0, 999 );
+    m_aBottomDist.EnableRelativeMode( 0, 999 );
+    bRelativeMode = true;
+}
+
+void SvxStdParagraphTabPage::ActivatePage( const SfxItemSet& rSet )
+{
+    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
+    SfxItemState eItemState = rSet.GetItemState( _nWhich );
+
+    if ( eItemState < SfxItemState::DEFAULT )
+        return;
+
+    const SvxAdjustItem& rAdj = static_cast<const SvxAdjustItem&>( rSet.Get( _nWhich ) );
+    SvxAdjust eAdjust = rAdj.GetAdjust();
+    if ( eAdjust == SvxAdjust::Center || eAdjust == SvxAdjust::Block )
+    {
+        _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION );
+        eItemState = rSet.GetItemState( _nWhich );
+
+        if ( eItemState >= SfxItemState::DEFAULT )
+        {
+            const SvxFrameDirectionItem& rFrameDirItem = static_cast<const SvxFrameDirectionItem&>( rSet.Get( _nWhich ) );
+            SvxFrameDirection eFrameDirection = rFrameDirItem.GetValue();
+
+            m_aExampleWin.EnableRTL( SvxFrameDirection::Horizontal_RL_TB == eFrameDirection );
+
+            if ( eAdjust == SvxAdjust::Block )
+                m_aExampleWin.SetLastLine( rAdj.GetLastBlock() );
+        }
+    }
+    else
+    {
+        m_aExampleWin.EnableRTL( eAdjust == SvxAdjust::Right );
+        eAdjust = SvxAdjust::Left; //required for correct preview display
+        m_aExampleWin.SetLastLine( eAdjust );
+    }
+    m_aExampleWin.SetAdjust( eAdjust );
+
+    UpdateExample_Impl();
+}
+
+DeactivateRC SvxStdParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
+{
+    ELRLoseFocus();
+
+    if ( _pSet )
+        FillItemSet( _pSet );
+    return DeactivateRC::LeavePage;
+}
+
+SvxStdParagraphTabPage::SvxStdParagraphTabPage(weld::Container* pPage, weld::DialogController* pController,  const SfxItemSet& rAttr)
+    : SfxTabPage(pPage, pController, "cui/ui/paraindentspacing.ui", "ParaIndentSpacing", &rAttr)
+    , nWidth(11905 /*567 * 50*/)
+    , nMinFixDist(0)
+    , bRelativeMode(false)
+    , m_aLeftIndent(m_xBuilder->weld_metric_spin_button("spinED_LEFTINDENT", FieldUnit::CM))
+    , m_aRightIndent(m_xBuilder->weld_metric_spin_button("spinED_RIGHTINDENT", FieldUnit::CM))
+    , m_xFLineLabel(m_xBuilder->weld_label("labelFT_FLINEINDENT"))
+    , m_aFLineIndent(m_xBuilder->weld_metric_spin_button("spinED_FLINEINDENT", FieldUnit::CM))
+    , m_xAutoCB(m_xBuilder->weld_check_button("checkCB_AUTO"))
+    , m_aTopDist(m_xBuilder->weld_metric_spin_button("spinED_TOPDIST", FieldUnit::CM))
+    , m_aBottomDist(m_xBuilder->weld_metric_spin_button("spinED_BOTTOMDIST", FieldUnit::CM))
+    , m_xContextualCB(m_xBuilder->weld_check_button("checkCB_CONTEXTUALSPACING"))
+    , m_xLineDist(m_xBuilder->weld_combo_box("comboLB_LINEDIST"))
+    , m_xLineDistAtPercentBox(m_xBuilder->weld_metric_spin_button("spinED_LINEDISTPERCENT", FieldUnit::PERCENT))
+    , m_xLineDistAtMetricBox(m_xBuilder->weld_metric_spin_button("spinED_LINEDISTMETRIC", FieldUnit::CM))
+    , m_xLineDistAtPlaceHolderBox(m_xBuilder->weld_metric_spin_button("spinED_BLANK", FieldUnit::CM))
+    , m_xLineDistAtLabel(m_xBuilder->weld_label("labelFT_LINEDIST"))
+    , m_xAbsDist(m_xBuilder->weld_label("labelST_LINEDIST_ABS"))
+    , m_xRegisterCB(m_xBuilder->weld_check_button("checkCB_REGISTER"))
+    , m_xExampleWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWN_EXAMPLE", m_aExampleWin))
+{
+    sAbsDist = m_xAbsDist->get_label();
+
+    // this page needs ExchangeSupport
+    SetExchangeSupport();
+
+    m_xLineDistAtMetricBox->hide();
+    m_xLineDistAtPlaceHolderBox->hide();
+    m_xLineDistAtPlaceHolderBox->set_text(OUString());
+
+    Init_Impl();
+    m_aFLineIndent.set_min(-9999, FieldUnit::NONE);    // is set to 0 on default
+}
+
+SvxStdParagraphTabPage::~SvxStdParagraphTabPage()
+{
+}
+
+void SvxStdParagraphTabPage::EnableNegativeMode()
+{
+    m_aLeftIndent.set_min(-9999, FieldUnit::NONE);
+    m_aRightIndent.set_min(-9999, FieldUnit::NONE);
+    m_aRightIndent.EnableNegativeMode();
+    m_aLeftIndent.EnableNegativeMode();
+}
+
+void SvxStdParagraphTabPage::SetLineSpacing_Impl
+(
+    const SvxLineSpacingItem &rAttr
+)
+{
+    MapUnit eUnit = GetItemSet().GetPool()->GetMetric( rAttr.Which() );
+
+    switch( rAttr.GetLineSpaceRule() )
+    {
+        case SvxLineSpaceRule::Auto:
+        {
+            SvxInterLineSpaceRule eInter = rAttr.GetInterLineSpaceRule();
+
+            switch( eInter )
+            {
+                // Default single line spacing
+                case SvxInterLineSpaceRule::Off:
+                    m_xLineDist->set_active( LLINESPACE_1 );
+                    break;
+
+                // Default single line spacing
+                case SvxInterLineSpaceRule::Prop:
+                    if ( 100 == rAttr.GetPropLineSpace() )
+                    {
+                        m_xLineDist->set_active( LLINESPACE_1 );
+                        break;
+                    }
+                    // 1.15 line spacing
+                    if ( 115 == rAttr.GetPropLineSpace() )
+                    {
+                        m_xLineDist->set_active( LLINESPACE_115 );
+                        break;
+                    }
+                    // 1.5 line spacing
+                    if ( 150 == rAttr.GetPropLineSpace() )
+                    {
+                        m_xLineDist->set_active( LLINESPACE_15 );
+                        break;
+                    }
+                    // double line spacing
+                    if ( 200 == rAttr.GetPropLineSpace() )
+                    {
+                        m_xLineDist->set_active( LLINESPACE_2 );
+                        break;
+                    }
+                    // the set per cent value
+                    m_xLineDistAtPercentBox->set_value(m_xLineDistAtPercentBox->normalize(rAttr.GetPropLineSpace()), FieldUnit::NONE);
+                    m_xLineDist->set_active( LLINESPACE_PROP );
+                    break;
+
+                case SvxInterLineSpaceRule::Fix:
+                    SetMetricValue( *m_xLineDistAtMetricBox, rAttr.GetInterLineSpace(), eUnit );
+                    m_xLineDist->set_active( LLINESPACE_DURCH );
+                    break;
+                default: ;//prevent warning
+            }
+        }
+        break;
+        case SvxLineSpaceRule::Fix:
+            SetMetricValue(*m_xLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
+            m_xLineDist->set_active( LLINESPACE_FIX );
+        break;
+
+        case SvxLineSpaceRule::Min:
+            SetMetricValue(*m_xLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
+            m_xLineDist->set_active( LLINESPACE_MIN );
+            break;
+        default: ;//prevent warning
+    }
+    LineDistHdl_Impl( *m_xLineDist );
+}
+
+IMPL_LINK_NOARG(SvxStdParagraphTabPage, LineDistPopupHdl_Impl, weld::ComboBox&, void)
+{
+    m_bLineDistToggled = true;
+}
+
+IMPL_LINK(SvxStdParagraphTabPage, LineDistHdl_Impl, weld::ComboBox&, rBox, void)
+{
+    switch (rBox.get_active())
+    {
+        case LLINESPACE_1:
+        case LLINESPACE_115:
+        case LLINESPACE_15:
+        case LLINESPACE_2:
+            m_xLineDistAtLabel->set_sensitive(false);
+            m_xLineDistAtPercentBox->hide();
+            m_xLineDistAtMetricBox->hide();
+            m_xLineDistAtPlaceHolderBox->show();
+            break;
+
+        case LLINESPACE_DURCH:
+            // setting a sensible default?
+            // limit MS min(10, aPageSize)
+            m_xLineDistAtMetricBox->set_min(0, FieldUnit::NONE);
+
+            if (m_xLineDistAtPlaceHolderBox->get_visible())
+                m_xLineDistAtMetricBox->set_value(m_xLineDistAtMetricBox->normalize(1), FieldUnit::NONE);
+            m_xLineDistAtPlaceHolderBox->hide();
+            m_xLineDistAtPercentBox->hide();
+            m_xLineDistAtMetricBox->show();
+            m_xLineDistAtLabel->set_sensitive(true);
+            break;
+
+        case LLINESPACE_MIN:
+            m_xLineDistAtMetricBox->set_min(0, FieldUnit::NONE);
+
+            if (m_xLineDistAtPlaceHolderBox->get_visible())
+                m_xLineDistAtMetricBox->set_value(m_xLineDistAtMetricBox->normalize(10), FieldUnit::TWIP);
+            m_xLineDistAtPlaceHolderBox->hide();
+            m_xLineDistAtPercentBox->hide();
+            m_xLineDistAtMetricBox->show();
+            m_xLineDistAtLabel->set_sensitive(true);
+            break;
+
+        case LLINESPACE_PROP:
+
+            if (m_xLineDistAtPlaceHolderBox->get_visible())
+                m_xLineDistAtPercentBox->set_value(m_xLineDistAtPercentBox->normalize(100), FieldUnit::TWIP);
+            m_xLineDistAtPlaceHolderBox->hide();
+            m_xLineDistAtMetricBox->hide();
+            m_xLineDistAtPercentBox->show();
+            m_xLineDistAtLabel->set_sensitive(true);
+            break;
+        case LLINESPACE_FIX:
+        {
+            auto nTemp = m_xLineDistAtMetricBox->get_value(FieldUnit::NONE);
+            m_xLineDistAtMetricBox->set_min(m_xLineDistAtMetricBox->normalize(nMinFixDist), FieldUnit::TWIP);
+
+            // if the value has been changed at SetMin,
+            // it is time for the default
+            if (m_xLineDistAtMetricBox->get_value(FieldUnit::NONE) != nTemp)
+                SetMetricValue( *m_xLineDistAtMetricBox, FIX_DIST_DEF, MapUnit::MapTwip ); // fix is only in Writer
+            m_xLineDistAtPlaceHolderBox->hide();
+            m_xLineDistAtPercentBox->hide();
+            m_xLineDistAtMetricBox->show();
+            m_xLineDistAtLabel->set_sensitive(true);
+        }
+        break;
+    }
+    UpdateExample_Impl();
+}
+
+IMPL_LINK_NOARG(SvxStdParagraphTabPage, ModifyHdl_Impl, weld::MetricSpinButton&, void)
+{
+    UpdateExample_Impl();
+}
+
+void SvxStdParagraphTabPage::Init_Impl()
+{
+    m_xLineDist->connect_popup_toggled(LINK(this, SvxStdParagraphTabPage, LineDistPopupHdl_Impl));
+    m_xLineDist->connect_changed(LINK(this, SvxStdParagraphTabPage, LineDistHdl_Impl));
+
+    Link<weld::MetricSpinButton&,void> aLink2 = LINK(this, SvxStdParagraphTabPage, ELRLoseFocusHdl);
+    m_aFLineIndent.connect_value_changed(aLink2);
+    m_aLeftIndent.connect_value_changed(aLink2);
+    m_aRightIndent.connect_value_changed(aLink2);
+
+    Link<weld::MetricSpinButton&,void> aLink = LINK(this, SvxStdParagraphTabPage, ModifyHdl_Impl);
+    m_aTopDist.connect_value_changed(aLink);
+    m_aBottomDist.connect_value_changed(aLink);
+
+    m_xAutoCB->connect_toggled(LINK(this, SvxStdParagraphTabPage, AutoHdl_Impl));
+    SfxItemPool* pPool = GetItemSet().GetPool();
+    DBG_ASSERT( pPool, "Where is the pool?" );
+    FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
+
+    m_aTopDist.set_max( m_aTopDist.normalize( MAX_DURCH ), eUnit );
+    m_aBottomDist.set_max( m_aBottomDist.normalize( MAX_DURCH ), eUnit );
+    m_xLineDistAtMetricBox->set_max( m_xLineDistAtMetricBox->normalize( MAX_DURCH ), eUnit );
+}
+
+void SvxStdParagraphTabPage::UpdateExample_Impl()
+{
+    m_aExampleWin.SetFirstLineOffset( static_cast<short>(m_aFLineIndent.denormalize( m_aFLineIndent.get_value( FieldUnit::TWIP ) )) );
+    m_aExampleWin.SetLeftMargin( static_cast<tools::Long>(m_aLeftIndent.denormalize( m_aLeftIndent.get_value( FieldUnit::TWIP ) ) ) );
+    m_aExampleWin.SetRightMargin( static_cast<tools::Long>(m_aRightIndent.denormalize( m_aRightIndent.get_value( FieldUnit::TWIP ) ) ) );
+    m_aExampleWin.SetUpper( static_cast<sal_uInt16>(m_aTopDist.denormalize( m_aTopDist.get_value( FieldUnit::TWIP ) )) );
+    m_aExampleWin.SetLower( static_cast<sal_uInt16>(m_aBottomDist.denormalize( m_aBottomDist.get_value( FieldUnit::TWIP ) )) );
+
+    int nPos = m_xLineDist->get_active();
+
+    switch ( nPos )
+    {
+        case LLINESPACE_1:
+        case LLINESPACE_115:
+        case LLINESPACE_15:
+        case LLINESPACE_2:
+        case LLINESPACE_PROP:
+        case LLINESPACE_MIN:
+        case LLINESPACE_DURCH:
+        case LLINESPACE_FIX:
+            m_aExampleWin.SetLineSpace( static_cast<SvxPrevLineSpace>(nPos) );
+            break;
+    }
+    m_aExampleWin.Invalidate();
+}
+
+void SvxStdParagraphTabPage::EnableRegisterMode()
+{
+    m_xRegisterCB->show();
+}
+
+void SvxStdParagraphTabPage::EnableContextualMode()
+{
+    m_xContextualCB->show();
+}
+
+IMPL_LINK(SvxStdParagraphTabPage, AutoHdl_Impl, weld::Toggleable&, rBox, void)
+{
+    bool bEnable = !rBox.get_active();
+    m_xFLineLabel->set_sensitive(bEnable);
+    m_aFLineIndent.set_sensitive(bEnable);
+}
+
+void SvxStdParagraphTabPage::EnableAutoFirstLine()
+{
+    m_xAutoCB->show();
+}
+
+void SvxStdParagraphTabPage::EnableAbsLineDist(tools::Long nMinTwip)
+{
+    m_xLineDist->append_text(sAbsDist);
+    nMinFixDist = nMinTwip;
+}
+
+void SvxStdParagraphTabPage::PageCreated(const SfxAllItemSet& aSet)
+{
+
+/* different bit represent call to different method of SvxStdParagraphTabPage
+                        0x0001 --->EnableRelativeMode()
+                        0x0002 --->EnableRegisterMode()
+                        0x0004 --->EnableAutoFirstLine()
+                        0x0008 --->EnableNegativeMode()
+                        0x0010 --->EnableContextualMode()
+            */
+    const SfxUInt16Item* pPageWidthItem = aSet.GetItem<SfxUInt16Item>(SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH, false);
+    const SfxUInt32Item* pFlagSetItem = aSet.GetItem<SfxUInt32Item>(SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET, false);
+    const SfxUInt32Item* pLineDistItem = aSet.GetItem<SfxUInt32Item>(SID_SVXSTDPARAGRAPHTABPAGE_ABSLINEDIST, false);
+
+    if (pPageWidthItem)
+        nWidth = pPageWidthItem->GetValue();
+
+    if (pFlagSetItem )
+    {
+        if (( 0x0001 & pFlagSetItem->GetValue())== 0x0001 )
+            EnableRelativeMode();
+
+        if (( 0x0002 & pFlagSetItem->GetValue())== 0x0002 )
+                EnableRegisterMode();
+
+        if ( ( 0x0004 & pFlagSetItem->GetValue())== 0x0004 )
+            EnableAutoFirstLine();
+    }
+
+    if(pLineDistItem)
+        EnableAbsLineDist(pLineDistItem->GetValue());
+
+    if (pFlagSetItem)
+    {
+        if  (( 0x0008 & pFlagSetItem->GetValue()) == 0x0008 )
+                EnableNegativeMode();
+
+        if  (( 0x0010 & pFlagSetItem->GetValue()) == 0x0010 )
+                EnableContextualMode();
+    }
+}
+
+#define LASTLINEPOS_DEFAULT     0
+#define LASTLINEPOS_LEFT        1
+
+#define LASTLINECOUNT_OLD       3
+#define LASTLINECOUNT_NEW       4
+
+SvxParaAlignTabPage::SvxParaAlignTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
+    : SfxTabPage(pPage, pController, "cui/ui/paragalignpage.ui", "ParaAlignPage", &rSet)
+    , m_bSdrVertAlign(false)
+    , m_xLeft(m_xBuilder->weld_radio_button("radioBTN_LEFTALIGN"))
+    , m_xRight(m_xBuilder->weld_radio_button("radioBTN_RIGHTALIGN"))
+    , m_xCenter(m_xBuilder->weld_radio_button("radioBTN_CENTERALIGN"))
+    , m_xJustify(m_xBuilder->weld_radio_button("radioBTN_JUSTIFYALIGN"))
+    , m_xLeftBottom(m_xBuilder->weld_label("labelST_LEFTALIGN_ASIAN"))
+    , m_xRightTop(m_xBuilder->weld_label("labelST_RIGHTALIGN_ASIAN"))
+    , m_xLastLineFT(m_xBuilder->weld_label("labelLB_LASTLINE"))
+    , m_xLastLineLB(m_xBuilder->weld_combo_box("comboLB_LASTLINE"))
+    , m_xExpandCB(m_xBuilder->weld_check_button("checkCB_EXPAND"))
+    , m_xSnapToGridCB(m_xBuilder->weld_check_button("checkCB_SNAP"))
+    , m_xExampleWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWN_EXAMPLE", m_aExampleWin))
+    , m_xVertAlignFL(m_xBuilder->weld_widget("frameFL_VERTALIGN"))
+    , m_xVertAlignLB(m_xBuilder->weld_combo_box("comboLB_VERTALIGN"))
+    , m_xVertAlign(m_xBuilder->weld_label("labelFL_VERTALIGN"))
+    , m_xVertAlignSdr(m_xBuilder->weld_label("labelST_VERTALIGN_SDR"))
+    , m_xTextDirectionLB(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("comboLB_TEXTDIRECTION")))
+{
+    SetExchangeSupport();
+
+    sal_uInt16 nLastLinePos = LASTLINEPOS_DEFAULT;
+
+    if ( SvtCJKOptions::IsAsianTypographyEnabled() )
+    {
+        m_xLeft->set_label(m_xLeftBottom->get_label());
+        m_xRight->set_label(m_xRightTop->get_label());
+
+        OUString sLeft(m_xLeft->get_label());
+        sLeft = MnemonicGenerator::EraseAllMnemonicChars( sLeft );
+
+        if (m_xLastLineLB->get_count() == LASTLINECOUNT_OLD)
+        {
+            m_xLastLineLB->remove(0);
+            m_xLastLineLB->insert_text(0, sLeft);
+        }
+        else
+            nLastLinePos = LASTLINEPOS_LEFT;
+    }
+
+    // remove "Default" or "Left" entry, depends on CJKOptions
+    if (m_xLastLineLB->get_count() == LASTLINECOUNT_NEW)
+        m_xLastLineLB->remove(nLastLinePos);
+
+    Link<weld::Toggleable&, void> aLink = LINK( this, SvxParaAlignTabPage, AlignHdl_Impl );
+    m_xLeft->connect_toggled(aLink);
+    m_xRight->connect_toggled(aLink);
+    m_xCenter->connect_toggled(aLink);
+    m_xJustify->connect_toggled(aLink);
+    m_xLastLineLB->connect_changed(LINK(this, SvxParaAlignTabPage, LastLineHdl_Impl));
+    m_xTextDirectionLB->connect_changed(LINK(this, SvxParaAlignTabPage, TextDirectionHdl_Impl));
+
+    m_xTextDirectionLB->append(SvxFrameDirection::Environment, SvxResId(RID_SVXSTR_FRAMEDIR_SUPER));
+    m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_FRAMEDIR_LTR));
+    m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_FRAMEDIR_RTL));
+}
+
+SvxParaAlignTabPage::~SvxParaAlignTabPage()
+{
+}
+
+DeactivateRC SvxParaAlignTabPage::DeactivatePage( SfxItemSet* _pSet )
+{
+    if ( _pSet )
+        FillItemSet( _pSet );
+    return DeactivateRC::LeavePage;
+}
+
+std::unique_ptr<SfxTabPage> SvxParaAlignTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet)
+{
+    return std::make_unique<SvxParaAlignTabPage>(pPage, pController, *rSet);
+}
+
+bool SvxParaAlignTabPage::FillItemSet( SfxItemSet* rOutSet )
+{
+    bool bModified = false;
+
+    bool bAdj = false;
+    SvxAdjust eAdjust = SvxAdjust::Left;
+
+    if (m_xLeft->get_active())
+    {
+        eAdjust = SvxAdjust::Left;
+        bAdj = m_xLeft->get_saved_state() == TRISTATE_FALSE;
+    }
+    else if (m_xRight->get_active())
+    {
+        eAdjust = SvxAdjust::Right;
+        bAdj = m_xRight->get_saved_state() == TRISTATE_FALSE;
+    }
+    else if (m_xCenter->get_active())
+    {
+        eAdjust = SvxAdjust::Center;
+        bAdj = m_xCenter->get_saved_state() == TRISTATE_FALSE;
+    }
+    else if (m_xJustify->get_active())
+    {
+        eAdjust = SvxAdjust::Block;
+        bAdj = m_xJustify->get_saved_state() == TRISTATE_FALSE ||
+            m_xExpandCB->get_state_changed_from_saved() ||
+            m_xLastLineLB->get_value_changed_from_saved();
+    }
+
+    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
+
+    if (bAdj)
+    {
+        SvxAdjust eOneWord = m_xExpandCB->get_active() ? SvxAdjust::Block : SvxAdjust::Left;
+
+        int nLBPos = m_xLastLineLB->get_active();
+        SvxAdjust eLastBlock = SvxAdjust::Left;
+        if ( 1 == nLBPos )
+            eLastBlock = SvxAdjust::Center;
+        else if ( 2 == nLBPos )
+            eLastBlock = SvxAdjust::Block;
+
+        SvxAdjustItem aAdj( static_cast<const SvxAdjustItem&>(GetItemSet().Get( _nWhich )) );
+        aAdj.SetAdjust( eAdjust );
+        aAdj.SetOneWord( eOneWord );
+        aAdj.SetLastBlock( eLastBlock );
+        rOutSet->Put( aAdj );
+        bModified = true;
+    }
+
+    if (m_xSnapToGridCB->get_state_changed_from_saved())
+    {
+        rOutSet->Put(SvxParaGridItem(m_xSnapToGridCB->get_active(), GetWhich( SID_ATTR_PARA_SNAPTOGRID )));
+        bModified = true;
+    }
+
+    if (m_xVertAlignLB->get_value_changed_from_saved())
+    {
+        if (m_bSdrVertAlign)
+            rOutSet->Put(SdrTextVertAdjustItem(static_cast<SdrTextVertAdjust>(m_xVertAlignLB->get_active())));
+        else
+            rOutSet->Put(SvxParaVertAlignItem(static_cast<SvxParaVertAlignItem::Align>(m_xVertAlignLB->get_active()), GetWhich( SID_PARA_VERTALIGN )));
+        bModified = true;
+    }
+
+    if (m_xTextDirectionLB->get_visible())
+    {
+        if (m_xTextDirectionLB->get_value_changed_from_saved())
+        {
+            SvxFrameDirection eDir = m_xTextDirectionLB->get_active_id();
+            rOutSet->Put( SvxFrameDirectionItem( eDir, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) );
+            bModified = true;
+        }
+    }
+
+    return bModified;
+}
+
+void SvxParaAlignTabPage::ActivatePage( const SfxItemSet& rSet )
+{
+    Reset( &rSet );
+}
+
+void SvxParaAlignTabPage::Reset( const SfxItemSet* rSet )
+{
+    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
+    SfxItemState eItemState = rSet->GetItemState( _nWhich );
+
+    sal_Int32 nLBSelect = 0;
+    if ( eItemState >= SfxItemState::DEFAULT )
+    {
+        const SvxAdjustItem& rAdj = static_cast<const SvxAdjustItem&>(rSet->Get( _nWhich ));
+
+        switch ( rAdj.GetAdjust() /*!!! ask VB rAdj.GetLastBlock()*/ )
+        {
+            case SvxAdjust::Left: m_xLeft->set_active(true); break;
+
+            case SvxAdjust::Right: m_xRight->set_active(true); break;
+
+            case SvxAdjust::Center: m_xCenter->set_active(true); break;
+
+            case SvxAdjust::Block: m_xJustify->set_active(true); break;
+            default: ; //prevent warning
+        }
+        bool bEnable = m_xJustify->get_active();
+        m_xLastLineFT->set_sensitive(bEnable);
+        m_xLastLineLB->set_sensitive(bEnable);
+
+        switch(rAdj.GetLastBlock())
+        {
+            case SvxAdjust::Left:  nLBSelect = 0; break;
+
+            case SvxAdjust::Center: nLBSelect = 1;  break;
+
+            case SvxAdjust::Block: nLBSelect = 2;  break;
+            default: ; //prevent warning
+        }
+        m_xExpandCB->set_sensitive(bEnable && nLBSelect == 2);
+        m_xExpandCB->set_active(SvxAdjust::Block == rAdj.GetOneWord());
+    }
+    else
+    {
+        m_xLeft->set_active(false);
+        m_xRight->set_active(false);
+        m_xCenter->set_active(false);
+        m_xJustify->set_active(false);
+    }
+    m_xLastLineLB->set_active(nLBSelect);
+
+    sal_uInt16 nHtmlMode = GetHtmlMode_Impl(*rSet);
+    if(nHtmlMode & HTMLMODE_ON)
+    {
+        m_xLastLineLB->hide();
+        m_xLastLineFT->hide();
+        m_xExpandCB->hide();
+        if(!(nHtmlMode & HTMLMODE_FULL_STYLES) )
+            m_xJustify->set_sensitive(false);
+        m_xSnapToGridCB->hide();
+    }
+    _nWhich = GetWhich(SID_ATTR_PARA_SNAPTOGRID);
+    eItemState = rSet->GetItemState( _nWhich );
+    if ( eItemState >= SfxItemState::DEFAULT )
+    {
+        const SvxParaGridItem& rSnap = static_cast<const SvxParaGridItem&>(rSet->Get( _nWhich ));
+        m_xSnapToGridCB->set_active(rSnap.GetValue());
+    }
+
+    _nWhich = m_bSdrVertAlign ? SDRATTR_TEXT_VERTADJUST : GetWhich( SID_PARA_VERTALIGN );
+    eItemState = rSet->GetItemState( _nWhich );
+
+    if ( eItemState >= SfxItemState::DEFAULT )
+    {
+        m_xVertAlignFL->show();
+
+        if (m_bSdrVertAlign)
+        {
+            const SdrTextVertAdjustItem& rAlign = static_cast<const SdrTextVertAdjustItem&>(rSet->Get( _nWhich ));
+            m_xVertAlignLB->set_active(rAlign.GetValue());
+        }
+        else
+        {
+            const SvxParaVertAlignItem& rAlign = static_cast<const SvxParaVertAlignItem&>(rSet->Get( _nWhich ));
+            m_xVertAlignLB->set_active(static_cast<sal_Int32>(rAlign.GetValue()));
+        }
+    }
+
+    _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION );
+    //text direction
+    if( SfxItemState::DEFAULT <= rSet->GetItemState( _nWhich ) )
+    {
+        const SvxFrameDirectionItem& rFrameDirItem = static_cast<const SvxFrameDirectionItem&>( rSet->Get( _nWhich ) );
+        m_xTextDirectionLB->set_active_id(rFrameDirItem.GetValue());
+        m_xTextDirectionLB->save_value();
+    }
+
+    m_xSnapToGridCB->save_state();
+    m_xVertAlignLB->save_value();
+    m_xLeft->save_state();
+    m_xRight->save_state();
+    m_xCenter->save_state();
+    m_xJustify->save_state();
+    m_xLastLineLB->save_value();
+    m_xExpandCB->save_state();
+
+    UpdateExample_Impl();
+}
+
+void SvxParaAlignTabPage::ChangesApplied()
+{
+    m_xTextDirectionLB->save_value();
+    m_xSnapToGridCB->save_state();
+    m_xVertAlignLB->save_value();
+    m_xLeft->save_state();
+    m_xRight->save_state();
+    m_xCenter->save_state();
+    m_xJustify->save_state();
+    m_xLastLineLB->save_value();
+    m_xExpandCB->save_state();
+}
+
+IMPL_LINK_NOARG(SvxParaAlignTabPage, AlignHdl_Impl, weld::Toggleable&, void)
+{
+    bool bJustify = m_xJustify->get_active();
+    m_xLastLineFT->set_sensitive(bJustify);
+    m_xLastLineLB->set_sensitive(bJustify);
+    bool bLastLineIsBlock = m_xLastLineLB->get_active() == 2;
+    m_xExpandCB->set_sensitive(bJustify && bLastLineIsBlock);
+    //set last line listbox to entry position 0 if not enabled
+    if (!m_xLastLineLB->get_sensitive())
+        m_xLastLineLB->set_active(0);
+    //uncheck 'Expand ... word' when check box is not enabled
+    if (!m_xExpandCB->get_sensitive())
+        m_xExpandCB->set_active(false);
+    UpdateExample_Impl();
+}
+
+IMPL_LINK_NOARG(SvxParaAlignTabPage, LastLineHdl_Impl, weld::ComboBox&, void)
+{
+    //fdo#41350 only enable 'Expand last word' if last line is also justified
+    bool bLastLineIsBlock = m_xLastLineLB->get_active() == 2;
+    m_xExpandCB->set_sensitive(bLastLineIsBlock);
+    //uncheck 'Expand ... word' when check box is not enabled
+    if (!m_xExpandCB->get_sensitive())
+        m_xExpandCB->set_active(false);
+    UpdateExample_Impl();
+}
+
+IMPL_LINK_NOARG(SvxParaAlignTabPage, TextDirectionHdl_Impl, weld::ComboBox&, void)
+{
+    UpdateExample_Impl();
+}
+
+void SvxParaAlignTabPage::UpdateExample_Impl()
+{
+    if (m_xLeft->get_active())
+    {
+        m_aExampleWin.EnableRTL(false);
+        m_aExampleWin.SetAdjust(SvxAdjust::Left);
+        m_aExampleWin.SetLastLine(SvxAdjust::Left);
+    }
+    else if (m_xRight->get_active())
+    {
+        m_aExampleWin.EnableRTL(true);
+        m_aExampleWin.SetAdjust(SvxAdjust::Left);
+        m_aExampleWin.SetLastLine(SvxAdjust::Left);
+    }
+    else
+    {
+        SvxFrameDirection eDir = m_xTextDirectionLB->get_active_id();
+        switch ( eDir )
+        {
+            case SvxFrameDirection::Environment :
+                if ( !m_xRight->get_active() )
+                    m_aExampleWin.EnableRTL( AllSettings::GetLayoutRTL() );
+                break;
+            case SvxFrameDirection::Horizontal_RL_TB :
+                if ( !m_xLeft->get_active() )
+                    m_aExampleWin.EnableRTL( true );
+                break;
+            case SvxFrameDirection::Horizontal_LR_TB :
+                if ( !m_xRight->get_active() )
+                    m_aExampleWin.EnableRTL( false );
+                break;
+            default: ; //prevent warning
+        }
+        if (m_xCenter->get_active())
+            m_aExampleWin.SetAdjust( SvxAdjust::Center );
+        else if (m_xJustify->get_active())
+        {
+            m_aExampleWin.SetAdjust( SvxAdjust::Block );
+            int nLBPos = m_xLastLineLB->get_active();
+            if (nLBPos == 0)
+                m_aExampleWin.SetLastLine(SvxAdjust::Left);
+            else if (nLBPos == 1)
+                m_aExampleWin.SetLastLine(SvxAdjust::Center);
+            else if (nLBPos == 2)
+                m_aExampleWin.SetLastLine(SvxAdjust::Block);
+        }
+    }
+
+    m_aExampleWin.Invalidate();
+}
+
+void SvxParaAlignTabPage::EnableJustifyExt()
+{
+    m_xLastLineFT->show();
+    m_xLastLineLB->show();
+    m_xExpandCB->show();
+    if (SvtCJKOptions::IsAsianTypographyEnabled())
+        m_xSnapToGridCB->show();
+
+}
+
+void SvxParaAlignTabPage::EnableSdrVertAlign()
+{
+    m_bSdrVertAlign = true;
+
+    m_xVertAlignLB->remove_id("0");
+    m_xVertAlignLB->remove_id("1");
+    m_xVertAlign->set_label(m_xVertAlignSdr->get_label());
+}
+
+void SvxParaAlignTabPage::PageCreated (const SfxAllItemSet& aSet)
+{
+    const SfxBoolItem* pBoolItem = aSet.GetItem<SfxBoolItem>(SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT, false);
+    if (pBoolItem && pBoolItem->GetValue())
+        EnableJustifyExt();
+}
+
+std::unique_ptr<SfxTabPage> SvxExtParagraphTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet)
+{
+    return std::make_unique<SvxExtParagraphTabPage>(pPage, pController, *rSet);
+}
+
+bool SvxExtParagraphTabPage::FillItemSet( SfxItemSet* rOutSet )
+{
+    bool bModified = false;
+    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
+    const TriState eHyphenState = m_xHyphenBox->get_state();
+    const SfxPoolItem* pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_HYPHENZONE );
+
+    if ( m_xHyphenBox->get_state_changed_from_saved() ||
+         m_xHyphenNoCapsBox->get_state_changed_from_saved() ||
+         m_xHyphenNoLastWordBox->get_state_changed_from_saved() ||
+         m_xExtHyphenBeforeBox->get_value_changed_from_saved() ||
+         m_xExtHyphenAfterBox->get_value_changed_from_saved() ||
+         m_xMaxHyphenEdit->get_value_changed_from_saved() ||
+         m_xMinWordLength->get_value_changed_from_saved() ||
+         m_aHyphenZone.get_value_changed_from_saved() )
+    {
+        SvxHyphenZoneItem aHyphen(
+            static_cast<const SvxHyphenZoneItem&>(GetItemSet().Get( _nWhich )) );
+        aHyphen.SetHyphen( eHyphenState == TRISTATE_TRUE );
+        aHyphen.SetNoCapsHyphenation(m_xHyphenNoCapsBox->get_state() == TRISTATE_TRUE);
+        aHyphen.SetNoLastWordHyphenation(m_xHyphenNoLastWordBox->get_state() == TRISTATE_TRUE);
+
+        if ( eHyphenState == TRISTATE_TRUE )
+        {
+            aHyphen.GetMinLead() = static_cast<sal_uInt8>(m_xExtHyphenBeforeBox->get_value());
+            aHyphen.GetMinTrail() = static_cast<sal_uInt8>(m_xExtHyphenAfterBox->get_value());
+            aHyphen.GetMinWordLength() = static_cast<sal_uInt8>(m_xMinWordLength->get_value());
+        }
+        aHyphen.GetMaxHyphens() = static_cast<sal_uInt8>(m_xMaxHyphenEdit->get_value());
+
+        SfxItemPool* pPool = GetItemSet().GetPool();
+        DBG_ASSERT( pPool, "Where is the pool?" );
+        MapUnit eUnit = pPool->GetMetric( _nWhich );
+        aHyphen.GetTextHyphenZone() = static_cast<sal_uInt16>(m_aHyphenZone.GetCoreValue(eUnit));
+
+        if ( !pOld ||
+            *static_cast<const SvxHyphenZoneItem*>(pOld) != aHyphen ||
+                m_xHyphenBox->get_state_changed_from_saved())
+        {
+            rOutSet->Put( aHyphen );
+            bModified = true;
+        }
+    }
+
+    if (m_xPageNumBox->get_sensitive()
+        && (m_xPageNumBox->get_state_changed_from_saved() || m_xPagenumEdit->get_value_changed_from_saved()))
+    {
+        pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_PAGENUM );
+
+        if (TRISTATE_TRUE == m_xPageNumBox->get_state()
+            && (!pOld || IsInvalidItem(pOld)
+                || static_cast<const SfxUInt16Item*>(pOld)->GetValue() != m_xPagenumEdit->get_value()))
+        {
+            SfxUInt16Item aPageNum(SID_ATTR_PARA_PAGENUM,
+                    static_cast<sal_uInt16>(m_xPagenumEdit->get_value()));
+            rOutSet->Put( aPageNum );
+            bModified = true;
+        }
+        else if (TRISTATE_FALSE == m_xPageNumBox->get_state()
+                && (pOld || IsInvalidItem(pOld)))
+        {
+            // need to tell sw to remove the item
+            rOutSet->DisableItem(SID_ATTR_PARA_PAGENUM);
+            bModified = true;
+        }
+    }
+
+    // pagebreak
+
+    TriState eState = m_xApplyCollBtn->get_state();
+    bool bIsPageModel = false;
+
+    OUString sPage;
+    if ( m_xApplyCollBtn->get_state_changed_from_saved() ||
+         ( TRISTATE_TRUE == eState &&
+           m_xApplyCollBox->get_value_changed_from_saved() ) )
+    {
+        if ( eState == TRISTATE_TRUE )
+        {
+            sPage = m_xApplyCollBox->get_active_text();
+            bIsPageModel = !sPage.isEmpty();
+        }
+        pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_MODEL );
+
+        if ( !pOld || static_cast<const SvxPageModelItem*>(pOld)->GetValue() != sPage )
+        {
+            rOutSet->Put( SvxPageModelItem( sPage, false, SID_ATTR_PARA_MODEL ) );
+            bModified = true;
+        }
+        else
+            bIsPageModel = false;
+    }
+    else if(TRISTATE_TRUE == eState && m_xApplyCollBtn->get_sensitive())
+        bIsPageModel = true;
+    else
+        rOutSet->Put( SvxPageModelItem( sPage, false, SID_ATTR_PARA_MODEL ) );
+
+    _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
+
+    if ( bIsPageModel )
+        // if PageModel is turned on, always turn off PageBreak
+        rOutSet->Put( SvxFormatBreakItem( SvxBreak::NONE, _nWhich ) );
+    else
+    {
+        eState = m_xPageBreakBox->get_state();
+        SfxItemState eModelState = GetItemSet().GetItemState(SID_ATTR_PARA_MODEL, false);
+
+        if ( (eModelState == SfxItemState::SET && TRISTATE_TRUE == m_xPageBreakBox->get_state()) ||
+             m_xPageBreakBox->get_state_changed_from_saved() ||
+             m_xBreakTypeLB->get_value_changed_from_saved() ||
+             m_xBreakPositionLB->get_value_changed_from_saved() )
+        {
+            const SvxFormatBreakItem rOldBreak(
+                    static_cast<const SvxFormatBreakItem&>(GetItemSet().Get( _nWhich )));
+            SvxFormatBreakItem aBreak(rOldBreak.GetBreak(), rOldBreak.Which());
+
+            switch ( eState )
+            {
+                case TRISTATE_TRUE:
+                {
+                    bool bBefore = m_xBreakPositionLB->get_active() == 0;
+
+                    if (m_xBreakTypeLB->get_active() == 0)
+                    {
+                        if ( bBefore )
+                            aBreak.SetValue( SvxBreak::PageBefore );
+                        else
+                            aBreak.SetValue( SvxBreak::PageAfter );
+                    }
+                    else
+                    {
+                        if ( bBefore )
+                            aBreak.SetValue( SvxBreak::ColumnBefore );
+                        else
+                            aBreak.SetValue( SvxBreak::ColumnAfter );
+                    }
+                    break;
+                }
+
+                case TRISTATE_FALSE:
+                    aBreak.SetValue( SvxBreak::NONE );
+                    break;
+                default: ; //prevent warning
+            }
+            pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_PAGEBREAK );
+
+            if ( eState != m_xPageBreakBox->get_saved_state() ||
+                    !pOld || !( *static_cast<const SvxFormatBreakItem*>(pOld) == aBreak ) )
+            {
+                bModified = true;
+                rOutSet->Put( aBreak );
+            }
+        }
+    }
+
+    // paragraph split
+    _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
+    eState = m_xAllowSplitBox->get_state();
+
+    if (m_xAllowSplitBox->get_state_changed_from_saved())
+    {
+        pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_SPLIT );
+
+        if ( !pOld || static_cast<const SvxFormatSplitItem*>(pOld)->GetValue() !=
+                      ( eState == TRISTATE_FALSE ) )
+        {
+            rOutSet->Put( SvxFormatSplitItem( eState == TRISTATE_FALSE, _nWhich ) );
+            bModified = true;
+        }
+    }
+
+    // keep paragraphs
+    _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
+    eState = m_xKeepParaBox->get_state();
+
+    if (m_xKeepParaBox->get_state_changed_from_saved())
+    {
+        // if the status has changed, putting is necessary
+        rOutSet->Put( SvxFormatKeepItem( eState == TRISTATE_TRUE, _nWhich ) );
+        bModified = true;
+    }
+
+    // widows and orphans
+    TypedWhichId<SvxWidowsItem> nWidowsWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
+    eState = m_xWidowBox->get_state();
+
+    if ( m_xWidowBox->get_state_changed_from_saved() ||
+         m_xWidowRowNo->get_value_changed_from_saved() )
+    {
+        SvxWidowsItem rItem( eState == TRISTATE_TRUE ?
+                             static_cast<sal_uInt8>(m_xWidowRowNo->get_value()) : 0, nWidowsWhich );
+        pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_WIDOWS );
+
+        if ( m_xWidowBox->get_state_changed_from_saved() || !pOld || !( *static_cast<const SvxWidowsItem*>(pOld) == rItem ) )
+        {
+            rOutSet->Put( rItem );
+            bModified = true;
+        }
+    }
+
+    TypedWhichId<SvxOrphansItem> nOrphansWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
+    eState = m_xOrphanBox->get_state();
+
+    if ( m_xOrphanBox->get_state_changed_from_saved() ||
+         m_xOrphanRowNo->get_value_changed_from_saved() )
+    {
+        SvxOrphansItem rItem( eState == TRISTATE_TRUE ?
+                             static_cast<sal_uInt8>(m_xOrphanRowNo->get_value()) : 0, nOrphansWhich );
+        pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_ORPHANS );
+
+        if ( m_xOrphanBox->get_state_changed_from_saved() ||
+                !pOld ||
+                    !( *static_cast<const SvxOrphansItem*>(pOld) == rItem ) )
+        {
+            rOutSet->Put( rItem );
+            bModified = true;
+        }
+    }
+
+    return bModified;
+}
+void SvxExtParagraphTabPage::Reset( const SfxItemSet* rSet )
+{
+    SfxItemPool* pPool = rSet->GetPool();
+    DBG_ASSERT( pPool, "Where is the pool?" );
+
+    // adjust metric
+    FieldUnit eFUnit = GetModuleFieldUnit( *rSet );
+    if (UseCharUnitInUI(*rSet))
+        eFUnit = FieldUnit::CHAR;
+
+    sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
+    SfxItemState eItemState = rSet->GetItemState( _nWhich );
+
+    bool bItemAvailable = eItemState >= SfxItemState::DEFAULT;
+    bool bIsHyphen = false;
+    if( !bHtmlMode && bItemAvailable )
+    {
+        const SvxHyphenZoneItem& rHyphen =
+            static_cast<const SvxHyphenZoneItem&>(rSet->Get( _nWhich ));
+        aHyphenState.bTriStateEnabled = false;
+
+        bIsHyphen = rHyphen.IsHyphen();
+        m_xHyphenBox->set_state(bIsHyphen ? TRISTATE_TRUE : TRISTATE_FALSE);
+        m_xHyphenNoCapsBox->set_state(rHyphen.IsNoCapsHyphenation() ? TRISTATE_TRUE : TRISTATE_FALSE);
+        m_xHyphenNoLastWordBox->set_state(rHyphen.IsNoLastWordHyphenation() ? TRISTATE_TRUE : TRISTATE_FALSE);
+
+        m_xExtHyphenBeforeBox->set_value(rHyphen.GetMinLead());
+        m_xExtHyphenAfterBox->set_value(rHyphen.GetMinTrail());
+        m_xMaxHyphenEdit->set_value(rHyphen.GetMaxHyphens());
+        m_xMinWordLength->set_value(rHyphen.GetMinWordLength());
+        m_aHyphenZone.SetFieldUnit(eFUnit);
+        m_aHyphenZone.SetMetricValue(rHyphen.GetTextHyphenZone(), MapUnit::MapTwip);
+    }
+    else
+    {
+        m_xHyphenBox->set_state(TRISTATE_INDET);
+        m_xHyphenNoCapsBox->set_state(TRISTATE_INDET);
+        m_xHyphenNoLastWordBox->set_state(TRISTATE_INDET);
+    }
+    bool bEnable = bItemAvailable && bIsHyphen;
+    m_xHyphenNoCapsBox->set_sensitive(bEnable);
+    m_xHyphenNoLastWordBox->set_sensitive(bEnable);
+    m_xExtHyphenBeforeBox->set_sensitive(bEnable);
+    m_xExtHyphenAfterBox->set_sensitive(bEnable);
+    m_xBeforeText->set_sensitive(bEnable);
+    m_xAfterText->set_sensitive(bEnable);
+    m_xMaxHyphenLabel->set_sensitive(bEnable);
+    m_xMaxHyphenEdit->set_sensitive(bEnable);
+    m_xMinWordLabel->set_sensitive(bEnable);
+    m_xMinWordLength->set_sensitive(bEnable);
+    m_xHyphenZoneLabel->set_sensitive(bEnable);
+    m_aHyphenZone.set_sensitive(bEnable);
+
+    switch (rSet->GetItemState(SID_ATTR_PARA_PAGENUM))
+    {
+        case SfxItemState::SET:
+        {
+            aPageNumState.bTriStateEnabled = false;
+            m_xPageNumBox->set_state(TRISTATE_TRUE);
+            SfxUInt16Item const*const pItem(rSet->GetItem<SfxUInt16Item>(SID_ATTR_PARA_PAGENUM));
+            const sal_uInt16 nPageNum(pItem->GetValue());
+            m_xPagenumEdit->set_value(nPageNum);
+            break;
+        }
+        case SfxItemState::DONTCARE:
+        {
+            aPageNumState.bTriStateEnabled = true;
+            m_xPageNumBox->set_state(TRISTATE_INDET);
+            break;
+        }
+        case SfxItemState::UNKNOWN:
+        case SfxItemState::DEFAULT:
+        case SfxItemState::DISABLED:
+        {
+            aPageNumState.bTriStateEnabled = false;
+            m_xPageNumBox->set_state(TRISTATE_FALSE);
+            break;
+        }
+        default:
+            assert(false); // unexpected
+            break;
+    }
+
+    if ( bPageBreak )
+    {
+        // first handle PageModel
+        bool bIsPageModel = false;
+        eItemState = rSet->GetItemState( SID_ATTR_PARA_MODEL );
+
+        if ( eItemState >= SfxItemState::SET )
+        {
+            aApplyCollState.bTriStateEnabled = false;
+
+            const SvxPageModelItem& rModel = rSet->Get( SID_ATTR_PARA_MODEL );
+            const OUString& aStr( rModel.GetValue() );
+
+            if (!aStr.isEmpty() && m_xApplyCollBox->find_text(aStr) != -1)
+            {
+                m_xApplyCollBox->set_active_text(aStr);
+                m_xApplyCollBtn->set_state(TRISTATE_TRUE);
+                bIsPageModel = true;
+
+                m_xPageBreakBox->set_sensitive(true);
+                aPageBreakState.bTriStateEnabled = false;
+                m_xBreakTypeFT->set_sensitive(true);
+                m_xBreakTypeLB->set_sensitive(true);
+                m_xBreakPositionFT->set_sensitive(true);
+                m_xBreakPositionLB->set_sensitive(true);
+                m_xApplyCollBtn->set_sensitive(false);
+                m_xPageBreakBox->set_state(TRISTATE_TRUE);
+
+                //select page break
+                m_xBreakTypeLB->set_active(0);
+                //select break before
+                m_xBreakPositionLB->set_active(0);
+            }
+            else
+            {
+                m_xApplyCollBox->set_active(-1);
+                m_xApplyCollBtn->set_state(TRISTATE_FALSE);
+            }
+        }
+        else if ( SfxItemState::DONTCARE == eItemState )
+        {
+            aApplyCollState.bTriStateEnabled = true;
+            m_xApplyCollBtn->set_state(TRISTATE_INDET);
+            m_xApplyCollBox->set_active(-1);
+        }
+        else
+        {
+            m_xApplyCollBtn->set_sensitive(false);
+            m_xApplyCollBox->set_sensitive(false);
+            m_xPagenumEdit->set_sensitive(false);
+            m_xPageNumBox->set_sensitive(false);
+        }
+
+        if ( !bIsPageModel )
+        {
+            _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
+            eItemState = rSet->GetItemState( _nWhich );
+
+            if ( eItemState >= SfxItemState::DEFAULT )
+            {
+                const SvxFormatBreakItem& rPageBreak =
+                    static_cast<const SvxFormatBreakItem&>(rSet->Get( _nWhich ));
+
+                SvxBreak eBreak = rPageBreak.GetBreak();
+
+                // PageBreak not via CTRL-RETURN,
+                // then CheckBox can be freed
+                m_xPageBreakBox->set_sensitive(true);
+                aPageBreakState.bTriStateEnabled = false;
+                m_xBreakTypeFT->set_sensitive(true);
+                m_xBreakTypeLB->set_sensitive(true);
+                m_xBreakPositionFT->set_sensitive(true);
+                m_xBreakPositionLB->set_sensitive(true);
+
+                m_xPageBreakBox->set_state(TRISTATE_TRUE);
+
+                bool _bEnable =     eBreak != SvxBreak::NONE &&
+                                eBreak != SvxBreak::ColumnBefore &&
+                                eBreak != SvxBreak::ColumnAfter;
+                m_xApplyCollBtn->set_sensitive(_bEnable);
+                if (!_bEnable)
+                {
+                    m_xApplyCollBox->set_sensitive(_bEnable);
+                    m_xPageNumBox->set_sensitive(false);
+                    m_xPagenumEdit->set_sensitive(_bEnable);
+                }
+
+                if ( eBreak == SvxBreak::NONE )
+                    m_xPageBreakBox->set_state(TRISTATE_FALSE);
+
+                sal_Int32 nType = 0; // selection position in break type ListBox : Page
+                sal_Int32 nPosition = 0; //  selection position in break position ListBox : Before
+                switch ( eBreak )
+                {
+                    case SvxBreak::PageBefore:
+                        break;
+                    case SvxBreak::PageAfter:
+                        nPosition = 1;
+                        break;
+                    case SvxBreak::ColumnBefore:
+                        nType = 1;
+                        break;
+                    case SvxBreak::ColumnAfter:
+                        nType = 1;
+                        nPosition = 1;
+                        break;
+                    default: ;//prevent warning
+                }
+                m_xBreakTypeLB->set_active(nType);
+                m_xBreakPositionLB->set_active(nPosition);
+            }
+            else if ( SfxItemState::DONTCARE == eItemState )
+                m_xPageBreakBox->set_state(TRISTATE_INDET);
+            else
+            {
+                m_xPageBreakBox->set_sensitive(false);
+                m_xBreakTypeFT->set_sensitive(false);
+                m_xBreakTypeLB->set_sensitive(false);
+                m_xBreakPositionFT->set_sensitive(false);
+                m_xBreakPositionLB->set_sensitive(false);
+            }
+        }
+
+        PageBreakPosHdl_Impl(*m_xBreakPositionLB);
+        PageBreakHdl();
+    }
+
+    _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
+    eItemState = rSet->GetItemState( _nWhich );
+
+    if ( eItemState >= SfxItemState::DEFAULT )
+    {
+        aKeepParaState.bTriStateEnabled = false;
+        const SvxFormatKeepItem& rKeep =
+            static_cast<const SvxFormatKeepItem&>(rSet->Get( _nWhich ));
+
+        if ( rKeep.GetValue() )
+            m_xKeepParaBox->set_state(TRISTATE_TRUE);
+        else
+            m_xKeepParaBox->set_state(TRISTATE_FALSE);
+    }
+    else if ( SfxItemState::DONTCARE == eItemState )
+        m_xKeepParaBox->set_state(TRISTATE_INDET);
+    else
+        m_xKeepParaBox->set_sensitive(false);
+
+    _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
+    eItemState = rSet->GetItemState( _nWhich );
+
+    if ( eItemState >= SfxItemState::DEFAULT )
+    {
+        const SvxFormatSplitItem& rSplit =
+            static_cast<const SvxFormatSplitItem&>(rSet->Get( _nWhich ));
+        aAllowSplitState.bTriStateEnabled = false;
+
+        if ( !rSplit.GetValue() )
+            m_xAllowSplitBox->set_state(TRISTATE_FALSE);
+        else
+        {
+            m_xAllowSplitBox->set_state(TRISTATE_TRUE);
+            // default widows and orphans to enabled
+            m_xWidowBox->set_sensitive(true);
+            m_xOrphanBox->set_sensitive(true);
+        }
+
+        // widows and orphans
+        _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
+        SfxItemState eTmpState = rSet->GetItemState( _nWhich );
+
+        if ( eTmpState >= SfxItemState::DEFAULT )
+        {
+            const SvxWidowsItem& rWidow =
+                static_cast<const SvxWidowsItem&>(rSet->Get( _nWhich ));
+            aWidowState.bTriStateEnabled = false;
+            const sal_uInt16 nLines = rWidow.GetValue();
+
+            bool _bEnable = nLines > 0;
+            m_xWidowRowNo->set_value(m_xWidowRowNo->normalize(nLines));
+            m_xWidowBox->set_state(_bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
+            m_xWidowRowNo->set_sensitive(_bEnable);
+        }
+        else if ( SfxItemState::DONTCARE == eTmpState )
+            m_xWidowBox->set_state( TRISTATE_INDET );
+        else
+            m_xWidowBox->set_sensitive(false);
+
+        _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
+        eTmpState = rSet->GetItemState( _nWhich );
+
+        if ( eTmpState >= SfxItemState::DEFAULT )
+        {
+            const SvxOrphansItem& rOrphan =
+                static_cast<const SvxOrphansItem&>(rSet->Get( _nWhich ));
+            const sal_uInt16 nLines = rOrphan.GetValue();
+            aOrphanState.bTriStateEnabled = false;
+
+            bool _bEnable = nLines > 0;
+            m_xOrphanBox->set_state(_bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
+            m_xOrphanRowNo->set_value(m_xOrphanRowNo->normalize(nLines));
+            m_xOrphanRowNo->set_sensitive(_bEnable);
+            m_xOrphanRowLabel->set_sensitive(_bEnable);
+
+        }
+        else if ( SfxItemState::DONTCARE == eTmpState )
+            m_xOrphanBox->set_state(TRISTATE_INDET);
+        else
+            m_xOrphanBox->set_sensitive(false);
+        aOrphanState.eState = m_xOrphanBox->get_state();
+    }
+    else if ( SfxItemState::DONTCARE == eItemState )
+        m_xAllowSplitBox->set_state(TRISTATE_INDET);
+    else
+        m_xAllowSplitBox->set_sensitive(false);
+
+    // so that everything is enabled correctly
+    AllowSplitHdl();
+    WidowHdl();
+    OrphanHdl();
+    ChangesApplied();
+}
+void SvxExtParagraphTabPage::ChangesApplied()
+{
+    m_xHyphenBox->save_state();
+    m_xHyphenNoCapsBox->save_state();
+    m_xHyphenNoLastWordBox->save_state();
+    m_xExtHyphenBeforeBox->save_value();
+    m_xExtHyphenAfterBox->save_value();
+    m_xMaxHyphenEdit->save_value();
+    m_xMinWordLength->save_value();
+    m_aHyphenZone.save_value();
+    m_xPageBreakBox->save_state();
+    m_xBreakPositionLB->save_value();
+    m_xBreakTypeLB->save_value();
+    m_xApplyCollBtn->save_state();
+    m_xApplyCollBox->save_value();
+    m_xPageNumBox->save_state();
+    m_xPagenumEdit->save_value();
+    m_xAllowSplitBox->save_state();
+    m_xKeepParaBox->save_state();
+    m_xWidowBox->save_state();
+    m_xOrphanBox->save_state();
+    m_xOrphanRowNo->save_value();
+    m_xWidowRowNo->save_value();
+}
+
+DeactivateRC SvxExtParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
+{
+    if ( _pSet )
+        FillItemSet( _pSet );
+    return DeactivateRC::LeavePage;
+}
+
+void SvxExtParagraphTabPage::DisablePageBreak()
+{
+    bPageBreak = false;
+    m_xPageBreakBox->set_sensitive(false);
+    m_xBreakTypeLB->remove(0);
+    m_xBreakPositionFT->set_sensitive(false);
+    m_xBreakPositionLB->set_sensitive(false);
+    m_xApplyCollBtn->set_sensitive(false);
+    m_xApplyCollBox->set_sensitive(false);
+    m_xPageNumBox->set_sensitive(false);
+    m_xPagenumEdit->set_sensitive(false);
+}
+
+SvxExtParagraphTabPage::SvxExtParagraphTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttr)
+    : SfxTabPage(pPage, pController, "cui/ui/textflowpage.ui", "TextFlowPage", &rAttr)
+    , bPageBreak(true)
+    , bHtmlMode(false)
+    , nStdPos(0)
+    // Hyphenation
+    , m_xHyphenBox(m_xBuilder->weld_check_button("checkAuto"))
+    , m_xHyphenNoCapsBox(m_xBuilder->weld_check_button("checkNoCaps"))
+    , m_xHyphenNoLastWordBox(m_xBuilder->weld_check_button("checkNoLastWord"))
+    , m_xBeforeText(m_xBuilder->weld_label("labelLineBegin"))
+    , m_xExtHyphenBeforeBox(m_xBuilder->weld_spin_button("spinLineEnd"))
+    , m_xAfterText(m_xBuilder->weld_label("labelLineEnd"))
+    , m_xExtHyphenAfterBox(m_xBuilder->weld_spin_button("spinLineBegin"))
+    , m_xMaxHyphenLabel(m_xBuilder->weld_label("labelMaxNum"))
+    , m_xMaxHyphenEdit(m_xBuilder->weld_spin_button("spinMaxNum"))
+    , m_xMinWordLabel(m_xBuilder->weld_label("labelMinLen"))
+    , m_xMinWordLength(m_xBuilder->weld_spin_button("spinMinLen"))
+    , m_xHyphenZoneLabel(m_xBuilder->weld_label("labelHyphenZone"))
+    , m_aHyphenZone(m_xBuilder->weld_metric_spin_button("spinHyphenZone", FieldUnit::CM))
+    //Page break
+    , m_xPageBreakBox(m_xBuilder->weld_check_button("checkInsert"))
+    , m_xBreakTypeFT(m_xBuilder->weld_label("labelType"))
+    , m_xBreakTypeLB(m_xBuilder->weld_combo_box("comboBreakType"))
+    , m_xBreakPositionFT(m_xBuilder->weld_label("labelPosition"))
+    , m_xBreakPositionLB(m_xBuilder->weld_combo_box("comboBreakPosition"))
+    , m_xApplyCollBtn(m_xBuilder->weld_check_button("checkPageStyle"))
+    , m_xApplyCollBox(m_xBuilder->weld_combo_box("comboPageStyle"))
+    , m_xPageNumBox(m_xBuilder->weld_check_button("labelPageNum"))
+    , m_xPagenumEdit(m_xBuilder->weld_spin_button("spinPageNumber"))
+    // Options
+    , m_xAllowSplitBox(m_xBuilder->weld_check_button("checkSplitPara"))
+    , m_xKeepParaBox(m_xBuilder->weld_check_button("checkKeepPara"))
+    , m_xOrphanBox(m_xBuilder->weld_check_button("checkOrphan"))
+    , m_xOrphanRowNo(m_xBuilder->weld_spin_button("spinOrphan"))
+    , m_xOrphanRowLabel(m_xBuilder->weld_label("labelOrphan"))
+    , m_xWidowBox(m_xBuilder->weld_check_button("checkWidow"))
+    , m_xWidowRowNo(m_xBuilder->weld_spin_button("spinWidow"))
+    , m_xWidowRowLabel(m_xBuilder->weld_label("labelWidow"))
+{
+    // this page needs ExchangeSupport
+    SetExchangeSupport();
+
+    m_xHyphenBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, HyphenClickHdl_Impl));
+    m_xPageBreakBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, PageBreakHdl_Impl));
+    m_xAllowSplitBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, AllowSplitHdl_Impl));
+    m_xWidowBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, WidowHdl_Impl));
+    m_xOrphanBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, OrphanHdl_Impl));
+    m_xApplyCollBtn->connect_toggled(LINK(this, SvxExtParagraphTabPage, ApplyCollClickHdl_Impl));
+    m_xBreakTypeLB->connect_changed(LINK(this, SvxExtParagraphTabPage, PageBreakTypeHdl_Impl));
+    m_xBreakPositionLB->connect_changed(LINK(this, SvxExtParagraphTabPage, PageBreakPosHdl_Impl));
+    m_xPageNumBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, PageNumBoxClickHdl_Impl));
+    m_xKeepParaBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, KeepParaBoxClickHdl_Impl));
+
+    if (SfxObjectShell* pSh = SfxObjectShell::Current())
+    {
+        SfxStyleSheetBasePool* pPool = pSh->GetStyleSheetPool();
+        SfxStyleSheetBase* pStyle = pPool->First(SfxStyleFamily::Page);
+        OUString aStdName;
+
+        // tdf139131 - sort page styles
+        m_xApplyCollBox->make_sorted();
+        while( pStyle )
+        {
+            if ( aStdName.isEmpty() )
+                // first style == standard style
+                aStdName = pStyle->GetName();
+            m_xApplyCollBox->append_text(pStyle->GetName());
+            pStyle = pPool->Next();
+        }
+        nStdPos = m_xApplyCollBox->find_text(aStdName);
+    }
+
+    sal_uInt16 nHtmlMode = GetHtmlMode_Impl( rAttr );
+    if ( !(nHtmlMode & HTMLMODE_ON) )
+        return;
+
+    bHtmlMode = true;
+    m_xHyphenBox->set_sensitive(false);
+    m_xHyphenNoCapsBox->set_sensitive(false);
+    m_xHyphenNoLastWordBox->set_sensitive(false);
+    m_xBeforeText->set_sensitive(false);
+    m_xExtHyphenBeforeBox->set_sensitive(false);
+    m_xAfterText->set_sensitive(false);
+    m_xExtHyphenAfterBox->set_sensitive(false);
+    m_xMaxHyphenLabel->set_sensitive(false);
+    m_xMaxHyphenEdit->set_sensitive(false);
+    m_xMinWordLabel->set_sensitive(false);
+    m_xMinWordLength->set_sensitive(false);
+    m_xHyphenZoneLabel->set_sensitive(false);
+    m_aHyphenZone.set_sensitive(false);
+    m_xPageNumBox->set_sensitive(false);
+    m_xPagenumEdit->set_sensitive(false);
+    // no column break in HTML
+    m_xBreakTypeLB->remove(1);
+}
+
+SvxExtParagraphTabPage::~SvxExtParagraphTabPage()
+{
+}
+
+void SvxExtParagraphTabPage::PageBreakHdl()
+{
+    switch (m_xPageBreakBox->get_state())
+    {
+        case TRISTATE_TRUE:
+            m_xBreakTypeFT->set_sensitive(true);
+            m_xBreakTypeLB->set_sensitive(true);
+            m_xBreakPositionFT->set_sensitive(true);
+            m_xBreakPositionLB->set_sensitive(true);
+
+            if (0 == m_xBreakTypeLB->get_active() && 0 == m_xBreakPositionLB->get_active())
+            {
+                m_xApplyCollBtn->set_sensitive(true);
+
+                bool bEnable = TRISTATE_TRUE == m_xApplyCollBtn->get_state() &&
+                                            m_xApplyCollBox->get_count();
+                m_xApplyCollBox->set_sensitive(bEnable);
+                if(!bHtmlMode)
+                {
+                    m_xPageNumBox->set_sensitive(bEnable);
+                    m_xPagenumEdit->set_sensitive(bEnable && m_xPageNumBox->get_state() == TRISTATE_TRUE);
+                }
+            }
+            break;
+
+        case TRISTATE_FALSE:
+        case TRISTATE_INDET:
+            m_xApplyCollBtn->set_state(TRISTATE_FALSE);
+            m_xApplyCollBtn->set_sensitive(false);
+            m_xApplyCollBox->set_sensitive(false);
+            m_xPageNumBox->set_sensitive(false);
+            m_xPagenumEdit->set_sensitive(false);
+            m_xBreakTypeFT->set_sensitive(false);
+            m_xBreakTypeLB->set_sensitive(false);
+            m_xBreakPositionFT->set_sensitive(false);
+            m_xBreakPositionLB->set_sensitive(false);
+            break;
+    }
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, PageBreakHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aPageBreakState.ButtonToggled(rToggle);
+    PageBreakHdl();
+}
+
+void SvxExtParagraphTabPage::AllowSplitHdl()
+{
+    bool bEnable = m_xAllowSplitBox->get_state() == TRISTATE_TRUE;
+    m_xWidowBox->set_sensitive(bEnable);
+    m_xOrphanBox->set_sensitive(bEnable);
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, AllowSplitHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aAllowSplitState.ButtonToggled(rToggle);
+    AllowSplitHdl();
+}
+
+void SvxExtParagraphTabPage::WidowHdl()
+{
+    switch (m_xWidowBox->get_state())
+    {
+        case TRISTATE_TRUE:
+            m_xWidowRowNo->set_sensitive(true);
+            m_xWidowRowLabel->set_sensitive(true);
+            m_xAllowSplitBox->set_sensitive(true);
+            break;
+        case TRISTATE_FALSE:
+            if (m_xOrphanBox->get_state() == TRISTATE_FALSE)
+                m_xAllowSplitBox->set_sensitive(false);
+            [[fallthrough]];
+        case TRISTATE_INDET:
+            m_xWidowRowNo->set_sensitive(false);
+            m_xWidowRowLabel->set_sensitive(false);
+            break;
+    }
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, WidowHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aWidowState.ButtonToggled(rToggle);
+    WidowHdl();
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, OrphanHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aOrphanState.ButtonToggled(rToggle);
+    OrphanHdl();
+}
+
+void SvxExtParagraphTabPage::OrphanHdl()
+{
+    switch (m_xOrphanBox->get_state())
+    {
+        case TRISTATE_TRUE:
+            m_xOrphanRowNo->set_sensitive(true);
+            m_xOrphanRowLabel->set_sensitive(true);
+            m_xAllowSplitBox->set_sensitive(true);
+            break;
+
+        case TRISTATE_FALSE:
+            if (m_xWidowBox->get_state() == TRISTATE_FALSE)
+                m_xAllowSplitBox->set_sensitive(true);
+            [[fallthrough]];
+        case TRISTATE_INDET:
+            m_xOrphanRowNo->set_sensitive(false);
+            m_xOrphanRowLabel->set_sensitive(false);
+            break;
+    }
+}
+
+void SvxExtParagraphTabPage::HyphenClickHdl()
+{
+    bool bEnable = m_xHyphenBox->get_state() == TRISTATE_TRUE;
+    m_xHyphenNoCapsBox->set_sensitive(bEnable);
+    m_xHyphenNoLastWordBox->set_sensitive(bEnable);
+    m_xBeforeText->set_sensitive(bEnable);
+    m_xExtHyphenBeforeBox->set_sensitive(bEnable);
+    m_xAfterText->set_sensitive(bEnable);
+    m_xExtHyphenAfterBox->set_sensitive(bEnable);
+    m_xMaxHyphenLabel->set_sensitive(bEnable);
+    m_xMaxHyphenEdit->set_sensitive(bEnable);
+    m_xMinWordLabel->set_sensitive(bEnable);
+    m_xMinWordLength->set_sensitive(bEnable);
+    m_xHyphenZoneLabel->set_sensitive(bEnable);
+    m_aHyphenZone.set_sensitive(bEnable);
+    m_xHyphenBox->set_state(bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, HyphenClickHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aHyphenState.ButtonToggled(rToggle);
+    HyphenClickHdl();
+}
+
+void SvxExtParagraphTabPage::ApplyCollClickHdl()
+{
+    bool bEnable = false;
+    if (m_xApplyCollBtn->get_state() == TRISTATE_TRUE && m_xApplyCollBox->get_count())
+    {
+        bEnable = true;
+        m_xApplyCollBox->set_active(nStdPos);
+    }
+    else
+    {
+        m_xApplyCollBox->set_active(-1);
+    }
+    m_xApplyCollBox->set_sensitive(bEnable);
+    if (!bHtmlMode)
+    {
+        m_xPageNumBox->set_sensitive(bEnable);
+        m_xPagenumEdit->set_sensitive(bEnable && m_xPageNumBox->get_state() == TRISTATE_TRUE);
+    }
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, ApplyCollClickHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aApplyCollState.ButtonToggled(rToggle);
+    ApplyCollClickHdl();
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, PageBreakPosHdl_Impl, weld::ComboBox&, rListBox, void)
+{
+    if (0 == rListBox.get_active())
+    {
+        m_xApplyCollBtn->set_sensitive(true);
+
+        bool bEnable = m_xApplyCollBtn->get_state() == TRISTATE_TRUE && m_xApplyCollBox->get_count();
+
+        m_xApplyCollBox->set_sensitive(bEnable);
+        if (!bHtmlMode)
+        {
+            m_xPageNumBox->set_sensitive(bEnable);
+            m_xPagenumEdit->set_sensitive(bEnable && m_xPageNumBox->get_state() == TRISTATE_TRUE);
+        }
+    }
+    else if (1 == rListBox.get_active())
+    {
+        m_xApplyCollBtn->set_state(TRISTATE_FALSE);
+        m_xApplyCollBtn->set_sensitive(false);
+        m_xApplyCollBox->set_sensitive(false);
+        m_xPageNumBox->set_sensitive(false);
+        m_xPagenumEdit->set_sensitive(false);
+    }
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, PageBreakTypeHdl_Impl, weld::ComboBox&, rListBox, void)
+{
+    //column break or break after
+    int nBreakPos = m_xBreakPositionLB->get_active();
+    if (rListBox.get_active() == 1 || 1 == nBreakPos)
+    {
+        m_xApplyCollBtn->set_state(TRISTATE_FALSE);
+        m_xApplyCollBtn->set_sensitive(false);
+        m_xApplyCollBox->set_sensitive(false);
+        m_xPageNumBox->set_sensitive(false);
+        m_xPagenumEdit->set_sensitive(false);
+    }
+    else
+        PageBreakPosHdl_Impl(*m_xBreakPositionLB);
+}
+
+void SvxExtParagraphTabPage::PageNumBoxClickHdl()
+{
+    m_xPagenumEdit->set_sensitive(m_xPageNumBox->get_state() == TRISTATE_TRUE);
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, PageNumBoxClickHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aPageNumState.ButtonToggled(rToggle);
+    PageNumBoxClickHdl();
+}
+
+IMPL_LINK(SvxExtParagraphTabPage, KeepParaBoxClickHdl_Impl, weld::Toggleable&, rToggle, void)
+{
+    aKeepParaState.ButtonToggled(rToggle);
+}
+
+void SvxExtParagraphTabPage::PageCreated(const SfxAllItemSet& aSet)
+{
+    const SfxBoolItem* pDisablePageBreakItem = aSet.GetItem<SfxBoolItem>(SID_DISABLE_SVXEXTPARAGRAPHTABPAGE_PAGEBREAK, false);
+
+    if (pDisablePageBreakItem)
+        if ( pDisablePageBreakItem->GetValue())
+                    DisablePageBreak();
+}
+
+SvxAsianTabPage::SvxAsianTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
+    : SfxTabPage(pPage, pController, "cui/ui/asiantypography.ui", "AsianTypography", &rSet)
+    , m_xForbiddenRulesCB(m_xBuilder->weld_check_button("checkForbidList"))
+    , m_xHangingPunctCB(m_xBuilder->weld_check_button("checkHangPunct"))
+    , m_xScriptSpaceCB(m_xBuilder->weld_check_button("checkApplySpacing"))
+{
+}
+
+SvxAsianTabPage::~SvxAsianTabPage()
+{
+}
+
+std::unique_ptr<SfxTabPage> SvxAsianTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet)
+{
+    return std::make_unique<SvxAsianTabPage>(pPage, pController, *rSet);
+}
+
+WhichRangesContainer SvxAsianTabPage::GetRanges()
+{
+    return WhichRangesContainer(svl::Items<SID_ATTR_PARA_SCRIPTSPACE, SID_ATTR_PARA_FORBIDDEN_RULES>);
+}
+
+bool SvxAsianTabPage::FillItemSet( SfxItemSet* rSet )
+{
+    bool bRet = false;
+    SfxItemPool* pPool = rSet->GetPool();
+    if (m_xScriptSpaceCB->get_sensitive() && m_xScriptSpaceCB->get_state_changed_from_saved())
+    {
+        std::unique_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get(
+            pPool->GetWhich(SID_ATTR_PARA_SCRIPTSPACE)).Clone()));
+        pNewItem->SetValue(m_xScriptSpaceCB->get_active());
+        rSet->Put(std::move(pNewItem));
+        bRet = true;
+    }
+    if (m_xHangingPunctCB->get_sensitive() && m_xHangingPunctCB->get_state_changed_from_saved())
+    {
+        std::unique_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get(
+            pPool->GetWhich(SID_ATTR_PARA_HANGPUNCTUATION)).Clone()));
+        pNewItem->SetValue(m_xHangingPunctCB->get_active());
+        rSet->Put(std::move(pNewItem));
+        bRet = true;
+    }
+    if (m_xForbiddenRulesCB->get_sensitive() && m_xForbiddenRulesCB->get_state_changed_from_saved())
+    {
+        std::unique_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get(
+            pPool->GetWhich(SID_ATTR_PARA_FORBIDDEN_RULES)).Clone()));
+        pNewItem->SetValue(m_xForbiddenRulesCB->get_active());
+        rSet->Put(std::move(pNewItem));
+        bRet = true;
+    }
+    return bRet;
+}
+
+static void lcl_SetBox(const SfxItemSet& rSet, sal_uInt16 nSlotId, weld::CheckButton& rBox)
+{
+    sal_uInt16 _nWhich = rSet.GetPool()->GetWhich(nSlotId);
+    SfxItemState eState = rSet.GetItemState(_nWhich);
+    if( eState == SfxItemState::UNKNOWN || eState == SfxItemState::DISABLED )
+        rBox.set_sensitive(false);
+    else if(eState >= SfxItemState::DEFAULT)
+        rBox.set_active(static_cast<const SfxBoolItem&>(rSet.Get(_nWhich)).GetValue());
+    else
+        rBox.set_state(TRISTATE_INDET);
+    rBox.save_state();
+}
+
+void SvxAsianTabPage::Reset( const SfxItemSet* rSet )
+{
+    lcl_SetBox(*rSet, SID_ATTR_PARA_FORBIDDEN_RULES, *m_xForbiddenRulesCB );
+    lcl_SetBox(*rSet, SID_ATTR_PARA_HANGPUNCTUATION, *m_xHangingPunctCB );
+
+    //character distance not yet available
+    lcl_SetBox(*rSet, SID_ATTR_PARA_SCRIPTSPACE, *m_xScriptSpaceCB );
+}
+
+void SvxAsianTabPage::ChangesApplied()
+{
+    m_xForbiddenRulesCB->save_state();
+    m_xHangingPunctCB->save_state();
+    m_xScriptSpaceCB->save_state();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */