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