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