svx/source/table/tablelayouter.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
  21 #include <com/sun/star/table/XMergeableCell.hpp>
  22
  23 #include <tools/debug.hxx>
  24 #include <comphelper/diagnose_ex.hxx>
  25 #include <tools/gen.hxx>
  26 #include <libxml/xmlwriter.h>
  27
  28 #include <cell.hxx>
  29 #include <o3tl/safeint.hxx>
  30 #include <tablemodel.hxx>
  31 #include "tablelayouter.hxx"
  32 #include <svx/svdotable.hxx>
  33 #include <editeng/borderline.hxx>
  34 #include <editeng/boxitem.hxx>
  35 #include <utility>
  36
  37 using ::editeng::SvxBorderLine;
  38 using namespace ::com::sun::star::uno;
  39 using namespace ::com::sun::star::container;
  40 using namespace ::com::sun::star::beans;
  41 using namespace ::com::sun::star::table;
  42 using namespace ::com::sun::star::text;
  43
  44
  45 namespace sdr::table {
  46
  47
  48 static SvxBorderLine gEmptyBorder;
  49
  50 constexpr OUString gsSize( u"Size"_ustr );
  51
  52 TableLayouter::TableLayouter( TableModelRef xTableModel )
  53 : mxTable(std::move( xTableModel ))
  54 {
  55 }
  56
  57
  58 TableLayouter::~TableLayouter()
  59 {
  60     ClearBorderLayout();
  61 }
  62
  63
  64 basegfx::B2ITuple TableLayouter::getCellSize( const CellRef& xCell, const CellPos& rPos  ) const
  65 {
  66     sal_Int32 width = 0;
  67     sal_Int32 height = 0;
  68
  69     try
  70     {
  71         if( xCell.is() && !xCell->isMerged() )
  72         {
  73             CellPos aPos( rPos );
  74
  75             sal_Int32 nRowCount = getRowCount();
  76             sal_Int32 nRowSpan = std::max( xCell->getRowSpan(), sal_Int32(1) );
  77             while( nRowSpan && (aPos.mnRow < nRowCount) )
  78             {
  79                 if( static_cast<sal_Int32>(maRows.size()) <= aPos.mnRow )
  80                     break;
  81
  82                 height = o3tl::saturating_add(height, maRows[aPos.mnRow++].mnSize);
  83                 nRowSpan--;
  84             }
  85
  86             sal_Int32 nColCount = getColumnCount();
  87             sal_Int32 nColSpan = std::max( xCell->getColumnSpan(), sal_Int32(1) );
  88             while( nColSpan && (aPos.mnCol < nColCount ) )
  89             {
  90                 if( static_cast<sal_Int32>(maColumns.size()) <= aPos.mnCol )
  91                     break;
  92
  93                 width = o3tl::saturating_add(width, maColumns[aPos.mnCol++].mnSize);
  94                 nColSpan--;
  95             }
  96         }
  97     }
  98     catch( Exception& )
  99     {
 100         TOOLS_WARN_EXCEPTION("svx", "");
 101     }
 102
 103     return basegfx::B2ITuple( width, height );
 104 }
 105
 106
 107 bool TableLayouter::getCellArea( const CellRef& xCell, const CellPos& rPos, basegfx::B2IRectangle& rArea ) const
 108 {
 109     try
 110     {
 111         if( xCell.is() && !xCell->isMerged() && isValid(rPos) )
 112         {
 113             const basegfx::B2ITuple aCellSize( getCellSize( xCell, rPos ) );
 114             const bool bRTL = (mxTable->getSdrTableObj()->GetWritingMode() == WritingMode_RL_TB);
 115
 116             if( (rPos.mnCol < static_cast<sal_Int32>(maColumns.size())) && (rPos.mnRow < static_cast<sal_Int32>(maRows.size()) ) )
 117             {
 118                 const sal_Int32 y = maRows[rPos.mnRow].mnPos;
 119
 120                 sal_Int32 endy;
 121                 if (o3tl::checked_add(y, aCellSize.getY(), endy))
 122                     return false;
 123
 124                 if(bRTL)
 125                 {
 126                     ///For RTL Table Calculate the Right End of cell instead of Left
 127                     const sal_Int32 x = maColumns[rPos.mnCol].mnPos + maColumns[rPos.mnCol].mnSize;
 128                     sal_Int32 startx;
 129                     if (o3tl::checked_sub(x, aCellSize.getX(), startx))
 130                         return false;
 131                     rArea = basegfx::B2IRectangle(startx, y, x, endy);
 132                 }
 133                 else
 134                 {
 135                     const sal_Int32 x = maColumns[rPos.mnCol].mnPos;
 136                     sal_Int32 endx;
 137                     if (o3tl::checked_add(x, aCellSize.getX(), endx))
 138                         return false;
 139                     rArea = basegfx::B2IRectangle(x, y, endx, endy);
 140                 }
 141                 return true;
 142             }
 143         }
 144     }
 145     catch( Exception& )
 146     {
 147         TOOLS_WARN_EXCEPTION("svx", "");
 148     }
 149     return false;
 150 }
 151
 152
 153 sal_Int32 TableLayouter::getRowHeight( sal_Int32 nRow ) const
 154 {
 155     if( isValidRow(nRow) )
 156         return maRows[nRow].mnSize;
 157     else
 158         return 0;
 159 }
 160
 161
 162 sal_Int32 TableLayouter::getColumnWidth( sal_Int32 nColumn ) const
 163 {
 164     if( isValidColumn(nColumn) )
 165         return maColumns[nColumn].mnSize;
 166     else
 167         return 0;
 168 }
 169
 170 sal_Int32 TableLayouter::calcPreferredColumnWidth( sal_Int32 nColumn, Size aSize ) const
 171 {
 172     sal_Int32 nRet = 0;
 173     for ( sal_uInt32 nRow = 0; nRow < static_cast<sal_uInt32>(maRows.size()); ++nRow )
 174     {
 175         // Account for the space desired by spanned columns.
 176         // Only the last spanned cell will try to ensure sufficient space,
 177         // by looping through the previous columns, subtracting their portion.
 178         sal_Int32 nWish = 0;
 179         sal_Int32 nSpannedColumn = nColumn;
 180         bool bFindSpan = true;
 181         while ( bFindSpan && isValidColumn(nSpannedColumn) )
 182         {
 183             // recursive function call gets earlier portion of spanned column.
 184             if ( nSpannedColumn < nColumn )
 185                 nWish -= calcPreferredColumnWidth( nSpannedColumn, aSize );
 186
 187             CellRef xCell( getCell( CellPos( nSpannedColumn, nRow ) ) );
 188             if ( xCell.is() && !xCell->isMerged()
 189                  && (xCell->getColumnSpan() == 1 || nSpannedColumn < nColumn) )
 190             {
 191                 nWish += xCell->calcPreferredWidth(aSize);
 192                 bFindSpan = false;
 193             }
 194             else if ( xCell.is() && xCell->isMerged()
 195                       && nColumn == nSpannedColumn
 196                       && isValidColumn(nColumn + 1) )
 197             {
 198                 xCell = getCell( CellPos( nColumn + 1, nRow ) );
 199                 bFindSpan = xCell.is() && !xCell->isMerged();
 200             }
 201             nSpannedColumn--;
 202         }
 203         nRet = std::max( nRet, nWish );
 204     }
 205     return nRet;
 206 }
 207
 208
 209 bool TableLayouter::isEdgeVisible( sal_Int32 nEdgeX, sal_Int32 nEdgeY, bool bHorizontal ) const
 210 {
 211     const BorderLineMap& rMap = bHorizontal ? maHorizontalBorders : maVerticalBorders;
 212
 213     if( (nEdgeX >= 0) && (nEdgeX < sal::static_int_cast<sal_Int32>(rMap.size())) &&
 214         (nEdgeY >= 0) && (nEdgeY < sal::static_int_cast<sal_Int32>(rMap[nEdgeX].size())) )
 215     {
 216         return rMap[nEdgeX][nEdgeY] != nullptr;
 217     }
 218     else
 219     {
 220         OSL_FAIL( "sdr::table::TableLayouter::getBorderLine(), invalid edge!" );
 221     }
 222
 223     return false;
 224 }
 225
 226
 227 /** returns the requested borderline in rpBorderLine or a null pointer if there is no border at this edge */
 228 SvxBorderLine* TableLayouter::getBorderLine( sal_Int32 nEdgeX, sal_Int32 nEdgeY, bool bHorizontal )const
 229 {
 230     SvxBorderLine* pLine = nullptr;
 231
 232     const BorderLineMap& rMap = bHorizontal ? maHorizontalBorders : maVerticalBorders;
 233
 234     if( (nEdgeX >= 0) && (nEdgeX < sal::static_int_cast<sal_Int32>(rMap.size())) &&
 235         (nEdgeY >= 0) && (nEdgeY < sal::static_int_cast<sal_Int32>(rMap[nEdgeX].size())) )
 236     {
 237         pLine = rMap[nEdgeX][nEdgeY];
 238         if( pLine == &gEmptyBorder )
 239             pLine = nullptr;
 240     }
 241     else
 242     {
 243         OSL_FAIL( "sdr::table::TableLayouter::getBorderLine(), invalid edge!" );
 244     }
 245
 246     return pLine;
 247 }
 248
 249 std::vector<EdgeInfo> TableLayouter::getHorizontalEdges()
 250 {
 251     std::vector<EdgeInfo> aReturn;
 252     sal_Int32 nRowSize = sal_Int32(maRows.size());
 253     for (sal_Int32 i = 0; i <= nRowSize; i++)
 254     {
 255         sal_Int32 nEdgeMin = 0;
 256         sal_Int32 nEdgeMax = 0;
 257         sal_Int32 nEdge = getHorizontalEdge(i, &nEdgeMin, &nEdgeMax);
 258         nEdgeMin -= nEdge;
 259         nEdgeMax -= nEdge;
 260         aReturn.emplace_back(i, nEdge, nEdgeMin, nEdgeMax);
 261     }
 262     return aReturn;
 263 }
 264
 265 std::vector<EdgeInfo> TableLayouter::getVerticalEdges()
 266 {
 267     std::vector<EdgeInfo> aReturn;
 268     sal_Int32 nColumnSize = sal_Int32(maColumns.size());
 269     for (sal_Int32 i = 0; i <= nColumnSize; i++)
 270     {
 271         sal_Int32 nEdgeMin = 0;
 272         sal_Int32 nEdgeMax = 0;
 273         sal_Int32 nEdge = getVerticalEdge(i, &nEdgeMin, &nEdgeMax);
 274         nEdgeMin -= nEdge;
 275         nEdgeMax -= nEdge;
 276         aReturn.emplace_back(i, nEdge, nEdgeMin, nEdgeMax);
 277     }
 278     return aReturn;
 279 }
 280
 281 sal_Int32 TableLayouter::getHorizontalEdge( int nEdgeY, sal_Int32* pnMin /*= 0*/, sal_Int32* pnMax /*= 0*/ )
 282 {
 283     sal_Int32 nRet = 0;
 284     const sal_Int32 nRowCount = getRowCount();
 285     if( (nEdgeY >= 0) && (nEdgeY <= nRowCount ) )
 286         nRet = maRows[std::min(static_cast<sal_Int32>(nEdgeY),nRowCount-1)].mnPos;
 287
 288     if( nEdgeY == nRowCount )
 289         nRet += maRows[nEdgeY - 1].mnSize;
 290
 291     if( pnMin )
 292     {
 293         if( (nEdgeY > 0) && (nEdgeY <= nRowCount ) )
 294         {
 295             *pnMin = maRows[nEdgeY-1].mnPos + 600; // todo
 296         }
 297         else
 298         {
 299             *pnMin = nRet;
 300         }
 301     }
 302
 303     if( pnMax )
 304     {
 305         *pnMax = 0x0fffffff;
 306     }
 307     return nRet;
 308 }
 309
 310
 311 sal_Int32 TableLayouter::getVerticalEdge( int nEdgeX, sal_Int32* pnMin /*= 0*/, sal_Int32* pnMax /*= 0*/ )
 312 {
 313     sal_Int32 nRet = 0;
 314
 315     const sal_Int32 nColCount = getColumnCount();
 316     if( (nEdgeX >= 0) && (nEdgeX <= nColCount ) )
 317         nRet = maColumns[std::min(static_cast<sal_Int32>(nEdgeX),nColCount-1)].mnPos;
 318
 319     const bool bRTL = (mxTable->getSdrTableObj()->GetWritingMode() == WritingMode_RL_TB);
 320     if( bRTL )
 321     {
 322         if( (nEdgeX >= 0) && (nEdgeX < nColCount) )
 323             nRet += maColumns[nEdgeX].mnSize;
 324     }
 325     else
 326     {
 327         if( nEdgeX == nColCount )
 328             nRet += maColumns[nEdgeX - 1].mnSize;
 329     }
 330
 331     if( pnMin )
 332     {
 333         *pnMin = nRet;
 334         if( bRTL )
 335         {
 336             if( nEdgeX < nColCount )
 337                 *pnMin = nRet - maColumns[nEdgeX].mnSize + getMinimumColumnWidth(nEdgeX);
 338         }
 339         else
 340         {
 341             if( (nEdgeX > 0) && (nEdgeX <= nColCount ) )
 342                 *pnMin = maColumns[nEdgeX-1].mnPos + getMinimumColumnWidth( nEdgeX-1 );
 343         }
 344     }
 345
 346     if( pnMax )
 347     {
 348         *pnMax = 0x0fffffff; // todo
 349         if( bRTL )
 350         {
 351             if( nEdgeX > 0 )
 352                 *pnMax = nRet + maColumns[nEdgeX-1].mnSize - getMinimumColumnWidth( nEdgeX-1 );
 353         }
 354         else
 355         {
 356             if( (nEdgeX >= 0) && (nEdgeX < nColCount ) )
 357                 *pnMax = maColumns[nEdgeX].mnPos + maColumns[nEdgeX].mnSize - getMinimumColumnWidth( nEdgeX );
 358         }
 359     }
 360
 361     return nRet;
 362 }
 363
 364
 365 static bool checkMergeOrigin( const TableModelRef& xTable, sal_Int32 nMergedX, sal_Int32 nMergedY, sal_Int32 nCellX, sal_Int32 nCellY, bool& bRunning )
 366 {
 367     Reference< XMergeableCell > xCell( xTable->getCellByPosition( nCellX, nCellY ), UNO_QUERY );
 368     if( xCell.is() && !xCell->isMerged() )
 369     {
 370         const sal_Int32 nRight = xCell->getColumnSpan() + nCellX;
 371         const sal_Int32 nBottom = xCell->getRowSpan() + nCellY;
 372         if( (nMergedX < nRight) && (nMergedY < nBottom) )
 373             return true;
 374
 375         bRunning = false;
 376     }
 377     return false;
 378 }
 379
 380 /** returns true if the cell(nMergedX,nMergedY) is merged with other cells.
 381     the returned cell( rOriginX, rOriginY ) is the origin( top left cell ) of the merge.
 382 */
 383 bool findMergeOrigin( const TableModelRef& xTable, sal_Int32 nMergedX, sal_Int32 nMergedY, sal_Int32& rOriginX, sal_Int32& rOriginY )
 384 {
 385     rOriginX = nMergedX;
 386     rOriginY = nMergedY;
 387
 388     if( xTable.is() ) try
 389     {
 390         // check if this cell already the origin or not merged at all
 391         Reference< XMergeableCell > xCell( xTable->getCellByPosition( nMergedX, nMergedY ), UNO_QUERY_THROW );
 392         if( !xCell->isMerged() )
 393             return true;
 394
 395         bool bCheckVert = true;
 396         bool bCheckHorz = true;
 397
 398         sal_Int32 nMinCol = 0;
 399         sal_Int32 nMinRow = 0;
 400
 401         sal_Int32 nStep = 1, i;
 402
 403         sal_Int32 nRow, nCol;
 404         do
 405         {
 406             if( bCheckVert )
 407             {
 408                 nRow = nMergedY - nStep;
 409                 if( nRow >= nMinRow )
 410                 {
 411                     nCol = nMergedX;
 412                     for( i = 0; (i <= nStep) && (nCol >= nMinCol); i++, nCol-- )
 413                     {
 414                         if( checkMergeOrigin( xTable, nMergedX, nMergedY, nCol, nRow, bCheckVert ) )
 415                         {
 416                             rOriginX = nCol; rOriginY = nRow;
 417                             return true;
 418                         }
 419
 420                         if( !bCheckVert )
 421                         {
 422                             if( nCol == nMergedX )
 423                             {
 424                                 nMinRow = nRow+1;
 425                             }
 426                             else
 427                             {
 428                                 bCheckVert = true;
 429                             }
 430                             break;
 431                         }
 432                     }
 433                 }
 434                 else
 435                 {
 436                     bCheckVert = false;
 437                 }
 438             }
 439
 440             if( bCheckHorz )
 441             {
 442                 nCol = nMergedX - nStep;
 443                 if( nCol >= nMinCol )
 444                 {
 445                     nRow = nMergedY;
 446                     for( i = 0; (i < nStep) && (nRow >= nMinRow); i++, nRow-- )
 447                     {
 448                         if( checkMergeOrigin( xTable, nMergedX, nMergedY, nCol, nRow, bCheckHorz ) )
 449                         {
 450                             rOriginX = nCol; rOriginY = nRow;
 451                             return true;
 452                         }
 453
 454                         if( !bCheckHorz )
 455                         {
 456                             if( nRow == nMergedY )
 457                             {
 458                                 nMinCol = nCol+1;
 459                             }
 460                             else
 461                             {
 462                                 bCheckHorz = true;
 463                             }
 464                             break;
 465                         }
 466                     }
 467                 }
 468                 else
 469                 {
 470                     bCheckHorz = false;
 471                 }
 472             }
 473             nStep++;
 474         }
 475         while( bCheckVert || bCheckHorz );
 476     }
 477     catch( Exception& )
 478     {
 479         TOOLS_WARN_EXCEPTION("svx", "");
 480     }
 481     return false;
 482 }
 483
 484
 485 sal_Int32 TableLayouter::getMinimumColumnWidth( sal_Int32 nColumn )
 486 {
 487     if( isValidColumn( nColumn ) )
 488     {
 489         return maColumns[nColumn].mnMinSize;
 490     }
 491     else
 492     {
 493         OSL_FAIL( "TableLayouter::getMinimumColumnWidth(), column out of range!" );
 494         return 0;
 495     }
 496 }
 497
 498
 499 sal_Int32 TableLayouter::distribute( LayoutVector& rLayouts, sal_Int32 nDistribute )
 500 {
 501     // break loops after 100 runs to avoid freezing office due to developer error
 502     sal_Int32 nSafe = 100;
 503
 504     const std::size_t nCount = rLayouts.size();
 505     std::size_t nIndex;
 506
 507     bool bConstrainsBroken = false;
 508
 509     do
 510     {
 511         bConstrainsBroken = false;
 512
 513         // first enforce minimum size constrains on all entities
 514         for( nIndex = 0; nIndex < nCount; ++nIndex )
 515         {
 516             Layout& rLayout = rLayouts[nIndex];
 517             if( rLayout.mnSize < rLayout.mnMinSize )
 518             {
 519                 sal_Int32 nDiff(0);
 520                 bConstrainsBroken |= o3tl::checked_sub(rLayout.mnMinSize, rLayout.mnSize, nDiff);
 521                 bConstrainsBroken |= o3tl::checked_sub(nDistribute, nDiff, nDistribute);
 522                 rLayout.mnSize = rLayout.mnMinSize;
 523             }
 524         }
 525
 526         // calculate current width
 527         // if nDistribute is < 0 (shrinking), entities that are already
 528         // at minimum width are not counted
 529         sal_Int32 nCurrentWidth = 0;
 530         for( nIndex = 0; nIndex < nCount; ++nIndex )
 531         {
 532             Layout& rLayout = rLayouts[nIndex];
 533             if( (nDistribute > 0) || (rLayout.mnSize > rLayout.mnMinSize) )
 534                 nCurrentWidth = o3tl::saturating_add(nCurrentWidth, rLayout.mnSize);
 535         }
 536
 537         // now distribute over entities
 538         if( (nCurrentWidth != 0) && (nDistribute != 0) )
 539         {
 540             sal_Int32 nDistributed = nDistribute;
 541             for( nIndex = 0; nIndex < nCount; ++nIndex )
 542             {
 543                 Layout& rLayout = rLayouts[nIndex];
 544                 if( (nDistribute > 0) || (rLayout.mnSize > rLayout.mnMinSize) )
 545                 {
 546                     sal_Int32 n(nDistributed); // for last entity use up rest
 547                     if (nIndex != (nCount-1))
 548                     {
 549                         bConstrainsBroken |= o3tl::checked_multiply(nDistribute, rLayout.mnSize, n);
 550                         n /= nCurrentWidth;
 551                     }
 552
 553                     bConstrainsBroken |= o3tl::checked_add(rLayout.mnSize, n, rLayout.mnSize);
 554                     nDistributed -= n;
 555
 556                     if( rLayout.mnSize < rLayout.mnMinSize )
 557                         bConstrainsBroken = true;
 558                 }
 559             }
 560         }
 561     } while( bConstrainsBroken && --nSafe );
 562
 563     sal_Int32 nSize = 0;
 564     for( nIndex = 0; nIndex < nCount; ++nIndex )
 565         nSize = o3tl::saturating_add(nSize, rLayouts[nIndex].mnSize);
 566
 567     return nSize;
 568 }
 569
 570
 571 typedef std::vector< CellRef > MergeableCellVector;
 572 typedef std::vector< MergeableCellVector > MergeVector;
 573
 574
 575 void TableLayouter::LayoutTableWidth( tools::Rectangle& rArea, bool bFit )
 576 {
 577     const sal_Int32 nColCount = getColumnCount();
 578     const sal_Int32 nRowCount = getRowCount();
 579     if( nColCount == 0 )
 580         return;
 581
 582     MergeVector aMergedCells( nColCount );
 583     std::vector<sal_Int32> aOptimalColumns;
 584
 585     static constexpr OUStringLiteral sOptimalSize(u"OptimalSize");
 586
 587     if( sal::static_int_cast< sal_Int32 >( maColumns.size() ) != nColCount )
 588         maColumns.resize( nColCount );
 589
 590     Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_SET_THROW );
 591
 592     // first calculate current width and initial minimum width per column,
 593     // merged cells will be counted later
 594     sal_Int32 nCurrentWidth = 0;
 595     sal_Int32 nCol = 0, nRow = 0;
 596     for( nCol = 0; nCol < nColCount; nCol++ )
 597     {
 598         sal_Int32 nMinWidth = 0;
 599
 600         bool bIsEmpty = true; // check if all cells in this column are merged
 601
 602         for( nRow = 0; nRow < nRowCount; ++nRow )
 603         {
 604             CellRef xCell( getCell( CellPos( nCol, nRow ) ) );
 605             if( xCell.is() && !xCell->isMerged() )
 606             {
 607                 bIsEmpty = false;
 608
 609                 sal_Int32 nColSpan = xCell->getColumnSpan();
 610                 if( nColSpan > 1 )
 611                 {
 612                     // merged cells will be evaluated later
 613                     aMergedCells[nCol+nColSpan-1].push_back( xCell );
 614                 }
 615                 else
 616                 {
 617                     nMinWidth = std::max( nMinWidth, xCell->getMinimumWidth() );
 618                 }
 619             }
 620         }
 621
 622         maColumns[nCol].mnMinSize = nMinWidth;
 623
 624         if( bIsEmpty )
 625         {
 626             maColumns[nCol].mnSize = 0;
 627         }
 628         else
 629         {
 630             sal_Int32 nColWidth = 0;
 631             Reference< XPropertySet > xColSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
 632             bool bOptimal = false;
 633             xColSet->getPropertyValue( sOptimalSize ) >>= bOptimal;
 634             if( bOptimal )
 635             {
 636                 aOptimalColumns.push_back(nCol);
 637             }
 638             else
 639             {
 640                 xColSet->getPropertyValue( gsSize ) >>= nColWidth;
 641             }
 642
 643             maColumns[nCol].mnSize = std::max( nColWidth, nMinWidth);
 644
 645             nCurrentWidth = o3tl::saturating_add(nCurrentWidth, maColumns[nCol].mnSize);
 646         }
 647     }
 648
 649     // if we have optimal sized rows, distribute what is given (left)
 650     if( !bFit && !aOptimalColumns.empty() && (nCurrentWidth < rArea.getOpenWidth()) )
 651     {
 652         sal_Int32 nLeft = rArea.getOpenWidth() - nCurrentWidth;
 653         sal_Int32 nDistribute = nLeft / aOptimalColumns.size();
 654
 655         auto iter( aOptimalColumns.begin() );
 656         while( iter != aOptimalColumns.end() )
 657         {
 658             sal_Int32 nOptCol = *iter++;
 659             if( iter == aOptimalColumns.end() )
 660                 nDistribute = nLeft;
 661
 662             maColumns[nOptCol].mnSize += nDistribute;
 663             nLeft -= nDistribute;
 664         }
 665
 666         DBG_ASSERT( nLeft == 0, "svx::TableLayouter::LayoutTableWidtht(), layouting failed!" );
 667     }
 668
 669     // now check if merged cells fit
 670     for( nCol = 1; nCol < nColCount; ++nCol )
 671     {
 672         bool bChanges = false;
 673
 674         const sal_Int32 nOldSize = maColumns[nCol].mnSize;
 675
 676         for( const CellRef& xCell : aMergedCells[nCol] )
 677         {
 678             sal_Int32 nMinWidth = xCell->getMinimumWidth();
 679
 680             for( sal_Int32 nMCol = nCol - xCell->getColumnSpan() + 1; (nMCol > 0) && (nMCol < nCol); ++nMCol )
 681                 nMinWidth -= maColumns[nMCol].mnSize;
 682
 683             if( nMinWidth > maColumns[nCol].mnMinSize )
 684                 maColumns[nCol].mnMinSize = nMinWidth;
 685
 686             if( nMinWidth > maColumns[nCol].mnSize )
 687             {
 688                 maColumns[nCol].mnSize = nMinWidth;
 689                 bChanges = true;
 690             }
 691         }
 692
 693         if( bChanges )
 694         {
 695             nCurrentWidth = o3tl::saturating_add(nCurrentWidth, maColumns[nCol].mnSize - nOldSize);
 696         }
 697     }
 698
 699     // now scale if wanted and needed
 700     if( bFit && (nCurrentWidth != rArea.getOpenWidth()) )
 701         distribute( maColumns, rArea.getOpenWidth() - nCurrentWidth );
 702
 703     // last step, update left edges
 704     sal_Int32 nNewWidth = 0;
 705
 706     const bool bRTL = (mxTable->getSdrTableObj()->GetWritingMode() == WritingMode_RL_TB);
 707     RangeIterator<sal_Int32> coliter( 0, nColCount, !bRTL );
 708     while( coliter.next(nCol ) )
 709     {
 710         maColumns[nCol].mnPos = nNewWidth;
 711         nNewWidth = o3tl::saturating_add(nNewWidth, maColumns[nCol].mnSize);
 712         if( bFit )
 713         {
 714             Reference< XPropertySet > xColSet( xCols->getByIndex(nCol), UNO_QUERY_THROW );
 715             xColSet->setPropertyValue( gsSize, Any( maColumns[nCol].mnSize ) );
 716         }
 717     }
 718
 719     rArea.SetSize( Size( nNewWidth, rArea.GetHeight() ) );
 720     updateCells( rArea );
 721 }
 722
 723
 724 void TableLayouter::LayoutTableHeight( tools::Rectangle& rArea, bool bFit )
 725 {
 726     const sal_Int32 nColCount = getColumnCount();
 727     const sal_Int32 nRowCount = getRowCount();
 728
 729     if( nRowCount == 0 )
 730         return;
 731
 732     Reference< XTableRows > xRows( mxTable->getRows() );
 733
 734     MergeVector aMergedCells( nRowCount );
 735     std::vector<sal_Int32> aOptimalRows;
 736
 737     static constexpr OUStringLiteral sOptimalSize(u"OptimalSize");
 738
 739     // first calculate current height and initial minimum size per column,
 740     // merged cells will be counted later
 741     sal_Int32 nCurrentHeight = 0;
 742     sal_Int32 nCol, nRow;
 743     for( nRow = 0; nRow < nRowCount; ++nRow )
 744     {
 745         sal_Int32 nMinHeight = 0;
 746
 747         bool bIsEmpty = true; // check if all cells in this row are merged
 748
 749         for( nCol = 0; nCol < nColCount; ++nCol )
 750         {
 751             CellRef xCell( getCell( CellPos( nCol, nRow ) ) );
 752             if( xCell.is() && !xCell->isMerged() )
 753             {
 754                 bIsEmpty = false;
 755
 756                 sal_Int32 nRowSpan = xCell->getRowSpan();
 757                 if( nRowSpan > 1 )
 758                 {
 759                     // merged cells will be evaluated later
 760                     aMergedCells[nRow+nRowSpan-1].push_back( xCell );
 761                 }
 762                 else
 763                 {
 764                     nMinHeight = std::max( nMinHeight, xCell->getMinimumHeight() );
 765                 }
 766             }
 767         }
 768
 769         maRows[nRow].mnMinSize = nMinHeight;
 770
 771         if( bIsEmpty )
 772         {
 773             maRows[nRow].mnSize = 0;
 774         }
 775         else
 776         {
 777             sal_Int32 nRowHeight = 0;
 778             Reference<XPropertySet> xRowSet(xRows->getByIndex(nRow), UNO_QUERY_THROW);
 779
 780             bool bOptimal = false;
 781             xRowSet->getPropertyValue( sOptimalSize ) >>= bOptimal;
 782             if( bOptimal )
 783             {
 784                 aOptimalRows.push_back( nRow );
 785             }
 786             else
 787             {
 788                 xRowSet->getPropertyValue( gsSize ) >>= nRowHeight;
 789             }
 790
 791             maRows[nRow].mnSize = nRowHeight;
 792
 793             if( maRows[nRow].mnSize < nMinHeight )
 794                 maRows[nRow].mnSize = nMinHeight;
 795
 796             nCurrentHeight = o3tl::saturating_add(nCurrentHeight, maRows[nRow].mnSize);
 797         }
 798     }
 799
 800     // if we have optimal sized rows, distribute what is given (left)
 801     if( !bFit && !aOptimalRows.empty() && (nCurrentHeight < rArea.getOpenHeight()) )
 802     {
 803         sal_Int32 nLeft = rArea.getOpenHeight() - nCurrentHeight;
 804         sal_Int32 nDistribute = nLeft / aOptimalRows.size();
 805
 806         auto iter( aOptimalRows.begin() );
 807         while( iter != aOptimalRows.end() )
 808         {
 809             sal_Int32 nOptRow = *iter++;
 810             if( iter == aOptimalRows.end() )
 811                 nDistribute = nLeft;
 812
 813             maRows[nOptRow].mnSize += nDistribute;
 814             nLeft -= nDistribute;
 815
 816         }
 817
 818         DBG_ASSERT( nLeft == 0, "svx::TableLayouter::LayoutTableHeight(), layouting failed!" );
 819     }
 820
 821     // now check if merged cells fit
 822     for( nRow = 1; nRow < nRowCount; ++nRow )
 823     {
 824         bool bChanges = false;
 825         sal_Int32 nOldSize = maRows[nRow].mnSize;
 826
 827         for( const CellRef& xCell : aMergedCells[nRow] )
 828         {
 829             sal_Int32 nMinHeight = xCell->getMinimumHeight();
 830
 831             for( sal_Int32 nMRow = nRow - xCell->getRowSpan() + 1; (nMRow > 0) && (nMRow < nRow); ++nMRow )
 832                 nMinHeight -= maRows[nMRow].mnSize;
 833
 834             if( nMinHeight > maRows[nRow].mnMinSize )
 835                 maRows[nRow].mnMinSize = nMinHeight;
 836
 837             if( nMinHeight > maRows[nRow].mnSize )
 838             {
 839                 maRows[nRow].mnSize = nMinHeight;
 840                 bChanges = true;
 841             }
 842         }
 843         if( bChanges )
 844             nCurrentHeight = o3tl::saturating_add(nCurrentHeight, maRows[nRow].mnSize - nOldSize);
 845     }
 846
 847     // now scale if wanted and needed
 848     if( bFit && nCurrentHeight != rArea.getOpenHeight() )
 849         distribute(maRows, o3tl::saturating_sub<sal_Int32>(rArea.getOpenHeight(), nCurrentHeight));
 850
 851     // last step, update left edges
 852     sal_Int32 nNewHeight = 0;
 853     for( nRow = 0; nRow < nRowCount; ++nRow )
 854     {
 855         maRows[nRow].mnPos = nNewHeight;
 856         nNewHeight = o3tl::saturating_add(nNewHeight, maRows[nRow].mnSize);
 857
 858         if( bFit )
 859         {
 860             Reference< XPropertySet > xRowSet( xRows->getByIndex(nRow), UNO_QUERY_THROW );
 861             xRowSet->setPropertyValue( gsSize, Any( maRows[nRow].mnSize ) );
 862         }
 863     }
 864
 865     rArea.SetSize( Size( rArea.GetWidth(), nNewHeight ) );
 866     updateCells( rArea );
 867 }
 868
 869
 870 /** try to fit the table into the given rectangle.
 871     If the rectangle is too small, it will be grown to fit the table. */
 872 void TableLayouter::LayoutTable( tools::Rectangle& rRectangle, bool bFitWidth, bool bFitHeight )
 873 {
 874     if( !mxTable.is() )
 875         return;
 876
 877     const sal_Int32 nRowCount = mxTable->getRowCount();
 878     const sal_Int32 nColCount = mxTable->getColumnCount();
 879
 880     if( (nRowCount != getRowCount()) || (nColCount != getColumnCount()) )
 881     {
 882         if( static_cast< sal_Int32 >( maRows.size() ) != nRowCount )
 883             maRows.resize( nRowCount );
 884
 885         for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
 886             maRows[nRow].clear();
 887
 888         if( static_cast< sal_Int32 >( maColumns.size() ) != nColCount )
 889             maColumns.resize( nColCount );
 890
 891         for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
 892             maColumns[nCol].clear();
 893     }
 894
 895     LayoutTableWidth( rRectangle, bFitWidth );
 896     LayoutTableHeight( rRectangle, bFitHeight );
 897     UpdateBorderLayout();
 898 }
 899
 900
 901 void TableLayouter::updateCells( tools::Rectangle const & rRectangle )
 902 {
 903     const sal_Int32 nColCount = getColumnCount();
 904     const sal_Int32 nRowCount = getRowCount();
 905
 906     CellPos aPos;
 907     for( aPos.mnRow = 0; aPos.mnRow < nRowCount; aPos.mnRow++ )
 908     {
 909         for( aPos.mnCol = 0; aPos.mnCol < nColCount; aPos.mnCol++ )
 910         {
 911             CellRef xCell( getCell( aPos ) );
 912             if( xCell.is() )
 913             {
 914                 basegfx::B2IRectangle aCellArea;
 915                 if( getCellArea( xCell, aPos, aCellArea ) )
 916                 {
 917                     tools::Rectangle aCellRect;
 918                     aCellRect.SetLeft( aCellArea.getMinX() );
 919                     aCellRect.SetRight( aCellArea.getMaxX() );
 920                     aCellRect.SetTop( aCellArea.getMinY() );
 921                     aCellRect.SetBottom( aCellArea.getMaxY() );
 922                     aCellRect.Move( rRectangle.Left(), rRectangle.Top() );
 923                     xCell->setCellRect( aCellRect );
 924                 }
 925             }
 926         }
 927     }
 928 }
 929
 930
 931 CellRef TableLayouter::getCell( const CellPos& rPos ) const
 932 {
 933     CellRef xCell;
 934     if( mxTable.is() ) try
 935     {
 936         xCell = mxTable->getCell( rPos.mnCol, rPos.mnRow );
 937     }
 938     catch( Exception& )
 939     {
 940         TOOLS_WARN_EXCEPTION("svx", "");
 941     }
 942     return xCell;
 943 }
 944
 945
 946 bool TableLayouter::HasPriority( const SvxBorderLine* pThis, const SvxBorderLine* pOther )
 947 {
 948     if (!pThis || ((pThis == &gEmptyBorder) && (pOther != nullptr)))
 949         return false;
 950     if (!pOther || (pOther == &gEmptyBorder))
 951         return true;
 952
 953     sal_uInt16 nThisSize = pThis->GetScaledWidth();
 954     sal_uInt16 nOtherSize = pOther->GetScaledWidth();
 955
 956     if (nThisSize > nOtherSize)
 957         return true;
 958
 959     else if (nThisSize < nOtherSize)
 960     {
 961         return false;
 962     }
 963     else
 964     {
 965         if ( pOther->GetInWidth() && !pThis->GetInWidth() )
 966         {
 967             return true;
 968         }
 969         else if ( pThis->GetInWidth() && !pOther->GetInWidth() )
 970         {
 971             return false;
 972         }
 973         else
 974         {
 975             return true;            //! ???
 976         }
 977     }
 978 }
 979
 980 void TableLayouter::SetBorder( sal_Int32 nCol, sal_Int32 nRow, bool bHorizontal, const SvxBorderLine* pLine )
 981 {
 982     if (!pLine)
 983         pLine = &gEmptyBorder;
 984
 985     BorderLineMap& rMap = bHorizontal ? maHorizontalBorders : maVerticalBorders;
 986
 987     if( (nCol >= 0) && (nCol < sal::static_int_cast<sal_Int32>(rMap.size())) &&
 988         (nRow >= 0) && (nRow < sal::static_int_cast<sal_Int32>(rMap[nCol].size())) )
 989     {
 990         SvxBorderLine *pOld = rMap[nCol][nRow];
 991
 992         if (HasPriority(pLine, pOld))
 993         {
 994             if (pOld && pOld != &gEmptyBorder)
 995                 delete pOld;
 996
 997             SvxBorderLine* pNew = (pLine != &gEmptyBorder) ?  new SvxBorderLine(*pLine) : &gEmptyBorder;
 998
 999             rMap[nCol][nRow] = pNew;
1000         }
1001     }
1002     else
1003     {
1004         OSL_FAIL( "sdr::table::TableLayouter::SetBorder(), invalid border!" );
1005     }
1006 }
1007
1008 void TableLayouter::ClearBorderLayout()
1009 {
1010     ClearBorderLayout(maHorizontalBorders);
1011     ClearBorderLayout(maVerticalBorders);
1012 }
1013
1014 void TableLayouter::ClearBorderLayout(BorderLineMap& rMap)
1015 {
1016     const sal_Int32 nColCount = rMap.size();
1017
1018     for( sal_Int32 nCol = 0; nCol < nColCount; nCol++ )
1019     {
1020         const sal_Int32 nRowCount = rMap[nCol].size();
1021         for( sal_Int32 nRow = 0; nRow < nRowCount; nRow++ )
1022         {
1023             SvxBorderLine* pLine = rMap[nCol][nRow];
1024             if( pLine )
1025             {
1026                 if( pLine != &gEmptyBorder )
1027                     delete pLine;
1028
1029                 rMap[nCol][nRow] = nullptr;
1030             }
1031         }
1032     }
1033 }
1034
1035 void TableLayouter::ResizeBorderLayout()
1036 {
1037     ClearBorderLayout();
1038     ResizeBorderLayout(maHorizontalBorders);
1039     ResizeBorderLayout(maVerticalBorders);
1040 }
1041
1042
1043 void TableLayouter::ResizeBorderLayout( BorderLineMap& rMap )
1044 {
1045     const sal_Int32 nColCount = getColumnCount() + 1;
1046     const sal_Int32 nRowCount = getRowCount() + 1;
1047
1048     if( sal::static_int_cast<sal_Int32>(rMap.size()) != nColCount )
1049         rMap.resize( nColCount );
1050
1051     for( auto& nCol : rMap )
1052     {
1053         if( sal::static_int_cast<sal_Int32>(nCol.size()) != nRowCount )
1054             nCol.resize( nRowCount );
1055     }
1056 }
1057
1058
1059 void TableLayouter::UpdateBorderLayout()
1060 {
1061     // make sure old border layout is cleared and border maps have correct size
1062     ResizeBorderLayout();
1063
1064     const sal_Int32 nColCount = getColumnCount();
1065     const sal_Int32 nRowCount = getRowCount();
1066
1067     CellPos aPos;
1068     for( aPos.mnRow = 0; aPos.mnRow < nRowCount; aPos.mnRow++ )
1069     {
1070         for( aPos.mnCol = 0; aPos.mnCol < nColCount; aPos.mnCol++ )
1071         {
1072             CellRef xCell( getCell( aPos ) );
1073             if( !xCell.is() )
1074                 continue;
1075
1076             const SvxBoxItem* pThisAttr = xCell->GetItemSet().GetItem<SvxBoxItem>( SDRATTR_TABLE_BORDER );
1077             OSL_ENSURE(pThisAttr,"sdr::table::TableLayouter::UpdateBorderLayout(), no border attribute?");
1078
1079             if( !pThisAttr )
1080                 continue;
1081
1082             const sal_Int32 nLastRow = xCell->getRowSpan() + aPos.mnRow;
1083             const sal_Int32 nLastCol = xCell->getColumnSpan() + aPos.mnCol;
1084
1085             for( sal_Int32 nRow = aPos.mnRow; nRow < nLastRow; nRow++ )
1086             {
1087                 SetBorder( aPos.mnCol, nRow, false, pThisAttr->GetLeft() );
1088                 SetBorder( nLastCol, nRow, false, pThisAttr->GetRight() );
1089             }
1090
1091             for( sal_Int32 nCol = aPos.mnCol; nCol < nLastCol; nCol++ )
1092             {
1093                 SetBorder( nCol, aPos.mnRow, true, pThisAttr->GetTop() );
1094                 SetBorder( nCol, nLastRow, true, pThisAttr->GetBottom() );
1095             }
1096         }
1097     }
1098 }
1099
1100
1101 void TableLayouter::DistributeColumns( ::tools::Rectangle& rArea,
1102                                        sal_Int32 nFirstCol,
1103                                        sal_Int32 nLastCol,
1104                                        const bool bOptimize,
1105                                        const bool bMinimize )
1106 {
1107     if( !mxTable.is() )
1108         return;
1109
1110     try
1111     {
1112         const sal_Int32 nColCount = getColumnCount();
1113         Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_SET_THROW );
1114         const Size aSize(0xffffff, 0xffffff);
1115
1116         //special case - optimize a single column
1117         if ( (bOptimize || bMinimize) && nFirstCol == nLastCol )
1118         {
1119             const sal_Int32 nWish = calcPreferredColumnWidth(nFirstCol, aSize);
1120             if ( nWish < getColumnWidth(nFirstCol) )
1121             {
1122                 Reference< XPropertySet > xColSet( xCols->getByIndex(nFirstCol), UNO_QUERY_THROW );
1123                 xColSet->setPropertyValue( gsSize, Any( nWish ) );
1124
1125                 //FitWidth automatically distributes the new excess space
1126                 LayoutTable( rArea, /*bFitWidth=*/!bMinimize, /*bFitHeight=*/false );
1127             }
1128         }
1129
1130         if( (nFirstCol < 0) || (nFirstCol>= nLastCol) || (nLastCol >= nColCount) )
1131             return;
1132
1133         sal_Int32 nAllWidth = 0;
1134         float fAllWish = 0;
1135         sal_Int32 nUnused = 0;
1136         std::vector<sal_Int32> aWish(nColCount);
1137
1138         for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol )
1139             nAllWidth += getColumnWidth(nCol);
1140
1141         const sal_Int32 nEqualWidth = nAllWidth / (nLastCol-nFirstCol+1);
1142
1143         //pass 1 - collect unneeded space (from an equal width perspective)
1144         if ( bMinimize || bOptimize )
1145         {
1146             for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol )
1147             {
1148                 const sal_Int32 nIndex = nCol - nFirstCol;
1149                 aWish[nIndex] = calcPreferredColumnWidth(nCol, aSize);
1150                 fAllWish += aWish[nIndex];
1151                 if ( aWish[nIndex] < nEqualWidth )
1152                     nUnused += nEqualWidth - aWish[nIndex];
1153             }
1154         }
1155         const sal_Int32 nDistributeExcess = nAllWidth - fAllWish;
1156
1157         sal_Int32 nWidth = nEqualWidth;
1158         for( sal_Int32 nCol = nFirstCol; nCol <= nLastCol; ++nCol )
1159         {
1160             if ( !bMinimize && nCol == nLastCol )
1161                 nWidth = nAllWidth; // last column gets rounding/logic errors
1162             else if ( (bMinimize || bOptimize) && fAllWish )
1163             {
1164                 //pass 2 - first come, first served when requesting from the
1165                 //  unneeded pool, or proportionally allocate excess.
1166                 const sal_Int32 nIndex = nCol - nFirstCol;
1167                 if ( aWish[nIndex] > nEqualWidth + nUnused )
1168                 {
1169                     nWidth = nEqualWidth + nUnused;
1170                     nUnused = 0;
1171                 }
1172                 else
1173                 {
1174                     nWidth = aWish[nIndex];
1175                     if ( aWish[nIndex] > nEqualWidth )
1176                         nUnused -= aWish[nIndex] - nEqualWidth;
1177
1178                     if ( !bMinimize && nDistributeExcess > 0 )
1179                         nWidth += nWidth / fAllWish * nDistributeExcess;
1180                 }
1181             }
1182
1183             Reference< XPropertySet > xColSet( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
1184             xColSet->setPropertyValue( gsSize, Any( nWidth ) );
1185
1186             nAllWidth -= nWidth;
1187         }
1188
1189         LayoutTable( rArea, !bMinimize, false );
1190     }
1191     catch( Exception& )
1192     {
1193         TOOLS_WARN_EXCEPTION("svx", "");
1194     }
1195 }
1196
1197
1198 void TableLayouter::DistributeRows( ::tools::Rectangle& rArea,
1199                                     sal_Int32 nFirstRow,
1200                                     sal_Int32 nLastRow,
1201                                     const bool bOptimize,
1202                                     const bool bMinimize )
1203 {
1204     if( !mxTable.is() )
1205         return;
1206
1207     try
1208     {
1209         const sal_Int32 nRowCount = mxTable->getRowCount();
1210         Reference< XTableRows > xRows( mxTable->getRows(), UNO_SET_THROW );
1211         sal_Int32 nMinHeight = 0;
1212
1213         //special case - minimize a single row
1214         if ( bMinimize && nFirstRow == nLastRow )
1215         {
1216             const sal_Int32 nWish = std::max( maRows[nFirstRow].mnMinSize, nMinHeight );
1217             if ( nWish < getRowHeight(nFirstRow) )
1218             {
1219                 Reference< XPropertySet > xRowSet( xRows->getByIndex( nFirstRow ), UNO_QUERY_THROW );
1220                 xRowSet->setPropertyValue( gsSize, Any( nWish ) );
1221
1222                 LayoutTable( rArea, /*bFitWidth=*/false, /*bFitHeight=*/!bMinimize );
1223             }
1224         }
1225
1226         if( (nFirstRow < 0) || (nFirstRow>= nLastRow) || (nLastRow >= nRowCount) )
1227             return;
1228
1229         sal_Int32 nAllHeight = 0;
1230         sal_Int32 nMaxHeight = 0;
1231
1232         for( sal_Int32 nRow = nFirstRow; nRow <= nLastRow; ++nRow )
1233         {
1234             nMinHeight = std::max( maRows[nRow].mnMinSize, nMinHeight );
1235             nMaxHeight = std::max( maRows[nRow].mnSize, nMaxHeight );
1236             nAllHeight += maRows[nRow].mnSize;
1237         }
1238
1239         const sal_Int32 nRows = nLastRow-nFirstRow+1;
1240         sal_Int32 nHeight = nAllHeight / nRows;
1241
1242         if ( !bMinimize && nHeight < nMaxHeight )
1243         {
1244             if ( !bOptimize )
1245             {
1246                 sal_Int32 nNeededHeight = nRows * nMaxHeight;
1247                 rArea.AdjustBottom(nNeededHeight - nAllHeight );
1248                 nHeight = nMaxHeight;
1249                 nAllHeight = nRows * nMaxHeight;
1250             }
1251             else if ( nHeight < nMinHeight )
1252             {
1253                 sal_Int32 nNeededHeight = nRows * nMinHeight;
1254                 rArea.AdjustBottom(nNeededHeight - nAllHeight );
1255                 nHeight = nMinHeight;
1256                 nAllHeight = nRows * nMinHeight;
1257             }
1258         }
1259
1260         for( sal_Int32 nRow = nFirstRow; nRow <= nLastRow; ++nRow )
1261         {
1262             if ( bMinimize )
1263                 nHeight = maRows[nRow].mnMinSize;
1264             else if ( nRow == nLastRow )
1265                 nHeight = nAllHeight; // last row get round errors
1266
1267             Reference< XPropertySet > xRowSet( xRows->getByIndex( nRow ), UNO_QUERY_THROW );
1268             xRowSet->setPropertyValue( gsSize, Any( nHeight ) );
1269
1270             nAllHeight -= nHeight;
1271         }
1272
1273         LayoutTable( rArea, false, !bMinimize );
1274     }
1275     catch( Exception& )
1276     {
1277         TOOLS_WARN_EXCEPTION("svx", "");
1278     }
1279 }
1280
1281 void TableLayouter::dumpAsXml(xmlTextWriterPtr pWriter) const
1282 {
1283     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("TableLayouter"));
1284
1285     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("columns"));
1286     for (const auto& rColumn : maColumns)
1287         rColumn.dumpAsXml(pWriter);
1288     (void)xmlTextWriterEndElement(pWriter);
1289
1290     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("rows"));
1291     for (const auto& rRow : maRows)
1292         rRow.dumpAsXml(pWriter);
1293     (void)xmlTextWriterEndElement(pWriter);
1294
1295     (void)xmlTextWriterEndElement(pWriter);
1296 }
1297
1298 void TableLayouter::Layout::dumpAsXml(xmlTextWriterPtr pWriter) const
1299 {
1300     (void)xmlTextWriterStartElement(pWriter, BAD_CAST("TableLayouter_Layout"));
1301
1302     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("pos"), BAD_CAST(OString::number(mnPos).getStr()));
1303     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("size"), BAD_CAST(OString::number(mnSize).getStr()));
1304     (void)xmlTextWriterWriteAttribute(pWriter, BAD_CAST("minSize"), BAD_CAST(OString::number(mnMinSize).getStr()));
1305
1306     (void)xmlTextWriterEndElement(pWriter);
1307 }
1308
1309 }
1310
1311 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */