diff options
Diffstat (limited to 'xmloff/source/style/xmlnumi.cxx')
| -rw-r--r-- | xmloff/source/style/xmlnumi.cxx | 1274 |
1 files changed, 1274 insertions, 0 deletions
diff --git a/xmloff/source/style/xmlnumi.cxx b/xmloff/source/style/xmlnumi.cxx new file mode 100644 index 000000000..a8924c5a7 --- /dev/null +++ b/xmloff/source/style/xmlnumi.cxx @@ -0,0 +1,1274 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/awt/Size.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/graphic/XGraphic.hpp> +#include <com/sun/star/awt/FontDescriptor.hpp> +#include <com/sun/star/text/HoriOrientation.hpp> +#include <com/sun/star/text/VertOrientation.hpp> +#include <com/sun/star/text/PositionAndSpaceMode.hpp> +#include <com/sun/star/text/LabelFollow.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/style/XStyle.hpp> +#include <com/sun/star/io/XOutputStream.hpp> +#include <com/sun/star/awt/XBitmap.hpp> +#include <com/sun/star/style/NumberingType.hpp> +#include <com/sun/star/container/XIndexReplace.hpp> + +#include <o3tl/any.hxx> +#include <rtl/ustrbuf.hxx> +#include <sal/log.hxx> +#include <osl/diagnose.h> + +#include <tools/fontenum.hxx> +#include <tools/color.hxx> + +#include <sax/tools/converter.hxx> + +#include <xmloff/xmltkmap.hxx> +#include <xmloff/nmspmap.hxx> +#include <xmloff/xmlnmspe.hxx> +#include <xmloff/xmlimp.hxx> +#include <xmloff/XMLBase64ImportContext.hxx> +#include <xmloff/xmltoken.hxx> + +#include <xmloff/xmluconv.hxx> +#include "fonthdl.hxx" +#include <xmloff/XMLFontStylesContext.hxx> +#include <xmloff/families.hxx> +#include <xmloff/maptype.hxx> + +#include <xmloff/xmlnumi.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::style; +using namespace ::com::sun::star::text; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::container; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::frame; +using namespace ::xmloff::token; +using namespace ::com::sun::star::io; + +class SvxXMLListLevelStyleContext_Impl; + +namespace { + +class SvxXMLListLevelStyleAttrContext_Impl : public SvXMLImportContext +{ + SvxXMLListLevelStyleContext_Impl& rListLevel; + +public: + + SvxXMLListLevelStyleAttrContext_Impl( + SvXMLImport& rImport, sal_uInt16 nPrfx, + const OUString& rLName, + const Reference< xml::sax::XAttributeList >& xAttrList, + SvxXMLListLevelStyleContext_Impl& rLLevel ); + + virtual SvXMLImportContextRef CreateChildContext( + sal_uInt16 nPrefix, const OUString& rLocalName, + const Reference< xml::sax::XAttributeList > & xAttrList ) override; +}; + +class SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl : public SvXMLImportContext +{ +public: + + SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl( + SvXMLImport& rImport, sal_uInt16 nPrfx, + const OUString& rLName, + const Reference< xml::sax::XAttributeList >& xAttrList, + SvxXMLListLevelStyleContext_Impl& rLLevel ); +}; + +enum SvxXMLTextListLevelStyleAttrTokens +{ + XML_TOK_TEXT_LEVEL_ATTR_LEVEL, + XML_TOK_TEXT_LEVEL_ATTR_STYLE_NAME, + XML_TOK_TEXT_LEVEL_ATTR_BULLET_CHAR, + XML_TOK_TEXT_LEVEL_ATTR_HREF, + XML_TOK_TEXT_LEVEL_ATTR_TYPE, + XML_TOK_TEXT_LEVEL_ATTR_SHOW, + XML_TOK_TEXT_LEVEL_ATTR_ACTUATE, + XML_TOK_TEXT_LEVEL_ATTR_NUM_FORMAT, + XML_TOK_TEXT_LEVEL_ATTR_NUM_PREFIX, + XML_TOK_TEXT_LEVEL_ATTR_NUM_SUFFIX, + XML_TOK_TEXT_LEVEL_ATTR_NUM_LETTER_SYNC, + XML_TOK_TEXT_LEVEL_ATTR_START_VALUE, + XML_TOK_TEXT_LEVEL_ATTR_DISPLAY_LEVELS +}; + +} + +static const SvXMLTokenMapEntry* lcl_getLevelAttrTokenMap() +{ + static const SvXMLTokenMapEntry aLevelAttrTokenMap[] = + { + { XML_NAMESPACE_TEXT, XML_LEVEL, XML_TOK_TEXT_LEVEL_ATTR_LEVEL }, + { XML_NAMESPACE_TEXT, XML_STYLE_NAME, XML_TOK_TEXT_LEVEL_ATTR_STYLE_NAME }, + { XML_NAMESPACE_TEXT, XML_BULLET_CHAR, XML_TOK_TEXT_LEVEL_ATTR_BULLET_CHAR }, + { XML_NAMESPACE_XLINK, XML_HREF, XML_TOK_TEXT_LEVEL_ATTR_HREF }, + { XML_NAMESPACE_XLINK, XML_TYPE, XML_TOK_TEXT_LEVEL_ATTR_TYPE }, + { XML_NAMESPACE_XLINK, XML_SHOW, XML_TOK_TEXT_LEVEL_ATTR_SHOW }, + { XML_NAMESPACE_XLINK, XML_ACTUATE, XML_TOK_TEXT_LEVEL_ATTR_ACTUATE }, + + { XML_NAMESPACE_STYLE, XML_NUM_FORMAT, XML_TOK_TEXT_LEVEL_ATTR_NUM_FORMAT }, + { XML_NAMESPACE_STYLE, XML_NUM_PREFIX, XML_TOK_TEXT_LEVEL_ATTR_NUM_PREFIX }, + { XML_NAMESPACE_STYLE, XML_NUM_SUFFIX, XML_TOK_TEXT_LEVEL_ATTR_NUM_SUFFIX }, + { XML_NAMESPACE_STYLE, XML_NUM_LETTER_SYNC, XML_TOK_TEXT_LEVEL_ATTR_NUM_LETTER_SYNC }, + { XML_NAMESPACE_TEXT, XML_START_VALUE, XML_TOK_TEXT_LEVEL_ATTR_START_VALUE }, + { XML_NAMESPACE_TEXT, XML_DISPLAY_LEVELS, XML_TOK_TEXT_LEVEL_ATTR_DISPLAY_LEVELS }, + + XML_TOKEN_MAP_END + }; + return aLevelAttrTokenMap; +} + +class SvxXMLListLevelStyleContext_Impl : public SvXMLImportContext +{ + friend SvxXMLListLevelStyleAttrContext_Impl; + + OUString sPrefix; + OUString sSuffix; + OUString sTextStyleName; + OUString sNumFormat; + OUString sNumLetterSync; + OUString sBulletFontName; + OUString sBulletFontStyleName; + OUString sImageURL; + + Reference < XOutputStream > xBase64Stream; + + sal_Int32 nLevel; + sal_Int32 nSpaceBefore; + sal_Int32 nMinLabelWidth; + sal_Int32 nMinLabelDist; + sal_Int32 nImageWidth; + sal_Int32 nImageHeight; + sal_Int16 nNumStartValue; + sal_Int16 nNumDisplayLevels; + + sal_Int16 eAdjust; + sal_Int16 eBulletFontFamily; + sal_Int16 eBulletFontPitch; + rtl_TextEncoding eBulletFontEncoding; + sal_Int16 eImageVertOrient; + + sal_Unicode cBullet; + + sal_Int16 nRelSize; + Color m_nColor; + + sal_Int16 ePosAndSpaceMode; + sal_Int16 eLabelFollowedBy; + sal_Int32 nListtabStopPosition; + sal_Int32 nFirstLineIndent; + sal_Int32 nIndentAt; + + bool bBullet : 1; + bool bImage : 1; + bool bNum : 1; + bool bHasColor : 1; + + void SetRelSize( sal_Int16 nRel ) { nRelSize = nRel; } + void SetColor( Color nColor ) + { m_nColor = nColor; bHasColor = true; } + void SetSpaceBefore( sal_Int32 nSet ) { nSpaceBefore = nSet; } + void SetMinLabelWidth( sal_Int32 nSet ) { nMinLabelWidth = nSet; } + void SetMinLabelDist( sal_Int32 nSet ) { nMinLabelDist = nSet; } + void SetAdjust( sal_Int16 eSet ) { eAdjust = eSet; } + + void SetBulletFontName( const OUString& rSet ) { sBulletFontName = rSet; } + void SetBulletFontStyleName( const OUString& rSet ) + { sBulletFontStyleName = rSet; } + void SetBulletFontFamily( sal_Int16 eSet ) { eBulletFontFamily = eSet; } + void SetBulletFontPitch( sal_Int16 eSet ) { eBulletFontPitch = eSet; } + void SetBulletFontEncoding( rtl_TextEncoding eSet ) + { eBulletFontEncoding = eSet; } + + void SetImageWidth( sal_Int32 nSet ) { nImageWidth = nSet; } + void SetImageHeight( sal_Int32 nSet ) { nImageHeight = nSet; } + void SetImageVertOrient( sal_Int16 eSet ) + { eImageVertOrient = eSet; } + +public: + + SvxXMLListLevelStyleContext_Impl( + SvXMLImport& rImport, sal_uInt16 nPrfx, + const OUString& rLName, + const Reference< xml::sax::XAttributeList > & xAttrList ); + + virtual SvXMLImportContextRef CreateChildContext( + sal_uInt16 nPrefix, const OUString& rLocalName, + const Reference< xml::sax::XAttributeList > & xAttrList ) override; + + sal_Int32 GetLevel() const { return nLevel; } + Sequence<beans::PropertyValue> GetProperties(); + + void SetPosAndSpaceMode( sal_Int16 eValue ) + { + ePosAndSpaceMode = eValue; + } + void SetLabelFollowedBy( sal_Int16 eValue ) + { + eLabelFollowedBy = eValue; + } + void SetListtabStopPosition( sal_Int32 nValue ) + { + nListtabStopPosition = nValue; + } + void SetFirstLineIndent( sal_Int32 nValue ) + { + nFirstLineIndent = nValue; + } + void SetIndentAt( sal_Int32 nValue ) + { + nIndentAt = nValue; + } +}; + +static const OUStringLiteral gsStarBats( "StarBats" ); +static const OUStringLiteral gsStarMath( "StarMath" ); + +SvxXMLListLevelStyleContext_Impl::SvxXMLListLevelStyleContext_Impl( + SvXMLImport& rImport, sal_uInt16 nPrfx, + const OUString& rLName, + const Reference< xml::sax::XAttributeList > & xAttrList ) + +: SvXMLImportContext( rImport, nPrfx, rLName ) +, sNumFormat( "1" ) +, nLevel( -1 ) +, nSpaceBefore( 0 ) +, nMinLabelWidth( 0 ) +, nMinLabelDist( 0 ) +, nImageWidth( 0 ) +, nImageHeight( 0 ) +, nNumStartValue( 1 ) +, nNumDisplayLevels( 1 ) +, eAdjust( HoriOrientation::LEFT ) +, eBulletFontFamily( FAMILY_DONTKNOW ) +, eBulletFontPitch( PITCH_DONTKNOW ) +, eBulletFontEncoding( RTL_TEXTENCODING_DONTKNOW ) +, eImageVertOrient(0) +, cBullet( 0 ) +, nRelSize(0) +, m_nColor(0) +, ePosAndSpaceMode( PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION ) +, eLabelFollowedBy( LabelFollow::LISTTAB ) +, nListtabStopPosition( 0 ) +, nFirstLineIndent( 0 ) +, nIndentAt( 0 ) +, bBullet( false ) +, bImage( false ) +, bNum( false ) +, bHasColor( false ) +{ + if( IsXMLToken( rLName, XML_LIST_LEVEL_STYLE_NUMBER ) || + IsXMLToken( rLName, XML_OUTLINE_LEVEL_STYLE ) ) + bNum = true; + else if( IsXMLToken( rLName, XML_LIST_LEVEL_STYLE_BULLET ) ) + bBullet = true; + else if( IsXMLToken( rLName, XML_LIST_LEVEL_STYLE_IMAGE ) ) + bImage = true; + + static const SvXMLTokenMap aTokenMap( lcl_getLevelAttrTokenMap() ); + sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; + for( sal_Int16 i=0; i < nAttrCount; i++ ) + { + const OUString& rAttrName = xAttrList->getNameByIndex( i ); + OUString aLocalName; + sal_uInt16 nPrefix = + GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, + &aLocalName ); + const OUString& rValue = xAttrList->getValueByIndex( i ); + + switch( aTokenMap.Get( nPrefix, aLocalName ) ) + { + case XML_TOK_TEXT_LEVEL_ATTR_LEVEL: + nLevel = rValue.toInt32(); + if( nLevel >= 1 ) + nLevel--; + else + nLevel = 0; + break; + case XML_TOK_TEXT_LEVEL_ATTR_STYLE_NAME: + sTextStyleName = rValue; + break; + case XML_TOK_TEXT_LEVEL_ATTR_BULLET_CHAR: + if (!rValue.isEmpty()) + cBullet = rValue[0]; + break; + case XML_TOK_TEXT_LEVEL_ATTR_HREF: + if( bImage ) + sImageURL = rValue; + break; + case XML_TOK_TEXT_LEVEL_ATTR_TYPE: + case XML_TOK_TEXT_LEVEL_ATTR_SHOW: + case XML_TOK_TEXT_LEVEL_ATTR_ACTUATE: + // This properties will be ignored + break; + case XML_TOK_TEXT_LEVEL_ATTR_NUM_FORMAT: + if( bNum ) + sNumFormat = rValue; + break; + case XML_TOK_TEXT_LEVEL_ATTR_NUM_PREFIX: + sPrefix = rValue; + break; + case XML_TOK_TEXT_LEVEL_ATTR_NUM_SUFFIX: + sSuffix = rValue; + break; + case XML_TOK_TEXT_LEVEL_ATTR_NUM_LETTER_SYNC: + if( bNum ) + sNumLetterSync = rValue; + break; + case XML_TOK_TEXT_LEVEL_ATTR_START_VALUE: + if( bNum ) + { + sal_Int32 nTmp = rValue.toInt32(); + nNumStartValue = + (nTmp < 0) ? 1 : ( (nTmp>SHRT_MAX) ? SHRT_MAX + : static_cast<sal_Int16>(nTmp) ); + } + break; + case XML_TOK_TEXT_LEVEL_ATTR_DISPLAY_LEVELS: + if( bNum ) + { + sal_Int32 nTmp = rValue.toInt32(); + nNumDisplayLevels = + (nTmp < 1) ? 1 : ( (nTmp>SHRT_MAX) ? SHRT_MAX + : static_cast<sal_Int16>(nTmp) ); + } + break; + } + } +} + +SvXMLImportContextRef SvxXMLListLevelStyleContext_Impl::CreateChildContext( + sal_uInt16 nPrefix, const OUString& rLocalName, + const Reference< xml::sax::XAttributeList > & xAttrList ) +{ + SvXMLImportContext *pContext = nullptr; + if( XML_NAMESPACE_STYLE == nPrefix && + ( IsXMLToken( rLocalName, XML_LIST_LEVEL_PROPERTIES ) || + IsXMLToken( rLocalName, XML_TEXT_PROPERTIES ) ) ) + { + pContext = new SvxXMLListLevelStyleAttrContext_Impl( GetImport(), + nPrefix, + rLocalName, + xAttrList, + *this ); + } + else if( (XML_NAMESPACE_OFFICE == nPrefix) && xmloff::token::IsXMLToken( rLocalName, + xmloff::token::XML_BINARY_DATA ) ) + { + if( bImage && sImageURL.isEmpty() && !xBase64Stream.is() ) + { + xBase64Stream = GetImport().GetStreamForGraphicObjectURLFromBase64(); + if( xBase64Stream.is() ) + pContext = new XMLBase64ImportContext( GetImport(), nPrefix, + rLocalName, xAttrList, + xBase64Stream ); + } + } + + return pContext; +} + +Sequence<beans::PropertyValue> SvxXMLListLevelStyleContext_Impl::GetProperties() +{ + sal_Int16 eType = NumberingType::NUMBER_NONE; + + sal_Int32 nCount = 0; + if( bBullet ) + { + eType = NumberingType::CHAR_SPECIAL; + nCount = 15; // 'cBullet' will be written anyway if 'bBullet' is true + } + if( bImage ) + { + eType = NumberingType::BITMAP; + nCount = 15; + + if( !sImageURL.isEmpty() || xBase64Stream.is() ) + nCount++; + } + if( bNum ) + { + eType = NumberingType::ARABIC; + GetImport().GetMM100UnitConverter().convertNumFormat( + eType, sNumFormat, sNumLetterSync, true ); + nCount = 15; + } + + if( ( bBullet || bNum ) && nRelSize ) + nCount++; + + if( !bImage && bHasColor ) + { + nCount++; + } + + if (bBullet && !sSuffix.isEmpty()) + { + sal_uInt16 const nVersion(GetImport().getGeneratorVersion()); + sal_Int32 nUPD; + sal_Int32 nBuildId; + if (GetImport().getBuildIds(nUPD, nBuildId) + && ( (SvXMLImport::OOo_1x == nVersion) + || (SvXMLImport::OOo_2x == nVersion) + || (310 == nUPD) || (320 == nUPD) || (330 == nUPD) + || ((300 == nUPD) && (nBuildId <= 9573)))) + { + // #i93908# OOo < 3.4 wrote a bogus suffix for bullet chars + sSuffix.clear(); // clear it + } + } + + Sequence<beans::PropertyValue> aPropSeq( nCount ); + if( nCount > 0 ) + { + beans::PropertyValue *pProps = aPropSeq.getArray(); + sal_Int32 nPos = 0; + pProps[nPos].Name = "NumberingType"; + pProps[nPos++].Value <<= eType ; + + pProps[nPos].Name = "Prefix"; + pProps[nPos++].Value <<= sPrefix; + + pProps[nPos].Name = "Suffix"; + pProps[nPos++].Value <<= sSuffix; + + pProps[nPos].Name = "Adjust"; + pProps[nPos++].Value <<= eAdjust; + + sal_Int32 nLeftMargin = nSpaceBefore + nMinLabelWidth; + pProps[nPos].Name = "LeftMargin"; + pProps[nPos++].Value <<= nLeftMargin; + + sal_Int32 nFirstLineOffset = -nMinLabelWidth; + + pProps[nPos].Name = "FirstLineOffset"; + pProps[nPos++].Value <<= nFirstLineOffset; + + pProps[nPos].Name = "SymbolTextDistance"; + pProps[nPos++].Value <<= static_cast<sal_Int16>(nMinLabelDist); + + pProps[nPos].Name = "PositionAndSpaceMode"; + pProps[nPos++].Value <<= ePosAndSpaceMode; + pProps[nPos].Name = "LabelFollowedBy"; + pProps[nPos++].Value <<= eLabelFollowedBy; + pProps[nPos].Name = "ListtabStopPosition"; + pProps[nPos++].Value <<= nListtabStopPosition; + pProps[nPos].Name = "FirstLineIndent"; + pProps[nPos++].Value <<= nFirstLineIndent; + pProps[nPos].Name = "IndentAt"; + pProps[nPos++].Value <<= nIndentAt; + + OUString sDisplayTextStyleName = GetImport().GetStyleDisplayName( + XmlStyleFamily::TEXT_TEXT, sTextStyleName ); + pProps[nPos].Name = "CharStyleName"; + pProps[nPos++].Value <<= sDisplayTextStyleName; + + if( bBullet ) + { + awt::FontDescriptor aFDesc; + aFDesc.Name = sBulletFontName; + if( !sBulletFontName.isEmpty() ) + { + aFDesc.StyleName = sBulletFontStyleName; + aFDesc.Family = eBulletFontFamily; + aFDesc.Pitch = eBulletFontPitch; + aFDesc.CharSet = eBulletFontEncoding; + aFDesc.Weight = WEIGHT_DONTKNOW; + bool bStarSymbol = false; + if( aFDesc.Name.equalsIgnoreAsciiCase( gsStarBats ) ) + { + cBullet = GetImport().ConvStarBatsCharToStarSymbol( cBullet ); + bStarSymbol = true; + } + else if( aFDesc.Name.equalsIgnoreAsciiCase( gsStarMath ) ) + { + cBullet = GetImport().ConvStarMathCharToStarSymbol( cBullet ); + bStarSymbol = true; + } + if( bStarSymbol ) + aFDesc.Name = "StarSymbol" ; + } + + // Must append 'cBullet' even if it is zero + // if 'bBullet' is true and 'cBullet' is zero - BulletChar property must be 0. + OUString sTmp = OUStringChar( cBullet ); + pProps[nPos].Name = "BulletChar"; + pProps[nPos++].Value <<= sTmp; + + pProps[nPos].Name = "BulletFont"; + pProps[nPos++].Value <<= aFDesc; + + } + + if( bImage ) + { + uno::Reference<graphic::XGraphic> xGraphic; + if (!sImageURL.isEmpty()) + { + xGraphic = GetImport().loadGraphicByURL(sImageURL); + } + else if( xBase64Stream.is() ) + { + xGraphic = GetImport().loadGraphicFromBase64(xBase64Stream); + } + + uno::Reference<awt::XBitmap> xBitmap; + if (xGraphic.is()) + xBitmap.set(xGraphic, uno::UNO_QUERY); + + if (xBitmap.is()) + { + pProps[nPos].Name = "GraphicBitmap"; + pProps[nPos++].Value <<= xBitmap; + } + + awt::Size aSize(nImageWidth, nImageHeight); + pProps[nPos].Name = "GraphicSize"; + pProps[nPos++].Value <<= aSize; + + pProps[nPos].Name = "VertOrient"; + pProps[nPos++].Value <<= eImageVertOrient; + } + + if( bNum ) + { + pProps[nPos].Name = "StartWith"; + pProps[nPos++].Value <<= nNumStartValue; + + pProps[nPos].Name = "ParentNumbering"; + pProps[nPos++].Value <<= nNumDisplayLevels; + } + + if( ( bNum || bBullet ) && nRelSize ) + { + pProps[nPos].Name = "BulletRelSize"; + pProps[nPos++].Value <<= nRelSize; + } + + if( !bImage && bHasColor ) + { + pProps[nPos].Name = "BulletColor"; + pProps[nPos++].Value <<= m_nColor; + } + + SAL_WARN_IF( nPos != nCount, "xmloff", "array under/overflow" ); + } + + return aPropSeq; +} + +namespace { + +enum SvxXMLStyleAttributesAttrTokens +{ + XML_TOK_STYLE_ATTRIBUTES_ATTR_SPACE_BEFORE, + XML_TOK_STYLE_ATTRIBUTES_ATTR_MIN_LABEL_WIDTH, + XML_TOK_STYLE_ATTRIBUTES_ATTR_MIN_LABEL_DIST, + XML_TOK_STYLE_ATTRIBUTES_ATTR_TEXT_ALIGN, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_NAME, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_FAMILY, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_FAMILY_GENERIC, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_STYLENAME, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_PITCH, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_CHARSET, + XML_TOK_STYLE_ATTRIBUTES_ATTR_VERTICAL_POS, + XML_TOK_STYLE_ATTRIBUTES_ATTR_VERTICAL_REL, + XML_TOK_STYLE_ATTRIBUTES_ATTR_WIDTH, + XML_TOK_STYLE_ATTRIBUTES_ATTR_HEIGHT, + XML_TOK_STYLE_ATTRIBUTES_ATTR_COLOR, + XML_TOK_STYLE_ATTRIBUTES_ATTR_WINDOW_FONT_COLOR, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_SIZE, + XML_TOK_STYLE_ATTRIBUTES_ATTR_POSITION_AND_SPACE_MODE +}; + +} + +static const SvXMLTokenMapEntry* lcl_getStyleAttributesAttrTokenMap() +{ + static const SvXMLTokenMapEntry aStyleAttributesAttrTokenMap[] = + { + { XML_NAMESPACE_TEXT, XML_SPACE_BEFORE, + XML_TOK_STYLE_ATTRIBUTES_ATTR_SPACE_BEFORE }, + { XML_NAMESPACE_TEXT, XML_MIN_LABEL_WIDTH, + XML_TOK_STYLE_ATTRIBUTES_ATTR_MIN_LABEL_WIDTH }, + { XML_NAMESPACE_TEXT, XML_MIN_LABEL_DISTANCE, + XML_TOK_STYLE_ATTRIBUTES_ATTR_MIN_LABEL_DIST }, + { XML_NAMESPACE_FO, XML_TEXT_ALIGN, + XML_TOK_STYLE_ATTRIBUTES_ATTR_TEXT_ALIGN }, + { XML_NAMESPACE_STYLE, XML_FONT_NAME, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_NAME }, + { XML_NAMESPACE_FO, XML_FONT_FAMILY, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_FAMILY }, + { XML_NAMESPACE_STYLE, XML_FONT_FAMILY_GENERIC, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_FAMILY_GENERIC }, + { XML_NAMESPACE_STYLE, XML_FONT_STYLE_NAME, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_STYLENAME }, + { XML_NAMESPACE_STYLE, XML_FONT_PITCH, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_PITCH }, + { XML_NAMESPACE_STYLE, XML_FONT_CHARSET, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_CHARSET }, + { XML_NAMESPACE_STYLE, XML_VERTICAL_POS, + XML_TOK_STYLE_ATTRIBUTES_ATTR_VERTICAL_POS }, + { XML_NAMESPACE_STYLE, XML_VERTICAL_REL, + XML_TOK_STYLE_ATTRIBUTES_ATTR_VERTICAL_REL }, + { XML_NAMESPACE_FO, XML_WIDTH, + XML_TOK_STYLE_ATTRIBUTES_ATTR_WIDTH }, + { XML_NAMESPACE_FO, XML_HEIGHT, + XML_TOK_STYLE_ATTRIBUTES_ATTR_HEIGHT }, + { XML_NAMESPACE_FO, XML_COLOR, + XML_TOK_STYLE_ATTRIBUTES_ATTR_COLOR }, + { XML_NAMESPACE_STYLE, XML_USE_WINDOW_FONT_COLOR, + XML_TOK_STYLE_ATTRIBUTES_ATTR_WINDOW_FONT_COLOR }, + { XML_NAMESPACE_FO, XML_FONT_SIZE, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_SIZE }, + { XML_NAMESPACE_TEXT, XML_LIST_LEVEL_POSITION_AND_SPACE_MODE, + XML_TOK_STYLE_ATTRIBUTES_ATTR_POSITION_AND_SPACE_MODE }, + XML_TOKEN_MAP_END + }; + return aStyleAttributesAttrTokenMap; +} +SvxXMLListLevelStyleAttrContext_Impl::SvxXMLListLevelStyleAttrContext_Impl( + SvXMLImport& rImport, sal_uInt16 nPrfx, + const OUString& rLName, + const Reference< xml::sax::XAttributeList > & xAttrList, + SvxXMLListLevelStyleContext_Impl& rLLevel ) : + SvXMLImportContext( rImport, nPrfx, rLName ), + rListLevel( rLLevel ) +{ + static const SvXMLTokenMap aTokenMap( lcl_getStyleAttributesAttrTokenMap() ); + SvXMLUnitConverter& rUnitConv = GetImport().GetMM100UnitConverter(); + + OUString sFontName, sFontFamily, sFontStyleName, sFontFamilyGeneric, + sFontPitch, sFontCharset; + OUString sVerticalPos, sVerticalRel; + + sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; + for( sal_Int16 i=0; i < nAttrCount; i++ ) + { + const OUString& rAttrName = xAttrList->getNameByIndex( i ); + OUString aLocalName; + sal_uInt16 nPrefix = + GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, + &aLocalName ); + const OUString& rValue = xAttrList->getValueByIndex( i ); + + sal_Int32 nVal; + switch( aTokenMap.Get( nPrefix, aLocalName ) ) + { + case XML_TOK_STYLE_ATTRIBUTES_ATTR_SPACE_BEFORE: + if (rUnitConv.convertMeasureToCore(nVal, rValue, SHRT_MIN, SHRT_MAX)) + rListLevel.SetSpaceBefore( nVal ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_MIN_LABEL_WIDTH: + if (rUnitConv.convertMeasureToCore( nVal, rValue, 0, SHRT_MAX )) + rListLevel.SetMinLabelWidth( nVal ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_MIN_LABEL_DIST: + if (rUnitConv.convertMeasureToCore( nVal, rValue, 0, USHRT_MAX )) + rListLevel.SetMinLabelDist( nVal ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_TEXT_ALIGN: + if( !rValue.isEmpty() ) + { + sal_Int16 eAdjust = HoriOrientation::LEFT; + if( IsXMLToken( rValue, XML_CENTER ) ) + eAdjust = HoriOrientation::CENTER; + else if( IsXMLToken( rValue, XML_END ) ) + eAdjust = HoriOrientation::RIGHT; + rListLevel.SetAdjust( eAdjust ); + } + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_NAME: + sFontName = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_FAMILY: + sFontFamily = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_FAMILY_GENERIC: + sFontFamilyGeneric = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_STYLENAME: + sFontStyleName = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_PITCH: + sFontPitch = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_CHARSET: + sFontCharset = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_VERTICAL_POS: + sVerticalPos = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_VERTICAL_REL: + sVerticalRel = rValue; + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_WIDTH: + if (rUnitConv.convertMeasureToCore(nVal, rValue)) + rListLevel.SetImageWidth( nVal ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_HEIGHT: + if (rUnitConv.convertMeasureToCore(nVal, rValue)) + rListLevel.SetImageHeight( nVal ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_COLOR: + { + sal_Int32 nColor(0); + if (::sax::Converter::convertColor( nColor, rValue )) + { + rListLevel.SetColor( Color(nColor) ); + } + } + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_WINDOW_FONT_COLOR: + { + if( IsXMLToken( rValue, XML_TRUE ) ) + rListLevel.SetColor( Color(0xffffffff) ); + } + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FONT_SIZE: + if (::sax::Converter::convertPercent( nVal, rValue )) + rListLevel.SetRelSize( static_cast<sal_Int16>(nVal) ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_POSITION_AND_SPACE_MODE: + { + sal_Int16 ePosAndSpaceMode = PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION; + if( IsXMLToken( rValue, XML_LABEL_ALIGNMENT ) ) + ePosAndSpaceMode = PositionAndSpaceMode::LABEL_ALIGNMENT; + rListLevel.SetPosAndSpaceMode( ePosAndSpaceMode ); + } + break; + } + } + + if( !sFontName.isEmpty() ) + { + const XMLFontStylesContext *pFontDecls = + GetImport().GetFontDecls(); + if( pFontDecls ) + { + ::std::vector < XMLPropertyState > aProps; + if( pFontDecls->FillProperties( sFontName, aProps, 0, 1, 2, 3, 4 ) ) + { + OUString sTmp; + sal_Int16 nTmp = 0; + for( const auto& rProp : aProps ) + { + switch( rProp.mnIndex ) + { + case 0: + rProp.maValue >>= sTmp; + rListLevel.SetBulletFontName( sTmp); + break; + case 1: + rProp.maValue >>= sTmp; + rListLevel.SetBulletFontStyleName( sTmp ); + break; + case 2: + rProp.maValue >>= nTmp; + rListLevel.SetBulletFontFamily( nTmp ); + break; + case 3: + rProp.maValue >>= nTmp; + rListLevel.SetBulletFontPitch( nTmp ); + break; + case 4: + rProp.maValue >>= nTmp; + rListLevel.SetBulletFontEncoding( nTmp ); + break; + } + } + } + } + } + if( !sFontFamily.isEmpty() ) + { + Any aAny; + + XMLFontFamilyNamePropHdl aFamilyNameHdl; + if( aFamilyNameHdl.importXML( sFontFamily, aAny, rUnitConv ) ) + { + OUString sTmp; + aAny >>= sTmp; + rListLevel.SetBulletFontName( sTmp); + } + + XMLFontFamilyPropHdl aFamilyHdl; + if( !sFontFamilyGeneric.isEmpty() && + aFamilyHdl.importXML( sFontFamilyGeneric, aAny, rUnitConv ) ) + { + sal_Int16 nTmp = 0; + aAny >>= nTmp; + rListLevel.SetBulletFontFamily( nTmp ); + } + + if( !sFontStyleName.isEmpty() ) + rListLevel.SetBulletFontStyleName( sFontStyleName ); + + XMLFontPitchPropHdl aPitchHdl; + if( !sFontPitch.isEmpty() && + aPitchHdl.importXML( sFontPitch, aAny, rUnitConv ) ) + { + sal_Int16 nTmp = 0; + aAny >>= nTmp; + rListLevel.SetBulletFontPitch( nTmp ); + } + + XMLFontEncodingPropHdl aEncHdl; + if( !sFontCharset.isEmpty() && + aEncHdl.importXML( sFontCharset, aAny, rUnitConv ) ) + { + sal_Int16 nTmp = 0; + aAny >>= nTmp; + rListLevel.SetBulletFontEncoding( nTmp ); + } + } + + sal_Int16 eVertOrient = VertOrientation::LINE_CENTER; + if( !sVerticalPos.isEmpty() ) + { + if( IsXMLToken( sVerticalPos, XML_TOP ) ) + eVertOrient = VertOrientation::LINE_TOP; + else if( IsXMLToken( sVerticalPos, XML_BOTTOM ) ) + eVertOrient = VertOrientation::LINE_BOTTOM; + } + if( !sVerticalRel.isEmpty() ) + { + if( IsXMLToken( sVerticalRel, XML_BASELINE ) ) + { + // TOP and BOTTOM are exchanged for a baseline relation + switch( eVertOrient ) + { + case VertOrientation::LINE_TOP: + eVertOrient = VertOrientation::BOTTOM; + break; + case VertOrientation::LINE_CENTER: + eVertOrient = VertOrientation::CENTER; + break; + case VertOrientation::LINE_BOTTOM: + eVertOrient = VertOrientation::TOP; + break; + } + } + else if( IsXMLToken( sVerticalRel, XML_CHAR ) ) + { + switch( eVertOrient ) + { + case VertOrientation::LINE_TOP: + eVertOrient = VertOrientation::CHAR_TOP; + break; + case VertOrientation::LINE_CENTER: + eVertOrient = VertOrientation::CHAR_CENTER; + break; + case VertOrientation::LINE_BOTTOM: + eVertOrient = VertOrientation::CHAR_BOTTOM; + break; + } + } + } + rListLevel.SetImageVertOrient( eVertOrient ); +} + +SvXMLImportContextRef SvxXMLListLevelStyleAttrContext_Impl::CreateChildContext( + sal_uInt16 nPrefix, const OUString& rLocalName, + const Reference< xml::sax::XAttributeList > & xAttrList ) +{ + SvXMLImportContext *pContext = nullptr; + if ( XML_NAMESPACE_STYLE == nPrefix && + IsXMLToken( rLocalName, XML_LIST_LEVEL_LABEL_ALIGNMENT ) ) + { + pContext = new SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl( GetImport(), + nPrefix, + rLocalName, + xAttrList, + rListLevel ); + } + + return pContext; +} + +namespace { + +enum SvxXMLStyleAttributesLabelAlignmentAttrTokens +{ + XML_TOK_STYLE_ATTRIBUTES_ATTR_LABEL_FOLLOWED_BY, + XML_TOK_STYLE_ATTRIBUTES_ATTR_LISTTAB_STOP_POSITION, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FIRST_LINE_INDENT, + XML_TOK_STYLE_ATTRIBUTES_ATTR_INDENT_AT +}; + +} + +static const SvXMLTokenMapEntry* lcl_getStyleAlignmentAttributesAttrTokenMap() +{ + static const SvXMLTokenMapEntry aStyleAlignmentAttributesAttrTokenMap[] = + { + { XML_NAMESPACE_TEXT, XML_LABEL_FOLLOWED_BY, + XML_TOK_STYLE_ATTRIBUTES_ATTR_LABEL_FOLLOWED_BY }, + { XML_NAMESPACE_LO_EXT, XML_LABEL_FOLLOWED_BY, + XML_TOK_STYLE_ATTRIBUTES_ATTR_LABEL_FOLLOWED_BY }, + { XML_NAMESPACE_TEXT, XML_LIST_TAB_STOP_POSITION, + XML_TOK_STYLE_ATTRIBUTES_ATTR_LISTTAB_STOP_POSITION }, + { XML_NAMESPACE_FO, XML_TEXT_INDENT, + XML_TOK_STYLE_ATTRIBUTES_ATTR_FIRST_LINE_INDENT }, + { XML_NAMESPACE_FO, XML_MARGIN_LEFT, + XML_TOK_STYLE_ATTRIBUTES_ATTR_INDENT_AT }, + + XML_TOKEN_MAP_END + }; + return aStyleAlignmentAttributesAttrTokenMap; +} +SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl::SvxXMLListLevelStyleLabelAlignmentAttrContext_Impl( + SvXMLImport& rImport, sal_uInt16 nPrfx, + const OUString& rLName, + const Reference< xml::sax::XAttributeList > & xAttrList, + SvxXMLListLevelStyleContext_Impl& rLLevel ) : + SvXMLImportContext( rImport, nPrfx, rLName ) +{ + static const SvXMLTokenMap aTokenMap( lcl_getStyleAlignmentAttributesAttrTokenMap() ); + SvXMLUnitConverter& rUnitConv = GetImport().GetMM100UnitConverter(); + + sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; + sal_Int16 eLabelFollowedBy = LabelFollow::LISTTAB; + for( sal_Int16 i=0; i < nAttrCount; i++ ) + { + const OUString& rAttrName = xAttrList->getNameByIndex( i ); + OUString aLocalName; + sal_uInt16 nPrefix = + GetImport().GetNamespaceMap().GetKeyByAttrName( rAttrName, + &aLocalName ); + const OUString& rValue = xAttrList->getValueByIndex( i ); + + sal_Int32 nVal; + switch( aTokenMap.Get( nPrefix, aLocalName ) ) + { + case XML_TOK_STYLE_ATTRIBUTES_ATTR_LABEL_FOLLOWED_BY: + { + if( eLabelFollowedBy == LabelFollow::NEWLINE) + //NewLine from LO_EXT has precedence over other values of the Non LO_EXT namespace + break; + if( IsXMLToken( rValue, XML_SPACE ) ) + eLabelFollowedBy = LabelFollow::SPACE; + else if( IsXMLToken( rValue, XML_NOTHING ) ) + eLabelFollowedBy = LabelFollow::NOTHING; + else if( IsXMLToken( rValue, XML_NEWLINE ) ) + eLabelFollowedBy = LabelFollow::NEWLINE; + } + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_LISTTAB_STOP_POSITION: + if (rUnitConv.convertMeasureToCore(nVal, rValue, 0, SHRT_MAX)) + rLLevel.SetListtabStopPosition( nVal ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_FIRST_LINE_INDENT: + if (rUnitConv.convertMeasureToCore(nVal, rValue, SHRT_MIN, SHRT_MAX)) + rLLevel.SetFirstLineIndent( nVal ); + break; + case XML_TOK_STYLE_ATTRIBUTES_ATTR_INDENT_AT: + if (rUnitConv.convertMeasureToCore(nVal, rValue, SHRT_MIN, SHRT_MAX)) + rLLevel.SetIndentAt( nVal ); + break; + } + } + rLLevel.SetLabelFollowedBy( eLabelFollowedBy ); +} + +void SvxXMLListStyleContext::SetAttribute( sal_uInt16 nPrefixKey, + const OUString& rLocalName, + const OUString& rValue ) +{ + if( XML_NAMESPACE_TEXT == nPrefixKey && + IsXMLToken( rLocalName, XML_CONSECUTIVE_NUMBERING ) ) + { + bConsecutive = IsXMLToken( rValue, XML_TRUE ); + } + else + { + SvXMLStyleContext::SetAttribute( nPrefixKey, rLocalName, rValue ); + } +} + +static const OUStringLiteral sIsPhysical( "IsPhysical" ); +static const OUStringLiteral sNumberingRules( "NumberingRules" ); +static const OUStringLiteral sIsContinuousNumbering( "IsContinuousNumbering" ); + +SvxXMLListStyleContext::SvxXMLListStyleContext( SvXMLImport& rImport, + sal_uInt16 nPrfx, + const OUString& rLName, + const Reference< xml::sax::XAttributeList > & xAttrList, + bool bOutl ) +: SvXMLStyleContext( rImport, nPrfx, rLName, xAttrList, bOutl ? XmlStyleFamily::TEXT_OUTLINE : XmlStyleFamily::TEXT_LIST ) +, bConsecutive( false ) +, bOutline( bOutl ) +{ +} + +SvxXMLListStyleContext::SvxXMLListStyleContext( SvXMLImport& rImport, + sal_Int32 nElement, + const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList, + bool bOutl ) +: SvXMLStyleContext( rImport, nElement, xAttrList, bOutl ? XmlStyleFamily::TEXT_OUTLINE : XmlStyleFamily::TEXT_LIST ) +, bConsecutive( false ) +, bOutline( bOutl ) +{ +} + +SvxXMLListStyleContext::~SvxXMLListStyleContext() {} + +SvXMLImportContextRef SvxXMLListStyleContext::CreateChildContext( + sal_uInt16 nPrefix, + const OUString& rLocalName, + const Reference< xml::sax::XAttributeList > & xAttrList ) +{ + SvXMLImportContextRef xContext; + + if( XML_NAMESPACE_TEXT == nPrefix && + ( bOutline + ? IsXMLToken( rLocalName, XML_OUTLINE_LEVEL_STYLE ) + : ( IsXMLToken( rLocalName, XML_LIST_LEVEL_STYLE_NUMBER ) || + IsXMLToken( rLocalName, XML_LIST_LEVEL_STYLE_BULLET ) || + IsXMLToken( rLocalName, XML_LIST_LEVEL_STYLE_IMAGE ) ) ) ) + { + rtl::Reference<SvxXMLListLevelStyleContext_Impl> xLevelStyle{ + new SvxXMLListLevelStyleContext_Impl( GetImport(), nPrefix, + rLocalName, xAttrList )}; + if( !pLevelStyles ) + pLevelStyles = std::make_unique<SvxXMLListStyle_Impl>(); + pLevelStyles->push_back( xLevelStyle ); + + xContext = xLevelStyle.get(); + } + + return xContext; +} + +void SvxXMLListStyleContext::FillUnoNumRule( + const Reference<container::XIndexReplace> & rNumRule) const +{ + try + { + if( pLevelStyles && rNumRule.is() ) + { + sal_Int32 l_nLevels = rNumRule->getCount(); + for (const auto& pLevelStyle : *pLevelStyles) + { + sal_Int32 nLevel = pLevelStyle->GetLevel(); + if( nLevel >= 0 && nLevel < l_nLevels ) + { + Sequence<beans::PropertyValue> aProps = + pLevelStyle->GetProperties(); + rNumRule->replaceByIndex( nLevel, Any(aProps) ); + } + } + } + + Reference < XPropertySet > xPropSet( rNumRule, UNO_QUERY ); + Reference< XPropertySetInfo > xPropSetInfo; + if (xPropSet.is()) + xPropSetInfo = xPropSet->getPropertySetInfo(); + if( xPropSetInfo.is() && + xPropSetInfo->hasPropertyByName( sIsContinuousNumbering ) ) + { + xPropSet->setPropertyValue( sIsContinuousNumbering, Any(bConsecutive) ); + } + } + catch (const Exception&) + { + OSL_FAIL( "SvxXMLListStyleContext::FillUnoNumRule - Exception caught" ); + } +} + +void SvxXMLListStyleContext::CreateAndInsertLate( bool bOverwrite ) +{ + if( bOutline ) + { + if( bOverwrite ) + { + const Reference< XIndexReplace >& rNumRule = + GetImport().GetTextImport()->GetChapterNumbering(); + // We don't set xNumberingRules here, to avoid using them + // as numbering rules. + if( rNumRule.is() ) + FillUnoNumRule(rNumRule); + } + } + else + { + Reference < XStyle > xStyle; + const OUString& rName = GetDisplayName(); + if( rName.isEmpty() ) + { + SetValid( false ); + return; + } + + const Reference < XNameContainer >& rNumStyles = + GetImport().GetTextImport()->GetNumberingStyles(); + if( !rNumStyles.is() ) + { + SetValid( false ); + return; + } + + bool bNew = false; + if( rNumStyles->hasByName( rName ) ) + { + Any aAny = rNumStyles->getByName( rName ); + aAny >>= xStyle; + } + else + { + Reference< XMultiServiceFactory > xFactory( GetImport().GetModel(), + UNO_QUERY ); + SAL_WARN_IF( !xFactory.is(), "xmloff", "no factory" ); + if( !xFactory.is() ) + return; + + Reference < XInterface > xIfc = xFactory->createInstance("com.sun.star.style.NumberingStyle"); + if( !xIfc.is() ) + return; + Reference < XStyle > xTmp( xIfc, UNO_QUERY ); + xStyle = xTmp; + if( !xStyle.is() ) + return; + + rNumStyles->insertByName( rName, Any(xStyle) ); + bNew = true; + } + + Reference < XPropertySet > xPropSet( xStyle, UNO_QUERY ); + Reference< XPropertySetInfo > xPropSetInfo = + xPropSet->getPropertySetInfo(); + if( !bNew && xPropSetInfo->hasPropertyByName( sIsPhysical ) ) + { + Any aAny = xPropSet->getPropertyValue( sIsPhysical ); + bNew = !*o3tl::doAccess<bool>(aAny); + } + + if ( xPropSetInfo->hasPropertyByName( "Hidden" ) ) + xPropSet->setPropertyValue( "Hidden", uno::makeAny( IsHidden( ) ) ); + + if( rName != GetName() ) + GetImport().AddStyleDisplayName( XmlStyleFamily::TEXT_LIST, + GetName(), rName ); + + Any aAny = xPropSet->getPropertyValue( sNumberingRules ); + aAny >>= xNumRules; + if( bOverwrite || bNew ) + { + FillUnoNumRule(xNumRules); + xPropSet->setPropertyValue( sNumberingRules, Any(xNumRules) ); + } + else + { + SetValid( false ); + } + + SetNew( bNew ); + } +} + +void SvxXMLListStyleContext::CreateAndInsertAuto() const +{ + SAL_WARN_IF( bOutline, "xmloff", "Outlines cannot be inserted here" ); + SAL_WARN_IF( xNumRules.is(), "xmloff", "Numbering Rule is existing already" ); + + const OUString& rName = GetName(); + if( bOutline || xNumRules.is() || rName.isEmpty() ) + { + const_cast<SvxXMLListStyleContext *>(this)->SetValid( false ); + return; + } + + const_cast<SvxXMLListStyleContext *>(this)->xNumRules = CreateNumRule( + GetImport().GetModel() ); + + FillUnoNumRule(xNumRules); +} + +Reference < XIndexReplace > SvxXMLListStyleContext::CreateNumRule( + const Reference < XModel > & rModel ) +{ + Reference<XIndexReplace> xNumRule; + + Reference< XMultiServiceFactory > xFactory( rModel, UNO_QUERY ); + SAL_WARN_IF( !xFactory.is(), "xmloff", "no factory" ); + if( !xFactory.is() ) + return xNumRule; + + Reference < XInterface > xIfc = xFactory->createInstance("com.sun.star.text.NumberingRules"); + if( !xIfc.is() ) + return xNumRule; + + xNumRule.set( xIfc, UNO_QUERY ); + SAL_WARN_IF( !xNumRule.is(), "xmloff", "go no numbering rule" ); + + return xNumRule; +} + +void SvxXMLListStyleContext::SetDefaultStyle( + const Reference < XIndexReplace > & rNumRule, + sal_Int16 nLevel, + bool bOrdered ) +{ + Sequence<beans::PropertyValue> aPropSeq( bOrdered ? 1 : 4 ); + beans::PropertyValue *pProps = aPropSeq.getArray(); + + pProps->Name = "NumberingType"; + (pProps++)->Value <<= static_cast<sal_Int16>(bOrdered ? NumberingType::ARABIC + : NumberingType::CHAR_SPECIAL ); + if( !bOrdered ) + { + // TODO: Bullet-Font + awt::FontDescriptor aFDesc; + aFDesc.Name = +#ifdef _WIN32 + "StarBats" +#else + "starbats" +#endif + ; + aFDesc.Family = FAMILY_DONTKNOW ; + aFDesc.Pitch = PITCH_DONTKNOW ; + aFDesc.CharSet = RTL_TEXTENCODING_SYMBOL ; + aFDesc.Weight = WEIGHT_DONTKNOW; + pProps->Name = "BulletFont"; + (pProps++)->Value <<= aFDesc; + + OUString sTmp = OUStringChar(sal_Unicode(0xF000 + 149)); + pProps->Name = "BulletChar"; + (pProps++)->Value <<= sTmp; + pProps->Name = "CharStyleName"; + (pProps++)->Value <<= OUString( "Numbering Symbols" ); + } + + rNumRule->replaceByIndex( nLevel, Any(aPropSeq) ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |