svx/source/table/cellcursor.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: cellcursor.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 "svx/svdotable.hxx"
  35 #include "cellcursor.hxx"
  36 #include "tablelayouter.hxx"
  37 #include "cell.hxx"
  38 #include "svx/svdmodel.hxx"
  39 #include "svdstr.hrc"
  40 #include "svdglob.hxx"
  41
  42 // -----------------------------------------------------------------------------
  43
  44 using ::rtl::OUString;
  45 using namespace ::com::sun::star::uno;
  46 using namespace ::com::sun::star::lang;
  47 using namespace ::com::sun::star::container;
  48 using namespace ::com::sun::star::beans;
  49 using namespace ::com::sun::star::table;
  50
  51 // -----------------------------------------------------------------------------
  52
  53 namespace sdr { namespace table {
  54
  55 // -----------------------------------------------------------------------------
  56 // CellCursor
  57 // -----------------------------------------------------------------------------
  58
  59 CellCursor::CellCursor( const TableModelRef & xTable, sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom )
  60 : CellCursorBase( xTable, nLeft, nTop, nRight, nBottom )
  61 {
  62 }
  63
  64 // -----------------------------------------------------------------------------
  65
  66 CellCursor::~CellCursor()
  67 {
  68 }
  69
  70 // -----------------------------------------------------------------------------
  71 // XCellCursor
  72 // -----------------------------------------------------------------------------
  73
  74 Reference< XCell > SAL_CALL CellCursor::getCellByPosition( sal_Int32 nColumn, sal_Int32 nRow ) throw (IndexOutOfBoundsException, RuntimeException)
  75 {
  76     return CellRange::getCellByPosition( nColumn, nRow );
  77 }
  78
  79 // -----------------------------------------------------------------------------
  80
  81 Reference< XCellRange > SAL_CALL CellCursor::getCellRangeByPosition( sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) throw (IndexOutOfBoundsException, RuntimeException)
  82 {
  83     return CellRange::getCellRangeByPosition( nLeft, nTop, nRight, nBottom );
  84 }
  85
  86 // -----------------------------------------------------------------------------
  87
  88 Reference< XCellRange > SAL_CALL CellCursor::getCellRangeByName( const OUString& aRange ) throw (RuntimeException)
  89 {
  90     return CellRange::getCellRangeByName( aRange );
  91 }
  92
  93 // -----------------------------------------------------------------------------
  94 // XCellCursor
  95 // -----------------------------------------------------------------------------
  96
  97 void SAL_CALL CellCursor::gotoStart(  ) throw (RuntimeException)
  98 {
  99     mnRight = mnLeft;
 100     mnBottom = mnTop;
 101 }
 102
 103 // -----------------------------------------------------------------------------
 104
 105 void SAL_CALL CellCursor::gotoEnd(  ) throw (RuntimeException)
 106 {
 107     mnLeft = mnRight;
 108     mnTop = mnBottom;
 109 }
 110
 111 // -----------------------------------------------------------------------------
 112
 113 void SAL_CALL CellCursor::gotoNext(  ) throw (RuntimeException)
 114 {
 115     if( mxTable.is() )
 116     {
 117         mnRight++;
 118         if( mnRight >= mxTable->getColumnCount() )
 119         {
 120             // if we past the last column, try skip to the row line
 121             mnTop++;
 122             if( mnTop >= mxTable->getRowCount() )
 123             {
 124                 // if we past the last row, do not move cursor at all
 125                 mnTop--;
 126                 mnRight--;
 127             }
 128             else
 129             {
 130                 // restart at the first column on the next row
 131                 mnRight = 0;
 132             }
 133         }
 134     }
 135
 136     mnLeft = mnRight;
 137     mnTop = mnBottom;
 138 }
 139
 140 // -----------------------------------------------------------------------------
 141
 142 void SAL_CALL CellCursor::gotoPrevious(  ) throw (RuntimeException)
 143 {
 144     if( mxTable.is() )
 145     {
 146         if( mnLeft > 0 )
 147         {
 148             --mnLeft;
 149         }
 150         else if( mnTop > 0 )
 151         {
 152             --mnTop;
 153             mnLeft = mxTable->getColumnCount() - 1;
 154         }
 155     }
 156
 157     mnRight = mnLeft;
 158     mnBottom = mnTop;
 159 }
 160
 161 // -----------------------------------------------------------------------------
 162
 163 void SAL_CALL CellCursor::gotoOffset( ::sal_Int32 nColumnOffset, ::sal_Int32 nRowOffset ) throw (RuntimeException)
 164 {
 165     if( mxTable.is() )
 166     {
 167         const sal_Int32 nLeft = mnLeft + nColumnOffset;
 168         if( (nLeft >= 0) && (nLeft < mxTable->getColumnCount() ) )
 169             mnRight = mnLeft = nLeft;
 170
 171         const sal_Int32 nTop = mnTop + nRowOffset;
 172         if( (nTop >= 0) && (nTop < mxTable->getRowCount()) )
 173             mnTop = mnBottom = nTop;
 174     }
 175 }
 176
 177 // -----------------------------------------------------------------------------
 178 // XMergeableCellCursor
 179 // -----------------------------------------------------------------------------
 180
 181 /** returns true and the merged cell positions if a merge is valid or false if a merge is
 182     not valid for that range */
 183 bool CellCursor::GetMergedSelection( CellPos& rStart, CellPos& rEnd )
 184 {
 185     rStart.mnCol = mnLeft; rStart.mnRow = mnTop;
 186     rEnd.mnCol = mnRight; rEnd.mnRow = mnBottom;
 187
 188     // single cell merge is never valid
 189     if( mxTable.is() && ((mnLeft != mnRight) || (mnTop != mnBottom)) ) try
 190     {
 191         CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( mnLeft, mnTop ).get() ) );
 192
 193         // check if first cell is merged
 194         if( xCell.is() && xCell->isMerged() )
 195             findMergeOrigin( mxTable, mnLeft, mnTop, rStart.mnCol, rStart.mnRow );
 196
 197         // check if last cell is merged
 198         xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( mnRight, mnBottom ).get() ) );
 199         if( xCell.is() )
 200         {
 201             if( xCell->isMerged() )
 202             {
 203                 findMergeOrigin( mxTable, mnRight, mnBottom, rEnd.mnCol, rEnd.mnRow );
 204                 // merge not possible if selection is only one cell and all its merges
 205                 if( rEnd == rStart )
 206                     return false;
 207                 xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( rEnd.mnCol, rEnd.mnRow ).get() ) );
 208             }
 209         }
 210         if( xCell.is() )
 211         {
 212             rEnd.mnCol += xCell->getColumnSpan()-1;
 213             rEnd.mnRow += xCell->getRowSpan()-1;
 214         }
 215
 216         // now check if everything is inside the given bounds
 217         sal_Int32 nRow, nCol;
 218         for( nRow = rStart.mnRow; nRow <= rEnd.mnRow; nRow++ )
 219         {
 220             for( nCol = rStart.mnCol; nCol <= rEnd.mnCol; nCol++ )
 221             {
 222                 xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 223                 if( !xCell.is() )
 224                     continue;
 225
 226                 if( xCell->isMerged() )
 227                 {
 228                     sal_Int32 nOriginCol, nOriginRow;
 229                     if( findMergeOrigin( mxTable, nCol, nRow, nOriginCol, nOriginRow ) )
 230                     {
 231                         if( (nOriginCol < rStart.mnCol) || (nOriginRow < rStart.mnRow) )
 232                             return false;
 233
 234                         xCell.set( dynamic_cast< Cell* >( mxTable->getCellByPosition( nOriginCol, nOriginRow ).get() ) );
 235                         if( xCell.is() )
 236                         {
 237                             nOriginCol += xCell->getColumnSpan()-1;
 238                             nOriginRow += xCell->getRowSpan()-1;
 239
 240                             if( (nOriginCol > rEnd.mnCol) || (nOriginRow > rEnd.mnRow) )
 241                                 return false;
 242                         }
 243                     }
 244                 }
 245                 else if( ((nCol + xCell->getColumnSpan() - 1) > rEnd.mnCol) || ((nRow + xCell->getRowSpan() - 1 ) > rEnd.mnRow) )
 246                 {
 247                     return false;
 248                 }
 249             }
 250         }
 251         return true;
 252     }
 253     catch( Exception& )
 254     {
 255         DBG_ERROR("sdr::table::SvmxTableController::GetMergedSelection(), exception caught!");
 256     }
 257     return false;
 258 }
 259
 260 // -----------------------------------------------------------------------------
 261
 262 void SAL_CALL CellCursor::merge(  ) throw (NoSupportException, RuntimeException)
 263 {
 264     CellPos aStart, aEnd;
 265     if( !GetMergedSelection( aStart, aEnd ) )
 266         throw NoSupportException();
 267
 268     if( !mxTable.is() || (mxTable->getSdrTableObj() == 0) )
 269         throw DisposedException();
 270
 271     SdrModel* pModel = mxTable->getSdrTableObj()->GetModel();
 272     const bool bUndo = pModel && mxTable->getSdrTableObj()->IsInserted() && pModel->IsUndoEnabled();
 273
 274     if( bUndo )
 275         pModel->BegUndo( ImpGetResStr(STR_TABLE_MERGE) );
 276
 277     try
 278     {
 279         mxTable->merge( aStart.mnCol, aStart.mnRow, aEnd.mnCol - aStart.mnCol + 1, aEnd.mnRow - aStart.mnRow + 1 );
 280         mxTable->optimize();
 281         mxTable->setModified(sal_True);
 282     }
 283     catch( Exception& )
 284     {
 285         DBG_ERROR("sdr::table::CellCursor::merge(), exception caught!");
 286     }
 287
 288     if( bUndo )
 289         pModel->EndUndo();
 290
 291     if( pModel )
 292         pModel->SetChanged();
 293 }
 294
 295 // -----------------------------------------------------------------------------
 296
 297 void CellCursor::split_column( sal_Int32 nCol, sal_Int32 nColumns, std::vector< sal_Int32 >& rLeftOvers )
 298 {
 299     const sal_Int32 nRowCount = mxTable->getRowCount();
 300
 301     sal_Int32 nNewCols = 0, nRow;
 302
 303     // first check how many columns we need to add
 304     for( nRow = mnTop; nRow <= mnBottom; ++nRow )
 305     {
 306         CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 307         if( xCell.is() && !xCell->isMerged() )
 308             nNewCols = std::max( nNewCols, nColumns - xCell->getColumnSpan() + 1 - rLeftOvers[nRow] );
 309     }
 310
 311     if( nNewCols > 0 )
 312     {
 313         const OUString sWidth( RTL_CONSTASCII_USTRINGPARAM("Width") );
 314         Reference< XTableColumns > xCols( mxTable->getColumns(), UNO_QUERY_THROW );
 315         Reference< XPropertySet > xRefColumn( xCols->getByIndex( nCol ), UNO_QUERY_THROW );
 316         sal_Int32 nWidth = 0;
 317         xRefColumn->getPropertyValue( sWidth ) >>= nWidth;
 318         const sal_Int32 nNewWidth = nWidth / (nNewCols + 1);
 319
 320         // reference column gets new width + rounding errors
 321         xRefColumn->setPropertyValue( sWidth, Any( nWidth - (nNewWidth * nNewCols) ) );
 322
 323         xCols->insertByIndex( nCol + 1, nNewCols );
 324         mnRight += nNewCols;
 325
 326         // distribute new width
 327         for( sal_Int32 nNewCol = nCol + nNewCols; nNewCol > nCol; --nNewCol )
 328         {
 329             Reference< XPropertySet > xNewCol( xCols->getByIndex( nNewCol ), UNO_QUERY_THROW );
 330             xNewCol->setPropertyValue( sWidth, Any( nNewWidth ) );
 331         }
 332     }
 333
 334     for( nRow = 0; nRow < nRowCount; ++nRow )
 335     {
 336         CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 337         if( !xCell.is() || xCell->isMerged() )
 338         {
 339             if( nNewCols > 0 )
 340             {
 341                 // merged cells are ignored, but newly added columns will be added to leftovers
 342                 xCell.set( dynamic_cast< Cell* >(mxTable->getCellByPosition( nCol+1, nRow ).get() ) );
 343                 if( !xCell.is() || !xCell->isMerged() )
 344                 rLeftOvers[nRow] += nNewCols;
 345             }
 346         }
 347         else
 348         {
 349             sal_Int32 nRowSpan = xCell->getRowSpan() - 1;
 350             sal_Int32 nColSpan = xCell->getColumnSpan() - 1;
 351
 352             if( (nRow >= mnTop) && (nRow <= mnBottom) )
 353             {
 354                 sal_Int32 nCellsAvailable = 1 + nColSpan + rLeftOvers[nRow];
 355                 if( nColSpan == 0 )
 356                     nCellsAvailable += nNewCols;
 357
 358                 DBG_ASSERT( nCellsAvailable > nColumns, "sdr::table::CellCursor::split_column(), somethings wrong" );
 359
 360                 sal_Int32 nSplitSpan = (nCellsAvailable / (nColumns + 1)) - 1;
 361
 362                 sal_Int32 nSplitCol = nCol;
 363                 sal_Int32 nSplits = nColumns + 1;
 364                 while( nSplits-- )
 365                 {
 366                     // last split eats rounding cells
 367                     if( nSplits == 0 )
 368                         nSplitSpan = nCellsAvailable - ((nSplitSpan+1) * nColumns) - 1;
 369
 370                     mxTable->merge( nSplitCol, nRow, nSplitSpan + 1, nRowSpan + 1);
 371                     if( nSplits > 0 )
 372                         nSplitCol += nSplitSpan + 1;
 373                 }
 374
 375                 do
 376                 {
 377                     rLeftOvers[nRow++] = 0;
 378                 }
 379                 while( nRowSpan-- );
 380                 --nRow;
 381             }
 382             else
 383             {
 384                 // cope with outside cells, merge if needed
 385                 if( nColSpan < (rLeftOvers[nRow] + nNewCols) )
 386                     mxTable->merge( nCol, nRow, (rLeftOvers[nRow] + nNewCols) + 1, nRowSpan + 1 );
 387
 388                 do
 389                 {
 390                     rLeftOvers[nRow++] = 0; // consumed
 391                 }
 392                 while( nRowSpan-- );
 393                 --nRow;
 394             }
 395         }
 396     }
 397 }
 398
 399 // -----------------------------------------------------------------------------
 400
 401 void CellCursor::split_horizontal( sal_Int32 nColumns )
 402 {
 403     const sal_Int32 nRowCount = mxTable->getRowCount();
 404
 405     std::vector< sal_Int32 > aLeftOvers( nRowCount );
 406
 407     for( sal_Int32 nCol = mnRight; nCol >= mnLeft; --nCol )
 408         split_column( nCol, nColumns, aLeftOvers );
 409 }
 410
 411 // -----------------------------------------------------------------------------
 412
 413 void CellCursor::split_row( sal_Int32 nRow, sal_Int32 nRows, std::vector< sal_Int32 >& rLeftOvers )
 414 {
 415     const sal_Int32 nColCount = mxTable->getColumnCount();
 416
 417     sal_Int32 nNewRows = 0, nCol;
 418
 419     // first check how many columns we need to add
 420     for( nCol = mnLeft; nCol <= mnRight; ++nCol )
 421     {
 422         CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 423         if( xCell.is() && !xCell->isMerged() )
 424             nNewRows = std::max( nNewRows, nRows - xCell->getRowSpan() + 1 - rLeftOvers[nCol] );
 425     }
 426
 427     if( nNewRows > 0 )
 428     {
 429         const OUString sHeight( RTL_CONSTASCII_USTRINGPARAM("Height") );
 430         Reference< XTableRows > xRows( mxTable->getRows(), UNO_QUERY_THROW );
 431         Reference< XPropertySet > xRefRow( xRows->getByIndex( nRow ), UNO_QUERY_THROW );
 432         sal_Int32 nHeight = 0;
 433         xRefRow->getPropertyValue( sHeight ) >>= nHeight;
 434         const sal_Int32 nNewHeight = nHeight / (nNewRows + 1);
 435
 436         // reference row gets new height + rounding errors
 437         xRefRow->setPropertyValue( sHeight, Any( nHeight - (nNewHeight * nNewRows) ) );
 438
 439         xRows->insertByIndex( nRow + 1, nNewRows );
 440         mnBottom += nNewRows;
 441
 442         // distribute new width
 443         for( sal_Int32 nNewRow = nRow + nNewRows; nNewRow > nRow; --nNewRow )
 444         {
 445             Reference< XPropertySet > xNewRow( xRows->getByIndex( nNewRow ), UNO_QUERY_THROW );
 446             xNewRow->setPropertyValue( sHeight, Any( nNewHeight ) );
 447         }
 448     }
 449
 450     for( nCol = 0; nCol < nColCount; ++nCol )
 451     {
 452         CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 453         if( !xCell.is() || xCell->isMerged() )
 454         {
 455             if( nNewRows )
 456             {
 457                 // merged cells are ignored, but newly added columns will be added to leftovers
 458                 xCell.set( dynamic_cast< Cell* >(mxTable->getCellByPosition( nCol, nRow+1 ).get() ) );
 459                 if( !xCell.is() || !xCell->isMerged() )
 460                     rLeftOvers[nCol] += nNewRows;
 461             }
 462         }
 463         else
 464         {
 465             sal_Int32 nRowSpan = xCell->getRowSpan() - 1;
 466             sal_Int32 nColSpan = xCell->getColumnSpan() - 1;
 467
 468             if( (nCol >= mnLeft) && (nCol <= mnRight) )
 469             {
 470                 sal_Int32 nCellsAvailable = 1 + nRowSpan + rLeftOvers[nCol];
 471                 if( nRowSpan == 0 )
 472                     nCellsAvailable += nNewRows;
 473
 474                 DBG_ASSERT( nCellsAvailable > nRows, "sdr::table::CellCursor::split_row(), somethings wrong" );
 475
 476                 sal_Int32 nSplitSpan = (nCellsAvailable / (nRows + 1)) - 1;
 477
 478                 sal_Int32 nSplitRow = nRow;
 479                 sal_Int32 nSplits = nRows + 1;
 480                 while( nSplits-- )
 481                 {
 482                     // last split eats rounding cells
 483                     if( nSplits == 0 )
 484                         nSplitSpan = nCellsAvailable - ((nSplitSpan+1) * nRows) - 1;
 485
 486                     mxTable->merge( nCol, nSplitRow, nColSpan + 1, nSplitSpan + 1 );
 487                     if( nSplits > 0 )
 488                         nSplitRow += nSplitSpan + 1;
 489                 }
 490
 491                 do
 492                 {
 493                     rLeftOvers[nCol++] = 0;
 494                 }
 495                 while( nColSpan-- );
 496                 --nCol;
 497             }
 498             else
 499             {
 500                 // cope with outside cells, merge if needed
 501                 if( nRowSpan < (rLeftOvers[nCol] + nNewRows) )
 502                     mxTable->merge( nCol, nRow, nColSpan + 1, (rLeftOvers[nCol] + nNewRows) + 1 );
 503
 504                 do
 505                 {
 506                     rLeftOvers[nCol++] = 0; // consumed
 507                 }
 508                 while( nColSpan-- );
 509                 --nCol;
 510             }
 511         }
 512     }
 513 }
 514
 515 // -----------------------------------------------------------------------------
 516
 517 void CellCursor::split_vertical( sal_Int32 nRows )
 518 {
 519     const sal_Int32 nColCount = mxTable->getColumnCount();
 520
 521     std::vector< sal_Int32 > aLeftOvers( nColCount );
 522
 523     for( sal_Int32 nRow = mnBottom; nRow >= mnTop; --nRow )
 524         split_row( nRow, nRows, aLeftOvers );
 525 }
 526
 527 // -----------------------------------------------------------------------------
 528
 529 void SAL_CALL CellCursor::split( sal_Int32 nColumns, sal_Int32 nRows ) throw (NoSupportException, IllegalArgumentException, RuntimeException)
 530 {
 531     if( (nColumns < 0) || (nRows < 0) )
 532         throw IllegalArgumentException();
 533
 534     if( !mxTable.is() || (mxTable->getSdrTableObj() == 0) )
 535         throw DisposedException();
 536
 537     SdrModel* pModel = mxTable->getSdrTableObj()->GetModel();
 538     const bool bUndo = pModel && mxTable->getSdrTableObj()->IsInserted() && pModel->IsUndoEnabled();
 539     if( bUndo )
 540         pModel->BegUndo( ImpGetResStr(STR_TABLE_SPLIT) );
 541
 542     try
 543     {
 544         if( nColumns > 0 )
 545             split_horizontal( nColumns );
 546
 547         if( nRows > 0 )
 548             split_vertical( nRows );
 549
 550         if( nColumns > 0 ||nRows > 0 )
 551             mxTable->setModified(sal_True);
 552     }
 553     catch( Exception& )
 554     {
 555         DBG_ERROR("sdr::table::CellCursor::split(), exception caught!");
 556         throw NoSupportException();
 557     }
 558
 559     if( bUndo )
 560         pModel->EndUndo();
 561
 562     if( pModel )
 563         pModel->SetChanged();
 564 }
 565
 566 // -----------------------------------------------------------------------------
 567
 568 sal_Bool SAL_CALL CellCursor::isMergeable(  ) throw (RuntimeException)
 569 {
 570     CellPos aStart, aEnd;
 571     return GetMergedSelection( aStart, aEnd ) ? sal_True : sal_False;
 572 }
 573
 574 // -----------------------------------------------------------------------------
 575
 576 sal_Bool SAL_CALL CellCursor::isUnmergeable(  ) throw (RuntimeException)
 577 {
 578     // this is true if there is at least one merged cell in the current range
 579     for( sal_Int32 nRow = mnTop; nRow <= mnBottom; nRow++ )
 580     {
 581         for( sal_Int32 nCol = mnLeft; nCol <= mnRight; nCol++ )
 582         {
 583             CellRef xCell( dynamic_cast< Cell* >( mxTable->getCellByPosition( nCol, nRow ).get() ) );
 584             if( xCell.is() && ( (xCell->getRowSpan() > 1) || (xCell->getColumnSpan() > 1) ) )
 585                 return sal_True;
 586         }
 587     }
 588     return sal_False;
 589 }
 590
 591 // -----------------------------------------------------------------------------
 592
 593 } }