svx/source/table/tableundo.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: tableundo.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/sdr/properties/textproperties.hxx"
  35 #include "svx/outlobj.hxx"
  36
  37 #include "cell.hxx"
  38 #include "tableundo.hxx"
  39 #include "svx/svdotable.hxx"
  40 #include "tablerow.hxx"
  41 #include "tablecolumn.hxx"
  42
  43
  44 // -----------------------------------------------------------------------------
  45
  46 using ::rtl::OUString;
  47 using namespace ::com::sun::star::uno;
  48 using namespace ::com::sun::star::table;
  49
  50 // -----------------------------------------------------------------------------
  51
  52 namespace sdr { namespace table {
  53
  54 CellUndo::CellUndo( const SdrObjectWeakRef& xObjRef, const CellRef& xCell )
  55 : SdrUndoAction( *xCell->GetModel() )
  56 , mxObjRef( xObjRef )
  57 , mxCell( xCell )
  58 , mbUndo( true )
  59 {
  60     if( mxCell.is() && mxObjRef.is() )
  61     {
  62         getDataFromCell( maUndoData );
  63         mxObjRef->AddObjectUser( *this );
  64     }
  65 }
  66
  67 CellUndo::~CellUndo()
  68 {
  69     if( mxObjRef.is() )
  70         mxObjRef->RemoveObjectUser( *this );
  71     dispose();
  72 }
  73
  74 void CellUndo::dispose()
  75 {
  76     mxCell.clear();
  77     delete maUndoData.mpProperties;
  78     maUndoData.mpProperties = 0;
  79     delete maRedoData.mpProperties;
  80     maRedoData.mpProperties = 0;
  81     delete maUndoData.mpOutlinerParaObject;
  82     maUndoData.mpOutlinerParaObject = 0;
  83     delete maRedoData.mpOutlinerParaObject;
  84     maRedoData.mpOutlinerParaObject = 0;
  85 }
  86
  87 void CellUndo::ObjectInDestruction(const SdrObject& )
  88 {
  89     dispose();
  90 }
  91
  92 void CellUndo::Undo()
  93 {
  94     if( mxCell.is() && mbUndo )
  95     {
  96         if( maRedoData.mpProperties == 0 )
  97             getDataFromCell( maRedoData );
  98
  99         setDataToCell( maUndoData );
 100         mbUndo = false;
 101     }
 102 }
 103
 104 void CellUndo::Redo()
 105 {
 106     if( mxCell.is() && !mbUndo )
 107     {
 108         setDataToCell( maRedoData );
 109         mbUndo = true;
 110     }
 111 }
 112
 113 BOOL CellUndo::Merge( SfxUndoAction *pNextAction )
 114 {
 115     CellUndo* pNext = dynamic_cast< CellUndo* >( pNextAction );
 116     if( pNext && pNext->mxCell.get() == mxCell.get() )
 117     {
 118         return TRUE;
 119     }
 120     else
 121     {
 122         return FALSE;
 123     }
 124 }
 125
 126 void CellUndo::setDataToCell( const Data& rData )
 127 {
 128     delete mxCell->mpProperties;
 129     if( rData.mpProperties )
 130         mxCell->mpProperties = Cell::CloneProperties( rData.mpProperties, *mxObjRef.get(), *mxCell.get() );
 131     else
 132         mxCell->mpProperties = 0;
 133
 134     if( rData.mpOutlinerParaObject )
 135         mxCell->SetOutlinerParaObject( new OutlinerParaObject(*rData.mpOutlinerParaObject) );
 136     else
 137         mxCell->RemoveOutlinerParaObject();
 138
 139     mxCell->msFormula = rData.msFormula;
 140     mxCell->mfValue = rData.mfValue;
 141     mxCell->mnError = rData.mnError;
 142     mxCell->mbMerged = rData.mbMerged;
 143     mxCell->mnRowSpan = rData.mnRowSpan;
 144     mxCell->mnColSpan = rData.mnColSpan;
 145
 146     if( mxObjRef.is() )
 147         mxObjRef->ActionChanged();
 148 }
 149
 150 void CellUndo::getDataFromCell( Data& rData )
 151 {
 152     if( mxObjRef.is() && mxCell.is() )
 153     {
 154         if( mxCell->mpProperties )
 155             rData.mpProperties = mxCell->CloneProperties( *mxObjRef.get(), *mxCell.get());
 156
 157         if( mxCell->GetOutlinerParaObject() )
 158             rData.mpOutlinerParaObject = new OutlinerParaObject(*mxCell->GetOutlinerParaObject());
 159         else
 160             rData.mpOutlinerParaObject =  0;
 161
 162         rData.mnCellContentType = mxCell->mnCellContentType;
 163
 164         rData.msFormula = mxCell->msFormula;
 165         rData.mfValue = mxCell->mfValue;
 166         rData.mnError = mxCell->mnError;
 167         rData.mbMerged = mxCell->mbMerged;
 168         rData.mnRowSpan = mxCell->mnRowSpan;
 169         rData.mnColSpan = mxCell->mnColSpan;
 170     }
 171 }
 172
 173 // -----------------------------------------------------------------------------
 174 // class InsertRowUndo : public SdrUndoAction
 175 // -----------------------------------------------------------------------------
 176
 177 static void Dispose( RowVector& rRows )
 178 {
 179     RowVector::iterator aIter( rRows.begin() );
 180     while( aIter != rRows.end() )
 181         (*aIter++)->dispose();
 182 }
 183
 184 // -----------------------------------------------------------------------------
 185
 186 InsertRowUndo::InsertRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aNewRows )
 187 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 188 , mxTable( xTable )
 189 , mnIndex( nIndex )
 190 , mbUndo( true )
 191 {
 192     maRows.swap( aNewRows );
 193 }
 194
 195 // -----------------------------------------------------------------------------
 196
 197 InsertRowUndo::~InsertRowUndo()
 198 {
 199     if( !mbUndo )
 200         Dispose( maRows );
 201 }
 202
 203 // -----------------------------------------------------------------------------
 204
 205 void InsertRowUndo::Undo()
 206 {
 207     if( mxTable.is() )
 208     {
 209         mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) );
 210         mbUndo = false;
 211     }
 212 }
 213
 214 // -----------------------------------------------------------------------------
 215
 216 void InsertRowUndo::Redo()
 217 {
 218     if( mxTable.is() )
 219     {
 220         mxTable->UndoRemoveRows( mnIndex, maRows );
 221         mbUndo = true;
 222     }
 223 }
 224
 225 // -----------------------------------------------------------------------------
 226 // class RemoveRowUndo : public SdrUndoAction
 227 // -----------------------------------------------------------------------------
 228
 229 RemoveRowUndo::RemoveRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aRemovedRows )
 230 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 231 , mxTable( xTable )
 232 , mnIndex( nIndex )
 233 , mbUndo( true )
 234 {
 235     maRows.swap( aRemovedRows );
 236 }
 237
 238 // -----------------------------------------------------------------------------
 239
 240 RemoveRowUndo::~RemoveRowUndo()
 241 {
 242     if( mbUndo )
 243         Dispose( maRows );
 244 }
 245
 246 // -----------------------------------------------------------------------------
 247
 248 void RemoveRowUndo::Undo()
 249 {
 250     if( mxTable.is() )
 251     {
 252         mxTable->UndoRemoveRows( mnIndex, maRows );
 253         mbUndo = false;
 254     }
 255 }
 256
 257 // -----------------------------------------------------------------------------
 258
 259 void RemoveRowUndo::Redo()
 260 {
 261     if( mxTable.is() )
 262     {
 263         mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) );
 264         mbUndo = true;
 265     }
 266 }
 267
 268 // -----------------------------------------------------------------------------
 269 // class InsertColUndo : public SdrUndoAction
 270 // -----------------------------------------------------------------------------
 271
 272 static void Dispose( ColumnVector& rCols )
 273 {
 274     ColumnVector::iterator aIter( rCols.begin() );
 275     while( aIter != rCols.end() )
 276         (*aIter++)->dispose();
 277 }
 278
 279 // -----------------------------------------------------------------------------
 280
 281 static void Dispose( CellVector& rCells )
 282 {
 283     CellVector::iterator aIter( rCells.begin() );
 284     while( aIter != rCells.end() )
 285         (*aIter++)->dispose();
 286 }
 287
 288 // -----------------------------------------------------------------------------
 289
 290 InsertColUndo::InsertColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells  )
 291 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 292 , mxTable( xTable )
 293 , mnIndex( nIndex )
 294 , mbUndo( true )
 295 {
 296     maColumns.swap( aNewCols );
 297     maCells.swap( aCells );
 298 }
 299
 300 // -----------------------------------------------------------------------------
 301
 302 InsertColUndo::~InsertColUndo()
 303 {
 304     if( !mbUndo )
 305     {
 306         Dispose( maColumns );
 307         Dispose( maCells );
 308     }
 309 }
 310
 311 // -----------------------------------------------------------------------------
 312
 313 void InsertColUndo::Undo()
 314 {
 315     if( mxTable.is() )
 316     {
 317         mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) );
 318         mbUndo = false;
 319     }
 320 }
 321
 322 // -----------------------------------------------------------------------------
 323
 324 void InsertColUndo::Redo()
 325 {
 326     if( mxTable.is() )
 327     {
 328         mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells );
 329         mbUndo = true;
 330     }
 331 }
 332
 333 // -----------------------------------------------------------------------------
 334 // class RemoveColUndo : public SdrUndoAction
 335 // -----------------------------------------------------------------------------
 336
 337 RemoveColUndo::RemoveColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells )
 338 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 339 , mxTable( xTable )
 340 , mnIndex( nIndex )
 341 , mbUndo( true )
 342 {
 343     maColumns.swap( aNewCols );
 344     maCells.swap( aCells );
 345 }
 346
 347 // -----------------------------------------------------------------------------
 348
 349 RemoveColUndo::~RemoveColUndo()
 350 {
 351     if( mbUndo )
 352     {
 353         Dispose( maColumns );
 354         Dispose( maCells );
 355     }
 356 }
 357
 358 // -----------------------------------------------------------------------------
 359
 360 void RemoveColUndo::Undo()
 361 {
 362     if( mxTable.is() )
 363     {
 364         mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells );
 365         mbUndo = false;
 366     }
 367 }
 368
 369 // -----------------------------------------------------------------------------
 370
 371 void RemoveColUndo::Redo()
 372 {
 373     if( mxTable.is() )
 374     {
 375         mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) );
 376         mbUndo = true;
 377     }
 378 }
 379
 380 // -----------------------------------------------------------------------------
 381 // class TableColumnUndo : public SdrUndoAction
 382 // -----------------------------------------------------------------------------
 383
 384 TableColumnUndo::TableColumnUndo( const TableColumnRef& xCol )
 385 : SdrUndoAction( *xCol->mxTableModel->getSdrTableObj()->GetModel() )
 386 , mxCol( xCol )
 387 , mbHasRedoData( false )
 388 {
 389     getData( maUndoData );
 390 }
 391
 392 // -----------------------------------------------------------------------------
 393
 394 TableColumnUndo::~TableColumnUndo()
 395 {
 396 }
 397
 398 // -----------------------------------------------------------------------------
 399
 400 void TableColumnUndo::Undo()
 401 {
 402     if( !mbHasRedoData )
 403     {
 404         getData( maRedoData );
 405         mbHasRedoData = true;
 406     }
 407     setData( maUndoData );
 408 }
 409
 410 // -----------------------------------------------------------------------------
 411
 412 void TableColumnUndo::Redo()
 413 {
 414     setData( maRedoData );
 415 }
 416
 417 // -----------------------------------------------------------------------------
 418
 419 BOOL TableColumnUndo::Merge( SfxUndoAction *pNextAction )
 420 {
 421     TableColumnUndo* pNext = dynamic_cast< TableColumnUndo* >( pNextAction );
 422     return pNext && pNext->mxCol == mxCol;
 423 }
 424
 425 // -----------------------------------------------------------------------------
 426
 427 void TableColumnUndo::setData( const Data& rData )
 428 {
 429     mxCol->mnColumn = rData.mnColumn;
 430     mxCol->mnWidth = rData.mnWidth;
 431     mxCol->mbOptimalWidth = rData.mbOptimalWidth;
 432     mxCol->mbIsVisible = rData.mbIsVisible;
 433     mxCol->mbIsStartOfNewPage = rData.mbIsStartOfNewPage;
 434     mxCol->maName = rData.maName;
 435 }
 436
 437 // -----------------------------------------------------------------------------
 438
 439 void TableColumnUndo::getData( Data& rData )
 440 {
 441     rData.mnColumn = mxCol->mnColumn;
 442     rData.mnWidth = mxCol->mnWidth;
 443     rData.mbOptimalWidth = mxCol->mbOptimalWidth;
 444     rData.mbIsVisible = mxCol->mbIsVisible;
 445     rData.mbIsStartOfNewPage = mxCol->mbIsStartOfNewPage;
 446     rData.maName = mxCol->maName;
 447 }
 448
 449 // -----------------------------------------------------------------------------
 450 // class TableRowUndo : public SdrUndoAction
 451 // -----------------------------------------------------------------------------
 452
 453 TableRowUndo::TableRowUndo( const TableRowRef& xRow )
 454 : SdrUndoAction( *xRow->mxTableModel->getSdrTableObj()->GetModel() )
 455 , mxRow( xRow )
 456 , mbHasRedoData( false )
 457 {
 458     getData( maUndoData );
 459 }
 460
 461 // -----------------------------------------------------------------------------
 462
 463 TableRowUndo::~TableRowUndo()
 464 {
 465 }
 466
 467 // -----------------------------------------------------------------------------
 468
 469 void TableRowUndo::Undo()
 470 {
 471     if( !mbHasRedoData )
 472     {
 473         getData( maRedoData );
 474         mbHasRedoData = true;
 475     }
 476     setData( maUndoData );
 477 }
 478
 479 // -----------------------------------------------------------------------------
 480
 481 void TableRowUndo::Redo()
 482 {
 483     setData( maRedoData );
 484 }
 485
 486 // -----------------------------------------------------------------------------
 487
 488 BOOL TableRowUndo::Merge( SfxUndoAction *pNextAction )
 489 {
 490     TableRowUndo* pNext = dynamic_cast< TableRowUndo* >( pNextAction );
 491     return pNext && pNext->mxRow == mxRow;
 492 }
 493
 494 // -----------------------------------------------------------------------------
 495
 496 void TableRowUndo::setData( const Data& rData )
 497 {
 498     mxRow->mnRow = rData.mnRow;
 499     mxRow->mnHeight = rData.mnHeight;
 500     mxRow->mbOptimalHeight = rData.mbOptimalHeight;
 501     mxRow->mbIsVisible = rData.mbIsVisible;
 502     mxRow->mbIsStartOfNewPage = rData.mbIsStartOfNewPage;
 503     mxRow->maName = rData.maName;
 504  }
 505
 506 // -----------------------------------------------------------------------------
 507
 508 void TableRowUndo::getData( Data& rData )
 509 {
 510     rData.mnRow = mxRow->mnRow;
 511     rData.mnHeight = mxRow->mnHeight;
 512     rData.mbOptimalHeight = mxRow->mbOptimalHeight;
 513     rData.mbIsVisible = mxRow->mbIsVisible;
 514     rData.mbIsStartOfNewPage = mxRow->mbIsStartOfNewPage;
 515     rData.maName = mxRow->maName;
 516 }
 517
 518 // -----------------------------------------------------------------------------
 519
 520 TableStyleUndo::TableStyleUndo( const SdrTableObj& rTableObj )
 521 : SdrUndoAction( *rTableObj.GetModel() )
 522 , mxObjRef( const_cast< sdr::table::SdrTableObj*>( &rTableObj ) )
 523 {
 524     getData( maUndoData );
 525 }
 526
 527 void TableStyleUndo::Undo()
 528 {
 529     if( !mbHasRedoData )
 530     {
 531         getData( maRedoData );
 532         mbHasRedoData = true;
 533     }
 534     setData( maUndoData );
 535 }
 536
 537 void TableStyleUndo::Redo()
 538 {
 539     setData( maRedoData );
 540 }
 541
 542 void TableStyleUndo::setData( const Data& rData )
 543 {
 544     SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() );
 545     if( pTableObj )
 546     {
 547         pTableObj->setTableStyle( rData.mxTableStyle );
 548         pTableObj->setTableStyleSettings( rData.maSettings );
 549     }
 550 }
 551
 552 void TableStyleUndo::getData( Data& rData )
 553 {
 554     SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() );
 555     if( pTableObj )
 556     {
 557         rData.maSettings = pTableObj->getTableStyleSettings();
 558         rData.mxTableStyle = pTableObj->getTableStyle();
 559     }
 560 }
 561
 562 } }