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 sal_Bool CellUndo::Merge( SfxUndoAction *pNextAction )
 100 {
 101     CellUndo* pNext = dynamic_cast< CellUndo* >( pNextAction );
 102     if( pNext && pNext->mxCell.get() == mxCell.get() )
 103     {
 104         return sal_True;
 105     }
 106     else
 107     {
 108         return sal_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         mxObjRef->ActionChanged();
 134 }
 135
 136 void CellUndo::getDataFromCell( Data& rData )
 137 {
 138     if( mxObjRef.is() && mxCell.is() )
 139     {
 140         if( mxCell->mpProperties )
 141             rData.mpProperties = mxCell->CloneProperties( *mxObjRef.get(), *mxCell.get());
 142
 143         if( mxCell->GetOutlinerParaObject() )
 144             rData.mpOutlinerParaObject = new OutlinerParaObject(*mxCell->GetOutlinerParaObject());
 145         else
 146             rData.mpOutlinerParaObject =  0;
 147
 148         rData.mnCellContentType = mxCell->mnCellContentType;
 149
 150         rData.msFormula = mxCell->msFormula;
 151         rData.mfValue = mxCell->mfValue;
 152         rData.mnError = mxCell->mnError;
 153         rData.mbMerged = mxCell->mbMerged;
 154         rData.mnRowSpan = mxCell->mnRowSpan;
 155         rData.mnColSpan = mxCell->mnColSpan;
 156     }
 157 }
 158
 159 // -----------------------------------------------------------------------------
 160 // class InsertRowUndo : public SdrUndoAction
 161 // -----------------------------------------------------------------------------
 162
 163 static void Dispose( RowVector& rRows )
 164 {
 165     RowVector::iterator aIter( rRows.begin() );
 166     while( aIter != rRows.end() )
 167         (*aIter++)->dispose();
 168 }
 169
 170 // -----------------------------------------------------------------------------
 171
 172 InsertRowUndo::InsertRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aNewRows )
 173 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 174 , mxTable( xTable )
 175 , mnIndex( nIndex )
 176 , mbUndo( true )
 177 {
 178     maRows.swap( aNewRows );
 179 }
 180
 181 // -----------------------------------------------------------------------------
 182
 183 InsertRowUndo::~InsertRowUndo()
 184 {
 185     if( !mbUndo )
 186         Dispose( maRows );
 187 }
 188
 189 // -----------------------------------------------------------------------------
 190
 191 void InsertRowUndo::Undo()
 192 {
 193     if( mxTable.is() )
 194     {
 195         mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) );
 196         mbUndo = false;
 197     }
 198 }
 199
 200 // -----------------------------------------------------------------------------
 201
 202 void InsertRowUndo::Redo()
 203 {
 204     if( mxTable.is() )
 205     {
 206         mxTable->UndoRemoveRows( mnIndex, maRows );
 207         mbUndo = true;
 208     }
 209 }
 210
 211 // -----------------------------------------------------------------------------
 212 // class RemoveRowUndo : public SdrUndoAction
 213 // -----------------------------------------------------------------------------
 214
 215 RemoveRowUndo::RemoveRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aRemovedRows )
 216 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 217 , mxTable( xTable )
 218 , mnIndex( nIndex )
 219 , mbUndo( true )
 220 {
 221     maRows.swap( aRemovedRows );
 222 }
 223
 224 // -----------------------------------------------------------------------------
 225
 226 RemoveRowUndo::~RemoveRowUndo()
 227 {
 228     if( mbUndo )
 229         Dispose( maRows );
 230 }
 231
 232 // -----------------------------------------------------------------------------
 233
 234 void RemoveRowUndo::Undo()
 235 {
 236     if( mxTable.is() )
 237     {
 238         mxTable->UndoRemoveRows( mnIndex, maRows );
 239         mbUndo = false;
 240     }
 241 }
 242
 243 // -----------------------------------------------------------------------------
 244
 245 void RemoveRowUndo::Redo()
 246 {
 247     if( mxTable.is() )
 248     {
 249         mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) );
 250         mbUndo = true;
 251     }
 252 }
 253
 254 // -----------------------------------------------------------------------------
 255 // class InsertColUndo : public SdrUndoAction
 256 // -----------------------------------------------------------------------------
 257
 258 static void Dispose( ColumnVector& rCols )
 259 {
 260     ColumnVector::iterator aIter( rCols.begin() );
 261     while( aIter != rCols.end() )
 262         (*aIter++)->dispose();
 263 }
 264
 265 // -----------------------------------------------------------------------------
 266
 267 static void Dispose( CellVector& rCells )
 268 {
 269     CellVector::iterator aIter( rCells.begin() );
 270     while( aIter != rCells.end() )
 271         (*aIter++)->dispose();
 272 }
 273
 274 // -----------------------------------------------------------------------------
 275
 276 InsertColUndo::InsertColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells  )
 277 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 278 , mxTable( xTable )
 279 , mnIndex( nIndex )
 280 , mbUndo( true )
 281 {
 282     maColumns.swap( aNewCols );
 283     maCells.swap( aCells );
 284 }
 285
 286 // -----------------------------------------------------------------------------
 287
 288 InsertColUndo::~InsertColUndo()
 289 {
 290     if( !mbUndo )
 291     {
 292         Dispose( maColumns );
 293         Dispose( maCells );
 294     }
 295 }
 296
 297 // -----------------------------------------------------------------------------
 298
 299 void InsertColUndo::Undo()
 300 {
 301     if( mxTable.is() )
 302     {
 303         mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) );
 304         mbUndo = false;
 305     }
 306 }
 307
 308 // -----------------------------------------------------------------------------
 309
 310 void InsertColUndo::Redo()
 311 {
 312     if( mxTable.is() )
 313     {
 314         mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells );
 315         mbUndo = true;
 316     }
 317 }
 318
 319 // -----------------------------------------------------------------------------
 320 // class RemoveColUndo : public SdrUndoAction
 321 // -----------------------------------------------------------------------------
 322
 323 RemoveColUndo::RemoveColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells )
 324 : SdrUndoAction( *xTable->getSdrTableObj()->GetModel() )
 325 , mxTable( xTable )
 326 , mnIndex( nIndex )
 327 , mbUndo( true )
 328 {
 329     maColumns.swap( aNewCols );
 330     maCells.swap( aCells );
 331 }
 332
 333 // -----------------------------------------------------------------------------
 334
 335 RemoveColUndo::~RemoveColUndo()
 336 {
 337     if( mbUndo )
 338     {
 339         Dispose( maColumns );
 340         Dispose( maCells );
 341     }
 342 }
 343
 344 // -----------------------------------------------------------------------------
 345
 346 void RemoveColUndo::Undo()
 347 {
 348     if( mxTable.is() )
 349     {
 350         mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells );
 351         mbUndo = false;
 352     }
 353 }
 354
 355 // -----------------------------------------------------------------------------
 356
 357 void RemoveColUndo::Redo()
 358 {
 359     if( mxTable.is() )
 360     {
 361         mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) );
 362         mbUndo = true;
 363     }
 364 }
 365
 366 // -----------------------------------------------------------------------------
 367 // class TableColumnUndo : public SdrUndoAction
 368 // -----------------------------------------------------------------------------
 369
 370 TableColumnUndo::TableColumnUndo( const TableColumnRef& xCol )
 371 : SdrUndoAction( *xCol->mxTableModel->getSdrTableObj()->GetModel() )
 372 , mxCol( xCol )
 373 , mbHasRedoData( false )
 374 {
 375     getData( maUndoData );
 376 }
 377
 378 // -----------------------------------------------------------------------------
 379
 380 TableColumnUndo::~TableColumnUndo()
 381 {
 382 }
 383
 384 // -----------------------------------------------------------------------------
 385
 386 void TableColumnUndo::Undo()
 387 {
 388     if( !mbHasRedoData )
 389     {
 390         getData( maRedoData );
 391         mbHasRedoData = true;
 392     }
 393     setData( maUndoData );
 394 }
 395
 396 // -----------------------------------------------------------------------------
 397
 398 void TableColumnUndo::Redo()
 399 {
 400     setData( maRedoData );
 401 }
 402
 403 // -----------------------------------------------------------------------------
 404
 405 sal_Bool TableColumnUndo::Merge( SfxUndoAction *pNextAction )
 406 {
 407     TableColumnUndo* pNext = dynamic_cast< TableColumnUndo* >( pNextAction );
 408     return pNext && pNext->mxCol == mxCol;
 409 }
 410
 411 // -----------------------------------------------------------------------------
 412
 413 void TableColumnUndo::setData( const Data& rData )
 414 {
 415     mxCol->mnColumn = rData.mnColumn;
 416     mxCol->mnWidth = rData.mnWidth;
 417     mxCol->mbOptimalWidth = rData.mbOptimalWidth;
 418     mxCol->mbIsVisible = rData.mbIsVisible;
 419     mxCol->mbIsStartOfNewPage = rData.mbIsStartOfNewPage;
 420     mxCol->maName = rData.maName;
 421 }
 422
 423 // -----------------------------------------------------------------------------
 424
 425 void TableColumnUndo::getData( Data& rData )
 426 {
 427     rData.mnColumn = mxCol->mnColumn;
 428     rData.mnWidth = mxCol->mnWidth;
 429     rData.mbOptimalWidth = mxCol->mbOptimalWidth;
 430     rData.mbIsVisible = mxCol->mbIsVisible;
 431     rData.mbIsStartOfNewPage = mxCol->mbIsStartOfNewPage;
 432     rData.maName = mxCol->maName;
 433 }
 434
 435 // -----------------------------------------------------------------------------
 436 // class TableRowUndo : public SdrUndoAction
 437 // -----------------------------------------------------------------------------
 438
 439 TableRowUndo::TableRowUndo( const TableRowRef& xRow )
 440 : SdrUndoAction( *xRow->mxTableModel->getSdrTableObj()->GetModel() )
 441 , mxRow( xRow )
 442 , mbHasRedoData( false )
 443 {
 444     getData( maUndoData );
 445 }
 446
 447 // -----------------------------------------------------------------------------
 448
 449 TableRowUndo::~TableRowUndo()
 450 {
 451 }
 452
 453 // -----------------------------------------------------------------------------
 454
 455 void TableRowUndo::Undo()
 456 {
 457     if( !mbHasRedoData )
 458     {
 459         getData( maRedoData );
 460         mbHasRedoData = true;
 461     }
 462     setData( maUndoData );
 463 }
 464
 465 // -----------------------------------------------------------------------------
 466
 467 void TableRowUndo::Redo()
 468 {
 469     setData( maRedoData );
 470 }
 471
 472 // -----------------------------------------------------------------------------
 473
 474 sal_Bool TableRowUndo::Merge( SfxUndoAction *pNextAction )
 475 {
 476     TableRowUndo* pNext = dynamic_cast< TableRowUndo* >( pNextAction );
 477     return pNext && pNext->mxRow == mxRow;
 478 }
 479
 480 // -----------------------------------------------------------------------------
 481
 482 void TableRowUndo::setData( const Data& rData )
 483 {
 484     mxRow->mnRow = rData.mnRow;
 485     mxRow->mnHeight = rData.mnHeight;
 486     mxRow->mbOptimalHeight = rData.mbOptimalHeight;
 487     mxRow->mbIsVisible = rData.mbIsVisible;
 488     mxRow->mbIsStartOfNewPage = rData.mbIsStartOfNewPage;
 489     mxRow->maName = rData.maName;
 490  }
 491
 492 // -----------------------------------------------------------------------------
 493
 494 void TableRowUndo::getData( Data& rData )
 495 {
 496     rData.mnRow = mxRow->mnRow;
 497     rData.mnHeight = mxRow->mnHeight;
 498     rData.mbOptimalHeight = mxRow->mbOptimalHeight;
 499     rData.mbIsVisible = mxRow->mbIsVisible;
 500     rData.mbIsStartOfNewPage = mxRow->mbIsStartOfNewPage;
 501     rData.maName = mxRow->maName;
 502 }
 503
 504 // -----------------------------------------------------------------------------
 505
 506 TableStyleUndo::TableStyleUndo( const SdrTableObj& rTableObj )
 507 : SdrUndoAction( *rTableObj.GetModel() )
 508 , mxObjRef( const_cast< sdr::table::SdrTableObj*>( &rTableObj ) )
 509 {
 510     getData( maUndoData );
 511 }
 512
 513 void TableStyleUndo::Undo()
 514 {
 515     if( !mbHasRedoData )
 516     {
 517         getData( maRedoData );
 518         mbHasRedoData = true;
 519     }
 520     setData( maUndoData );
 521 }
 522
 523 void TableStyleUndo::Redo()
 524 {
 525     setData( maRedoData );
 526 }
 527
 528 void TableStyleUndo::setData( const Data& rData )
 529 {
 530     SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() );
 531     if( pTableObj )
 532     {
 533         pTableObj->setTableStyle( rData.mxTableStyle );
 534         pTableObj->setTableStyleSettings( rData.maSettings );
 535     }
 536 }
 537
 538 void TableStyleUndo::getData( Data& rData )
 539 {
 540     SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() );
 541     if( pTableObj )
 542     {
 543         rData.maSettings = pTableObj->getTableStyleSettings();
 544         rData.mxTableStyle = pTableObj->getTableStyle();
 545     }
 546 }
 547
 548 } }
 549
 550 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */