sw/source/filter/xml/xmltble.cxx

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