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