svx/source/table/tablelayouter.cxx

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