| /************************************************************** |
| * |
| * 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! |
| } |
| |
| |
