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