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