/* -*- 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include 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(lValue) ); break; case LLINESPACE_MIN: rLineSpace.SetLineHeight( static_cast(lValue) ); rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); break; case LLINESPACE_DURCH: rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); rLineSpace.SetInterLineSpace( static_cast(lValue) ); break; case LLINESPACE_FIX: rLineSpace.SetLineHeight(static_cast(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 SvxStdParagraphTabPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) { return std::make_unique(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(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(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(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(GetItemSet().GetParent()->Get( nWhich )); if ( m_aTopDist.IsRelative() ) aMargin.SetUpper( rOldItem.GetUpper(), static_cast(m_aTopDist.get_value(FieldUnit::NONE)) ); else aMargin.SetUpper( static_cast(m_aTopDist.GetCoreValue(eUnit)) ); if ( m_aBottomDist.IsRelative() ) aMargin.SetLower( rOldItem.GetLower(), static_cast(m_aBottomDist.get_value(FieldUnit::NONE)) ); else aMargin.SetLower( static_cast(m_aBottomDist.GetCoreValue(eUnit)) ); } else { aMargin.SetUpper(static_cast(m_aTopDist.GetCoreValue(eUnit))); aMargin.SetLower(static_cast(m_aBottomDist.GetCoreValue(eUnit))); } aMargin.SetContextValue(m_xContextualCB->get_active()); if ( !pOld || *static_cast(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(GetItemSet().GetParent()->Get(nWhich))); if (m_aLeftIndent.IsRelative()) { item.SetTextLeft(rOldItem.GetTextLeft(), static_cast(m_aLeftIndent.get_value(FieldUnit::NONE))); } else { item.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit)); } } else { item.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit)); } if (!pOld || *static_cast(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(GetItemSet().GetParent()->Get(nWhich))); if (m_aRightIndent.IsRelative()) { item.SetRight(rOldItem.GetRight(), static_cast(m_aRightIndent.get_value(FieldUnit::NONE))); } else { item.SetRight(m_aRightIndent.GetCoreValue(eUnit)); } } else { item.SetRight(m_aRightIndent.GetCoreValue(eUnit)); } if (!pOld || *static_cast(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(GetItemSet().GetParent()->Get(nWhich))); if (m_aFLineIndent.IsRelative()) { item.SetTextFirstLineOffset(rOldItem.GetTextFirstLineOffset(), static_cast(m_aFLineIndent.get_value(FieldUnit::NONE))); } else { item.SetTextFirstLineOffset(static_cast(m_aFLineIndent.GetCoreValue(eUnit))); } } else { item.SetTextFirstLineOffset(static_cast(m_aFLineIndent.GetCoreValue(eUnit))); } item.SetAutoFirst(m_xAutoCB->get_active()); if (item.GetTextFirstLineOffset() < 0) { bNullTab = true; } if (!pOld || *static_cast(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(GetItemSet().GetParent()->Get( nWhich )); if (m_aLeftIndent.IsRelative()) aMargin.SetTextLeft( rOldItem.GetTextLeft(), static_cast(m_aLeftIndent.get_value(FieldUnit::NONE)) ); else aMargin.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit)); if ( m_aRightIndent.IsRelative() ) aMargin.SetRight( rOldItem.GetRight(), static_cast(m_aRightIndent.get_value(FieldUnit::NONE)) ); else aMargin.SetRight(m_aRightIndent.GetCoreValue(eUnit)); if ( m_aFLineIndent.IsRelative() ) aMargin.SetTextFirstLineOffset( rOldItem.GetTextFirstLineOffset(), static_cast(m_aFLineIndent.get_value(FieldUnit::NONE)) ); else aMargin.SetTextFirstLineOffset(static_cast(m_aFLineIndent.GetCoreValue(eUnit))); } else { aMargin.SetTextLeft(m_aLeftIndent.GetCoreValue(eUnit)); aMargin.SetRight(m_aRightIndent.GetCoreValue(eUnit)); aMargin.SetTextFirstLineOffset(static_cast(m_aFLineIndent.GetCoreValue(eUnit))); } aMargin.SetAutoFirst(m_xAutoCB->get_active()); if ( aMargin.GetTextFirstLineOffset() < 0 ) bNullTab = true; if ( !pOld || *static_cast(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(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(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 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(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(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(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(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(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(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(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(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( 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( 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 aLink2 = LINK(this, SvxStdParagraphTabPage, ELRLoseFocusHdl); m_aFLineIndent.connect_value_changed(aLink2); m_aLeftIndent.connect_value_changed(aLink2); m_aRightIndent.connect_value_changed(aLink2); Link 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(m_aFLineIndent.denormalize( m_aFLineIndent.get_value( FieldUnit::TWIP ) )) ); m_aExampleWin.SetLeftMargin( static_cast(m_aLeftIndent.denormalize( m_aLeftIndent.get_value( FieldUnit::TWIP ) ) ) ); m_aExampleWin.SetRightMargin( static_cast(m_aRightIndent.denormalize( m_aRightIndent.get_value( FieldUnit::TWIP ) ) ) ); m_aExampleWin.SetUpper( static_cast(m_aTopDist.denormalize( m_aTopDist.get_value( FieldUnit::TWIP ) )) ); m_aExampleWin.SetLower( static_cast(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(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(SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH, false); const SfxUInt32Item* pFlagSetItem = aSet.GetItem(SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET, false); const SfxUInt32Item* pLineDistItem = aSet.GetItem(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 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 SvxParaAlignTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) { return std::make_unique(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(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(m_xVertAlignLB->get_active()))); else rOutSet->Put(SvxParaVertAlignItem(static_cast(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(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(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(rSet->Get( _nWhich )); m_xVertAlignLB->set_active(rAlign.GetValue()); } else { const SvxParaVertAlignItem& rAlign = static_cast(rSet->Get( _nWhich )); m_xVertAlignLB->set_active(static_cast(rAlign.GetValue())); } } _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION ); //text direction if( SfxItemState::DEFAULT <= rSet->GetItemState( _nWhich ) ) { const SvxFrameDirectionItem& rFrameDirItem = static_cast( 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(SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT, false); if (pBoolItem && pBoolItem->GetValue()) EnableJustifyExt(); } std::unique_ptr SvxExtParagraphTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) { return std::make_unique(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(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(m_xExtHyphenBeforeBox->get_value()); aHyphen.GetMinTrail() = static_cast(m_xExtHyphenAfterBox->get_value()); aHyphen.GetMinWordLength() = static_cast(m_xMinWordLength->get_value()); } aHyphen.GetMaxHyphens() = static_cast(m_xMaxHyphenEdit->get_value()); SfxItemPool* pPool = GetItemSet().GetPool(); DBG_ASSERT( pPool, "Where is the pool?" ); MapUnit eUnit = pPool->GetMetric( _nWhich ); aHyphen.GetTextHyphenZone() = static_cast(m_aHyphenZone.GetCoreValue(eUnit)); if ( !pOld || *static_cast(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(pOld)->GetValue() != m_xPagenumEdit->get_value())) { SfxUInt16Item aPageNum(SID_ATTR_PARA_PAGENUM, static_cast(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(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(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(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()) { rOutSet->Put( SvxFormatSplitItem( eState == TRISTATE_TRUE, _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 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(m_xWidowRowNo->get_value()) : 0, nWidowsWhich ); pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_WIDOWS ); if ( m_xWidowBox->get_state_changed_from_saved() || !pOld || !( *static_cast(pOld) == rItem ) ) { rOutSet->Put( rItem ); bModified = true; } } TypedWhichId 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(m_xOrphanRowNo->get_value()) : 0, nOrphansWhich ); pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_ORPHANS ); if ( m_xOrphanBox->get_state_changed_from_saved() || !pOld || !( *static_cast(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(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(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(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(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(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(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(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(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 SvxAsianTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) { return std::make_unique(pPage, pController, *rSet); } WhichRangesContainer SvxAsianTabPage::GetRanges() { return WhichRangesContainer(svl::Items); } 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 pNewItem(static_cast(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 pNewItem(static_cast(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 pNewItem(static_cast(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(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: */