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