?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sw / source / filter / xml / xmltble.cxx
blob933c31be2310d156648651e7457107ac2aef1bd2
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: xmltble.cxx,v $
10 * $Revision: 1.48 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33
34
35 #include <hintids.hxx>
36 #include <rtl/ustrbuf.hxx>
37 #include <com/sun/star/text/XTextTable.hpp>
38 #include <xmloff/xmlnmspe.hxx>
39 #include <xmloff/xmltoken.hxx>
40 #include <xmloff/xmluconv.hxx>
41 #include <xmloff/numehelp.hxx>
42 #include <svtools/cntnrsrt.hxx>
43 #include <svtools/zforlist.hxx>
44 #include <svx/brshitem.hxx>
45 #include <svx/boxitem.hxx>
46 #include <fmtrowsplt.hxx>
47 #ifndef _SVX_FRAMEDIRITEM_HXX
48 #include <svx/frmdiritem.hxx>
49 #endif
50
51 #include <list>
52 #include "swtable.hxx"
53 #include "doc.hxx"
54 #include "pam.hxx"
55 #include "frmfmt.hxx"
56 #include "wrtswtbl.hxx"
57 #include "fmtfsize.hxx"
58 #include "fmtornt.hxx"
59 #include "cellatr.hxx"
60 #include "ddefld.hxx"
61 #include "swddetbl.hxx"
62 #include <ndole.hxx>
63 #include <xmloff/nmspmap.hxx>
64 #include <sfx2/linkmgr.hxx> // for cTokenSeperator
65 #include "unoobj.hxx"
66 #include "unotbl.hxx"
67 #include "xmltexte.hxx"
68 #include "xmlexp.hxx"
69
70
71 using ::rtl::OUString;
72 using ::rtl::OUStringBuffer;
73 using namespace ::com::sun::star;
74 using namespace ::com::sun::star::uno;
75 using namespace ::com::sun::star::text;
76 using namespace ::com::sun::star::beans;
77 using namespace ::com::sun::star::lang;
78 using namespace ::com::sun::star::container;
79 using namespace ::xmloff::token;
80 using table::XCell;
81
82
83 class SwXMLTableColumn_Impl : public SwWriteTableCol
84 {
85 OUString sStyleName;
86 sal_uInt32 nRelWidth;
87
88 public:
89
90
91 SwXMLTableColumn_Impl( sal_uInt16 nPosition ) :
92 SwWriteTableCol( nPosition ),
93 nRelWidth( 0UL )
94 {};
95
96 void SetStyleName( const OUString& rName ) { sStyleName = rName; }
97 const OUString& GetStyleName() const { return sStyleName; }
98
99 void SetRelWidth( sal_uInt32 nSet ) { nRelWidth = nSet; }
100 sal_uInt32 GetRelWidth() const { return nRelWidth; }
101 };
102
103 sal_Int32 SwXMLTableColumnCmpWidth_Impl( const SwXMLTableColumn_Impl& r1,
104 const SwXMLTableColumn_Impl& r2 )
105 {
106 sal_Int32 n = (sal_Int32)r1.GetWidthOpt() - (sal_Int32)r2.GetWidthOpt();
107 if( !n )
108 n = (sal_Int32)r1.GetRelWidth() - (sal_Int32)r2.GetRelWidth();
109 return n;
110 }
111
112 // ---------------------------------------------------------------------
113
114 typedef SwXMLTableColumn_Impl *SwXMLTableColumnPtr;
115 SV_DECL_PTRARR_SORT_DEL( SwXMLTableColumns_Impl, SwXMLTableColumnPtr, 5, 5 )
116 SV_IMPL_OP_PTRARR_SORT( SwXMLTableColumns_Impl, SwXMLTableColumnPtr )
117
118 DECLARE_CONTAINER_SORT( SwXMLTableColumnsSortByWidth_Impl,
119 SwXMLTableColumn_Impl )
120 IMPL_CONTAINER_SORT( SwXMLTableColumnsSortByWidth_Impl, SwXMLTableColumn_Impl,
121 SwXMLTableColumnCmpWidth_Impl )
122
123 class SwXMLTableLines_Impl
124 {
125 SwXMLTableColumns_Impl aCols;
126 const SwTableLines *pLines;
127 sal_uInt32 nWidth;
128
129 public:
130
131 SwXMLTableLines_Impl( const SwTableLines& rLines );
132
133 ~SwXMLTableLines_Impl() {}
134
135 sal_uInt32 GetWidth() const { return nWidth; }
136 const SwTableLines *GetLines() const { return pLines; }
137
138 const SwXMLTableColumns_Impl& GetColumns() const { return aCols; }
139 };
140
141 SwXMLTableLines_Impl::SwXMLTableLines_Impl( const SwTableLines& rLines ) :
142 pLines( &rLines ),
143 nWidth( 0UL )
144 {
145 #ifndef PRODUCT
146 sal_uInt16 nEndCPos = 0U;
147 #endif
148 sal_uInt16 nLines = rLines.Count();
149 sal_uInt16 nLine;
150 for( nLine=0U; nLine<nLines; nLine++ )
151 {
152 const SwTableLine *pLine = rLines[nLine];
153 const SwTableBoxes& rBoxes = pLine->GetTabBoxes();
154 sal_uInt16 nBoxes = rBoxes.Count();
155
156 sal_uInt16 nCPos = 0U;
157 for( sal_uInt16 nBox=0U; nBox<nBoxes; nBox++ )
158 {
159 const SwTableBox *pBox = rBoxes[nBox];
160
161 if( nBox < nBoxes-1U || nWidth==0UL )
162 {
163 nCPos = nCPos + (sal_uInt16)SwWriteTable::GetBoxWidth( pBox );
164 SwXMLTableColumn_Impl *pCol =
165 new SwXMLTableColumn_Impl( nCPos );
166
167 if( !aCols.Insert( pCol ) )
168 delete pCol;
169
170 if( nBox==nBoxes-1U )
171 {
172 ASSERT( nLine==0U && nWidth==0UL,
173 "parent width will be lost" );
174 nWidth = nCPos;
175 }
176 }
177 else
178 {
179 #ifndef PRODUCT
180 sal_uInt16 nCheckPos =
181 nCPos + (sal_uInt16)SwWriteTable::GetBoxWidth( pBox );
182 if( !nEndCPos )
183 {
184 nEndCPos = nCheckPos;
185 }
186 else
187 {
188 /*
189 ASSERT( SwXMLTableColumn_impl(nCheckPos) ==
190 SwXMLTableColumn_Impl(nEndCPos),
191 "rows have different total widths" );
192 */
193 }
194 #endif
195 nCPos = (sal_uInt16)nWidth;
196 #ifndef PRODUCT
197 SwXMLTableColumn_Impl aCol( (sal_uInt16)nWidth );
198 ASSERT( aCols.Seek_Entry(&aCol), "couldn't find last column" );
199 ASSERT( SwXMLTableColumn_Impl(nCheckPos) ==
200 SwXMLTableColumn_Impl(nCPos),
201 "rows have different total widths" );
202 #endif
203 }
204 }
205 }
206 }
207
208 typedef SwXMLTableLines_Impl *SwXMLTableLinesPtr;
209 DECLARE_LIST( SwXMLTableLinesCache_Impl, SwXMLTableLinesPtr )
210
211 // ---------------------------------------------------------------------
212
213 typedef SwFrmFmt *SwFrmFmtPtr;
214 DECLARE_LIST( SwXMLFrmFmts_Impl, SwFrmFmtPtr )
215
216 class SwXMLTableFrmFmtsSort_Impl : public SwXMLFrmFmts_Impl
217 {
218 public:
219 SwXMLTableFrmFmtsSort_Impl ( sal_uInt16 nInit, sal_uInt16 nGrow ) :
220 SwXMLFrmFmts_Impl( nInit, nGrow )
221 {}
222
223 sal_Bool AddRow( SwFrmFmt& rFrmFmt, const OUString& rNamePrefix, sal_uInt32 nLine );
224 sal_Bool AddCell( SwFrmFmt& rFrmFmt, const OUString& rNamePrefix,
225 sal_uInt32 nCol, sal_uInt32 nRow, sal_Bool bTop );
226 };
227
228 sal_Bool SwXMLTableFrmFmtsSort_Impl::AddRow( SwFrmFmt& rFrmFmt,
229 const OUString& rNamePrefix,
230 sal_uInt32 nLine )
231 {
232 const SwFmtFrmSize *pFrmSize = 0;
233 const SwFmtRowSplit* pRowSplit = 0;
234 const SvxBrushItem *pBrush = 0;
235
236 const SfxItemSet& rItemSet = rFrmFmt.GetAttrSet();
237 const SfxPoolItem *pItem;
238 if( SFX_ITEM_SET == rItemSet.GetItemState( RES_FRM_SIZE, sal_False, &pItem ) )
239 pFrmSize = (const SwFmtFrmSize *)pItem;
240
241 if( SFX_ITEM_SET == rItemSet.GetItemState( RES_ROW_SPLIT, sal_False, &pItem ) )
242 pRowSplit = (const SwFmtRowSplit *)pItem;
243
244 if( SFX_ITEM_SET == rItemSet.GetItemState( RES_BACKGROUND, sal_False, &pItem ) )
245 pBrush = (const SvxBrushItem *)pItem;
246
247 // empty styles have not to be exported
248 if( !pFrmSize && !pBrush && !pRowSplit )
249 return sal_False;
250
251 // order is: -/brush, size/-, size/brush
252 sal_uInt32 nCount2 = Count();
253 sal_Bool bInsert = sal_True;
254 sal_uInt32 i;
255 for( i = 0; i < nCount2; ++i )
256 {
257 const SwFmtFrmSize *pTestFrmSize = 0;
258 const SwFmtRowSplit* pTestRowSplit = 0;
259 const SvxBrushItem *pTestBrush = 0;
260 const SwFrmFmt *pTestFmt = GetObject(i);
261 const SfxItemSet& rTestSet = pTestFmt->GetAttrSet();
262 if( SFX_ITEM_SET == rTestSet.GetItemState( RES_FRM_SIZE, sal_False,
263 &pItem ) )
264 {
265 if( !pFrmSize )
266 break;
267
268 pTestFrmSize = (const SwFmtFrmSize *)pItem;
269 }
270 else
271 {
272 if( pFrmSize )
273 continue;
274 }
275
276 if( SFX_ITEM_SET == rTestSet.GetItemState( RES_BACKGROUND, sal_False,
277 &pItem ) )
278 {
279 if( !pBrush )
280 break;
281
282 pTestBrush = (const SvxBrushItem *)pItem;
283 }
284 else
285 {
286 if( pBrush )
287 continue;
288 }
289
290 if( SFX_ITEM_SET == rTestSet.GetItemState( RES_ROW_SPLIT, sal_False,
291 &pItem ) )
292 {
293 if( !pRowSplit )
294 break;
295
296 pTestRowSplit = (const SwFmtRowSplit *)pItem;
297 }
298 else
299 {
300 if( pRowSplit )
301 continue;
302 }
303
304
305 if( pFrmSize &&
306 ( pFrmSize->GetHeightSizeType() != pTestFrmSize->GetHeightSizeType() ||
307 pFrmSize->GetHeight() != pTestFrmSize->GetHeight() ) )
308 continue;
309
310 if( pBrush && (*pBrush != *pTestBrush) )
311 continue;
312
313 if( pRowSplit && (!pRowSplit->GetValue() != !pTestRowSplit->GetValue()) )
314 continue;
315
316 // found!
317 const String& rFmtName = pTestFmt->GetName();
318 rFrmFmt.SetName( rFmtName );
319 bInsert = sal_False;
320 break;
321 }
322
323 if( bInsert )
324 {
325 OUStringBuffer sBuffer( rNamePrefix.getLength() + 4UL );
326 sBuffer.append( rNamePrefix );
327 sBuffer.append( (sal_Unicode)'.' );
328 sBuffer.append( (sal_Int32)(nLine+1UL) );
329
330 rFrmFmt.SetName( sBuffer.makeStringAndClear() );
331 Insert( &rFrmFmt, i );
332 }
333
334 return bInsert;
335 }
336
337 void lcl_GetTblBoxColStr( sal_uInt16 nCol, String& rNm );
338 void lcl_xmltble_appendBoxPrefix( OUStringBuffer& rBuffer,
339 const OUString& rNamePrefix,
340 sal_uInt32 nCol, sal_uInt32 nRow, sal_Bool bTop )
341 {
342 rBuffer.append( rNamePrefix );
343 rBuffer.append( (sal_Unicode)'.' );
344 if( bTop )
345 {
346 String sTmp;
347 lcl_GetTblBoxColStr( (sal_uInt16)nCol, sTmp );
348 rBuffer.append( sTmp );
349 }
350 else
351 {
352 rBuffer.append( (sal_Int32)(nCol + 1));
353 rBuffer.append( (sal_Unicode)'.' );
354 }
355 rBuffer.append( (sal_Int32)(nRow + 1));
356 }
357
358 sal_Bool SwXMLTableFrmFmtsSort_Impl::AddCell( SwFrmFmt& rFrmFmt,
359 const OUString& rNamePrefix,
360 sal_uInt32 nCol, sal_uInt32 nRow, sal_Bool bTop )
361 {
362 const SwFmtVertOrient *pVertOrient = 0;
363 const SvxBrushItem *pBrush = 0;
364 const SvxBoxItem *pBox = 0;
365 const SwTblBoxNumFormat *pNumFmt = 0;
366 const SvxFrameDirectionItem *pFrameDir = 0;
367
368 const SfxItemSet& rItemSet = rFrmFmt.GetAttrSet();
369 const SfxPoolItem *pItem;
370 if( SFX_ITEM_SET == rItemSet.GetItemState( RES_VERT_ORIENT, sal_False,
371 &pItem ) )
372 pVertOrient = (const SwFmtVertOrient *)pItem;
373
374 if( SFX_ITEM_SET == rItemSet.GetItemState( RES_BACKGROUND, sal_False, &pItem ) )
375 pBrush = (const SvxBrushItem *)pItem;
376
377 if( SFX_ITEM_SET == rItemSet.GetItemState( RES_BOX, sal_False, &pItem ) )
378 pBox = (const SvxBoxItem *)pItem;
379
380 if ( SFX_ITEM_SET == rItemSet.GetItemState( RES_BOXATR_FORMAT,
381 sal_False, &pItem ) )
382 pNumFmt = (const SwTblBoxNumFormat *)pItem;
383 if ( SFX_ITEM_SET == rItemSet.GetItemState( RES_FRAMEDIR,
384 sal_False, &pItem ) )
385 pFrameDir = (const SvxFrameDirectionItem *)pItem;
386
387 // empty styles have not to be exported
388 if( !pVertOrient && !pBrush && !pBox && !pNumFmt && !pFrameDir )
389 return sal_False;
390
391 // order is: -/-/-/num,
392 // -/-/box/-, --/-/box/num,
393 // -/brush/-/-, -/brush/-/num, -/brush/box/-, -/brush/box/num,
394 // vert/-/-/-, vert/-/-/num, vert/-/box/-, ver/-/box/num,
395 // vert/brush/-/-, vert/brush/-/num, vert/brush/box/-,
396 // vert/brush/box/num
397 sal_uInt32 nCount2 = Count();
398 sal_Bool bInsert = sal_True;
399 sal_uInt32 i;
400 for( i = 0; i < nCount2; ++i )
401 {
402 const SwFmtVertOrient *pTestVertOrient = 0;
403 const SvxBrushItem *pTestBrush = 0;
404 const SvxBoxItem *pTestBox = 0;
405 const SwTblBoxNumFormat *pTestNumFmt = 0;
406 const SvxFrameDirectionItem *pTestFrameDir = 0;
407 const SwFrmFmt *pTestFmt = GetObject(i);
408 const SfxItemSet& rTestSet = pTestFmt->GetAttrSet();
409 if( SFX_ITEM_SET == rTestSet.GetItemState( RES_VERT_ORIENT, sal_False,
410 &pItem ) )
411 {
412 if( !pVertOrient )
413 break;
414
415 pTestVertOrient = (const SwFmtVertOrient *)pItem;
416 }
417 else
418 {
419 if( pVertOrient )
420 continue;
421 }
422
423 if( SFX_ITEM_SET == rTestSet.GetItemState( RES_BACKGROUND, sal_False,
424 &pItem ) )
425 {
426 if( !pBrush )
427 break;
428
429 pTestBrush = (const SvxBrushItem *)pItem;
430 }
431 else
432 {
433 if( pBrush )
434 continue;
435 }
436
437 if( SFX_ITEM_SET == rTestSet.GetItemState( RES_BOX, sal_False, &pItem ) )
438 {
439 if( !pBox )
440 break;
441
442 pTestBox = (const SvxBoxItem *)pItem;
443 }
444 else
445 {
446 if( pBox )
447 continue;
448 }
449
450 if ( SFX_ITEM_SET == rTestSet.GetItemState( RES_BOXATR_FORMAT,
451 sal_False, &pItem ) )
452 {
453 if( !pNumFmt )
454 break;
455
456 pTestNumFmt = (const SwTblBoxNumFormat *)pItem;
457 }
458 else
459 {
460 if( pNumFmt )
461 continue;
462
463 }
464
465 if ( SFX_ITEM_SET == rTestSet.GetItemState( RES_FRAMEDIR,
466 sal_False, &pItem ) )
467 {
468 if( !pFrameDir )
469 break;
470
471 pTestFrameDir = (const SvxFrameDirectionItem *)pItem;
472 }
473 else
474 {
475 if( pFrameDir )
476 continue;
477
478 }
479
480 if( pVertOrient &&
481 pVertOrient->GetVertOrient() != pTestVertOrient->GetVertOrient() )
482 continue;
483
484 if( pBrush && ( *pBrush != *pTestBrush ) )
485 continue;
486
487 if( pBox && ( *pBox != *pTestBox ) )
488 continue;
489
490 if( pNumFmt && pNumFmt->GetValue() != pTestNumFmt->GetValue() )
491 continue;
492
493 if( pFrameDir && pFrameDir->GetValue() != pTestFrameDir->GetValue() )
494 continue;
495
496 // found!
497 const String& rFmtName = pTestFmt->GetName();
498 rFrmFmt.SetName( rFmtName );
499 bInsert = sal_False;
500 break;
501 }
502
503 if( bInsert )
504 {
505 OUStringBuffer sBuffer( rNamePrefix.getLength() + 8UL );
506 lcl_xmltble_appendBoxPrefix( sBuffer, rNamePrefix, nCol, nRow, bTop );
507 rFrmFmt.SetName( sBuffer.makeStringAndClear() );
508 Insert( &rFrmFmt, i );
509 }
510
511 return bInsert;
512 }
513 // ---------------------------------------------------------------------
514
515 class SwXMLTableInfo_Impl
516 {
517 const SwTable *pTable;
518 Reference < XTextSection > xBaseSection;
519 sal_Bool bBaseSectionValid;
520
521 public:
522
523 inline SwXMLTableInfo_Impl( const SwTable *pTbl );
524
525 const SwTable *GetTable() const { return pTable; }
526 const SwFrmFmt *GetTblFmt() const { return pTable->GetFrmFmt(); }
527
528 sal_Bool IsBaseSectionValid() const { return bBaseSectionValid; }
529 const Reference < XTextSection >& GetBaseSection() const { return xBaseSection; }
530 inline void SetBaseSection( const Reference < XTextSection >& rBase );
531 };
532
533 inline SwXMLTableInfo_Impl::SwXMLTableInfo_Impl( const SwTable *pTbl ) :
534 pTable( pTbl ),
535 bBaseSectionValid( sal_False )
536 {
537 }
538
539 inline void SwXMLTableInfo_Impl::SetBaseSection(
540 const Reference < XTextSection >& rBaseSection )
541 {
542 xBaseSection = rBaseSection;
543 bBaseSectionValid = sal_True;
544 }
545
546 // ---------------------------------------------------------------------
547
548
549 void SwXMLExport::ExportTableColumnStyle( const SwXMLTableColumn_Impl& rCol )
550 {
551 // <style:style ...>
552 CheckAttrList();
553
554 // style:name="..."
555 sal_Bool bEncoded = sal_False;
556 AddAttribute( XML_NAMESPACE_STYLE, XML_NAME,
557 EncodeStyleName( rCol.GetStyleName(), &bEncoded ) );
558 if( bEncoded )
559 AddAttribute( XML_NAMESPACE_STYLE, XML_DISPLAY_NAME, rCol.GetStyleName() );
560
561 // style:family="table-column"
562 AddAttribute( XML_NAMESPACE_STYLE, XML_FAMILY, XML_TABLE_COLUMN );
563
564 {
565 SvXMLElementExport aElem( *this, XML_NAMESPACE_STYLE, XML_STYLE, sal_True,
566 sal_True );
567 OUStringBuffer sValue;
568 if( rCol.GetWidthOpt() )
569 {
570 GetTwipUnitConverter().convertMeasure( sValue, rCol.GetWidthOpt() );
571 AddAttribute( XML_NAMESPACE_STYLE, XML_COLUMN_WIDTH,
572 sValue.makeStringAndClear() );
573 }
574 if( rCol.GetRelWidth() )
575 {
576 sValue.append( (sal_Int32)rCol.GetRelWidth() );
577 sValue.append( (sal_Unicode)'*' );
578 AddAttribute( XML_NAMESPACE_STYLE, XML_REL_COLUMN_WIDTH,
579 sValue.makeStringAndClear() );
580 }
581
582 {
583 SvXMLElementExport aElemExport( *this, XML_NAMESPACE_STYLE,
584 XML_TABLE_COLUMN_PROPERTIES,
585 sal_True, sal_True );
586 }
587 }
588 }
589
590 void SwXMLExport::ExportTableLinesAutoStyles( const SwTableLines& rLines,
591 sal_uInt32 nAbsWidth, sal_uInt32 nBaseWidth,
592 const OUString& rNamePrefix,
593 SwXMLTableColumnsSortByWidth_Impl& rExpCols,
594 SwXMLTableFrmFmtsSort_Impl& rExpRows,
595 SwXMLTableFrmFmtsSort_Impl& rExpCells,
596 SwXMLTableInfo_Impl& rTblInfo,
597 sal_Bool bTop )
598 {
599 // pass 1: calculate columns
600 SwXMLTableLines_Impl *pLines =
601 new SwXMLTableLines_Impl( rLines );
602 if( !pTableLines )
603 pTableLines = new SwXMLTableLinesCache_Impl( 5, 5 );
604 pTableLines->Insert( pLines, pTableLines->Count() );
605
606 OUStringBuffer sBuffer( rNamePrefix.getLength() + 8L );
607
608 // pass 2: export column styles
609 {
610 const SwXMLTableColumns_Impl& rCols = pLines->GetColumns();
611 sal_uInt16 nCPos = 0U;
612 sal_uInt16 nColumns = rCols.Count();
613 for( sal_uInt16 nColumn=0U; nColumn<nColumns; nColumn++ )
614 {
615 SwXMLTableColumn_Impl *pColumn = rCols[nColumn];
616
617 sal_uInt16 nOldCPos = nCPos;
618 nCPos = pColumn->GetPos();
619
620 sal_uInt32 nWidth = nCPos - nOldCPos;
621
622 // If a base width is given, the table has either an automatic
623 // or margin alignment, or an percentage width. In either case,
624 // relative widths should be exported.
625 if( nBaseWidth )
626 {
627 pColumn->SetRelWidth( nWidth );
628 }
629
630 // If an absolute width is given, the table either has a fixed
631 // width, or the current width is known from the layout. In the
632 // later case, a base width is set in addition and must be used
633 // to "absoultize" the relative column width.
634 if( nAbsWidth )
635 {
636 sal_uInt32 nColAbsWidth = nWidth;
637 if( nBaseWidth )
638 {
639 nColAbsWidth *= nAbsWidth;
640 nColAbsWidth += (nBaseWidth/2UL);
641 nColAbsWidth /= nBaseWidth;
642 }
643 pColumn->SetWidthOpt( (sal_uInt16)nColAbsWidth, sal_False );
644 }
645
646 ULONG nExpPos = 0;
647 if( rExpCols.Seek_Entry( pColumn, &nExpPos ) )
648 {
649 pColumn->SetStyleName(
650 rExpCols.GetObject(nExpPos)->GetStyleName() );
651 }
652 else
653 {
654 sBuffer.append( rNamePrefix );
655 sBuffer.append( (sal_Unicode)'.' );
656 if( bTop )
657 {
658 String sTmp;
659 lcl_GetTblBoxColStr( nColumn, sTmp );
660 sBuffer.append( sTmp );
661 }
662 else
663 {
664 sBuffer.append( (sal_Int32)(nColumn + 1U) );
665 }
666
667 pColumn->SetStyleName( sBuffer.makeStringAndClear() );
668 ExportTableColumnStyle( *pColumn );
669 rExpCols.Insert( pColumn );
670 }
671 }
672 }
673
674 // pass 3: export line/rows
675 sal_uInt16 nLines = rLines.Count();
676 for( sal_uInt16 nLine=0U; nLine<nLines; nLine++ )
677 {
678 SwTableLine *pLine = rLines[nLine];
679
680 SwFrmFmt *pFrmFmt = pLine->GetFrmFmt();
681 if( rExpRows.AddRow( *pFrmFmt, rNamePrefix, nLine ) )
682 ExportFmt( *pFrmFmt, XML_TABLE_ROW );
683
684 const SwTableBoxes& rBoxes = pLine->GetTabBoxes();
685 sal_uInt16 nBoxes = rBoxes.Count();
686
687 sal_uInt16 nCPos = 0U;
688 sal_uInt16 nCol = 0U;
689 for( sal_uInt16 nBox=0U; nBox<nBoxes; nBox++ )
690 {
691 SwTableBox *pBox = rBoxes[nBox];
692
693 if( nBox < nBoxes-1U )
694 nCPos = nCPos + (sal_uInt16)SwWriteTable::GetBoxWidth( pBox );
695 else
696 nCPos = (sal_uInt16)pLines->GetWidth();
697
698
699 // Und ihren Index
700 sal_uInt16 nOldCol = nCol;
701 SwXMLTableColumn_Impl aCol( nCPos );
702 #ifndef PRODUCT
703 sal_Bool bFound =
704 #endif
705 pLines->GetColumns().Seek_Entry( &aCol, &nCol );
706 ASSERT( bFound, "couldn't find column" );
707
708 const SwStartNode *pBoxSttNd = pBox->GetSttNd();
709 if( pBoxSttNd )
710 {
711 SwFrmFmt *pFrmFmt2 = pBox->GetFrmFmt();
712 if( rExpCells.AddCell( *pFrmFmt2, rNamePrefix, nOldCol, nLine,
713 bTop) )
714 ExportFmt( *pFrmFmt2, XML_TABLE_CELL );
715
716 Reference < XCell > xCell = SwXCell::CreateXCell(
717 (SwFrmFmt *)rTblInfo.GetTblFmt(),
718 pBox,
719 (SwTable *)rTblInfo.GetTable() );
720 if (xCell.is())
721 {
722 Reference < XText > xText( xCell, UNO_QUERY );
723 if( !rTblInfo.IsBaseSectionValid() )
724 {
725 Reference<XPropertySet> xCellPropertySet( xCell,
726 UNO_QUERY );
727 OUString sTextSection( RTL_CONSTASCII_USTRINGPARAM("TextSection") );
728 Any aAny = xCellPropertySet->getPropertyValue(sTextSection);
729 Reference < XTextSection > xTextSection;
730 aAny >>= xTextSection;
731 rTblInfo.SetBaseSection( xTextSection );
732 }
733
734 const bool bExportContent = (getExportFlags() & EXPORT_CONTENT ) != 0;
735 if ( !bExportContent )
736 {
737 // AUTOSTYLES - not needed anymore if we are currently exporting content.xml
738 GetTextParagraphExport()->collectTextAutoStyles(
739 xText, rTblInfo.GetBaseSection(), IsShowProgress() );
740 }
741 }
742 else {
743 DBG_ERROR("here should be a XCell");
744 }
745 }
746 else
747 {
748 lcl_xmltble_appendBoxPrefix( sBuffer, rNamePrefix, nOldCol,
749 nLine, bTop );
750
751 ExportTableLinesAutoStyles( pBox->GetTabLines(),
752 nAbsWidth, nBaseWidth,
753 sBuffer.makeStringAndClear(),
754 rExpCols, rExpRows, rExpCells,
755 rTblInfo );
756 }
757
758 nCol++;
759 }
760 }
761 }
762
763 void SwXMLExport::ExportTableAutoStyles( const SwTableNode& rTblNd )
764 {
765 const SwTable& rTbl = rTblNd.GetTable();
766 const SwFrmFmt *pTblFmt = rTbl.GetFrmFmt();
767
768 if( pTblFmt )
769 {
770 sal_Int16 eTabHoriOri = pTblFmt->GetHoriOrient().GetHoriOrient();
771 const SwFmtFrmSize& rFrmSize = pTblFmt->GetFrmSize();
772
773 sal_uInt32 nAbsWidth = rFrmSize.GetSize().Width();
774 sal_uInt32 nBaseWidth = 0UL;
775 sal_Int8 nPrcWidth = rFrmSize.GetWidthPercent();
776
777 sal_Bool bFixAbsWidth = nPrcWidth != 0 || /*text::*/HoriOrientation::NONE == eTabHoriOri
778 || /*text::*/HoriOrientation::FULL == eTabHoriOri;
779 if( bFixAbsWidth )
780 {
781 nBaseWidth = nAbsWidth;
782 nAbsWidth = pTblFmt->FindLayoutRect(sal_True).Width();
783 if( !nAbsWidth )
784 {
785 // TODO???
786 }
787 }
788 ExportTableFmt( *pTblFmt, nAbsWidth );
789
790 OUString sName( pTblFmt->GetName() );
791 SwXMLTableColumnsSortByWidth_Impl aExpCols( 10, 10 );
792 SwXMLTableFrmFmtsSort_Impl aExpRows( 10, 10 );
793 SwXMLTableFrmFmtsSort_Impl aExpCells( 10, 10 );
794 SwXMLTableInfo_Impl aTblInfo( &rTbl );
795 ExportTableLinesAutoStyles( rTbl.GetTabLines(), nAbsWidth, nBaseWidth,
796 sName, aExpCols, aExpRows, aExpCells,
797 aTblInfo, sal_True);
798 }
799 }
800
801 // ---------------------------------------------------------------------
802
803 void SwXMLExport::ExportTableBox( const SwTableBox& rBox,
804 sal_uInt16 nColSpan,
805 sal_uInt16 nRowSpan,
806 SwXMLTableInfo_Impl& rTblInfo )
807 {
808 const SwStartNode *pBoxSttNd = rBox.GetSttNd();
809 if( pBoxSttNd )
810 {
811 const SwFrmFmt *pFrmFmt = rBox.GetFrmFmt();
812 if( pFrmFmt )
813 {
814 const String& rName = pFrmFmt->GetName();
815 if( rName.Len() )
816 {
817 AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME, EncodeStyleName(rName) );
818 }
819 }
820 }
821
822 if( nRowSpan != 1 )
823 {
824 OUStringBuffer sTmp;
825 sTmp.append( (sal_Int32)nRowSpan );
826 AddAttribute( XML_NAMESPACE_TABLE, XML_NUMBER_ROWS_SPANNED,
827 sTmp.makeStringAndClear() );
828 }
829
830 if( nColSpan != 1 )
831 {
832 OUStringBuffer sTmp;
833 sTmp.append( (sal_Int32)nColSpan );
834 AddAttribute( XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_SPANNED,
835 sTmp.makeStringAndClear() );
836 }
837
838 {
839 if( pBoxSttNd )
840 {
841 // start node -> normal cell
842
843 // get cell range for table
844 Reference<XCell> xCell = SwXCell::CreateXCell( (SwFrmFmt *)rTblInfo.GetTblFmt(),
845 (SwTableBox *)&rBox,
846 (SwTable *)rTblInfo.GetTable() );
847
848 if (xCell.is())
849 {
850 Reference<XText> xText( xCell, UNO_QUERY );
851
852 // get formula (and protection)
853 OUString sCellFormula = xCell->getFormula();
854
855 // if this cell has a formula, export it
856 // (with value and number format)
857 if (sCellFormula.getLength()>0)
858 {
859 OUString sQValue =
860 GetNamespaceMap().GetQNameByKey(
861 XML_NAMESPACE_OOOW, sCellFormula, sal_False );
862 // formula
863 AddAttribute(XML_NAMESPACE_TABLE, XML_FORMULA, sQValue );
864 }
865
866 // value and format (if NumberFormat != -1)
867 Reference<XPropertySet> xCellPropertySet(xCell,
868 UNO_QUERY);
869 if (xCellPropertySet.is())
870 {
871 sal_Int32 nNumberFormat = 0;
872 Any aAny = xCellPropertySet->getPropertyValue(sNumberFormat);
873 aAny >>= nNumberFormat;
874
875 if (NUMBERFORMAT_TEXT == nNumberFormat)
876 {
877 // text format
878 AddAttribute( XML_NAMESPACE_OFFICE,
879 XML_VALUE_TYPE, XML_STRING );
880 }
881 else if ( (-1 != nNumberFormat) && (xText->getString().getLength() > 0) )
882 {
883 // number format key:
884 // (export values only if cell contains text;
885 // cf. #83755#)
886 XMLNumberFormatAttributesExportHelper::
887 SetNumberFormatAttributes(
888 *this, nNumberFormat, xCell->getValue(),
889 sal_True );
890 }
891 // else: invalid key; ignore
892
893 // cell protection
894 aAny = xCellPropertySet->getPropertyValue(sIsProtected);
895 if (*(sal_Bool*)aAny.getValue())
896 {
897 AddAttribute( XML_NAMESPACE_TABLE, XML_PROTECTED,
898 XML_TRUE );
899 }
900
901 if( !rTblInfo.IsBaseSectionValid() )
902 {
903 OUString sTextSection( RTL_CONSTASCII_USTRINGPARAM("TextSection") );
904 aAny = xCellPropertySet->getPropertyValue(sTextSection);
905 Reference < XTextSection > xTextSection;
906 aAny >>= xTextSection;
907 rTblInfo.SetBaseSection( xTextSection );
908 }
909 }
910
911 // export cell element
912 SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
913 XML_TABLE_CELL, sal_True, sal_True );
914
915 // export cell content
916 GetTextParagraphExport()->exportText( xText,
917 rTblInfo.GetBaseSection(),
918 IsShowProgress() );
919 }
920 else
921 {
922 DBG_ERROR("here should be a XCell");
923 ClearAttrList();
924 }
925 }
926 else
927 {
928 // no start node -> merged cells: export subtable in cell
929 SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
930 XML_TABLE_CELL, sal_True, sal_True );
931 {
932 AddAttribute( XML_NAMESPACE_TABLE, XML_IS_SUB_TABLE,
933 GetXMLToken( XML_TRUE ) );
934
935 SvXMLElementExport aElemExport( *this, XML_NAMESPACE_TABLE,
936 XML_TABLE, sal_True, sal_True );
937 ExportTableLines( rBox.GetTabLines(), rTblInfo );
938 }
939 }
940 }
941 }
942
943 void SwXMLExport::ExportTableLine( const SwTableLine& rLine,
944 const SwXMLTableLines_Impl& rLines,
945 SwXMLTableInfo_Impl& rTblInfo )
946 {
947 if( rLine.hasSoftPageBreak() )
948 {
949 SvXMLElementExport aElem( *this, XML_NAMESPACE_TEXT,
950 XML_SOFT_PAGE_BREAK, sal_True, sal_True );
951 }
952 const SwFrmFmt *pFrmFmt = rLine.GetFrmFmt();
953 if( pFrmFmt )
954 {
955 const String& rName = pFrmFmt->GetName();
956 if( rName.Len() )
957 {
958 AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME, EncodeStyleName(rName) );
959 }
960 }
961
962 {
963 SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
964 XML_TABLE_ROW, sal_True, sal_True );
965 const SwTableBoxes& rBoxes = rLine.GetTabBoxes();
966 sal_uInt16 nBoxes = rBoxes.Count();
967
968 sal_uInt16 nCPos = 0U;
969 sal_uInt16 nCol = 0U;
970 for( sal_uInt16 nBox=0U; nBox<nBoxes; nBox++ )
971 {
972 const SwTableBox *pBox = rBoxes[nBox];
973
974 // NEW TABLES
975 const long nRowSpan = pBox->getRowSpan();
976 if( nRowSpan < 1 )
977 {
978 SvXMLElementExport aElem2( *this, XML_NAMESPACE_TABLE,
979 XML_COVERED_TABLE_CELL, sal_True,
980 sal_False );
981 }
982
983 if( nBox < nBoxes-1U )
984 nCPos = nCPos + (sal_uInt16)SwWriteTable::GetBoxWidth( pBox );
985 else
986 nCPos = (sal_uInt16)rLines.GetWidth();
987
988 // Und ihren Index
989 const sal_uInt16 nOldCol = nCol;
990 {
991 SwXMLTableColumn_Impl aCol( nCPos );
992 #ifndef PRODUCT
993 const sal_Bool bFound =
994 #endif
995 rLines.GetColumns().Seek_Entry( &aCol, &nCol );
996 ASSERT( bFound, "couldn't find column" );
997 }
998
999 // --> OD 2009-03-19 #i95726#
1000 // Some fault tolerance, if table is somehow corrupted.
1001 if ( nCol < nOldCol )
1002 {
1003 ASSERT( false, "table and/or table information seems to be corrupted." );
1004 if ( nBox == nBoxes - 1 )
1005 {
1006 nCol = rLines.GetColumns().Count() - 1;
1007 }
1008 else
1009 {
1010 nCol = nOldCol;
1011 }
1012 }
1013 // <--
1014
1015 sal_uInt16 nColSpan = nCol - nOldCol + 1U;
1016
1017 if ( nRowSpan >= 1 )
1018 ExportTableBox( *pBox, nColSpan, static_cast< sal_uInt16 >(nRowSpan), rTblInfo );
1019
1020 for( sal_uInt16 i=nOldCol; i<nCol; i++ )
1021 {
1022 SvXMLElementExport aElemExport( *this, XML_NAMESPACE_TABLE,
1023 XML_COVERED_TABLE_CELL, sal_True,
1024 sal_False );
1025 }
1026
1027 nCol++;
1028 }
1029 }
1030 }
1031
1032 void SwXMLExport::ExportTableLines( const SwTableLines& rLines,
1033 SwXMLTableInfo_Impl& rTblInfo,
1034 USHORT nHeaderRows )
1035 {
1036 ASSERT( pTableLines && pTableLines->Count(),
1037 "SwXMLExport::ExportTableLines: table columns infos missing" );
1038 if( !pTableLines || 0 == pTableLines->Count() )
1039 return;
1040
1041 SwXMLTableLines_Impl *pLines = 0;
1042 sal_uInt16 nInfoPos;
1043 for( nInfoPos=0; nInfoPos < pTableLines->Count(); nInfoPos++ )
1044 {
1045 if( pTableLines->GetObject( nInfoPos )->GetLines() == &rLines )
1046 {
1047 pLines = pTableLines->GetObject( nInfoPos );
1048 break;
1049 }
1050 }
1051 ASSERT( pLines,
1052 "SwXMLExport::ExportTableLines: table columns info missing" );
1053 ASSERT( 0==nInfoPos,
1054 "SwXMLExport::ExportTableLines: table columns infos are unsorted" );
1055 if( !pLines )
1056 return;
1057
1058 pTableLines->Remove( nInfoPos );
1059 if( 0 == pTableLines->Count() )
1060 {
1061 delete pTableLines ;
1062 pTableLines = 0;
1063 }
1064
1065 // pass 2: export columns
1066 const SwXMLTableColumns_Impl& rCols = pLines->GetColumns();
1067 sal_uInt16 nColumn = 0U;
1068 sal_uInt16 nColumns = rCols.Count();
1069 sal_uInt16 nColRep = 1U;
1070 SwXMLTableColumn_Impl *pColumn = (nColumns > 0) ? rCols[0U] : 0;
1071 while( pColumn )
1072 {
1073 nColumn++;
1074 SwXMLTableColumn_Impl *pNextColumn =
1075 (nColumn < nColumns) ? rCols[nColumn] : 0;
1076 if( pNextColumn &&
1077 pNextColumn->GetStyleName() == pColumn->GetStyleName() )
1078 {
1079 nColRep++;
1080 }
1081 else
1082 {
1083 AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME,
1084 EncodeStyleName(pColumn->GetStyleName()) );
1085
1086 if( nColRep > 1U )
1087 {
1088 OUStringBuffer sTmp(4);
1089 sTmp.append( (sal_Int32)nColRep );
1090 AddAttribute( XML_NAMESPACE_TABLE, XML_NUMBER_COLUMNS_REPEATED,
1091 sTmp.makeStringAndClear() );
1092 }
1093
1094 {
1095 SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
1096 XML_TABLE_COLUMN, sal_True, sal_True );
1097 }
1098
1099 nColRep = 1U;
1100 }
1101 pColumn = pNextColumn;
1102 }
1103
1104 // pass 3: export line/rows
1105 sal_uInt16 nLines = rLines.Count();
1106 // export header rows, if present
1107 if( nHeaderRows > 0 )
1108 {
1109 SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE,
1110 XML_TABLE_HEADER_ROWS, sal_True, sal_True );
1111
1112 DBG_ASSERT( nHeaderRows <= nLines, "more headers then lines?" );
1113 for( sal_uInt16 nLine = 0U; nLine < nHeaderRows; nLine++ )
1114 ExportTableLine( *(rLines[nLine]), *pLines, rTblInfo );
1115 }
1116 // export remaining rows
1117 for( sal_uInt16 nLine = nHeaderRows; nLine < nLines; nLine++ )
1118 {
1119 ExportTableLine( *(rLines[nLine]), *pLines, rTblInfo );
1120 }
1121
1122 delete pLines;
1123 }
1124
1125 sal_Bool lcl_xmltble_ClearName_Line( const SwTableLine*& rpLine, void* );
1126
1127 sal_Bool lcl_xmltble_ClearName_Box( const SwTableBox*& rpBox, void* )
1128 {
1129 if( !rpBox->GetSttNd() )
1130 {
1131 ((SwTableBox *)rpBox)->GetTabLines().ForEach(
1132 &lcl_xmltble_ClearName_Line, 0 );
1133 }
1134 else
1135 {
1136 SwFrmFmt *pFrmFmt = ((SwTableBox *)rpBox)->GetFrmFmt();
1137 if( pFrmFmt && pFrmFmt->GetName().Len() )
1138 pFrmFmt->SetName( aEmptyStr );
1139 }
1140
1141 return sal_True;
1142 }
1143
1144 sal_Bool lcl_xmltble_ClearName_Line( const SwTableLine*& rpLine, void* )
1145 {
1146 ((SwTableLine *)rpLine)->GetTabBoxes().ForEach(
1147 &lcl_xmltble_ClearName_Box, 0 );
1148
1149 return sal_True;
1150 }
1151
1152 void SwXMLExport::ExportTable( const SwTableNode& rTblNd )
1153 {
1154 const SwTable& rTbl = rTblNd.GetTable();
1155 const SwFrmFmt *pTblFmt = rTbl.GetFrmFmt();
1156 if( pTblFmt && pTblFmt->GetName().Len() )
1157 {
1158 AddAttribute( XML_NAMESPACE_TABLE, XML_NAME, pTblFmt->GetName() );
1159 AddAttribute( XML_NAMESPACE_TABLE, XML_STYLE_NAME,
1160 EncodeStyleName( pTblFmt->GetName() ) );
1161 }
1162
1163 {
1164 SvXMLElementExport aElem( *this, XML_NAMESPACE_TABLE, XML_TABLE,
1165 sal_True, sal_True );
1166
1167 // export DDE source (if this is a DDE table)
1168 if ( rTbl.ISA(SwDDETable) )
1169 {
1170 // get DDE Field Type (contains the DDE connection)
1171 const SwDDEFieldType* pDDEFldType =
1172 ((SwDDETable&)rTbl).GetDDEFldType();
1173
1174 // connection name
1175 AddAttribute( XML_NAMESPACE_OFFICE, XML_NAME,
1176 pDDEFldType->GetName() );
1177
1178 // DDE command
1179 const String sCmd = pDDEFldType->GetCmd();
1180 AddAttribute( XML_NAMESPACE_OFFICE, XML_DDE_APPLICATION,
1181 sCmd.GetToken(0, sfx2::cTokenSeperator) );
1182 AddAttribute( XML_NAMESPACE_OFFICE, XML_DDE_ITEM,
1183 sCmd.GetToken(1, sfx2::cTokenSeperator) );
1184 AddAttribute( XML_NAMESPACE_OFFICE, XML_DDE_TOPIC,
1185 sCmd.GetToken(2, sfx2::cTokenSeperator) );
1186
1187 // auto update
1188 if (pDDEFldType->GetType() == sfx2::LINKUPDATE_ALWAYS)
1189 {
1190 AddAttribute( XML_NAMESPACE_OFFICE,
1191 XML_AUTOMATIC_UPDATE, XML_TRUE );
1192 }
1193
1194 // DDE source element (always empty)
1195 SvXMLElementExport aSource(*this, XML_NAMESPACE_OFFICE,
1196 XML_DDE_SOURCE, sal_True, sal_False);
1197 }
1198
1199 SwXMLTableInfo_Impl aTblInfo( &rTbl );
1200 ExportTableLines( rTbl.GetTabLines(), aTblInfo, rTbl.GetRowsToRepeat() );
1201
1202 ((SwTable &)rTbl).GetTabLines().ForEach( &lcl_xmltble_ClearName_Line,
1203 0 );
1204 }
1205 }
1206
1207 void SwXMLTextParagraphExport::exportTable(
1208 const Reference < XTextContent > & rTextContent,
1209 sal_Bool bAutoStyles, sal_Bool _bProgress )
1210 {
1211 sal_Bool bOldShowProgress = ((SwXMLExport&)GetExport()).IsShowProgress();
1212 ((SwXMLExport&)GetExport()).SetShowProgress( _bProgress );
1213
1214 Reference < XTextTable > xTxtTbl( rTextContent, UNO_QUERY );
1215 DBG_ASSERT( xTxtTbl.is(), "text table missing" );
1216 if( xTxtTbl.is() )
1217 {
1218 const SwXTextTable *pXTable = 0;
1219 Reference<XUnoTunnel> xTableTunnel( rTextContent, UNO_QUERY);
1220 if( xTableTunnel.is() )
1221 {
1222 pXTable = reinterpret_cast< SwXTextTable * >(
1223 sal::static_int_cast< sal_IntPtr >( xTableTunnel->getSomething( SwXTextTable::getUnoTunnelId() )));
1224 ASSERT( pXTable, "SwXTextTable missing" );
1225 }
1226 if( pXTable )
1227 {
1228 SwFrmFmt *pFmt = pXTable->GetFrmFmt();
1229 ASSERT( pFmt, "table format missing" );
1230 const SwTable *pTbl = SwTable::FindTable( pFmt );
1231 ASSERT( pTbl, "table missing" );
1232 const SwTableNode *pTblNd = pTbl->GetTableNode();
1233 ASSERT( pTblNd, "table node missing" );
1234 if( bAutoStyles )
1235 {
1236 SwNodeIndex aIdx( *pTblNd );
1237 // AUTOSTYLES: Optimization: Do not export table autostyle if
1238 // we are currently exporting the content.xml stuff and
1239 // the table is located in header/footer:
1240 // #144704: During the flat XML export (used e.g. by .sdw-export)
1241 // ALL flags are set at the same time.
1242 const bool bExportStyles = ( GetExport().getExportFlags() & EXPORT_STYLES ) != 0;
1243 if ( bExportStyles || !pFmt->GetDoc()->IsInHeaderFooter( aIdx ) )
1244 ((SwXMLExport&)GetExport()).ExportTableAutoStyles( *pTblNd );
1245 }
1246 else
1247 {
1248 ((SwXMLExport&)GetExport()).ExportTable( *pTblNd );
1249 }
1250 }
1251 }
1252
1253 ((SwXMLExport&)GetExport()).SetShowProgress( bOldShowProgress );
1254 }
1255
1256
vba interoperability for OOo