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 "xmlexpit.hxx"
21 :
22 : #include <rtl/ustrbuf.hxx>
23 : #include <sax/tools/converter.hxx>
24 : #include <svl/itempool.hxx>
25 : #include <svl/poolitem.hxx>
26 : #include <svl/itemset.hxx>
27 : #include <xmloff/xmluconv.hxx>
28 : #include <xmloff/attrlist.hxx>
29 : #include <xmloff/nmspmap.hxx>
30 : #include <xmloff/xmlnmspe.hxx>
31 : #include <editeng/xmlcnitm.hxx>
32 : #include <xmloff/xmlexp.hxx>
33 : #include <editeng/memberids.hrc>
34 : #include "hintids.hxx"
35 : #include "unomid.h"
36 : #include <svx/unomid.hxx>
37 : #include <editeng/lrspitem.hxx>
38 : #include <editeng/ulspitem.hxx>
39 : #include <editeng/shaditem.hxx>
40 : #include <editeng/boxitem.hxx>
41 : #include <editeng/formatbreakitem.hxx>
42 : #include <editeng/keepitem.hxx>
43 : #include <editeng/brushitem.hxx>
44 : #include "fmtpdsc.hxx"
45 : #include "fmtornt.hxx"
46 : #include "fmtfsize.hxx"
47 :
48 : #include "fmtlsplt.hxx"
49 : #include "xmlithlp.hxx"
50 :
51 : #include "fmtrowsplt.hxx"
52 :
53 :
54 : using ::editeng::SvxBorderLine;
55 : using namespace ::com::sun::star;
56 : using namespace ::xmloff::token;
57 : using uno::Any;
58 :
59 : /** fills the given attribute list with the items in the given set */
60 0 : void SvXMLExportItemMapper::exportXML( const SvXMLExport& rExport,
61 : SvXMLAttributeList& rAttrList,
62 : const SfxItemSet& rSet,
63 : const SvXMLUnitConverter& rUnitConverter,
64 : const SvXMLNamespaceMap& rNamespaceMap,
65 : sal_uInt16 nFlags,
66 : std::vector<sal_uInt16> *pIndexArray ) const
67 : {
68 0 : const sal_uInt16 nCount = mrMapEntries->getCount();
69 0 : sal_uInt16 nIndex = 0;
70 :
71 0 : while( nIndex < nCount )
72 : {
73 0 : SvXMLItemMapEntry* pEntry = mrMapEntries->getByIndex( nIndex );
74 :
75 : // we have a valid map entry here, so lets use it...
76 0 : if( 0 == (pEntry->nMemberId & MID_SW_FLAG_NO_ITEM_EXPORT) )
77 : {
78 : const SfxPoolItem* pItem = GetItem( rSet, pEntry->nWhichId,
79 0 : nFlags );
80 : // do we have an item?
81 0 : if(pItem)
82 : {
83 0 : if( 0 != (pEntry->nMemberId & MID_SW_FLAG_ELEMENT_ITEM_EXPORT) )
84 : {
85 : // element items do not add any properties,
86 : // we export it later
87 0 : if( pIndexArray )
88 0 : pIndexArray->push_back( nIndex );
89 :
90 : }
91 : else
92 : {
93 : exportXML( rExport, rAttrList, *pItem, *pEntry, rUnitConverter,
94 0 : rNamespaceMap, nFlags, &rSet );
95 : }
96 : }
97 : }
98 : else
99 : {
100 : handleNoItem( rAttrList, *pEntry, rUnitConverter, rNamespaceMap,
101 0 : rSet );
102 : }
103 0 : nIndex++;
104 : }
105 0 : }
106 :
107 0 : void SvXMLExportItemMapper::exportXML( const SvXMLExport& rExport,
108 : SvXMLAttributeList& rAttrList,
109 : const SfxPoolItem& rItem,
110 : const SvXMLItemMapEntry& rEntry,
111 : const SvXMLUnitConverter& rUnitConverter,
112 : const SvXMLNamespaceMap& rNamespaceMap,
113 : sal_uInt16 /*nFlags*/,
114 : const SfxItemSet *pSet ) const
115 : {
116 0 : if( 0 != (rEntry.nMemberId & MID_SW_FLAG_SPECIAL_ITEM_EXPORT) )
117 : {
118 0 : if( rItem.ISA( SwFmtRowSplit ) )
119 : {
120 0 : OUString aValue;
121 0 : bool bAddAttribute = true;
122 0 : if( rEntry.nNameSpace == XML_NAMESPACE_STYLE )
123 : {
124 0 : if( (rExport.getExportFlags() & EXPORT_SAVEBACKWARDCOMPATIBLE ) == 0 ||
125 : !QueryXMLValue(rItem, aValue,
126 : static_cast< sal_uInt16 >( rEntry.nMemberId & MID_SW_FLAG_MASK ),
127 0 : rUnitConverter ) )
128 : {
129 0 : bAddAttribute = false;
130 : }
131 : }
132 : else
133 : {
134 0 : OUStringBuffer aOut;
135 0 : const SfxBoolItem* pSplit = PTR_CAST(SfxBoolItem, &rItem);
136 : OSL_ENSURE( pSplit != NULL, "Wrong Which-ID" );
137 0 : sal_uInt16 eEnum = pSplit->GetValue() ? 1 : 0;
138 0 : rUnitConverter.convertEnum( aOut, eEnum, aXML_KeepTogetherType );
139 0 : aValue = aOut.makeStringAndClear();
140 : }
141 0 : if( bAddAttribute )
142 : {
143 : OUString sName( rNamespaceMap.GetQNameByKey( rEntry.nNameSpace,
144 0 : GetXMLToken(rEntry.eLocalName) ) );
145 0 : rAttrList.AddAttribute( sName, aValue );
146 0 : }
147 : }
148 0 : if( rItem.ISA( SvXMLAttrContainerItem ) )
149 : {
150 0 : SvXMLNamespaceMap *pNewNamespaceMap = 0;
151 0 : const SvXMLNamespaceMap *pNamespaceMap = &rNamespaceMap;
152 :
153 : const SvXMLAttrContainerItem *pUnknown =
154 0 : PTR_CAST( SvXMLAttrContainerItem, &rItem );
155 :
156 0 : sal_uInt16 nCount = pUnknown->GetAttrCount();
157 0 : OUStringBuffer sName;
158 0 : for( sal_uInt16 i=0; i < nCount; i++ )
159 : {
160 0 : OUString sPrefix( pUnknown->GetAttrPrefix( i ) );
161 0 : if( !sPrefix.isEmpty() )
162 : {
163 0 : OUString sNamespace( pUnknown->GetAttrNamespace( i ) );
164 :
165 : // if the prefix isn't defined yet or has another meaning,
166 : // we have to redefine it now.
167 0 : sal_uInt16 nIdx = pNamespaceMap->GetIndexByPrefix( sPrefix );
168 0 : if( USHRT_MAX == nIdx ||
169 0 : pNamespaceMap->GetNameByIndex( nIdx ) != sNamespace )
170 : {
171 0 : if( !pNewNamespaceMap )
172 : {
173 : pNewNamespaceMap =
174 0 : new SvXMLNamespaceMap( rNamespaceMap );
175 0 : pNamespaceMap = pNewNamespaceMap;
176 : }
177 0 : pNewNamespaceMap->Add( sPrefix, sNamespace );
178 :
179 0 : sName.append( GetXMLToken(XML_XMLNS) );
180 0 : sName.append( sal_Unicode(':') );
181 0 : sName.append( sPrefix );
182 : rAttrList.AddAttribute( sName.makeStringAndClear(),
183 0 : sNamespace );
184 : }
185 :
186 0 : sName.append( sPrefix );
187 0 : sName.append( sal_Unicode(':') );
188 : }
189 :
190 0 : sName.append( pUnknown->GetAttrLName( i ) );
191 : rAttrList.AddAttribute( sName.makeStringAndClear(),
192 0 : pUnknown->GetAttrValue(i) );
193 0 : }
194 :
195 0 : delete pNewNamespaceMap;
196 : }
197 : else
198 : {
199 : handleSpecialItem( rAttrList, rEntry, rItem, rUnitConverter,
200 0 : rNamespaceMap, pSet );
201 : }
202 : }
203 0 : else if( 0 == (rEntry.nMemberId & MID_SW_FLAG_ELEMENT_ITEM_EXPORT) )
204 : {
205 0 : OUString aValue;
206 0 : if( QueryXMLValue(rItem, aValue,
207 : static_cast< sal_uInt16 >(
208 : rEntry.nMemberId & MID_SW_FLAG_MASK ),
209 0 : rUnitConverter ) )
210 : {
211 : OUString sName(
212 : rNamespaceMap.GetQNameByKey( rEntry.nNameSpace,
213 0 : GetXMLToken(rEntry.eLocalName)));
214 0 : rAttrList.AddAttribute( sName, aValue );
215 0 : }
216 : }
217 0 : }
218 :
219 0 : void SvXMLExportItemMapper::exportElementItems(
220 : SvXMLExport& rExport,
221 : const SvXMLUnitConverter& rUnitConverter,
222 : const SfxItemSet &rSet,
223 : sal_uInt16 nFlags,
224 : const std::vector<sal_uInt16> &rIndexArray ) const
225 : {
226 0 : const sal_uInt16 nCount = rIndexArray.size();
227 :
228 0 : bool bItemsExported = false;
229 0 : for( sal_uInt16 nIndex = 0; nIndex < nCount; nIndex++ )
230 : {
231 0 : const sal_uInt16 nElement = rIndexArray[ nIndex ];
232 0 : SvXMLItemMapEntry* pEntry = mrMapEntries->getByIndex( nElement );
233 : OSL_ENSURE( 0 != (pEntry->nMemberId & MID_SW_FLAG_ELEMENT_ITEM_EXPORT),
234 : "wrong mid flag!" );
235 :
236 0 : const SfxPoolItem* pItem = GetItem( rSet, pEntry->nWhichId, nFlags );
237 : // do we have an item?
238 0 : if(pItem)
239 : {
240 0 : rExport.IgnorableWhitespace();
241 : handleElementItem( rExport, *pEntry, *pItem, rUnitConverter,
242 0 : rSet, nFlags);
243 0 : bItemsExported = true;
244 : }
245 : }
246 :
247 0 : if( bItemsExported )
248 0 : rExport.IgnorableWhitespace();
249 0 : }
250 :
251 : /** returns the item with the givin WhichId from the given ItemSet if its
252 : set or its default item if its not set and the XML_EXPORT_FLAG_DEEP
253 : is set in the flags
254 : */
255 0 : const SfxPoolItem* SvXMLExportItemMapper::GetItem( const SfxItemSet& rSet,
256 : sal_uInt16 nWhichId,
257 : sal_uInt16 nFlags )
258 : {
259 : // first get item from itemset
260 : const SfxPoolItem* pItem;
261 : SfxItemState eState =
262 : rSet.GetItemState( nWhichId,
263 0 : ( nFlags & XML_EXPORT_FLAG_DEEP ) != 0,
264 0 : &pItem );
265 :
266 0 : if( SFX_ITEM_SET == eState )
267 : {
268 0 : return pItem;
269 : }
270 0 : else if( (nFlags & XML_EXPORT_FLAG_DEFAULTS) != 0 &&
271 : SFX_WHICH_MAX > nWhichId )
272 : {
273 : // if its not set, try the pool if we export defaults
274 0 : return &rSet.GetPool()->GetDefaultItem(nWhichId);
275 : }
276 : else
277 : {
278 0 : return NULL;
279 : }
280 : }
281 :
282 68 : SvXMLExportItemMapper::SvXMLExportItemMapper( SvXMLItemMapEntriesRef rMapEntries )
283 : {
284 68 : mrMapEntries = rMapEntries;
285 68 : }
286 :
287 68 : SvXMLExportItemMapper::~SvXMLExportItemMapper()
288 : {
289 68 : }
290 :
291 0 : void SvXMLExportItemMapper::exportXML( SvXMLExport& rExport,
292 : const SfxItemSet& rSet,
293 : const SvXMLUnitConverter& rUnitConverter,
294 : XMLTokenEnum ePropToken,
295 : sal_uInt16 nFlags ) const
296 : {
297 0 : std::vector<sal_uInt16> aIndexArray;
298 :
299 0 : exportXML( rExport, rExport.GetAttrList(), rSet, rUnitConverter,
300 0 : rExport.GetNamespaceMap(), nFlags, &aIndexArray );
301 :
302 0 : if( rExport.GetAttrList().getLength() > 0L ||
303 0 : (nFlags & XML_EXPORT_FLAG_EMPTY) != 0 ||
304 0 : !aIndexArray.empty() )
305 : {
306 0 : if( (nFlags & XML_EXPORT_FLAG_IGN_WS) != 0 )
307 : {
308 0 : rExport.IgnorableWhitespace();
309 : }
310 :
311 : SvXMLElementExport aElem( rExport, XML_NAMESPACE_STYLE, ePropToken,
312 0 : sal_False, sal_False );
313 : exportElementItems( rExport, rUnitConverter,
314 0 : rSet, nFlags, aIndexArray );
315 0 : }
316 0 : }
317 :
318 : /** this method is called for every item that has the
319 : MID_SW_FLAG_SPECIAL_ITEM_EXPORT flag set */
320 0 : void SvXMLExportItemMapper::handleSpecialItem( SvXMLAttributeList& /*rAttrList*/,
321 : const SvXMLItemMapEntry& /*rEntry*/,
322 : const SfxPoolItem& /*rItem*/,
323 : const SvXMLUnitConverter& /*rUnitConverter*/,
324 : const SvXMLNamespaceMap& /*rNamespaceMap*/,
325 : const SfxItemSet* /*pSet*/ /* = NULL */ ) const
326 : {
327 : OSL_FAIL( "special item not handled in xml export" );
328 0 : }
329 :
330 : /** this method is called for every item that has the
331 : MID_SW_FLAG_NO_ITEM_EXPORT flag set */
332 0 : void SvXMLExportItemMapper::handleNoItem( SvXMLAttributeList& /*rAttrList*/,
333 : const SvXMLItemMapEntry& /*rEntry*/,
334 : const SvXMLUnitConverter& /*rUnitConverter*/,
335 : const SvXMLNamespaceMap& /*rNamespaceMap*/,
336 : const SfxItemSet& /*rSet*/ ) const
337 : {
338 : OSL_FAIL( "no item not handled in xml export" );
339 0 : }
340 :
341 : /** this method is called for every item that has the
342 : MID_SW_FLAG_ELEMENT_EXPORT flag set */
343 0 : void SvXMLExportItemMapper::handleElementItem(
344 : SvXMLExport& /*rExport*/,
345 : const SvXMLItemMapEntry& /*rEntry*/,
346 : const SfxPoolItem& /*rItem*/,
347 : const SvXMLUnitConverter& /*rUnitConverter*/,
348 : const SfxItemSet& /*rSet*/,
349 : sal_uInt16 /*nFlags*/ ) const
350 : {
351 : OSL_FAIL( "element item not handled in xml export" );
352 0 : }
353 :
354 0 : static bool lcl_isOdfDoubleLine( const SvxBorderLine* pLine )
355 : {
356 0 : bool bIsOdfDouble = false;
357 0 : switch (pLine->GetBorderLineStyle())
358 : {
359 : case table::BorderLineStyle::DOUBLE:
360 : case table::BorderLineStyle::THINTHICK_SMALLGAP:
361 : case table::BorderLineStyle::THINTHICK_MEDIUMGAP:
362 : case table::BorderLineStyle::THINTHICK_LARGEGAP:
363 : case table::BorderLineStyle::THICKTHIN_SMALLGAP:
364 : case table::BorderLineStyle::THICKTHIN_MEDIUMGAP:
365 : case table::BorderLineStyle::THICKTHIN_LARGEGAP:
366 0 : bIsOdfDouble = true;
367 0 : break;
368 : default:
369 0 : break;
370 : }
371 0 : return bIsOdfDouble;
372 : }
373 :
374 0 : bool SvXMLExportItemMapper::QueryXMLValue(
375 : const SfxPoolItem& rItem,
376 : OUString& rValue,
377 : sal_uInt16 nMemberId,
378 : const SvXMLUnitConverter& rUnitConverter )
379 : {
380 0 : bool bOk = false;
381 0 : OUStringBuffer aOut;
382 :
383 0 : switch ( rItem.Which() )
384 : {
385 :
386 : case RES_LR_SPACE:
387 : {
388 0 : const SvxLRSpaceItem* pLRSpace = PTR_CAST(SvxLRSpaceItem, &rItem);
389 : OSL_ENSURE( pLRSpace != NULL, "Wrong Which-ID!" );
390 :
391 0 : bOk = true;
392 0 : switch( nMemberId )
393 : {
394 : case MID_L_MARGIN:
395 0 : if(pLRSpace->GetPropLeft() != 100)
396 : {
397 : ::sax::Converter::convertPercent(
398 0 : aOut, pLRSpace->GetPropLeft() );
399 : }
400 : else
401 : {
402 : rUnitConverter.convertMeasureToXML(
403 0 : aOut, pLRSpace->GetLeft() );
404 : }
405 0 : break;
406 :
407 : case MID_R_MARGIN:
408 0 : if(pLRSpace->GetPropRight() != 100)
409 : {
410 : ::sax::Converter::convertPercent(
411 0 : aOut, pLRSpace->GetPropRight() );
412 : }
413 : else
414 : {
415 : rUnitConverter.convertMeasureToXML(
416 0 : aOut, pLRSpace->GetRight() );
417 : }
418 0 : break;
419 :
420 : case MID_FIRST_AUTO:
421 0 : if( pLRSpace->IsAutoFirst() )
422 : {
423 : ::sax::Converter::convertBool(
424 0 : aOut, pLRSpace->IsAutoFirst() );
425 : }
426 : else
427 0 : bOk = false;
428 0 : break;
429 :
430 : case MID_FIRST_LINE_INDENT:
431 0 : if( !pLRSpace->IsAutoFirst() )
432 : {
433 0 : if(pLRSpace->GetPropTxtFirstLineOfst() != 100)
434 : {
435 : ::sax::Converter::convertPercent(
436 0 : aOut, pLRSpace->GetPropTxtFirstLineOfst() );
437 : }
438 : else
439 : {
440 : rUnitConverter.convertMeasureToXML(
441 0 : aOut, pLRSpace->GetTxtFirstLineOfst() );
442 : }
443 : }
444 : else
445 0 : bOk = false;
446 0 : break;
447 :
448 : default:
449 : OSL_FAIL( "unknown member id!");
450 0 : bOk = false;
451 0 : break;
452 : }
453 : }
454 0 : break;
455 :
456 : case RES_UL_SPACE:
457 : {
458 0 : const SvxULSpaceItem* pULSpace = PTR_CAST(SvxULSpaceItem, &rItem);
459 : OSL_ENSURE( pULSpace != NULL, "Wrong Which-ID!" );
460 :
461 0 : switch( nMemberId )
462 : {
463 : case MID_UP_MARGIN:
464 0 : if( pULSpace->GetPropUpper() != 100 )
465 : {
466 : ::sax::Converter::convertPercent(
467 0 : aOut, pULSpace->GetPropUpper() );
468 : }
469 : else
470 : {
471 : rUnitConverter.convertMeasureToXML(
472 0 : aOut, pULSpace->GetUpper() );
473 : }
474 0 : break;
475 :
476 : case MID_LO_MARGIN:
477 0 : if( pULSpace->GetPropLower() != 100 )
478 : {
479 : ::sax::Converter::convertPercent(
480 0 : aOut, pULSpace->GetPropLower() );
481 : }
482 : else
483 : {
484 : rUnitConverter.convertMeasureToXML(
485 0 : aOut, pULSpace->GetLower() );
486 : }
487 0 : break;
488 :
489 : default:
490 : OSL_FAIL("unknown MemberId");
491 : };
492 :
493 0 : bOk = true;
494 : }
495 0 : break;
496 :
497 : case RES_SHADOW:
498 : {
499 0 : const SvxShadowItem* pShadow = PTR_CAST(SvxShadowItem, &rItem);
500 : OSL_ENSURE( pShadow != NULL, "Wrong Which-ID" );
501 :
502 0 : sal_Int32 nX = 1, nY = 1;
503 0 : switch( pShadow->GetLocation() )
504 : {
505 : case SVX_SHADOW_TOPLEFT:
506 0 : nX = -1;
507 0 : nY = -1;
508 0 : break;
509 : case SVX_SHADOW_TOPRIGHT:
510 0 : nY = -1;
511 0 : break;
512 : case SVX_SHADOW_BOTTOMLEFT:
513 0 : nX = -1;
514 0 : break;
515 : case SVX_SHADOW_BOTTOMRIGHT:
516 0 : break;
517 : case SVX_SHADOW_NONE:
518 : default:
519 0 : rValue = GetXMLToken(XML_NONE);
520 0 : return true;
521 : }
522 :
523 0 : nX *= pShadow->GetWidth();
524 0 : nY *= pShadow->GetWidth();
525 :
526 0 : ::sax::Converter::convertColor(aOut, pShadow->GetColor().GetColor());
527 0 : aOut.append( sal_Unicode(' ') );
528 0 : rUnitConverter.convertMeasureToXML( aOut, nX );
529 0 : aOut.append( sal_Unicode(' ') );
530 0 : rUnitConverter.convertMeasureToXML( aOut, nY );
531 :
532 0 : bOk = true;
533 : }
534 0 : break;
535 :
536 : case RES_BOX:
537 : {
538 0 : SvxBoxItem* pBox = PTR_CAST(SvxBoxItem, &rItem);
539 : OSL_ENSURE( pBox != NULL, "Wrong WHich-ID" );
540 :
541 : /**
542 : xml -> MemberId
543 :
544 : border-padding ALL_BORDER_PADDING
545 : border-padding-before LEFT_BORDER_PADDING
546 : border-padding-after RIGHT_BORDER_PADDING
547 : border-padding-start TOP_BORDER_PADDING
548 : border-padding-end BOTTOM_BORDER_PADDING
549 :
550 : border ALL_BORDER
551 : border-before LEFT_BORDER
552 : border-after RIGHT_BORDER
553 : border-start TOP_BORDER
554 : border-end BOTTOM_BORDER
555 :
556 : border-line-width ALL_BORDER_LINE_WIDTH
557 : border-line-width-before LEFT_BORDER_LINE_WIDTH
558 : border-line-width-after RIGHT_BORDER_LINE_WIDTH
559 : border-line-width-start TOP_BORDER_LINE_WIDTH
560 : border-line-width-end BOTTOM_BORDER_LINE_WIDTH
561 : */
562 :
563 0 : const SvxBorderLine* pLeft = pBox->GetLeft();
564 0 : const SvxBorderLine* pRight = pBox->GetRight();
565 0 : const SvxBorderLine* pTop = pBox->GetTop();
566 0 : const SvxBorderLine* pBottom = pBox->GetBottom();
567 0 : sal_uInt16 nTopDist = pBox->GetDistance( BOX_LINE_TOP );
568 0 : sal_uInt16 nBottomDist = pBox->GetDistance( BOX_LINE_BOTTOM );
569 0 : sal_uInt16 nLeftDist = pBox->GetDistance( BOX_LINE_LEFT );
570 0 : sal_uInt16 nRightDist = pBox->GetDistance( BOX_LINE_RIGHT );
571 :
572 :
573 : // check if we need to export it
574 0 : switch( nMemberId )
575 : {
576 : case ALL_BORDER_PADDING:
577 : case LEFT_BORDER_PADDING:
578 : case RIGHT_BORDER_PADDING:
579 : case TOP_BORDER_PADDING:
580 : case BOTTOM_BORDER_PADDING:
581 : {
582 0 : bool bEqual = nLeftDist == nRightDist &&
583 0 : nLeftDist == nTopDist &&
584 0 : nLeftDist == nBottomDist;
585 : // don't export individual paddings if all paddings are equal and
586 : // don't export all padding if some paddings are not equal
587 0 : if( (bEqual && ALL_BORDER_PADDING != nMemberId) ||
588 0 : (!bEqual && ALL_BORDER_PADDING == nMemberId) )
589 0 : return false;
590 : }
591 0 : break;
592 : case ALL_BORDER:
593 : case LEFT_BORDER:
594 : case RIGHT_BORDER:
595 : case TOP_BORDER:
596 : case BOTTOM_BORDER:
597 : {
598 0 : bool bEqual = ( NULL == pTop && NULL == pBottom &&
599 0 : NULL == pLeft && NULL == pRight ) ||
600 0 : ( pTop && pBottom && pLeft && pRight &&
601 0 : *pTop == *pBottom && *pTop == *pLeft &&
602 0 : *pTop == *pRight );
603 :
604 : // don't export individual borders if all are the same and
605 : // don't export all borders if some are not equal
606 0 : if( (bEqual && ALL_BORDER != nMemberId) ||
607 0 : (!bEqual && ALL_BORDER == nMemberId) )
608 0 : return false;
609 : }
610 0 : break;
611 : case ALL_BORDER_LINE_WIDTH:
612 : case LEFT_BORDER_LINE_WIDTH:
613 : case RIGHT_BORDER_LINE_WIDTH:
614 : case TOP_BORDER_LINE_WIDTH:
615 : case BOTTOM_BORDER_LINE_WIDTH:
616 : {
617 : // if no line is set, there is nothing to export
618 0 : if( !pTop && !pBottom && !pLeft && !pRight )
619 0 : return false;
620 :
621 0 : bool bEqual = NULL != pTop &&
622 0 : NULL != pBottom &&
623 0 : NULL != pLeft &&
624 0 : NULL != pRight;
625 :
626 0 : if( bEqual )
627 : {
628 0 : const sal_uInt16 nDistance = pTop->GetDistance();
629 0 : const sal_uInt16 nInWidth = pTop->GetInWidth();
630 0 : const sal_uInt16 nOutWidth = pTop->GetOutWidth();
631 0 : const sal_uInt16 nWidth = pTop->GetWidth();
632 :
633 0 : bEqual = nDistance == pLeft->GetDistance() &&
634 0 : nInWidth == pLeft->GetInWidth() &&
635 0 : nOutWidth == pLeft->GetOutWidth() &&
636 0 : nWidth == pLeft->GetWidth() &&
637 0 : nDistance == pRight->GetDistance() &&
638 0 : nInWidth == pRight->GetInWidth() &&
639 0 : nOutWidth == pRight->GetOutWidth() &&
640 0 : nWidth == pRight->GetWidth() &&
641 0 : nDistance == pBottom->GetDistance() &&
642 0 : nInWidth == pBottom->GetInWidth() &&
643 0 : nOutWidth == pBottom->GetOutWidth() &&
644 0 : nWidth == pBottom->GetWidth();
645 : }
646 :
647 0 : switch( nMemberId )
648 : {
649 : case ALL_BORDER_LINE_WIDTH:
650 0 : if( !bEqual || pTop->GetDistance() == 0 ||
651 0 : !lcl_isOdfDoubleLine( pTop ) )
652 0 : return false;
653 0 : break;
654 : case LEFT_BORDER_LINE_WIDTH:
655 0 : if( bEqual || NULL == pLeft ||
656 0 : 0 == pLeft->GetDistance() ||
657 0 : !lcl_isOdfDoubleLine( pLeft ) )
658 0 : return false;
659 0 : break;
660 : case RIGHT_BORDER_LINE_WIDTH:
661 0 : if( bEqual || NULL == pRight ||
662 0 : 0 == pRight->GetDistance() ||
663 0 : !lcl_isOdfDoubleLine( pRight ) )
664 0 : return false;
665 0 : break;
666 : case TOP_BORDER_LINE_WIDTH:
667 0 : if( bEqual || NULL == pTop ||
668 0 : 0 == pTop->GetDistance() ||
669 0 : !lcl_isOdfDoubleLine( pTop ) )
670 0 : return false;
671 0 : break;
672 : case BOTTOM_BORDER_LINE_WIDTH:
673 0 : if( bEqual || NULL == pBottom ||
674 0 : 0 == pBottom->GetDistance() ||
675 0 : !lcl_isOdfDoubleLine( pBottom ) )
676 0 : return false;
677 0 : break;
678 : }
679 : }
680 0 : break;
681 : }
682 :
683 : // now export it export
684 0 : switch( nMemberId )
685 : {
686 : // padding
687 : case ALL_BORDER_PADDING:
688 : case LEFT_BORDER_PADDING:
689 0 : rUnitConverter.convertMeasureToXML( aOut, nLeftDist );
690 0 : break;
691 : case RIGHT_BORDER_PADDING:
692 0 : rUnitConverter.convertMeasureToXML( aOut, nRightDist );
693 0 : break;
694 : case TOP_BORDER_PADDING:
695 0 : rUnitConverter.convertMeasureToXML( aOut, nTopDist );
696 0 : break;
697 : case BOTTOM_BORDER_PADDING:
698 0 : rUnitConverter.convertMeasureToXML( aOut, nBottomDist );
699 0 : break;
700 :
701 : // border
702 : case ALL_BORDER:
703 : case LEFT_BORDER:
704 : case RIGHT_BORDER:
705 : case TOP_BORDER:
706 : case BOTTOM_BORDER:
707 : {
708 : const SvxBorderLine* pLine;
709 0 : switch( nMemberId )
710 : {
711 : case ALL_BORDER:
712 : case LEFT_BORDER:
713 0 : pLine = pLeft;
714 0 : break;
715 : case RIGHT_BORDER:
716 0 : pLine = pRight;
717 0 : break;
718 : case TOP_BORDER:
719 0 : pLine = pTop;
720 0 : break;
721 : case BOTTOM_BORDER:
722 0 : pLine = pBottom;
723 0 : break;
724 : default:
725 0 : pLine = NULL;
726 0 : break;
727 : }
728 :
729 0 : if( NULL != pLine )
730 : {
731 0 : sal_Int32 nWidth = pLine->GetWidth();
732 :
733 0 : enum XMLTokenEnum eStyle = XML_SOLID;
734 0 : bool bNoBorder = false;
735 0 : switch (pLine->GetBorderLineStyle())
736 : {
737 : case table::BorderLineStyle::SOLID:
738 0 : eStyle = XML_SOLID;
739 0 : break;
740 : case table::BorderLineStyle::DOTTED:
741 0 : eStyle = XML_DOTTED;
742 0 : break;
743 : case table::BorderLineStyle::DASHED:
744 0 : eStyle = XML_DASHED;
745 0 : break;
746 : case table::BorderLineStyle::DOUBLE:
747 : case table::BorderLineStyle::THINTHICK_SMALLGAP:
748 : case table::BorderLineStyle::THINTHICK_MEDIUMGAP:
749 : case table::BorderLineStyle::THINTHICK_LARGEGAP:
750 : case table::BorderLineStyle::THICKTHIN_SMALLGAP:
751 : case table::BorderLineStyle::THICKTHIN_MEDIUMGAP:
752 : case table::BorderLineStyle::THICKTHIN_LARGEGAP:
753 0 : eStyle = XML_DOUBLE;
754 0 : break;
755 : case table::BorderLineStyle::EMBOSSED:
756 0 : eStyle = XML_RIDGE;
757 0 : break;
758 : case table::BorderLineStyle::ENGRAVED:
759 0 : eStyle = XML_GROOVE;
760 0 : break;
761 : case table::BorderLineStyle::INSET:
762 0 : eStyle = XML_INSET;
763 0 : break;
764 : case table::BorderLineStyle::OUTSET:
765 0 : eStyle = XML_OUTSET;
766 0 : break;
767 : default:
768 0 : bNoBorder = true;
769 : }
770 :
771 0 : if ( !bNoBorder )
772 : {
773 : ::sax::Converter::convertMeasure(aOut, nWidth,
774 : util::MeasureUnit::TWIP,
775 0 : util::MeasureUnit::POINT);
776 0 : aOut.append( sal_Unicode( ' ' ) );
777 0 : aOut.append( GetXMLToken( eStyle ) );
778 0 : aOut.append( sal_Unicode( ' ' ) );
779 : ::sax::Converter::convertColor(aOut,
780 0 : pLine->GetColor().GetColor());
781 : }
782 : }
783 : else
784 : {
785 0 : aOut.append( GetXMLToken(XML_NONE) );
786 : }
787 : }
788 0 : break;
789 :
790 : // width
791 : case ALL_BORDER_LINE_WIDTH:
792 : case LEFT_BORDER_LINE_WIDTH:
793 : case RIGHT_BORDER_LINE_WIDTH:
794 : case TOP_BORDER_LINE_WIDTH:
795 : case BOTTOM_BORDER_LINE_WIDTH:
796 : const SvxBorderLine* pLine;
797 0 : switch( nMemberId )
798 : {
799 : case ALL_BORDER_LINE_WIDTH:
800 : case LEFT_BORDER_LINE_WIDTH:
801 0 : pLine = pLeft;
802 0 : break;
803 : case RIGHT_BORDER_LINE_WIDTH:
804 0 : pLine = pRight;
805 0 : break;
806 : case TOP_BORDER_LINE_WIDTH:
807 0 : pLine = pTop;
808 0 : break;
809 : case BOTTOM_BORDER_LINE_WIDTH:
810 0 : pLine = pBottom;
811 0 : break;
812 : default:
813 0 : return false;
814 : }
815 0 : rUnitConverter.convertMeasureToXML( aOut, pLine->GetInWidth() );
816 0 : aOut.append( sal_Unicode( ' ' ) );
817 0 : rUnitConverter.convertMeasureToXML( aOut, pLine->GetDistance() );
818 0 : aOut.append( sal_Unicode( ' ' ) );
819 0 : rUnitConverter.convertMeasureToXML( aOut, pLine->GetOutWidth() );
820 0 : break;
821 : }
822 :
823 0 : bOk = true;
824 : }
825 0 : break;
826 :
827 : case RES_BREAK:
828 : {
829 0 : const SvxFmtBreakItem* pFmtBreak = PTR_CAST(SvxFmtBreakItem, &rItem);
830 : OSL_ENSURE( pFmtBreak != NULL, "Wrong Which-ID" );
831 :
832 0 : sal_uInt16 eEnum = 0;
833 :
834 0 : switch( nMemberId )
835 : {
836 : case MID_BREAK_BEFORE:
837 0 : switch( pFmtBreak->GetValue() )
838 : {
839 : case SVX_BREAK_COLUMN_BEFORE:
840 0 : eEnum = 1;
841 0 : break;
842 : case SVX_BREAK_PAGE_BEFORE:
843 0 : eEnum = 2;
844 0 : break;
845 : case SVX_BREAK_NONE:
846 0 : eEnum = 0;
847 0 : break;
848 : default:
849 0 : return false;
850 : }
851 0 : break;
852 : case MID_BREAK_AFTER:
853 0 : switch( pFmtBreak->GetValue() )
854 : {
855 : case SVX_BREAK_COLUMN_AFTER:
856 0 : eEnum = 1;
857 0 : break;
858 : case SVX_BREAK_PAGE_AFTER:
859 0 : eEnum = 2;
860 0 : break;
861 : case SVX_BREAK_NONE:
862 0 : eEnum = 0;
863 0 : break;
864 : default:
865 0 : return false;
866 : }
867 0 : break;
868 : }
869 :
870 0 : bOk = rUnitConverter.convertEnum( aOut, eEnum, psXML_BreakType );
871 : }
872 0 : break;
873 :
874 : case RES_KEEP:
875 : {
876 0 : SvxFmtKeepItem* pFmtKeep = PTR_CAST(SvxFmtKeepItem, &rItem);
877 : OSL_ENSURE( pFmtKeep != NULL, "Wrong Which-ID" );
878 :
879 0 : aOut.append( pFmtKeep->GetValue()
880 : ? GetXMLToken( XML_ALWAYS )
881 0 : : GetXMLToken( XML_AUTO ) );
882 0 : bOk = true;
883 : }
884 0 : break;
885 :
886 : case RES_BACKGROUND:
887 : {
888 0 : SvxBrushItem* pBrush = PTR_CAST(SvxBrushItem, &rItem);
889 : OSL_ENSURE( pBrush != NULL, "Wrong Which-ID" );
890 :
891 : // note: the graphic is only exported if nMemberId equals
892 : // MID_GRAPHIC..
893 : // If not, only the color or transparency is exported
894 :
895 0 : switch( nMemberId )
896 : {
897 : case MID_BACK_COLOR:
898 0 : if ( pBrush->GetColor().GetTransparency() )
899 0 : aOut.append( GetXMLToken(XML_TRANSPARENT) );
900 : else
901 : {
902 : ::sax::Converter::convertColor(aOut,
903 0 : pBrush->GetColor().GetColor());
904 : }
905 0 : bOk = true;
906 0 : break;
907 :
908 : case MID_GRAPHIC_LINK:
909 0 : if( pBrush->GetGraphicPos() != GPOS_NONE )
910 : {
911 0 : uno::Any aAny;
912 0 : pBrush->QueryValue( aAny, MID_GRAPHIC_URL );
913 0 : OUString sTmp;
914 0 : aAny >>= sTmp;
915 0 : aOut.append( sTmp );
916 0 : bOk = true;
917 : }
918 0 : break;
919 :
920 : case MID_GRAPHIC_POSITION:
921 0 : switch( pBrush->GetGraphicPos() )
922 : {
923 : case GPOS_LT:
924 : case GPOS_MT:
925 : case GPOS_RT:
926 0 : aOut.append( GetXMLToken(XML_TOP) );
927 0 : bOk = true;
928 0 : break;
929 : case GPOS_LM:
930 : case GPOS_MM:
931 : case GPOS_RM:
932 0 : aOut.append( GetXMLToken(XML_CENTER) );
933 0 : bOk = true;
934 0 : break;
935 : case GPOS_LB:
936 : case GPOS_MB:
937 : case GPOS_RB:
938 0 : aOut.append( GetXMLToken(XML_BOTTOM) );
939 0 : bOk = true;
940 0 : break;
941 : default:
942 : ;
943 : }
944 :
945 0 : if( bOk )
946 : {
947 0 : aOut.append( sal_Unicode( ' ' ) );
948 :
949 0 : switch( pBrush->GetGraphicPos() )
950 : {
951 : case GPOS_LT:
952 : case GPOS_LB:
953 : case GPOS_LM:
954 0 : aOut.append( GetXMLToken(XML_LEFT) );
955 0 : break;
956 : case GPOS_MT:
957 : case GPOS_MM:
958 : case GPOS_MB:
959 0 : aOut.append( GetXMLToken(XML_CENTER) );
960 0 : break;
961 : case GPOS_RM:
962 : case GPOS_RT:
963 : case GPOS_RB:
964 0 : aOut.append( GetXMLToken(XML_RIGHT) );
965 0 : break;
966 : default:
967 : ;
968 : }
969 : }
970 0 : break;
971 :
972 : case MID_GRAPHIC_REPEAT:
973 : {
974 0 : SvxGraphicPosition eGraphicPos = pBrush->GetGraphicPos();
975 0 : if( GPOS_AREA == eGraphicPos )
976 : {
977 0 : aOut.append( GetXMLToken(XML_BACKGROUND_STRETCH) );
978 0 : bOk = true;
979 : }
980 0 : else if( GPOS_NONE != eGraphicPos && GPOS_TILED != eGraphicPos )
981 : {
982 0 : aOut.append( GetXMLToken(XML_BACKGROUND_NO_REPEAT) );
983 0 : bOk = true;
984 : }
985 : }
986 0 : break;
987 :
988 : case MID_GRAPHIC_FILTER:
989 0 : if( pBrush->GetGraphicPos() != GPOS_NONE &&
990 0 : pBrush->GetGraphicFilter() )
991 : {
992 0 : aOut.append( *pBrush->GetGraphicFilter() );
993 0 : bOk = true;
994 : }
995 0 : break;
996 : }
997 : }
998 0 : break;
999 :
1000 : case RES_PAGEDESC:
1001 : {
1002 0 : const SwFmtPageDesc* pPageDesc = PTR_CAST(SwFmtPageDesc, &rItem);
1003 : OSL_ENSURE( pPageDesc != NULL, "Wrong Which-ID" );
1004 :
1005 0 : if( MID_PAGEDESC_PAGENUMOFFSET==nMemberId )
1006 : {
1007 0 : sal_Int32 const number(pPageDesc->GetNumOffset());
1008 0 : if (0 >= number)
1009 : {
1010 0 : aOut.append(GetXMLToken(XML_AUTO));
1011 : }
1012 : else // #i114163# positiveInteger only!
1013 : {
1014 0 : ::sax::Converter::convertNumber(aOut, number);
1015 : }
1016 0 : bOk = true;
1017 : }
1018 : }
1019 0 : break;
1020 :
1021 : case RES_LAYOUT_SPLIT:
1022 : case RES_ROW_SPLIT:
1023 : {
1024 0 : const SfxBoolItem* pSplit = PTR_CAST(SfxBoolItem, &rItem);
1025 : OSL_ENSURE( pSplit != NULL, "Wrong Which-ID" );
1026 :
1027 0 : ::sax::Converter::convertBool( aOut, pSplit->GetValue() );
1028 0 : bOk = true;
1029 : }
1030 0 : break;
1031 :
1032 : case RES_HORI_ORIENT:
1033 : {
1034 0 : SwFmtHoriOrient* pHoriOrient = PTR_CAST(SwFmtHoriOrient, &rItem);
1035 : OSL_ENSURE( pHoriOrient != NULL, "Wrong Which-ID" );
1036 :
1037 0 : rUnitConverter.convertEnum( aOut, pHoriOrient->GetHoriOrient(),
1038 0 : aXMLTableAlignMap );
1039 0 : bOk = true;
1040 : }
1041 0 : break;
1042 :
1043 : case RES_VERT_ORIENT:
1044 : {
1045 0 : SwFmtVertOrient* pVertOrient = PTR_CAST(SwFmtVertOrient, &rItem);
1046 : OSL_ENSURE( pVertOrient != NULL, "Wrong Which-ID" );
1047 :
1048 0 : rUnitConverter.convertEnum( aOut, pVertOrient->GetVertOrient(),
1049 0 : aXMLTableVAlignMap );
1050 0 : bOk = true;
1051 : }
1052 0 : break;
1053 :
1054 : case RES_FRM_SIZE:
1055 : {
1056 0 : SwFmtFrmSize* pFrmSize = PTR_CAST(SwFmtFrmSize, &rItem);
1057 : OSL_ENSURE( pFrmSize != NULL, "Wrong Which-ID" );
1058 :
1059 0 : bool bOutHeight = false;
1060 0 : switch( nMemberId )
1061 : {
1062 : case MID_FRMSIZE_REL_WIDTH:
1063 0 : if( pFrmSize->GetWidthPercent() )
1064 : {
1065 : ::sax::Converter::convertPercent(
1066 0 : aOut, pFrmSize->GetWidthPercent() );
1067 0 : bOk = true;
1068 : }
1069 0 : break;
1070 : case MID_FRMSIZE_MIN_HEIGHT:
1071 0 : if( ATT_MIN_SIZE == pFrmSize->GetHeightSizeType() )
1072 0 : bOutHeight = true;
1073 0 : break;
1074 : case MID_FRMSIZE_FIX_HEIGHT:
1075 0 : if( ATT_FIX_SIZE == pFrmSize->GetHeightSizeType() )
1076 0 : bOutHeight = true;
1077 0 : break;
1078 : }
1079 :
1080 0 : if( bOutHeight )
1081 : {
1082 0 : rUnitConverter.convertMeasureToXML(aOut, pFrmSize->GetHeight());
1083 0 : bOk = true;
1084 : }
1085 : }
1086 0 : break;
1087 :
1088 : case RES_FRAMEDIR:
1089 : {
1090 0 : Any aAny;
1091 0 : bOk = rItem.QueryValue( aAny );
1092 0 : if( bOk )
1093 : {
1094 : const XMLPropertyHandler* pWritingModeHandler =
1095 : XMLPropertyHandlerFactory::CreatePropertyHandler(
1096 0 : XML_TYPE_TEXT_WRITING_MODE_WITH_DEFAULT );
1097 0 : OUString sValue;
1098 : bOk = pWritingModeHandler->exportXML( sValue, aAny,
1099 0 : rUnitConverter );
1100 0 : if( bOk )
1101 0 : aOut.append( sValue );
1102 :
1103 0 : delete pWritingModeHandler;
1104 0 : }
1105 : }
1106 0 : break;
1107 :
1108 : case RES_COLLAPSING_BORDERS:
1109 : {
1110 0 : const SfxBoolItem* pBorders = PTR_CAST(SfxBoolItem, &rItem);
1111 : OSL_ENSURE( pBorders != NULL, "Wrong RES-ID" );
1112 :
1113 0 : aOut.append( pBorders->GetValue()
1114 : ? GetXMLToken( XML_COLLAPSING )
1115 0 : : GetXMLToken( XML_SEPARATING ) );
1116 0 : bOk = true;
1117 : }
1118 0 : break;
1119 :
1120 : default:
1121 : OSL_FAIL("GetXMLValue not implemented for this item.");
1122 0 : break;
1123 : }
1124 :
1125 0 : if ( bOk )
1126 0 : rValue = aOut.makeStringAndClear();
1127 :
1128 0 : return bOk;
1129 99 : }
1130 :
1131 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
