/**************************************************************
*
* 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
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_xmloff.hxx"
#include <tools/debug.hxx>
#include <com/sun/star/awt/FontFamily.hpp>
#include <com/sun/star/awt/FontPitch.hpp>
#include <com/sun/star/table/BorderLine.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <com/sun/star/text/SizeType.hpp>
#include <tools/string.hxx>
#include <xmloff/XMLFontStylesContext.hxx>
#include <xmloff/txtprmap.hxx>
#include <xmloff/xmlimp.hxx>
#include "xmloff/txtimppr.hxx"
#define XML_LINE_LEFT 0
#define XML_LINE_RIGHT 1
#define XML_LINE_TOP 2
#define XML_LINE_BOTTOM 3
#define MIN_BORDER_DIST 49
using ::rtl::OUString;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::table;
using namespace ::com::sun::star::text;
sal_Bool XMLTextImportPropertyMapper::handleSpecialItem(
XMLPropertyState& rProperty,
::std::vector< XMLPropertyState >& rProperties,
const ::rtl::OUString& rValue,
const SvXMLUnitConverter& rUnitConverter,
const SvXMLNamespaceMap& rNamespaceMap ) const
{
sal_Bool bRet = sal_False;
sal_Int32 nIndex = rProperty.mnIndex;
switch( getPropertySetMapper()->GetEntryContextId( nIndex ) )
{
case CTF_FONTNAME:
case CTF_FONTNAME_CJK:
case CTF_FONTNAME_CTL:
if( xFontDecls.Is() )
{
DBG_ASSERT(
( CTF_FONTFAMILYNAME ==
getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
CTF_FONTSTYLENAME ==
getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
CTF_FONTFAMILY ==
getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
CTF_FONTPITCH ==
getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
CTF_FONTCHARSET ==
getPropertySetMapper()->GetEntryContextId(nIndex+5) ) ||
( CTF_FONTFAMILYNAME_CJK ==
getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
CTF_FONTSTYLENAME_CJK ==
getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
CTF_FONTFAMILY_CJK ==
getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
CTF_FONTPITCH_CJK ==
getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
CTF_FONTCHARSET_CJK ==
getPropertySetMapper()->GetEntryContextId(nIndex+5) ) ||
( CTF_FONTFAMILYNAME_CTL ==
getPropertySetMapper()->GetEntryContextId(nIndex+1) &&
CTF_FONTSTYLENAME_CTL ==
getPropertySetMapper()->GetEntryContextId(nIndex+2) &&
CTF_FONTFAMILY_CTL ==
getPropertySetMapper()->GetEntryContextId(nIndex+3) &&
CTF_FONTPITCH_CTL ==
getPropertySetMapper()->GetEntryContextId(nIndex+4) &&
CTF_FONTCHARSET_CTL ==
getPropertySetMapper()->GetEntryContextId(nIndex+5) ),
"illegal property map" );
((XMLFontStylesContext *)&xFontDecls)->FillProperties(
rValue, rProperties,
rProperty.mnIndex+1, rProperty.mnIndex+2,
rProperty.mnIndex+3, rProperty.mnIndex+4,
rProperty.mnIndex+5 );
bRet = sal_False; // the property hasn't been filled
}
break;
// If we want to do StarMath/StarSymbol font conversion, then we'll
// want these special items to be treated just like regular ones...
// For the Writer, we'll catch and convert them in _FillPropertySet;
// the other apps probably don't care. For the other apps, we just
// imitate the default non-special-item mechanism.
case CTF_FONTFAMILYNAME:
case CTF_FONTFAMILYNAME_CJK:
case CTF_FONTFAMILYNAME_CTL:
bRet = getPropertySetMapper()->importXML( rValue, rProperty,
rUnitConverter );
break;
case CTF_TEXT_DISPLAY:
bRet = getPropertySetMapper()->importXML( rValue, rProperty,
rUnitConverter );
if( SvXMLImport::OOo_2x == GetImport().getGeneratorVersion() )
{
sal_Bool bHidden;
rProperty.maValue >>= bHidden;
bHidden = !bHidden;
rProperty.maValue <<= bHidden;
}
break;
default:
bRet = SvXMLImportPropertyMapper::handleSpecialItem( rProperty,
rProperties, rValue, rUnitConverter, rNamespaceMap );
break;
}
return bRet;
}
XMLTextImportPropertyMapper::XMLTextImportPropertyMapper(
const UniReference< XMLPropertySetMapper >& rMapper,
SvXMLImport& rImp,
XMLFontStylesContext *pFontDecls ) :
SvXMLImportPropertyMapper( rMapper, rImp ),
nSizeTypeIndex( -2 ),
nWidthTypeIndex( -2 ),
xFontDecls( pFontDecls )
{
}
XMLTextImportPropertyMapper::~XMLTextImportPropertyMapper()
{
}
void XMLTextImportPropertyMapper::SetFontDecls(
XMLFontStylesContext *pFontDecls )
{
xFontDecls = pFontDecls;
}
void XMLTextImportPropertyMapper::FontFinished(
XMLPropertyState *pFontFamilyNameState,
XMLPropertyState *pFontStyleNameState,
XMLPropertyState *pFontFamilyState,
XMLPropertyState *pFontPitchState,
XMLPropertyState *pFontCharsetState ) const
{
if( pFontFamilyNameState && pFontFamilyNameState->mnIndex != -1 )
{
OUString sName;
pFontFamilyNameState->maValue >>= sName;
if( !sName.getLength() )
pFontFamilyNameState->mnIndex = -1;
}
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;
}
}
/** since the properties "CharFontFamilyName", "CharFontStyleName", "CharFontFamily",
"CharFontPitch" and "CharFontSet" and theire CJK and CTL counterparts are only
usable as a union, we add defaults to all values that are not set as long as we
have an "CharFontFamilyName"
#99928# CL */
void XMLTextImportPropertyMapper::FontDefaultsCheck(
XMLPropertyState* pFontFamilyName,
XMLPropertyState* pFontStyleName,
XMLPropertyState* pFontFamily,
XMLPropertyState* pFontPitch,
XMLPropertyState* pFontCharSet,
XMLPropertyState** ppNewFontStyleName,
XMLPropertyState** ppNewFontFamily,
XMLPropertyState** ppNewFontPitch,
XMLPropertyState** ppNewFontCharSet ) const
{
if( pFontFamilyName )
{
OUString sEmpty;
Any aAny;
if( !pFontStyleName )
{
aAny <<= sEmpty;
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pFontFamilyName->mnIndex + 1 );
DBG_ASSERT( nTmp == CTF_FONTSTYLENAME || nTmp == CTF_FONTSTYLENAME_CJK || nTmp == CTF_FONTSTYLENAME_CTL,
"wrong property context id" );
#endif
*ppNewFontStyleName = new XMLPropertyState( pFontFamilyName->mnIndex + 1,
aAny );
}
if( !pFontFamily )
{
aAny <<= (sal_Int16)com::sun::star::awt::FontFamily::DONTKNOW;
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pFontFamilyName->mnIndex + 2 );
DBG_ASSERT( nTmp == CTF_FONTFAMILY || nTmp == CTF_FONTFAMILY_CJK || nTmp == CTF_FONTFAMILY_CTL,
"wrong property context id" );
#endif
*ppNewFontFamily = new XMLPropertyState( pFontFamilyName->mnIndex + 2,
aAny );
}
if( !pFontPitch )
{
aAny <<= (sal_Int16)com::sun::star::awt::FontPitch::DONTKNOW;
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pFontFamilyName->mnIndex + 3 );
DBG_ASSERT( nTmp == CTF_FONTPITCH || nTmp == CTF_FONTPITCH_CJK || nTmp == CTF_FONTPITCH_CTL,
"wrong property context id" );
#endif
*ppNewFontPitch = new XMLPropertyState( pFontFamilyName->mnIndex + 3,
aAny );
}
if( !pFontCharSet )
{
aAny <<= (sal_Int16)gsl_getSystemTextEncoding();
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pFontFamilyName->mnIndex + 4 );
DBG_ASSERT( nTmp == CTF_FONTCHARSET || nTmp == CTF_FONTCHARSET_CJK || nTmp == CTF_FONTCHARSET_CTL,
"wrong property context id" );
#endif
*ppNewFontCharSet = new XMLPropertyState( pFontFamilyName->mnIndex + 4,
aAny );
}
}
}
void XMLTextImportPropertyMapper::finished(
::std::vector< XMLPropertyState >& rProperties,
sal_Int32 /*nStartIndex*/, sal_Int32 /*nEndIndex*/ ) const
{
sal_Bool bHasAnyHeight = sal_False;
sal_Bool bHasAnyMinHeight = sal_False;
sal_Bool bHasAnyWidth = sal_False;
sal_Bool bHasAnyMinWidth = sal_False;
XMLPropertyState* pFontFamilyName = 0;
XMLPropertyState* pFontStyleName = 0;
XMLPropertyState* pFontFamily = 0;
XMLPropertyState* pFontPitch = 0;
XMLPropertyState* pFontCharSet = 0;
XMLPropertyState* pNewFontStyleName = 0;
XMLPropertyState* pNewFontFamily = 0;
XMLPropertyState* pNewFontPitch = 0;
XMLPropertyState* pNewFontCharSet = 0;
XMLPropertyState* pFontFamilyNameCJK = 0;
XMLPropertyState* pFontStyleNameCJK = 0;
XMLPropertyState* pFontFamilyCJK = 0;
XMLPropertyState* pFontPitchCJK = 0;
XMLPropertyState* pFontCharSetCJK = 0;
XMLPropertyState* pNewFontStyleNameCJK = 0;
XMLPropertyState* pNewFontFamilyCJK = 0;
XMLPropertyState* pNewFontPitchCJK = 0;
XMLPropertyState* pNewFontCharSetCJK = 0;
XMLPropertyState* pFontFamilyNameCTL = 0;
XMLPropertyState* pFontStyleNameCTL = 0;
XMLPropertyState* pFontFamilyCTL = 0;
XMLPropertyState* pFontPitchCTL = 0;
XMLPropertyState* pFontCharSetCTL = 0;
XMLPropertyState* pNewFontStyleNameCTL = 0;
XMLPropertyState* pNewFontFamilyCTL = 0;
XMLPropertyState* pNewFontPitchCTL = 0;
XMLPropertyState* pNewFontCharSetCTL = 0;
XMLPropertyState* pAllBorderDistance = 0;
XMLPropertyState* pBorderDistances[4] = { 0, 0, 0, 0 };
XMLPropertyState* pNewBorderDistances[4] = { 0, 0, 0, 0 };
XMLPropertyState* pAllBorder = 0;
XMLPropertyState* pBorders[4] = { 0, 0, 0, 0 };
XMLPropertyState* pNewBorders[4] = { 0, 0, 0, 0 };
XMLPropertyState* pAllBorderWidth = 0;
XMLPropertyState* pBorderWidths[4] = { 0, 0, 0, 0 };
XMLPropertyState* pAnchorType = 0;
XMLPropertyState* pVertOrient = 0;
XMLPropertyState* pVertOrientRelAsChar = 0;
XMLPropertyState* pBackTransparency = NULL; // transparency in %
XMLPropertyState* pBackTransparent = NULL; // transparency as boolean
XMLPropertyState* pAllParaMargin = 0;
XMLPropertyState* pParaMargins[4] = { 0, 0, 0, 0 };
::std::auto_ptr<XMLPropertyState> pNewParaMargins[4];
XMLPropertyState* pAllMargin = 0;
XMLPropertyState* pMargins[4] = { 0, 0, 0, 0 };
::std::auto_ptr<XMLPropertyState> pNewMargins[4];
for( ::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin();
aIter != rProperties.end();
++aIter )
{
XMLPropertyState* property = &(*aIter);
if( -1 == property->mnIndex )
continue;
switch( getPropertySetMapper()->GetEntryContextId( property->mnIndex ) )
{
case CTF_FONTFAMILYNAME: pFontFamilyName = property; break;
case CTF_FONTSTYLENAME: pFontStyleName = property; break;
case CTF_FONTFAMILY: pFontFamily = property; break;
case CTF_FONTPITCH: pFontPitch = property; break;
case CTF_FONTCHARSET: pFontCharSet = property; break;
case CTF_FONTFAMILYNAME_CJK: pFontFamilyNameCJK = property; break;
case CTF_FONTSTYLENAME_CJK: pFontStyleNameCJK = property; break;
case CTF_FONTFAMILY_CJK: pFontFamilyCJK = property; break;
case CTF_FONTPITCH_CJK: pFontPitchCJK = property; break;
case CTF_FONTCHARSET_CJK: pFontCharSetCJK = property; break;
case CTF_FONTFAMILYNAME_CTL: pFontFamilyNameCTL = property; break;
case CTF_FONTSTYLENAME_CTL: pFontStyleNameCTL = property; break;
case CTF_FONTFAMILY_CTL: pFontFamilyCTL = property; break;
case CTF_FONTPITCH_CTL: pFontPitchCTL = property; break;
case CTF_FONTCHARSET_CTL: pFontCharSetCTL = property; break;
case CTF_ALLBORDERDISTANCE: pAllBorderDistance = property; break;
case CTF_LEFTBORDERDISTANCE: pBorderDistances[XML_LINE_LEFT] = property; break;
case CTF_RIGHTBORDERDISTANCE: pBorderDistances[XML_LINE_RIGHT] = property; break;
case CTF_TOPBORDERDISTANCE: pBorderDistances[XML_LINE_TOP] = property; break;
case CTF_BOTTOMBORDERDISTANCE: pBorderDistances[XML_LINE_BOTTOM] = property; break;
case CTF_ALLBORDER: pAllBorder = property; break;
case CTF_LEFTBORDER: pBorders[XML_LINE_LEFT] = property; break;
case CTF_RIGHTBORDER: pBorders[XML_LINE_RIGHT] = property; break;
case CTF_TOPBORDER: pBorders[XML_LINE_TOP] = property; break;
case CTF_BOTTOMBORDER: pBorders[XML_LINE_BOTTOM] = property; break;
case CTF_ALLBORDERWIDTH: pAllBorderWidth = property; break;
case CTF_LEFTBORDERWIDTH: pBorderWidths[XML_LINE_LEFT] = property; break;
case CTF_RIGHTBORDERWIDTH: pBorderWidths[XML_LINE_RIGHT] = property; break;
case CTF_TOPBORDERWIDTH: pBorderWidths[XML_LINE_TOP] = property; break;
case CTF_BOTTOMBORDERWIDTH: pBorderWidths[XML_LINE_BOTTOM] = property; break;
case CTF_ANCHORTYPE: pAnchorType = property; break;
case CTF_VERTICALPOS: pVertOrient = property; break;
case CTF_VERTICALREL_ASCHAR: pVertOrientRelAsChar = property; break;
case CTF_FRAMEHEIGHT_MIN_ABS:
case CTF_FRAMEHEIGHT_MIN_REL:
// case CTF_SYNCHEIGHT_MIN:
bHasAnyMinHeight = sal_True;
// no break here!
case CTF_FRAMEHEIGHT_ABS:
case CTF_FRAMEHEIGHT_REL:
// case CTF_SYNCHEIGHT:
bHasAnyHeight = sal_True; break;
case CTF_FRAMEWIDTH_MIN_ABS:
case CTF_FRAMEWIDTH_MIN_REL:
bHasAnyMinWidth = sal_True;
// no break here!
case CTF_FRAMEWIDTH_ABS:
case CTF_FRAMEWIDTH_REL:
bHasAnyWidth = sal_True; break;
case CTF_BACKGROUND_TRANSPARENCY: pBackTransparency = property; break;
case CTF_BACKGROUND_TRANSPARENT: pBackTransparent = property; break;
case CTF_PARAMARGINALL:
pAllParaMargin = property;
break;
case CTF_PARAMARGINALL_REL:
{
sal_uInt32 nValue;
property->maValue >>= nValue;
// treat fo:margin="100%" as it is not exisiting as the
// corresponding core attribute classes - <SvxULSpaceItem> and
// <SvxLRSpaceItem> - are not able to treat such a value correctly.
// The result will be the same as the values will be inherited
// from parent, when the no margin attribute is given.
if ( nValue != 100 )
{
pAllParaMargin = property;
}
}
break;
case CTF_PARALEFTMARGIN:
case CTF_PARALEFTMARGIN_REL:
pParaMargins[XML_LINE_LEFT] = property; break;
case CTF_PARARIGHTMARGIN:
case CTF_PARARIGHTMARGIN_REL:
pParaMargins[XML_LINE_RIGHT] = property; break;
case CTF_PARATOPMARGIN:
case CTF_PARATOPMARGIN_REL:
pParaMargins[XML_LINE_TOP] = property; break;
case CTF_PARABOTTOMMARGIN:
case CTF_PARABOTTOMMARGIN_REL:
pParaMargins[XML_LINE_BOTTOM] = property; break;
case CTF_MARGINALL:
pAllMargin = property; break;
case CTF_MARGINLEFT:
pMargins[XML_LINE_LEFT] = property; break;
case CTF_MARGINRIGHT:
pMargins[XML_LINE_RIGHT] = property; break;
case CTF_MARGINTOP:
pMargins[XML_LINE_TOP] = property; break;
case CTF_MARGINBOTTOM:
pMargins[XML_LINE_BOTTOM] = property; break;
}
}
if( pFontFamilyName || pFontStyleName || pFontFamily ||
pFontPitch || pFontCharSet )
FontFinished( pFontFamilyName, pFontStyleName, pFontFamily,
pFontPitch, pFontCharSet );
if( pFontFamilyNameCJK || pFontStyleNameCJK || pFontFamilyCJK ||
pFontPitchCJK || pFontCharSetCJK )
FontFinished( pFontFamilyNameCJK, pFontStyleNameCJK, pFontFamilyCJK,
pFontPitchCJK, pFontCharSetCJK );
if( pFontFamilyNameCTL || pFontStyleNameCTL || pFontFamilyCTL ||
pFontPitchCTL || pFontCharSetCTL )
FontFinished( pFontFamilyNameCTL, pFontStyleNameCTL, pFontFamilyCTL,
pFontPitchCTL, pFontCharSetCTL );
for (sal_uInt16 i = 0; i < 4; i++)
{
if ( pAllParaMargin != NULL
&& pParaMargins[i] == NULL )
{
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pAllParaMargin->mnIndex + (2*i) + 2 );
OSL_ENSURE( nTmp >= CTF_PARALEFTMARGIN &&
nTmp <= CTF_PARABOTTOMMARGIN_REL,
"wrong property context id" );
#endif
// IMPORTANT NOTE: the index calculation depends on the right order in the property map
pNewParaMargins[i].reset(
new XMLPropertyState( pAllParaMargin->mnIndex + (2*i) + 2,
pAllParaMargin->maValue ) );
}
if (pAllMargin && !pMargins[i])
{
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pAllMargin->mnIndex + i + 1 );
OSL_ENSURE( nTmp >= CTF_MARGINLEFT && nTmp <= CTF_MARGINBOTTOM,
"wrong property context id" );
#endif
// IMPORTANT NOTE: the index calculation depends on the right order in the property map
pNewMargins[i].reset(
new XMLPropertyState( pAllMargin->mnIndex + i + 1,
pAllMargin->maValue ) );
}
if( pAllBorderDistance && !pBorderDistances[i] )
{
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pAllBorderDistance->mnIndex + i + 1 );
DBG_ASSERT( nTmp >= CTF_LEFTBORDERDISTANCE &&
nTmp <= CTF_BOTTOMBORDERDISTANCE,
"wrong property context id" );
#endif
pNewBorderDistances[i] =
new XMLPropertyState( pAllBorderDistance->mnIndex + i + 1,
pAllBorderDistance->maValue );
pBorderDistances[i] = pNewBorderDistances[i];
}
if( pAllBorder && !pBorders[i] )
{
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pAllBorder->mnIndex + i + 1 );
DBG_ASSERT( nTmp >= CTF_LEFTBORDER && nTmp <= CTF_BOTTOMBORDER,
"wrong property context id" );
#endif
pNewBorders[i] = new XMLPropertyState( pAllBorder->mnIndex + i + 1,
pAllBorder->maValue );
pBorders[i] = pNewBorders[i];
}
if( !pBorderWidths[i] )
pBorderWidths[i] = pAllBorderWidth;
else
pBorderWidths[i]->mnIndex = -1;
#ifdef XML_CHECK_UI_CONSTRAINS
sal_Bool bHasBorder = sal_False;
if( pBorders[i] )
{
table::BorderLine aBorderLine;
pBorders[i]->maValue >>= aBorderLine;
if( pBorderWidths[i] )
{
table::BorderLine aBorderLineWidth;
pBorderWidths[i]->maValue >>= aBorderLineWidth;
aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
pBorders[i]->maValue <<= aBorderLine;
}
bHasBorder = (aBorderLine.OuterLineWidth +
aBorderLine.InnerLineWidth) > 0;
}
if( bHasBorder )
{
if( !pBorderDistances[i] )
{
#ifdef DBG_UTIL
sal_Int16 nTmp = getPropertySetMapper()->GetEntryContextId(
pBorders[i]->mnIndex + 5 );
DBG_ASSERT( nTmp >= CTF_LEFTBORDERDISTANCE &&
nTmp <= CTF_BOTTOMBORDERDISTANCE,
"wrong property context id" );
#endif
pNewBorderDistances[i] =
new XMLPropertyState( pBorders[i]->mnIndex + 5 );
pNewBorderDistances[i]->maValue <<= (sal_Int32)MIN_BORDER_DIST;
pBorderDistances[i] = pNewBorderDistances[i];
}
else
{
sal_Int32 nDist;
pBorderDistances[i]->maValue >>= nDist;
if( nDist < MIN_BORDER_DIST )
pBorderDistances[i]->maValue <<= (sal_Int32)MIN_BORDER_DIST;
}
}
else
{
if( pBorderDistances[i] )
{
sal_Int32 nDist;
pBorderDistances[i]->maValue >>= nDist;
if( nDist > 0 )
pBorderDistances[i]->maValue <<= (sal_Int32)0;
}
}
#else
if( pBorders[i] && pBorderWidths[i] )
{
table::BorderLine aBorderLine;
pBorders[i]->maValue >>= aBorderLine;
table::BorderLine aBorderLineWidth;
pBorderWidths[i]->maValue >>= aBorderLineWidth;
aBorderLine.OuterLineWidth = aBorderLineWidth.OuterLineWidth;
aBorderLine.InnerLineWidth = aBorderLineWidth.InnerLineWidth;
aBorderLine.LineDistance = aBorderLineWidth.LineDistance;
pBorders[i]->maValue <<= aBorderLine;
}
#endif
}
if (pAllParaMargin)
{
pAllParaMargin->mnIndex = -1;
}
if (pAllMargin)
{
pAllMargin->mnIndex = -1;
}
if( pAllBorderDistance )
pAllBorderDistance->mnIndex = -1;
if( pAllBorder )
pAllBorder->mnIndex = -1;
if( pAllBorderWidth )
pAllBorderWidth->mnIndex = -1;
if( pVertOrient && pVertOrientRelAsChar )
{
sal_Int16 nVertOrient;
pVertOrient->maValue >>= nVertOrient;
sal_Int16 nVertOrientRel = 0;
pVertOrientRelAsChar->maValue >>= nVertOrientRel;
switch( nVertOrient )
{
case VertOrientation::TOP:
nVertOrient = nVertOrientRel;
break;
case VertOrientation::CENTER:
switch( nVertOrientRel )
{
case VertOrientation::CHAR_TOP:
nVertOrient = VertOrientation::CHAR_CENTER;
break;
case VertOrientation::LINE_TOP:
nVertOrient = VertOrientation::LINE_CENTER;
break;
}
break;
case VertOrientation::BOTTOM:
switch( nVertOrientRel )
{
case VertOrientation::CHAR_TOP:
nVertOrient = VertOrientation::CHAR_BOTTOM;
break;
case VertOrientation::LINE_TOP:
nVertOrient = VertOrientation::LINE_BOTTOM;
break;
}
break;
}
pVertOrient->maValue <<= nVertOrient;
pVertOrientRelAsChar->mnIndex = -1;
}
FontDefaultsCheck( pFontFamilyName,
pFontStyleName, pFontFamily, pFontPitch, pFontCharSet,
&pNewFontStyleName, &pNewFontFamily, &pNewFontPitch, &pNewFontCharSet );
FontDefaultsCheck( pFontFamilyNameCJK,
pFontStyleNameCJK, pFontFamilyCJK, pFontPitchCJK, pFontCharSetCJK,
&pNewFontStyleNameCJK, &pNewFontFamilyCJK, &pNewFontPitchCJK, &pNewFontCharSetCJK );
FontDefaultsCheck( pFontFamilyNameCTL,
pFontStyleNameCTL, pFontFamilyCTL, pFontPitchCTL, pFontCharSetCTL,
&pNewFontStyleNameCTL, &pNewFontFamilyCTL, &pNewFontPitchCTL, &pNewFontCharSetCTL );
// #i5775# don't overwrite %transparency with binary transparency
if( ( pBackTransparency != NULL ) && ( pBackTransparent != NULL ) )
{
if( ! *(sal_Bool*)(pBackTransparent->maValue.getValue()) )
pBackTransparent->mnIndex = -1;
}
// insert newly created properties. This inavlidates all iterators!
// Most of the pXXX variables in this method are iterators and will be
// invalidated!!!
if( pNewFontStyleName )
{
rProperties.push_back( *pNewFontStyleName );
delete pNewFontStyleName;
}
if( pNewFontFamily )
{
rProperties.push_back( *pNewFontFamily );
delete pNewFontFamily;
}
if( pNewFontPitch )
{
rProperties.push_back( *pNewFontPitch );
delete pNewFontPitch;
}
if( pNewFontCharSet )
{
rProperties.push_back( *pNewFontCharSet );
delete pNewFontCharSet;
}
if( pNewFontStyleNameCJK )
{
rProperties.push_back( *pNewFontStyleNameCJK );
delete pNewFontStyleNameCJK;
}
if( pNewFontFamilyCJK )
{
rProperties.push_back( *pNewFontFamilyCJK );
delete pNewFontFamilyCJK;
}
if( pNewFontPitchCJK )
{
rProperties.push_back( *pNewFontPitchCJK );
delete pNewFontPitchCJK;
}
if( pNewFontCharSetCJK )
{
rProperties.push_back( *pNewFontCharSetCJK );
delete pNewFontCharSetCJK;
}
if( pNewFontStyleNameCTL)
{
rProperties.push_back( *pNewFontStyleNameCTL );
delete pNewFontStyleNameCTL;
}
if( pNewFontFamilyCTL )
{
rProperties.push_back( *pNewFontFamilyCTL );
delete pNewFontFamilyCTL;
}
if( pNewFontPitchCTL )
{
rProperties.push_back( *pNewFontPitchCTL );
delete pNewFontPitchCTL;
}
if( pNewFontCharSetCTL )
{
rProperties.push_back( *pNewFontCharSetCTL );
delete pNewFontCharSetCTL;
}
for (sal_uInt16 i=0; i<4; i++)
{
if (pNewParaMargins[i].get())
{
rProperties.push_back(*pNewParaMargins[i]);
}
if (pNewMargins[i].get())
{
rProperties.push_back(*pNewMargins[i]);
}
if( pNewBorderDistances[i] )
{
rProperties.push_back( *pNewBorderDistances[i] );
delete pNewBorderDistances[i];
}
if( pNewBorders[i] )
{
rProperties.push_back( *pNewBorders[i] );
delete pNewBorders[i];
}
}
if( bHasAnyHeight )
{
if( nSizeTypeIndex == -2 )
{
const_cast < XMLTextImportPropertyMapper * > ( this )
->nSizeTypeIndex = -1;
sal_Int32 nPropCount = getPropertySetMapper()->GetEntryCount();
for( sal_Int32 j=0; j < nPropCount; j++ )
{
if( CTF_SIZETYPE == getPropertySetMapper()
->GetEntryContextId( j ) )
{
const_cast < XMLTextImportPropertyMapper * > ( this )
->nSizeTypeIndex = j;
break;
}
}
}
if( nSizeTypeIndex != -1 )
{
XMLPropertyState aSizeTypeState( nSizeTypeIndex );
aSizeTypeState.maValue <<= (sal_Int16)( bHasAnyMinHeight
? SizeType::MIN
: SizeType::FIX);
rProperties.push_back( aSizeTypeState );
}
}
if( bHasAnyWidth )
{
if( nWidthTypeIndex == -2 )
{
const_cast < XMLTextImportPropertyMapper * > ( this )
->nWidthTypeIndex = -1;
sal_Int32 nCount = getPropertySetMapper()->GetEntryCount();
for( sal_Int32 j=0; j < nCount; j++ )
{
if( CTF_FRAMEWIDTH_TYPE == getPropertySetMapper()
->GetEntryContextId( j ) )
{
const_cast < XMLTextImportPropertyMapper * > ( this )
->nWidthTypeIndex = j;
break;
}
}
}
if( nWidthTypeIndex != -1 )
{
XMLPropertyState aSizeTypeState( nWidthTypeIndex );
aSizeTypeState.maValue <<= (sal_Int16)( bHasAnyMinWidth
? SizeType::MIN
: SizeType::FIX);
rProperties.push_back( aSizeTypeState );
}
}
// DO NOT USE ITERATORS/POINTERS INTO THE rProperties-VECTOR AFTER
// THIS LINE. All iterators into the rProperties-vector, especially all
// pXXX-type variables set in the first switch statement of this method,
// may have been invalidated by the above push_back() calls!
}