| /************************************************************** |
| * |
| * 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_sw.hxx" |
| #include "xmlimpit.hxx" |
| #include <xmloff/xmluconv.hxx> |
| #include <svl/itempool.hxx> |
| #include <svl/poolitem.hxx> |
| #include <svl/itemset.hxx> |
| #include <xmloff/attrlist.hxx> |
| #include <xmloff/nmspmap.hxx> |
| #include <xmloff/xmlnmspe.hxx> |
| #include <editeng/xmlcnitm.hxx> |
| #include <editeng/memberids.hrc> |
| |
| |
| #include "hintids.hxx" |
| #include "unomid.h" |
| #include <svx/unomid.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/shaditem.hxx> |
| #include <editeng/boxitem.hxx> |
| #include <editeng/brkitem.hxx> |
| #include <editeng/keepitem.hxx> |
| #include <editeng/brshitem.hxx> |
| #include "fmtpdsc.hxx" |
| #include "fmtornt.hxx" |
| #include "fmtfsize.hxx" |
| |
| #ifndef _FMTLSPLT_HXX |
| #include "fmtlsplt.hxx" |
| #endif |
| #include <xmloff/prhdlfac.hxx> |
| #include <xmloff/xmltypes.hxx> |
| #include "xmlithlp.hxx" |
| #include <com/sun/star/uno/Any.hxx> |
| |
| using ::rtl::OUString; |
| using namespace ::com::sun::star; |
| using namespace ::xmloff::token; |
| using uno::Any; |
| |
| SvXMLImportItemMapper::SvXMLImportItemMapper( |
| SvXMLItemMapEntriesRef rMapEntries, |
| sal_uInt16 nUnknWhich ) : |
| mrMapEntries( rMapEntries ), |
| nUnknownWhich( nUnknWhich ) |
| { |
| } |
| |
| SvXMLImportItemMapper::~SvXMLImportItemMapper() |
| { |
| } |
| |
| void |
| SvXMLImportItemMapper::setMapEntries( SvXMLItemMapEntriesRef rMapEntries ) |
| { |
| mrMapEntries = rMapEntries; |
| } |
| |
| /** fills the given itemset with the attributes in the given list */ |
| void SvXMLImportItemMapper::importXML( SfxItemSet& rSet, |
| uno::Reference< xml::sax::XAttributeList > xAttrList, |
| const SvXMLUnitConverter& rUnitConverter, |
| const SvXMLNamespaceMap& rNamespaceMap ) |
| { |
| sal_Int16 nAttr = xAttrList->getLength(); |
| |
| SvXMLAttrContainerItem *pUnknownItem = 0; |
| for( sal_Int16 i=0; i < nAttr; i++ ) |
| { |
| const OUString& rAttrName = xAttrList->getNameByIndex( i ); |
| OUString aLocalName, aPrefix, aNamespace; |
| sal_uInt16 nPrefix = |
| rNamespaceMap.GetKeyByAttrName( rAttrName, &aPrefix, &aLocalName, |
| &aNamespace ); |
| if( XML_NAMESPACE_XMLNS == nPrefix ) |
| continue; |
| |
| const OUString& rValue = xAttrList->getValueByIndex( i ); |
| |
| // find a map entry for this attribute |
| SvXMLItemMapEntry* pEntry = mrMapEntries->getByName( nPrefix, aLocalName ); |
| |
| if( pEntry ) |
| { |
| // we have a valid map entry here, so lets use it... |
| if( 0 == (pEntry->nMemberId & (MID_SW_FLAG_NO_ITEM_IMPORT| |
| MID_SW_FLAG_ELEMENT_ITEM_IMPORT)) ) |
| { |
| // first get item from itemset |
| const SfxPoolItem* pItem = 0; |
| SfxItemState eState = rSet.GetItemState( pEntry->nWhichId, sal_True, |
| &pItem ); |
| |
| // if its not set, try the pool |
| if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > pEntry->nWhichId ) |
| pItem = &rSet.GetPool()->GetDefaultItem(pEntry->nWhichId); |
| |
| // do we have an item? |
| if(eState >= SFX_ITEM_DEFAULT && pItem) |
| { |
| SfxPoolItem *pNewItem = pItem->Clone(); |
| sal_Bool bPut = sal_False; |
| |
| if( 0 == (pEntry->nMemberId&MID_SW_FLAG_SPECIAL_ITEM_IMPORT) ) |
| { |
| // bPut = pNewItem->importXML( rValue, |
| // pEntry->nMemberId & MID_SW_FLAG_MASK, |
| // rUnitConverter ); |
| bPut = PutXMLValue( *pNewItem, rValue, |
| static_cast<sal_uInt16>( pEntry->nMemberId & MID_SW_FLAG_MASK ), |
| rUnitConverter ); |
| |
| } |
| else |
| { |
| bPut = handleSpecialItem( *pEntry, *pNewItem, rSet, |
| rValue, rUnitConverter, |
| rNamespaceMap ); |
| } |
| |
| if( bPut ) |
| rSet.Put( *pNewItem ); |
| |
| delete pNewItem; |
| } |
| else |
| { |
| DBG_ERROR( "Could not get a needed item for xml import!" ); |
| } |
| } |
| else if( 0 != (pEntry->nMemberId & MID_SW_FLAG_NO_ITEM_IMPORT) ) |
| { |
| handleNoItem( *pEntry, rSet, rValue, rUnitConverter, |
| rNamespaceMap ); |
| } |
| } |
| else if( USHRT_MAX != nUnknownWhich ) |
| { |
| if( !pUnknownItem ) |
| { |
| const SfxPoolItem* pItem = 0; |
| if( SFX_ITEM_SET == rSet.GetItemState( nUnknownWhich, sal_True, |
| &pItem ) ) |
| { |
| SfxPoolItem *pNew = pItem->Clone(); |
| pUnknownItem = PTR_CAST( SvXMLAttrContainerItem, pNew ); |
| DBG_ASSERT( pUnknownItem, |
| "SvXMLAttrContainerItem expected" ); |
| if( !pUnknownItem ) |
| delete pNew; |
| } |
| else |
| { |
| pUnknownItem = new SvXMLAttrContainerItem( nUnknownWhich ); |
| } |
| } |
| if( pUnknownItem ) |
| { |
| if( XML_NAMESPACE_NONE == nPrefix ) |
| pUnknownItem->AddAttr( aLocalName, rValue ); |
| else |
| pUnknownItem->AddAttr( aPrefix, aNamespace, aLocalName, |
| rValue ); |
| } |
| } |
| } |
| |
| if( pUnknownItem ) |
| { |
| rSet.Put( *pUnknownItem ); |
| delete pUnknownItem; |
| } |
| |
| finished(rSet, rUnitConverter); |
| } |
| |
| /** this method is called for every item that has the |
| MID_SW_FLAG_SPECIAL_ITEM_IMPORT flag set */ |
| sal_Bool |
| SvXMLImportItemMapper::handleSpecialItem( const SvXMLItemMapEntry& /*rEntry*/, |
| SfxPoolItem& /*rItem*/, |
| SfxItemSet& /*rSet*/, |
| const OUString& /*rValue*/, |
| const SvXMLUnitConverter& /*rUnitConverter*/, |
| const SvXMLNamespaceMap& /*rNamespaceMap*/ ) |
| { |
| DBG_ERROR( "unsuported special item in xml import" ); |
| return sal_False; |
| } |
| |
| /** this method is called for every item that has the |
| MID_SW_FLAG_NO_ITEM_IMPORT flag set */ |
| sal_Bool SvXMLImportItemMapper::handleNoItem( const SvXMLItemMapEntry& /*rEntry*/, |
| SfxItemSet& /*rSet*/, |
| const OUString& /*rValue*/, |
| const SvXMLUnitConverter& /*rUnitConverter*/, |
| const SvXMLNamespaceMap& /*rNamespaceMap*/ ) |
| { |
| DBG_ERROR( "unsuported no item in xml import" ); |
| return sal_False; |
| } |
| |
| void |
| SvXMLImportItemMapper::finished(SfxItemSet &, SvXMLUnitConverter const&) const |
| { |
| // nothing to do here |
| } |
| |
| |
| |
| // put an XML-string value into an item |
| sal_Bool SvXMLImportItemMapper::PutXMLValue( |
| SfxPoolItem& rItem, |
| const ::rtl::OUString& rValue, |
| sal_uInt16 nMemberId, |
| const SvXMLUnitConverter& rUnitConverter ) |
| { |
| sal_Bool bOk = sal_False; |
| |
| switch (rItem.Which()) |
| { |
| case RES_LR_SPACE: |
| { |
| SvxLRSpaceItem* pLRSpace = PTR_CAST(SvxLRSpaceItem, &rItem); |
| DBG_ASSERT( pLRSpace != NULL, "Wrong Which-ID!" ); |
| |
| switch( nMemberId ) |
| { |
| case MID_L_MARGIN: |
| case MID_R_MARGIN: |
| { |
| sal_Int32 nProp = 100; |
| sal_Int32 nAbs = 0; |
| |
| if( rValue.indexOf( sal_Unicode('%') ) != -1 ) |
| bOk = rUnitConverter.convertPercent( nProp, rValue ); |
| else |
| bOk = rUnitConverter.convertMeasure( nAbs, rValue ); |
| |
| if( bOk ) |
| { |
| switch( nMemberId ) |
| { |
| case MID_L_MARGIN: |
| pLRSpace->SetTxtLeft( (sal_Int32)nAbs, (sal_uInt16)nProp ); |
| break; |
| case MID_R_MARGIN: |
| pLRSpace->SetRight( (sal_Int32)nAbs, (sal_uInt16)nProp ); |
| break; |
| } |
| } |
| } |
| break; |
| case MID_FIRST_LINE_INDENT: |
| { |
| sal_Int32 nProp = 100; |
| sal_Int32 nAbs = 0; |
| |
| if( rValue.indexOf( sal_Unicode('%') ) != -1 ) |
| bOk = rUnitConverter.convertPercent( nProp, rValue ); |
| else |
| bOk = rUnitConverter.convertMeasure( nAbs, rValue, |
| -0x7fff, 0x7fff ); |
| |
| pLRSpace->SetTxtFirstLineOfst( (short)nAbs, (sal_uInt16)nProp ); |
| } |
| |
| case MID_FIRST_AUTO: |
| { |
| sal_Bool bAutoFirst; |
| bOk = rUnitConverter.convertBool( bAutoFirst, rValue ); |
| if( bOk ) |
| pLRSpace->SetAutoFirst( bAutoFirst ); |
| } |
| break; |
| |
| default: |
| DBG_ERROR( "unknown member id!"); |
| } |
| } |
| break; |
| |
| case RES_UL_SPACE: |
| { |
| SvxULSpaceItem* pULSpace = PTR_CAST(SvxULSpaceItem, &rItem); |
| DBG_ASSERT( pULSpace != NULL, "Wrong Which-ID!" ); |
| |
| sal_Int32 nProp = 100; |
| sal_Int32 nAbs = 0; |
| |
| if( rValue.indexOf( sal_Unicode('%') ) != -1 ) |
| bOk = rUnitConverter.convertPercent( nProp, rValue ); |
| else |
| bOk = rUnitConverter.convertMeasure( nAbs, rValue ); |
| |
| switch( nMemberId ) |
| { |
| case MID_UP_MARGIN: |
| pULSpace->SetUpper( (sal_uInt16)nAbs, (sal_uInt16)nProp ); |
| break; |
| case MID_LO_MARGIN: |
| pULSpace->SetLower( (sal_uInt16)nAbs, (sal_uInt16)nProp ); |
| break; |
| default: |
| DBG_ERROR("unknown MemberId"); |
| } |
| } |
| break; |
| |
| case RES_SHADOW: |
| { |
| SvxShadowItem* pShadow = PTR_CAST(SvxShadowItem, &rItem); |
| DBG_ASSERT( pShadow != NULL, "Wrong Which-ID" ); |
| |
| sal_Bool bColorFound = sal_False; |
| sal_Bool bOffsetFound = sal_False; |
| |
| SvXMLTokenEnumerator aTokenEnum( rValue ); |
| |
| Color aColor( 128,128, 128 ); |
| pShadow->SetLocation( SVX_SHADOW_BOTTOMRIGHT ); |
| |
| OUString aToken; |
| while( aTokenEnum.getNextToken( aToken ) ) |
| { |
| if( IsXMLToken( aToken, XML_NONE ) ) |
| { |
| pShadow->SetLocation( SVX_SHADOW_NONE ); |
| bOk = sal_True; |
| } |
| else if( !bColorFound && aToken.compareToAscii( "#", 1 ) == 0 ) |
| { |
| bOk = rUnitConverter.convertColor( aColor, aToken ); |
| if( !bOk ) |
| return sal_False; |
| |
| bColorFound = sal_True; |
| } |
| else if( !bOffsetFound ) |
| { |
| sal_Int32 nX = 0, nY = 0; |
| |
| bOk = rUnitConverter.convertMeasure( nX, aToken ); |
| if( bOk && aTokenEnum.getNextToken( aToken ) ) |
| bOk = rUnitConverter.convertMeasure( nY, aToken ); |
| |
| if( bOk ) |
| { |
| if( nX < 0 ) |
| { |
| if( nY < 0 ) |
| { |
| pShadow->SetLocation( SVX_SHADOW_TOPLEFT ); |
| } |
| else |
| { |
| pShadow->SetLocation( SVX_SHADOW_BOTTOMLEFT ); |
| } |
| } |
| else |
| { |
| if( nY < 0 ) |
| { |
| pShadow->SetLocation( SVX_SHADOW_TOPRIGHT ); |
| } |
| else |
| { |
| pShadow->SetLocation( SVX_SHADOW_BOTTOMRIGHT ); |
| } |
| } |
| |
| if( nX < 0 ) nX *= -1; |
| if( nY < 0 ) nY *= -1; |
| |
| pShadow->SetWidth( static_cast< sal_uInt16 >( (nX + nY) >> 1 ) ); |
| } |
| } |
| } |
| |
| if( bOk && ( bColorFound || bOffsetFound ) ) |
| { |
| pShadow->SetColor( aColor ); |
| } |
| else |
| bOk = sal_False; |
| } |
| break; |
| |
| case RES_BOX: |
| { |
| SvxBoxItem* pBox = PTR_CAST(SvxBoxItem, &rItem); |
| DBG_ASSERT( pBox != NULL, "Wrong WHich-ID" ); |
| |
| /** copy SvxBorderLines */ |
| SvxBorderLine* pTop = pBox->GetTop() == NULL ? |
| NULL : new SvxBorderLine( *pBox->GetTop() ); |
| SvxBorderLine* pBottom = pBox->GetBottom() == NULL ? |
| NULL : new SvxBorderLine( *pBox->GetBottom() ); |
| SvxBorderLine* pLeft = pBox->GetLeft() == NULL ? |
| NULL : new SvxBorderLine( *pBox->GetLeft() ); |
| SvxBorderLine* pRight = pBox->GetRight() == NULL ? |
| NULL : new SvxBorderLine( *pBox->GetRight() ); |
| |
| sal_Int32 nTemp; |
| |
| switch( nMemberId ) |
| { |
| case ALL_BORDER_PADDING: |
| case LEFT_BORDER_PADDING: |
| case RIGHT_BORDER_PADDING: |
| case TOP_BORDER_PADDING: |
| case BOTTOM_BORDER_PADDING: |
| if(!rUnitConverter.convertMeasure( nTemp, rValue, 0, 0xffff )) |
| return sal_False; |
| |
| if( nMemberId == LEFT_BORDER_PADDING || |
| nMemberId == ALL_BORDER_PADDING ) |
| pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_LEFT ); |
| if( nMemberId == RIGHT_BORDER_PADDING || |
| nMemberId == ALL_BORDER_PADDING ) |
| pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_RIGHT ); |
| if( nMemberId == TOP_BORDER_PADDING || |
| nMemberId == ALL_BORDER_PADDING ) |
| pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_TOP ); |
| if( nMemberId == BOTTOM_BORDER_PADDING || |
| nMemberId == ALL_BORDER_PADDING ) |
| pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_BOTTOM); |
| break; |
| |
| case ALL_BORDER: |
| case LEFT_BORDER: |
| case RIGHT_BORDER: |
| case TOP_BORDER: |
| case BOTTOM_BORDER: |
| { |
| sal_Bool bHasStyle = sal_False; |
| sal_Bool bHasWidth = sal_False; |
| sal_Bool bHasColor = sal_False; |
| |
| sal_uInt16 nStyle = USHRT_MAX; |
| sal_uInt16 nWidth = 0; |
| sal_uInt16 nNamedWidth = USHRT_MAX; |
| |
| Color aColor( COL_BLACK ); |
| |
| if( !lcl_frmitems_parseXMLBorder( rValue, rUnitConverter, |
| bHasStyle, nStyle, |
| bHasWidth, nWidth, nNamedWidth, |
| bHasColor, aColor ) ) |
| return sal_False; |
| |
| if( TOP_BORDER == nMemberId || ALL_BORDER == nMemberId ) |
| lcl_frmitems_setXMLBorder( pTop, |
| bHasStyle, nStyle, |
| bHasWidth, nWidth, nNamedWidth, |
| bHasColor, aColor ); |
| |
| if( BOTTOM_BORDER == nMemberId || ALL_BORDER == nMemberId ) |
| lcl_frmitems_setXMLBorder( pBottom, |
| bHasStyle, nStyle, |
| bHasWidth, nWidth, nNamedWidth, |
| bHasColor, aColor ); |
| |
| if( LEFT_BORDER == nMemberId || ALL_BORDER == nMemberId ) |
| lcl_frmitems_setXMLBorder( pLeft, |
| bHasStyle, nStyle, |
| bHasWidth, nWidth, nNamedWidth, |
| bHasColor, aColor ); |
| |
| if( RIGHT_BORDER == nMemberId || ALL_BORDER == nMemberId ) |
| lcl_frmitems_setXMLBorder( pRight, |
| bHasStyle, nStyle, |
| bHasWidth, nWidth, nNamedWidth, |
| bHasColor, aColor ); |
| } |
| break; |
| case ALL_BORDER_LINE_WIDTH: |
| case LEFT_BORDER_LINE_WIDTH: |
| case RIGHT_BORDER_LINE_WIDTH: |
| case TOP_BORDER_LINE_WIDTH: |
| case BOTTOM_BORDER_LINE_WIDTH: |
| { |
| SvXMLTokenEnumerator aTokenEnum( rValue ); |
| |
| sal_Int32 nInWidth, nDistance, nOutWidth; |
| |
| OUString aToken; |
| if( !aTokenEnum.getNextToken( aToken ) ) |
| return sal_False; |
| |
| if( !rUnitConverter.convertMeasure( nInWidth, aToken, |
| DEF_LINE_WIDTH_0, |
| DEF_LINE_WIDTH_4 ) ) |
| return sal_False; |
| |
| if( !aTokenEnum.getNextToken( aToken ) ) |
| return sal_False; |
| |
| if( !rUnitConverter.convertMeasure( nDistance, aToken, |
| DEF_LINE_WIDTH_0, |
| DEF_LINE_WIDTH_4 ) ) |
| return sal_False; |
| |
| if( !aTokenEnum.getNextToken( aToken ) ) |
| return sal_False; |
| |
| if( !rUnitConverter.convertMeasure( nOutWidth, aToken, |
| DEF_LINE_WIDTH_0, |
| DEF_LINE_WIDTH_4 ) ) |
| return sal_False; |
| |
| // #i61946: accept line style even it's not part of our "normal" set of line styles |
| sal_uInt16 nWidth = 0; |
| |
| if( TOP_BORDER_LINE_WIDTH == nMemberId || |
| ALL_BORDER_LINE_WIDTH == nMemberId ) |
| lcl_frmitems_setXMLBorder( pTop, nWidth, |
| static_cast< sal_uInt16 >( nOutWidth ), |
| static_cast< sal_uInt16 >( nInWidth ), |
| static_cast< sal_uInt16 >( nDistance ) ); |
| |
| if( BOTTOM_BORDER_LINE_WIDTH == nMemberId || |
| ALL_BORDER_LINE_WIDTH == nMemberId ) |
| lcl_frmitems_setXMLBorder( pBottom, nWidth, |
| static_cast< sal_uInt16 >( nOutWidth ), |
| static_cast< sal_uInt16 >( nInWidth ), |
| static_cast< sal_uInt16 >( nDistance ) ); |
| |
| if( LEFT_BORDER_LINE_WIDTH == nMemberId || |
| ALL_BORDER_LINE_WIDTH == nMemberId ) |
| lcl_frmitems_setXMLBorder( pLeft, nWidth, |
| static_cast< sal_uInt16 >( nOutWidth ), |
| static_cast< sal_uInt16 >( nInWidth ), |
| static_cast< sal_uInt16 >( nDistance ) ); |
| |
| if( RIGHT_BORDER_LINE_WIDTH == nMemberId || |
| ALL_BORDER_LINE_WIDTH == nMemberId ) |
| lcl_frmitems_setXMLBorder( pRight, nWidth, |
| static_cast< sal_uInt16 >( nOutWidth ), |
| static_cast< sal_uInt16 >( nInWidth ), |
| static_cast< sal_uInt16 >( nDistance ) ); |
| } |
| break; |
| } |
| |
| pBox->SetLine( pTop, BOX_LINE_TOP ); |
| pBox->SetLine( pBottom, BOX_LINE_BOTTOM ); |
| pBox->SetLine( pLeft, BOX_LINE_LEFT ); |
| pBox->SetLine( pRight, BOX_LINE_RIGHT ); |
| |
| delete pTop; |
| delete pBottom; |
| delete pLeft; |
| delete pRight; |
| |
| bOk = sal_True; |
| } |
| break; |
| |
| case RES_BREAK: |
| { |
| SvxFmtBreakItem* pFmtBreak = PTR_CAST(SvxFmtBreakItem, &rItem); |
| DBG_ASSERT( pFmtBreak != NULL, "Wrong Which-ID" ); |
| |
| sal_uInt16 eEnum; |
| |
| if( !rUnitConverter.convertEnum( eEnum, rValue, psXML_BreakType ) ) |
| return sal_False; |
| |
| if( eEnum == 0 ) |
| { |
| pFmtBreak->SetValue( SVX_BREAK_NONE ); |
| bOk = sal_True; |
| } |
| else |
| { |
| switch( nMemberId ) |
| { |
| case MID_BREAK_BEFORE: |
| pFmtBreak->SetValue( static_cast< sal_uInt16 >((eEnum == 1) ? |
| SVX_BREAK_COLUMN_BEFORE : |
| SVX_BREAK_PAGE_BEFORE) ); |
| break; |
| case MID_BREAK_AFTER: |
| pFmtBreak->SetValue( static_cast< sal_uInt16 >((eEnum == 1) ? |
| SVX_BREAK_COLUMN_AFTER : |
| SVX_BREAK_PAGE_AFTER) ); |
| break; |
| } |
| bOk = sal_True; |
| } |
| } |
| break; |
| |
| case RES_KEEP: |
| { |
| SvxFmtKeepItem* pFmtKeep = PTR_CAST(SvxFmtKeepItem, &rItem); |
| DBG_ASSERT( pFmtKeep != NULL, "Wrong Which-ID" ); |
| |
| if( IsXMLToken( rValue, XML_ALWAYS ) || |
| IsXMLToken( rValue, XML_TRUE ) ) |
| { |
| pFmtKeep->SetValue( sal_True ); |
| bOk = sal_True; |
| } |
| else if( IsXMLToken( rValue, XML_AUTO ) || |
| IsXMLToken( rValue, XML_FALSE ) ) |
| { |
| pFmtKeep->SetValue( sal_False ); |
| bOk = sal_True; |
| } |
| } |
| break; |
| |
| case RES_BACKGROUND: |
| { |
| SvxBrushItem* pBrush = PTR_CAST(SvxBrushItem, &rItem); |
| DBG_ASSERT( pBrush != NULL, "Wrong Which-ID" ); |
| |
| Color aTempColor; |
| switch( nMemberId ) |
| { |
| case MID_BACK_COLOR: |
| if( IsXMLToken( rValue, XML_TRANSPARENT ) ) |
| { |
| pBrush->GetColor().SetTransparency(0xff); |
| bOk = sal_True; |
| } |
| else if( rUnitConverter.convertColor( aTempColor, rValue ) ) |
| { |
| aTempColor.SetTransparency(0); |
| pBrush->SetColor( aTempColor ); |
| bOk = sal_True; |
| } |
| break; |
| |
| case MID_GRAPHIC_LINK: |
| { |
| SvxGraphicPosition eOldGraphicPos = pBrush->GetGraphicPos(); |
| uno::Any aAny; |
| aAny <<= rValue; |
| pBrush->PutValue( aAny, MID_GRAPHIC_URL ); |
| if( GPOS_NONE == eOldGraphicPos && |
| GPOS_NONE != pBrush->GetGraphicPos() ) |
| pBrush->SetGraphicPos( GPOS_TILED ); |
| bOk = sal_True ; |
| } |
| break; |
| |
| case MID_GRAPHIC_REPEAT: |
| { |
| SvxGraphicPosition eGraphicPos = pBrush->GetGraphicPos(); |
| sal_uInt16 nPos = GPOS_NONE; |
| if( rUnitConverter.convertEnum( nPos, rValue, |
| psXML_BrushRepeat ) ) |
| { |
| if( GPOS_MM != nPos || GPOS_NONE == eGraphicPos || |
| GPOS_AREA == eGraphicPos || GPOS_TILED == eGraphicPos ) |
| pBrush->SetGraphicPos( (SvxGraphicPosition)nPos ); |
| bOk = sal_True; |
| } |
| } |
| break; |
| |
| case MID_GRAPHIC_POSITION: |
| { |
| SvxGraphicPosition ePos = GPOS_NONE, eTmp; |
| sal_uInt16 nTmp; |
| SvXMLTokenEnumerator aTokenEnum( rValue ); |
| OUString aToken; |
| sal_Bool bHori = sal_False, bVert = sal_False; |
| bOk = sal_True; |
| while( bOk && aTokenEnum.getNextToken( aToken ) ) |
| { |
| if( bHori && bVert ) |
| { |
| bOk = sal_False; |
| } |
| else if( -1 != aToken.indexOf( sal_Unicode('%') ) ) |
| { |
| sal_Int32 nPrc = 50; |
| if( rUnitConverter.convertPercent( nPrc, aToken ) ) |
| { |
| if( !bHori ) |
| { |
| ePos = nPrc < 25 ? GPOS_LT : |
| (nPrc < 75 ? GPOS_MM : GPOS_RB); |
| bHori = sal_True; |
| } |
| else |
| { |
| eTmp = nPrc < 25 ? GPOS_LT: |
| (nPrc < 75 ? GPOS_LM : GPOS_LB); |
| lcl_frmitems_MergeXMLVertPos( ePos, eTmp ); |
| bVert = sal_True; |
| } |
| } |
| else |
| { |
| // wrong percentage |
| bOk = sal_False; |
| } |
| } |
| else if( IsXMLToken( aToken, XML_CENTER ) ) |
| { |
| if( bHori ) |
| lcl_frmitems_MergeXMLVertPos( ePos, GPOS_MM ); |
| else if ( bVert ) |
| lcl_frmitems_MergeXMLHoriPos( ePos, GPOS_MM ); |
| else |
| ePos = GPOS_MM; |
| } |
| else if( rUnitConverter.convertEnum( nTmp, aToken, |
| psXML_BrushHoriPos ) ) |
| { |
| if( bVert ) |
| lcl_frmitems_MergeXMLHoriPos( |
| ePos, (SvxGraphicPosition)nTmp ); |
| else if( !bHori ) |
| ePos = (SvxGraphicPosition)nTmp; |
| else |
| bOk = sal_False; |
| bHori = sal_True; |
| } |
| else if( rUnitConverter.convertEnum( nTmp, aToken, |
| psXML_BrushVertPos ) ) |
| { |
| if( bHori ) |
| lcl_frmitems_MergeXMLVertPos( |
| ePos, (SvxGraphicPosition)nTmp ); |
| else if( !bVert ) |
| ePos = (SvxGraphicPosition)nTmp; |
| else |
| bOk = sal_False; |
| bVert = sal_True; |
| } |
| else |
| { |
| bOk = sal_False; |
| } |
| } |
| |
| bOk &= GPOS_NONE != ePos; |
| if( bOk ) |
| pBrush->SetGraphicPos( ePos ); |
| } |
| break; |
| |
| case MID_GRAPHIC_FILTER: |
| pBrush->SetGraphicFilter( rValue.getStr() ); |
| bOk = sal_True; |
| break; |
| } |
| } |
| break; |
| |
| case RES_PAGEDESC: |
| { |
| SwFmtPageDesc* pPageDesc = PTR_CAST(SwFmtPageDesc, &rItem); |
| DBG_ASSERT( pPageDesc != NULL, "Wrong Which-ID" ); |
| |
| if( MID_PAGEDESC_PAGENUMOFFSET==nMemberId ) |
| { |
| sal_Int32 nVal; |
| bOk = rUnitConverter.convertNumber( nVal, rValue, 0, USHRT_MAX ); |
| if( bOk ) |
| pPageDesc->SetNumOffset( (sal_uInt16)nVal ); |
| } |
| } |
| break; |
| |
| case RES_LAYOUT_SPLIT: |
| case RES_ROW_SPLIT: |
| { |
| SfxBoolItem* pSplit = PTR_CAST(SfxBoolItem, &rItem); |
| DBG_ASSERT( pSplit != NULL, "Wrong Which-ID" ); |
| |
| if( IsXMLToken( rValue, XML_AUTO ) || |
| IsXMLToken( rValue, XML_TRUE ) ) |
| { |
| pSplit->SetValue( sal_True ); |
| bOk = sal_True; |
| } |
| else if( IsXMLToken( rValue, XML_ALWAYS ) || |
| IsXMLToken( rValue, XML_FALSE ) ) |
| { |
| pSplit->SetValue( sal_False ); |
| bOk = sal_True; |
| } |
| } |
| break; |
| |
| case RES_HORI_ORIENT: |
| { |
| SwFmtHoriOrient* pHoriOrient = PTR_CAST(SwFmtHoriOrient, &rItem); |
| DBG_ASSERT( pHoriOrient != NULL, "Wrong Which-ID" ); |
| |
| sal_uInt16 nValue; |
| bOk = rUnitConverter.convertEnum( nValue, rValue, |
| aXMLTableAlignMap ); |
| if( bOk ) |
| pHoriOrient->SetHoriOrient( nValue ); |
| } |
| break; |
| |
| case RES_VERT_ORIENT: |
| { |
| SwFmtVertOrient* pVertOrient = PTR_CAST(SwFmtVertOrient, &rItem); |
| DBG_ASSERT( pVertOrient != NULL, "Wrong Which-ID" ); |
| |
| sal_uInt16 nValue; |
| bOk = rUnitConverter.convertEnum( nValue, rValue, |
| aXMLTableVAlignMap ); |
| if( bOk ) |
| pVertOrient->SetVertOrient( nValue ); |
| //#i8855# text::VertOrientation::NONE is stored as empty string and should be applied here |
| else if(!rValue.getLength()) |
| { |
| pVertOrient->SetVertOrient( text::VertOrientation::NONE ); |
| bOk = sal_True; |
| } |
| } |
| break; |
| |
| case RES_FRM_SIZE: |
| { |
| SwFmtFrmSize* pFrmSize = PTR_CAST(SwFmtFrmSize, &rItem); |
| DBG_ASSERT( pFrmSize != NULL, "Wrong Which-ID" ); |
| |
| sal_Bool bSetHeight = sal_False; |
| sal_Bool bSetWidth = sal_False; |
| sal_Bool bSetSizeType = sal_False; |
| SwFrmSize eSizeType = ATT_VAR_SIZE; |
| sal_Int32 nMin = MINLAY; |
| |
| switch( nMemberId ) |
| { |
| case MID_FRMSIZE_REL_WIDTH: |
| { |
| sal_Int32 nValue; |
| bOk = rUnitConverter.convertPercent( nValue, rValue ); |
| if( bOk ) |
| { |
| if( nValue < 1 ) |
| nValue = 1; |
| else if( nValue > 100 ) |
| nValue = 100; |
| |
| pFrmSize->SetWidthPercent( (sal_Int8)nValue ); |
| } |
| } |
| break; |
| case MID_FRMSIZE_WIDTH: |
| bSetWidth = sal_True; |
| break; |
| case MID_FRMSIZE_MIN_HEIGHT: |
| eSizeType = ATT_MIN_SIZE; |
| bSetHeight = sal_True; |
| nMin = 1; |
| bSetSizeType = sal_True; |
| break; |
| case MID_FRMSIZE_FIX_HEIGHT: |
| eSizeType = ATT_FIX_SIZE; |
| bSetHeight = sal_True; |
| nMin = 1; |
| bSetSizeType = sal_True; |
| break; |
| case MID_FRMSIZE_COL_WIDTH: |
| eSizeType = ATT_FIX_SIZE; |
| bSetWidth = sal_True; |
| bSetSizeType = sal_True; |
| break; |
| case MID_FRMSIZE_REL_COL_WIDTH: |
| { |
| sal_Int32 nPos = rValue.indexOf( (sal_Unicode)'*' ); |
| if( -1L != nPos ) |
| { |
| OUString sNum( rValue.copy( 0L, nPos ) ); |
| sal_Int32 nValue = rValue.toInt32(); |
| if( nValue < MINLAY ) |
| nValue = MINLAY; |
| else if( nValue > USHRT_MAX ) |
| nValue = USHRT_MAX; |
| |
| pFrmSize->SetWidth( (sal_uInt16)nValue ); |
| pFrmSize->SetHeightSizeType( ATT_VAR_SIZE ); |
| bOk = sal_True; |
| } |
| } |
| break; |
| } |
| |
| sal_Int32 nValue; |
| if( bSetHeight || bSetWidth ) |
| { |
| bOk = rUnitConverter.convertMeasure( nValue, rValue, nMin, |
| USHRT_MAX ); |
| if( bOk ) |
| { |
| if( bSetWidth ) |
| pFrmSize->SetWidth( (sal_uInt16)nValue ); |
| if( bSetHeight ) |
| pFrmSize->SetHeight( (sal_uInt16)nValue ); |
| if( bSetSizeType ) |
| pFrmSize->SetHeightSizeType( eSizeType ); |
| } |
| } |
| } |
| break; |
| |
| case RES_FRAMEDIR: |
| { |
| const XMLPropertyHandler* pWritingModeHandler = |
| XMLPropertyHandlerFactory::CreatePropertyHandler( |
| XML_TYPE_TEXT_WRITING_MODE_WITH_DEFAULT ); |
| if( pWritingModeHandler != NULL ) |
| { |
| Any aAny; |
| bOk = pWritingModeHandler->importXML( rValue, aAny, |
| rUnitConverter ); |
| if( bOk ) |
| bOk = rItem.PutValue( aAny ); |
| |
| delete pWritingModeHandler; |
| } |
| } |
| break; |
| |
| case RES_COLLAPSING_BORDERS: |
| { |
| SfxBoolItem* pBorders = PTR_CAST(SfxBoolItem, &rItem); |
| DBG_ASSERT( pBorders != NULL, "Wrong Which-ID" ); |
| |
| if( IsXMLToken( rValue, XML_COLLAPSING ) ) |
| { |
| pBorders->SetValue( sal_True ); |
| bOk = sal_True; |
| } |
| else if( IsXMLToken( rValue, XML_SEPARATING ) ) |
| { |
| pBorders->SetValue( sal_False ); |
| bOk = sal_True; |
| } |
| else |
| bOk = sal_False; |
| } |
| break; |
| |
| default: |
| DBG_ERROR("Item not implemented!"); |
| break; |
| } |
| |
| return bOk; |
| } |
| |
| |
