summaryrefslogtreecommitdiffstats
path: root/kspread/kspread_undo.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kspread/kspread_undo.cpp')
-rw-r--r--kspread/kspread_undo.cpp3001
1 files changed, 3001 insertions, 0 deletions
diff --git a/kspread/kspread_undo.cpp b/kspread/kspread_undo.cpp
new file mode 100644
index 000000000..28f592651
--- /dev/null
+++ b/kspread/kspread_undo.cpp
@@ -0,0 +1,3001 @@
+/* This file is part of the KDE project
+ Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+*/
+
+
+#include "kspread_cell.h"
+#include "kspread_doc.h"
+#include "kspread_global.h"
+#include "kspread_locale.h"
+#include "kspread_map.h"
+#include "kspread_sheet.h"
+#include "kspread_sheetprint.h"
+#include "kspread_style.h"
+#include "kspread_style_manager.h"
+#include "kspread_util.h"
+
+#include "kspread_undo.h"
+
+using namespace KSpread;
+
+bool operator < (const TQPoint& pointA , const TQPoint& pointB)
+{
+ if (pointA.y() == pointB.y())
+ return ( pointA.x() < pointB.x() );
+ else
+ return ( pointA.y() < pointB.y() );
+}
+
+/****************************************************************************
+ *
+ * Undo
+ *
+ ***************************************************************************/
+
+Undo::Undo( Doc *_doc )
+{
+ m_pDoc = _doc;
+
+ m_stckUndo.setAutoDelete( false );
+ m_stckRedo.setAutoDelete( false );
+}
+
+Undo::~Undo()
+{
+ clear();
+}
+
+void Undo::appendUndo( UndoAction *_action )
+{
+ if ( isLocked() )
+ return;
+
+ m_stckRedo.setAutoDelete( true );
+ m_stckRedo.clear();
+ m_stckRedo.setAutoDelete( false );
+
+ m_stckUndo.push( _action );
+
+ if ( m_pDoc )
+ {
+ m_pDoc->enableUndo( hasUndoActions() );
+ m_pDoc->enableRedo( hasRedoActions() );
+ m_pDoc->setModified( true );
+ }
+}
+
+void Undo::clear()
+{
+ if ( isLocked() )
+ return;
+
+ m_stckUndo.setAutoDelete( true );
+ m_stckRedo.setAutoDelete( true );
+
+ m_stckUndo.clear();
+ m_stckRedo.clear();
+
+ m_stckUndo.setAutoDelete( false );
+ m_stckRedo.setAutoDelete( false );
+}
+
+void Undo::undo()
+{
+ if ( m_stckUndo.isEmpty() )
+ return;
+
+ //Don't show error dialogs on undo
+ bool origErrorMessages = true;
+ if ( m_pDoc )
+ {
+ origErrorMessages = m_pDoc->getShowMessageError();
+ m_pDoc->setShowMessageError( false );
+ }
+
+ UndoAction *a = m_stckUndo.pop();
+ a->undo();
+ m_stckRedo.push( a );
+
+ if ( m_pDoc )
+ {
+ m_pDoc->setShowMessageError( origErrorMessages );
+ m_pDoc->enableUndo( hasUndoActions() );
+ m_pDoc->enableRedo( hasRedoActions() );
+ }
+}
+
+void Undo::redo()
+{
+ if ( m_stckRedo.isEmpty() )
+ return;
+ UndoAction *a = m_stckRedo.pop();
+ a->redo();
+ m_stckUndo.push( a );
+
+ if ( m_pDoc )
+ {
+ m_pDoc->enableUndo( hasUndoActions() );
+ m_pDoc->enableRedo( hasRedoActions() );
+ }
+}
+
+void Undo::lock()
+{
+ m_pDoc->undoLock();
+}
+
+void Undo::unlock()
+{
+ m_pDoc->undoUnlock();
+}
+
+bool Undo::isLocked() const
+{
+ return m_pDoc->undoLocked();
+}
+
+TQString Undo::getRedoName()
+{
+ if ( m_stckRedo.isEmpty() )
+ return TQString("");
+ return m_stckRedo.current()->getName();
+
+}
+
+TQString Undo::getUndoName()
+{
+ if ( m_stckUndo.isEmpty() )
+ return TQString("");
+ return m_stckUndo.current()->getName();
+}
+
+/****************************************************************************
+ *
+ * MacroUndoAction
+ *
+ ***************************************************************************/
+MacroUndoAction::MacroUndoAction( Doc *_doc, const TQString& _name ):
+ UndoAction( _doc )
+{
+ name=_name;
+}
+
+MacroUndoAction::~MacroUndoAction()
+{
+ m_commands.setAutoDelete( true );
+}
+
+void MacroUndoAction::addCommand(UndoAction *command)
+{
+ m_commands.append(command);
+}
+
+void MacroUndoAction::undo()
+{
+ TQPtrListIterator<UndoAction> it(m_commands);
+ for ( ; it.current() ; ++it )
+ it.current()->undo();
+}
+
+void MacroUndoAction::redo()
+{
+ TQPtrListIterator<UndoAction> it(m_commands);
+ for ( ; it.current() ; ++it )
+ it.current()->redo();
+}
+
+/****************************************************************************
+ *
+ * UndoInsertRemoveAction
+ *
+ ***************************************************************************/
+
+UndoInsertRemoveAction::UndoInsertRemoveAction( Doc * _doc ) :
+ UndoAction( _doc )
+{
+}
+
+UndoInsertRemoveAction::~UndoInsertRemoveAction()
+{
+
+}
+
+void UndoInsertRemoveAction::saveFormulaReference( Sheet *_sheet,
+ int col, int row, TQString & formula )
+{
+ if ( _sheet == 0 )
+ return;
+ TQString sheetName = _sheet->sheetName();
+
+ m_lstFormulaCells.append( FormulaOfCell( sheetName, col, row, formula ) );
+}
+
+void UndoInsertRemoveAction::undoFormulaReference()
+{
+ TQValueList<FormulaOfCell>::iterator it;
+ for ( it = m_lstFormulaCells.begin(); it != m_lstFormulaCells.end(); ++it )
+ {
+ Sheet* sheet = doc()->map()->findSheet( (*it).sheetName() );
+ if ( sheet )
+ {
+ Cell * cell = sheet->cellAt( (*it).col(), (*it).row() );
+ if ( cell && !cell->isDefault() )
+ {
+ cell->setCellText( (*it).formula() );
+ }
+ }
+ }
+}
+
+/****************************************************************************
+ *
+ * UndoRemoveColumn
+ *
+ ***************************************************************************/
+
+UndoRemoveColumn::UndoRemoveColumn( Doc *_doc, Sheet *_sheet, int _column,int _nbCol ) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Remove Columns");
+ m_sheetName = _sheet->sheetName();
+ m_iColumn= _column;
+ m_iNbCol = _nbCol;
+ m_printRange = _sheet->print()->printRange();
+ m_printRepeatColumns = _sheet->print()->printRepeatColumns();
+ TQRect selection;
+ selection.setCoords( _column, 1, _column+m_iNbCol, KS_rowMax );
+ TQDomDocument doc = _sheet->saveCellRegion( selection );
+
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ m_data = buffer.utf8();
+ int len = m_data.length();
+ char tmp = m_data[ len - 1 ];
+ m_data.resize( len );
+ *( m_data.data() + len - 1 ) = tmp;
+}
+
+UndoRemoveColumn::~UndoRemoveColumn()
+{
+}
+
+void UndoRemoveColumn::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+
+ sheet->insertColumn( m_iColumn,m_iNbCol);
+
+ TQPoint pastePoint( m_iColumn, 1 );
+ sheet->paste( m_data, TQRect( pastePoint, pastePoint ) );
+ if(sheet->getAutoCalc()) sheet->recalc();
+
+ sheet->print()->setPrintRange( m_printRange );
+ sheet->print()->setPrintRepeatColumns( m_printRepeatColumns );
+
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoRemoveColumn::redo()
+{
+ doc()->undoLock();
+
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ sheet->removeColumn( m_iColumn,m_iNbCol );
+
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoInsertColumn
+ *
+ ***************************************************************************/
+
+UndoInsertColumn::UndoInsertColumn( Doc *_doc, Sheet *_sheet, int _column, int _nbCol ) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Insert Columns");
+ m_sheetName = _sheet->sheetName();
+ m_iColumn= _column;
+ m_iNbCol=_nbCol;
+}
+
+UndoInsertColumn::~UndoInsertColumn()
+{
+}
+
+void UndoInsertColumn::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->removeColumn( m_iColumn,m_iNbCol );
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoInsertColumn::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->insertColumn( m_iColumn,m_iNbCol);
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoRemoveRow
+ *
+ ***************************************************************************/
+
+UndoRemoveRow::UndoRemoveRow( Doc *_doc, Sheet *_sheet, int _row,int _nbRow) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Remove Rows");
+
+ m_sheetName = _sheet->sheetName();
+ m_iRow = _row;
+ m_iNbRow= _nbRow;
+ m_printRange=_sheet->print()->printRange();
+ m_printRepeatRows = _sheet->print()->printRepeatRows();
+
+ TQRect selection;
+ selection.setCoords( 1, _row, KS_colMax, _row+m_iNbRow );
+ TQDomDocument doc = _sheet->saveCellRegion( selection );
+
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ m_data = buffer.utf8();
+ int len = m_data.length();
+ char tmp = m_data[ len - 1 ];
+ m_data.resize( len );
+ *( m_data.data() + len - 1 ) = tmp;
+
+ // printf("UNDO {{{%s}}}\n", buffer.latin1() );
+ // printf("UNDO2 %i bytes, length %i {{{%s}}}\n", m_data.length(), m_data.size(), (const char*)m_data );
+ // printf("length=%i, size=%i", m_data.length(), m_data.size() );
+ // printf("Last characters are %i %i %i\n", (int)m_data[ m_data.size() - 3 ],
+ // (int)m_data[ m_data.size() - 2 ], (int)m_data[ m_data.size() - 1 ] );
+}
+
+UndoRemoveRow::~UndoRemoveRow()
+{
+}
+
+void UndoRemoveRow::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+
+ sheet->insertRow( m_iRow,m_iNbRow );
+
+ TQPoint pastePoint( 1, m_iRow );
+ sheet->paste( m_data, TQRect(pastePoint, pastePoint) );
+
+ sheet->print()->setPrintRange( m_printRange );
+ sheet->print()->setPrintRepeatRows( m_printRepeatRows );
+
+ if(sheet->getAutoCalc()) sheet->recalc();
+
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoRemoveRow::redo()
+{
+ doc()->undoLock();
+
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ sheet->removeRow( m_iRow,m_iNbRow );
+
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoInsertRow
+ *
+ ***************************************************************************/
+
+UndoInsertRow::UndoInsertRow( Doc *_doc, Sheet *_sheet, int _row,int _nbRow ) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Insert Rows");
+ m_sheetName = _sheet->sheetName();
+ m_iRow = _row;
+ m_iNbRow=_nbRow;
+}
+
+UndoInsertRow::~UndoInsertRow()
+{
+}
+
+void UndoInsertRow::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->removeRow( m_iRow,m_iNbRow );
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoInsertRow::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->insertRow( m_iRow,m_iNbRow );
+ doc()->undoUnlock();
+}
+
+
+/****************************************************************************
+ *
+ * UndoHideRow
+ *
+ ***************************************************************************/
+
+/*UndoHideRow::UndoHideRow( Doc *_doc, Sheet *_sheet, int _row, int _nbRow , TQValueList<int>_listRow) :
+ UndoAction( _doc )
+{
+ name=i18n("Hide Rows");
+ m_sheetName = _sheet->sheetName();
+ m_iRow= _row;
+ m_iNbRow=_nbRow;
+ if(m_iNbRow!=-1)
+ createList( listRow ,_sheet );
+ else
+ listRow=TQValueList<int>(_listRow);
+}
+
+UndoHideRow::~UndoHideRow()
+{
+}
+
+void UndoHideRow::createList( TQValueList<int>&list,Sheet *tab )
+{
+RowFormat *rl;
+for(int i=m_iRow;i<=(m_iRow+m_iNbRow);i++)
+ {
+ rl= tab->nonDefaultRowFormat( i );
+ if(!rl->isHide())
+ list.append(rl->row());
+ }
+}
+
+void UndoHideRow::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->showRow( 0,-1,listRow );
+ doc()->undoUnlock();
+}
+
+void UndoHideRow::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->hideRow(0,-1, listRow );
+ doc()->undoUnlock();
+}*/
+
+/****************************************************************************
+ *
+ * UndoHideColumn
+ *
+ ***************************************************************************/
+
+/*UndoHideColumn::UndoHideColumn( Doc *_doc, Sheet *_sheet, int _column, int _nbCol, TQValueList<int>_listCol ) :
+ UndoAction( _doc )
+{
+ name=i18n("Hide Columns");
+
+ m_sheetName = _sheet->sheetName();
+ m_iColumn= _column;
+ m_iNbCol=_nbCol;
+ if(m_iNbCol!=-1)
+ createList( listCol ,_sheet );
+ else
+ listCol=TQValueList<int>(_listCol);
+}
+
+UndoHideColumn::~UndoHideColumn()
+{
+}
+
+void UndoHideColumn::createList( TQValueList<int>&list,Sheet *tab )
+{
+ColumnFormat *cl;
+for(int i=m_iColumn;i<=(m_iColumn+m_iNbCol);i++)
+ {
+ cl= tab->nonDefaultColumnFormat( i );
+ if(!cl->isHide())
+ list.append(cl->column());
+ }
+}
+
+void UndoHideColumn::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->showColumn(0,-1,listCol);
+ doc()->undoUnlock();
+}
+
+void UndoHideColumn::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->hideColumn(0,-1,listCol);
+ doc()->undoUnlock();
+}*/
+
+/****************************************************************************
+ *
+ * UndoShowRow
+ *
+ ***************************************************************************/
+
+/*UndoShowRow::UndoShowRow( Doc *_doc, Sheet *_sheet, int _row, int _nbRow, TQValueList<int>_listRow ) :
+ UndoAction( _doc )
+{
+ name=i18n("Show Rows");
+
+ m_sheetName = _sheet->sheetName();
+ m_iRow= _row;
+ m_iNbRow=_nbRow;
+ if(m_iNbRow!=-1)
+ createList( listRow ,_sheet );
+ else
+ listRow=TQValueList<int>(_listRow);
+}
+
+UndoShowRow::~UndoShowRow()
+{
+}
+
+void UndoShowRow::createList( TQValueList<int>&list,Sheet *tab )
+{
+RowFormat *rl;
+for(int i=m_iRow;i<=(m_iRow+m_iNbRow);i++)
+ {
+ rl= tab->nonDefaultRowFormat( i );
+ if(rl->isHide())
+ list.append(rl->row());
+ }
+}
+
+void UndoShowRow::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->hideRow(0,-1,listRow);
+ doc()->undoUnlock();
+}
+
+void UndoShowRow::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->showRow(0,-1,listRow);
+ doc()->undoUnlock();
+}*/
+
+/****************************************************************************
+ *
+ * UndoShowColumn
+ *
+ ***************************************************************************/
+
+/*UndoShowColumn::UndoShowColumn( Doc *_doc, Sheet *_sheet, int _column, int _nbCol,TQValueList<int>_listCol ) :
+ UndoAction( _doc )
+{
+ name=i18n("Show Columns");
+
+ m_sheetName = _sheet->sheetName();
+ m_iColumn= _column;
+ m_iNbCol=_nbCol;
+ if(m_iNbCol!=-1)
+ createList( listCol ,_sheet );
+ else
+ listCol=TQValueList<int>(_listCol);
+}
+
+UndoShowColumn::~UndoShowColumn()
+{
+}
+
+void UndoShowColumn::createList( TQValueList<int>&list,Sheet *tab )
+{
+ColumnFormat *cl;
+for(int i=m_iColumn;i<=(m_iColumn+m_iNbCol);i++)
+ {
+ cl= tab->nonDefaultColumnFormat( i );
+ if(cl->isHide())
+ list.append(cl->column());
+ }
+
+}
+
+void UndoShowColumn::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->hideColumn( 0,-1,listCol );
+ doc()->undoUnlock();
+}
+
+void UndoShowColumn::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->showColumn(0,-1,listCol);
+ doc()->undoUnlock();
+}*/
+
+
+/****************************************************************************
+ *
+ * UndoPaperLayout
+ *
+ ***************************************************************************/
+
+UndoPaperLayout::UndoPaperLayout( Doc *_doc, Sheet *_sheet )
+ : UndoAction( _doc )
+{
+ name=i18n("Set Page Layout");
+ m_sheetName = _sheet->sheetName();
+
+ m_pl = _sheet->print()->paperLayout();
+ m_hf = _sheet->print()->headFootLine();
+ m_unit = doc()->unit();
+ m_printGrid = _sheet->print()->printGrid();
+ m_printCommentIndicator = _sheet->print()->printCommentIndicator();
+ m_printFormulaIndicator = _sheet->print()->printFormulaIndicator();
+ m_printRange = _sheet->print()->printRange();
+ m_printRepeatColumns = _sheet->print()->printRepeatColumns();
+ m_printRepeatRows = _sheet->print()->printRepeatRows();
+ m_dZoom = _sheet->print()->zoom();
+ m_iPageLimitX = _sheet->print()->pageLimitX();
+ m_iPageLimitY = _sheet->print()->pageLimitY();
+}
+
+UndoPaperLayout::~UndoPaperLayout()
+{
+}
+
+void UndoPaperLayout::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+ SheetPrint* print = sheet->print();
+
+ doc()->undoLock();
+
+ m_plRedo = print->paperLayout();
+ print->setPaperLayout( m_pl.ptLeft, m_pl.ptTop,
+ m_pl.ptRight, m_pl.ptBottom,
+ m_pl.format, m_pl.orientation );
+
+ m_hfRedo = print->headFootLine();
+ print->setHeadFootLine( m_hf.headLeft, m_hf.headMid, m_hf.headRight,
+ m_hf.footLeft, m_hf.footMid, m_hf.footRight );
+
+ m_unitRedo = doc()->unit();
+ doc()->setUnit( m_unit );
+
+ m_printGridRedo = print->printGrid();
+ print->setPrintGrid( m_printGrid );
+
+ m_printCommentIndicatorRedo = print->printCommentIndicator();
+ print->setPrintCommentIndicator( m_printCommentIndicator );
+
+ m_printFormulaIndicatorRedo = print->printFormulaIndicator();
+ print->setPrintFormulaIndicator( m_printFormulaIndicator );
+
+ m_printRangeRedo = print->printRange();
+ print->setPrintRange( m_printRange );
+
+ m_printRepeatColumnsRedo = print->printRepeatColumns();
+ print->setPrintRepeatColumns( m_printRepeatColumns );
+
+ m_printRepeatRowsRedo = print->printRepeatRows();
+ print->setPrintRepeatRows( m_printRepeatRows );
+
+ m_dZoomRedo = print->zoom();
+ print->setZoom( m_dZoom );
+
+ m_iPageLimitXRedo = print->pageLimitX();
+ print->setPageLimitX( m_iPageLimitX );
+
+ m_iPageLimitYRedo = print->pageLimitY();
+ print->setPageLimitY( m_iPageLimitY );
+
+ doc()->undoUnlock();
+}
+
+void UndoPaperLayout::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+ SheetPrint* print = sheet->print();
+
+ doc()->undoLock();
+ print->setPaperLayout( m_plRedo.ptLeft, m_plRedo.ptTop,
+ m_plRedo.ptRight, m_plRedo.ptBottom,
+ m_plRedo.format, m_plRedo.orientation );
+
+ print->setHeadFootLine( m_hfRedo.headLeft, m_hfRedo.headMid, m_hfRedo.headRight,
+ m_hfRedo.footLeft, m_hfRedo.footMid, m_hfRedo.footRight );
+
+ doc()->setUnit( m_unitRedo );
+
+ print->setPrintGrid( m_printGridRedo );
+ print->setPrintCommentIndicator( m_printCommentIndicatorRedo );
+ print->setPrintFormulaIndicator( m_printFormulaIndicatorRedo );
+
+ print->setPrintRange( m_printRangeRedo );
+ print->setPrintRepeatColumns( m_printRepeatColumnsRedo );
+ print->setPrintRepeatRows( m_printRepeatRowsRedo );
+
+ print->setZoom( m_dZoomRedo );
+
+ print->setPageLimitX( m_iPageLimitX );
+ print->setPageLimitY( m_iPageLimitY );
+
+ doc()->undoUnlock();
+}
+
+
+
+
+/****************************************************************************
+ *
+ * UndoSetText
+ *
+ ***************************************************************************/
+
+UndoSetText::UndoSetText( Doc *_doc, Sheet *_sheet, const TQString& _text, int _column, int _row,FormatType _formatType ) :
+ UndoAction( _doc )
+{
+ name=i18n("Change Text");
+
+ m_strText = _text;
+ m_iColumn= _column;
+ m_iRow = _row;
+ m_sheetName = _sheet->sheetName();
+ m_eFormatType=_formatType;
+}
+
+UndoSetText::~UndoSetText()
+{
+}
+
+void UndoSetText::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+ Cell *cell = sheet->nonDefaultCell( m_iColumn, m_iRow );
+ m_strRedoText = cell->text();
+ m_eFormatTypeRedo=cell->format()->getFormatType( m_iColumn, m_iRow );
+ cell->format()->setFormatType(m_eFormatType);
+
+ if ( m_strText.isNull() )
+ cell->setCellText( "" );
+ else
+ cell->setCellText( m_strText );
+ sheet->updateView( TQRect( m_iColumn, m_iRow, 1, 1 ) );
+ doc()->undoUnlock();
+}
+
+void UndoSetText::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+ Cell *cell = sheet->nonDefaultCell( m_iColumn, m_iRow );
+ m_strText = cell->text();
+ m_eFormatType=cell->format()->getFormatType( m_iColumn, m_iRow );
+ if ( m_strRedoText.isNull() )
+ cell->setCellText( "" );
+ else
+ cell->setCellText( m_strRedoText );
+ cell->format()->setFormatType(m_eFormatTypeRedo);
+ sheet->updateView( TQRect( m_iColumn, m_iRow, 1, 1 ) );
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoCellFormat
+ *
+ ***************************************************************************/
+
+UndoCellFormat::UndoCellFormat( Doc * _doc,
+ Sheet * _sheet,
+ const Region & _selection,
+ const TQString & _name ) :
+ UndoAction( _doc )
+{
+ if ( _name.isEmpty())
+ name = i18n("Change Format");
+ else
+ name = _name;
+
+ m_region = _selection;
+ m_sheetName = _sheet->sheetName();
+ copyFormat( m_lstFormats, m_lstColFormats, m_lstRowFormats, _sheet );
+}
+
+void UndoCellFormat::copyFormat(TQValueList<layoutCell> & list,
+ TQValueList<layoutColumn> & listCol,
+ TQValueList<layoutRow> & listRow,
+ Sheet * sheet )
+{
+ TQValueList<layoutCell>::Iterator it2;
+ for ( it2 = list.begin(); it2 != list.end(); ++it2 )
+ {
+ delete (*it2).l;
+ }
+ list.clear();
+
+ Cell * cell;
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect range = (*it)->rect().normalize();
+ int bottom = range.bottom();
+ int right = range.right();
+
+ if ( util_isColumnSelected( range ) )
+ {
+ /* Don't need to go through the loop twice...
+ for (int i = range.left(); i <= right; ++i)
+ {
+ layoutColumn tmplayout;
+ tmplayout.col = i;
+ tmplayout.l = new ColumnFormat( sheet, i );
+ tmplayout.l->copy( *(sheet->columnFormat( i )) );
+ listCol.append(tmplayout);
+ }
+ */
+ for ( int c = range.left(); c <= right; ++c )
+ {
+ layoutColumn tmplayout;
+ tmplayout.col = c;
+ tmplayout.l = new ColumnFormat( sheet, c );
+ tmplayout.l->copy( *(sheet->columnFormat( c )) );
+ listCol.append(tmplayout);
+
+ cell = sheet->getFirstCellColumn( c );
+ while ( cell )
+ {
+ if ( cell->isPartOfMerged() )
+ {
+ cell = sheet->getNextCellDown( c, cell->row() );
+ continue;
+ }
+
+ layoutCell tmplayout;
+ tmplayout.col = c;
+ tmplayout.row = cell->row();
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( tmplayout.col, tmplayout.row )->format()) );
+ list.append(tmplayout);
+
+ cell = sheet->getNextCellDown( c, cell->row() );
+ }
+ }
+ /*
+ Cell * c = sheet->firstCell();
+ for( ; c; c = c->nextCell() )
+ {
+ int col = c->column();
+ if ( range.left() <= col && right >= col
+ && !c->isPartOfMerged())
+ {
+ layoutCell tmplayout;
+ tmplayout.col = c->column();
+ tmplayout.row = c->row();
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( tmplayout.col, tmplayout.row )) );
+ list.append(tmplayout);
+ }
+ }
+ */
+ }
+ else if (util_isRowSelected( range ) )
+ {
+ for ( int row = range.top(); row <= bottom; ++row )
+ {
+ layoutRow tmplayout;
+ tmplayout.row = row;
+ tmplayout.l = new RowFormat( sheet, row );
+ tmplayout.l->copy( *(sheet->rowFormat( row )) );
+ listRow.append(tmplayout);
+
+ cell = sheet->getFirstCellRow( row );
+ while ( cell )
+ {
+ if ( cell->isPartOfMerged() )
+ {
+ cell = sheet->getNextCellRight( cell->column(), row );
+ continue;
+ }
+ layoutCell tmplayout;
+ tmplayout.col = cell->column();
+ tmplayout.row = row;
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( cell->column(), row )->format()) );
+ list.append(tmplayout);
+
+ cell = sheet->getNextCellRight( cell->column(), row );
+ }
+ }
+ /*
+ Cell * c = sheet->firstCell();
+ for( ; c; c = c->nextCell() )
+ {
+ int row = c->row();
+ if ( range.top() <= row && bottom >= row
+ && !c->isPartOfMerged())
+ {
+ layoutCell tmplayout;
+ tmplayout.col = c->column();
+ tmplayout.row = c->row();
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( tmplayout.col, tmplayout.row )) );
+ list.append(tmplayout);
+ }
+ }
+ */
+ }
+ else
+ {
+ for ( int y = range.top(); y <= bottom; ++y )
+ for ( int x = range.left(); x <= right; ++x )
+ {
+ Cell * cell = sheet->nonDefaultCell( x, y );
+ if ( !cell->isPartOfMerged() )
+ {
+ layoutCell tmplayout;
+ tmplayout.col = x;
+ tmplayout.row = y;
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( x, y )->format()) );
+ list.append(tmplayout);
+ }
+ }
+ }
+ }
+}
+
+UndoCellFormat::~UndoCellFormat()
+{
+ TQValueList<layoutCell>::Iterator it2;
+ for ( it2 = m_lstFormats.begin(); it2 != m_lstFormats.end(); ++it2 )
+ {
+ delete (*it2).l;
+ }
+ m_lstFormats.clear();
+
+ for ( it2 = m_lstRedoFormats.begin(); it2 != m_lstRedoFormats.end(); ++it2 )
+ {
+ delete (*it2).l;
+ }
+ m_lstRedoFormats.clear();
+
+ TQValueList<layoutColumn>::Iterator it3;
+ for ( it3 = m_lstColFormats.begin(); it3 != m_lstColFormats.end(); ++it3 )
+ {
+ delete (*it3).l;
+ }
+ m_lstColFormats.clear();
+
+ for ( it3 = m_lstRedoColFormats.begin(); it3 != m_lstRedoColFormats.end(); ++it3 )
+ {
+ delete (*it3).l;
+ }
+ m_lstRedoColFormats.clear();
+
+ TQValueList<layoutRow>::Iterator it4;
+ for ( it4 = m_lstRowFormats.begin(); it4 != m_lstRowFormats.end(); ++it4 )
+ {
+ delete (*it4).l;
+ }
+ m_lstRowFormats.clear();
+
+ for ( it4 = m_lstRedoRowFormats.begin(); it4 != m_lstRedoRowFormats.end(); ++it4 )
+ {
+ delete (*it4).l;
+ }
+ m_lstRedoRowFormats.clear();
+
+
+}
+
+void UndoCellFormat::undo()
+{
+ Sheet * sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+ copyFormat( m_lstRedoFormats, m_lstRedoColFormats, m_lstRedoRowFormats, sheet );
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect range = (*it)->rect().normalize();
+ if( util_isColumnSelected( range ) )
+ {
+ TQValueList<layoutColumn>::Iterator it2;
+ for ( it2 = m_lstColFormats.begin(); it2 != m_lstColFormats.end(); ++it2 )
+ {
+ ColumnFormat * col = sheet->nonDefaultColumnFormat( (*it2).col );
+ col->copy( *(*it2).l );
+ }
+ }
+ else if( util_isRowSelected( range ) )
+ {
+ TQValueList<layoutRow>::Iterator it2;
+ for ( it2 = m_lstRowFormats.begin(); it2 != m_lstRowFormats.end(); ++it2 )
+ {
+ RowFormat * row = sheet->nonDefaultRowFormat( (*it2).row );
+ row->copy( *(*it2).l );
+ }
+ }
+
+ TQValueList<layoutCell>::Iterator it2;
+ for ( it2 = m_lstFormats.begin(); it2 != m_lstFormats.end(); ++it2 )
+ {
+ Cell *cell = sheet->nonDefaultCell( (*it2).col,(*it2).row );
+ cell->format()->copy( *(*it2).l );
+ cell->setLayoutDirtyFlag();
+ cell->setDisplayDirtyFlag();
+ sheet->updateCell( cell, (*it2).col, (*it2).row );
+ }
+ }
+ sheet->setRegionPaintDirty( m_region );
+ sheet->updateView( &m_region );
+
+ doc()->undoUnlock();
+}
+
+void UndoCellFormat::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect range = (*it)->rect().normalize();
+ if ( util_isColumnSelected( range ) )
+ {
+ TQValueList<layoutColumn>::Iterator it2;
+ for ( it2 = m_lstRedoColFormats.begin(); it2 != m_lstRedoColFormats.end(); ++it2 )
+ {
+ ColumnFormat * col = sheet->nonDefaultColumnFormat( (*it2).col );
+ col->copy( *(*it2).l );
+ }
+ }
+ else if( util_isRowSelected( range ) )
+ {
+ TQValueList<layoutRow>::Iterator it2;
+ for ( it2 = m_lstRedoRowFormats.begin(); it2 != m_lstRedoRowFormats.end(); ++it2 )
+ {
+ RowFormat * row = sheet->nonDefaultRowFormat( (*it2).row );
+ row->copy( *(*it2).l );
+ }
+ }
+
+ TQValueList<layoutCell>::Iterator it2;
+ for ( it2 = m_lstRedoFormats.begin(); it2 != m_lstRedoFormats.end(); ++it2 )
+ {
+ Cell * cell = sheet->nonDefaultCell( (*it2).col,(*it2).row );
+ cell->format()->copy( *(*it2).l );
+ cell->setLayoutDirtyFlag();
+ cell->setDisplayDirtyFlag();
+ sheet->updateCell( cell, (*it2).col, (*it2).row );
+ }
+ }
+
+ sheet->setRegionPaintDirty( m_region );
+ sheet->updateView( &m_region );
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoChangeAngle
+ *
+ ***************************************************************************/
+
+UndoChangeAngle::UndoChangeAngle( Doc * _doc,
+ Sheet * _sheet,
+ const Region & _selection ) :
+ UndoAction( _doc )
+{
+ name = i18n("Change Angle");
+ m_layoutUndo = new UndoCellFormat( _doc, _sheet, _selection, TQString() );
+ m_resizeUndo = new UndoResizeColRow( _doc, _sheet, _selection );
+}
+
+UndoChangeAngle::~UndoChangeAngle()
+{
+ delete m_resizeUndo;
+ delete m_layoutUndo;
+}
+
+void UndoChangeAngle::undo()
+{
+ m_layoutUndo->undo();
+ m_resizeUndo->undo();
+}
+
+void UndoChangeAngle::redo()
+{
+ m_layoutUndo->redo();
+ m_resizeUndo->redo();
+}
+
+/****************************************************************************
+ *
+ * UndoSort
+ *
+ ***************************************************************************/
+
+UndoSort::UndoSort( Doc * _doc, Sheet * _sheet, const TQRect & _selection ) :
+ UndoAction( _doc )
+{
+ name = i18n("Sort");
+
+ m_rctRect = _selection;
+ m_sheetName = _sheet->sheetName();
+ copyAll( m_lstFormats, m_lstColFormats, m_lstRowFormats, _sheet );
+}
+
+void UndoSort::copyAll(TQValueList<layoutTextCell> & list, TQValueList<layoutColumn> & listCol,
+ TQValueList<layoutRow> & listRow, Sheet * sheet )
+{
+ TQValueList<layoutTextCell>::Iterator it2;
+ for ( it2 = list.begin(); it2 != list.end(); ++it2 )
+ {
+ delete (*it2).l;
+ }
+ list.clear();
+
+ if ( util_isColumnSelected( m_rctRect ) )
+ {
+ Cell * c;
+ for (int col = m_rctRect.left(); col <= m_rctRect.right(); ++col)
+ {
+ layoutColumn tmplayout;
+ tmplayout.col = col;
+ tmplayout.l = new ColumnFormat( sheet, col );
+ tmplayout.l->copy( *(sheet->columnFormat( col )) );
+ listCol.append(tmplayout);
+
+ c = sheet->getFirstCellColumn( col );
+ while ( c )
+ {
+ if ( !c->isPartOfMerged() )
+ {
+ layoutTextCell tmplayout;
+ tmplayout.col = col;
+ tmplayout.row = c->row();
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( tmplayout.col, tmplayout.row )->format()) );
+ tmplayout.text = c->text();
+ list.append(tmplayout);
+ }
+
+ c = sheet->getNextCellDown( col, c->row() );
+ }
+ }
+ }
+ else if ( util_isRowSelected( m_rctRect ) )
+ {
+ Cell * c;
+ for ( int row = m_rctRect.top(); row <= m_rctRect.bottom(); ++row)
+ {
+ layoutRow tmplayout;
+ tmplayout.row = row;
+ tmplayout.l = new RowFormat( sheet, row );
+ tmplayout.l->copy( *(sheet->rowFormat( row )) );
+ listRow.append(tmplayout);
+
+ c = sheet->getFirstCellRow( row );
+ while ( c )
+ {
+ if ( !c->isPartOfMerged() )
+ {
+ layoutTextCell tmplayout;
+ tmplayout.col = c->column();
+ tmplayout.row = row;
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( tmplayout.col, tmplayout.row )->format()) );
+ tmplayout.text = c->text();
+ list.append(tmplayout);
+ }
+ c = sheet->getNextCellRight( c->column(), row );
+ }
+ }
+ }
+ else
+ {
+ int bottom = m_rctRect.bottom();
+ int right = m_rctRect.right();
+ Cell * cell;
+ for ( int y = m_rctRect.top(); y <= bottom; ++y )
+ for ( int x = m_rctRect.left(); x <= right; ++x )
+ {
+ cell = sheet->nonDefaultCell( x, y );
+ if (!cell->isPartOfMerged())
+ {
+ layoutTextCell tmplayout;
+ tmplayout.col = x;
+ tmplayout.row = y;
+ tmplayout.l = new Format( sheet, 0 );
+ tmplayout.l->copy( *(sheet->cellAt( x, y )->format()) );
+ tmplayout.text = cell->text();
+ list.append(tmplayout);
+ }
+ }
+ }
+}
+
+UndoSort::~UndoSort()
+{
+ TQValueList<layoutTextCell>::Iterator it2;
+ for ( it2 = m_lstFormats.begin(); it2 != m_lstFormats.end(); ++it2 )
+ {
+ delete (*it2).l;
+ }
+ m_lstFormats.clear();
+
+ for ( it2 = m_lstRedoFormats.begin(); it2 != m_lstRedoFormats.end(); ++it2 )
+ {
+ delete (*it2).l;
+ }
+ m_lstRedoFormats.clear();
+
+ TQValueList<layoutColumn>::Iterator it3;
+ for ( it3 = m_lstColFormats.begin(); it3 != m_lstColFormats.end(); ++it3 )
+ {
+ delete (*it3).l;
+ }
+ m_lstColFormats.clear();
+
+ for ( it3 = m_lstRedoColFormats.begin(); it3 != m_lstRedoColFormats.end(); ++it3 )
+ {
+ delete (*it3).l;
+ }
+ m_lstRedoColFormats.clear();
+
+ TQValueList<layoutRow>::Iterator it4;
+ for ( it4 = m_lstRowFormats.begin(); it4 != m_lstRowFormats.end(); ++it4 )
+ {
+ delete (*it4).l;
+ }
+ m_lstRowFormats.clear();
+
+ for ( it4 = m_lstRedoRowFormats.begin(); it4 != m_lstRedoRowFormats.end(); ++it4 )
+ {
+ delete (*it4).l;
+ }
+ m_lstRedoRowFormats.clear();
+
+}
+
+void UndoSort::undo()
+{
+ Sheet * sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ copyAll( m_lstRedoFormats, m_lstRedoColFormats,
+ m_lstRedoRowFormats, sheet );
+
+ if ( util_isColumnSelected( m_rctRect ) )
+ {
+ TQValueList<layoutColumn>::Iterator it2;
+ for ( it2 = m_lstColFormats.begin(); it2 != m_lstColFormats.end(); ++it2 )
+ {
+ ColumnFormat * col = sheet->nonDefaultColumnFormat( (*it2).col );
+ col->copy( *(*it2).l );
+ }
+ }
+ else if( util_isRowSelected( m_rctRect ) )
+ {
+ TQValueList<layoutRow>::Iterator it2;
+ for ( it2 = m_lstRowFormats.begin(); it2 != m_lstRowFormats.end(); ++it2 )
+ {
+ RowFormat *row= sheet->nonDefaultRowFormat( (*it2).row );
+ row->copy( *(*it2).l );
+ }
+ }
+
+ TQValueList<layoutTextCell>::Iterator it2;
+ for ( it2 = m_lstFormats.begin(); it2 != m_lstFormats.end(); ++it2 )
+ {
+ Cell *cell = sheet->nonDefaultCell( (*it2).col,(*it2).row );
+ if ( (*it2).text.isEmpty() )
+ {
+ if(!cell->text().isEmpty())
+ cell->setCellText( "" );
+ }
+ else
+ cell->setCellText( (*it2).text );
+
+ cell->format()->copy( *(*it2).l );
+ cell->setLayoutDirtyFlag();
+ cell->setDisplayDirtyFlag();
+ sheet->updateCell( cell, (*it2).col, (*it2).row );
+ }
+
+ sheet->setRegionPaintDirty(m_rctRect);
+ sheet->updateView( m_rctRect );
+
+ doc()->undoUnlock();
+}
+
+void UndoSort::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ if( util_isColumnSelected( m_rctRect ) )
+ {
+ TQValueList<layoutColumn>::Iterator it2;
+ for ( it2 = m_lstRedoColFormats.begin(); it2 != m_lstRedoColFormats.end(); ++it2 )
+ {
+ ColumnFormat *col= sheet->nonDefaultColumnFormat( (*it2).col );
+ col->copy( *(*it2).l );
+ }
+ }
+ else if( util_isRowSelected( m_rctRect ) )
+ {
+ TQValueList<layoutRow>::Iterator it2;
+ for ( it2 = m_lstRedoRowFormats.begin(); it2 != m_lstRedoRowFormats.end(); ++it2 )
+ {
+ RowFormat *row= sheet->nonDefaultRowFormat( (*it2).row );
+ row->copy( *(*it2).l );
+ }
+ }
+
+ TQValueList<layoutTextCell>::Iterator it2;
+ for ( it2 = m_lstRedoFormats.begin(); it2 != m_lstRedoFormats.end(); ++it2 )
+ {
+ Cell *cell = sheet->nonDefaultCell( (*it2).col,(*it2).row );
+
+ if ( (*it2).text.isEmpty() )
+ {
+ if(!cell->text().isEmpty())
+ cell->setCellText( "" );
+ }
+ else
+ cell->setCellText( (*it2).text );
+
+ cell->format()->copy( *(*it2).l );
+ cell->setLayoutDirtyFlag();
+ cell->setDisplayDirtyFlag();
+ sheet->updateCell( cell, (*it2).col, (*it2).row );
+ }
+ sheet->setRegionPaintDirty(m_rctRect);
+ sheet->updateView( m_rctRect );
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoDelete
+ *
+ ***************************************************************************/
+
+UndoDelete::UndoDelete( Doc *_doc, Sheet* sheet, const Region& region)
+ : UndoAction( _doc )
+{
+ name=i18n("Delete");
+ m_sheetName = sheet->sheetName();
+ m_region = region;
+ createListCell(m_data, m_lstColumn, m_lstRow, sheet);
+}
+
+UndoDelete::~UndoDelete()
+{
+}
+
+void UndoDelete::createListCell( TQCString &listCell,TQValueList<columnSize> &listCol,TQValueList<rowSize> &listRow, Sheet* sheet )
+{
+ listRow.clear();
+ listCol.clear();
+ Region::ConstIterator endOfList = m_region.constEnd();
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect range = (*it)->rect().normalize();
+ // copy column(s)
+ if ((*it)->isColumn())
+ {
+ for( int y = range.left() ; y <= range.right() ; ++y )
+ {
+ ColumnFormat * cl = sheet->columnFormat( y );
+ if ( !cl->isDefault() )
+ {
+ columnSize tmpSize;
+ tmpSize.columnNumber=y;
+ tmpSize.columnWidth=cl->dblWidth();
+ listCol.append(tmpSize);
+ }
+ }
+ }
+ // copy row(s)
+ else if ((*it)->isRow())
+ {
+ //save size of row(s)
+ for( int y = range.top() ; y <= range.bottom() ; ++y )
+ {
+ RowFormat *rw=sheet->rowFormat(y);
+ if(!rw->isDefault())
+ {
+ rowSize tmpSize;
+ tmpSize.rowNumber=y;
+ tmpSize.rowHeight=rw->dblHeight();
+ listRow.append(tmpSize);
+ }
+ }
+
+ }
+ }
+
+ //save all cells in area
+ TQDomDocument doc = sheet->saveCellRegion( m_region );
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ listCell = buffer.utf8();
+ int len = listCell.length();
+ char tmp = listCell[ len - 1 ];
+ listCell.resize( len );
+ *( listCell.data() + len - 1 ) = tmp;
+}
+
+
+void UndoDelete::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+ createListCell( m_dataRedo, m_lstRedoColumn, m_lstRedoRow, sheet );
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstColumn.begin(); it2 != m_lstColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->nonDefaultColumnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ }
+
+ {
+ TQValueList<rowSize>::Iterator it2;
+ for ( it2 = m_lstRow.begin(); it2 != m_lstRow.end(); ++it2 )
+ {
+ RowFormat *rw=sheet->nonDefaultRowFormat((*it2).rowNumber);
+ rw->setDblHeight((*it2).rowHeight);
+ }
+ }
+
+ sheet->deleteCells(m_region);
+ sheet->paste( m_data, m_region.boundingRect() );
+ sheet->updateView( );
+
+ if(sheet->getAutoCalc()) sheet->recalc();
+
+ doc()->undoUnlock();
+}
+
+void UndoDelete::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstRedoColumn.begin(); it2 != m_lstRedoColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->nonDefaultColumnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ }
+
+ {
+ TQValueList<rowSize>::Iterator it2;
+ for ( it2 = m_lstRedoRow.begin(); it2 != m_lstRedoRow.end(); ++it2 )
+ {
+ RowFormat *rw=sheet->nonDefaultRowFormat((*it2).rowNumber);
+ rw->setDblHeight((*it2).rowHeight);
+ }
+ }
+
+ //move next line to refreshView
+ //because I must know what is the real rect
+ //that I must refresh, when there is cell Merged
+
+ sheet->paste( m_dataRedo, m_region.boundingRect() );
+ //sheet->deleteCells( m_selection );
+ sheet->updateView();
+ sheet->refreshView( m_region ); // deletes the cells in region!
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoDragDrop
+ *
+ ***************************************************************************/
+
+UndoDragDrop::UndoDragDrop( Doc * _doc, Sheet * _sheet,
+ const Region& _source,
+ const Region& _target )
+ : UndoAction( _doc ),
+ m_selectionSource( _source ),
+ m_selectionTarget( _target )
+{
+ name = i18n( "Drag & Drop" );
+
+ m_sheetName = _sheet->sheetName();
+
+ saveCellRect( m_dataTarget, _sheet, _target );
+ saveCellRect( m_dataSource, _sheet, _source );
+}
+
+UndoDragDrop::~UndoDragDrop()
+{
+}
+
+void UndoDragDrop::saveCellRect( TQCString & cells, Sheet * sheet,
+ const Region& region )
+{
+ TQDomDocument doc = sheet->saveCellRegion(region);
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ cells = buffer.utf8();
+ int len = cells.length();
+ char tmp = cells[ len - 1 ];
+ cells.resize( len );
+ *( cells.data() + len - 1 ) = tmp;
+}
+
+void UndoDragDrop::undo()
+{
+ Sheet * sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ saveCellRect( m_dataRedoSource, sheet, m_selectionSource );
+ saveCellRect( m_dataRedoTarget, sheet, m_selectionTarget );
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ sheet->deleteCells( m_selectionTarget );
+ sheet->paste( m_dataTarget, m_selectionTarget.boundingRect() );
+
+ sheet->deleteCells( m_selectionSource );
+ sheet->paste( m_dataSource, m_selectionSource.boundingRect() );
+
+ sheet->updateView();
+
+ if ( sheet->getAutoCalc() )
+ sheet->recalc();
+
+ doc()->undoUnlock();
+}
+
+void UndoDragDrop::redo()
+{
+ Sheet * sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ //move next line to refreshView
+ //because I must know what is the real rect
+ //that I must refresh, when there is cell Merged
+
+ sheet->deleteCells( m_selectionTarget );
+ sheet->paste( m_dataRedoTarget, m_selectionTarget.boundingRect() );
+ sheet->deleteCells( m_selectionSource );
+ sheet->paste( m_dataRedoSource, m_selectionSource.boundingRect() );
+
+ sheet->updateView();
+ if ( sheet->getAutoCalc() )
+ sheet->recalc();
+
+ doc()->undoUnlock();
+}
+
+
+/****************************************************************************
+ *
+ * UndoResizeColRow
+ *
+ ***************************************************************************/
+
+
+UndoResizeColRow::UndoResizeColRow( Doc *_doc, Sheet *_sheet, const Region &_selection ) :
+ UndoAction( _doc )
+{
+ name=i18n("Resize");
+ m_region = _selection;
+ m_sheetName = _sheet->sheetName();
+
+ createList( m_lstColumn,m_lstRow, _sheet );
+}
+
+void UndoResizeColRow::createList( TQValueList<columnSize> &listCol,TQValueList<rowSize> &listRow, Sheet* sheet )
+{
+ listCol.clear();
+ listRow.clear();
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect m_rctRect = (*it)->rect().normalize();
+
+ if( util_isColumnSelected( m_rctRect ) ) // entire column(s)
+ {
+ for( int y = m_rctRect.left(); y <= m_rctRect.right(); y++ )
+ {
+ ColumnFormat *cl=sheet->columnFormat(y);
+ if(!cl->isHide())
+ {
+ columnSize tmpSize;
+ tmpSize.columnNumber=y;
+ tmpSize.columnWidth=cl->dblWidth();
+ listCol.append(tmpSize);
+ }
+ }
+ }
+ else if( util_isRowSelected( m_rctRect ) ) // entire row(s)
+ {
+ for( int y = m_rctRect.top(); y <= m_rctRect.bottom(); y++ )
+ {
+ RowFormat *rw=sheet->rowFormat(y);
+ if(!rw->isHide())
+ {
+ rowSize tmpSize;
+ tmpSize.rowNumber=y;
+ tmpSize.rowHeight=rw->dblHeight();
+ listRow.append(tmpSize);
+ }
+ }
+ }
+ else //row and column
+ {
+ for( int y = m_rctRect.left(); y <= m_rctRect.right(); y++ )
+ {
+ ColumnFormat *cl=sheet->columnFormat(y);
+ if(!cl->isHide())
+ {
+ columnSize tmpSize;
+ tmpSize.columnNumber=y;
+ tmpSize.columnWidth=cl->dblWidth();
+ listCol.append(tmpSize);
+ }
+ }
+ for( int y = m_rctRect.top(); y <= m_rctRect.bottom(); y++ )
+ {
+ RowFormat *rw=sheet->rowFormat(y);
+ if(!rw->isHide())
+ {
+ rowSize tmpSize;
+ tmpSize.rowNumber=y;
+ tmpSize.rowHeight=rw->dblHeight();
+ listRow.append(tmpSize);
+ }
+ }
+
+ }
+ }
+}
+
+UndoResizeColRow::~UndoResizeColRow()
+{
+}
+
+void UndoResizeColRow::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+
+ createList( m_lstRedoColumn,m_lstRedoRow, sheet );
+
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect m_rctRect = (*it)->rect().normalize();
+
+ if( util_isColumnSelected( m_rctRect ) ) // complete column(s)
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstColumn.begin(); it2 != m_lstColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->columnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ }
+ else if( util_isRowSelected( m_rctRect ) ) // complete row(s)
+ {
+ TQValueList<rowSize>::Iterator it2;
+ for ( it2 = m_lstRow.begin(); it2 != m_lstRow.end(); ++it2 )
+ {
+ RowFormat *rw=sheet->rowFormat((*it2).rowNumber);
+ rw->setDblHeight((*it2).rowHeight);
+ }
+ }
+ else // row and column
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstColumn.begin(); it2 != m_lstColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->columnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ TQValueList<rowSize>::Iterator it1;
+ for ( it1 = m_lstRow.begin(); it1 != m_lstRow.end(); ++it1 )
+ {
+ RowFormat *rw=sheet->rowFormat((*it1).rowNumber);
+ rw->setDblHeight((*it1).rowHeight);
+ }
+ }
+ }
+
+ doc()->undoUnlock();
+}
+
+void UndoResizeColRow::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect m_rctRect = (*it)->rect().normalize();
+
+ if( util_isColumnSelected( m_rctRect ) ) // complete column(s)
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstRedoColumn.begin(); it2 != m_lstRedoColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->columnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ }
+ else if( util_isRowSelected( m_rctRect ) ) // complete row(s)
+ {
+ TQValueList<rowSize>::Iterator it2;
+ for ( it2 = m_lstRedoRow.begin(); it2 != m_lstRedoRow.end(); ++it2 )
+ {
+ RowFormat *rw=sheet->rowFormat((*it2).rowNumber);
+ rw->setDblHeight((*it2).rowHeight);
+ }
+ }
+ else // row and column
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstRedoColumn.begin(); it2 != m_lstRedoColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->columnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ TQValueList<rowSize>::Iterator it1;
+ for ( it1 = m_lstRedoRow.begin(); it1 != m_lstRedoRow.end(); ++it1 )
+ {
+ RowFormat *rw=sheet->rowFormat((*it1).rowNumber);
+ rw->setDblHeight((*it1).rowHeight);
+ }
+ }
+ }
+
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoChangeAreaTextCell
+ *
+ ***************************************************************************/
+
+
+UndoChangeAreaTextCell::UndoChangeAreaTextCell( Doc *_doc, Sheet *_sheet, const Region &_selection ) :
+ UndoAction( _doc )
+{
+ name=i18n("Change Text");
+
+ m_region = _selection;
+ m_sheetName = _sheet->sheetName();
+
+ createList( m_lstTextCell, _sheet );
+}
+
+void UndoChangeAreaTextCell::createList( TQMap<TQPoint,TQString> &map, Sheet* sheet )
+{
+ map.clear();
+
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect m_rctRect = (*it)->rect().normalize();
+ int bottom = m_rctRect.bottom();
+ int right = m_rctRect.right();
+
+ if( util_isColumnSelected( m_rctRect ) )
+ {
+ Cell * c;
+ for ( int col = m_rctRect.left(); col <= right; ++col )
+ {
+ c = sheet->getFirstCellColumn( col );
+ while ( c )
+ {
+ if ( !c->isPartOfMerged() )
+ {
+ //textOfCell tmpText;
+ //tmpText.col = col;
+ //tmpText.row = c->row();
+ //tmpText.text = c->text();
+ map.insert( TQPoint(col,c->row()) , c->text() );
+ }
+ c = sheet->getNextCellDown( col, c->row() );
+ }
+ }
+ }
+ else if ( util_isRowSelected( m_rctRect ) )
+ {
+ Cell * c;
+ for ( int row = m_rctRect.top(); row <= bottom; ++row )
+ {
+ c = sheet->getFirstCellRow( row );
+ while ( c )
+ {
+ if ( !c->isPartOfMerged() )
+ {
+ //textOfCell tmpText;
+ //tmpText.col = c->column();
+ //tmpText.row = row;
+ //tmpText.text = c->text();
+ map.insert( TQPoint(c->column(),row) , c->text() );
+ }
+ c = sheet->getNextCellRight( c->column(), row );
+ }
+ }
+ }
+ else
+ {
+ Cell * cell;
+ for ( int x = m_rctRect.left(); x <= right; ++x )
+ {
+ cell = sheet->getFirstCellColumn( x );
+ if ( !cell )
+ continue;
+ while ( cell && cell->row() <= bottom )
+ {
+ if ( !cell->isObscured() )
+ {
+ //textOfCell tmpText;
+ //tmpText.col = x;
+ //tmpText.row = cell->row();
+ //tmpText.text = cell->text();
+ map.insert( TQPoint(x,cell->row()) , cell->text());
+ }
+ cell = sheet->getNextCellDown( x, cell->row() );
+ }
+ }
+ }
+ }
+}
+
+UndoChangeAreaTextCell::~UndoChangeAreaTextCell()
+{
+}
+
+void UndoChangeAreaTextCell::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+ sheet->setRegionPaintDirty(m_region);
+
+ kdDebug() << "creating redo list..." << endl;
+ createList( m_lstRedoTextCell, sheet );
+ kdDebug() << "created redo list..." << endl;
+
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect m_rctRect = (*it)->rect().normalize();
+
+ if ( !util_isRowSelected( m_rctRect )
+ && !util_isColumnSelected( m_rctRect ) )
+ {
+ for ( int x = m_rctRect.left(); x <= m_rctRect.right(); ++x )
+ for ( int y = m_rctRect.top(); y <= m_rctRect.bottom(); ++y )
+ {
+ Cell* cell = sheet->nonDefaultCell( x, y );
+
+ const TQPoint location(x,y);
+
+ if ( m_lstTextCell.contains(location) )
+ cell->setCellText( m_lstTextCell[location] );
+ else
+ cell->setCellText( "",true );
+
+ /*bool found = false;
+ TQValueList<textOfCell>::Iterator it;
+ for( it = m_lstTextCell.begin(); it != m_lstTextCell.end(); ++it )
+ if ( (*it).col == x && (*it).row == y && !found )
+ {
+ cell->setCellText( (*it).text );
+ found = true;
+ }
+ if( !found )
+ cell->setCellText( "", true );*/
+ }
+
+ }
+ else
+ {
+ TQMap<TQPoint,TQString>::Iterator it2;
+ for ( it2 = m_lstTextCell.begin(); it2 != m_lstTextCell.end(); ++it2 )
+ {
+ Cell *cell = sheet->nonDefaultCell( it2.key().x(), it2.key().y() );
+ if ( it2.data().isEmpty() )
+ {
+ if ( !cell->text().isEmpty() )
+ cell->setCellText( "" );
+ }
+ else
+ cell->setCellText( it2.data() );
+ }
+ }
+ }
+
+ //sheet->updateView();
+ doc()->emitEndOperation();
+ doc()->undoUnlock();
+}
+
+void UndoChangeAreaTextCell::redo()
+{
+ Sheet * sheet = doc()->map()->findSheet( m_sheetName );
+
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+ sheet->setRegionPaintDirty(m_region);
+
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect m_rctRect = (*it)->rect().normalize();
+
+ if ( !util_isRowSelected( m_rctRect )
+ && !util_isColumnSelected( m_rctRect ) )
+ {
+ for ( int x = m_rctRect.left(); x <= m_rctRect.right(); ++x )
+ for ( int y = m_rctRect.top(); y <= m_rctRect.bottom(); ++y )
+ {
+ Cell* cell = sheet->nonDefaultCell( x, y );
+
+ const TQPoint location(x,y);
+
+ if (m_lstRedoTextCell.contains(location))
+ cell->setCellText( m_lstRedoTextCell[location] );
+ else
+ cell->setCellText( "" , true );
+ /*bool found = false;
+ TQValueList<textOfCell>::Iterator it;
+ for( it = m_lstRedoTextCell.begin(); it != m_lstRedoTextCell.end(); ++it )
+ if ( (*it).col == x && (*it).row == y && !found )
+ {
+ cell->setCellText( (*it).text );
+ found = true;
+ }
+ if( !found )
+ cell->setCellText( "", true );*/
+ }
+
+ }
+ else
+ {
+ TQMap<TQPoint,TQString>::Iterator it2;
+ for ( it2 = m_lstRedoTextCell.begin(); it2 != m_lstRedoTextCell.end(); ++it2 )
+ {
+ Cell *cell = sheet->nonDefaultCell( it2.key().x(), it2.key().y() );
+ if ( it2.data().isEmpty() )
+ {
+ if ( !cell->text().isEmpty() )
+ cell->setCellText( "" );
+ }
+ else
+ cell->setCellText( it2.data() );
+ }
+ }
+ }
+
+ //sheet->updateView();
+ doc()->emitEndOperation();
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoMergedCell
+ *
+ ***************************************************************************/
+
+
+UndoMergedCell::UndoMergedCell( Doc *_doc, Sheet *_sheet, int _column, int _row , int _extraX,int _extraY) :
+ UndoAction( _doc )
+{
+ name=i18n("Merge Cells");
+
+ m_sheetName = _sheet->sheetName();
+ m_iRow=_row;
+ m_iCol=_column;
+ m_iExtraX=_extraX;
+ m_iExtraY=_extraY;
+
+}
+
+UndoMergedCell::~UndoMergedCell()
+{
+}
+
+void UndoMergedCell::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+
+ Cell *cell = sheet->nonDefaultCell( m_iCol, m_iRow );
+ m_iExtraRedoX=cell->extraXCells();
+ m_iExtraRedoY=cell->extraYCells();
+
+ sheet->changeMergedCell( m_iCol, m_iRow, m_iExtraX,m_iExtraY);
+
+ doc()->undoUnlock();
+}
+
+void UndoMergedCell::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+
+ sheet->changeMergedCell( m_iCol, m_iRow, m_iExtraRedoX,m_iExtraRedoY);
+
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoAutofill
+ *
+ ***************************************************************************/
+
+UndoAutofill::UndoAutofill( Doc *_doc, Sheet* sheet, const TQRect & _selection)
+ : UndoAction( _doc )
+{
+ name=i18n("Autofill");
+
+ m_sheetName = sheet->sheetName();
+ m_selection = _selection;
+ createListCell( m_data, sheet );
+
+}
+
+UndoAutofill::~UndoAutofill()
+{
+}
+
+void UndoAutofill::createListCell( TQCString &list, Sheet* sheet )
+{
+ TQDomDocument doc = sheet->saveCellRegion( m_selection );
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ list = buffer.utf8();
+ int len = list.length();
+ char tmp = list[ len - 1 ];
+ list.resize( len );
+ *( list.data() + len - 1 ) = tmp;
+}
+
+void UndoAutofill::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ createListCell( m_dataRedo, sheet );
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ sheet->deleteCells( m_selection );
+ sheet->paste( m_data, m_selection );
+ //if(sheet->getAutoCalc()) sheet->recalc();
+
+ doc()->emitEndOperation();
+ //sheet->updateView();
+
+ doc()->undoUnlock();
+}
+
+void UndoAutofill::redo()
+{
+ doc()->undoLock();
+
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->emitBeginOperation();
+
+ sheet->deleteCells( m_selection );
+ doc()->undoLock();
+ sheet->paste( m_dataRedo, m_selection );
+ if ( sheet->getAutoCalc() )
+ sheet->recalc();
+ sheet->updateView();
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoInsertCellRow
+ *
+ ***************************************************************************/
+
+UndoInsertCellRow::UndoInsertCellRow( Doc *_doc, Sheet *_sheet, const TQRect &_rect ) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Insert Cell");
+
+ m_sheetName = _sheet->sheetName();
+ m_rect=_rect;
+}
+
+UndoInsertCellRow::~UndoInsertCellRow()
+{
+}
+
+void UndoInsertCellRow::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->unshiftRow( m_rect);
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoInsertCellRow::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->shiftRow( m_rect);
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoInsertCellCol
+ *
+ ***************************************************************************/
+
+
+UndoInsertCellCol::UndoInsertCellCol( Doc *_doc, Sheet *_sheet, const TQRect &_rect ) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Insert Cell");
+
+ m_sheetName = _sheet->sheetName();
+ m_rect=_rect;
+}
+
+UndoInsertCellCol::~UndoInsertCellCol()
+{
+}
+
+void UndoInsertCellCol::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->unshiftColumn( m_rect);
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoInsertCellCol::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->shiftColumn( m_rect );
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoRemoveCellRow
+ *
+ ***************************************************************************/
+
+UndoRemoveCellRow::UndoRemoveCellRow( Doc *_doc, Sheet *_sheet, const TQRect &rect ) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Remove Cell");
+
+ m_sheetName = _sheet->sheetName();
+ m_rect=rect;
+ TQDomDocument doc = _sheet->saveCellRegion( m_rect );
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ m_data = buffer.utf8();
+ int len = m_data.length();
+ char tmp = m_data[ len - 1 ];
+ m_data.resize( len );
+ *( m_data.data() + len - 1 ) = tmp;
+}
+
+UndoRemoveCellRow::~UndoRemoveCellRow()
+{
+}
+
+void UndoRemoveCellRow::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->shiftRow( m_rect );
+ sheet->paste( m_data, m_rect );
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoRemoveCellRow::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->unshiftRow( m_rect);
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoRemoveCellCol
+ *
+ ***************************************************************************/
+
+UndoRemoveCellCol::UndoRemoveCellCol( Doc *_doc, Sheet *_sheet, const TQRect &_rect ) :
+ UndoInsertRemoveAction( _doc )
+{
+ name=i18n("Remove Cell");
+
+ m_sheetName = _sheet->sheetName();
+ m_rect=_rect;
+ TQDomDocument doc = _sheet->saveCellRegion( m_rect );
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ m_data = buffer.utf8();
+ int len = m_data.length();
+ char tmp = m_data[ len - 1 ];
+ m_data.resize( len );
+ *( m_data.data() + len - 1 ) = tmp;
+}
+
+UndoRemoveCellCol::~UndoRemoveCellCol()
+{
+}
+
+void UndoRemoveCellCol::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->shiftColumn( m_rect );
+ sheet->paste( m_data, m_rect );
+ doc()->undoUnlock();
+
+ undoFormulaReference();
+}
+
+void UndoRemoveCellCol::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->unshiftColumn( m_rect );
+ doc()->undoUnlock();
+}
+
+/****************************************************************************
+ *
+ * UndoConditional
+ *
+ ***************************************************************************/
+
+UndoConditional::UndoConditional( Doc *_doc, Sheet* sheet, const Region & _selection)
+ : UndoAction( _doc )
+{
+ name=i18n("Conditional Cell Attribute");
+
+ m_sheetName = sheet->sheetName();
+ m_region = _selection;
+ createListCell( m_data, sheet );
+
+}
+
+UndoConditional::~UndoConditional()
+{
+}
+
+void UndoConditional::createListCell( TQCString &list, Sheet* sheet )
+{
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+
+ TQDomDocument doc = sheet->saveCellRegion( m_region );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ list = buffer.utf8();
+ int len = list.length();
+ char tmp = list[ len - 1 ];
+ list.resize( len );
+ *( list.data() + len - 1 ) = tmp;
+}
+
+void UndoConditional::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ createListCell( m_dataRedo, sheet );
+
+ doc()->undoLock();
+ sheet->paste(m_data, m_region.boundingRect());
+ if (sheet->getAutoCalc())
+ {
+ sheet->recalc();
+ }
+
+ doc()->undoUnlock();
+}
+
+void UndoConditional::redo()
+{
+ doc()->undoLock();
+
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ sheet->paste(m_dataRedo, m_region.boundingRect());
+ if (sheet->getAutoCalc())
+ {
+ sheet->recalc();
+ }
+
+ doc()->undoUnlock();
+}
+
+
+/****************************************************************************
+ *
+ * UndoCellPaste
+ *
+ ***************************************************************************/
+
+UndoCellPaste::UndoCellPaste(Doc *_doc, Sheet* sheet,
+ int _xshift, int _yshift,
+ const Region& region, bool insert, int _insertTo)
+ : UndoAction( _doc )
+{
+ if(!insert)
+ name=i18n("Paste");
+ else
+ name=i18n("Paste & Insert");
+
+ m_sheetName = sheet->sheetName();
+ m_region = region;
+ xshift=_xshift;
+ yshift=_yshift;
+ b_insert=insert;
+ m_iInsertTo=_insertTo;
+ if( !b_insert)
+ createListCell( m_data, m_lstColumn,m_lstRow,sheet );
+
+}
+
+UndoCellPaste::~UndoCellPaste()
+{
+}
+
+void UndoCellPaste::createListCell(TQCString& listCell,
+ TQValueList<columnSize>& listCol,
+ TQValueList<rowSize>& listRow,
+ Sheet* sheet)
+{
+ listCol.clear();
+ listRow.clear();
+
+ Region::ConstIterator endOfList = m_region.constEnd();
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ int nbCol = 0;
+ int nbRow = 0;
+ TQRect range = (*it)->rect().normalize();
+ if ((*it)->isColumn())
+ {
+ nbCol = range.width();
+ }
+ else if ((*it)->isRow())
+ {
+ nbRow = range.height();
+ }
+
+ // copy column(s)
+ if (nbCol != 0)
+ {
+ //save size of columns
+ for( int y = 1; y <=nbCol ; ++y )
+ {
+ ColumnFormat *cl=sheet->columnFormat(y);
+ if(!cl->isDefault())
+ {
+ columnSize tmpSize;
+ tmpSize.columnNumber=y;
+ tmpSize.columnWidth=cl->dblWidth();
+ listCol.append(tmpSize);
+ }
+ }
+ }
+ //copy a row(s)
+ else if (nbRow != 0)
+ {
+ //save size of columns
+ for ( int y = 1; y <=nbRow ; ++y )
+ {
+ RowFormat *rw=sheet->rowFormat(y);
+ if (!rw->isDefault())
+ {
+ rowSize tmpSize;
+ tmpSize.rowNumber=y;
+ tmpSize.rowHeight=rw->dblHeight();
+ listRow.append(tmpSize);
+ }
+ }
+ }
+ }
+ //save all cells in area
+ TQDomDocument doc = sheet->saveCellRegion(m_region);
+ // Save to buffer
+ TQString buffer;
+ TQTextStream str( &buffer, IO_WriteOnly );
+ str << doc;
+
+ // This is a terrible hack to store unicode
+ // data in a TQCString in a way that
+ // TQCString::length() == TQCString().size().
+ // This allows us to treat the TQCString like a TQByteArray later on.
+ listCell = buffer.utf8();
+ int len = listCell.length();
+ char tmp = listCell[ len - 1 ];
+ listCell.resize( len );
+ *( listCell.data() + len - 1 ) = tmp;
+}
+
+void UndoCellPaste::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ createListCell( m_dataRedo, m_lstRedoColumn, m_lstRedoRow, sheet );
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ uint numCols = 0;
+ uint numRows = 0;
+
+ Region::ConstIterator endOfList = m_region.constEnd();
+ for (Region::ConstIterator it = --m_region.constEnd(); it != endOfList; --it)
+ {
+ TQRect range = (*it)->rect().normalize();
+
+ if ((*it)->isColumn())
+ {
+ if (!b_insert)
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstColumn.begin(); it2 != m_lstColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->nonDefaultColumnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ }
+ else
+ {
+ numCols += range.width();
+ }
+ }
+ else if ((*it)->isRow())
+ {
+ if (!b_insert)
+ {
+ TQValueList<rowSize>::Iterator it2;
+ for ( it2 = m_lstRow.begin(); it2 != m_lstRow.end(); ++it2 )
+ {
+ RowFormat *rw=sheet->nonDefaultRowFormat((*it2).rowNumber);
+ rw->setDblHeight((*it2).rowHeight);
+ }
+ }
+ else
+ {
+ numRows += range.height();
+ }
+ }
+
+ if (!b_insert)
+ {
+ sheet->deleteCells(range);
+ }
+ } // for (Region::...
+
+ if (b_insert) // with insertion
+ {
+ TQRect rect = m_region.boundingRect();
+ if (m_iInsertTo == -1 && numCols == 0 && numRows == 0)
+ {
+ // substract already removed columns
+ rect.setWidth(rect.width());
+ sheet->unshiftRow(rect);
+ }
+ else if (m_iInsertTo == 1 && numCols == 0 && numRows == 0)
+ {
+ // substract already removed rows
+ rect.setHeight(rect.height());
+ sheet->unshiftColumn(rect);
+ }
+ // delete columns
+ else if (m_iInsertTo == 0 && numCols == 0 && numRows > 0)
+ {
+ sheet->removeRow(rect.top(), rect.height() - 1, false);
+ }
+ // delete rows
+ else if (m_iInsertTo == 0 && numCols > 0 && numRows == 0)
+ {
+ sheet->removeColumn(rect.left(), rect.width() - 1, false);
+ }
+ }
+ else // without insertion
+ {
+ sheet->paste(m_data, m_region.boundingRect());
+ }
+
+ if (sheet->getAutoCalc())
+ {
+ sheet->recalc();
+ }
+ sheet->updateView();
+ doc()->undoUnlock();
+}
+
+void UndoCellPaste::redo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ uint numCols = 0;
+ uint numRows = 0;
+
+ Region::ConstIterator endOfList(m_region.constEnd());
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ TQRect range = (*it)->rect().normalize();
+
+ if ((*it)->isColumn())
+ {
+ numCols += range.width();
+ }
+ else if ((*it)->isRow())
+ {
+ numRows += range.height();
+ }
+ else
+ {
+ if (!b_insert)
+ {
+ sheet->deleteCells( range );
+ }
+ }
+ } // for (Region::...
+
+ if (b_insert)
+ {
+ TQRect rect = m_region.boundingRect();
+ if (m_iInsertTo == -1 && numCols == 0 && numRows == 0)
+ {
+ rect.setWidth(rect.width());
+ sheet->shiftRow(rect);
+ }
+ else if (m_iInsertTo == 1 && numCols == 0 && numRows == 0)
+ {
+ rect.setHeight(rect.height());
+ sheet->shiftColumn(rect);
+ }
+ // insert columns
+ else if (m_iInsertTo == 0 && numCols == 0 && numRows > 0)
+ {
+ sheet->insertRow(rect.top(), rect.height() - 1, false);
+ }
+ // insert rows
+ else if (m_iInsertTo == 0 && numCols > 0 && numRows == 0)
+ {
+ sheet->insertColumn(rect.left(), rect.width() - 1, false);
+ }
+ }
+
+ for (Region::ConstIterator it = m_region.constBegin(); it != endOfList; ++it)
+ {
+ if ((*it)->isColumn())
+ {
+ TQValueList<columnSize>::Iterator it2;
+ for ( it2 = m_lstRedoColumn.begin(); it2 != m_lstRedoColumn.end(); ++it2 )
+ {
+ ColumnFormat *cl=sheet->nonDefaultColumnFormat((*it2).columnNumber);
+ cl->setDblWidth((*it2).columnWidth);
+ }
+ }
+ else if ((*it)->isRow())
+ {
+ TQValueList<rowSize>::Iterator it2;
+ for ( it2 = m_lstRedoRow.begin(); it2 != m_lstRedoRow.end(); ++it2 )
+ {
+ RowFormat *rw=sheet->nonDefaultRowFormat((*it2).rowNumber);
+ rw->setDblHeight((*it2).rowHeight);
+ }
+ }
+ } // for (Region::...
+
+ sheet->paste( m_dataRedo, m_region.boundingRect() );
+
+ if (sheet->getAutoCalc())
+ {
+ sheet->recalc();
+ }
+
+ sheet->updateView();
+ doc()->undoUnlock();
+}
+
+
+/****************************************************************************
+ *
+ * UndoStyleCell
+ *
+ ***************************************************************************/
+
+UndoStyleCell::UndoStyleCell( Doc *_doc, Sheet* sheet, const TQRect & _selection)
+ : UndoAction( _doc )
+{
+ name=i18n("Style of Cell");
+
+ m_sheetName = sheet->sheetName();
+ m_selection = _selection;
+ createListCell( m_lstStyleCell, sheet );
+
+}
+
+UndoStyleCell::~UndoStyleCell()
+{
+}
+
+void UndoStyleCell::createListCell( TQValueList<styleCell> &listCell, Sheet* sheet )
+{
+ int bottom = m_selection.bottom();
+ int right = m_selection.right();
+ if ( util_isColumnSelected( m_selection ) )
+ {
+ Cell * c;
+ for ( int col = m_selection.left(); col <= right; ++ col )
+ {
+ c = sheet->getFirstCellColumn( col );
+ while ( c )
+ {
+ if ( !c->isPartOfMerged() )
+ {
+ styleCell tmpStyleCell;
+ tmpStyleCell.row = c->row();
+ tmpStyleCell.col = col;
+ listCell.append(tmpStyleCell);
+ }
+ c = sheet->getNextCellDown( col, c->row() );
+ }
+ }
+ }
+ else if ( util_isRowSelected( m_selection ) )
+ {
+ Cell * c;
+ for ( int row = m_selection.top(); row <= bottom; ++row )
+ {
+ c = sheet->getFirstCellRow( row );
+ while ( c )
+ {
+ if ( !c->isPartOfMerged() )
+ {
+ styleCell tmpStyleCell;
+ tmpStyleCell.row = row;
+ tmpStyleCell.col = c->column();
+ listCell.append(tmpStyleCell);
+ }
+ c = sheet->getNextCellRight( c->column(), row );
+ }
+ }
+ }
+ else
+ {
+ Cell * cell;
+ for ( int i = m_selection.top(); i <= bottom; ++i)
+ for ( int j = m_selection.left(); j <= right; ++j )
+ {
+ cell = sheet->nonDefaultCell( j, i);
+ styleCell tmpStyleCell;
+ tmpStyleCell.row = i;
+ tmpStyleCell.col = j;
+ listCell.append(tmpStyleCell);
+ }
+ }
+}
+
+void UndoStyleCell::undo()
+{
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ createListCell( m_lstRedoStyleCell, sheet );
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+
+ TQValueList<styleCell>::Iterator it2;
+ for ( it2 = m_lstStyleCell.begin(); it2 != m_lstStyleCell.end(); ++it2 )
+ {
+ sheet->nonDefaultCell( (*it2).col, (*it2).row);
+ }
+ sheet->setRegionPaintDirty(m_selection);
+ sheet->updateView( m_selection );
+ doc()->undoUnlock();
+}
+
+void UndoStyleCell::redo()
+{
+ doc()->undoLock();
+
+ Sheet* sheet = doc()->map()->findSheet( m_sheetName );
+ if ( !sheet )
+ return;
+
+ doc()->undoLock();
+ doc()->emitBeginOperation();
+
+ TQValueList<styleCell>::Iterator it2;
+ for ( it2 = m_lstRedoStyleCell.begin(); it2 != m_lstRedoStyleCell.end(); ++it2 )
+ {
+ sheet->nonDefaultCell( (*it2).col, (*it2).row);
+ }
+ sheet->setRegionPaintDirty(m_selection);
+ sheet->updateView();
+
+ doc()->undoUnlock();
+}
+
+UndoInsertData::UndoInsertData( Doc * _doc, Sheet * _sheet, TQRect & _selection )
+ : UndoChangeAreaTextCell( _doc, _sheet, _selection )
+{
+ name = i18n("Insert Data From Database");
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-01 09:42:36 +0000