LCOV - code coverage report
Current view: top level - svx/source/table - tableundo.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 48 268 17.9 %
Date: 2014-11-03 Functions: 16 56 28.6 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10