svx/source/table/tableundo.cxx

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