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