From 267c6f2ac71f92999e969232431ba04678e7437e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 07:54:39 +0200 Subject: Adding upstream version 4:24.2.0. Signed-off-by: Daniel Baumann --- sw/source/core/unocore/unosett.cxx | 2126 ++++++++++++++++++++++++++++++++++++ 1 file changed, 2126 insertions(+) create mode 100644 sw/source/core/unocore/unosett.cxx (limited to 'sw/source/core/unocore/unosett.cxx') diff --git a/sw/source/core/unocore/unosett.cxx b/sw/source/core/unocore/unosett.cxx new file mode 100644 index 0000000000..bfc4b00a34 --- /dev/null +++ b/sw/source/core/unocore/unosett.cxx @@ -0,0 +1,2126 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::text; +using namespace ::com::sun::star::style; + + +namespace +{ + SvtBroadcaster& GetPageDescNotifier(SwDoc* pDoc) + { + return pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool(RES_POOLPAGE_STANDARD)->GetNotifier(); + } +} + +#define WID_PREFIX 0 +#define WID_SUFFIX 1 +#define WID_NUMBERING_TYPE 2 +#define WID_START_AT 3 +#define WID_FOOTNOTE_COUNTING 4 +#define WID_PARAGRAPH_STYLE 5 +#define WID_PAGE_STYLE 6 +#define WID_CHARACTER_STYLE 7 +#define WID_POSITION_END_OF_DOC 8 +#define WID_END_NOTICE 9 +#define WID_BEGIN_NOTICE 10 +#define WID_ANCHOR_CHARACTER_STYLE 11 +#define WID_NUM_ON 12 +#define WID_SEPARATOR_INTERVAL 13 +#define WID_NUMBER_POSITION 14 +#define WID_DISTANCE 15 +#define WID_INTERVAL 16 +#define WID_SEPARATOR_TEXT 17 +#define WID_COUNT_EMPTY_LINES 18 +#define WID_COUNT_LINES_IN_FRAMES 19 +#define WID_RESTART_AT_EACH_PAGE 20 + + +static const SfxItemPropertySet* GetFootnoteSet() +{ + static const SfxItemPropertyMapEntry aFootnoteMap_Impl[] = + { + { UNO_NAME_ANCHOR_CHAR_STYLE_NAME,WID_ANCHOR_CHARACTER_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_BEGIN_NOTICE, WID_BEGIN_NOTICE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_CHAR_STYLE_NAME, WID_CHARACTER_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_END_NOTICE, WID_END_NOTICE , ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_FOOTNOTE_COUNTING, WID_FOOTNOTE_COUNTING, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_NUMBERING_TYPE, WID_NUMBERING_TYPE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_PAGE_STYLE_NAME, WID_PAGE_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_PARA_STYLE_NAME, WID_PARAGRAPH_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_POSITION_END_OF_DOC, WID_POSITION_END_OF_DOC,cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_PREFIX, WID_PREFIX, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_START_AT, WID_START_AT , ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_SUFFIX, WID_SUFFIX, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + }; + static const SfxItemPropertySet aFootnoteSet_Impl(aFootnoteMap_Impl); + return &aFootnoteSet_Impl; +} + +static const SfxItemPropertySet* GetEndnoteSet() +{ + static const SfxItemPropertyMapEntry aEndnoteMap_Impl[] = + { + { UNO_NAME_ANCHOR_CHAR_STYLE_NAME,WID_ANCHOR_CHARACTER_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_CHAR_STYLE_NAME, WID_CHARACTER_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_NUMBERING_TYPE, WID_NUMBERING_TYPE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_PAGE_STYLE_NAME, WID_PAGE_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_PARA_STYLE_NAME, WID_PARAGRAPH_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_PREFIX, WID_PREFIX, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_START_AT, WID_START_AT , ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_SUFFIX, WID_SUFFIX, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + }; + static const SfxItemPropertySet aEndnoteSet_Impl(aEndnoteMap_Impl); + return &aEndnoteSet_Impl; +} + +static const SfxItemPropertySet* GetNumberingRulesSet() +{ + static const SfxItemPropertyMapEntry aNumberingRulesMap_Impl[] = + { + { UNO_NAME_IS_ABSOLUTE_MARGINS, WID_IS_ABS_MARGINS, cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_IS_AUTOMATIC, WID_IS_AUTOMATIC, cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_IS_CONTINUOUS_NUMBERING, WID_CONTINUOUS, cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_NAME, WID_RULE_NAME , ::cppu::UnoType::get(), PropertyAttribute::READONLY, 0}, + { UNO_NAME_NUMBERING_IS_OUTLINE, WID_IS_OUTLINE, cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_DEFAULT_LIST_ID, WID_DEFAULT_LIST_ID, ::cppu::UnoType::get(), PropertyAttribute::READONLY, 0}, + }; + static const SfxItemPropertySet aNumberingRulesSet_Impl( aNumberingRulesMap_Impl ); + return &aNumberingRulesSet_Impl; +} + +static const SfxItemPropertySet* GetLineNumberingSet() +{ + static const SfxItemPropertyMapEntry aLineNumberingMap_Impl[] = + { + { UNO_NAME_CHAR_STYLE_NAME, WID_CHARACTER_STYLE, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_COUNT_EMPTY_LINES, WID_COUNT_EMPTY_LINES , cppu::UnoType::get(),PROPERTY_NONE, 0}, + { UNO_NAME_COUNT_LINES_IN_FRAMES, WID_COUNT_LINES_IN_FRAMES, cppu::UnoType::get(),PROPERTY_NONE, 0}, + { UNO_NAME_DISTANCE, WID_DISTANCE , ::cppu::UnoType::get(),PROPERTY_NONE, 0}, + { UNO_NAME_IS_ON, WID_NUM_ON, cppu::UnoType::get() , PROPERTY_NONE, 0}, + { UNO_NAME_INTERVAL, WID_INTERVAL , ::cppu::UnoType::get(),PROPERTY_NONE, 0}, + { UNO_NAME_SEPARATOR_TEXT, WID_SEPARATOR_TEXT, ::cppu::UnoType::get(), PROPERTY_NONE, 0}, + { UNO_NAME_NUMBER_POSITION, WID_NUMBER_POSITION, ::cppu::UnoType::get(),PROPERTY_NONE, 0}, + { UNO_NAME_NUMBERING_TYPE, WID_NUMBERING_TYPE , ::cppu::UnoType::get(),PROPERTY_NONE, 0}, + { UNO_NAME_RESTART_AT_EACH_PAGE, WID_RESTART_AT_EACH_PAGE, cppu::UnoType::get() , PROPERTY_NONE, 0}, + { UNO_NAME_SEPARATOR_INTERVAL, WID_SEPARATOR_INTERVAL, ::cppu::UnoType::get(),PROPERTY_NONE, 0}, + }; + static const SfxItemPropertySet aLineNumberingSet_Impl(aLineNumberingMap_Impl); + return &aLineNumberingSet_Impl; +} + +static SwCharFormat* lcl_getCharFormat(SwDoc* pDoc, const uno::Any& aValue) +{ + SwCharFormat* pRet = nullptr; + OUString uTmp; + aValue >>= uTmp; + OUString sCharFormat; + SwStyleNameMapper::FillUIName(uTmp, sCharFormat, SwGetPoolIdFromName::ChrFmt); + if (sCharFormat != SwResId(STR_POOLCHR_STANDARD)) + { + pRet = pDoc->FindCharFormatByName( sCharFormat ); + } + if(!pRet) + { + const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(sCharFormat, SwGetPoolIdFromName::ChrFmt); + if(USHRT_MAX != nId) + pRet = pDoc->getIDocumentStylePoolAccess().GetCharFormatFromPool( nId ); + } + return pRet; +} + +static SwTextFormatColl* lcl_GetParaStyle(SwDoc* pDoc, const uno::Any& aValue) +{ + OUString uTmp; + aValue >>= uTmp; + OUString sParaStyle; + SwStyleNameMapper::FillUIName(uTmp, sParaStyle, SwGetPoolIdFromName::TxtColl ); + SwTextFormatColl* pRet = pDoc->FindTextFormatCollByName( sParaStyle ); + if( !pRet ) + { + const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( sParaStyle, SwGetPoolIdFromName::TxtColl ); + if( USHRT_MAX != nId ) + pRet = pDoc->getIDocumentStylePoolAccess().GetTextCollFromPool( nId ); + } + return pRet; +} + +static SwPageDesc* lcl_GetPageDesc(SwDoc* pDoc, const uno::Any& aValue) +{ + OUString uTmp; + aValue >>= uTmp; + OUString sPageDesc; + SwStyleNameMapper::FillUIName(uTmp, sPageDesc, SwGetPoolIdFromName::PageDesc ); + SwPageDesc* pRet = pDoc->FindPageDesc( sPageDesc ); + if(!pRet) + { + const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(sPageDesc, SwGetPoolIdFromName::PageDesc); + if(USHRT_MAX != nId) + pRet = pDoc->getIDocumentStylePoolAccess().GetPageDescFromPool( nId ); + } + return pRet; +} + +// Numbering +const o3tl::enumarray aSvxToUnoAdjust +{ + text::HoriOrientation::LEFT, //3 + text::HoriOrientation::RIGHT, //1 + sal_Int16(-1), + text::HoriOrientation::CENTER, //2 + sal_Int16(-1), + sal_Int16(-1) +}; + +OUString SwXFootnoteProperties::getImplementationName() +{ + return "SwXFootnoteProperties"; +} + +sal_Bool SwXFootnoteProperties::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXFootnoteProperties::getSupportedServiceNames() +{ + Sequence aRet { "com.sun.star.text.FootnoteSettings" }; + return aRet; +} + +SwXFootnoteProperties::SwXFootnoteProperties(SwDoc* pDc) : + m_pDoc(pDc), + m_pPropertySet(GetFootnoteSet()) +{ +} + +SwXFootnoteProperties::~SwXFootnoteProperties() +{ + +} + +uno::Reference< beans::XPropertySetInfo > SwXFootnoteProperties::getPropertySetInfo() +{ + static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); + return aRef; +} + +void SwXFootnoteProperties::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue) +{ + SolarMutexGuard aGuard; + if(!m_pDoc) + throw uno::RuntimeException(); + + const SfxItemPropertyMapEntry* pEntry = m_pPropertySet->getPropertyMap().getByName( rPropertyName ); + if(!pEntry) + throw beans::UnknownPropertyException("Unknown property: " + rPropertyName, getXWeak() ); + + if ( pEntry->nFlags & PropertyAttribute::READONLY) + throw PropertyVetoException("Property is read-only: " + rPropertyName, getXWeak() ); + SwFootnoteInfo aFootnoteInfo(m_pDoc->GetFootnoteInfo()); + switch(pEntry->nWID) + { + case WID_PREFIX: + { + OUString uTmp; + aValue >>= uTmp; + aFootnoteInfo.SetPrefix(uTmp); + } + break; + case WID_SUFFIX: + { + OUString uTmp; + aValue >>= uTmp; + aFootnoteInfo.SetSuffix(uTmp); + } + break; + case WID_NUMBERING_TYPE: + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + if(!(nTmp >= 0 && + (nTmp <= SVX_NUM_ARABIC || + nTmp > SVX_NUM_BITMAP))) + throw lang::IllegalArgumentException(); + + aFootnoteInfo.m_aFormat.SetNumberingType(static_cast(nTmp)); + + } + break; + case WID_START_AT: + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + aFootnoteInfo.m_nFootnoteOffset = nTmp; + } + break; + case WID_FOOTNOTE_COUNTING: + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + switch(nTmp) + { + case FootnoteNumbering::PER_PAGE: + aFootnoteInfo.m_eNum = FTNNUM_PAGE; + break; + case FootnoteNumbering::PER_CHAPTER: + aFootnoteInfo.m_eNum = FTNNUM_CHAPTER; + break; + case FootnoteNumbering::PER_DOCUMENT: + aFootnoteInfo.m_eNum = FTNNUM_DOC; + break; + } + } + break; + case WID_PARAGRAPH_STYLE: + { + SwTextFormatColl* pColl = lcl_GetParaStyle(m_pDoc, aValue); + if(pColl) + aFootnoteInfo.SetFootnoteTextColl(*pColl); + } + break; + case WID_PAGE_STYLE: + { + SwPageDesc* pDesc = lcl_GetPageDesc(m_pDoc, aValue); + if(pDesc) + aFootnoteInfo.ChgPageDesc( pDesc ); + } + break; + case WID_ANCHOR_CHARACTER_STYLE: + case WID_CHARACTER_STYLE: + { + SwCharFormat* pFormat = lcl_getCharFormat(m_pDoc, aValue); + if(pFormat) + { + if(pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE) + aFootnoteInfo.SetAnchorCharFormat(pFormat); + else + aFootnoteInfo.SetCharFormat(pFormat); + } + } + break; + case WID_POSITION_END_OF_DOC: + { + bool bVal = *o3tl::doAccess(aValue); + aFootnoteInfo.m_ePos = bVal ? FTNPOS_CHAPTER : FTNPOS_PAGE; + } + break; + case WID_END_NOTICE: + { + OUString uTmp; + aValue >>= uTmp; + aFootnoteInfo.m_aQuoVadis = uTmp; + } + break; + case WID_BEGIN_NOTICE: + { + OUString uTmp; + aValue >>= uTmp; + aFootnoteInfo.m_aErgoSum = uTmp; + } + break; + } + m_pDoc->SetFootnoteInfo(aFootnoteInfo); + + +} + +uno::Any SwXFootnoteProperties::getPropertyValue(const OUString& rPropertyName) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + if(!m_pDoc) + throw uno::RuntimeException(); + + const SfxItemPropertyMapEntry* pEntry = m_pPropertySet->getPropertyMap().getByName( rPropertyName ); + if(!pEntry) + throw UnknownPropertyException("Unknown property: " + rPropertyName, getXWeak() ); + + const SwFootnoteInfo& rFootnoteInfo = m_pDoc->GetFootnoteInfo(); + switch(pEntry->nWID) + { + case WID_PREFIX: + { + aRet <<= rFootnoteInfo.GetPrefix(); + } + break; + case WID_SUFFIX: + { + aRet <<= rFootnoteInfo.GetSuffix(); + } + break; + case WID_NUMBERING_TYPE : + { + aRet <<= static_cast(rFootnoteInfo.m_aFormat.GetNumberingType()); + } + break; + case WID_START_AT: + aRet <<= static_cast(rFootnoteInfo.m_nFootnoteOffset); + break; + case WID_FOOTNOTE_COUNTING : + { + sal_Int16 nRet = 0; + switch(rFootnoteInfo.m_eNum) + { + case FTNNUM_PAGE: + nRet = FootnoteNumbering::PER_PAGE; + break; + case FTNNUM_CHAPTER: + nRet = FootnoteNumbering::PER_CHAPTER; + break; + case FTNNUM_DOC: + nRet = FootnoteNumbering::PER_DOCUMENT; + break; + } + aRet <<= nRet; + } + break; + case WID_PARAGRAPH_STYLE : + { + SwTextFormatColl* pColl = rFootnoteInfo.GetFootnoteTextColl(); + OUString aString; + if(pColl) + aString = pColl->GetName(); + SwStyleNameMapper::FillProgName(aString, aString, SwGetPoolIdFromName::TxtColl); + aRet <<= aString; + } + break; + case WID_PAGE_STYLE : + { + OUString aString; + if( rFootnoteInfo.KnowsPageDesc() ) + { + SwStyleNameMapper::FillProgName( + rFootnoteInfo.GetPageDesc( *m_pDoc )->GetName(), + aString, + SwGetPoolIdFromName::PageDesc); + } + aRet <<= aString; + } + break; + case WID_ANCHOR_CHARACTER_STYLE: + case WID_CHARACTER_STYLE: + { + OUString aString; + const SwCharFormat* pCharFormat = rFootnoteInfo.GetCurrentCharFormat(pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE); + if( pCharFormat ) + { + SwStyleNameMapper::FillProgName( + pCharFormat->GetName(), + aString, + SwGetPoolIdFromName::ChrFmt); + } + aRet <<= aString; + } + break; + case WID_POSITION_END_OF_DOC: + aRet <<= FTNPOS_CHAPTER == rFootnoteInfo.m_ePos; + break; + case WID_END_NOTICE : + aRet <<= rFootnoteInfo.m_aQuoVadis; + break; + case WID_BEGIN_NOTICE : + aRet <<= rFootnoteInfo.m_aErgoSum; + break; + } + + + return aRet; +} + +void SwXFootnoteProperties::addPropertyChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +void SwXFootnoteProperties::removePropertyChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +void SwXFootnoteProperties::addVetoableChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +void SwXFootnoteProperties::removeVetoableChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +OUString SwXEndnoteProperties::getImplementationName() +{ + return "SwXEndnoteProperties"; +} + +sal_Bool SwXEndnoteProperties::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXEndnoteProperties::getSupportedServiceNames() +{ + Sequence aRet { "com.sun.star.text.FootnoteSettings" }; + return aRet; +} + +SwXEndnoteProperties::SwXEndnoteProperties(SwDoc* pDc) : + m_pDoc(pDc), + m_pPropertySet(GetEndnoteSet()) +{ +} + +SwXEndnoteProperties::~SwXEndnoteProperties() +{ +} + +uno::Reference< beans::XPropertySetInfo > SwXEndnoteProperties::getPropertySetInfo() +{ + static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); + return aRef; +} + +void SwXEndnoteProperties::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue) +{ + SolarMutexGuard aGuard; + if(!m_pDoc) + return; + + const SfxItemPropertyMapEntry* pEntry = m_pPropertySet->getPropertyMap().getByName( rPropertyName ); + if(!pEntry) + throw UnknownPropertyException("Unknown property: " + rPropertyName, getXWeak() ); + + if ( pEntry->nFlags & PropertyAttribute::READONLY) + throw PropertyVetoException("Property is read-only: " + rPropertyName, getXWeak() ); + SwEndNoteInfo aEndInfo(m_pDoc->GetEndNoteInfo()); + switch(pEntry->nWID) + { + case WID_PREFIX: + { + OUString uTmp; + aValue >>= uTmp; + aEndInfo.SetPrefix(uTmp); + } + break; + case WID_SUFFIX: + { + OUString uTmp; + aValue >>= uTmp; + aEndInfo.SetSuffix(uTmp); + } + break; + case WID_NUMBERING_TYPE : + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + aEndInfo.m_aFormat.SetNumberingType(static_cast(nTmp)); + } + break; + case WID_START_AT: + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + aEndInfo.m_nFootnoteOffset = nTmp; + } + break; + case WID_PARAGRAPH_STYLE : + { + SwTextFormatColl* pColl = lcl_GetParaStyle(m_pDoc, aValue); + if(pColl) + aEndInfo.SetFootnoteTextColl(*pColl); + } + break; + case WID_PAGE_STYLE : + { + SwPageDesc* pDesc = lcl_GetPageDesc(m_pDoc, aValue); + if(pDesc) + aEndInfo.ChgPageDesc( pDesc ); + } + break; + case WID_ANCHOR_CHARACTER_STYLE: + case WID_CHARACTER_STYLE : + { + SwCharFormat* pFormat = lcl_getCharFormat(m_pDoc, aValue); + if(pFormat) + { + if(pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE) + aEndInfo.SetAnchorCharFormat(pFormat); + else + aEndInfo.SetCharFormat(pFormat); + } + } + break; + } + m_pDoc->SetEndNoteInfo(aEndInfo); +} + +uno::Any SwXEndnoteProperties::getPropertyValue(const OUString& rPropertyName) +{ + SolarMutexGuard aGuard; + uno::Any aRet; + if(m_pDoc) + { + const SfxItemPropertyMapEntry* pEntry = m_pPropertySet->getPropertyMap().getByName( rPropertyName ); + if(!pEntry) + throw UnknownPropertyException("Unknown property: " + rPropertyName, getXWeak() ); + + const SwEndNoteInfo& rEndInfo = m_pDoc->GetEndNoteInfo(); + switch(pEntry->nWID) + { + case WID_PREFIX: + aRet <<= rEndInfo.GetPrefix(); + break; + case WID_SUFFIX: + aRet <<= rEndInfo.GetSuffix(); + break; + case WID_NUMBERING_TYPE : + aRet <<= static_cast(rEndInfo.m_aFormat.GetNumberingType()); + break; + case WID_START_AT: + aRet <<= static_cast(rEndInfo.m_nFootnoteOffset); + break; + case WID_PARAGRAPH_STYLE : + { + SwTextFormatColl* pColl = rEndInfo.GetFootnoteTextColl(); + OUString aString; + if(pColl) + aString = pColl->GetName(); + SwStyleNameMapper::FillProgName( + aString, + aString, + SwGetPoolIdFromName::TxtColl); + aRet <<= aString; + + } + break; + case WID_PAGE_STYLE : + { + OUString aString; + if( rEndInfo.KnowsPageDesc() ) + { + SwStyleNameMapper::FillProgName( + rEndInfo.GetPageDesc( *m_pDoc )->GetName(), + aString, + SwGetPoolIdFromName::PageDesc); + } + aRet <<= aString; + } + break; + case WID_ANCHOR_CHARACTER_STYLE: + case WID_CHARACTER_STYLE: + { + OUString aString; + const SwCharFormat* pCharFormat = rEndInfo.GetCurrentCharFormat( pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE ); + if( pCharFormat ) + { + SwStyleNameMapper::FillProgName( + pCharFormat->GetName(), + aString, + SwGetPoolIdFromName::ChrFmt); + } + aRet <<= aString; + } + break; + } + + } + return aRet; +} + +void SwXEndnoteProperties::addPropertyChangeListener( + const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +void SwXEndnoteProperties::removePropertyChangeListener(const OUString& /*PropertyName*/, + const uno:: Reference< beans::XPropertyChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +void SwXEndnoteProperties::addVetoableChangeListener(const OUString& /*PropertyName*/, + const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +void SwXEndnoteProperties::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) +{ + OSL_FAIL("not implemented"); +} + +OUString SwXLineNumberingProperties::getImplementationName() +{ + return "SwXLineNumberingProperties"; +} + +sal_Bool SwXLineNumberingProperties::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXLineNumberingProperties::getSupportedServiceNames() +{ + Sequence aRet { "com.sun.star.text.LineNumberingProperties" }; + return aRet; +} + +SwXLineNumberingProperties::SwXLineNumberingProperties(SwDoc* pDc) : + m_pDoc(pDc), + m_pPropertySet(GetLineNumberingSet()) +{ +} + +SwXLineNumberingProperties::~SwXLineNumberingProperties() +{ +} + +uno::Reference< beans::XPropertySetInfo > SwXLineNumberingProperties::getPropertySetInfo() +{ + static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); + return aRef; +} + +void SwXLineNumberingProperties::setPropertyValue( + const OUString& rPropertyName, const Any& aValue) +{ + SolarMutexGuard aGuard; + if(!m_pDoc) + throw uno::RuntimeException(); + + const SfxItemPropertyMapEntry* pEntry = m_pPropertySet->getPropertyMap().getByName( rPropertyName ); + if(!pEntry) + throw UnknownPropertyException("Unknown property: " + rPropertyName, getXWeak() ); + + if ( pEntry->nFlags & PropertyAttribute::READONLY) + throw PropertyVetoException("Property is read-only: " + rPropertyName, getXWeak() ); + SwLineNumberInfo aFontMetric(m_pDoc->GetLineNumberInfo()); + switch(pEntry->nWID) + { + case WID_NUM_ON: + { + bool bVal = *o3tl::doAccess(aValue); + aFontMetric.SetPaintLineNumbers(bVal); + } + break; + case WID_CHARACTER_STYLE : + { + SwCharFormat* pFormat = lcl_getCharFormat(m_pDoc, aValue); + if(pFormat) + aFontMetric.SetCharFormat(pFormat); + } + break; + case WID_NUMBERING_TYPE : + { + SvxNumberType aNumType(aFontMetric.GetNumType()); + sal_Int16 nTmp = 0; + aValue >>= nTmp; + aNumType.SetNumberingType(static_cast(nTmp)); + aFontMetric.SetNumType(aNumType); + } + break; + case WID_NUMBER_POSITION : + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + switch(nTmp) + { + case style::LineNumberPosition::LEFT: + aFontMetric.SetPos(LINENUMBER_POS_LEFT); + break; + case style::LineNumberPosition::RIGHT : + aFontMetric.SetPos(LINENUMBER_POS_RIGHT); + break; + case style::LineNumberPosition::INSIDE: + aFontMetric.SetPos(LINENUMBER_POS_INSIDE); + break; + case style::LineNumberPosition::OUTSIDE: + aFontMetric.SetPos(LINENUMBER_POS_OUTSIDE); + break; + } + } + break; + case WID_DISTANCE : + { + sal_Int32 nVal = 0; + aValue >>= nVal; + sal_Int32 nTmp = o3tl::toTwips(nVal, o3tl::Length::mm100); + if (nTmp > SAL_MAX_UINT16) + nTmp = SAL_MAX_UINT16; + aFontMetric.SetPosFromLeft(nTmp); + } + break; + case WID_INTERVAL : + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + if( nTmp > 0) + aFontMetric.SetCountBy(nTmp); + } + break; + case WID_SEPARATOR_TEXT : + { + OUString uTmp; + aValue >>= uTmp; + aFontMetric.SetDivider(uTmp); + } + break; + case WID_SEPARATOR_INTERVAL: + { + sal_Int16 nTmp = 0; + aValue >>= nTmp; + if( nTmp >= 0) + aFontMetric.SetDividerCountBy(nTmp); + } + break; + case WID_COUNT_EMPTY_LINES : + { + bool bVal = *o3tl::doAccess(aValue); + aFontMetric.SetCountBlankLines(bVal); + } + break; + case WID_COUNT_LINES_IN_FRAMES : + { + bool bVal = *o3tl::doAccess(aValue); + aFontMetric.SetCountInFlys(bVal); + } + break; + case WID_RESTART_AT_EACH_PAGE : + { + bool bVal = *o3tl::doAccess(aValue); + aFontMetric.SetRestartEachPage(bVal); + } + break; + } + m_pDoc->SetLineNumberInfo(aFontMetric); +} + +Any SwXLineNumberingProperties::getPropertyValue(const OUString& rPropertyName) +{ + SolarMutexGuard aGuard; + Any aRet; + if(!m_pDoc) + throw uno::RuntimeException(); + + const SfxItemPropertyMapEntry* pEntry = m_pPropertySet->getPropertyMap().getByName( rPropertyName ); + if(!pEntry) + throw UnknownPropertyException("Unknown property: " + rPropertyName, getXWeak() ); + + const SwLineNumberInfo& rInfo = m_pDoc->GetLineNumberInfo(); + switch(pEntry->nWID) + { + case WID_NUM_ON: + aRet <<= rInfo.IsPaintLineNumbers(); + break; + case WID_CHARACTER_STYLE : + { + OUString aString; + // return empty string if no char format is set + // otherwise it would be created here + if(rInfo.HasCharFormat()) + { + SwStyleNameMapper::FillProgName( + rInfo.GetCharFormat(m_pDoc->getIDocumentStylePoolAccess())->GetName(), + aString, + SwGetPoolIdFromName::ChrFmt); + } + aRet <<= aString; + } + break; + case WID_NUMBERING_TYPE : + aRet <<= static_cast(rInfo.GetNumType().GetNumberingType()); + break; + case WID_NUMBER_POSITION : + { + sal_Int16 nRet = 0; + switch(rInfo.GetPos()) + { + case LINENUMBER_POS_LEFT: + nRet = style::LineNumberPosition::LEFT; + break; + case LINENUMBER_POS_RIGHT : + nRet = style::LineNumberPosition::RIGHT ; + break; + case LINENUMBER_POS_INSIDE: + nRet = style::LineNumberPosition::INSIDE ; + break; + case LINENUMBER_POS_OUTSIDE : + nRet = style::LineNumberPosition::OUTSIDE ; + break; + } + aRet <<= nRet; + } + break; + case WID_DISTANCE : + { + sal_uInt32 nPos = rInfo.GetPosFromLeft(); + if(USHRT_MAX == nPos) + nPos = 0; + aRet <<= static_cast < sal_Int32 >(convertTwipToMm100(nPos)); + } + break; + case WID_INTERVAL : + aRet <<= static_cast(rInfo.GetCountBy()); + break; + case WID_SEPARATOR_TEXT : + aRet <<= rInfo.GetDivider(); + break; + case WID_SEPARATOR_INTERVAL: + aRet <<= static_cast(rInfo.GetDividerCountBy()); + break; + case WID_COUNT_EMPTY_LINES : + aRet <<= rInfo.IsCountBlankLines(); + break; + case WID_COUNT_LINES_IN_FRAMES : + aRet <<= rInfo.IsCountInFlys(); + break; + case WID_RESTART_AT_EACH_PAGE : + aRet <<= rInfo.IsRestartEachPage(); + break; + } + return aRet; +} + +void SwXLineNumberingProperties::addPropertyChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XPropertyChangeListener > & /*xListener*/) +{ +OSL_FAIL("not implemented"); +} + +void SwXLineNumberingProperties::removePropertyChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XPropertyChangeListener > & /*xListener*/) +{ +OSL_FAIL("not implemented"); +} + +void SwXLineNumberingProperties::addVetoableChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) +{ +OSL_FAIL("not implemented"); +} + +void SwXLineNumberingProperties::removeVetoableChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) +{ +OSL_FAIL("not implemented"); +} + +constexpr OUString aInvalidStyle = u"__XXX___invalid"_ustr; + +class SwXNumberingRules::Impl + : public SvtListener +{ + SwXNumberingRules& m_rParent; + virtual void Notify(const SfxHint&) override; + public: + explicit Impl(SwXNumberingRules& rParent) : m_rParent(rParent) {} +}; + +bool SwXNumberingRules::isInvalidStyle(std::u16string_view rName) +{ + return rName == aInvalidStyle; +} + +OUString SwXNumberingRules::getImplementationName() +{ + return "SwXNumberingRules"; +} + +sal_Bool SwXNumberingRules::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXNumberingRules::getSupportedServiceNames() +{ + Sequence aRet { "com.sun.star.text.NumberingRules" }; + return aRet; +} + +SwXNumberingRules::SwXNumberingRules(const SwNumRule& rRule, SwDoc* doc) : + m_pImpl(new SwXNumberingRules::Impl(*this)), + m_pDoc(doc), + m_pDocShell(nullptr), + m_pNumRule(new SwNumRule(rRule)), + m_pPropertySet(GetNumberingRulesSet()), + m_bOwnNumRuleCreated(true) +{ + // first organize the document - it is dependent on the set character formats + // if no format is set, it should work as well + for( sal_uInt16 i = 0; i < MAXLEVEL; ++i) + { + SwNumFormat rFormat(m_pNumRule->Get(i)); + SwCharFormat* pCharFormat = rFormat.GetCharFormat(); + if(pCharFormat) + { + m_pDoc = pCharFormat->GetDoc(); + break; + } + } + if(m_pDoc) + m_pImpl->StartListening(GetPageDescNotifier(m_pDoc)); + for(sal_uInt16 i = 0; i < MAXLEVEL; ++i) + { + m_sNewCharStyleNames[i] = aInvalidStyle; + m_sNewBulletFontNames[i] = aInvalidStyle; + } +} + +SwXNumberingRules::SwXNumberingRules(SwDocShell& rDocSh) : + m_pImpl(new SwXNumberingRules::Impl(*this)), + m_pDoc(nullptr), + m_pDocShell(&rDocSh), + m_pNumRule(nullptr), + m_pPropertySet(GetNumberingRulesSet()), + m_bOwnNumRuleCreated(false) +{ + if (!m_pDocShell->GetDoc()) + throw uno::RuntimeException("Unitialized shell passed to SwXNumberingRules constructor"); + m_pImpl->StartListening(GetPageDescNotifier(m_pDocShell->GetDoc())); +} + +SwXNumberingRules::SwXNumberingRules(SwDoc& rDoc) : + m_pImpl(new SwXNumberingRules::Impl(*this)), + m_pDoc(&rDoc), + m_pDocShell(nullptr), + m_pNumRule(nullptr), + m_pPropertySet(GetNumberingRulesSet()), + m_bOwnNumRuleCreated(false) +{ + m_pImpl->StartListening(GetPageDescNotifier(&rDoc)); + m_sCreatedNumRuleName = rDoc.GetUniqueNumRuleName(); + rDoc.MakeNumRule( m_sCreatedNumRuleName, nullptr, false, + // #i89178# + numfunc::GetDefaultPositionAndSpaceMode() ); +} + +SwXNumberingRules::~SwXNumberingRules() +{ + SolarMutexGuard aGuard; + if(m_pDoc && !m_sCreatedNumRuleName.isEmpty()) + m_pDoc->DelNumRule( m_sCreatedNumRuleName ); + if( m_bOwnNumRuleCreated ) + delete m_pNumRule; +} + +void SwXNumberingRules::replaceByIndex(sal_Int32 nIndex, const uno::Any& rElement) +{ + SolarMutexGuard aGuard; + if(nIndex < 0 || MAXLEVEL <= nIndex) + throw lang::IndexOutOfBoundsException(); + + auto rProperties = o3tl::tryAccess>( + rElement); + if(!rProperties) + throw lang::IllegalArgumentException(); + SwNumRule* pRule = nullptr; + if(m_pNumRule) + SwXNumberingRules::SetNumberingRuleByIndex( *m_pNumRule, + *rProperties, nIndex); + else if(m_pDocShell) + { + // #i87650# - correction of cws warnings: + SwNumRule aNumRule( *(m_pDocShell->GetDoc()->GetOutlineNumRule()) ); + SwXNumberingRules::SetNumberingRuleByIndex( aNumRule, + *rProperties, nIndex); + // set character format if needed + // this code appears to be dead - except when a style is assigned for BITMAP numbering? + const SwCharFormats* pFormats = m_pDocShell->GetDoc()->GetCharFormats(); + const size_t nChCount = pFormats->size(); + for(sal_uInt16 i = 0; i < MAXLEVEL;i++) + { + SwNumFormat aFormat(aNumRule.Get( i )); + if (!m_sNewCharStyleNames[i].isEmpty() && + (!aFormat.GetCharFormat() || aFormat.GetCharFormat()->GetName()!= m_sNewCharStyleNames[i])) + { + SwCharFormat* pCharFormat = nullptr; + for(size_t j = 0; j< nChCount; ++j) + { + SwCharFormat* pTmp = (*pFormats)[j]; + if(pTmp->GetName() == m_sNewCharStyleNames[i]) + { + pCharFormat = pTmp; + break; + } + } + if(!pCharFormat) + { + SfxStyleSheetBase* pBase; + pBase = m_pDocShell->GetStyleSheetPool()->Find(m_sNewCharStyleNames[i], + SfxStyleFamily::Char); + if(!pBase) + pBase = &m_pDocShell->GetStyleSheetPool()->Make(m_sNewCharStyleNames[i], SfxStyleFamily::Char); + pCharFormat = static_cast(pBase)->GetCharFormat(); + + } + aFormat.SetCharFormat( pCharFormat ); + aNumRule.Set( i, aFormat ); + } + } + m_pDocShell->GetDoc()->SetOutlineNumRule( aNumRule ); + } + else if(m_pDoc && !m_sCreatedNumRuleName.isEmpty() && + nullptr != (pRule = m_pDoc->FindNumRulePtr( m_sCreatedNumRuleName ))) + { + SwXNumberingRules::SetNumberingRuleByIndex( *pRule, + *rProperties, nIndex); + + pRule->Validate(*m_pDoc); + } + else + throw uno::RuntimeException(); +} + +sal_Int32 SwXNumberingRules::getCount() +{ + return MAXLEVEL; +} + +uno::Any SwXNumberingRules::getByIndex(sal_Int32 nIndex) +{ + SolarMutexGuard aGuard; + if(nIndex < 0 || MAXLEVEL <= nIndex) + throw lang::IndexOutOfBoundsException(); + + uno::Any aVal; + const SwNumRule* pRule = m_pNumRule; + if(!pRule && m_pDoc && !m_sCreatedNumRuleName.isEmpty()) + pRule = m_pDoc->FindNumRulePtr( m_sCreatedNumRuleName ); + if(pRule) + { + uno::Sequence aRet = GetNumberingRuleByIndex( + *pRule, nIndex); + aVal <<= aRet; + + } + else if(m_pDocShell) + { + uno::Sequence aRet = GetNumberingRuleByIndex( + *m_pDocShell->GetDoc()->GetOutlineNumRule(), nIndex); + aVal <<= aRet; + } + else + throw uno::RuntimeException(); + return aVal; +} + +uno::Type SwXNumberingRules::getElementType() +{ + return cppu::UnoType>::get(); +} + +sal_Bool SwXNumberingRules::hasElements() +{ + return true; +} + +const TranslateId STR_POOLCOLL_HEADLINE_ARY[] +{ + STR_POOLCOLL_HEADLINE1, + STR_POOLCOLL_HEADLINE2, + STR_POOLCOLL_HEADLINE3, + STR_POOLCOLL_HEADLINE4, + STR_POOLCOLL_HEADLINE5, + STR_POOLCOLL_HEADLINE6, + STR_POOLCOLL_HEADLINE7, + STR_POOLCOLL_HEADLINE8, + STR_POOLCOLL_HEADLINE9, + STR_POOLCOLL_HEADLINE10 +}; + +uno::Sequence SwXNumberingRules::GetNumberingRuleByIndex( + const SwNumRule& rNumRule, sal_Int32 nIndex) const +{ + SolarMutexGuard aGuard; + OSL_ENSURE( 0 <= nIndex && nIndex < MAXLEVEL, "index out of range" ); + + const SwNumFormat& rFormat = rNumRule.Get( o3tl::narrowing(nIndex) ); + + SwCharFormat* pCharFormat = rFormat.GetCharFormat(); + OUString CharStyleName; + if (pCharFormat) + CharStyleName = pCharFormat->GetName(); + + // Whether or not a style is present: the array entry overwrites this string + if (!m_sNewCharStyleNames[nIndex].isEmpty() && + !SwXNumberingRules::isInvalidStyle(m_sNewCharStyleNames[nIndex])) + { + CharStyleName = m_sNewCharStyleNames[nIndex]; + } + + OUString aUString; + if (m_pDocShell) // -> Chapter Numbering + { + // template name + OUString sValue(SwResId(STR_POOLCOLL_HEADLINE_ARY[nIndex])); + const SwTextFormatColls* pColls = m_pDocShell->GetDoc()->GetTextFormatColls(); + const size_t nCount = pColls->size(); + for(size_t i = 0; i < nCount; ++i) + { + SwTextFormatColl &rTextColl = *pColls->operator[](i); + if(rTextColl.IsDefault()) + continue; + + const sal_Int16 nOutLevel = rTextColl.IsAssignedToListLevelOfOutlineStyle() + ? static_cast(rTextColl.GetAssignedOutlineStyleLevel()) + : MAXLEVEL; + if ( nOutLevel == nIndex ) + { + sValue = rTextColl.GetName(); + break; // the style for the level in question has been found + } + else if( sValue==rTextColl.GetName() ) + { + // if the default for the level is existing, but its + // level is different, then it cannot be the default. + sValue.clear(); + } + } + SwStyleNameMapper::FillProgName(sValue, aUString, SwGetPoolIdFromName::TxtColl); + } + + OUString referer; + if (m_pDoc != nullptr) { + auto const sh = m_pDoc->GetPersist(); + if (sh != nullptr && sh->HasName()) { + referer = sh->GetMedium()->GetName(); + } + } + return GetPropertiesForNumFormat( + rFormat, CharStyleName, m_pDocShell ? & aUString : nullptr, referer); + +} + +uno::Sequence SwXNumberingRules::GetPropertiesForNumFormat( + const SwNumFormat& rFormat, OUString const& rCharFormatName, + OUString const*const pHeadingStyleName, OUString const & referer) +{ + bool bChapterNum = pHeadingStyleName != nullptr; + + std::vector aPropertyValues; + aPropertyValues.reserve(32); + //fill all properties into the array + + //adjust + SvxAdjust eAdj = rFormat.GetNumAdjust(); + sal_Int16 nINT16 = aSvxToUnoAdjust[eAdj]; + aPropertyValues.push_back(comphelper::makePropertyValue("Adjust", nINT16)); + + //parentnumbering + nINT16 = rFormat.GetIncludeUpperLevels(); + aPropertyValues.push_back(comphelper::makePropertyValue("ParentNumbering", nINT16)); + + //prefix + OUString aUString = rFormat.GetPrefix(); + aPropertyValues.push_back(comphelper::makePropertyValue("Prefix", aUString)); + + //suffix + aUString = rFormat.GetSuffix(); + aPropertyValues.push_back(comphelper::makePropertyValue("Suffix", aUString)); + + //listformat + if (rFormat.HasListFormat()) + { + aPropertyValues.push_back(comphelper::makePropertyValue("ListFormat", rFormat.GetListFormat())); + } + + if (rFormat.GetIsLegal()) + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_LEVEL_IS_LEGAL, true)); + + //char style name + aUString.clear(); + SwStyleNameMapper::FillProgName( rCharFormatName, aUString, SwGetPoolIdFromName::ChrFmt); + aPropertyValues.push_back(comphelper::makePropertyValue("CharStyleName", aUString)); + + //startvalue + nINT16 = rFormat.GetStart(); + aPropertyValues.push_back(comphelper::makePropertyValue("StartWith", nINT16)); + + if ( rFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) + { + //leftmargin + sal_Int32 nINT32 = convertTwipToMm100(rFormat.GetAbsLSpace()); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_LEFT_MARGIN, nINT32)); + + //chartextoffset + nINT32 = convertTwipToMm100(rFormat.GetCharTextDistance()); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_SYMBOL_TEXT_DISTANCE, nINT32)); + + //firstlineoffset + nINT32 = convertTwipToMm100(rFormat.GetFirstLineOffset()); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_FIRST_LINE_OFFSET, nINT32)); + } + + // PositionAndSpaceMode + nINT16 = PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION; + if ( rFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT ) + { + nINT16 = PositionAndSpaceMode::LABEL_ALIGNMENT; + } + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_POSITION_AND_SPACE_MODE, nINT16)); + + if ( rFormat.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT ) + { + // LabelFollowedBy + nINT16 = LabelFollow::LISTTAB; + if ( rFormat.GetLabelFollowedBy() == SvxNumberFormat::SPACE ) + { + nINT16 = LabelFollow::SPACE; + } + else if ( rFormat.GetLabelFollowedBy() == SvxNumberFormat::NOTHING ) + { + nINT16 = LabelFollow::NOTHING; + } + else if ( rFormat.GetLabelFollowedBy() == SvxNumberFormat::NEWLINE ) + { + nINT16 = LabelFollow::NEWLINE; + } + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_LABEL_FOLLOWED_BY, nINT16)); + + // ListtabStopPosition + sal_Int32 nINT32 = convertTwipToMm100(rFormat.GetListtabPos()); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_LISTTAB_STOP_POSITION, nINT32)); + + // FirstLineIndent + nINT32 = convertTwipToMm100(rFormat.GetFirstLineIndent()); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_FIRST_LINE_INDENT, nINT32)); + + // IndentAt + nINT32 = convertTwipToMm100(rFormat.GetIndentAt()); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_INDENT_AT, nINT32)); + } + + //numberingtype + nINT16 = rFormat.GetNumberingType(); + aPropertyValues.push_back(comphelper::makePropertyValue("NumberingType", nINT16)); + + if(!bChapterNum) + { + if(SVX_NUM_CHAR_SPECIAL == rFormat.GetNumberingType()) + { + sal_UCS4 cBullet = rFormat.GetBulletChar(); + + //BulletId + nINT16 = cBullet; + aPropertyValues.push_back(comphelper::makePropertyValue("BulletId", nINT16)); + + std::optional pFont = rFormat.GetBulletFont(); + + //BulletChar + aUString = OUString(&cBullet, 1); + aPropertyValues.push_back(comphelper::makePropertyValue("BulletChar", aUString)); + + //BulletFontName + aUString = pFont ? pFont->GetStyleName() : OUString(); + aPropertyValues.push_back(comphelper::makePropertyValue("BulletFontName", aUString)); + + //BulletFont + if(pFont) + { + awt::FontDescriptor aDesc; + SvxUnoFontDescriptor::ConvertFromFont( *pFont, aDesc ); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_BULLET_FONT, aDesc)); + } + } + if (SVX_NUM_BITMAP == rFormat.GetNumberingType()) + { + const SvxBrushItem* pBrush = rFormat.GetBrush(); + const Graphic* pGraphic = pBrush ? pBrush->GetGraphic(referer) : nullptr; + if (pGraphic) + { + //GraphicBitmap + uno::Reference xBitmap(pGraphic->GetXGraphic(), uno::UNO_QUERY); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_GRAPHIC_BITMAP, xBitmap)); + } + + Size aSize = rFormat.GetGraphicSize(); + // #i101131# + // adjust conversion due to type mismatch between and + awt::Size aAwtSize(convertTwipToMm100(aSize.Width()), convertTwipToMm100(aSize.Height())); + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_GRAPHIC_SIZE, aAwtSize)); + + const SwFormatVertOrient* pOrient = rFormat.GetGraphicOrientation(); + if(pOrient) + { + uno::Any any; + pOrient->QueryValue(any); + aPropertyValues.emplace_back( + UNO_NAME_VERT_ORIENT, -1, any, PropertyState_DIRECT_VALUE); + } + } + } + else + { + aUString = *pHeadingStyleName; + aPropertyValues.push_back(comphelper::makePropertyValue(UNO_NAME_HEADING_STYLE_NAME, aUString)); + } + + return ::comphelper::containerToSequence(aPropertyValues); +} + +void SwXNumberingRules::SetNumberingRuleByIndex( + SwNumRule& rNumRule, + const uno::Sequence& rProperties, sal_Int32 nIndex) +{ + SolarMutexGuard aGuard; + OSL_ENSURE( 0 <= nIndex && nIndex < MAXLEVEL, "index out of range" ); + + SwNumFormat aFormat(rNumRule.Get( o3tl::narrowing(nIndex) )); + + OUString sHeadingStyleName; + OUString sParagraphStyleName; + + SetPropertiesToNumFormat(aFormat, m_sNewCharStyleNames[nIndex], + &m_sNewBulletFontNames[nIndex], + &sHeadingStyleName, &sParagraphStyleName, + m_pDoc, m_pDocShell, rProperties); + + + if (m_pDoc && !sParagraphStyleName.isEmpty()) + { + const SwTextFormatColls* pColls = m_pDoc->GetTextFormatColls(); + const size_t nCount = pColls->size(); + for (size_t k = 0; k < nCount; ++k) + { + SwTextFormatColl &rTextColl = *((*pColls)[k]); + if (rTextColl.GetName() == sParagraphStyleName) + rTextColl.SetFormatAttr( SwNumRuleItem( rNumRule.GetName())); + } + } + + if (!sHeadingStyleName.isEmpty()) + { + assert(m_pDocShell); + const SwTextFormatColls* pColls = m_pDocShell->GetDoc()->GetTextFormatColls(); + const size_t nCount = pColls->size(); + for (size_t k = 0; k < nCount; ++k) + { + SwTextFormatColl &rTextColl = *((*pColls)[k]); + if (rTextColl.IsDefault()) + continue; + if (rTextColl.IsAssignedToListLevelOfOutlineStyle() && + rTextColl.GetAssignedOutlineStyleLevel() == nIndex && + rTextColl.GetName() != sHeadingStyleName) + { + rTextColl.DeleteAssignmentToListLevelOfOutlineStyle(); + } + else if (rTextColl.GetName() == sHeadingStyleName) + { + rTextColl.AssignToListLevelOfOutlineStyle( nIndex ); + } + } + } + + rNumRule.Set(o3tl::narrowing(nIndex), aFormat); +} + +void SwXNumberingRules::SetPropertiesToNumFormat( + SwNumFormat & aFormat, + OUString & rCharStyleName, OUString *const pBulletFontName, + OUString *const pHeadingStyleName, + OUString *const pParagraphStyleName, + SwDoc *const pDoc, + SwDocShell *const pDocShell, + const uno::Sequence& rProperties) +{ + assert(pDoc == nullptr || pDocShell == nullptr); // can't be both ordinary and chapter numbering + + bool bWrongArg = false; + std::unique_ptr pSetBrush; + std::unique_ptr pSetSize; + std::unique_ptr pSetVOrient; + bool bCharStyleNameSet = false; + + for (const beans::PropertyValue& rProp : rProperties) + { + if (rProp.Name == UNO_NAME_ADJUST) + { + sal_Int16 nValue = text::HoriOrientation::NONE; + rProp.Value >>= nValue; + switch (nValue) { + case text::HoriOrientation::RIGHT: + aFormat.SetNumAdjust(SvxAdjust::Right); + break; + case text::HoriOrientation::CENTER: + aFormat.SetNumAdjust(SvxAdjust::Center); + break; + case text::HoriOrientation::LEFT: + aFormat.SetNumAdjust(SvxAdjust::Left); + break; + default: + bWrongArg = true; + break; + } + } + else if (rProp.Name == UNO_NAME_PARENT_NUMBERING) + { + sal_Int16 nSet = 0; + rProp.Value >>= nSet; + if(nSet >= 0 && MAXLEVEL >= nSet) + aFormat.SetIncludeUpperLevels( static_cast< sal_uInt8 >(nSet) ); + } + else if (rProp.Name == UNO_NAME_PREFIX) + { + OUString uTmp; + rProp.Value >>= uTmp; + aFormat.SetPrefix(uTmp); + } + else if (rProp.Name == UNO_NAME_SUFFIX) + { + OUString uTmp; + rProp.Value >>= uTmp; + aFormat.SetSuffix(uTmp); + } + else if (rProp.Name == UNO_NAME_CHAR_STYLE_NAME) + { + bCharStyleNameSet = true; + OUString uTmp; + rProp.Value >>= uTmp; + OUString sCharFormatName; + SwStyleNameMapper::FillUIName( uTmp, sCharFormatName, SwGetPoolIdFromName::ChrFmt ); + SwDoc *const pLocalDoc = pDocShell ? pDocShell->GetDoc() : pDoc; + if (sCharFormatName.isEmpty()) + { + rCharStyleName.clear(); + aFormat.SetCharFormat(nullptr); + aFormat.SetCharFormatName(""); + } + else if (pLocalDoc) + { + SwCharFormat* pCharFormat = nullptr; + if (!sCharFormatName.isEmpty()) + { + pCharFormat = pLocalDoc->FindCharFormatByName(sCharFormatName); + if(!pCharFormat) + { + + SfxStyleSheetBase* pBase; + SfxStyleSheetBasePool* pPool = pLocalDoc->GetDocShell()->GetStyleSheetPool(); + pBase = pPool->Find(sCharFormatName, SfxStyleFamily::Char); + if(!pBase) + pBase = &pPool->Make(sCharFormatName, SfxStyleFamily::Char); + pCharFormat = static_cast(pBase)->GetCharFormat(); + } + } + aFormat.SetCharFormat( pCharFormat ); + // #i51842# + // If the character format has been found its name should not be in the + // char style names array + rCharStyleName.clear(); + } + else + rCharStyleName = sCharFormatName; + } + else if (rProp.Name == UNO_NAME_START_WITH) + { + sal_Int16 nVal = 0; + rProp.Value >>= nVal; + aFormat.SetStart(nVal); + } + else if (rProp.Name == UNO_NAME_LEFT_MARGIN) + { + sal_Int32 nValue = 0; + rProp.Value >>= nValue; + // #i23727# nValue can be negative + aFormat.SetAbsLSpace(o3tl::toTwips(nValue, o3tl::Length::mm100)); + } + else if (rProp.Name == UNO_NAME_SYMBOL_TEXT_DISTANCE) + { + sal_Int32 nValue = 0; + rProp.Value >>= nValue; + if (nValue >= 0) + aFormat.SetCharTextDistance(o3tl::toTwips(nValue, o3tl::Length::mm100)); + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_FIRST_LINE_OFFSET) + { + sal_Int32 nValue = 0; + rProp.Value >>= nValue; + // #i23727# nValue can be positive + nValue = o3tl::toTwips(nValue, o3tl::Length::mm100); + aFormat.SetFirstLineOffset(nValue); + } + else if (rProp.Name == UNO_NAME_POSITION_AND_SPACE_MODE) + { + sal_Int16 nValue = 0; + rProp.Value >>= nValue; + if ( nValue == 0 ) + { + aFormat.SetPositionAndSpaceMode( SvxNumberFormat::LABEL_WIDTH_AND_POSITION ); + } + else if ( nValue == 1 ) + { + aFormat.SetPositionAndSpaceMode( SvxNumberFormat::LABEL_ALIGNMENT ); + } + else + { + bWrongArg = true; + } + } + else if (rProp.Name == UNO_NAME_LABEL_FOLLOWED_BY) + { + sal_Int16 nValue = 0; + rProp.Value >>= nValue; + if ( nValue == LabelFollow::LISTTAB ) + { + aFormat.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); + } + else if ( nValue == LabelFollow::SPACE ) + { + aFormat.SetLabelFollowedBy( SvxNumberFormat::SPACE ); + } + else if ( nValue == LabelFollow::NOTHING ) + { + aFormat.SetLabelFollowedBy( SvxNumberFormat::NOTHING ); + } + else if ( nValue == LabelFollow::NEWLINE ) + { + aFormat.SetLabelFollowedBy( SvxNumberFormat::NEWLINE ); + } + else + { + bWrongArg = true; + } + } + else if (rProp.Name == UNO_NAME_LISTTAB_STOP_POSITION) + { + sal_Int32 nValue = 0; + rProp.Value >>= nValue; + nValue = o3tl::toTwips(nValue, o3tl::Length::mm100); + if ( nValue >= 0 ) + { + aFormat.SetListtabPos( nValue ); + } + else + { + bWrongArg = true; + } + } + else if (rProp.Name == UNO_NAME_FIRST_LINE_INDENT) + { + sal_Int32 nValue = 0; + rProp.Value >>= nValue; + nValue = o3tl::toTwips(nValue, o3tl::Length::mm100); + aFormat.SetFirstLineIndent( nValue ); + } + else if (rProp.Name == UNO_NAME_INDENT_AT) + { + sal_Int32 nValue = 0; + rProp.Value >>= nValue; + nValue = o3tl::toTwips(nValue, o3tl::Length::mm100); + aFormat.SetIndentAt( nValue ); + } + else if (rProp.Name == UNO_NAME_NUMBERING_TYPE) + { + sal_Int16 nSet = 0; + rProp.Value >>= nSet; + if(nSet >= 0) + aFormat.SetNumberingType(static_cast(nSet)); + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_PARAGRAPH_STYLE_NAME) + { + if (pParagraphStyleName) + { + OUString uTmp; + rProp.Value >>= uTmp; + OUString sStyleName; + SwStyleNameMapper::FillUIName(uTmp, sStyleName, SwGetPoolIdFromName::TxtColl ); + *pParagraphStyleName = sStyleName; + } + } + else if (rProp.Name == UNO_NAME_BULLET_ID) + { + sal_Int16 nSet = 0; + if( rProp.Value >>= nSet ) + aFormat.SetBulletChar(nSet); + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_BULLET_FONT) + { + awt::FontDescriptor desc; + if (rProp.Value >>= desc) + { + // #i93725# + // do not accept "empty" font + if (!desc.Name.isEmpty()) + { + vcl::Font aFont; + SvxUnoFontDescriptor::ConvertToFont(desc, aFont); + aFormat.SetBulletFont(&aFont); + } + } + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_BULLET_FONT_NAME) + { + OUString sBulletFontName; + rProp.Value >>= sBulletFontName; + SwDocShell *const pLclDocShell = pDocShell ? pDocShell : pDoc ? pDoc->GetDocShell() : nullptr; + if (!sBulletFontName.isEmpty() && pLclDocShell) + { + const SvxFontListItem* pFontListItem = + static_cast(pLclDocShell + ->GetItem( SID_ATTR_CHAR_FONTLIST )); + const FontList* pList = pFontListItem->GetFontList(); + FontMetric aFontMetric = pList->Get( + sBulletFontName, WEIGHT_NORMAL, ITALIC_NONE); + vcl::Font aFont(aFontMetric); + aFormat.SetBulletFont(&aFont); + } + else if (pBulletFontName) + *pBulletFontName = sBulletFontName; + } + else if (rProp.Name == UNO_NAME_BULLET_CHAR) + { + OUString aChar; + rProp.Value >>= aChar; + if (aChar.isEmpty()) + { + // If w:lvlText's value is null - set bullet char to zero + aFormat.SetBulletChar(u'\0'); + } + else + { + sal_Int32 nIndexUtf16 = 0; + sal_UCS4 cBullet = aChar.iterateCodePoints(&nIndexUtf16); + if (aChar.getLength() == nIndexUtf16) + aFormat.SetBulletChar(cBullet); + else + bWrongArg = true; + } + } + else if (rProp.Name == UNO_NAME_GRAPHIC) + { + uno::Reference xGraphic; + if (rProp.Value >>= xGraphic) + { + if (!pSetBrush) + { + const SvxBrushItem* pOrigBrush = aFormat.GetBrush(); + if(pOrigBrush) + pSetBrush.reset(new SvxBrushItem(*pOrigBrush)); + else + pSetBrush.reset(new SvxBrushItem(OUString(), OUString(), GPOS_AREA, RES_BACKGROUND)); + } + Graphic aGraphic(xGraphic); + pSetBrush->SetGraphic(aGraphic); + } + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_GRAPHIC_BITMAP) + { + uno::Reference xBitmap; + if (rProp.Value >>= xBitmap) + { + if(!pSetBrush) + { + const SvxBrushItem* pOrigBrush = aFormat.GetBrush(); + if(pOrigBrush) + pSetBrush.reset(new SvxBrushItem(*pOrigBrush)); + else + pSetBrush.reset(new SvxBrushItem(OUString(), OUString(), GPOS_AREA, RES_BACKGROUND)); + } + + uno::Reference xGraphic(xBitmap, uno::UNO_QUERY); + Graphic aGraphic(xGraphic); + pSetBrush->SetGraphic(aGraphic); + } + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_GRAPHIC_SIZE) + { + if(!pSetSize) + pSetSize.reset(new Size); + awt::Size size; + if (rProp.Value >>= size) + { + pSetSize->setWidth(o3tl::toTwips(size.Width, o3tl::Length::mm100)); + pSetSize->setHeight(o3tl::toTwips(size.Height, o3tl::Length::mm100)); + } + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_VERT_ORIENT) + { + if(!pSetVOrient) + { + if(aFormat.GetGraphicOrientation()) + pSetVOrient.reset(aFormat.GetGraphicOrientation()->Clone()); + else + pSetVOrient.reset(new SwFormatVertOrient); + } + pSetVOrient->PutValue(rProp.Value, MID_VERTORIENT_ORIENT); + } + else if (rProp.Name == UNO_NAME_HEADING_STYLE_NAME + && pDocShell) // only on chapter numbering + { + if (pHeadingStyleName) + { + OUString uTmp; + rProp.Value >>= uTmp; + OUString sStyleName; + SwStyleNameMapper::FillUIName(uTmp, sStyleName, SwGetPoolIdFromName::TxtColl ); + *pHeadingStyleName = sStyleName; + } + } + else if (rProp.Name == UNO_NAME_BULLET_REL_SIZE) + { + // BulletRelSize - unsupported - only available in Impress + } + else if (rProp.Name == UNO_NAME_BULLET_COLOR) + { + // BulletColor - ignored too + } + else if (rProp.Name == UNO_NAME_GRAPHIC_URL) + { + OUString aURL; + if (rProp.Value >>= aURL) + { + if(!pSetBrush) + { + const SvxBrushItem* pOrigBrush = aFormat.GetBrush(); + if(pOrigBrush) + pSetBrush.reset(new SvxBrushItem(*pOrigBrush)); + else + pSetBrush.reset(new SvxBrushItem(OUString(), OUString(), GPOS_AREA, RES_BACKGROUND)); + } + + Graphic aGraphic = vcl::graphic::loadFromURL(aURL); + if (!aGraphic.IsNone()) + pSetBrush->SetGraphic(aGraphic); + } + else + bWrongArg = true; + } + else if (rProp.Name == UNO_NAME_LIST_FORMAT) + { + OUString uTmp; + rProp.Value >>= uTmp; + aFormat.SetListFormat(uTmp); + } + else if (rProp.Name == UNO_NAME_LEVEL_IS_LEGAL) + { + if (bool bVal; rProp.Value >>= bVal) + aFormat.SetIsLegal(bVal); + } + else + { + // Invalid property name + throw beans::UnknownPropertyException("Unknown property " + rProp.Name); + } + } + if(!bWrongArg && (pSetBrush || pSetSize || pSetVOrient)) + { + if(!pSetBrush && aFormat.GetBrush()) + pSetBrush.reset(new SvxBrushItem(*aFormat.GetBrush())); + + if(pSetBrush) + { + if(!pSetVOrient && aFormat.GetGraphicOrientation()) + pSetVOrient.reset( new SwFormatVertOrient(*aFormat.GetGraphicOrientation()) ); + + if(!pSetSize) + { + pSetSize.reset(new Size(aFormat.GetGraphicSize())); + if(!pSetSize->Width() || !pSetSize->Height()) + { + const Graphic* pGraphic = pSetBrush->GetGraphic(); + if(pGraphic) + *pSetSize = ::GetGraphicSizeTwip(*pGraphic, nullptr); + } + } + sal_Int16 eOrient = pSetVOrient ? + pSetVOrient->GetVertOrient() : text::VertOrientation::NONE; + aFormat.SetGraphicBrush( pSetBrush.get(), pSetSize.get(), text::VertOrientation::NONE == eOrient ? nullptr : &eOrient ); + } + } + if ((!bCharStyleNameSet || rCharStyleName.isEmpty()) + && aFormat.GetNumberingType() == NumberingType::BITMAP + && !aFormat.GetCharFormat() + && !SwXNumberingRules::isInvalidStyle(rCharStyleName)) + { + OUString tmp; + SwStyleNameMapper::FillProgName(RES_POOLCHR_BULLET_LEVEL, tmp); + rCharStyleName = tmp; + } + + if(bWrongArg) + throw lang::IllegalArgumentException(); +} + +uno::Reference< XPropertySetInfo > SwXNumberingRules::getPropertySetInfo() +{ + static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); + return aRef; +} + +void SwXNumberingRules::setPropertyValue( const OUString& rPropertyName, const Any& rValue ) +{ + SolarMutexGuard aGuard; + std::unique_ptr pDocRule; + SwNumRule* pCreatedRule = nullptr; + if(!m_pNumRule) + { + if(m_pDocShell) + { + pDocRule.reset(new SwNumRule(*m_pDocShell->GetDoc()->GetOutlineNumRule())); + } + else if(m_pDoc && !m_sCreatedNumRuleName.isEmpty()) + { + pCreatedRule = m_pDoc->FindNumRulePtr(m_sCreatedNumRuleName); + } + + } + if(!m_pNumRule && !pDocRule && !pCreatedRule) + throw RuntimeException(); + + if(rPropertyName == UNO_NAME_IS_AUTOMATIC) + { + bool bVal = *o3tl::doAccess(rValue); + if(!pCreatedRule) + pDocRule ? pDocRule->SetAutoRule(bVal) : m_pNumRule->SetAutoRule(bVal); + } + else if(rPropertyName == UNO_NAME_IS_CONTINUOUS_NUMBERING) + { + bool bVal = *o3tl::doAccess(rValue); + pDocRule ? pDocRule->SetContinusNum(bVal) : + pCreatedRule ? pCreatedRule->SetContinusNum(bVal) : m_pNumRule->SetContinusNum(bVal); + } + else if(rPropertyName == UNO_NAME_NAME) + { + throw IllegalArgumentException(); + } + else if(rPropertyName == UNO_NAME_IS_ABSOLUTE_MARGINS) + { + bool bVal = *o3tl::doAccess(rValue); + pDocRule ? pDocRule->SetAbsSpaces(bVal) : + pCreatedRule ? pCreatedRule->SetAbsSpaces(bVal) : m_pNumRule->SetAbsSpaces(bVal); + } + else if(rPropertyName == UNO_NAME_NUMBERING_IS_OUTLINE) + { + bool bVal = *o3tl::doAccess(rValue); + SwNumRuleType eNumRuleType = bVal ? OUTLINE_RULE : NUM_RULE; + pDocRule ? pDocRule->SetRuleType(eNumRuleType) : + pCreatedRule ? pCreatedRule->SetRuleType(eNumRuleType) : m_pNumRule->SetRuleType(eNumRuleType); + } + else if(rPropertyName == UNO_NAME_DEFAULT_LIST_ID) + { + throw IllegalArgumentException(); + } + else + throw UnknownPropertyException(rPropertyName); + + if(pDocRule) + { + assert(m_pDocShell); + m_pDocShell->GetDoc()->SetOutlineNumRule(*pDocRule); + pDocRule.reset(); + } + else if(pCreatedRule) + { + pCreatedRule->Validate(*m_pDoc); + } +} + +Any SwXNumberingRules::getPropertyValue( const OUString& rPropertyName ) +{ + Any aRet; + const SwNumRule* pRule = m_pNumRule; + if(!pRule && m_pDocShell) + pRule = m_pDocShell->GetDoc()->GetOutlineNumRule(); + else if(m_pDoc && !m_sCreatedNumRuleName.isEmpty()) + pRule = m_pDoc->FindNumRulePtr( m_sCreatedNumRuleName ); + if(!pRule) + throw RuntimeException(); + + if(rPropertyName == UNO_NAME_IS_AUTOMATIC) + { + aRet <<= pRule->IsAutoRule(); + } + else if(rPropertyName == UNO_NAME_IS_CONTINUOUS_NUMBERING) + { + aRet <<= pRule->IsContinusNum(); + } + else if(rPropertyName == UNO_NAME_NAME) + aRet <<= pRule->GetName(); + else if(rPropertyName == UNO_NAME_IS_ABSOLUTE_MARGINS) + { + aRet <<= pRule->IsAbsSpaces(); + } + else if(rPropertyName == UNO_NAME_NUMBERING_IS_OUTLINE) + { + aRet <<= pRule->IsOutlineRule(); + } + else if(rPropertyName == UNO_NAME_DEFAULT_LIST_ID) + { + OSL_ENSURE( !pRule->GetDefaultListId().isEmpty(), + " - no default list id found. Serious defect." ); + aRet <<= pRule->GetDefaultListId(); + } + else + throw UnknownPropertyException(rPropertyName); + return aRet; +} + +void SwXNumberingRules::addPropertyChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*xListener*/ ) +{ +} + +void SwXNumberingRules::removePropertyChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*xListener*/ ) +{ +} + +void SwXNumberingRules::addVetoableChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< XVetoableChangeListener >& /*xListener*/ ) +{ +} + +void SwXNumberingRules::removeVetoableChangeListener( + const OUString& /*rPropertyName*/, const uno::Reference< XVetoableChangeListener >& /*xListener*/ ) +{ +} + +OUString SwXNumberingRules::getName() +{ + if(m_pNumRule) + { + OUString aString; + SwStyleNameMapper::FillProgName(m_pNumRule->GetName(), aString, SwGetPoolIdFromName::NumRule ); + return aString; + } + // consider chapter numbering + if ( m_pDocShell ) + { + OUString aString; + SwStyleNameMapper::FillProgName( m_pDocShell->GetDoc()->GetOutlineNumRule()->GetName(), + aString, SwGetPoolIdFromName::NumRule ); + return aString; + } + return m_sCreatedNumRuleName; +} + +void SwXNumberingRules::setName(const OUString& /*rName*/) +{ + throw RuntimeException("readonly"); +} + +void SwXNumberingRules::Impl::Notify(const SfxHint& rHint) +{ + if(rHint.GetId() == SfxHintId::Dying) + { + if(m_rParent.m_bOwnNumRuleCreated) + delete m_rParent.m_pNumRule; + m_rParent.m_pNumRule = nullptr; + m_rParent.m_pDoc = nullptr; + } +} + +OUString SwXChapterNumbering::getImplementationName() +{ + return "SwXChapterNumbering"; +} + +sal_Bool SwXChapterNumbering::supportsService(const OUString& rServiceName) +{ + return cppu::supportsService(this, rServiceName); +} + +Sequence< OUString > SwXChapterNumbering::getSupportedServiceNames() +{ + return { "com.sun.star.text.ChapterNumbering", "com.sun.star.text.NumberingRules" }; +} + +SwXChapterNumbering::SwXChapterNumbering(SwDocShell& rDocSh) : + SwXNumberingRules(rDocSh) +{ +} + +SwXChapterNumbering::~SwXChapterNumbering() +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3