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