/* -*- 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/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 <o3tl/any.hxx>
#include <sal/log.hxx>
#include <tools/color.hxx>
#include <xmloff/txtprmap.hxx>
#include <xmloff/xmlexp.hxx>
#include <xmloff/maptype.hxx>
#include "XMLSectionFootnoteConfigExport.hxx"
#include <xmlsdtypes.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_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 )
{
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&, const OUString&);
void
lcl_checkMultiProperty(XMLPropertyState *const pState,
XMLPropertyState *const pRelState)
{
if (pState && pRelState)
{
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 )
{
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( ::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin();
aIter != rProperties.end();
++aIter )
{
XMLPropertyState *propertyState = &(*aIter);
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;
SAL_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 && pCharBackground )
{
assert(pCharBackgroundTransparency); // always together
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;
}
else
{
pCharBackground->mnIndex = -1;
pCharBackgroundTransparency->mnIndex = -1;
}
}
SvXMLExportPropertyMapper::ContextFilter(bEnableFoFontFamily, rProperties, rPropSet);
}
namespace {
bool lcl_IsOutlineStyle(const SvXMLExport &rExport, const OUString & 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: */
↑ V1019 Compound assignment expression 'pFontCharsetState->maValue >>= nTmp' is used inside condition.
↑ V1019 Compound assignment expression 'pHeightMinRelState->maValue >>= nRel' is used inside condition.
↑ V1019 Compound assignment expression 'pWidthMinRelState->maValue >>= nRel' is used inside condition.
↑ V1019 Compound assignment expression 'pFontPitchState->maValue >>= nTmp' is used inside condition.
↑ V1019 Compound assignment expression 'pFontFamilyState->maValue >>= nTmp' is used inside condition.
↑ V1019 Compound assignment expression 'pFontFamilyNameState->maValue >>= sTmp' is used inside condition.
↑ V1019 Compound assignment expression 'pFontStyleNameState->maValue >>= sTmp' is used inside condition.