| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| #include "svx/sdr/properties/textproperties.hxx" |
| #include "editeng/outlobj.hxx" |
| #include "cell.hxx" |
| #include "tableundo.hxx" |
| #include "svx/svdotable.hxx" |
| #include "tablerow.hxx" |
| #include "tablecolumn.hxx" |
| #include <svx/svdmodel.hxx> |
| |
| // ----------------------------------------------------------------------------- |
| |
| using ::rtl::OUString; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::table; |
| |
| // ----------------------------------------------------------------------------- |
| |
| namespace sdr { namespace table { |
| |
| CellUndo::CellUndo( const SdrObjectWeakRef& xObjRef, const CellRef& xCell ) |
| : SdrUndoAction( xCell->getSdrTextObj().getSdrModelFromSdrObject() ) |
| , SfxListener() |
| , mxObjRef( xObjRef ) |
| , mxCell( xCell ) |
| , mbUndo( true ) |
| { |
| if( mxCell.is() && mxObjRef.is() ) |
| { |
| getDataFromCell( maUndoData ); |
| StartListening(*mxObjRef.get()); |
| } |
| } |
| |
| CellUndo::~CellUndo() |
| { |
| if( mxObjRef.is() ) |
| { |
| EndListening(*mxObjRef.get()); |
| } |
| |
| dispose(); |
| } |
| |
| void CellUndo::dispose() |
| { |
| mxCell.clear(); |
| delete maUndoData.mpProperties; |
| maUndoData.mpProperties = 0; |
| delete maRedoData.mpProperties; |
| maRedoData.mpProperties = 0; |
| delete maUndoData.mpOutlinerParaObject; |
| maUndoData.mpOutlinerParaObject = 0; |
| delete maRedoData.mpOutlinerParaObject; |
| maRedoData.mpOutlinerParaObject = 0; |
| } |
| |
| // derived from SfxListener |
| void CellUndo::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& rHint) |
| { |
| const SdrBaseHint* pSdrHint = dynamic_cast< const SdrBaseHint* >(&rHint); |
| |
| if(pSdrHint && HINT_SDROBJECTDYING == pSdrHint->GetSdrHintKind()) |
| { |
| dispose(); |
| } |
| } |
| |
| void CellUndo::Undo() |
| { |
| if( mxCell.is() && mbUndo ) |
| { |
| if( maRedoData.mpProperties == 0 ) |
| getDataFromCell( maRedoData ); |
| |
| setDataToCell( maUndoData ); |
| mbUndo = false; |
| } |
| } |
| |
| void CellUndo::Redo() |
| { |
| if( mxCell.is() && !mbUndo ) |
| { |
| setDataToCell( maRedoData ); |
| mbUndo = true; |
| } |
| } |
| |
| sal_Bool CellUndo::Merge( SfxUndoAction *pNextAction ) |
| { |
| CellUndo* pNext = dynamic_cast< CellUndo* >( pNextAction ); |
| if( pNext && pNext->mxCell.get() == mxCell.get() ) |
| { |
| return sal_True; |
| } |
| else |
| { |
| return sal_False; |
| } |
| } |
| |
| void CellUndo::setDataToCell( const Data& rData ) |
| { |
| delete mxCell->mpProperties; |
| if( rData.mpProperties ) |
| mxCell->mpProperties = Cell::CloneProperties( rData.mpProperties, *mxObjRef.get(), *mxCell.get() ); |
| else |
| mxCell->mpProperties = 0; |
| |
| if( rData.mpOutlinerParaObject ) |
| mxCell->SetOutlinerParaObject( new OutlinerParaObject(*rData.mpOutlinerParaObject) ); |
| else |
| mxCell->RemoveOutlinerParaObject(); |
| |
| mxCell->msFormula = rData.msFormula; |
| mxCell->mfValue = rData.mfValue; |
| mxCell->mnError = rData.mnError; |
| mxCell->mbMerged = rData.mbMerged; |
| mxCell->mnRowSpan = rData.mnRowSpan; |
| mxCell->mnColSpan = rData.mnColSpan; |
| |
| if(mxObjRef.is()) |
| { |
| // #120201# ActionChanged is not enough, we need to trigger TableLayouter::UpdateBorderLayout() |
| // and this is done best using ReformatText() for table objects |
| mxObjRef->ActionChanged(); |
| mxObjRef->ReformatText(); |
| } |
| } |
| |
| void CellUndo::getDataFromCell( Data& rData ) |
| { |
| if( mxObjRef.is() && mxCell.is() ) |
| { |
| if( mxCell->mpProperties ) |
| rData.mpProperties = mxCell->CloneProperties( *mxObjRef.get(), *mxCell.get()); |
| |
| if( mxCell->GetOutlinerParaObject() ) |
| rData.mpOutlinerParaObject = new OutlinerParaObject(*mxCell->GetOutlinerParaObject()); |
| else |
| rData.mpOutlinerParaObject = 0; |
| |
| rData.mnCellContentType = mxCell->mnCellContentType; |
| |
| rData.msFormula = mxCell->msFormula; |
| rData.mfValue = mxCell->mfValue; |
| rData.mnError = mxCell->mnError; |
| rData.mbMerged = mxCell->mbMerged; |
| rData.mnRowSpan = mxCell->mnRowSpan; |
| rData.mnColSpan = mxCell->mnColSpan; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // class InsertRowUndo : public SdrUndoAction |
| // ----------------------------------------------------------------------------- |
| |
| static void Dispose( RowVector& rRows ) |
| { |
| RowVector::iterator aIter( rRows.begin() ); |
| while( aIter != rRows.end() ) |
| (*aIter++)->dispose(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| InsertRowUndo::InsertRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aNewRows ) |
| : SdrUndoAction( xTable->getSdrTableObj()->getSdrModelFromSdrObject() ) |
| , mxTable( xTable ) |
| , mnIndex( nIndex ) |
| , mbUndo( true ) |
| { |
| maRows.swap( aNewRows ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| InsertRowUndo::~InsertRowUndo() |
| { |
| if( !mbUndo ) |
| Dispose( maRows ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void InsertRowUndo::Undo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) ); |
| mbUndo = false; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void InsertRowUndo::Redo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoRemoveRows( mnIndex, maRows ); |
| mbUndo = true; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // class RemoveRowUndo : public SdrUndoAction |
| // ----------------------------------------------------------------------------- |
| |
| RemoveRowUndo::RemoveRowUndo( const TableModelRef& xTable, sal_Int32 nIndex, RowVector& aRemovedRows ) |
| : SdrUndoAction( xTable->getSdrTableObj()->getSdrModelFromSdrObject() ) |
| , mxTable( xTable ) |
| , mnIndex( nIndex ) |
| , mbUndo( true ) |
| { |
| maRows.swap( aRemovedRows ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| RemoveRowUndo::~RemoveRowUndo() |
| { |
| if( mbUndo ) |
| Dispose( maRows ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void RemoveRowUndo::Undo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoRemoveRows( mnIndex, maRows ); |
| mbUndo = false; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void RemoveRowUndo::Redo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoInsertRows( mnIndex, sal::static_int_cast< sal_Int32 >( maRows.size() ) ); |
| mbUndo = true; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // class InsertColUndo : public SdrUndoAction |
| // ----------------------------------------------------------------------------- |
| |
| static void Dispose( ColumnVector& rCols ) |
| { |
| ColumnVector::iterator aIter( rCols.begin() ); |
| while( aIter != rCols.end() ) |
| (*aIter++)->dispose(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| static void Dispose( CellVector& rCells ) |
| { |
| CellVector::iterator aIter( rCells.begin() ); |
| while( aIter != rCells.end() ) |
| (*aIter++)->dispose(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| InsertColUndo::InsertColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells ) |
| : SdrUndoAction( xTable->getSdrTableObj()->getSdrModelFromSdrObject() ) |
| , mxTable( xTable ) |
| , mnIndex( nIndex ) |
| , mbUndo( true ) |
| { |
| maColumns.swap( aNewCols ); |
| maCells.swap( aCells ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| InsertColUndo::~InsertColUndo() |
| { |
| if( !mbUndo ) |
| { |
| Dispose( maColumns ); |
| Dispose( maCells ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void InsertColUndo::Undo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) ); |
| mbUndo = false; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void InsertColUndo::Redo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells ); |
| mbUndo = true; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // class RemoveColUndo : public SdrUndoAction |
| // ----------------------------------------------------------------------------- |
| |
| RemoveColUndo::RemoveColUndo( const TableModelRef& xTable, sal_Int32 nIndex, ColumnVector& aNewCols, CellVector& aCells ) |
| : SdrUndoAction( xTable->getSdrTableObj()->getSdrModelFromSdrObject() ) |
| , mxTable( xTable ) |
| , mnIndex( nIndex ) |
| , mbUndo( true ) |
| { |
| maColumns.swap( aNewCols ); |
| maCells.swap( aCells ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| RemoveColUndo::~RemoveColUndo() |
| { |
| if( mbUndo ) |
| { |
| Dispose( maColumns ); |
| Dispose( maCells ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void RemoveColUndo::Undo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoRemoveColumns( mnIndex, maColumns, maCells ); |
| mbUndo = false; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void RemoveColUndo::Redo() |
| { |
| if( mxTable.is() ) |
| { |
| mxTable->UndoInsertColumns( mnIndex, sal::static_int_cast< sal_Int32 >( maColumns.size() ) ); |
| mbUndo = true; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // class TableColumnUndo : public SdrUndoAction |
| // ----------------------------------------------------------------------------- |
| |
| TableColumnUndo::TableColumnUndo( const TableColumnRef& xCol ) |
| : SdrUndoAction( xCol->mxTableModel->getSdrTableObj()->getSdrModelFromSdrObject() ) |
| , mxCol( xCol ) |
| , mbHasRedoData( false ) |
| { |
| getData( maUndoData ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| TableColumnUndo::~TableColumnUndo() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableColumnUndo::Undo() |
| { |
| if( !mbHasRedoData ) |
| { |
| getData( maRedoData ); |
| mbHasRedoData = true; |
| } |
| setData( maUndoData ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableColumnUndo::Redo() |
| { |
| setData( maRedoData ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool TableColumnUndo::Merge( SfxUndoAction *pNextAction ) |
| { |
| TableColumnUndo* pNext = dynamic_cast< TableColumnUndo* >( pNextAction ); |
| return pNext && pNext->mxCol == mxCol; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableColumnUndo::setData( const Data& rData ) |
| { |
| mxCol->mnColumn = rData.mnColumn; |
| mxCol->mnWidth = rData.mnWidth; |
| mxCol->mbOptimalWidth = rData.mbOptimalWidth; |
| mxCol->mbIsVisible = rData.mbIsVisible; |
| mxCol->mbIsStartOfNewPage = rData.mbIsStartOfNewPage; |
| mxCol->maName = rData.maName; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableColumnUndo::getData( Data& rData ) |
| { |
| rData.mnColumn = mxCol->mnColumn; |
| rData.mnWidth = mxCol->mnWidth; |
| rData.mbOptimalWidth = mxCol->mbOptimalWidth; |
| rData.mbIsVisible = mxCol->mbIsVisible; |
| rData.mbIsStartOfNewPage = mxCol->mbIsStartOfNewPage; |
| rData.maName = mxCol->maName; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| // class TableRowUndo : public SdrUndoAction |
| // ----------------------------------------------------------------------------- |
| |
| TableRowUndo::TableRowUndo( const TableRowRef& xRow ) |
| : SdrUndoAction( xRow->mxTableModel->getSdrTableObj()->getSdrModelFromSdrObject() ) |
| , mxRow( xRow ) |
| , mbHasRedoData( false ) |
| { |
| getData( maUndoData ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| TableRowUndo::~TableRowUndo() |
| { |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableRowUndo::Undo() |
| { |
| if( !mbHasRedoData ) |
| { |
| getData( maRedoData ); |
| mbHasRedoData = true; |
| } |
| setData( maUndoData ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableRowUndo::Redo() |
| { |
| setData( maRedoData ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool TableRowUndo::Merge( SfxUndoAction *pNextAction ) |
| { |
| TableRowUndo* pNext = dynamic_cast< TableRowUndo* >( pNextAction ); |
| return pNext && pNext->mxRow == mxRow; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableRowUndo::setData( const Data& rData ) |
| { |
| mxRow->mnRow = rData.mnRow; |
| mxRow->mnHeight = rData.mnHeight; |
| mxRow->mbOptimalHeight = rData.mbOptimalHeight; |
| mxRow->mbIsVisible = rData.mbIsVisible; |
| mxRow->mbIsStartOfNewPage = rData.mbIsStartOfNewPage; |
| mxRow->maName = rData.maName; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void TableRowUndo::getData( Data& rData ) |
| { |
| rData.mnRow = mxRow->mnRow; |
| rData.mnHeight = mxRow->mnHeight; |
| rData.mbOptimalHeight = mxRow->mbOptimalHeight; |
| rData.mbIsVisible = mxRow->mbIsVisible; |
| rData.mbIsStartOfNewPage = mxRow->mbIsStartOfNewPage; |
| rData.maName = mxRow->maName; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| TableStyleUndo::TableStyleUndo( const SdrTableObj& rTableObj ) |
| : SdrUndoAction( rTableObj.getSdrModelFromSdrObject() ) |
| , mxObjRef( const_cast< sdr::table::SdrTableObj*>( &rTableObj ) ) |
| { |
| getData( maUndoData ); |
| } |
| |
| void TableStyleUndo::Undo() |
| { |
| if( !mbHasRedoData ) |
| { |
| getData( maRedoData ); |
| mbHasRedoData = true; |
| } |
| setData( maUndoData ); |
| } |
| |
| void TableStyleUndo::Redo() |
| { |
| setData( maRedoData ); |
| } |
| |
| void TableStyleUndo::setData( const Data& rData ) |
| { |
| SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() ); |
| if( pTableObj ) |
| { |
| pTableObj->setTableStyle( rData.mxTableStyle ); |
| pTableObj->setTableStyleSettings( rData.maSettings ); |
| } |
| } |
| |
| void TableStyleUndo::getData( Data& rData ) |
| { |
| SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >( mxObjRef.get() ); |
| if( pTableObj ) |
| { |
| rData.maSettings = pTableObj->getTableStyleSettings(); |
| rData.mxTableStyle = pTableObj->getTableStyle(); |
| } |
| } |
| |
| } } |