summaryrefslogtreecommitdiffstats
path: root/xmloff/source/text/txtexppr.cxx
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--xmloff/source/text/txtexppr.cxx1199
1 files changed, 1199 insertions, 0 deletions
diff --git a/xmloff/source/text/txtexppr.cxx b/xmloff/source/text/txtexppr.cxx
new file mode 100644
index 000000000..65cdf59b7
--- /dev/null
+++ b/xmloff/source/text/txtexppr.cxx
@@ -0,0 +1,1199 @@
+/* -*- 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/table/BorderLine2.hpp>
+
+#include "txtexppr.hxx"
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/text/SizeType.hpp>
+#include <com/sun/star/text/WrapTextMode.hpp>
+#include <com/sun/star/text/TextContentAnchorType.hpp>
+#include <com/sun/star/awt/FontUnderline.hpp>
+#include <com/sun/star/text/XChapterNumberingSupplier.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <o3tl/any.hxx>
+#include <sal/log.hxx>
+#include <tools/color.hxx>
+#include <xmloff/txtprmap.hxx>
+#include <xmloff/xmlexp.hxx>
+#include <xmloff/maptype.hxx>
+#include <xmloff/namespacemap.hxx>
+#include "XMLSectionFootnoteConfigExport.hxx"
+#include <xmlsdtypes.hxx>
+#include <XMLNumberWithAutoForVoidPropHdl.hxx>
+
+using namespace ::com::sun::star;
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::style;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::text;
+
+void XMLTextExportPropertySetMapper::handleElementItem(
+ SvXMLExport& rExp,
+ const XMLPropertyState& rProperty,
+ SvXmlExportFlags nFlags,
+ const ::std::vector< XMLPropertyState > *pProperties,
+ sal_uInt32 nIdx ) const
+{
+ XMLTextExportPropertySetMapper *pThis =
+ const_cast<XMLTextExportPropertySetMapper*>(this);
+
+ switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ) )
+ {
+ case CTF_DROPCAPFORMAT:
+ pThis->maDropCapExport.exportXML( rProperty.maValue, bDropWholeWord,
+ sDropCharStyle );
+ pThis->bDropWholeWord = false;
+ pThis->sDropCharStyle.clear();
+ break;
+
+ case CTF_TABSTOP:
+ pThis->maTabStopExport.Export( rProperty.maValue );
+ break;
+
+ case CTF_TEXTCOLUMNS:
+ pThis->maTextColumnsExport.exportXML( rProperty.maValue );
+ break;
+
+ case CTF_BACKGROUND_URL:
+ {
+ const Any *pPos = nullptr, *pFilter = nullptr, *pTrans = nullptr;
+ sal_uInt32 nPropIndex = rProperty.mnIndex;
+
+ // these are all optional, so have to check them in order
+ // note: this index order dependency is a steaming pile of manure
+ if (nIdx)
+ {
+ const XMLPropertyState& rFilter = (*pProperties)[nIdx - 1];
+ if (CTF_BACKGROUND_FILTER == getPropertySetMapper()
+ ->GetEntryContextId(rFilter.mnIndex))
+ {
+ pFilter = &rFilter.maValue;
+ --nIdx;
+ }
+ }
+
+ if (nIdx)
+ {
+ const XMLPropertyState& rPos = (*pProperties)[nIdx - 1];
+ if (CTF_BACKGROUND_POS == getPropertySetMapper()
+ ->GetEntryContextId(rPos.mnIndex))
+ {
+ pPos = &rPos.maValue;
+ --nIdx;
+ }
+ }
+
+ if (nIdx)
+ {
+ const XMLPropertyState& rTrans = (*pProperties)[nIdx - 1];
+ // #99657# transparency may be there, but doesn't have to be.
+ // If it's there, it must be in the right position.
+ if( CTF_BACKGROUND_TRANSPARENCY == getPropertySetMapper()
+ ->GetEntryContextId( rTrans.mnIndex ) )
+ pTrans = &rTrans.maValue;
+ }
+
+ pThis->maBackgroundImageExport.exportXML(
+ rProperty.maValue, pPos, pFilter, pTrans,
+ getPropertySetMapper()->GetEntryNameSpace( nPropIndex ),
+ getPropertySetMapper()->GetEntryXMLName( nPropIndex ) );
+ }
+ break;
+
+ case CTF_SECTION_FOOTNOTE_END:
+ XMLSectionFootnoteConfigExport::exportXML(rExp, false,
+ pProperties, nIdx,
+ getPropertySetMapper());
+ break;
+
+ case CTF_SECTION_ENDNOTE_END:
+ XMLSectionFootnoteConfigExport::exportXML(rExp, true,
+ pProperties, nIdx,
+ getPropertySetMapper());
+ break;
+
+ default:
+ SvXMLExportPropertyMapper::handleElementItem( rExp, rProperty, nFlags, pProperties, nIdx );
+ break;
+ }
+}
+
+void XMLTextExportPropertySetMapper::handleSpecialItem(
+ SvXMLAttributeList& rAttrList,
+ const XMLPropertyState& rProperty,
+ const SvXMLUnitConverter& rUnitConverter,
+ const SvXMLNamespaceMap& rNamespaceMap,
+ const ::std::vector< XMLPropertyState > *pProperties,
+ sal_uInt32 nIdx ) const
+{
+ XMLTextExportPropertySetMapper *pThis =
+ const_cast<XMLTextExportPropertySetMapper*>(this);
+
+ switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ) )
+ {
+ case CTF_PAGENUMBEROFFSET:
+ {
+ OUString value;
+ XMLNumberWithAutoForVoidPropHdl const handler;
+ handler.exportXML(value, rProperty.maValue, rUnitConverter);
+ if (GetExport().getSaneDefaultVersion() < SvtSaveOptions::ODFSVER_013
+ && value == "0") // tdf#91306 ODF 1.3 OFFICE-3923
+ {
+ value = "auto";
+ }
+ OUString const name = rNamespaceMap.GetQNameByKey(
+ getPropertySetMapper()->GetEntryNameSpace(rProperty.mnIndex),
+ getPropertySetMapper()->GetEntryXMLName(rProperty.mnIndex));
+ rAttrList.AddAttribute(name, value);
+ }
+ break;
+ case CTF_DROPCAPWHOLEWORD:
+ SAL_WARN_IF( !!bDropWholeWord, "xmloff", "drop whole word is set already!" );
+ pThis->bDropWholeWord = *o3tl::doAccess<bool>(rProperty.maValue);
+ break;
+ case CTF_DROPCAPCHARSTYLE:
+ SAL_WARN_IF( !sDropCharStyle.isEmpty(), "xmloff", "drop char style is set already!" );
+ rProperty.maValue >>= pThis->sDropCharStyle;
+ break;
+ case CTF_NUMBERINGSTYLENAME:
+ case CTF_PAGEDESCNAME:
+ case CTF_OLDTEXTBACKGROUND:
+ case CTF_BACKGROUND_POS:
+ case CTF_BACKGROUND_FILTER:
+ case CTF_BACKGROUND_TRANSPARENCY:
+ case CTF_SECTION_FOOTNOTE_NUM_OWN:
+ case CTF_SECTION_FOOTNOTE_NUM_RESTART:
+ case CTF_SECTION_FOOTNOTE_NUM_RESTART_AT:
+ case CTF_SECTION_FOOTNOTE_NUM_TYPE:
+ case CTF_SECTION_FOOTNOTE_NUM_PREFIX:
+ case CTF_SECTION_FOOTNOTE_NUM_SUFFIX:
+ case CTF_SECTION_ENDNOTE_NUM_OWN:
+ case CTF_SECTION_ENDNOTE_NUM_RESTART:
+ case CTF_SECTION_ENDNOTE_NUM_RESTART_AT:
+ case CTF_SECTION_ENDNOTE_NUM_TYPE:
+ case CTF_SECTION_ENDNOTE_NUM_PREFIX:
+ case CTF_SECTION_ENDNOTE_NUM_SUFFIX:
+ case CTF_DEFAULT_OUTLINE_LEVEL:
+ case CTF_OLD_FLOW_WITH_TEXT:
+ // There's nothing to do here!
+ break;
+ default:
+ SvXMLExportPropertyMapper::handleSpecialItem(rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx );
+ break;
+ }
+}
+
+XMLTextExportPropertySetMapper::XMLTextExportPropertySetMapper(
+ const rtl::Reference< XMLPropertySetMapper >& rMapper,
+ SvXMLExport& rExp ) :
+ SvXMLExportPropertyMapper( rMapper ),
+ rExport( rExp ),
+ bDropWholeWord( false ),
+ maDropCapExport( rExp ),
+ maTabStopExport( rExp ),
+ maTextColumnsExport( rExp ),
+ maBackgroundImageExport( rExp )
+{
+}
+
+XMLTextExportPropertySetMapper::~XMLTextExportPropertySetMapper()
+{
+}
+
+void XMLTextExportPropertySetMapper::ContextFontFilter(
+ bool bEnableFoFontFamily,
+ XMLPropertyState *pFontNameState,
+ XMLPropertyState *pFontFamilyNameState,
+ XMLPropertyState *pFontStyleNameState,
+ XMLPropertyState *pFontFamilyState,
+ XMLPropertyState *pFontPitchState,
+ XMLPropertyState *pFontCharsetState ) const
+{
+ OUString sFamilyName;
+ OUString sStyleName;
+ FontFamily nFamily = FAMILY_DONTKNOW;
+ FontPitch nPitch = PITCH_DONTKNOW;
+ rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW;
+
+ OUString sTmp;
+ if( pFontFamilyNameState && (pFontFamilyNameState->maValue >>= sTmp ) )
+ sFamilyName = sTmp;
+ if( pFontStyleNameState && (pFontStyleNameState->maValue >>= sTmp ) )
+ sStyleName = sTmp;
+
+ sal_Int16 nTmp = sal_Int16();
+ if( pFontFamilyState && (pFontFamilyState->maValue >>= nTmp ) )
+ nFamily = static_cast< FontFamily >( nTmp );
+ if( pFontPitchState && (pFontPitchState->maValue >>= nTmp ) )
+ nPitch = static_cast< FontPitch >( nTmp );
+ if( pFontCharsetState && (pFontCharsetState->maValue >>= nTmp ) )
+ eEnc = static_cast<rtl_TextEncoding>(nTmp);
+
+ //Resolves: fdo#67665 The purpose here appears to be to replace
+ //FontFamilyName and FontStyleName etc with a single FontName property. The
+ //problem is that repeated calls to here will first set
+ //pFontFamilyNameState->mnIndex to -1 to indicate it is disabled, so the
+ //next time pFontFamilyNameState is not passed here at all, which gives an
+ //empty sFamilyName resulting in disabling pFontNameState->mnIndex to -1.
+ //That doesn't seem right to me.
+
+ //So assuming that the main purpose is just to convert the properties in
+ //the main when we can, and to leave them alone when we can't. And with a
+ //secondary purpose to filter out empty font properties, then is would
+ //appear to make sense to base attempting the conversion if we have
+ //both of the major facts of the font description
+
+ //An alternative solution is to *not* fill the FontAutoStylePool with
+ //every font in the document, but to partition the fonts into the
+ //hard-attribute fonts which go into that pool and the style-attribute
+ //fonts which go into some additional pool which get merged just for
+ //the purposes of writing the embedded fonts but are not queried by
+ //"Find" which restores the original logic.
+ if (pFontFamilyNameState || pFontStyleNameState)
+ {
+ OUString sName( const_cast<SvXMLExport&>(GetExport()).GetFontAutoStylePool()->Find(
+ sFamilyName, sStyleName, nFamily, nPitch, eEnc ) );
+ if (!sName.isEmpty())
+ {
+ pFontNameState->maValue <<= sName;
+ //Resolves: fdo#68431 style:font-name unrecognized by LibreOffice
+ //<= 4.1 in styles (but recognized in autostyles) so add
+ //fo:font-family, etc
+ if (!bEnableFoFontFamily)
+ {
+ if( pFontFamilyNameState )
+ pFontFamilyNameState->mnIndex = -1;
+ if( pFontStyleNameState )
+ pFontStyleNameState->mnIndex = -1;
+ if( pFontFamilyState )
+ pFontFamilyState->mnIndex = -1;
+ if( pFontPitchState )
+ pFontPitchState->mnIndex = -1;
+ if( pFontCharsetState )
+ pFontCharsetState->mnIndex = -1;
+ }
+ }
+ else
+ {
+ pFontNameState->mnIndex = -1;
+ }
+ }
+
+ if( pFontFamilyNameState && sFamilyName.isEmpty() )
+ {
+ pFontFamilyNameState->mnIndex = -1;
+ }
+
+ if( pFontStyleNameState && sStyleName.isEmpty() )
+ {
+ pFontStyleNameState->mnIndex = -1;
+ }
+}
+
+void XMLTextExportPropertySetMapper::ContextFontHeightFilter(
+ XMLPropertyState* pCharHeightState,
+ XMLPropertyState* pCharPropHeightState,
+ XMLPropertyState* pCharDiffHeightState )
+{
+ if( pCharPropHeightState )
+ {
+ sal_Int32 nTemp = 0;
+ pCharPropHeightState->maValue >>= nTemp;
+ if( nTemp == 100 )
+ {
+ pCharPropHeightState->mnIndex = -1;
+ pCharPropHeightState->maValue.clear();
+ }
+ else
+ {
+ pCharHeightState->mnIndex = -1;
+ pCharHeightState->maValue.clear();
+ }
+ }
+ if( !pCharDiffHeightState )
+ return;
+
+ float nTemp = 0;
+ pCharDiffHeightState->maValue >>= nTemp;
+ if( nTemp == 0. )
+ {
+ pCharDiffHeightState->mnIndex = -1;
+ pCharDiffHeightState->maValue.clear();
+ }
+ else
+ {
+ pCharHeightState->mnIndex = -1;
+ pCharHeightState->maValue.clear();
+ }
+
+}
+
+namespace {
+
+// helper method; implementation below
+bool lcl_IsOutlineStyle(const SvXMLExport&, std::u16string_view);
+
+void
+lcl_checkMultiProperty(XMLPropertyState *const pState,
+ XMLPropertyState *const pRelState)
+{
+ if (!(pState && pRelState))
+ return;
+
+ sal_Int32 nTemp = 0;
+ pRelState->maValue >>= nTemp;
+ if (100 == nTemp)
+ {
+ pRelState->mnIndex = -1;
+ pRelState->maValue.clear();
+ }
+ else
+ {
+ pState->mnIndex = -1;
+ pState->maValue.clear();
+ }
+}
+
+/**
+ * Filter context of paragraph and character borders.
+ * Compress border attributes. If one of groupable attributes (border type, border width, padding)
+ * is equal for all four side then just one general attribute will be exported.
+**/
+void lcl_FilterBorders(
+ XMLPropertyState* pAllBorderWidthState, XMLPropertyState* pLeftBorderWidthState,
+ XMLPropertyState* pRightBorderWidthState, XMLPropertyState* pTopBorderWidthState,
+ XMLPropertyState* pBottomBorderWidthState, XMLPropertyState* pAllBorderDistanceState,
+ XMLPropertyState* pLeftBorderDistanceState, XMLPropertyState* pRightBorderDistanceState,
+ XMLPropertyState* pTopBorderDistanceState, XMLPropertyState* pBottomBorderDistanceState,
+ XMLPropertyState* pAllBorderState, XMLPropertyState* pLeftBorderState,
+ XMLPropertyState* pRightBorderState,XMLPropertyState* pTopBorderState,
+ XMLPropertyState* pBottomBorderState )
+{
+ if( pAllBorderWidthState )
+ {
+ if( pLeftBorderWidthState && pRightBorderWidthState && pTopBorderWidthState && pBottomBorderWidthState )
+ {
+ table::BorderLine2 aLeft, aRight, aTop, aBottom;
+
+ pLeftBorderWidthState->maValue >>= aLeft;
+ pRightBorderWidthState->maValue >>= aRight;
+ pTopBorderWidthState->maValue >>= aTop;
+ pBottomBorderWidthState->maValue >>= aBottom;
+ if( aLeft.Color == aRight.Color && aLeft.InnerLineWidth == aRight.InnerLineWidth &&
+ aLeft.OuterLineWidth == aRight.OuterLineWidth && aLeft.LineDistance == aRight.LineDistance &&
+ aLeft.LineStyle == aRight.LineStyle &&
+ aLeft.LineWidth == aRight.LineWidth &&
+ aLeft.Color == aTop.Color && aLeft.InnerLineWidth == aTop.InnerLineWidth &&
+ aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance &&
+ aLeft.LineStyle == aTop.LineStyle &&
+ aLeft.LineWidth == aTop.LineWidth &&
+ aLeft.Color == aBottom.Color && aLeft.InnerLineWidth == aBottom.InnerLineWidth &&
+ aLeft.OuterLineWidth == aBottom.OuterLineWidth && aLeft.LineDistance == aBottom.LineDistance &&
+ aLeft.LineStyle == aBottom.LineStyle &&
+ aLeft.LineWidth == aBottom.LineWidth )
+ {
+ pLeftBorderWidthState->mnIndex = -1;
+ pLeftBorderWidthState->maValue.clear();
+ pRightBorderWidthState->mnIndex = -1;
+ pRightBorderWidthState->maValue.clear();
+ pTopBorderWidthState->mnIndex = -1;
+ pTopBorderWidthState->maValue.clear();
+ pBottomBorderWidthState->mnIndex = -1;
+ pBottomBorderWidthState->maValue.clear();
+ }
+ else
+ {
+ pAllBorderWidthState->mnIndex = -1;
+ pAllBorderWidthState->maValue.clear();
+ }
+ }
+ else
+ {
+ pAllBorderWidthState->mnIndex = -1;
+ pAllBorderWidthState->maValue.clear();
+ }
+ }
+
+ if( pAllBorderDistanceState )
+ {
+ if( pLeftBorderDistanceState && pRightBorderDistanceState && pTopBorderDistanceState && pBottomBorderDistanceState )
+ {
+ sal_Int32 aLeft = 0, aRight = 0, aTop = 0, aBottom = 0;
+
+ pLeftBorderDistanceState->maValue >>= aLeft;
+ pRightBorderDistanceState->maValue >>= aRight;
+ pTopBorderDistanceState->maValue >>= aTop;
+ pBottomBorderDistanceState->maValue >>= aBottom;
+ if( aLeft == aRight && aLeft == aTop && aLeft == aBottom )
+ {
+ pLeftBorderDistanceState->mnIndex = -1;
+ pLeftBorderDistanceState->maValue.clear();
+ pRightBorderDistanceState->mnIndex = -1;
+ pRightBorderDistanceState->maValue.clear();
+ pTopBorderDistanceState->mnIndex = -1;
+ pTopBorderDistanceState->maValue.clear();
+ pBottomBorderDistanceState->mnIndex = -1;
+ pBottomBorderDistanceState->maValue.clear();
+ }
+ else
+ {
+ pAllBorderDistanceState->mnIndex = -1;
+ pAllBorderDistanceState->maValue.clear();
+ }
+ }
+ else
+ {
+ pAllBorderDistanceState->mnIndex = -1;
+ pAllBorderDistanceState->maValue.clear();
+ }
+ }
+
+ if( !pAllBorderState )
+ return;
+
+ if( pLeftBorderState && pRightBorderState && pTopBorderState && pBottomBorderState )
+ {
+ table::BorderLine2 aLeft, aRight, aTop, aBottom;
+
+ pLeftBorderState->maValue >>= aLeft;
+ pRightBorderState->maValue >>= aRight;
+ pTopBorderState->maValue >>= aTop;
+ pBottomBorderState->maValue >>= aBottom;
+ if( aLeft.Color == aRight.Color && aLeft.InnerLineWidth == aRight.InnerLineWidth &&
+ aLeft.OuterLineWidth == aRight.OuterLineWidth && aLeft.LineDistance == aRight.LineDistance &&
+ aLeft.LineStyle == aRight.LineStyle &&
+ aLeft.LineWidth == aRight.LineWidth &&
+ aLeft.Color == aTop.Color && aLeft.InnerLineWidth == aTop.InnerLineWidth &&
+ aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance &&
+ aLeft.LineStyle == aTop.LineStyle &&
+ aLeft.LineWidth == aTop.LineWidth &&
+ aLeft.Color == aBottom.Color && aLeft.InnerLineWidth == aBottom.InnerLineWidth &&
+ aLeft.OuterLineWidth == aBottom.OuterLineWidth && aLeft.LineDistance == aBottom.LineDistance &&
+ aLeft.LineWidth == aBottom.LineWidth &&
+ aLeft.LineStyle == aBottom.LineStyle )
+ {
+ pLeftBorderState->mnIndex = -1;
+ pLeftBorderState->maValue.clear();
+ pRightBorderState->mnIndex = -1;
+ pRightBorderState->maValue.clear();
+ pTopBorderState->mnIndex = -1;
+ pTopBorderState->maValue.clear();
+ pBottomBorderState->mnIndex = -1;
+ pBottomBorderState->maValue.clear();
+ }
+ else
+ {
+ pAllBorderState->mnIndex = -1;
+ pAllBorderState->maValue.clear();
+ }
+ }
+ else
+ {
+ pAllBorderState->mnIndex = -1;
+ pAllBorderState->maValue.clear();
+ }
+}
+
+}
+
+void XMLTextExportPropertySetMapper::ContextFilter(
+ bool bEnableFoFontFamily,
+ ::std::vector< XMLPropertyState >& rProperties,
+ const Reference< XPropertySet >& rPropSet ) const
+{
+ // filter font
+ XMLPropertyState *pFontNameState = nullptr;
+ XMLPropertyState *pFontFamilyNameState = nullptr;
+ XMLPropertyState *pFontStyleNameState = nullptr;
+ XMLPropertyState *pFontFamilyState = nullptr;
+ XMLPropertyState *pFontPitchState = nullptr;
+ XMLPropertyState *pFontCharsetState = nullptr;
+ XMLPropertyState *pFontNameCJKState = nullptr;
+ XMLPropertyState *pFontFamilyNameCJKState = nullptr;
+ XMLPropertyState *pFontStyleNameCJKState = nullptr;
+ XMLPropertyState *pFontFamilyCJKState = nullptr;
+ XMLPropertyState *pFontPitchCJKState = nullptr;
+ XMLPropertyState *pFontCharsetCJKState = nullptr;
+ XMLPropertyState *pFontNameCTLState = nullptr;
+ XMLPropertyState *pFontFamilyNameCTLState = nullptr;
+ XMLPropertyState *pFontStyleNameCTLState = nullptr;
+ XMLPropertyState *pFontFamilyCTLState = nullptr;
+ XMLPropertyState *pFontPitchCTLState = nullptr;
+ XMLPropertyState *pFontCharsetCTLState = nullptr;
+
+ // filter char height point/percent
+ XMLPropertyState* pCharHeightState = nullptr;
+ XMLPropertyState* pCharPropHeightState = nullptr;
+ XMLPropertyState* pCharDiffHeightState = nullptr;
+ XMLPropertyState* pCharHeightCJKState = nullptr;
+ XMLPropertyState* pCharPropHeightCJKState = nullptr;
+ XMLPropertyState* pCharDiffHeightCJKState = nullptr;
+ XMLPropertyState* pCharHeightCTLState = nullptr;
+ XMLPropertyState* pCharPropHeightCTLState = nullptr;
+ XMLPropertyState* pCharDiffHeightCTLState = nullptr;
+
+ // filter left margin measure/percent
+ XMLPropertyState* pParaLeftMarginState = nullptr;
+ XMLPropertyState* pParaLeftMarginRelState = nullptr;
+
+ // filter right margin measure/percent
+ XMLPropertyState* pParaRightMarginState = nullptr;
+ XMLPropertyState* pParaRightMarginRelState = nullptr;
+
+ // filter first line indent measure/percent
+ XMLPropertyState* pParaFirstLineState = nullptr;
+ XMLPropertyState* pParaFirstLineRelState = nullptr;
+
+ // filter ParaTopMargin/Relative
+ XMLPropertyState* pParaTopMarginState = nullptr;
+ XMLPropertyState* pParaTopMarginRelState = nullptr;
+
+ // filter ParaTopMargin/Relative
+ XMLPropertyState* pParaBottomMarginState = nullptr;
+ XMLPropertyState* pParaBottomMarginRelState = nullptr;
+
+ // filter (Left|Right|Top|Bottom|)BorderWidth
+ XMLPropertyState* pAllBorderWidthState = nullptr;
+ XMLPropertyState* pLeftBorderWidthState = nullptr;
+ XMLPropertyState* pRightBorderWidthState = nullptr;
+ XMLPropertyState* pTopBorderWidthState = nullptr;
+ XMLPropertyState* pBottomBorderWidthState = nullptr;
+
+ // filter (Left|Right|Top|)BorderDistance
+ XMLPropertyState* pAllBorderDistanceState = nullptr;
+ XMLPropertyState* pLeftBorderDistanceState = nullptr;
+ XMLPropertyState* pRightBorderDistanceState = nullptr;
+ XMLPropertyState* pTopBorderDistanceState = nullptr;
+ XMLPropertyState* pBottomBorderDistanceState = nullptr;
+
+ // filter (Left|Right|Top|Bottom|)Border
+ XMLPropertyState* pAllBorderState = nullptr;
+ XMLPropertyState* pLeftBorderState = nullptr;
+ XMLPropertyState* pRightBorderState = nullptr;
+ XMLPropertyState* pTopBorderState = nullptr;
+ XMLPropertyState* pBottomBorderState = nullptr;
+
+ // filter Char(Left|Right|Top|Bottom|)BorderWidth
+ XMLPropertyState* pCharAllBorderWidthState = nullptr;
+ XMLPropertyState* pCharLeftBorderWidthState = nullptr;
+ XMLPropertyState* pCharRightBorderWidthState = nullptr;
+ XMLPropertyState* pCharTopBorderWidthState = nullptr;
+ XMLPropertyState* pCharBottomBorderWidthState = nullptr;
+
+ // filter Char(Left|Right|Top|)BorderDistance
+ XMLPropertyState* pCharAllBorderDistanceState = nullptr;
+ XMLPropertyState* pCharLeftBorderDistanceState = nullptr;
+ XMLPropertyState* pCharRightBorderDistanceState = nullptr;
+ XMLPropertyState* pCharTopBorderDistanceState = nullptr;
+ XMLPropertyState* pCharBottomBorderDistanceState = nullptr;
+
+ // filter Char(Left|Right|Top|Bottom|)Border
+ XMLPropertyState* pCharAllBorderState = nullptr;
+ XMLPropertyState* pCharLeftBorderState = nullptr;
+ XMLPropertyState* pCharRightBorderState = nullptr;
+ XMLPropertyState* pCharTopBorderState = nullptr;
+ XMLPropertyState* pCharBottomBorderState = nullptr;
+
+ // filter height properties
+ XMLPropertyState* pHeightMinAbsState = nullptr;
+ XMLPropertyState* pHeightMinRelState = nullptr;
+ XMLPropertyState* pHeightAbsState = nullptr;
+ XMLPropertyState* pHeightRelState = nullptr;
+ XMLPropertyState* pSizeTypeState = nullptr;
+
+ // filter width properties
+ XMLPropertyState* pWidthMinAbsState = nullptr;
+ XMLPropertyState* pWidthMinRelState = nullptr;
+ XMLPropertyState* pWidthAbsState = nullptr;
+ XMLPropertyState* pWidthRelState = nullptr;
+ XMLPropertyState* pWidthTypeState = nullptr;
+
+ // wrap
+ XMLPropertyState* pWrapState = nullptr;
+ XMLPropertyState* pWrapContourState = nullptr;
+ XMLPropertyState* pWrapContourModeState = nullptr;
+ XMLPropertyState* pWrapParagraphOnlyState = nullptr;
+
+ // anchor
+ XMLPropertyState* pAnchorTypeState = nullptr;
+
+ // horizontal position and relation
+ XMLPropertyState* pHoriOrientState = nullptr;
+ XMLPropertyState* pHoriOrientMirroredState = nullptr;
+ XMLPropertyState* pHoriOrientRelState = nullptr;
+ XMLPropertyState* pHoriOrientRelFrameState = nullptr;
+ XMLPropertyState* pHoriOrientMirrorState = nullptr;
+ // Horizontal position and relation for shapes (#i28749#)
+ XMLPropertyState* pShapeHoriOrientState = nullptr;
+ XMLPropertyState* pShapeHoriOrientMirroredState = nullptr;
+ XMLPropertyState* pShapeHoriOrientRelState = nullptr;
+ XMLPropertyState* pShapeHoriOrientRelFrameState = nullptr;
+ XMLPropertyState* pShapeHoriOrientMirrorState = nullptr;
+
+ // vertical position and relation
+ XMLPropertyState* pVertOrientState = nullptr;
+ XMLPropertyState* pVertOrientAtCharState = nullptr;
+ XMLPropertyState* pVertOrientRelState = nullptr;
+ XMLPropertyState* pVertOrientRelPageState = nullptr;
+ XMLPropertyState* pVertOrientRelFrameState = nullptr;
+ XMLPropertyState* pVertOrientRelAsCharState = nullptr;
+ XMLPropertyState* pRelWidthRel = nullptr;
+ XMLPropertyState* pRelHeightRel = nullptr;
+
+ // Vertical position and relation for shapes (#i28749#)
+ XMLPropertyState* pShapeVertOrientState = nullptr;
+ XMLPropertyState* pShapeVertOrientAtCharState = nullptr;
+ XMLPropertyState* pShapeVertOrientRelState = nullptr;
+ XMLPropertyState* pShapeVertOrientRelPageState = nullptr;
+ XMLPropertyState* pShapeVertOrientRelFrameState = nullptr;
+
+ // filter underline color
+ XMLPropertyState* pUnderlineState = nullptr;
+ XMLPropertyState* pUnderlineColorState = nullptr;
+ XMLPropertyState* pUnderlineHasColorState = nullptr;
+
+ // filter list style name
+ XMLPropertyState* pListStyleName = nullptr;
+
+ // filter fo:clip
+ XMLPropertyState* pClip11State = nullptr;
+ XMLPropertyState* pClipState = nullptr;
+
+ // filter fo:margin
+ XMLPropertyState* pAllParaMarginRel = nullptr;
+ XMLPropertyState* pAllParaMargin = nullptr;
+ XMLPropertyState* pAllMargin = nullptr;
+
+ XMLPropertyState* pRepeatOffsetX = nullptr;
+ XMLPropertyState* pRepeatOffsetY = nullptr;
+
+ // character background and highlight
+ XMLPropertyState* pCharBackground = nullptr;
+ XMLPropertyState* pCharBackgroundTransparency = nullptr;
+ XMLPropertyState* pCharHighlight = nullptr;
+
+ bool bNeedsAnchor = false;
+
+ for( auto& rPropertyState : rProperties )
+ {
+ XMLPropertyState *propertyState = &rPropertyState;
+ if( propertyState->mnIndex == -1 )
+ continue;
+
+ switch( getPropertySetMapper()->GetEntryContextId( propertyState->mnIndex ) )
+ {
+ case CTF_CHARHEIGHT: pCharHeightState = propertyState; break;
+ case CTF_CHARHEIGHT_REL: pCharPropHeightState = propertyState; break;
+ case CTF_CHARHEIGHT_DIFF: pCharDiffHeightState = propertyState; break;
+ case CTF_CHARHEIGHT_CJK: pCharHeightCJKState = propertyState; break;
+ case CTF_CHARHEIGHT_REL_CJK: pCharPropHeightCJKState = propertyState; break;
+ case CTF_CHARHEIGHT_DIFF_CJK: pCharDiffHeightCJKState = propertyState; break;
+ case CTF_CHARHEIGHT_CTL: pCharHeightCTLState = propertyState; break;
+ case CTF_CHARHEIGHT_REL_CTL: pCharPropHeightCTLState = propertyState; break;
+ case CTF_CHARHEIGHT_DIFF_CTL: pCharDiffHeightCTLState = propertyState; break;
+ case CTF_PARALEFTMARGIN: pParaLeftMarginState = propertyState; break;
+ case CTF_PARALEFTMARGIN_REL: pParaLeftMarginRelState = propertyState; break;
+ case CTF_PARARIGHTMARGIN: pParaRightMarginState = propertyState; break;
+ case CTF_PARARIGHTMARGIN_REL: pParaRightMarginRelState = propertyState; break;
+ case CTF_PARAFIRSTLINE: pParaFirstLineState = propertyState; break;
+ case CTF_PARAFIRSTLINE_REL: pParaFirstLineRelState = propertyState; break;
+ case CTF_PARATOPMARGIN: pParaTopMarginState = propertyState; break;
+ case CTF_PARATOPMARGIN_REL: pParaTopMarginRelState = propertyState; break;
+ case CTF_PARABOTTOMMARGIN: pParaBottomMarginState = propertyState; break;
+ case CTF_PARABOTTOMMARGIN_REL: pParaBottomMarginRelState = propertyState; break;
+
+ case CTF_ALLBORDERWIDTH: pAllBorderWidthState = propertyState; break;
+ case CTF_LEFTBORDERWIDTH: pLeftBorderWidthState = propertyState; break;
+ case CTF_RIGHTBORDERWIDTH: pRightBorderWidthState = propertyState; break;
+ case CTF_TOPBORDERWIDTH: pTopBorderWidthState = propertyState; break;
+ case CTF_BOTTOMBORDERWIDTH: pBottomBorderWidthState = propertyState; break;
+ case CTF_ALLBORDERDISTANCE: pAllBorderDistanceState = propertyState; break;
+ case CTF_LEFTBORDERDISTANCE: pLeftBorderDistanceState = propertyState; break;
+ case CTF_RIGHTBORDERDISTANCE: pRightBorderDistanceState = propertyState; break;
+ case CTF_TOPBORDERDISTANCE: pTopBorderDistanceState = propertyState; break;
+ case CTF_BOTTOMBORDERDISTANCE: pBottomBorderDistanceState = propertyState; break;
+ case CTF_ALLBORDER: pAllBorderState = propertyState; break;
+ case CTF_LEFTBORDER: pLeftBorderState = propertyState; break;
+ case CTF_RIGHTBORDER: pRightBorderState = propertyState; break;
+ case CTF_TOPBORDER: pTopBorderState = propertyState; break;
+ case CTF_BOTTOMBORDER: pBottomBorderState = propertyState; break;
+
+ case CTF_CHARALLBORDERWIDTH: pCharAllBorderWidthState = propertyState; break;
+ case CTF_CHARLEFTBORDERWIDTH: pCharLeftBorderWidthState = propertyState; break;
+ case CTF_CHARRIGHTBORDERWIDTH: pCharRightBorderWidthState = propertyState; break;
+ case CTF_CHARTOPBORDERWIDTH: pCharTopBorderWidthState = propertyState; break;
+ case CTF_CHARBOTTOMBORDERWIDTH: pCharBottomBorderWidthState = propertyState; break;
+ case CTF_CHARALLBORDERDISTANCE: pCharAllBorderDistanceState = propertyState; break;
+ case CTF_CHARLEFTBORDERDISTANCE: pCharLeftBorderDistanceState = propertyState; break;
+ case CTF_CHARRIGHTBORDERDISTANCE: pCharRightBorderDistanceState = propertyState; break;
+ case CTF_CHARTOPBORDERDISTANCE: pCharTopBorderDistanceState = propertyState; break;
+ case CTF_CHARBOTTOMBORDERDISTANCE: pCharBottomBorderDistanceState = propertyState; break;
+ case CTF_CHARALLBORDER: pCharAllBorderState = propertyState; break;
+ case CTF_CHARLEFTBORDER: pCharLeftBorderState = propertyState; break;
+ case CTF_CHARRIGHTBORDER: pCharRightBorderState = propertyState; break;
+ case CTF_CHARTOPBORDER: pCharTopBorderState = propertyState; break;
+ case CTF_CHARBOTTOMBORDER: pCharBottomBorderState = propertyState; break;
+
+ case CTF_FRAMEHEIGHT_MIN_ABS: pHeightMinAbsState = propertyState; break;
+ case CTF_FRAMEHEIGHT_MIN_REL: pHeightMinRelState = propertyState; break;
+ case CTF_FRAMEHEIGHT_ABS: pHeightAbsState = propertyState; break;
+ case CTF_FRAMEHEIGHT_REL: pHeightRelState = propertyState; break;
+ case CTF_SIZETYPE: pSizeTypeState = propertyState; break;
+
+ case CTF_FRAMEWIDTH_MIN_ABS: pWidthMinAbsState = propertyState; break;
+ case CTF_FRAMEWIDTH_MIN_REL: pWidthMinRelState = propertyState; break;
+ case CTF_FRAMEWIDTH_ABS: pWidthAbsState = propertyState; break;
+ case CTF_FRAMEWIDTH_REL: pWidthRelState = propertyState; break;
+ case CTF_FRAMEWIDTH_TYPE: pWidthTypeState = propertyState; break;
+
+ case CTF_WRAP: pWrapState = propertyState; break;
+ case CTF_WRAP_CONTOUR: pWrapContourState = propertyState; break;
+ case CTF_WRAP_CONTOUR_MODE: pWrapContourModeState = propertyState; break;
+ case CTF_WRAP_PARAGRAPH_ONLY: pWrapParagraphOnlyState = propertyState; break;
+ case CTF_ANCHORTYPE: pAnchorTypeState = propertyState; break;
+
+ case CTF_HORIZONTALPOS: pHoriOrientState = propertyState; bNeedsAnchor = true; break;
+ case CTF_HORIZONTALPOS_MIRRORED: pHoriOrientMirroredState = propertyState; bNeedsAnchor = true; break;
+ case CTF_HORIZONTALREL: pHoriOrientRelState = propertyState; bNeedsAnchor = true; break;
+ case CTF_HORIZONTALREL_FRAME: pHoriOrientRelFrameState = propertyState; bNeedsAnchor = true; break;
+ case CTF_HORIZONTALMIRROR: pHoriOrientMirrorState = propertyState; bNeedsAnchor = true; break;
+ case CTF_RELWIDTHREL: pRelWidthRel = propertyState; break;
+ case CTF_VERTICALPOS: pVertOrientState = propertyState; bNeedsAnchor = true; break;
+ case CTF_VERTICALPOS_ATCHAR: pVertOrientAtCharState = propertyState; bNeedsAnchor = true; break;
+ case CTF_VERTICALREL: pVertOrientRelState = propertyState; bNeedsAnchor = true; break;
+ case CTF_VERTICALREL_PAGE: pVertOrientRelPageState = propertyState; bNeedsAnchor = true; break;
+ case CTF_VERTICALREL_FRAME: pVertOrientRelFrameState = propertyState; bNeedsAnchor = true; break;
+ case CTF_VERTICALREL_ASCHAR: pVertOrientRelAsCharState = propertyState; bNeedsAnchor = true; break;
+ case CTF_RELHEIGHTREL: pRelHeightRel = propertyState; break;
+
+ // Handle new CTFs for shape positioning properties (#i28749#)
+ case CTF_SHAPE_HORIZONTALPOS: pShapeHoriOrientState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_HORIZONTALPOS_MIRRORED: pShapeHoriOrientMirroredState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_HORIZONTALREL: pShapeHoriOrientRelState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_HORIZONTALREL_FRAME: pShapeHoriOrientRelFrameState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_HORIZONTALMIRROR: pShapeHoriOrientMirrorState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_VERTICALPOS: pShapeVertOrientState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_VERTICALPOS_ATCHAR: pShapeVertOrientAtCharState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_VERTICALREL: pShapeVertOrientRelState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_VERTICALREL_PAGE: pShapeVertOrientRelPageState = propertyState; bNeedsAnchor = true; break;
+ case CTF_SHAPE_VERTICALREL_FRAME: pShapeVertOrientRelFrameState = propertyState; bNeedsAnchor = true; break;
+ case CTF_FONTNAME: pFontNameState = propertyState; break;
+ case CTF_FONTFAMILYNAME: pFontFamilyNameState = propertyState; break;
+ case CTF_FONTSTYLENAME: pFontStyleNameState = propertyState; break;
+ case CTF_FONTFAMILY: pFontFamilyState = propertyState; break;
+ case CTF_FONTPITCH: pFontPitchState = propertyState; break;
+ case CTF_FONTCHARSET: pFontCharsetState = propertyState; break;
+
+ case CTF_FONTNAME_CJK: pFontNameCJKState = propertyState; break;
+ case CTF_FONTFAMILYNAME_CJK: pFontFamilyNameCJKState = propertyState; break;
+ case CTF_FONTSTYLENAME_CJK: pFontStyleNameCJKState = propertyState; break;
+ case CTF_FONTFAMILY_CJK: pFontFamilyCJKState = propertyState; break;
+ case CTF_FONTPITCH_CJK: pFontPitchCJKState = propertyState; break;
+ case CTF_FONTCHARSET_CJK: pFontCharsetCJKState = propertyState; break;
+
+ case CTF_FONTNAME_CTL: pFontNameCTLState = propertyState; break;
+ case CTF_FONTFAMILYNAME_CTL: pFontFamilyNameCTLState = propertyState; break;
+ case CTF_FONTSTYLENAME_CTL: pFontStyleNameCTLState = propertyState; break;
+ case CTF_FONTFAMILY_CTL: pFontFamilyCTLState = propertyState; break;
+ case CTF_FONTPITCH_CTL: pFontPitchCTLState = propertyState; break;
+ case CTF_FONTCHARSET_CTL: pFontCharsetCTLState = propertyState; break;
+ case CTF_UNDERLINE: pUnderlineState = propertyState; break;
+ case CTF_UNDERLINE_COLOR: pUnderlineColorState = propertyState; break;
+ case CTF_UNDERLINE_HASCOLOR: pUnderlineHasColorState = propertyState; break;
+ case CTF_NUMBERINGSTYLENAME: pListStyleName = propertyState; break;
+ case CTF_TEXT_CLIP11: pClip11State = propertyState; break;
+ case CTF_TEXT_CLIP: pClipState = propertyState; break;
+ case CTF_PARAMARGINALL_REL: pAllParaMarginRel = propertyState; break;
+ case CTF_PARAMARGINALL: pAllParaMargin = propertyState; break;
+ case CTF_MARGINALL: pAllMargin = propertyState; break;
+
+ case CTF_REPEAT_OFFSET_X:
+ pRepeatOffsetX = propertyState;
+ break;
+
+ case CTF_REPEAT_OFFSET_Y:
+ pRepeatOffsetY = propertyState;
+ break;
+
+ case CTF_FILLGRADIENTNAME:
+ case CTF_FILLHATCHNAME:
+ case CTF_FILLBITMAPNAME:
+ case CTF_FILLTRANSNAME:
+ {
+ OUString aStr;
+ if( (propertyState->maValue >>= aStr) && 0 == aStr.getLength() )
+ propertyState->mnIndex = -1;
+ }
+ break;
+
+ case CTF_CHAR_BACKGROUND: pCharBackground = propertyState; break;
+ case CTF_CHAR_BACKGROUND_TRANSPARENCY: pCharBackgroundTransparency = propertyState; break;
+ case CTF_CHAR_HIGHLIGHT: pCharHighlight = propertyState; break;
+ }
+ }
+
+ if( pRepeatOffsetX && pRepeatOffsetY )
+ {
+ sal_Int32 nOffset = 0;
+ if( ( pRepeatOffsetX->maValue >>= nOffset ) && ( nOffset == 0 ) )
+ pRepeatOffsetX->mnIndex = -1;
+ else
+ pRepeatOffsetY->mnIndex = -1;
+ }
+
+ if( pFontNameState )
+ ContextFontFilter( bEnableFoFontFamily, pFontNameState, pFontFamilyNameState,
+ pFontStyleNameState, pFontFamilyState,
+ pFontPitchState, pFontCharsetState );
+ if( pFontNameCJKState )
+ ContextFontFilter( bEnableFoFontFamily, pFontNameCJKState, pFontFamilyNameCJKState,
+ pFontStyleNameCJKState, pFontFamilyCJKState,
+ pFontPitchCJKState, pFontCharsetCJKState );
+ if( pFontNameCTLState )
+ ContextFontFilter( bEnableFoFontFamily, pFontNameCTLState, pFontFamilyNameCTLState,
+ pFontStyleNameCTLState, pFontFamilyCTLState,
+ pFontPitchCTLState, pFontCharsetCTLState );
+
+ if( pCharHeightState && (pCharPropHeightState || pCharDiffHeightState ) )
+ ContextFontHeightFilter( pCharHeightState, pCharPropHeightState,
+ pCharDiffHeightState );
+ if( pCharHeightCJKState &&
+ (pCharPropHeightCJKState || pCharDiffHeightCJKState ) )
+ ContextFontHeightFilter( pCharHeightCJKState, pCharPropHeightCJKState,
+ pCharDiffHeightCJKState );
+ if( pCharHeightCTLState &&
+ (pCharPropHeightCTLState || pCharDiffHeightCTLState ) )
+ ContextFontHeightFilter( pCharHeightCTLState, pCharPropHeightCTLState,
+ pCharDiffHeightCTLState );
+ if( pUnderlineColorState || pUnderlineHasColorState )
+ {
+ bool bClear = !pUnderlineState;
+ if( !bClear )
+ {
+ sal_Int16 nUnderline = 0;
+ pUnderlineState->maValue >>= nUnderline;
+ bClear = awt::FontUnderline::NONE == nUnderline;
+ }
+ if( bClear )
+ {
+ if( pUnderlineColorState )
+ pUnderlineColorState->mnIndex = -1;
+ if( pUnderlineHasColorState )
+ pUnderlineHasColorState->mnIndex = -1;
+ }
+ }
+
+ lcl_checkMultiProperty(pParaLeftMarginState, pParaLeftMarginRelState);
+ lcl_checkMultiProperty(pParaRightMarginState, pParaRightMarginRelState);
+ lcl_checkMultiProperty(pParaTopMarginState, pParaTopMarginRelState);
+ lcl_checkMultiProperty(pParaBottomMarginState, pParaBottomMarginRelState);
+ lcl_checkMultiProperty(pParaFirstLineState, pParaFirstLineRelState);
+
+ if (pAllParaMarginRel)
+ { // because older OOo/LO versions can't read fo:margin:
+ pAllParaMarginRel->mnIndex = -1; // just export individual attributes...
+ pAllParaMarginRel->maValue.clear();
+ }
+ if (pAllParaMargin)
+ {
+ pAllParaMargin->mnIndex = -1; // just export individual attributes...
+ pAllParaMargin->maValue.clear();
+ }
+ if (pAllMargin)
+ {
+ pAllMargin->mnIndex = -1; // just export individual attributes...
+ pAllMargin->maValue.clear();
+ }
+
+ lcl_FilterBorders(
+ pAllBorderWidthState, pLeftBorderWidthState, pRightBorderWidthState,
+ pTopBorderWidthState, pBottomBorderWidthState, pAllBorderDistanceState,
+ pLeftBorderDistanceState, pRightBorderDistanceState, pTopBorderDistanceState,
+ pBottomBorderDistanceState, pAllBorderState, pLeftBorderState,
+ pRightBorderState, pTopBorderState, pBottomBorderState);
+
+ lcl_FilterBorders(
+ pCharAllBorderWidthState, pCharLeftBorderWidthState, pCharRightBorderWidthState,
+ pCharTopBorderWidthState, pCharBottomBorderWidthState, pCharAllBorderDistanceState,
+ pCharLeftBorderDistanceState, pCharRightBorderDistanceState, pCharTopBorderDistanceState,
+ pCharBottomBorderDistanceState, pCharAllBorderState, pCharLeftBorderState,
+ pCharRightBorderState, pCharTopBorderState, pCharBottomBorderState);
+
+ sal_Int16 nSizeType = SizeType::FIX;
+ if( pSizeTypeState )
+ {
+ pSizeTypeState->maValue >>= nSizeType;
+ pSizeTypeState->mnIndex = -1;
+ }
+
+ if( pHeightMinAbsState )
+ {
+ sal_Int16 nRel = sal_Int16();
+ if( (SizeType::FIX == nSizeType) ||
+ ( pHeightMinRelState &&
+ ( !(pHeightMinRelState->maValue >>= nRel) || nRel > 0 ) ) )
+ {
+ pHeightMinAbsState->mnIndex = -1;
+ }
+
+ // export SizeType::VARIABLE as min-width="0"
+ if( SizeType::VARIABLE == nSizeType )
+ pHeightMinAbsState->maValue <<= static_cast<sal_Int32>( 0 );
+ }
+ if( pHeightMinRelState && SizeType::MIN != nSizeType)
+ pHeightMinRelState->mnIndex = -1;
+ if( pHeightAbsState && pHeightMinAbsState &&
+ -1 != pHeightMinAbsState->mnIndex )
+ pHeightAbsState->mnIndex = -1;
+ if( pHeightRelState && SizeType::FIX != nSizeType)
+ pHeightRelState->mnIndex = -1;
+
+ // frame width
+ nSizeType = SizeType::FIX;
+ if( pWidthTypeState )
+ {
+ pWidthTypeState->maValue >>= nSizeType;
+ pWidthTypeState->mnIndex = -1;
+ }
+ if( pWidthMinAbsState )
+ {
+ sal_Int16 nRel = sal_Int16();
+ if( (SizeType::FIX == nSizeType) ||
+ ( pWidthMinRelState &&
+ ( !(pWidthMinRelState->maValue >>= nRel) || nRel > 0 ) ) )
+ {
+ pWidthMinAbsState->mnIndex = -1;
+ }
+
+ // export SizeType::VARIABLE as min-width="0"
+ if( SizeType::VARIABLE == nSizeType )
+ pWidthMinAbsState->maValue <<= static_cast<sal_Int32>( 0 );
+ }
+ if( pWidthMinRelState && SizeType::MIN != nSizeType)
+ pWidthMinRelState->mnIndex = -1;
+ if( pWidthAbsState && pWidthMinAbsState &&
+ -1 != pWidthMinAbsState->mnIndex )
+ pWidthAbsState->mnIndex = -1;
+ if( pWidthRelState && SizeType::FIX != nSizeType)
+ pWidthRelState->mnIndex = -1;
+
+ if( pWrapState )
+ {
+ WrapTextMode eVal;
+ pWrapState->maValue >>= eVal;
+ switch( eVal )
+ {
+ case WrapTextMode_NONE:
+ // no wrapping: disable para-only and contour
+ if( pWrapParagraphOnlyState )
+ pWrapParagraphOnlyState->mnIndex = -1;
+ [[fallthrough]];
+ case WrapTextMode_THROUGH:
+ // wrap through: disable only contour
+ if( pWrapContourState )
+ pWrapContourState->mnIndex = -1;
+ break;
+ default:
+ break;
+ }
+ if( pWrapContourModeState &&
+ (!pWrapContourState ||
+ !*o3tl::doAccess<bool>(pWrapContourState ->maValue) ) )
+ pWrapContourModeState->mnIndex = -1;
+ }
+
+ TextContentAnchorType eAnchor = TextContentAnchorType_AT_PARAGRAPH;
+ if( pAnchorTypeState )
+ pAnchorTypeState->maValue >>= eAnchor;
+ else if( bNeedsAnchor )
+ {
+ Any aAny = rPropSet->getPropertyValue("AnchorType");
+ aAny >>= eAnchor;
+ }
+
+ // states for frame positioning attributes
+ {
+ if( pHoriOrientState && pHoriOrientMirroredState )
+ {
+ if( pHoriOrientMirrorState &&
+ *o3tl::doAccess<bool>(pHoriOrientMirrorState->maValue) )
+ pHoriOrientState->mnIndex = -1;
+ else
+ pHoriOrientMirroredState->mnIndex = -1;
+ }
+ if( pHoriOrientMirrorState )
+ pHoriOrientMirrorState->mnIndex = -1;
+
+ if( pHoriOrientRelState && TextContentAnchorType_AT_FRAME == eAnchor )
+ pHoriOrientRelState->mnIndex = -1;
+ if( pHoriOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor )
+ pHoriOrientRelFrameState->mnIndex = -1;
+ if (pRelWidthRel)
+ {
+ sal_Int16 nRelWidth = 0;
+ rPropSet->getPropertyValue("RelativeWidth") >>= nRelWidth;
+ if (!nRelWidth)
+ pRelWidthRel->mnIndex = -1;
+ }
+
+ if( pVertOrientState && TextContentAnchorType_AT_CHARACTER == eAnchor )
+ pVertOrientState->mnIndex = -1;
+ if( pVertOrientAtCharState && TextContentAnchorType_AT_CHARACTER != eAnchor )
+ pVertOrientAtCharState->mnIndex = -1;
+ if( pVertOrientRelState && TextContentAnchorType_AT_PARAGRAPH != eAnchor &&
+ TextContentAnchorType_AT_CHARACTER != eAnchor )
+ pVertOrientRelState->mnIndex = -1;
+ if( pVertOrientRelPageState && TextContentAnchorType_AT_PAGE != eAnchor )
+ pVertOrientRelPageState->mnIndex = -1;
+ if( pVertOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor )
+ pVertOrientRelFrameState->mnIndex = -1;
+ if( pVertOrientRelAsCharState && TextContentAnchorType_AS_CHARACTER != eAnchor )
+ pVertOrientRelAsCharState->mnIndex = -1;
+ if (pRelHeightRel)
+ {
+ sal_Int16 nRelHeight = 0;
+ rPropSet->getPropertyValue("RelativeHeight") >>= nRelHeight;
+ if (!nRelHeight)
+ pRelHeightRel->mnIndex = -1;
+ }
+ }
+
+ // States for shape positioning properties (#i28749#)
+ if ( eAnchor != TextContentAnchorType_AS_CHARACTER &&
+ !( GetExport().getExportFlags() & SvXMLExportFlags::OASIS ) )
+ {
+ // no export of shape positioning properties,
+ // if shape isn't anchored as-character and
+ // destination file format is OpenOffice.org file format
+ if ( pShapeHoriOrientState )
+ pShapeHoriOrientState->mnIndex = -1;
+ if ( pShapeHoriOrientMirroredState )
+ pShapeHoriOrientMirroredState->mnIndex = -1;
+ if ( pShapeHoriOrientRelState )
+ pShapeHoriOrientRelState->mnIndex = -1;
+ if ( pShapeHoriOrientRelFrameState )
+ pShapeHoriOrientRelFrameState->mnIndex = -1;
+ if ( pShapeHoriOrientMirrorState )
+ pShapeHoriOrientMirrorState->mnIndex = -1;
+ if ( pShapeVertOrientState )
+ pShapeVertOrientState->mnIndex = -1;
+ if ( pShapeVertOrientAtCharState )
+ pShapeVertOrientAtCharState->mnIndex = -1;
+ if ( pShapeVertOrientRelState )
+ pShapeVertOrientRelState->mnIndex = -1;
+ if ( pShapeVertOrientRelPageState )
+ pShapeVertOrientRelPageState->mnIndex = -1;
+ if ( pShapeVertOrientRelFrameState )
+ pShapeVertOrientRelFrameState->mnIndex = -1;
+ }
+ else
+ {
+ // handling of shape positioning property states as for frames - see above
+ if( pShapeHoriOrientState && pShapeHoriOrientMirroredState )
+ {
+ if( pShapeHoriOrientMirrorState &&
+ *o3tl::doAccess<bool>(pShapeHoriOrientMirrorState->maValue) )
+ pShapeHoriOrientState->mnIndex = -1;
+ else
+ pShapeHoriOrientMirroredState->mnIndex = -1;
+ }
+ if( pShapeHoriOrientMirrorState )
+ pShapeHoriOrientMirrorState->mnIndex = -1;
+
+ if( pShapeHoriOrientRelState && TextContentAnchorType_AT_FRAME == eAnchor )
+ pShapeHoriOrientRelState->mnIndex = -1;
+ if( pShapeHoriOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor )
+ pShapeHoriOrientRelFrameState->mnIndex = -1;
+
+ if( pShapeVertOrientState && TextContentAnchorType_AT_CHARACTER == eAnchor )
+ pShapeVertOrientState->mnIndex = -1;
+ if( pShapeVertOrientAtCharState && TextContentAnchorType_AT_CHARACTER != eAnchor )
+ pShapeVertOrientAtCharState->mnIndex = -1;
+ if( pShapeVertOrientRelState && TextContentAnchorType_AT_PARAGRAPH != eAnchor &&
+ TextContentAnchorType_AT_CHARACTER != eAnchor )
+ pShapeVertOrientRelState->mnIndex = -1;
+ if( pShapeVertOrientRelPageState && TextContentAnchorType_AT_PAGE != eAnchor )
+ pShapeVertOrientRelPageState->mnIndex = -1;
+ if( pShapeVertOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor )
+ pShapeVertOrientRelFrameState->mnIndex = -1;
+ }
+
+ // list style name: remove list style if it is the default outline style
+ if( pListStyleName != nullptr )
+ {
+ OUString sListStyleName;
+ pListStyleName->maValue >>= sListStyleName;
+ if( lcl_IsOutlineStyle( GetExport(), sListStyleName ) )
+ pListStyleName->mnIndex = -1;
+ }
+
+ if( pClipState != nullptr && pClip11State != nullptr )
+ pClip11State->mnIndex = -1;
+
+ // When both background attributes are available export the visible one
+ if (pCharHighlight)
+ {
+ Color nColor = COL_TRANSPARENT;
+ pCharHighlight->maValue >>= nColor;
+ if( nColor == COL_TRANSPARENT )
+ {
+ // actually this would not be exported as transparent anyway
+ // and we'd need another property CharHighlightTransparent for that
+ pCharHighlight->mnIndex = -1;
+ }
+ // When both background attributes are available export the visible one
+ else if(pCharBackground)
+ {
+ assert(pCharBackgroundTransparency); // always together
+ pCharBackground->mnIndex = -1;
+ pCharBackgroundTransparency->mnIndex = -1;
+ }
+ }
+
+ SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
+}
+
+namespace {
+
+bool lcl_IsOutlineStyle(const SvXMLExport &rExport, std::u16string_view rName)
+{
+ Reference< XChapterNumberingSupplier >
+ xCNSupplier(rExport.GetModel(), UNO_QUERY);
+
+ OUString sOutlineName;
+
+ if (xCNSupplier.is())
+ {
+ Reference<XPropertySet> xNumRule(
+ xCNSupplier->getChapterNumberingRules(), UNO_QUERY );
+ SAL_WARN_IF( !xNumRule.is(), "xmloff", "no chapter numbering rules" );
+ if (xNumRule.is())
+ {
+ xNumRule->getPropertyValue("Name") >>= sOutlineName;
+ }
+ }
+
+ return rName == sOutlineName;
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */