1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 #include "xmlimpit.hxx"
27 #include <xmloff/xmluconv.hxx>
28 #include <svl/itempool.hxx>
29 #include <svl/poolitem.hxx>
30 #include <svl/itemset.hxx>
31 #include <xmloff/attrlist.hxx>
32 #include <xmloff/nmspmap.hxx>
33 #include <xmloff/xmlnmspe.hxx>
34 #include <editeng/xmlcnitm.hxx>
35 #include <editeng/memberids.hrc>
36
37
38 #include "hintids.hxx"
39 #include "unomid.h"
40 #include <svx/unomid.hxx>
41 #include <editeng/lrspitem.hxx>
42 #include <editeng/ulspitem.hxx>
43 #include <editeng/shaditem.hxx>
44 #include <editeng/boxitem.hxx>
45 #include <editeng/brkitem.hxx>
46 #include <editeng/keepitem.hxx>
47 #include <editeng/brshitem.hxx>
48 #include "fmtpdsc.hxx"
49 #include "fmtornt.hxx"
50 #include "fmtfsize.hxx"
51
52 #ifndef _FMTLSPLT_HXX
53 #include "fmtlsplt.hxx"
54 #endif
55 #include <xmloff/prhdlfac.hxx>
56 #include <xmloff/xmltypes.hxx>
57 #include "xmlithlp.hxx"
58 #include <com/sun/star/uno/Any.hxx>
59
60 using ::rtl::OUString;
61 using namespace ::com::sun::star;
62 using namespace ::xmloff::token;
63 using uno::Any;
64
SvXMLImportItemMapper(SvXMLItemMapEntriesRef rMapEntries,sal_uInt16 nUnknWhich)65 SvXMLImportItemMapper::SvXMLImportItemMapper(
66 SvXMLItemMapEntriesRef rMapEntries,
67 sal_uInt16 nUnknWhich ) :
68 mrMapEntries( rMapEntries ),
69 nUnknownWhich( nUnknWhich )
70 {
71 }
72
~SvXMLImportItemMapper()73 SvXMLImportItemMapper::~SvXMLImportItemMapper()
74 {
75 }
76
77 void
setMapEntries(SvXMLItemMapEntriesRef rMapEntries)78 SvXMLImportItemMapper::setMapEntries( SvXMLItemMapEntriesRef rMapEntries )
79 {
80 mrMapEntries = rMapEntries;
81 }
82
83 /** fills the given itemset with the attributes in the given list */
importXML(SfxItemSet & rSet,uno::Reference<xml::sax::XAttributeList> xAttrList,const SvXMLUnitConverter & rUnitConverter,const SvXMLNamespaceMap & rNamespaceMap)84 void SvXMLImportItemMapper::importXML( SfxItemSet& rSet,
85 uno::Reference< xml::sax::XAttributeList > xAttrList,
86 const SvXMLUnitConverter& rUnitConverter,
87 const SvXMLNamespaceMap& rNamespaceMap )
88 {
89 sal_Int16 nAttr = xAttrList->getLength();
90
91 SvXMLAttrContainerItem *pUnknownItem = 0;
92 for( sal_Int16 i=0; i < nAttr; i++ )
93 {
94 const OUString& rAttrName = xAttrList->getNameByIndex( i );
95 OUString aLocalName, aPrefix, aNamespace;
96 sal_uInt16 nPrefix =
97 rNamespaceMap.GetKeyByAttrName( rAttrName, &aPrefix, &aLocalName,
98 &aNamespace );
99 if( XML_NAMESPACE_XMLNS == nPrefix )
100 continue;
101
102 const OUString& rValue = xAttrList->getValueByIndex( i );
103
104 // find a map entry for this attribute
105 SvXMLItemMapEntry* pEntry = mrMapEntries->getByName( nPrefix, aLocalName );
106
107 if( pEntry )
108 {
109 // we have a valid map entry here, so lets use it...
110 if( 0 == (pEntry->nMemberId & (MID_SW_FLAG_NO_ITEM_IMPORT|
111 MID_SW_FLAG_ELEMENT_ITEM_IMPORT)) )
112 {
113 // first get item from itemset
114 const SfxPoolItem* pItem = 0;
115 SfxItemState eState = rSet.GetItemState( pEntry->nWhichId, sal_True,
116 &pItem );
117
118 // if its not set, try the pool
119 if(SFX_ITEM_SET != eState && SFX_WHICH_MAX > pEntry->nWhichId )
120 pItem = &rSet.GetPool()->GetDefaultItem(pEntry->nWhichId);
121
122 // do we have an item?
123 if(eState >= SFX_ITEM_DEFAULT && pItem)
124 {
125 SfxPoolItem *pNewItem = pItem->Clone();
126 sal_Bool bPut = sal_False;
127
128 if( 0 == (pEntry->nMemberId&MID_SW_FLAG_SPECIAL_ITEM_IMPORT) )
129 {
130 // bPut = pNewItem->importXML( rValue,
131 // pEntry->nMemberId & MID_SW_FLAG_MASK,
132 // rUnitConverter );
133 bPut = PutXMLValue( *pNewItem, rValue,
134 static_cast<sal_uInt16>( pEntry->nMemberId & MID_SW_FLAG_MASK ),
135 rUnitConverter );
136
137 }
138 else
139 {
140 bPut = handleSpecialItem( *pEntry, *pNewItem, rSet,
141 rValue, rUnitConverter,
142 rNamespaceMap );
143 }
144
145 if( bPut )
146 rSet.Put( *pNewItem );
147
148 delete pNewItem;
149 }
150 else
151 {
152 DBG_ERROR( "Could not get a needed item for xml import!" );
153 }
154 }
155 else if( 0 != (pEntry->nMemberId & MID_SW_FLAG_NO_ITEM_IMPORT) )
156 {
157 handleNoItem( *pEntry, rSet, rValue, rUnitConverter,
158 rNamespaceMap );
159 }
160 }
161 else if( USHRT_MAX != nUnknownWhich )
162 {
163 if( !pUnknownItem )
164 {
165 const SfxPoolItem* pItem = 0;
166 if( SFX_ITEM_SET == rSet.GetItemState( nUnknownWhich, sal_True,
167 &pItem ) )
168 {
169 SfxPoolItem *pNew = pItem->Clone();
170 pUnknownItem = PTR_CAST( SvXMLAttrContainerItem, pNew );
171 DBG_ASSERT( pUnknownItem,
172 "SvXMLAttrContainerItem expected" );
173 if( !pUnknownItem )
174 delete pNew;
175 }
176 else
177 {
178 pUnknownItem = new SvXMLAttrContainerItem( nUnknownWhich );
179 }
180 }
181 if( pUnknownItem )
182 {
183 if( XML_NAMESPACE_NONE == nPrefix )
184 pUnknownItem->AddAttr( aLocalName, rValue );
185 else
186 pUnknownItem->AddAttr( aPrefix, aNamespace, aLocalName,
187 rValue );
188 }
189 }
190 }
191
192 if( pUnknownItem )
193 {
194 rSet.Put( *pUnknownItem );
195 delete pUnknownItem;
196 }
197
198 finished(rSet, rUnitConverter);
199 }
200
201 /** this method is called for every item that has the
202 MID_SW_FLAG_SPECIAL_ITEM_IMPORT flag set */
203 sal_Bool
handleSpecialItem(const SvXMLItemMapEntry &,SfxPoolItem &,SfxItemSet &,const OUString &,const SvXMLUnitConverter &,const SvXMLNamespaceMap &)204 SvXMLImportItemMapper::handleSpecialItem( const SvXMLItemMapEntry& /*rEntry*/,
205 SfxPoolItem& /*rItem*/,
206 SfxItemSet& /*rSet*/,
207 const OUString& /*rValue*/,
208 const SvXMLUnitConverter& /*rUnitConverter*/,
209 const SvXMLNamespaceMap& /*rNamespaceMap*/ )
210 {
211 DBG_ERROR( "unsuported special item in xml import" );
212 return sal_False;
213 }
214
215 /** this method is called for every item that has the
216 MID_SW_FLAG_NO_ITEM_IMPORT flag set */
handleNoItem(const SvXMLItemMapEntry &,SfxItemSet &,const OUString &,const SvXMLUnitConverter &,const SvXMLNamespaceMap &)217 sal_Bool SvXMLImportItemMapper::handleNoItem( const SvXMLItemMapEntry& /*rEntry*/,
218 SfxItemSet& /*rSet*/,
219 const OUString& /*rValue*/,
220 const SvXMLUnitConverter& /*rUnitConverter*/,
221 const SvXMLNamespaceMap& /*rNamespaceMap*/ )
222 {
223 DBG_ERROR( "unsuported no item in xml import" );
224 return sal_False;
225 }
226
227 void
finished(SfxItemSet &,SvXMLUnitConverter const &) const228 SvXMLImportItemMapper::finished(SfxItemSet &, SvXMLUnitConverter const&) const
229 {
230 // nothing to do here
231 }
232
233
234
235 // put an XML-string value into an item
PutXMLValue(SfxPoolItem & rItem,const::rtl::OUString & rValue,sal_uInt16 nMemberId,const SvXMLUnitConverter & rUnitConverter)236 sal_Bool SvXMLImportItemMapper::PutXMLValue(
237 SfxPoolItem& rItem,
238 const ::rtl::OUString& rValue,
239 sal_uInt16 nMemberId,
240 const SvXMLUnitConverter& rUnitConverter )
241 {
242 sal_Bool bOk = sal_False;
243
244 switch (rItem.Which())
245 {
246 case RES_LR_SPACE:
247 {
248 SvxLRSpaceItem* pLRSpace = PTR_CAST(SvxLRSpaceItem, &rItem);
249 DBG_ASSERT( pLRSpace != NULL, "Wrong Which-ID!" );
250
251 switch( nMemberId )
252 {
253 case MID_L_MARGIN:
254 case MID_R_MARGIN:
255 {
256 sal_Int32 nProp = 100;
257 sal_Int32 nAbs = 0;
258
259 if( rValue.indexOf( sal_Unicode('%') ) != -1 )
260 bOk = rUnitConverter.convertPercent( nProp, rValue );
261 else
262 bOk = rUnitConverter.convertMeasure( nAbs, rValue );
263
264 if( bOk )
265 {
266 switch( nMemberId )
267 {
268 case MID_L_MARGIN:
269 pLRSpace->SetTxtLeft( (sal_Int32)nAbs, (sal_uInt16)nProp );
270 break;
271 case MID_R_MARGIN:
272 pLRSpace->SetRight( (sal_Int32)nAbs, (sal_uInt16)nProp );
273 break;
274 }
275 }
276 }
277 break;
278 case MID_FIRST_LINE_INDENT:
279 {
280 sal_Int32 nProp = 100;
281 sal_Int32 nAbs = 0;
282
283 if( rValue.indexOf( sal_Unicode('%') ) != -1 )
284 bOk = rUnitConverter.convertPercent( nProp, rValue );
285 else
286 bOk = rUnitConverter.convertMeasure( nAbs, rValue,
287 -0x7fff, 0x7fff );
288
289 pLRSpace->SetTxtFirstLineOfst( (short)nAbs, (sal_uInt16)nProp );
290 }
291
292 case MID_FIRST_AUTO:
293 {
294 sal_Bool bAutoFirst;
295 bOk = rUnitConverter.convertBool( bAutoFirst, rValue );
296 if( bOk )
297 pLRSpace->SetAutoFirst( bAutoFirst );
298 }
299 break;
300
301 default:
302 DBG_ERROR( "unknown member id!");
303 }
304 }
305 break;
306
307 case RES_UL_SPACE:
308 {
309 SvxULSpaceItem* pULSpace = PTR_CAST(SvxULSpaceItem, &rItem);
310 DBG_ASSERT( pULSpace != NULL, "Wrong Which-ID!" );
311
312 sal_Int32 nProp = 100;
313 sal_Int32 nAbs = 0;
314
315 if( rValue.indexOf( sal_Unicode('%') ) != -1 )
316 bOk = rUnitConverter.convertPercent( nProp, rValue );
317 else
318 bOk = rUnitConverter.convertMeasure( nAbs, rValue );
319
320 switch( nMemberId )
321 {
322 case MID_UP_MARGIN:
323 pULSpace->SetUpper( (sal_uInt16)nAbs, (sal_uInt16)nProp );
324 break;
325 case MID_LO_MARGIN:
326 pULSpace->SetLower( (sal_uInt16)nAbs, (sal_uInt16)nProp );
327 break;
328 default:
329 DBG_ERROR("unknown MemberId");
330 }
331 }
332 break;
333
334 case RES_SHADOW:
335 {
336 SvxShadowItem* pShadow = PTR_CAST(SvxShadowItem, &rItem);
337 DBG_ASSERT( pShadow != NULL, "Wrong Which-ID" );
338
339 sal_Bool bColorFound = sal_False;
340 sal_Bool bOffsetFound = sal_False;
341
342 SvXMLTokenEnumerator aTokenEnum( rValue );
343
344 Color aColor( 128,128, 128 );
345 pShadow->SetLocation( SVX_SHADOW_BOTTOMRIGHT );
346
347 OUString aToken;
348 while( aTokenEnum.getNextToken( aToken ) )
349 {
350 if( IsXMLToken( aToken, XML_NONE ) )
351 {
352 pShadow->SetLocation( SVX_SHADOW_NONE );
353 bOk = sal_True;
354 }
355 else if( !bColorFound && aToken.compareToAscii( "#", 1 ) == 0 )
356 {
357 bOk = rUnitConverter.convertColor( aColor, aToken );
358 if( !bOk )
359 return sal_False;
360
361 bColorFound = sal_True;
362 }
363 else if( !bOffsetFound )
364 {
365 sal_Int32 nX = 0, nY = 0;
366
367 bOk = rUnitConverter.convertMeasure( nX, aToken );
368 if( bOk && aTokenEnum.getNextToken( aToken ) )
369 bOk = rUnitConverter.convertMeasure( nY, aToken );
370
371 if( bOk )
372 {
373 if( nX < 0 )
374 {
375 if( nY < 0 )
376 {
377 pShadow->SetLocation( SVX_SHADOW_TOPLEFT );
378 }
379 else
380 {
381 pShadow->SetLocation( SVX_SHADOW_BOTTOMLEFT );
382 }
383 }
384 else
385 {
386 if( nY < 0 )
387 {
388 pShadow->SetLocation( SVX_SHADOW_TOPRIGHT );
389 }
390 else
391 {
392 pShadow->SetLocation( SVX_SHADOW_BOTTOMRIGHT );
393 }
394 }
395
396 if( nX < 0 ) nX *= -1;
397 if( nY < 0 ) nY *= -1;
398
399 pShadow->SetWidth( static_cast< sal_uInt16 >( (nX + nY) >> 1 ) );
400 }
401 }
402 }
403
404 if( bOk && ( bColorFound || bOffsetFound ) )
405 {
406 pShadow->SetColor( aColor );
407 }
408 else
409 bOk = sal_False;
410 }
411 break;
412
413 case RES_BOX:
414 {
415 SvxBoxItem* pBox = PTR_CAST(SvxBoxItem, &rItem);
416 DBG_ASSERT( pBox != NULL, "Wrong WHich-ID" );
417
418 /** copy SvxBorderLines */
419 SvxBorderLine* pTop = pBox->GetTop() == NULL ?
420 NULL : new SvxBorderLine( *pBox->GetTop() );
421 SvxBorderLine* pBottom = pBox->GetBottom() == NULL ?
422 NULL : new SvxBorderLine( *pBox->GetBottom() );
423 SvxBorderLine* pLeft = pBox->GetLeft() == NULL ?
424 NULL : new SvxBorderLine( *pBox->GetLeft() );
425 SvxBorderLine* pRight = pBox->GetRight() == NULL ?
426 NULL : new SvxBorderLine( *pBox->GetRight() );
427
428 sal_Int32 nTemp;
429
430 switch( nMemberId )
431 {
432 case ALL_BORDER_PADDING:
433 case LEFT_BORDER_PADDING:
434 case RIGHT_BORDER_PADDING:
435 case TOP_BORDER_PADDING:
436 case BOTTOM_BORDER_PADDING:
437 if(!rUnitConverter.convertMeasure( nTemp, rValue, 0, 0xffff ))
438 return sal_False;
439
440 if( nMemberId == LEFT_BORDER_PADDING ||
441 nMemberId == ALL_BORDER_PADDING )
442 pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_LEFT );
443 if( nMemberId == RIGHT_BORDER_PADDING ||
444 nMemberId == ALL_BORDER_PADDING )
445 pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_RIGHT );
446 if( nMemberId == TOP_BORDER_PADDING ||
447 nMemberId == ALL_BORDER_PADDING )
448 pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_TOP );
449 if( nMemberId == BOTTOM_BORDER_PADDING ||
450 nMemberId == ALL_BORDER_PADDING )
451 pBox->SetDistance( (sal_uInt16)nTemp, BOX_LINE_BOTTOM);
452 break;
453
454 case ALL_BORDER:
455 case LEFT_BORDER:
456 case RIGHT_BORDER:
457 case TOP_BORDER:
458 case BOTTOM_BORDER:
459 {
460 sal_Bool bHasStyle = sal_False;
461 sal_Bool bHasWidth = sal_False;
462 sal_Bool bHasColor = sal_False;
463
464 sal_uInt16 nStyle = USHRT_MAX;
465 sal_uInt16 nWidth = 0;
466 sal_uInt16 nNamedWidth = USHRT_MAX;
467
468 Color aColor( COL_BLACK );
469
470 if( !lcl_frmitems_parseXMLBorder( rValue, rUnitConverter,
471 bHasStyle, nStyle,
472 bHasWidth, nWidth, nNamedWidth,
473 bHasColor, aColor ) )
474 return sal_False;
475
476 if( TOP_BORDER == nMemberId || ALL_BORDER == nMemberId )
477 lcl_frmitems_setXMLBorder( pTop,
478 bHasStyle, nStyle,
479 bHasWidth, nWidth, nNamedWidth,
480 bHasColor, aColor );
481
482 if( BOTTOM_BORDER == nMemberId || ALL_BORDER == nMemberId )
483 lcl_frmitems_setXMLBorder( pBottom,
484 bHasStyle, nStyle,
485 bHasWidth, nWidth, nNamedWidth,
486 bHasColor, aColor );
487
488 if( LEFT_BORDER == nMemberId || ALL_BORDER == nMemberId )
489 lcl_frmitems_setXMLBorder( pLeft,
490 bHasStyle, nStyle,
491 bHasWidth, nWidth, nNamedWidth,
492 bHasColor, aColor );
493
494 if( RIGHT_BORDER == nMemberId || ALL_BORDER == nMemberId )
495 lcl_frmitems_setXMLBorder( pRight,
496 bHasStyle, nStyle,
497 bHasWidth, nWidth, nNamedWidth,
498 bHasColor, aColor );
499 }
500 break;
501 case ALL_BORDER_LINE_WIDTH:
502 case LEFT_BORDER_LINE_WIDTH:
503 case RIGHT_BORDER_LINE_WIDTH:
504 case TOP_BORDER_LINE_WIDTH:
505 case BOTTOM_BORDER_LINE_WIDTH:
506 {
507 SvXMLTokenEnumerator aTokenEnum( rValue );
508
509 sal_Int32 nInWidth, nDistance, nOutWidth;
510
511 OUString aToken;
512 if( !aTokenEnum.getNextToken( aToken ) )
513 return sal_False;
514
515 if( !rUnitConverter.convertMeasure( nInWidth, aToken,
516 DEF_LINE_WIDTH_0,
517 DEF_LINE_WIDTH_4 ) )
518 return sal_False;
519
520 if( !aTokenEnum.getNextToken( aToken ) )
521 return sal_False;
522
523 if( !rUnitConverter.convertMeasure( nDistance, aToken,
524 DEF_LINE_WIDTH_0,
525 DEF_LINE_WIDTH_4 ) )
526 return sal_False;
527
528 if( !aTokenEnum.getNextToken( aToken ) )
529 return sal_False;
530
531 if( !rUnitConverter.convertMeasure( nOutWidth, aToken,
532 DEF_LINE_WIDTH_0,
533 DEF_LINE_WIDTH_4 ) )
534 return sal_False;
535
536 // #i61946: accept line style even it's not part of our "normal" set of line styles
537 sal_uInt16 nWidth = 0;
538
539 if( TOP_BORDER_LINE_WIDTH == nMemberId ||
540 ALL_BORDER_LINE_WIDTH == nMemberId )
541 lcl_frmitems_setXMLBorder( pTop, nWidth,
542 static_cast< sal_uInt16 >( nOutWidth ),
543 static_cast< sal_uInt16 >( nInWidth ),
544 static_cast< sal_uInt16 >( nDistance ) );
545
546 if( BOTTOM_BORDER_LINE_WIDTH == nMemberId ||
547 ALL_BORDER_LINE_WIDTH == nMemberId )
548 lcl_frmitems_setXMLBorder( pBottom, nWidth,
549 static_cast< sal_uInt16 >( nOutWidth ),
550 static_cast< sal_uInt16 >( nInWidth ),
551 static_cast< sal_uInt16 >( nDistance ) );
552
553 if( LEFT_BORDER_LINE_WIDTH == nMemberId ||
554 ALL_BORDER_LINE_WIDTH == nMemberId )
555 lcl_frmitems_setXMLBorder( pLeft, nWidth,
556 static_cast< sal_uInt16 >( nOutWidth ),
557 static_cast< sal_uInt16 >( nInWidth ),
558 static_cast< sal_uInt16 >( nDistance ) );
559
560 if( RIGHT_BORDER_LINE_WIDTH == nMemberId ||
561 ALL_BORDER_LINE_WIDTH == nMemberId )
562 lcl_frmitems_setXMLBorder( pRight, nWidth,
563 static_cast< sal_uInt16 >( nOutWidth ),
564 static_cast< sal_uInt16 >( nInWidth ),
565 static_cast< sal_uInt16 >( nDistance ) );
566 }
567 break;
568 }
569
570 pBox->SetLine( pTop, BOX_LINE_TOP );
571 pBox->SetLine( pBottom, BOX_LINE_BOTTOM );
572 pBox->SetLine( pLeft, BOX_LINE_LEFT );
573 pBox->SetLine( pRight, BOX_LINE_RIGHT );
574
575 delete pTop;
576 delete pBottom;
577 delete pLeft;
578 delete pRight;
579
580 bOk = sal_True;
581 }
582 break;
583
584 case RES_BREAK:
585 {
586 SvxFmtBreakItem* pFmtBreak = PTR_CAST(SvxFmtBreakItem, &rItem);
587 DBG_ASSERT( pFmtBreak != NULL, "Wrong Which-ID" );
588
589 sal_uInt16 eEnum;
590
591 if( !rUnitConverter.convertEnum( eEnum, rValue, psXML_BreakType ) )
592 return sal_False;
593
594 if( eEnum == 0 )
595 {
596 pFmtBreak->SetValue( SVX_BREAK_NONE );
597 bOk = sal_True;
598 }
599 else
600 {
601 switch( nMemberId )
602 {
603 case MID_BREAK_BEFORE:
604 pFmtBreak->SetValue( static_cast< sal_uInt16 >((eEnum == 1) ?
605 SVX_BREAK_COLUMN_BEFORE :
606 SVX_BREAK_PAGE_BEFORE) );
607 break;
608 case MID_BREAK_AFTER:
609 pFmtBreak->SetValue( static_cast< sal_uInt16 >((eEnum == 1) ?
610 SVX_BREAK_COLUMN_AFTER :
611 SVX_BREAK_PAGE_AFTER) );
612 break;
613 }
614 bOk = sal_True;
615 }
616 }
617 break;
618
619 case RES_KEEP:
620 {
621 SvxFmtKeepItem* pFmtKeep = PTR_CAST(SvxFmtKeepItem, &rItem);
622 DBG_ASSERT( pFmtKeep != NULL, "Wrong Which-ID" );
623
624 if( IsXMLToken( rValue, XML_ALWAYS ) ||
625 IsXMLToken( rValue, XML_TRUE ) )
626 {
627 pFmtKeep->SetValue( sal_True );
628 bOk = sal_True;
629 }
630 else if( IsXMLToken( rValue, XML_AUTO ) ||
631 IsXMLToken( rValue, XML_FALSE ) )
632 {
633 pFmtKeep->SetValue( sal_False );
634 bOk = sal_True;
635 }
636 }
637 break;
638
639 case RES_BACKGROUND:
640 {
641 SvxBrushItem* pBrush = PTR_CAST(SvxBrushItem, &rItem);
642 DBG_ASSERT( pBrush != NULL, "Wrong Which-ID" );
643
644 Color aTempColor;
645 switch( nMemberId )
646 {
647 case MID_BACK_COLOR:
648 if( IsXMLToken( rValue, XML_TRANSPARENT ) )
649 {
650 pBrush->GetColor().SetTransparency(0xff);
651 bOk = sal_True;
652 }
653 else if( rUnitConverter.convertColor( aTempColor, rValue ) )
654 {
655 aTempColor.SetTransparency(0);
656 pBrush->SetColor( aTempColor );
657 bOk = sal_True;
658 }
659 break;
660
661 case MID_GRAPHIC_LINK:
662 {
663 SvxGraphicPosition eOldGraphicPos = pBrush->GetGraphicPos();
664 uno::Any aAny;
665 aAny <<= rValue;
666 pBrush->PutValue( aAny, MID_GRAPHIC_URL );
667 if( GPOS_NONE == eOldGraphicPos &&
668 GPOS_NONE != pBrush->GetGraphicPos() )
669 pBrush->SetGraphicPos( GPOS_TILED );
670 bOk = sal_True ;
671 }
672 break;
673
674 case MID_GRAPHIC_REPEAT:
675 {
676 SvxGraphicPosition eGraphicPos = pBrush->GetGraphicPos();
677 sal_uInt16 nPos = GPOS_NONE;
678 if( rUnitConverter.convertEnum( nPos, rValue,
679 psXML_BrushRepeat ) )
680 {
681 if( GPOS_MM != nPos || GPOS_NONE == eGraphicPos ||
682 GPOS_AREA == eGraphicPos || GPOS_TILED == eGraphicPos )
683 pBrush->SetGraphicPos( (SvxGraphicPosition)nPos );
684 bOk = sal_True;
685 }
686 }
687 break;
688
689 case MID_GRAPHIC_POSITION:
690 {
691 SvxGraphicPosition ePos = GPOS_NONE, eTmp;
692 sal_uInt16 nTmp;
693 SvXMLTokenEnumerator aTokenEnum( rValue );
694 OUString aToken;
695 sal_Bool bHori = sal_False, bVert = sal_False;
696 bOk = sal_True;
697 while( bOk && aTokenEnum.getNextToken( aToken ) )
698 {
699 if( bHori && bVert )
700 {
701 bOk = sal_False;
702 }
703 else if( -1 != aToken.indexOf( sal_Unicode('%') ) )
704 {
705 sal_Int32 nPrc = 50;
706 if( rUnitConverter.convertPercent( nPrc, aToken ) )
707 {
708 if( !bHori )
709 {
710 ePos = nPrc < 25 ? GPOS_LT :
711 (nPrc < 75 ? GPOS_MM : GPOS_RB);
712 bHori = sal_True;
713 }
714 else
715 {
716 eTmp = nPrc < 25 ? GPOS_LT:
717 (nPrc < 75 ? GPOS_LM : GPOS_LB);
718 lcl_frmitems_MergeXMLVertPos( ePos, eTmp );
719 bVert = sal_True;
720 }
721 }
722 else
723 {
724 // wrong percentage
725 bOk = sal_False;
726 }
727 }
728 else if( IsXMLToken( aToken, XML_CENTER ) )
729 {
730 if( bHori )
731 lcl_frmitems_MergeXMLVertPos( ePos, GPOS_MM );
732 else if ( bVert )
733 lcl_frmitems_MergeXMLHoriPos( ePos, GPOS_MM );
734 else
735 ePos = GPOS_MM;
736 }
737 else if( rUnitConverter.convertEnum( nTmp, aToken,
738 psXML_BrushHoriPos ) )
739 {
740 if( bVert )
741 lcl_frmitems_MergeXMLHoriPos(
742 ePos, (SvxGraphicPosition)nTmp );
743 else if( !bHori )
744 ePos = (SvxGraphicPosition)nTmp;
745 else
746 bOk = sal_False;
747 bHori = sal_True;
748 }
749 else if( rUnitConverter.convertEnum( nTmp, aToken,
750 psXML_BrushVertPos ) )
751 {
752 if( bHori )
753 lcl_frmitems_MergeXMLVertPos(
754 ePos, (SvxGraphicPosition)nTmp );
755 else if( !bVert )
756 ePos = (SvxGraphicPosition)nTmp;
757 else
758 bOk = sal_False;
759 bVert = sal_True;
760 }
761 else
762 {
763 bOk = sal_False;
764 }
765 }
766
767 bOk &= GPOS_NONE != ePos;
768 if( bOk )
769 pBrush->SetGraphicPos( ePos );
770 }
771 break;
772
773 case MID_GRAPHIC_FILTER:
774 pBrush->SetGraphicFilter( rValue.getStr() );
775 bOk = sal_True;
776 break;
777 }
778 }
779 break;
780
781 case RES_PAGEDESC:
782 {
783 SwFmtPageDesc* pPageDesc = PTR_CAST(SwFmtPageDesc, &rItem);
784 DBG_ASSERT( pPageDesc != NULL, "Wrong Which-ID" );
785
786 if( MID_PAGEDESC_PAGENUMOFFSET==nMemberId )
787 {
788 sal_Int32 nVal;
789 bOk = rUnitConverter.convertNumber( nVal, rValue, 0, USHRT_MAX );
790 if( bOk )
791 pPageDesc->SetNumOffset( (sal_uInt16)nVal );
792 }
793 }
794 break;
795
796 case RES_LAYOUT_SPLIT:
797 case RES_ROW_SPLIT:
798 {
799 SfxBoolItem* pSplit = PTR_CAST(SfxBoolItem, &rItem);
800 DBG_ASSERT( pSplit != NULL, "Wrong Which-ID" );
801
802 if( IsXMLToken( rValue, XML_AUTO ) ||
803 IsXMLToken( rValue, XML_TRUE ) )
804 {
805 pSplit->SetValue( sal_True );
806 bOk = sal_True;
807 }
808 else if( IsXMLToken( rValue, XML_ALWAYS ) ||
809 IsXMLToken( rValue, XML_FALSE ) )
810 {
811 pSplit->SetValue( sal_False );
812 bOk = sal_True;
813 }
814 }
815 break;
816
817 case RES_HORI_ORIENT:
818 {
819 SwFmtHoriOrient* pHoriOrient = PTR_CAST(SwFmtHoriOrient, &rItem);
820 DBG_ASSERT( pHoriOrient != NULL, "Wrong Which-ID" );
821
822 sal_uInt16 nValue;
823 bOk = rUnitConverter.convertEnum( nValue, rValue,
824 aXMLTableAlignMap );
825 if( bOk )
826 pHoriOrient->SetHoriOrient( nValue );
827 }
828 break;
829
830 case RES_VERT_ORIENT:
831 {
832 SwFmtVertOrient* pVertOrient = PTR_CAST(SwFmtVertOrient, &rItem);
833 DBG_ASSERT( pVertOrient != NULL, "Wrong Which-ID" );
834
835 sal_uInt16 nValue;
836 bOk = rUnitConverter.convertEnum( nValue, rValue,
837 aXMLTableVAlignMap );
838 if( bOk )
839 pVertOrient->SetVertOrient( nValue );
840 //#i8855# text::VertOrientation::NONE is stored as empty string and should be applied here
841 else if(!rValue.getLength())
842 {
843 pVertOrient->SetVertOrient( text::VertOrientation::NONE );
844 bOk = sal_True;
845 }
846 }
847 break;
848
849 case RES_FRM_SIZE:
850 {
851 SwFmtFrmSize* pFrmSize = PTR_CAST(SwFmtFrmSize, &rItem);
852 DBG_ASSERT( pFrmSize != NULL, "Wrong Which-ID" );
853
854 sal_Bool bSetHeight = sal_False;
855 sal_Bool bSetWidth = sal_False;
856 sal_Bool bSetSizeType = sal_False;
857 SwFrmSize eSizeType = ATT_VAR_SIZE;
858 sal_Int32 nMin = MINLAY;
859
860 switch( nMemberId )
861 {
862 case MID_FRMSIZE_REL_WIDTH:
863 {
864 sal_Int32 nValue;
865 bOk = rUnitConverter.convertPercent( nValue, rValue );
866 if( bOk )
867 {
868 if( nValue < 1 )
869 nValue = 1;
870 else if( nValue > 100 )
871 nValue = 100;
872
873 pFrmSize->SetWidthPercent( (sal_Int8)nValue );
874 }
875 }
876 break;
877 case MID_FRMSIZE_WIDTH:
878 bSetWidth = sal_True;
879 break;
880 case MID_FRMSIZE_MIN_HEIGHT:
881 eSizeType = ATT_MIN_SIZE;
882 bSetHeight = sal_True;
883 nMin = 1;
884 bSetSizeType = sal_True;
885 break;
886 case MID_FRMSIZE_FIX_HEIGHT:
887 eSizeType = ATT_FIX_SIZE;
888 bSetHeight = sal_True;
889 nMin = 1;
890 bSetSizeType = sal_True;
891 break;
892 case MID_FRMSIZE_COL_WIDTH:
893 eSizeType = ATT_FIX_SIZE;
894 bSetWidth = sal_True;
895 bSetSizeType = sal_True;
896 break;
897 case MID_FRMSIZE_REL_COL_WIDTH:
898 {
899 sal_Int32 nPos = rValue.indexOf( (sal_Unicode)'*' );
900 if( -1L != nPos )
901 {
902 OUString sNum( rValue.copy( 0L, nPos ) );
903 sal_Int32 nValue = rValue.toInt32();
904 if( nValue < MINLAY )
905 nValue = MINLAY;
906 else if( nValue > USHRT_MAX )
907 nValue = USHRT_MAX;
908
909 pFrmSize->SetWidth( (sal_uInt16)nValue );
910 pFrmSize->SetHeightSizeType( ATT_VAR_SIZE );
911 bOk = sal_True;
912 }
913 }
914 break;
915 }
916
917 sal_Int32 nValue;
918 if( bSetHeight || bSetWidth )
919 {
920 bOk = rUnitConverter.convertMeasure( nValue, rValue, nMin,
921 USHRT_MAX );
922 if( bOk )
923 {
924 if( bSetWidth )
925 pFrmSize->SetWidth( (sal_uInt16)nValue );
926 if( bSetHeight )
927 pFrmSize->SetHeight( (sal_uInt16)nValue );
928 if( bSetSizeType )
929 pFrmSize->SetHeightSizeType( eSizeType );
930 }
931 }
932 }
933 break;
934
935 case RES_FRAMEDIR:
936 {
937 const XMLPropertyHandler* pWritingModeHandler =
938 XMLPropertyHandlerFactory::CreatePropertyHandler(
939 XML_TYPE_TEXT_WRITING_MODE_WITH_DEFAULT );
940 if( pWritingModeHandler != NULL )
941 {
942 Any aAny;
943 bOk = pWritingModeHandler->importXML( rValue, aAny,
944 rUnitConverter );
945 if( bOk )
946 bOk = rItem.PutValue( aAny );
947
948 delete pWritingModeHandler;
949 }
950 }
951 break;
952
953 case RES_COLLAPSING_BORDERS:
954 {
955 SfxBoolItem* pBorders = PTR_CAST(SfxBoolItem, &rItem);
956 DBG_ASSERT( pBorders != NULL, "Wrong Which-ID" );
957
958 if( IsXMLToken( rValue, XML_COLLAPSING ) )
959 {
960 pBorders->SetValue( sal_True );
961 bOk = sal_True;
962 }
963 else if( IsXMLToken( rValue, XML_SEPARATING ) )
964 {
965 pBorders->SetValue( sal_False );
966 bOk = sal_True;
967 }
968 else
969 bOk = sal_False;
970 }
971 break;
972
973 default:
974 DBG_ERROR("Item not implemented!");
975 break;
976 }
977
978 return bOk;
979 }
980
981
982