svx/source/table/tablemodel.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: tablemodel.cxx,v $
  10  * $Revision: 1.4.264.2 $
  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
  36 #include <algorithm>
  37 #include <boost/bind.hpp>
  38
  39 #include <vcl/svapp.hxx>
  40 #include <vos/mutex.hxx>
  41
  42 #include "cell.hxx"
  43 #include "cellcursor.hxx"
  44 #include "tablemodel.hxx"
  45 #include "tablerow.hxx"
  46 #include "tablerows.hxx"
  47 #include "tablecolumn.hxx"
  48 #include "tablecolumns.hxx"
  49 #include "tableundo.hxx"
  50 #include "svx/svdotable.hxx"
  51 #include "svx/svdmodel.hxx"
  52 #include "svdstr.hrc"
  53 #include "svdglob.hxx"
  54
  55 //#define PLEASE_DEBUG_THE_TABLES 1
  56
  57 using ::rtl::OUString;
  58 using namespace ::osl;
  59 using namespace ::vos;
  60 using namespace ::com::sun::star::uno;
  61 using namespace ::com::sun::star::table;
  62 using namespace ::com::sun::star::lang;
  63 using namespace ::com::sun::star::container;
  64 using namespace ::com::sun::star::beans;
  65 using namespace ::com::sun::star::util;
  66
  67 // -----------------------------------------------------------------------------
  68
  69 namespace sdr { namespace table {
  70
  71 // -----------------------------------------------------------------------------
  72
  73 // removes the given range from a vector
  74 template< class Vec, class Iter > void remove_range( Vec& rVector, sal_Int32 nIndex, sal_Int32 nCount )
  75 {
  76     const sal_Int32 nSize = static_cast<sal_Int32>(rVector.size());
  77     if( nCount && (nIndex >= 0) && (nIndex < nSize) )
  78     {
  79         if( (nIndex + nCount) >= nSize )
  80         {
  81             // remove at end
  82             rVector.resize( nIndex );
  83         }
  84         else
  85         {
  86             Iter aBegin( rVector.begin() );
  87             while( nIndex-- )
  88                 aBegin++;
  89             if( nCount == 1 )
  90             {
  91                 rVector.erase( aBegin );
  92             }
  93             else
  94             {
  95                 Iter aEnd( aBegin );
  96
  97                 while( nCount-- )
  98                     aEnd++;
  99                 rVector.erase( aBegin, aEnd );
 100             }
 101         }
 102     }
 103 }
 104
 105 // -----------------------------------------------------------------------------
 106
 107 /** inserts a range into a vector */
 108 template< class Vec, class Iter, class Entry > sal_Int32 insert_range( Vec& rVector, sal_Int32 nIndex, sal_Int32 nCount )
 109 {
 110     if( nCount )
 111     {
 112         if( nIndex >= static_cast< sal_Int32 >( rVector.size() ) )
 113         {
 114             // append at end
 115             nIndex = static_cast< sal_Int32 >( rVector.size() ); // cap to end
 116             rVector.resize( nIndex + nCount );
 117         }
 118         else
 119         {
 120             // insert
 121             sal_Int32 nFind = nIndex;
 122             Iter aIter( rVector.begin() );
 123             while( nFind-- )
 124                 aIter++;
 125
 126             Entry aEmpty;
 127             rVector.insert( aIter, nCount, aEmpty );
 128         }
 129     }
 130     return nIndex;
 131 }
 132
 133 // -----------------------------------------------------------------------------
 134
 135 TableModel::TableModel( SdrTableObj* pTableObj )
 136 : TableModelBase( m_aMutex  )
 137 , mpTableObj( pTableObj )
 138 , mbModified( sal_False )
 139 , mbNotifyPending( false )
 140 , mnNotifyLock( 0 )
 141 {
 142 }
 143
 144 TableModel::TableModel( SdrTableObj* pTableObj, const TableModelRef& xSourceTable )
 145 : TableModelBase( m_aMutex  )
 146 , mpTableObj( pTableObj )
 147 , mbModified( sal_False )
 148 , mbNotifyPending( false )
 149 , mnNotifyLock( 0 )
 150 {
 151     if( xSourceTable.is() )
 152     {
 153         const sal_Int32 nColCount = xSourceTable->getColumnCountImpl();
 154         const sal_Int32 nRowCount = xSourceTable->getRowCountImpl();
 155
 156         init( nColCount, nRowCount );
 157
 158         sal_Int32 nRows = nRowCount;
 159         while( nRows-- )
 160             (*maRows[nRows]) = (*xSourceTable->maRows[nRows]);
 161
 162         sal_Int32 nColumns = nColCount;
 163         while( nColumns-- )
 164             (*maColumns[nColumns]) = (*xSourceTable->maColumns[nColumns]);
 165
 166         // copy cells
 167         for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
 168         {
 169             for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
 170             {
 171                 CellRef xTargetCell( getCell( nCol, nRow ) );
 172                 if( xTargetCell.is() )
 173                     xTargetCell->cloneFrom( xSourceTable->getCell( nCol, nRow ) );
 174             }
 175         }
 176     }
 177 }
 178
 179 // -----------------------------------------------------------------------------
 180
 181 TableModel::~TableModel()
 182 {
 183 }
 184
 185 // -----------------------------------------------------------------------------
 186
 187 void TableModel::init( sal_Int32 nColumns, sal_Int32 nRows )
 188 {
 189     if( nRows < 20 )
 190         maRows.reserve( 20 );
 191
 192     if( nColumns < 20 )
 193         maColumns.reserve( 20 );
 194
 195     if( nRows && nColumns )
 196     {
 197         maColumns.resize( nColumns );
 198         maRows.resize( nRows );
 199
 200         while( nRows-- )
 201             maRows[nRows].set( new TableRow( this, nRows, nColumns ) );
 202
 203         while( nColumns-- )
 204             maColumns[nColumns].set( new TableColumn( this, nColumns ) );
 205     }
 206 }
 207
 208 // -----------------------------------------------------------------------------
 209 // ICellRange
 210 // -----------------------------------------------------------------------------
 211
 212 sal_Int32 TableModel::getLeft()
 213 {
 214     return 0;
 215 }
 216
 217 // -----------------------------------------------------------------------------
 218
 219 sal_Int32 TableModel::getTop()
 220 {
 221     return 0;
 222 }
 223
 224 // -----------------------------------------------------------------------------
 225
 226 sal_Int32 TableModel::getRight()
 227 {
 228     return getColumnCount();
 229 }
 230
 231 // -----------------------------------------------------------------------------
 232
 233 sal_Int32 TableModel::getBottom()
 234 {
 235     return getRowCount();
 236 }
 237
 238 // -----------------------------------------------------------------------------
 239
 240 Reference< XTable > TableModel::getTable()
 241 {
 242     return this;
 243 }
 244
 245 // -----------------------------------------------------------------------------
 246
 247 void TableModel::UndoInsertRows( sal_Int32 nIndex, sal_Int32 nCount )
 248 {
 249     TableModelNotifyGuard aGuard( this );
 250
 251     // remove the rows
 252     remove_range<RowVector,RowVector::iterator>( maRows, nIndex, nCount );
 253     updateRows();
 254     setModified(sal_True);
 255 }
 256
 257 // -----------------------------------------------------------------------------
 258
 259 void TableModel::UndoRemoveRows( sal_Int32 nIndex, RowVector& aRows )
 260 {
 261     TableModelNotifyGuard aGuard( this );
 262
 263     const sal_Int32 nCount = sal::static_int_cast< sal_Int32 >( aRows.size() );
 264
 265     nIndex = insert_range<RowVector,RowVector::iterator,TableRowRef>( maRows, nIndex, nCount );
 266
 267     for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
 268         maRows[nIndex+nOffset] = aRows[nOffset];
 269
 270     updateRows();
 271     setModified(sal_True);
 272 }
 273
 274 // -----------------------------------------------------------------------------
 275
 276 void TableModel::UndoInsertColumns( sal_Int32 nIndex, sal_Int32 nCount )
 277 {
 278     TableModelNotifyGuard aGuard( this );
 279
 280     // now remove the columns
 281     remove_range<ColumnVector,ColumnVector::iterator>( maColumns, nIndex, nCount );
 282     sal_Int32 nRows = getRowCountImpl();
 283     while( nRows-- )
 284         maRows[nRows]->removeColumns( nIndex, nCount );
 285
 286     updateColumns();
 287     setModified(sal_True);
 288 }
 289
 290 // -----------------------------------------------------------------------------
 291
 292 void TableModel::UndoRemoveColumns( sal_Int32 nIndex, ColumnVector& aCols, CellVector& aCells )
 293 {
 294     TableModelNotifyGuard aGuard( this );
 295
 296     const sal_Int32 nCount = sal::static_int_cast< sal_Int32 >( aCols.size() );
 297
 298     // assert if there are not enough cells saved
 299     DBG_ASSERT( (aCols.size() * maRows.size()) == aCells.size(), "sdr::table::TableModel::UndoRemoveColumns(), invalid undo data!" );
 300
 301     nIndex = insert_range<ColumnVector,ColumnVector::iterator,TableColumnRef>( maColumns, nIndex, nCount );
 302     for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
 303         maColumns[nIndex+nOffset] = aCols[nOffset];
 304
 305     CellVector::iterator aIter( aCells.begin() );
 306
 307     sal_Int32 nRows = getRowCountImpl();
 308     for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
 309         maRows[nRow]->insertColumns( nIndex, nCount, &aIter );
 310
 311     updateColumns();
 312     setModified(sal_True);
 313 }
 314
 315 // -----------------------------------------------------------------------------
 316 // XTable
 317 // -----------------------------------------------------------------------------
 318
 319 Reference< XCellCursor > SAL_CALL TableModel::createCursor() throw (RuntimeException)
 320 {
 321     OGuard aGuard( Application::GetSolarMutex() );
 322     return createCursorByRange( Reference< XCellRange >( this ) );
 323 }
 324
 325 // -----------------------------------------------------------------------------
 326
 327 Reference< XCellCursor > SAL_CALL TableModel::createCursorByRange( const Reference< XCellRange >& Range ) throw (IllegalArgumentException, RuntimeException)
 328 {
 329     OGuard aGuard( Application::GetSolarMutex() );
 330
 331     ICellRange* pRange = dynamic_cast< ICellRange* >( Range.get() );
 332     if( (pRange == 0) || (pRange->getTable().get() != this) )
 333         throw IllegalArgumentException();
 334
 335     TableModelRef xModel( this );
 336     return new CellCursor( xModel, pRange->getLeft(), pRange->getTop(), pRange->getRight(), pRange->getBottom() );
 337 }
 338
 339 // -----------------------------------------------------------------------------
 340
 341 sal_Int32 SAL_CALL TableModel::getRowCount() throw (RuntimeException)
 342 {
 343     OGuard aGuard( Application::GetSolarMutex() );
 344     return getRowCountImpl();
 345 }
 346
 347 // -----------------------------------------------------------------------------
 348
 349 sal_Int32 SAL_CALL TableModel::getColumnCount() throw (RuntimeException)
 350 {
 351     OGuard aGuard( Application::GetSolarMutex() );
 352     return getColumnCountImpl();
 353 }
 354
 355 // -----------------------------------------------------------------------------
 356 // XComponent
 357 // -----------------------------------------------------------------------------
 358
 359 void TableModel::dispose() throw (RuntimeException)
 360 {
 361     OGuard aGuard( Application::GetSolarMutex() );
 362     TableModelBase::dispose();
 363 }
 364
 365 // -----------------------------------------------------------------------------
 366
 367 void SAL_CALL TableModel::addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException)
 368 {
 369     TableModelBase::addEventListener( xListener );
 370 }
 371
 372 // -----------------------------------------------------------------------------
 373
 374 void SAL_CALL TableModel::removeEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException)
 375 {
 376     TableModelBase::removeEventListener( xListener );
 377 }
 378
 379 // -----------------------------------------------------------------------------
 380 // XModifiable
 381 // -----------------------------------------------------------------------------
 382
 383 sal_Bool SAL_CALL TableModel::isModified(  ) throw (RuntimeException)
 384 {
 385     OGuard aGuard( Application::GetSolarMutex() );
 386     return mbModified;
 387 }
 388
 389 // -----------------------------------------------------------------------------
 390
 391 void SAL_CALL TableModel::setModified( sal_Bool bModified ) throw (PropertyVetoException, RuntimeException)
 392 {
 393     {
 394         OGuard aGuard( Application::GetSolarMutex() );
 395         mbModified = bModified;
 396     }
 397     if( bModified )
 398         notifyModification();
 399 }
 400
 401 // -----------------------------------------------------------------------------
 402 // XModifyBroadcaster
 403 // -----------------------------------------------------------------------------
 404
 405 void SAL_CALL TableModel::addModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException)
 406 {
 407     rBHelper.addListener( XModifyListener::static_type() , xListener );
 408 }
 409
 410 // -----------------------------------------------------------------------------
 411
 412 void SAL_CALL TableModel::removeModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException)
 413 {
 414     rBHelper.removeListener( XModifyListener::static_type() , xListener );
 415 }
 416
 417 // -----------------------------------------------------------------------------
 418 // XColumnRowRange
 419 // -----------------------------------------------------------------------------
 420
 421 Reference< XTableColumns > SAL_CALL TableModel::getColumns() throw (RuntimeException)
 422 {
 423     OGuard aGuard( Application::GetSolarMutex() );
 424
 425     if( !mxTableColumns.is() )
 426         mxTableColumns.set( new TableColumns( this ) );
 427     return mxTableColumns.get();
 428 }
 429
 430 // -----------------------------------------------------------------------------
 431
 432 Reference< XTableRows > SAL_CALL TableModel::getRows() throw (RuntimeException)
 433 {
 434     OGuard aGuard( Application::GetSolarMutex() );
 435
 436     if( !mxTableRows.is() )
 437         mxTableRows.set( new TableRows( this ) );
 438     return mxTableRows.get();
 439 }
 440
 441 // -----------------------------------------------------------------------------
 442 // XCellRange
 443 // -----------------------------------------------------------------------------
 444
 445 Reference< XCell > SAL_CALL TableModel::getCellByPosition( sal_Int32 nColumn, sal_Int32 nRow ) throw ( IndexOutOfBoundsException, RuntimeException)
 446 {
 447     OGuard aGuard( Application::GetSolarMutex() );
 448
 449     CellRef xCell( getCell( nColumn, nRow ) );
 450     if( xCell.is() )
 451         return xCell.get();
 452
 453     throw IndexOutOfBoundsException();
 454 }
 455
 456 // -----------------------------------------------------------------------------
 457
 458 Reference< XCellRange > SAL_CALL TableModel::getCellRangeByPosition( sal_Int32 nLeft, sal_Int32 nTop, sal_Int32 nRight, sal_Int32 nBottom ) throw (IndexOutOfBoundsException, RuntimeException)
 459 {
 460     OGuard aGuard( Application::GetSolarMutex() );
 461
 462     if( (nLeft >= 0) && (nTop >= 0) && (nRight >= nLeft) && (nBottom >= nTop) && (nRight < getColumnCountImpl()) && (nBottom < getRowCountImpl() ) )
 463     {
 464         TableModelRef xModel( this );
 465         return new CellRange( xModel, nLeft, nTop, nRight, nBottom );
 466     }
 467
 468     throw IndexOutOfBoundsException();
 469 }
 470
 471 // -----------------------------------------------------------------------------
 472
 473 Reference< XCellRange > SAL_CALL TableModel::getCellRangeByName( const OUString& /*aRange*/ ) throw (RuntimeException)
 474 {
 475     return Reference< XCellRange >();
 476 }
 477
 478 // -----------------------------------------------------------------------------
 479 // XPropertySet
 480 // -----------------------------------------------------------------------------
 481
 482 Reference< XPropertySetInfo > SAL_CALL TableModel::getPropertySetInfo(  ) throw (RuntimeException)
 483 {
 484     Reference< XPropertySetInfo > xInfo;
 485     return xInfo;
 486 }
 487
 488 // -----------------------------------------------------------------------------
 489
 490 void SAL_CALL TableModel::setPropertyValue( const ::rtl::OUString& /*aPropertyName*/, const Any& /*aValue*/ ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
 491 {
 492 }
 493
 494 // -----------------------------------------------------------------------------
 495
 496 Any SAL_CALL TableModel::getPropertyValue( const OUString& /*PropertyName*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
 497 {
 498     return Any();
 499 }
 500
 501 // -----------------------------------------------------------------------------
 502
 503 void SAL_CALL TableModel::addPropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
 504 {
 505 }
 506
 507 // -----------------------------------------------------------------------------
 508
 509 void SAL_CALL TableModel::removePropertyChangeListener( const OUString& /*aPropertyName*/, const Reference< XPropertyChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
 510 {
 511 }
 512
 513 // -----------------------------------------------------------------------------
 514
 515 void SAL_CALL TableModel::addVetoableChangeListener( const OUString& /*aPropertyName*/, const Reference< XVetoableChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
 516 {
 517 }
 518
 519 // -----------------------------------------------------------------------------
 520
 521 void SAL_CALL TableModel::removeVetoableChangeListener( const OUString& /*aPropertyName*/, const Reference< XVetoableChangeListener >& /*xListener*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
 522 {
 523 }
 524
 525 // -----------------------------------------------------------------------------
 526 // XFastPropertySet
 527 // -----------------------------------------------------------------------------
 528
 529 void SAL_CALL TableModel::setFastPropertyValue( ::sal_Int32 /*nHandle*/, const Any& /*aValue*/ ) throw (UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException)
 530 {
 531 }
 532
 533 // -----------------------------------------------------------------------------
 534
 535 Any SAL_CALL TableModel::getFastPropertyValue( ::sal_Int32 /*nHandle*/ ) throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
 536 {
 537     Any aAny;
 538     return aAny;
 539 }
 540
 541 // -----------------------------------------------------------------------------
 542 // internals
 543 // -----------------------------------------------------------------------------
 544
 545 sal_Int32 TableModel::getRowCountImpl() const
 546 {
 547     return static_cast< sal_Int32 >( maRows.size() );
 548 }
 549
 550 // -----------------------------------------------------------------------------
 551
 552 sal_Int32 TableModel::getColumnCountImpl() const
 553 {
 554     return static_cast< sal_Int32 >( maColumns.size() );
 555 }
 556
 557 // -----------------------------------------------------------------------------
 558
 559 void TableModel::disposing()
 560 {
 561     if( !maRows.empty() )
 562     {
 563         RowVector::iterator aIter( maRows.begin() );
 564         while( aIter != maRows.end() )
 565             (*aIter++)->dispose();
 566         RowVector().swap(maRows);
 567     }
 568
 569     if( !maColumns.empty() )
 570     {
 571         ColumnVector::iterator aIter( maColumns.begin() );
 572         while( aIter != maColumns.end() )
 573             (*aIter++)->dispose();
 574         ColumnVector().swap(maColumns);
 575     }
 576
 577     if( mxTableColumns.is() )
 578     {
 579         mxTableColumns->dispose();
 580         mxTableColumns.clear();
 581     }
 582
 583     if( mxTableRows.is() )
 584     {
 585         mxTableRows->dispose();
 586         mxTableRows.clear();
 587     }
 588
 589     mpTableObj = 0;
 590 }
 591
 592 // -----------------------------------------------------------------------------
 593 // XBroadcaster
 594 // -----------------------------------------------------------------------------
 595
 596 void TableModel::lockBroadcasts() throw (RuntimeException)
 597 {
 598     OGuard aGuard( Application::GetSolarMutex() );
 599     ++mnNotifyLock;
 600 }
 601 // -----------------------------------------------------------------------------
 602
 603 void TableModel::unlockBroadcasts() throw (RuntimeException)
 604 {
 605     OGuard aGuard( Application::GetSolarMutex() );
 606     --mnNotifyLock;
 607     if( mnNotifyLock <= 0 )
 608     {
 609         mnNotifyLock = 0;
 610         if( mbNotifyPending )
 611             notifyModification();
 612     }
 613 }
 614
 615 // -----------------------------------------------------------------------------
 616 #ifdef PLEASE_DEBUG_THE_TABLES
 617 #include <stdio.h>
 618 #endif
 619
 620 void TableModel::notifyModification()
 621 {
 622     ::osl::MutexGuard guard( m_aMutex );
 623     if( (mnNotifyLock == 0) && mpTableObj && mpTableObj->GetModel() )
 624     {
 625         mbNotifyPending = false;
 626
 627         ::cppu::OInterfaceContainerHelper * pModifyListeners = rBHelper.getContainer( XModifyListener::static_type() );
 628         if( pModifyListeners )
 629         {
 630             EventObject aSource;
 631             aSource.Source = static_cast< ::cppu::OWeakObject* >(this);
 632             pModifyListeners->notifyEach( &XModifyListener::modified, aSource);
 633         }
 634     }
 635     else
 636     {
 637         mbNotifyPending = true;
 638     }
 639
 640 #ifdef PLEASE_DEBUG_THE_TABLES
 641         FILE* file = fopen( "c:\\table.xml","w" );
 642
 643         const sal_Int32 nColCount = getColumnCountImpl();
 644         const sal_Int32 nRowCount = getRowCountImpl();
 645
 646         fprintf( file, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\r" );
 647         fprintf( file, "<table columns=\"%ld\" rows=\"%ld\" updated=\"%s\">\n\r", nColCount, nRowCount, mbNotifyPending ? "false" : "true");
 648
 649         for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
 650         {
 651             fprintf( file, "<column this=\"%lx\"/>\n\r", maColumns[nCol].get() );
 652         }
 653
 654         // first check merged cells before and inside the removed rows
 655         for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
 656         {
 657             fprintf( file, "<row this=\"%lx\">\n\r", maRows[nRow].get() );
 658             for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
 659             {
 660                 CellRef xCell( getCell( nCol, nRow ) );
 661                 fprintf( file, "<cell this=\"%lx\"", xCell.get() );
 662
 663                 sal_Int32 nRowSpan = xCell->getRowSpan();
 664                 sal_Int32 nColSpan = xCell->getColumnSpan();
 665                 sal_Bool bMerged = xCell->isMerged();
 666
 667                 if( nColSpan != 1 )
 668                     fprintf( file, " column-span=\"%ld\"", nColSpan );
 669                 if( nRowSpan != 1 )
 670                     fprintf( file, " row-span=\"%ld\"", nRowSpan );
 671
 672                 if( bMerged )
 673                     fprintf( file, " merged=\"true\"" );
 674
 675                 fprintf( file, "/>" );
 676             }
 677             fprintf( file, "\n\r</row>\n\r" );
 678         }
 679
 680         fprintf( file, "</table>\n\r" );
 681         fclose( file );
 682 #endif
 683 }
 684
 685 // -----------------------------------------------------------------------------
 686
 687 CellRef TableModel::getCell( sal_Int32 nCol, sal_Int32 nRow ) const
 688 {
 689     if( ((nRow >= 0) && (nRow < getRowCountImpl())) && (nCol >= 0) && (nCol < getColumnCountImpl()) )
 690     {
 691         return maRows[nRow]->maCells[nCol];
 692     }
 693     else
 694     {
 695         CellRef xRet;
 696         return xRet;
 697     }
 698 }
 699
 700 // -----------------------------------------------------------------------------
 701 /*
 702 bool TableModel::getCellPos( const CellRef& xCell, ::sal_Int32& rnCol, ::sal_Int32& rnRow ) const
 703 {
 704     const sal_Int32 nRowCount = getRowCount();
 705     const sal_Int32 nColCount = getColumnCount();
 706     for( rnRow = 0; rnRow < nRowCount; rnRow++ )
 707     {
 708         for( rnCol = 0; rnCol < nColCount; rnCol++ )
 709         {
 710             if( maRows[rnRow]->maCells[rnCol] == xCell )
 711             {
 712                 return true;
 713             }
 714         }
 715     }
 716     return false;
 717 }
 718 */
 719
 720 // -----------------------------------------------------------------------------
 721
 722 CellRef TableModel::createCell()
 723 {
 724     CellRef xCell;
 725     if( mpTableObj )
 726         mpTableObj->createCell( xCell );
 727     return xCell;
 728 }
 729
 730 // -----------------------------------------------------------------------------
 731
 732 void TableModel::insertColumns( sal_Int32 nIndex, sal_Int32 nCount )
 733 {
 734     if( nCount && mpTableObj )
 735     {
 736         try
 737         {
 738             SdrModel* pModel = mpTableObj->GetModel();
 739
 740             TableModelNotifyGuard aGuard( this );
 741             nIndex = insert_range<ColumnVector,ColumnVector::iterator,TableColumnRef>( maColumns, nIndex, nCount );
 742
 743             sal_Int32 nRows = getRowCountImpl();
 744             while( nRows-- )
 745                 maRows[nRows]->insertColumns( nIndex, nCount );
 746
 747             ColumnVector aNewColumns(nCount);
 748             for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
 749             {
 750                 TableColumnRef xNewCol( new TableColumn( this, nIndex+nOffset ) );
 751                 maColumns[nIndex+nOffset] = xNewCol;
 752                 aNewColumns[nOffset] = xNewCol;
 753             }
 754
 755             const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
 756             if( bUndo )
 757             {
 758                 pModel->BegUndo( ImpGetResStr(STR_TABLE_INSCOL) );
 759                 pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
 760
 761                 TableModelRef xThis( this );
 762
 763                 nRows = getRowCountImpl();
 764                 CellVector aNewCells( nCount * nRows );
 765                 CellVector::iterator aCellIter( aNewCells.begin() );
 766
 767                 nRows = getRowCountImpl();
 768                 for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
 769                 {
 770                     for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
 771                         (*aCellIter++) = getCell( nIndex + nOffset, nRow );
 772                 }
 773
 774                 pModel->AddUndo( new InsertColUndo( xThis, nIndex, aNewColumns, aNewCells ) );
 775             }
 776
 777             const sal_Int32 nRowCount = getRowCountImpl();
 778             // check if cells merge over new columns
 779             for( sal_Int32 nCol = 0; nCol < nIndex; ++nCol )
 780             {
 781                 for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
 782                 {
 783                     CellRef xCell( getCell( nCol, nRow ) );
 784                     sal_Int32 nColSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getColumnSpan() : 1;
 785                     if( (nColSpan != 1) && ((nColSpan + nCol ) > nIndex) )
 786                     {
 787                         // cell merges over newly created columns, so add the new columns to the merged cell
 788                         const sal_Int32 nRowSpan = xCell->getRowSpan();
 789                         nColSpan += nCount;
 790                         merge( nCol, nRow, nColSpan, nRowSpan );
 791                     }
 792                 }
 793             }
 794
 795             if( bUndo )
 796                 pModel->EndUndo();
 797
 798             if( pModel )
 799                 pModel->SetChanged();
 800
 801         }
 802         catch( Exception& )
 803         {
 804             DBG_ERROR("sdr::table::TableModel::insertColumns(), exception caught!");
 805         }
 806         updateColumns();
 807         setModified(sal_True);
 808     }
 809 }
 810
 811 // -----------------------------------------------------------------------------
 812
 813 void TableModel::removeColumns( sal_Int32 nIndex, sal_Int32 nCount )
 814 {
 815     sal_Int32 nColCount = getColumnCountImpl();
 816
 817     if( mpTableObj && nCount && (nIndex >= 0) && (nIndex < nColCount) )
 818     {
 819         try
 820         {
 821             TableModelNotifyGuard aGuard( this );
 822
 823             // clip removed columns to columns actually avalaible
 824             if( (nIndex + nCount) > nColCount )
 825                 nCount = nColCount - nIndex;
 826
 827             sal_Int32 nRows = getRowCountImpl();
 828
 829             SdrModel* pModel = mpTableObj->GetModel();
 830
 831             const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
 832             if( bUndo  )
 833             {
 834                 pModel->BegUndo( ImpGetResStr(STR_UNDO_COL_DELETE) );
 835                 pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
 836
 837                 TableModelRef xThis( this );
 838                 ColumnVector aRemovedCols( nCount );
 839                 sal_Int32 nOffset;
 840                 for( nOffset = 0; nOffset < nCount; ++nOffset )
 841                 {
 842                     aRemovedCols[nOffset] = maColumns[nIndex+nOffset];
 843                 }
 844
 845                 CellVector aRemovedCells( nCount * nRows );
 846                 CellVector::iterator aCellIter( aRemovedCells.begin() );
 847                 for( sal_Int32 nRow = 0; nRow < nRows; ++nRow )
 848                 {
 849                     for( nOffset = 0; nOffset < nCount; ++nOffset )
 850                         (*aCellIter++) = getCell( nIndex + nOffset, nRow );
 851                 }
 852
 853                 pModel->AddUndo( new RemoveColUndo( xThis, nIndex, aRemovedCols, aRemovedCells ) );
 854             }
 855
 856             // only rows before and inside the removed rows are considered
 857             nColCount = nIndex + nCount + 1;
 858
 859             const sal_Int32 nRowCount = getRowCountImpl();
 860
 861             // first check merged cells before and inside the removed rows
 862             for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
 863             {
 864                 for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
 865                 {
 866                     CellRef xCell( getCell( nCol, nRow ) );
 867                     sal_Int32 nColSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getColumnSpan() : 1;
 868                     if( nColSpan <= 1 )
 869                         continue;
 870
 871                     if( nCol >= nIndex )
 872                     {
 873                         // current cell is inside the removed columns
 874                         if( (nCol + nColSpan) > ( nIndex + nCount ) )
 875                         {
 876                             // current cells merges with columns after the removed columns
 877                             const sal_Int32 nRemove = nCount - nCol + nIndex;
 878
 879                             CellRef xTargetCell( getCell( nIndex + nCount, nRow ) );
 880                             if( xTargetCell.is() )
 881                             {
 882                                 if( bUndo )
 883                                     xTargetCell->AddUndo();
 884                                 xTargetCell->merge( nColSpan - nRemove, xCell->getRowSpan() );
 885                                 xTargetCell->replaceContentAndFormating( xCell );
 886                             }
 887                         }
 888                     }
 889                     else if( nColSpan > (nIndex - nCol) )
 890                     {
 891                         // current cells spans inside the removed columns, so adjust
 892                         const sal_Int32 nRemove = ::std::min( nCount, nCol + nColSpan - nIndex );
 893                         if( bUndo )
 894                             xCell->AddUndo();
 895                         xCell->merge( nColSpan - nRemove, xCell->getRowSpan() );
 896                     }
 897                 }
 898             }
 899
 900             // now remove the columns
 901             remove_range<ColumnVector,ColumnVector::iterator>( maColumns, nIndex, nCount );
 902             while( nRows-- )
 903                 maRows[nRows]->removeColumns( nIndex, nCount );
 904
 905             if( bUndo )
 906                 pModel->EndUndo();
 907
 908             if( pModel )
 909                 pModel->SetChanged();
 910         }
 911         catch( Exception& )
 912         {
 913             DBG_ERROR("sdr::table::TableModel::removeColumns(), exception caught!");
 914         }
 915
 916         updateColumns();
 917         setModified(sal_True);
 918     }
 919 }
 920
 921 // -----------------------------------------------------------------------------
 922
 923 void TableModel::insertRows( sal_Int32 nIndex, sal_Int32 nCount )
 924 {
 925     if( nCount && mpTableObj )
 926     {
 927         SdrModel* pModel = mpTableObj->GetModel();
 928         const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
 929         try
 930         {
 931             TableModelNotifyGuard aGuard( this );
 932
 933             nIndex = insert_range<RowVector,RowVector::iterator,TableRowRef>( maRows, nIndex, nCount );
 934
 935             RowVector aNewRows(nCount);
 936             const sal_Int32 nColCount = getColumnCountImpl();
 937             for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
 938             {
 939                 TableRowRef xNewRow( new TableRow( this, nIndex+nOffset, nColCount ) );
 940                 maRows[nIndex+nOffset] = xNewRow;
 941                 aNewRows[nOffset] = xNewRow;
 942             }
 943
 944             if( bUndo )
 945             {
 946                 pModel->BegUndo( ImpGetResStr(STR_TABLE_INSROW) );
 947                 pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
 948                 TableModelRef xThis( this );
 949                 pModel->AddUndo( new InsertRowUndo( xThis, nIndex, aNewRows ) );
 950             }
 951
 952             // check if cells merge over new columns
 953             for( sal_Int32 nRow = 0; nRow < nIndex; ++nRow )
 954             {
 955                 for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
 956                 {
 957                     CellRef xCell( getCell( nCol, nRow ) );
 958                     sal_Int32 nRowSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getRowSpan() : 1;
 959                     if( (nRowSpan > 1) && ((nRowSpan + nRow) > nIndex) )
 960                     {
 961                         // cell merges over newly created columns, so add the new columns to the merged cell
 962                         const sal_Int32 nColSpan = xCell->getColumnSpan();
 963                         nRowSpan += nCount;
 964                         merge( nCol, nRow, nColSpan, nRowSpan );
 965                     }
 966                 }
 967             }
 968         }
 969         catch( Exception& )
 970         {
 971             DBG_ERROR("sdr::table::TableModel::insertRows(), exception caught!");
 972         }
 973         if( bUndo )
 974             pModel->EndUndo();
 975
 976         if( pModel )
 977             pModel->SetChanged();
 978
 979         updateRows();
 980         setModified(sal_True);
 981     }
 982 }
 983
 984 // -----------------------------------------------------------------------------
 985
 986 void TableModel::removeRows( sal_Int32 nIndex, sal_Int32 nCount )
 987 {
 988     sal_Int32 nRowCount = getRowCountImpl();
 989
 990     if( mpTableObj && nCount && (nIndex >= 0) && (nIndex < nRowCount) )
 991     {
 992         SdrModel* pModel = mpTableObj->GetModel();
 993         const bool bUndo = pModel && mpTableObj->IsInserted()&& pModel->IsUndoEnabled();
 994
 995         try
 996         {
 997             TableModelNotifyGuard aGuard( this );
 998
 999             // clip removed rows to rows actually avalaible
1000             if( (nIndex + nCount) > nRowCount )
1001                 nCount = nRowCount - nIndex;
1002
1003             if( bUndo )
1004             {
1005                 pModel->BegUndo( ImpGetResStr(STR_UNDO_ROW_DELETE) );
1006                 pModel->AddUndo( pModel->GetSdrUndoFactory().CreateUndoGeoObject(*mpTableObj) );
1007
1008                 TableModelRef xThis( this );
1009
1010                 RowVector aRemovedRows( nCount );
1011                 for( sal_Int32 nOffset = 0; nOffset < nCount; ++nOffset )
1012                     aRemovedRows[nOffset] = maRows[nIndex+nOffset];
1013
1014                 pModel->AddUndo( new RemoveRowUndo( xThis, nIndex, aRemovedRows ) );
1015             }
1016
1017             // only rows before and inside the removed rows are considered
1018             nRowCount = nIndex + nCount + 1;
1019
1020             const sal_Int32 nColCount = getColumnCountImpl();
1021
1022             // first check merged cells before and inside the removed rows
1023             for( sal_Int32 nRow = 0; nRow < nRowCount; ++nRow )
1024             {
1025                 for( sal_Int32 nCol = 0; nCol < nColCount; ++nCol )
1026                 {
1027                     CellRef xCell( getCell( nCol, nRow ) );
1028                     sal_Int32 nRowSpan = (xCell.is() && !xCell->isMerged()) ? xCell->getRowSpan() : 1;
1029                     if( nRowSpan <= 1 )
1030                         continue;
1031
1032                     if( nRow >= nIndex )
1033                     {
1034                         // current cell is inside the removed rows
1035                         if( (nRow + nRowSpan) > (nIndex + nCount) )
1036                         {
1037                             // current cells merges with rows after the removed rows
1038                             const sal_Int32 nRemove = nCount - nRow + nIndex;
1039
1040                             CellRef xTargetCell( getCell( nCol, nIndex + nCount ) );
1041                             if( xTargetCell.is() )
1042                             {
1043                                 if( bUndo )
1044                                     xTargetCell->AddUndo();
1045                                 xTargetCell->merge( xCell->getColumnSpan(), nRowSpan - nRemove );
1046                                 xTargetCell->replaceContentAndFormating( xCell );
1047                             }
1048                         }
1049                     }
1050                     else if( nRowSpan > (nIndex - nRow) )
1051                     {
1052                         // current cells spans inside the removed rows, so adjust
1053                         const sal_Int32 nRemove = ::std::min( nCount, nRow + nRowSpan - nIndex );
1054                         if( bUndo )
1055                             xCell->AddUndo();
1056                         xCell->merge( xCell->getColumnSpan(), nRowSpan - nRemove );
1057                     }
1058                 }
1059             }
1060
1061             // now remove the rows
1062             remove_range<RowVector,RowVector::iterator>( maRows, nIndex, nCount );
1063
1064             if( bUndo )
1065                 pModel->EndUndo();
1066
1067             if( pModel )
1068                 pModel->SetChanged();
1069         }
1070         catch( Exception& )
1071         {
1072             DBG_ERROR("sdr::table::TableModel::removeRows(), exception caught!");
1073         }
1074
1075         updateRows();
1076         setModified(sal_True);
1077     }
1078 }
1079
1080 // -----------------------------------------------------------------------------
1081
1082 TableRowRef TableModel::getRow( sal_Int32 nRow ) const throw (IndexOutOfBoundsException)
1083 {
1084     if( (nRow >= 0) && (nRow < getRowCountImpl()) )
1085         return maRows[nRow];
1086
1087     throw IndexOutOfBoundsException();
1088 }
1089
1090 // -----------------------------------------------------------------------------
1091
1092 TableColumnRef TableModel::getColumn( sal_Int32 nColumn ) const throw (IndexOutOfBoundsException)
1093 {
1094     if( (nColumn >= 0) && (nColumn < getColumnCountImpl()) )
1095         return maColumns[nColumn];
1096
1097     throw IndexOutOfBoundsException();
1098 }
1099
1100 // -----------------------------------------------------------------------------
1101
1102 /** deletes rows and columns that are completly merged. Must be called between BegUndo/EndUndo! */
1103 void TableModel::optimize()
1104 {
1105     TableModelNotifyGuard aGuard( this );
1106
1107     bool bWasModified = false;
1108
1109     if( !maRows.empty() && !maColumns.empty() )
1110     {
1111         sal_Int32 nCol = getColumnCountImpl() - 1;
1112         while( nCol > 0 )
1113         {
1114             bool bEmpty = true;
1115             for( sal_Int32 nRow = 0; (nRow < getRowCountImpl()) && bEmpty; nRow++ )
1116             {
1117                 Reference< XMergeableCell > xCell( getCellByPosition( nCol, nRow ), UNO_QUERY );
1118                 if( xCell.is() && !xCell->isMerged() )
1119                     bEmpty = false;
1120             }
1121
1122             if( bEmpty )
1123             {
1124                 if( nCol > 0 ) try
1125                 {
1126                     const OUString sWidth( RTL_CONSTASCII_USTRINGPARAM("Width") );
1127                     sal_Int32 nWidth1 = 0, nWidth2 = 0;
1128                     Reference< XPropertySet > xSet1( static_cast< XCellRange* >( maColumns[nCol].get() ), UNO_QUERY_THROW );
1129                     Reference< XPropertySet > xSet2( static_cast< XCellRange* >( maColumns[nCol-1].get() ), UNO_QUERY_THROW );
1130                     xSet1->getPropertyValue( sWidth ) >>= nWidth1;
1131                     xSet2->getPropertyValue( sWidth ) >>= nWidth2;
1132                     nWidth1 += nWidth2;
1133                     xSet2->setPropertyValue( sWidth, Any( nWidth1 ) );
1134                 }
1135                 catch( Exception& e )
1136                 {
1137                     (void)e;
1138                     DBG_ERROR("svx::TableModel::optimize(), exception caught!");
1139                 }
1140
1141                 removeColumns( nCol, 1 );
1142                 bWasModified = true;
1143             }
1144
1145             nCol--;
1146         }
1147
1148         sal_Int32 nRow = getRowCountImpl() - 1;
1149         while( nRow > 0 )
1150         {
1151             bool bEmpty = true;
1152             for( nCol = 0; (nCol < getColumnCountImpl()) && bEmpty; nCol++ )
1153             {
1154                 Reference< XMergeableCell > xCell( getCellByPosition( nCol, nRow ), UNO_QUERY );
1155                 if( xCell.is() && !xCell->isMerged() )
1156                     bEmpty = false;
1157             }
1158
1159             if( bEmpty )
1160             {
1161                 if( nRow > 0 ) try
1162                 {
1163                     const OUString sHeight( RTL_CONSTASCII_USTRINGPARAM("Height") );
1164                     sal_Int32 nHeight1 = 0, nHeight2 = 0;
1165                     Reference< XPropertySet > xSet1( static_cast< XCellRange* >( maRows[nRow].get() ), UNO_QUERY_THROW );
1166                     Reference< XPropertySet > xSet2( static_cast< XCellRange* >( maRows[nRow-1].get() ), UNO_QUERY_THROW );
1167                     xSet1->getPropertyValue( sHeight ) >>= nHeight1;
1168                     xSet2->getPropertyValue( sHeight ) >>= nHeight2;
1169                     nHeight1 += nHeight2;
1170                     xSet2->setPropertyValue( sHeight, Any( nHeight1 ) );
1171                 }
1172                 catch( Exception& e )
1173                 {
1174                     (void)e;
1175                     DBG_ERROR("svx::TableModel::optimize(), exception caught!");
1176                 }
1177
1178                 removeRows( nRow, 1 );
1179                 bWasModified = true;
1180             }
1181
1182             nRow--;
1183         }
1184     }
1185     if( bWasModified )
1186         setModified(sal_True);
1187 }
1188
1189 // -----------------------------------------------------------------------------
1190
1191 void TableModel::merge( sal_Int32 nCol, sal_Int32 nRow, sal_Int32 nColSpan, sal_Int32 nRowSpan )
1192 {
1193     SdrModel* pModel = mpTableObj->GetModel();
1194
1195     const bool bUndo = pModel && mpTableObj->IsInserted() && pModel->IsUndoEnabled();
1196
1197     const sal_Int32 nLastRow = nRow + nRowSpan;
1198     const sal_Int32 nLastCol = nCol + nColSpan;
1199
1200     if( (nLastRow > getRowCount()) || (nLastCol > getRowCount() ) )
1201     {
1202         DBG_ERROR("TableModel::merge(), merge beyound the table!");
1203     }
1204
1205     // merge first cell
1206     CellRef xOriginCell( dynamic_cast< Cell* >( getCellByPosition( nCol, nRow ).get() ) );
1207     if( xOriginCell.is() )
1208     {
1209         if( bUndo )
1210             xOriginCell->AddUndo();
1211         xOriginCell->merge( nColSpan, nRowSpan );
1212     }
1213
1214     sal_Int32 nTempCol = nCol + 1;
1215
1216     // merge remaining cells
1217     for( ; nRow < nLastRow; nRow++ )
1218     {
1219         for( ; nTempCol < nLastCol; nTempCol++ )
1220         {
1221             CellRef xCell( dynamic_cast< Cell* >( getCellByPosition( nTempCol, nRow ).get() ) );
1222             if( xCell.is() && !xCell->isMerged() )
1223             {
1224                 if( bUndo )
1225                     xCell->AddUndo();
1226                 xCell->setMerged();
1227                 xOriginCell->mergeContent( xCell );
1228             }
1229         }
1230         nTempCol = nCol;
1231     }
1232 }
1233
1234
1235 // -----------------------------------------------------------------------------
1236
1237 void TableModel::updateRows()
1238 {
1239     sal_Int32 nRow = 0;
1240     RowVector::iterator iter = maRows.begin();
1241     while( iter != maRows.end() )
1242     {
1243         (*iter++)->mnRow = nRow++;
1244     }
1245 }
1246
1247 // -----------------------------------------------------------------------------
1248
1249 void TableModel::updateColumns()
1250 {
1251     sal_Int32 nColumn = 0;
1252     ColumnVector::iterator iter = maColumns.begin();
1253     while( iter != maColumns.end() )
1254     {
1255         (*iter++)->mnColumn = nColumn++;
1256     }
1257 }
1258
1259 // -----------------------------------------------------------------------------
1260
1261 } }