sw/source/filter/ww8/WW8TableInfo.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 <iostream>
  21 #include <set>
  22 #include <stdio.h>
  23 #include "WW8TableInfo.hxx"
  24 #include "fmtfsize.hxx"
  25 #include "attributeoutputbase.hxx"
  26 #include "swtable.hxx"
  27 #include "frmfmt.hxx"
  28 #include "pam.hxx"
  29 #include "ndtxt.hxx"
  30 #include "dbgoutsw.hxx"
  31
  32 namespace ww8
  33 {
  34
  35 WW8TableNodeInfoInner::WW8TableNodeInfoInner(WW8TableNodeInfo * pParent)
  36 : mpParent(pParent)
  37 , mnDepth(0)
  38 , mnCell(0)
  39 , mnRow(0)
  40 , mnShadowsBefore(0)
  41 , mnShadowsAfter(0)
  42 , mbEndOfLine(false)
  43 , mbFinalEndOfLine(false)
  44 , mbEndOfCell(false)
  45 , mbFirstInTable(false)
  46 , mbVertMerge(false)
  47 , mpTableBox(nullptr)
  48 , mpTable(nullptr)
  49 {
  50 }
  51
  52 WW8TableNodeInfoInner::~WW8TableNodeInfoInner()
  53 {
  54 }
  55
  56 void WW8TableNodeInfoInner::setDepth(sal_uInt32 nDepth)
  57 {
  58     mnDepth = nDepth;
  59 }
  60
  61 void WW8TableNodeInfoInner::setCell(sal_uInt32 nCell)
  62 {
  63     mnCell = nCell;
  64 }
  65
  66 void WW8TableNodeInfoInner::setRow(sal_uInt32 nRow)
  67 {
  68     mnRow = nRow;
  69 }
  70
  71 void WW8TableNodeInfoInner::setShadowsBefore(sal_uInt32 nShadowsBefore)
  72 {
  73     mnShadowsBefore = nShadowsBefore;
  74 }
  75
  76 void WW8TableNodeInfoInner::setShadowsAfter(sal_uInt32 nShadowsAfter)
  77 {
  78     mnShadowsAfter = nShadowsAfter;
  79 }
  80
  81 void WW8TableNodeInfoInner::setEndOfLine(bool bEndOfLine)
  82 {
  83     mbEndOfLine = bEndOfLine;
  84 }
  85
  86 void WW8TableNodeInfoInner::setFinalEndOfLine(bool bFinalEndOfLine)
  87 {
  88     mbFinalEndOfLine = bFinalEndOfLine;
  89 }
  90
  91 void WW8TableNodeInfoInner::setEndOfCell(bool bEndOfCell)
  92 {
  93     mbEndOfCell = bEndOfCell;
  94 }
  95
  96 void WW8TableNodeInfoInner::setFirstInTable(bool bFirstInTable)
  97 {
  98     mbFirstInTable = bFirstInTable;
  99 }
 100
 101 void WW8TableNodeInfoInner::setVertMerge(bool bVertMerge)
 102
 103 {
 104     mbVertMerge = bVertMerge;
 105 }
 106
 107 void WW8TableNodeInfoInner::setTableBox(const SwTableBox * pTableBox)
 108 {
 109     mpTableBox = pTableBox;
 110 }
 111
 112 void WW8TableNodeInfoInner::setTable(const SwTable * pTable)
 113 {
 114     mpTable = pTable;
 115 }
 116
 117 void WW8TableNodeInfoInner::setRect(const SwRect & rRect)
 118 {
 119     maRect = rRect;
 120 }
 121
 122
 123 const SwNode * WW8TableNodeInfoInner::getNode() const
 124 {
 125     const SwNode * pResult = nullptr;
 126
 127     if (mpParent != nullptr)
 128         pResult = mpParent->getNode();
 129
 130     return pResult;
 131 }
 132
 133 TableBoxVectorPtr WW8TableNodeInfoInner::getTableBoxesOfRow()
 134 {
 135     TableBoxVectorPtr pResult(new TableBoxVector);
 136
 137     WW8TableCellGrid::Pointer_t pCellGrid =
 138         mpParent->getParent()->getCellGridForTable(getTable(), false);
 139
 140     if (pCellGrid.get() == nullptr)
 141     {
 142         const SwTableLine * pTabLine = getTableBox()->GetUpper();
 143         const SwTableBoxes & rTableBoxes = pTabLine->GetTabBoxes();
 144
 145         sal_uInt8 nBoxes = rTableBoxes.size();
 146         if (nBoxes > MAXTABLECELLS)
 147             nBoxes = MAXTABLECELLS;
 148         for ( sal_uInt8 n = 0; n < nBoxes; n++ )
 149         {
 150             pResult->push_back(rTableBoxes[n]);
 151         }
 152     }
 153     else
 154         pResult = pCellGrid->getTableBoxesOfRow(this);
 155
 156     return pResult;
 157 }
 158
 159 GridColsPtr WW8TableNodeInfoInner::getGridColsOfRow(AttributeOutputBase & rBase, bool calculateColumnsFromAllRows)
 160 {
 161     GridColsPtr pResult(new GridCols);
 162     WidthsPtr pWidths;
 163
 164     // Check which columns should be checked - only the current row,
 165     // or all the rows together
 166     if (calculateColumnsFromAllRows)
 167     {
 168                 // Calculate the width of all the columns based on ALL the rows.
 169         // The difference is that this kind of draws vertical lines,
 170         // so that if the rows look like this:
 171         //
 172         //  ------------------------
 173         //  |                   |  |
 174         //  ------------------------
 175         //  |   |                  |
 176         //  ------------------------
 177         //  |       |              |
 178         //  ------------------------
 179
 180         // then the actual column widths will be broken down like this:
 181         //
 182         //  ------------------------
 183         //  |   |   |           |  |
 184         //  ------------------------
 185
 186         // See the example at
 187         // http://officeopenxml.com/WPtableGrid.php
 188         // Under "Word 2007 Example"
 189         pWidths = getColumnWidthsBasedOnAllRows();
 190     }
 191     else
 192     {
 193         // Calculate the width of all the columns based on the current row
 194         pWidths = getWidthsOfRow();
 195     }
 196
 197     const SwFrameFormat *pFormat = getTable()->GetFrameFormat();
 198     OSL_ENSURE(pFormat,"Impossible");
 199     if (!pFormat)
 200         return pResult;
 201
 202     const SwFormatFrameSize &rSize = pFormat->GetFrameSize();
 203     unsigned long nTableSz = static_cast<unsigned long>(rSize.GetWidth());
 204
 205     long nPageSize = 0;
 206     bool bRelBoxSize = false;
 207
 208     rBase.GetTablePageSize( this, nPageSize, bRelBoxSize );
 209
 210     SwTwips nSz = 0;
 211     Widths::const_iterator aWidthsEnd = pWidths->end();
 212     for ( Widths::const_iterator aIt = pWidths->begin();
 213           aIt != aWidthsEnd;
 214           ++aIt)
 215     {
 216         nSz += *aIt;
 217         SwTwips nCalc = nSz;
 218         if ( bRelBoxSize )
 219             nCalc = ( nCalc * nPageSize ) / nTableSz;
 220
 221         pResult->push_back( nCalc );
 222     }
 223
 224     return pResult;
 225 }
 226
 227 WidthsPtr WW8TableNodeInfoInner::getColumnWidthsBasedOnAllRows()
 228 {
 229     WidthsPtr pWidths;
 230
 231     WW8TableCellGrid::Pointer_t pCellGrid =
 232         mpParent->getParent()->getCellGridForTable(getTable(), false);
 233
 234     if (pCellGrid.get() == nullptr)
 235     {
 236         const SwTable * pTable = getTable();
 237         const SwTableLines& rTableLines = pTable->GetTabLines();
 238         const size_t nNumOfLines = rTableLines.size();
 239
 240         // Go over all the rows - and for each row - calculate where
 241         // there is a separator between columns
 242         WidthsPtr pSeparators(new Widths);
 243         for ( size_t nLineIndex = 0; nLineIndex < nNumOfLines; ++nLineIndex )
 244         {
 245             const SwTableLine *pCurrentLine = rTableLines[nLineIndex];
 246             const SwTableBoxes & rTabBoxes = pCurrentLine->GetTabBoxes();
 247             size_t nBoxes = rTabBoxes.size();
 248             if (nBoxes > MAXTABLECELLS)
 249                 nBoxes = MAXTABLECELLS;
 250
 251             sal_uInt32 nSeparatorPosition = 0;
 252             for (size_t nBoxIndex = 0; nBoxIndex < nBoxes; ++nBoxIndex)
 253             {
 254                 const SwFrameFormat* pBoxFormat = rTabBoxes[ nBoxIndex ]->GetFrameFormat();
 255                 const SwFormatFrameSize& rLSz = pBoxFormat->GetFrameSize();
 256                 nSeparatorPosition += rLSz.GetWidth();
 257                 pSeparators->push_back(nSeparatorPosition);
 258             }
 259         }
 260
 261         // Sort the separator positions and remove any duplicates
 262         std::sort(pSeparators->begin(), pSeparators->end());
 263         std::vector<sal_uInt32>::iterator it = std::unique(pSeparators->begin(), pSeparators->end());
 264         pSeparators->erase(it, pSeparators->end());
 265
 266         // Calculate the widths based on the position of the unique & sorted
 267         // column separators
 268         pWidths = std::make_shared<Widths>();
 269         sal_uInt32 nPreviousWidth = 0;
 270         Widths::const_iterator aItEnd2 = pSeparators->end();
 271         for (Widths::const_iterator aIt2 = pSeparators->begin(); aIt2 != aItEnd2; ++aIt2)
 272         {
 273             sal_uInt32 nCurrentWidth = *aIt2;
 274             pWidths->push_back(nCurrentWidth - nPreviousWidth);
 275             nPreviousWidth = nCurrentWidth;
 276         }
 277     }
 278     else
 279     {
 280         pWidths = pCellGrid->getWidthsOfRow(this);
 281     }
 282
 283     return pWidths;
 284 }
 285
 286 WidthsPtr WW8TableNodeInfoInner::getWidthsOfRow()
 287 {
 288     WidthsPtr pWidths;
 289
 290     WW8TableCellGrid::Pointer_t pCellGrid =
 291         mpParent->getParent()->getCellGridForTable(getTable(), false);
 292
 293     if (pCellGrid.get() == nullptr)
 294     {
 295         const SwTableBox * pTabBox = getTableBox();
 296         const SwTableLine * pTabLine = pTabBox->GetUpper();
 297         const SwTableBoxes & rTabBoxes = pTabLine->GetTabBoxes();
 298
 299         pWidths = std::make_shared<Widths>();
 300         // number of cell written
 301         sal_uInt32 nBoxes = rTabBoxes.size();
 302         if (nBoxes > MAXTABLECELLS)
 303             nBoxes = MAXTABLECELLS;
 304
 305         for (sal_uInt32 n = 0; n < nBoxes; n++)
 306         {
 307             const SwFrameFormat* pBoxFormat = rTabBoxes[ n ]->GetFrameFormat();
 308             const SwFormatFrameSize& rLSz = pBoxFormat->GetFrameSize();
 309
 310             pWidths->push_back(rLSz.GetWidth());
 311         }
 312     }
 313     else
 314         pWidths = pCellGrid->getWidthsOfRow(this);
 315
 316     return pWidths;
 317 }
 318
 319 RowSpansPtr WW8TableNodeInfoInner::getRowSpansOfRow()
 320 {
 321     RowSpansPtr pResult(new RowSpans);
 322
 323     WW8TableCellGrid::Pointer_t pCellGrid =
 324         mpParent->getParent()->getCellGridForTable(getTable(), false);
 325
 326     if (pCellGrid.get() == nullptr)
 327     {
 328         const SwTableBox * pTabBox = getTableBox();
 329         const SwTableLine * pTabLine = pTabBox->GetUpper();
 330         const SwTableBoxes & rTabBoxes = pTabLine->GetTabBoxes();
 331
 332         sal_uInt32 nBoxes = rTabBoxes.size();
 333         if (nBoxes > MAXTABLECELLS)
 334             nBoxes = MAXTABLECELLS;
 335
 336         for (sal_uInt32 n = 0; n < nBoxes; ++n)
 337         {
 338             pResult->push_back(rTabBoxes[n]->getRowSpan());
 339         }
 340     }
 341     else
 342         pResult = pCellGrid->getRowSpansOfRow(this);
 343
 344     return pResult;
 345  }
 346
 347
 348 #ifdef DBG_UTIL
 349 std::string WW8TableNodeInfoInner::toString() const
 350 {
 351     static char buffer[256];
 352     snprintf(buffer, sizeof(buffer),
 353              "<tableinner depth=\"%" SAL_PRIuUINT32 "\""
 354              " cell=\"%" SAL_PRIuUINT32 "\""
 355              " row=\"%" SAL_PRIuUINT32 "\""
 356              " endOfCell=\"%s\""
 357              " endOfLine=\"%s\""
 358              " shadowsBefore=\"%" SAL_PRIuUINT32 "\""
 359              " shadowsAfter=\"%" SAL_PRIuUINT32 "\""
 360              " vertMerge=\"%s\"/>",
 361              mnDepth, mnCell, mnRow,
 362              mbEndOfCell ? "yes" : "no",
 363              mbEndOfLine ? "yes" : "no",
 364              mnShadowsBefore,
 365              mnShadowsAfter,
 366              mbVertMerge ? "yes" : "no");
 367
 368     return std::string(buffer);
 369 }
 370 #endif
 371
 372 WW8TableNodeInfo::WW8TableNodeInfo(WW8TableInfo * pParent,
 373                                    const SwNode * pNode)
 374 : mpParent(pParent),
 375   mnDepth(0),
 376   mpNode(pNode),
 377   mpNext(nullptr),
 378   mpNextNode(nullptr)
 379 {
 380 }
 381
 382 WW8TableNodeInfo::~WW8TableNodeInfo()
 383 {
 384 }
 385
 386 #ifdef DBG_UTIL
 387 std::string WW8TableNodeInfo::toString() const
 388 {
 389     static char buffer[1024];
 390     snprintf(buffer, sizeof(buffer),
 391              "<tableNodeInfo p=\"%p\" depth=\"%" SAL_PRIuUINT32 "\">"
 392              ,this, getDepth());
 393
 394     std::string sResult(buffer);
 395
 396     Inners_t::const_iterator aIt(mInners.begin());
 397     Inners_t::const_iterator aEnd(mInners.end());
 398
 399     while (aIt != aEnd)
 400     {
 401         WW8TableNodeInfoInner::Pointer_t pInner = aIt->second;
 402         sResult += pInner->toString();
 403
 404         ++aIt;
 405     }
 406     sResult += dbg_out(*mpNode);
 407     sResult += "</tableNodeInfo>";
 408
 409     return sResult;
 410 }
 411 #endif
 412
 413 void WW8TableNodeInfo::setDepth(sal_uInt32 nDepth)
 414 {
 415     mnDepth = nDepth;
 416
 417     Inners_t::iterator aIt = mInners.find(mnDepth);
 418
 419     if (aIt == mInners.end())
 420         mInners[mnDepth] = std::make_shared<ww8::WW8TableNodeInfoInner>(this);
 421
 422     mInners[mnDepth]->setDepth(mnDepth);
 423 }
 424
 425 void WW8TableNodeInfo::setEndOfLine(bool bEndOfLine)
 426 {
 427     WW8TableNodeInfoInner::Pointer_t pInner = getInnerForDepth(mnDepth);
 428     pInner->setEndOfLine(bEndOfLine);
 429
 430 #ifdef DBG_UTIL
 431     SAL_INFO( "sw.ww8", "<endOfLine depth=\"" << mnDepth << "\">" << toString() << "</endOfLine>" );
 432 #endif
 433 }
 434
 435 void WW8TableNodeInfo::setEndOfCell(bool bEndOfCell)
 436 {
 437     WW8TableNodeInfoInner::Pointer_t pInner = getInnerForDepth(mnDepth);
 438     pInner->setEndOfCell(bEndOfCell);
 439
 440 #ifdef DBG_UTIL
 441     SAL_INFO( "sw.ww8", "<endOfCell depth=\"" << mnDepth << "\">" << toString() << "</endOfCell>" );
 442 #endif
 443 }
 444
 445 void WW8TableNodeInfo::setFirstInTable(bool bFirstInTable)
 446 {
 447     WW8TableNodeInfoInner::Pointer_t pInner = getInnerForDepth(mnDepth);
 448
 449     pInner->setFirstInTable(bFirstInTable);
 450
 451 #ifdef DBG_UTIL
 452     SAL_INFO( "sw.ww8", "<firstInTable depth=\"" << mnDepth << "\">" << toString() << "</firstInTable>" );
 453 #endif
 454 }
 455
 456 void WW8TableNodeInfo::setVertMerge(bool bVertMerge)
 457 {
 458     WW8TableNodeInfoInner::Pointer_t pInner = getInnerForDepth(mnDepth);
 459
 460     pInner->setVertMerge(bVertMerge);
 461
 462 #ifdef DBG_UTIL
 463     SAL_INFO( "sw.ww8", "<vertMerge depth=\"" << mnDepth << "\">" << toString() << "</vertMerge>" );
 464 #endif
 465 }
 466
 467 void WW8TableNodeInfo::setTableBox(const SwTableBox * pTableBox)
 468 {
 469     getInnerForDepth(mnDepth)->setTableBox(pTableBox);
 470 }
 471
 472 void WW8TableNodeInfo::setTable(const SwTable * pTable)
 473 {
 474     getInnerForDepth(mnDepth)->setTable(pTable);
 475 }
 476
 477 void WW8TableNodeInfo::setNext(WW8TableNodeInfo * pNext)
 478 {
 479     mpNext = pNext;
 480
 481 #ifdef DBG_UTIL
 482     SAL_INFO( "sw.ww8", "<setnext><from>" << toString() << "</from><to>" << pNext->toString() << "</to></setnext>" );
 483 #endif
 484 }
 485
 486 void WW8TableNodeInfo::setNextNode(const SwNode * pNode)
 487 {
 488     mpNextNode = pNode;
 489 }
 490
 491 void WW8TableNodeInfo::setRect(const SwRect & rRect)
 492 {
 493     getInnerForDepth(mnDepth)->setRect(rRect);
 494 }
 495
 496 void WW8TableNodeInfo::setCell(sal_uInt32 nCell)
 497 {
 498     getInnerForDepth(mnDepth)->setCell(nCell);
 499 }
 500
 501 void WW8TableNodeInfo::setRow(sal_uInt32 nRow)
 502 {
 503     getInnerForDepth(mnDepth)->setRow(nRow);
 504 }
 505
 506 void WW8TableNodeInfo::setShadowsBefore(sal_uInt32 nShadowsBefore)
 507 {
 508     getInnerForDepth(mnDepth)->setShadowsBefore(nShadowsBefore);
 509 }
 510
 511 void WW8TableNodeInfo::setShadowsAfter(sal_uInt32 nShadowsAfter)
 512 {
 513     getInnerForDepth(mnDepth)->setShadowsAfter(nShadowsAfter);
 514 }
 515
 516
 517 sal_uInt32 WW8TableNodeInfo::getDepth() const
 518 {
 519     if (!mInners.empty())
 520         return mInners.begin()->second->getDepth();
 521
 522     return mnDepth;
 523 }
 524
 525
 526 const SwTableBox * WW8TableNodeInfo::getTableBox() const
 527 {
 528     return getInnerForDepth(mnDepth)->getTableBox();
 529 }
 530
 531 sal_uInt32 WW8TableNodeInfo::getCell() const
 532 {
 533     return getInnerForDepth(mnDepth)->getCell();
 534 }
 535
 536 sal_uInt32 WW8TableNodeInfo::getRow() const
 537 {
 538     return getInnerForDepth(mnDepth)->getRow();
 539 }
 540
 541 const WW8TableNodeInfoInner::Pointer_t WW8TableNodeInfo::getFirstInner() const
 542 {
 543     WW8TableNodeInfoInner::Pointer_t pResult;
 544
 545     if (!mInners.empty())
 546         pResult = mInners.begin()->second;
 547
 548     return pResult;
 549 }
 550
 551 const WW8TableNodeInfoInner::Pointer_t WW8TableNodeInfo::getInnerForDepth(sal_uInt32 nDepth) const
 552 {
 553     WW8TableNodeInfoInner::Pointer_t pResult;
 554
 555     Inners_t::const_iterator aIt = mInners.find(nDepth);
 556     if (aIt != mInners.end())
 557     {
 558         pResult = aIt->second;
 559     }
 560
 561     return pResult;
 562 }
 563
 564 WW8TableInfo::WW8TableInfo()
 565 {
 566 }
 567
 568 WW8TableInfo::~WW8TableInfo()
 569 {
 570 }
 571
 572 WW8TableNodeInfo *
 573 WW8TableInfo::processSwTableByLayout(const SwTable * pTable, RowEndInners_t &rLastRowEnds)
 574 {
 575     SwTableCellInfo aTableCellInfo(pTable);
 576
 577     while (aTableCellInfo.getNext())
 578     {
 579         SwRect aRect = aTableCellInfo.getRect();
 580
 581         SAL_INFO( "sw.ww8", "<CellFrame>" );
 582         SAL_INFO( "sw.ww8", "<rect top=\"" << aRect.Top() << "\" bottom=\"" << aRect.Bottom()
 583             << "\" left=\"" << aRect.Left() << "\" right=\"" << aRect.Right() << "\"/>" );
 584         const SwTableBox * pTableBox = aTableCellInfo.getTableBox();
 585         const SwStartNode * pSttNd = pTableBox->GetSttNd();
 586
 587         if (pSttNd != nullptr)
 588         {
 589             SwPaM aPam(*pSttNd, 0);
 590
 591             bool bDone = false;
 592             do
 593             {
 594                 SwNode & rNode = aPam.GetPoint()->nNode.GetNode();
 595
 596                 insertTableNodeInfo(&rNode, pTable, pTableBox, 0, 0, 1, & aRect);
 597
 598                 if (rNode.IsEndNode())
 599                 {
 600                     SwEndNode * pEndNode = rNode.GetEndNode();
 601                     SwStartNode * pTmpSttNd = pEndNode->StartOfSectionNode();
 602
 603                     if (pTmpSttNd == pSttNd)
 604                         bDone = true;
 605                 }
 606
 607                 aPam.GetPoint()->nNode++;
 608             }
 609             while (!bDone);
 610         }
 611
 612         SAL_INFO( "sw.ww8", "</CellFrame>" );
 613     }
 614
 615     return reorderByLayout(pTable, rLastRowEnds);
 616 }
 617
 618 void WW8TableInfo::processSwTable(const SwTable * pTable)
 619 {
 620     SAL_INFO( "sw.ww8", "<processSwTable>" );
 621
 622     WW8TableNodeInfo * pPrev = nullptr;
 623     RowEndInners_t aLastRowEnds;
 624
 625     if (pTable->IsTableComplex() && pTable->HasLayout())
 626     {
 627         pPrev = processSwTableByLayout(pTable, aLastRowEnds);
 628 #ifdef DBG_UTIL
 629         SAL_INFO( "sw.ww8", getCellGridForTable(pTable)->toString());
 630 #endif
 631     }
 632     else
 633     {
 634         const SwTableLines & rLines = pTable->GetTabLines();
 635
 636         for (size_t n = 0; n < rLines.size(); ++n)
 637         {
 638             const SwTableLine * pLine = rLines[n];
 639
 640             pPrev = processTableLine(pTable, pLine, static_cast<sal_uInt32>(n), 1, pPrev, aLastRowEnds);
 641         }
 642
 643     }
 644
 645     if (pPrev)
 646     {
 647         SwTableNode * pTableNode = pTable->GetTableNode();
 648         SwEndNode * pEndNode = pTableNode->EndOfSectionNode();
 649         pPrev->setNextNode(pEndNode);
 650         assert(!aLastRowEnds.empty());
 651         for (auto &a : aLastRowEnds)
 652         {
 653             assert(a.second->isEndOfLine());
 654             a.second->setFinalEndOfLine(true);
 655         }
 656     }
 657     SAL_INFO( "sw.ww8", "</processSwTable>" );
 658 }
 659
 660 WW8TableNodeInfo *
 661 WW8TableInfo::processTableLine(const SwTable * pTable,
 662                                const SwTableLine * pTableLine,
 663                                sal_uInt32 nRow,
 664                                sal_uInt32 nDepth,
 665                                WW8TableNodeInfo * pPrev,
 666                                RowEndInners_t &rLastRowEnds)
 667 {
 668     SAL_INFO( "sw.ww8", "<processTableLine row=\"" << nRow << "\" depth=\"" << nDepth << "\">" );
 669
 670     const SwTableBoxes & rBoxes = pTableLine->GetTabBoxes();
 671
 672     WW8TableNodeInfo::Pointer_t pTextNodeInfo;
 673
 674     for (size_t n = 0; n < rBoxes.size(); ++n)
 675     {
 676         const SwTableBox * pBox = rBoxes[n];
 677
 678         pPrev = processTableBox(pTable, pBox, nRow, static_cast<sal_uInt32>(n), nDepth, n == rBoxes.size() - 1, pPrev, rLastRowEnds);
 679     }
 680
 681     SAL_INFO( "sw.ww8", "</processTableLine>" );
 682
 683     return pPrev;
 684 }
 685
 686 WW8TableNodeInfo::Pointer_t
 687 WW8TableInfo::processTableBoxLines(const SwTableBox * pBox,
 688                                    const SwTable * pTable,
 689                                    const SwTableBox * pBoxToSet,
 690                                    sal_uInt32 nRow,
 691                                    sal_uInt32 nCell,
 692                                    sal_uInt32 nDepth)
 693 {
 694     SAL_INFO( "sw.ww8", "<processTableBoxLines depth=\"" << nDepth << "\" row=\"" << nRow
 695         << "\" cell=\"" << nCell << "\">" );
 696
 697     const SwTableLines & rLines = pBox->GetTabLines();
 698     WW8TableNodeInfo::Pointer_t pNodeInfo;
 699
 700     if (!rLines.empty())
 701     {
 702         for (size_t n = 0; n < rLines.size(); ++n)
 703         {
 704             const SwTableLine * pLine = rLines[n];
 705             const SwTableBoxes & rBoxes = pLine->GetTabBoxes();
 706
 707             for (size_t nBox = 0; nBox < rBoxes.size(); ++nBox)
 708                 pNodeInfo = processTableBoxLines(rBoxes[nBox], pTable, pBoxToSet, nRow, nCell, nDepth);
 709         }
 710     }
 711     else
 712     {
 713         const SwStartNode * pSttNd = pBox->GetSttNd();
 714         const SwEndNode * pEndNd = pSttNd->EndOfSectionNode();
 715         SwPaM aPaM(*pSttNd, 0);
 716         SwPaM aEndPaM(*pEndNd, 0);
 717
 718         bool bDone = false;
 719         while (!bDone)
 720         {
 721             SwNode & rNode = aPaM.GetPoint()->nNode.GetNode();
 722
 723             pNodeInfo = insertTableNodeInfo(&rNode, pTable, pBoxToSet, nRow, nCell, nDepth);
 724
 725             if (aPaM.GetPoint()->nNode == aEndPaM.GetPoint()->nNode)
 726                 bDone = true;
 727             else
 728                 aPaM.GetPoint()->nNode++;
 729         }
 730     }
 731
 732     SAL_INFO( "sw.ww8", "</processTableBoxLines>" );
 733
 734     return pNodeInfo;
 735 }
 736
 737 void updateFinalEndOfLine(RowEndInners_t &rLastRowEnds, WW8TableNodeInfo* pEndOfCellInfo)
 738 {
 739     sal_Int32 nDepth = pEndOfCellInfo->getDepth();
 740     WW8TableNodeInfoInner::Pointer_t pInner = pEndOfCellInfo->getInnerForDepth(nDepth);
 741
 742     auto aIt = rLastRowEnds.find(nDepth);
 743     if (aIt == rLastRowEnds.end() || (pInner->getRow() > aIt->second->getRow()))
 744         rLastRowEnds[nDepth] = pInner.get();
 745 }
 746
 747 WW8TableNodeInfo *
 748 WW8TableInfo::processTableBox(const SwTable * pTable,
 749                               const SwTableBox * pBox,
 750                               sal_uInt32 nRow,
 751                               sal_uInt32 nCell,
 752                               sal_uInt32 nDepth,
 753                               bool bEndOfLine,
 754                               WW8TableNodeInfo * pPrev,
 755                               RowEndInners_t &rLastRowEnds)
 756 {
 757     SAL_INFO( "sw.ww8", "<processTableBox row=\"" << nRow << "\" cell=\"" << nCell
 758         << "\" depth=\"" << nDepth << "\">" );
 759
 760     WW8TableNodeInfo::Pointer_t pNodeInfo;
 761     const SwTableLines & rLines = pBox->GetTabLines();
 762     const SwStartNode * pSttNd = pBox->GetSttNd();
 763     WW8TableNodeInfo::Pointer_t pEndOfCellInfo;
 764
 765     if (!rLines.empty())
 766     {
 767         pNodeInfo = processTableBoxLines(pBox, pTable, pBox, nRow, nCell, nDepth);
 768         pNodeInfo->setEndOfCell(true);
 769         if (bEndOfLine)
 770         {
 771             pNodeInfo->setEndOfLine(true);
 772             updateFinalEndOfLine(rLastRowEnds, pNodeInfo.get());
 773         }
 774
 775         for (size_t n = 0; n < rLines.size(); n++)
 776         {
 777             const SwTableLine * pLine = rLines[n];
 778
 779             pPrev = processTableLine(pTable, pLine, n, 1, pPrev, rLastRowEnds);
 780         }
 781     }
 782     else
 783     {
 784         SwPaM aPaM(*pSttNd, 0);
 785
 786         bool bDone = false;
 787         sal_uInt32 nDepthInsideCell = 0;
 788
 789         do
 790         {
 791             SwNode & rNode = aPaM.GetPoint()->nNode.GetNode();
 792
 793             if (rNode.IsStartNode())
 794             {
 795                 if (nDepthInsideCell > 0)
 796                     pEndOfCellInfo.reset();
 797
 798                 nDepthInsideCell++;
 799             }
 800
 801             pNodeInfo = insertTableNodeInfo(&rNode, pTable, pBox, nRow, nCell, nDepth);
 802
 803             if (pPrev)
 804                 pPrev->setNext(pNodeInfo.get());
 805
 806             pPrev = pNodeInfo.get();
 807
 808             if (nDepthInsideCell == 1 && rNode.IsTextNode())
 809                 pEndOfCellInfo = pNodeInfo;
 810
 811             if (rNode.IsEndNode())
 812             {
 813                 nDepthInsideCell--;
 814
 815                 if (nDepthInsideCell == 0 && !pEndOfCellInfo)
 816                     pEndOfCellInfo = pNodeInfo;
 817
 818                 SwEndNode * pEndNode = rNode.GetEndNode( );
 819                 SwStartNode * pTmpSttNd = pEndNode->StartOfSectionNode();
 820                 if (pTmpSttNd == pSttNd)
 821                     bDone = true;
 822             }
 823
 824             aPaM.GetPoint()->nNode++;
 825         }
 826         while (!bDone);
 827
 828         if (pEndOfCellInfo.get() != nullptr)
 829         {
 830             pEndOfCellInfo->setEndOfCell(true);
 831
 832             if (bEndOfLine)
 833             {
 834                 pEndOfCellInfo->setEndOfLine(true);
 835                 updateFinalEndOfLine(rLastRowEnds, pEndOfCellInfo.get());
 836             }
 837         }
 838     }
 839
 840     SAL_INFO( "sw.ww8", "</processTableBox>" );
 841
 842     return pPrev;
 843 }
 844
 845 WW8TableNodeInfo::Pointer_t WW8TableInfo::insertTableNodeInfo
 846 (const SwNode * pNode,
 847  const SwTable * pTable,
 848  const SwTableBox * pTableBox,
 849  sal_uInt32 nRow,
 850  sal_uInt32 nCell,
 851  sal_uInt32 nDepth,
 852  SwRect * pRect)
 853 {
 854     WW8TableNodeInfo::Pointer_t pNodeInfo = getTableNodeInfo(pNode);
 855
 856     if (pNodeInfo.get() == nullptr)
 857     {
 858         pNodeInfo =
 859             std::make_shared<ww8::WW8TableNodeInfo>(this, pNode);
 860         mMap.insert(Map_t::value_type(pNode, pNodeInfo));
 861     }
 862
 863     pNodeInfo->setDepth(nDepth + pNodeInfo->getDepth());
 864
 865     pNodeInfo->setTable(pTable);
 866     pNodeInfo->setTableBox(pTableBox);
 867
 868     pNodeInfo->setCell(nCell);
 869     pNodeInfo->setRow(nRow);
 870
 871     if (pNode->IsTextNode())
 872     {
 873         FirstInTableMap_t::const_iterator aIt = mFirstInTableMap.find(pTable);
 874         if (aIt == mFirstInTableMap.end())
 875         {
 876             mFirstInTableMap[pTable] = pNode;
 877             pNodeInfo->setFirstInTable(true);
 878         }
 879     }
 880
 881     if (pRect)
 882     {
 883         WW8TableCellGrid::Pointer_t pCellGrid = getCellGridForTable(pTable);
 884
 885         pCellGrid->insert(*pRect, pNodeInfo.get());
 886         pNodeInfo->setRect(*pRect);
 887     }
 888
 889 #ifdef DBG_UTIL
 890     SAL_INFO( "sw.ww8", pNodeInfo->toString());
 891 #endif
 892     return pNodeInfo;
 893 }
 894
 895 WW8TableCellGrid::Pointer_t WW8TableInfo::getCellGridForTable
 896 (const SwTable * pTable, bool bCreate)
 897 {
 898     WW8TableCellGrid::Pointer_t pResult;
 899     CellGridMap_t::iterator aIt = mCellGridMap.find(pTable);
 900
 901     if (aIt == mCellGridMap.end())
 902     {
 903         if (bCreate)
 904         {
 905             pResult = std::make_shared<ww8::WW8TableCellGrid>();
 906             mCellGridMap[pTable] = pResult;
 907         }
 908     }
 909     else
 910         pResult = mCellGridMap[pTable];
 911
 912     return pResult;
 913 }
 914
 915 WW8TableNodeInfo::Pointer_t WW8TableInfo::getTableNodeInfo
 916 (const SwNode * pNode)
 917 {
 918     WW8TableNodeInfo::Pointer_t pResult;
 919     Map_t::iterator aIt = mMap.find(pNode);
 920
 921     if (aIt != mMap.end())
 922         pResult = (*aIt).second;
 923
 924     return pResult;
 925 }
 926
 927 const SwNode * WW8TableInfo::getNextNode(const SwNode * pNode)
 928 {
 929     const SwNode * pResult = nullptr;
 930
 931     WW8TableNodeInfo::Pointer_t pNodeInfo = getTableNodeInfo(pNode);
 932
 933     if (pNodeInfo.get() != nullptr)
 934     {
 935         WW8TableNodeInfo * pNextInfo = pNodeInfo->getNext();
 936
 937         if (pNextInfo != nullptr)
 938             pResult = pNextInfo->getNode();
 939         else
 940         {
 941             const SwNode * pNextNode = pNodeInfo->getNextNode();
 942
 943             if (pNextNode != nullptr)
 944                 pResult = pNextNode;
 945         }
 946     }
 947
 948     return pResult;
 949 }
 950
 951 bool WW8TableNodeInfo::operator < (const WW8TableNodeInfo & rInfo) const
 952 {
 953     bool bRet = false;
 954
 955     if (rInfo.mpNode != nullptr)
 956     {
 957         if (mpNode == nullptr)
 958         {
 959             bRet = true;
 960         }
 961         else
 962         {
 963             if (mpNode->GetIndex() < rInfo.mpNode->GetIndex())
 964                 bRet = true;
 965         }
 966     }
 967
 968     return bRet;
 969 }
 970
 971 bool CellInfo::operator < (const CellInfo & aCellInfo) const
 972 {
 973     bool aRet = false;
 974
 975     if (top() < aCellInfo.top())
 976         aRet = true;
 977     else if (top() == aCellInfo.top())
 978     {
 979         if (left() < aCellInfo.left())
 980             aRet = true;
 981         else if (left() == aCellInfo.left())
 982         {
 983             if (width() < aCellInfo.width())
 984                 aRet = true;
 985             else if (width() == aCellInfo.width())
 986             {
 987                 if (height() < aCellInfo.height())
 988                     aRet = true;
 989                 else if (height() == aCellInfo.height())
 990                 {
 991                     if (aCellInfo.getTableNodeInfo())
 992                     {
 993                         if (m_pNodeInfo == nullptr)
 994                             aRet = true;
 995                         else
 996                         {
 997                             aRet = *m_pNodeInfo < *aCellInfo.getTableNodeInfo();
 998                         }
 999                     }
1000                 }
1001             }
1002         }
1003     }
1004
1005     return aRet;
1006 }
1007
1008 #ifdef DBG_UTIL
1009 std::string CellInfo::toString() const
1010 {
1011     static char sBuffer[256];
1012
1013     snprintf(sBuffer, sizeof(sBuffer),
1014              "<cellinfo left=\"%ld\""
1015              " right=\"%ld\""
1016              " top=\"%ld\""
1017              " bottom=\"%ld\""
1018              " node=\"%p\"/>",
1019              left(),
1020              right(),
1021              top(),
1022              bottom(),
1023              m_pNodeInfo);
1024
1025     return sBuffer;
1026 }
1027 #endif
1028
1029 WW8TableNodeInfo * WW8TableInfo::reorderByLayout(const SwTable * pTable, RowEndInners_t &rLastRowEnds)
1030 {
1031     WW8TableCellGrid::Pointer_t pCellGrid = getCellGridForTable(pTable);
1032
1033 #ifdef DBG_UTIL
1034     SAL_INFO( "sw.ww8", pCellGrid->toString());
1035 #endif
1036
1037     pCellGrid->addShadowCells();
1038     return pCellGrid->connectCells(rLastRowEnds);
1039 }
1040
1041 WW8TableCellGrid::WW8TableCellGrid()
1042 {
1043 }
1044
1045 WW8TableCellGrid::~WW8TableCellGrid()
1046 {
1047 }
1048
1049 WW8TableCellGridRow::Pointer_t WW8TableCellGrid::getRow(long nTop, bool bCreate)
1050 {
1051     WW8TableCellGridRow::Pointer_t pResult;
1052
1053     RowTops_t::iterator aIt = m_aRowTops.find(nTop);
1054
1055     if (aIt == m_aRowTops.end())
1056     {
1057         if (bCreate)
1058         {
1059             pResult = std::make_shared<ww8::WW8TableCellGridRow>();
1060             m_aRows[nTop] = pResult;
1061             m_aRowTops.insert(nTop);
1062         }
1063     }
1064     else
1065         pResult = m_aRows[nTop];
1066
1067     return pResult;
1068 }
1069
1070 WW8TableCellGrid::RowTops_t::const_iterator WW8TableCellGrid::getRowTopsBegin() const
1071 {
1072     return m_aRowTops.begin();
1073 }
1074
1075 WW8TableCellGrid::RowTops_t::const_iterator WW8TableCellGrid::getRowTopsEnd() const
1076 {
1077     return m_aRowTops.end();
1078 }
1079
1080 CellInfoMultiSet::const_iterator WW8TableCellGrid::getCellsBegin(long nTop)
1081 {
1082     return getRow(nTop)->begin();
1083 }
1084
1085 CellInfoMultiSet::const_iterator WW8TableCellGrid::getCellsEnd(long nTop)
1086 {
1087     return getRow(nTop)->end();
1088 }
1089
1090 void WW8TableCellGrid::insert(const SwRect & rRect,
1091                               WW8TableNodeInfo * pNodeInfo,
1092                               unsigned long * pFormatFrameWidth)
1093 {
1094     CellInfo aCellInfo(rRect, pNodeInfo);
1095
1096     if (pFormatFrameWidth != nullptr)
1097         aCellInfo.setFormatFrameWidth(*pFormatFrameWidth);
1098
1099     WW8TableCellGridRow::Pointer_t pRow = getRow(rRect.Top());
1100     pRow->insert(aCellInfo);
1101 }
1102
1103 void WW8TableCellGrid::addShadowCells()
1104 {
1105     SAL_INFO( "sw.ww8", "<addShadowCells>" );
1106
1107     RowTops_t::const_iterator aTopsIt = getRowTopsBegin();
1108
1109     while (aTopsIt != getRowTopsEnd())
1110     {
1111 #ifdef DBG_UTIL
1112         long nTop = *aTopsIt;
1113         (void) nTop;
1114 #endif
1115         CellInfoMultiSet::const_iterator aCellIt = getCellsBegin(*aTopsIt);
1116         CellInfoMultiSet::const_iterator aCellEndIt = getCellsEnd(*aTopsIt);
1117
1118         RowSpansPtr pRowSpans(new RowSpans);
1119
1120         bool bBeginningOfCell = true;
1121         bool bVertMerge = false;
1122         SwRect aRect = aCellIt->getRect();
1123         long nRowSpan = 1;
1124         while (aCellIt != aCellEndIt)
1125         {
1126             WW8TableNodeInfo * pNodeInfo = aCellIt->getTableNodeInfo();
1127
1128             if (bBeginningOfCell)
1129             {
1130                 RowTops_t::const_iterator aRowSpanIt(aTopsIt);
1131                 ++aRowSpanIt;
1132
1133                 if (aRowSpanIt != getRowTopsEnd() &&
1134                     *aRowSpanIt < aCellIt->bottom())
1135                 {
1136                     aRect.Top(*aRowSpanIt);
1137                     unsigned long nFormatFrameWidth = aCellIt->getFormatFrameWidth();
1138                     insert(aRect, nullptr, &nFormatFrameWidth);
1139
1140                     bVertMerge = true;
1141                 }
1142                 else
1143                     bVertMerge = false;
1144
1145                 nRowSpan = 1;
1146                 while (aRowSpanIt != getRowTopsEnd() &&
1147                        *aRowSpanIt < aCellIt->bottom())
1148                 {
1149                     ++aRowSpanIt;
1150                     nRowSpan++;
1151                 }
1152
1153                 if (pNodeInfo)
1154                     pRowSpans->push_back(nRowSpan);
1155                 else
1156                     pRowSpans->push_back(-nRowSpan);
1157             }
1158
1159             if (pNodeInfo)
1160             {
1161                 pNodeInfo->setVertMerge(bVertMerge);
1162             }
1163
1164             ++aCellIt;
1165             if (aCellIt != aCellEndIt)
1166             {
1167                 bBeginningOfCell = (aRect.Left() != aCellIt->left());
1168                 aRect = aCellIt->getRect();
1169             }
1170         }
1171
1172         WW8TableCellGridRow::Pointer_t pRow = getRow(*aTopsIt);
1173         if (pRow.get() != nullptr)
1174             pRow->setRowSpans(pRowSpans);
1175
1176         ++aTopsIt;
1177     }
1178     SAL_INFO( "sw.ww8", "</addShadowCells>" );
1179 }
1180
1181 WW8TableNodeInfo * WW8TableCellGrid::connectCells(RowEndInners_t &rLastRowEnds)
1182 {
1183     RowTops_t::const_iterator aTopsIt = getRowTopsBegin();
1184     sal_uInt32 nRow = 0;
1185     WW8TableNodeInfo * pLastNodeInfo = nullptr;
1186
1187     while (aTopsIt != getRowTopsEnd())
1188     {
1189         CellInfoMultiSet::const_iterator aCellIt = getCellsBegin(*aTopsIt);
1190         CellInfoMultiSet::const_iterator aCellEndIt = getCellsEnd(*aTopsIt);
1191         GridColsPtr pWidths(new Widths);
1192         TableBoxVectorPtr pTableBoxes(new TableBoxVector);
1193
1194         sal_uInt32 nShadows = 0;
1195         sal_uInt32 nCell = 0;
1196         bool bBeginningOfCell = true;
1197         WW8TableNodeInfo * pEndOfCellInfo = nullptr;
1198         sal_uInt32 nDepthInCell = 0;
1199         while (aCellIt != aCellEndIt)
1200         {
1201             long nCellX = aCellIt->left();
1202             WW8TableNodeInfo * pNodeInfo = aCellIt->getTableNodeInfo();
1203             if (pNodeInfo)
1204             {
1205                 const SwNode * pNode = pNodeInfo->getNode();
1206
1207                 if (pNode->IsStartNode())
1208                 {
1209                     nDepthInCell++;
1210                     pEndOfCellInfo = nullptr;
1211                 }
1212
1213                 if (nDepthInCell == 1 && pNode->IsTextNode())
1214                     pEndOfCellInfo = pNodeInfo;
1215
1216                 pNodeInfo->setShadowsBefore(nShadows);
1217                 pNodeInfo->setCell(nCell);
1218                 pNodeInfo->setRow(nRow);
1219                 if (pLastNodeInfo)
1220                 {
1221                     pLastNodeInfo->setNext(pNodeInfo);
1222                     pLastNodeInfo->setNextNode(pNode);
1223                 }
1224                 pLastNodeInfo = pNodeInfo;
1225                 nShadows = 0;
1226
1227                 if (pNode->IsEndNode())
1228                 {
1229                     nDepthInCell--;
1230
1231                     if (nDepthInCell == 0 && !pEndOfCellInfo)
1232                         pEndOfCellInfo = pNodeInfo;
1233                 }
1234             }
1235             else
1236             {
1237                 nShadows++;
1238             }
1239
1240             if (bBeginningOfCell)
1241             {
1242                 pWidths->push_back(aCellIt->getFormatFrameWidth());
1243
1244                 if (pNodeInfo)
1245                     pTableBoxes->push_back(pNodeInfo->getTableBox());
1246                 else
1247                     pTableBoxes->push_back(nullptr);
1248             }
1249
1250             ++aCellIt;
1251             bBeginningOfCell = false;
1252
1253             if (aCellIt != aCellEndIt && aCellIt->left() != nCellX)
1254             {
1255                 nCell++;
1256                 bBeginningOfCell = true;
1257
1258                 if (pEndOfCellInfo)
1259                 {
1260                     pEndOfCellInfo->setEndOfCell(true);
1261                 }
1262
1263                 pEndOfCellInfo = nullptr;
1264             }
1265         }
1266
1267         pLastNodeInfo->setShadowsAfter(nShadows);
1268
1269         if (!pEndOfCellInfo)
1270         {
1271             pEndOfCellInfo = pLastNodeInfo;
1272         }
1273
1274         pEndOfCellInfo->setEndOfCell(true);
1275         pLastNodeInfo->setEndOfLine(true);
1276         updateFinalEndOfLine(rLastRowEnds, pLastNodeInfo);
1277
1278         WW8TableCellGridRow::Pointer_t pRow(getRow(*aTopsIt));
1279         pRow->setTableBoxVector(pTableBoxes);
1280         pRow->setWidths(pWidths);
1281
1282         ++aTopsIt;
1283         nRow++;
1284     }
1285
1286     return pLastNodeInfo;
1287 }
1288
1289 #ifdef DBG_UTIL
1290 std::string WW8TableCellGrid::toString()
1291 {
1292     std::string sResult = "<WW8TableCellGrid>";
1293
1294     RowTops_t::const_iterator aTopsIt = getRowTopsBegin();
1295     static char sBuffer[1024];
1296     while (aTopsIt != getRowTopsEnd())
1297     {
1298         sprintf(sBuffer, "<row y=\"%ld\">", *aTopsIt);
1299         sResult += sBuffer;
1300
1301         CellInfoMultiSet::const_iterator aCellIt = getCellsBegin(*aTopsIt);
1302         CellInfoMultiSet::const_iterator aCellsEnd = getCellsEnd(*aTopsIt);
1303
1304         while (aCellIt != aCellsEnd)
1305         {
1306             snprintf(sBuffer, sizeof(sBuffer), "<cellInfo top=\"%ld\" bottom=\"%ld\" left=\"%ld\" right=\"%ld\">",
1307                      aCellIt->top(), aCellIt->bottom(), aCellIt->left(), aCellIt->right());
1308             sResult += sBuffer;
1309
1310             WW8TableNodeInfo * pInfo = aCellIt->getTableNodeInfo();
1311             if (pInfo)
1312                 sResult += pInfo->toString();
1313             else
1314                 sResult += "<shadow/>\n";
1315
1316             sResult += "</cellInfo>\n";
1317             ++aCellIt;
1318         }
1319
1320         WW8TableCellGridRow::Pointer_t pRow = getRow(*aTopsIt);
1321         WidthsPtr pWidths = pRow->getWidths();
1322         if (pWidths != nullptr)
1323         {
1324             sResult += "<widths>";
1325
1326             Widths::const_iterator aItEnd = pWidths->end();
1327             for (Widths::const_iterator aIt = pWidths->begin();
1328                  aIt != aItEnd;
1329                  ++aIt)
1330             {
1331                 if (aIt != pWidths->begin())
1332                     sResult += ", ";
1333
1334                 snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIxUINT32 "", *aIt);
1335                 sResult += sBuffer;
1336             }
1337
1338             sResult += "</widths>";
1339         }
1340
1341         RowSpansPtr pRowSpans = pRow->getRowSpans();
1342         if (pRowSpans.get() != nullptr)
1343         {
1344             sResult += "<rowspans>";
1345
1346             RowSpans::const_iterator aItEnd = pRowSpans->end();
1347             for (RowSpans::const_iterator aIt = pRowSpans->begin();
1348                  aIt != aItEnd;
1349                  ++aIt)
1350             {
1351                 if (aIt != pRowSpans->begin())
1352                     sResult += ", ";
1353
1354                 snprintf(sBuffer, sizeof(sBuffer), "%" SAL_PRIxUINT32 "", *aIt);
1355                 sResult += sBuffer;
1356             }
1357
1358             sResult += "</rowspans>";
1359         }
1360
1361         sResult += "</row>\n";
1362         ++aTopsIt;
1363     }
1364
1365     sResult += "</WW8TableCellGrid>\n";
1366
1367     return sResult;
1368 }
1369 #endif
1370
1371 TableBoxVectorPtr WW8TableCellGrid::getTableBoxesOfRow
1372 (WW8TableNodeInfoInner * pNodeInfoInner)
1373 {
1374     TableBoxVectorPtr pResult;
1375     WW8TableCellGridRow::Pointer_t pRow =
1376         getRow(pNodeInfoInner->getRect().Top(), false);
1377
1378     if (pRow.get() != nullptr)
1379     {
1380         pResult = pRow->getTableBoxVector();
1381     }
1382
1383     return pResult;
1384 }
1385
1386 WidthsPtr WW8TableCellGrid::getWidthsOfRow
1387 (WW8TableNodeInfoInner * pNodeInfoInner)
1388 {
1389     GridColsPtr pResult;
1390
1391     WW8TableCellGridRow::Pointer_t pRow =
1392         getRow(pNodeInfoInner->getRect().Top(), false);
1393
1394     if (pRow.get() != nullptr)
1395     {
1396         pResult = pRow->getWidths();
1397     }
1398
1399     return pResult;
1400 }
1401
1402 RowSpansPtr WW8TableCellGrid::getRowSpansOfRow
1403 (WW8TableNodeInfoInner * pNodeInfoInner)
1404 {
1405     RowSpansPtr pResult;
1406
1407     WW8TableCellGridRow::Pointer_t pRow =
1408         getRow(pNodeInfoInner->getRect().Top(), false);
1409
1410     if (pRow.get() != nullptr)
1411     {
1412         pResult = pRow->getRowSpans();
1413     }
1414
1415     return pResult;
1416 }
1417
1418 WW8TableCellGridRow::WW8TableCellGridRow()
1419 : m_pCellInfos(new CellInfoMultiSet)
1420 {
1421 }
1422
1423 WW8TableCellGridRow::~WW8TableCellGridRow()
1424 {
1425 }
1426
1427 void WW8TableCellGridRow::insert(const CellInfo & rCellInfo)
1428 {
1429     m_pCellInfos->insert(rCellInfo);
1430
1431 #ifdef DBG_UTIL
1432     SAL_INFO( "sw.ww8", "<gridRowInsert>" << rCellInfo.toString() << "</gridRowInsert>" );
1433 #endif
1434 }
1435
1436 CellInfoMultiSet::const_iterator WW8TableCellGridRow::begin() const
1437 {
1438     return m_pCellInfos->begin();
1439 }
1440
1441 CellInfoMultiSet::const_iterator WW8TableCellGridRow::end() const
1442 {
1443     return m_pCellInfos->end();
1444 }
1445
1446 void WW8TableCellGridRow::setTableBoxVector(TableBoxVectorPtr const & pTableBoxVector)
1447 {
1448     if (pTableBoxVector->size() > MAXTABLECELLS)
1449         pTableBoxVector->resize(MAXTABLECELLS);
1450     m_pTableBoxVector = pTableBoxVector;
1451 }
1452
1453 void WW8TableCellGridRow::setWidths(WidthsPtr const & pWidths)
1454 {
1455     m_pWidths = pWidths;
1456 }
1457
1458 void WW8TableCellGridRow::setRowSpans(RowSpansPtr const & pRowSpans)
1459 {
1460     m_pRowSpans = pRowSpans;
1461 }
1462
1463
1464 CellInfo::CellInfo(const SwRect & aRect, WW8TableNodeInfo * pNodeInfo)
1465 : m_aRect(aRect), m_pNodeInfo(pNodeInfo), m_nFormatFrameWidth(0)
1466 {
1467     if (pNodeInfo != nullptr)
1468     {
1469         const SwTableBox * pBox = pNodeInfo->getTableBox();
1470         const SwFrameFormat * pFrameFormat = pBox->GetFrameFormat();
1471         const SwFormatFrameSize & rSize = pFrameFormat->GetFrameSize();
1472
1473         m_nFormatFrameWidth = rSize.GetWidth();
1474     }
1475 }
1476
1477 }
1478
1479 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */