選択できるのは25トピックまでです。
トピックは、先頭が英数字で、英数字とダッシュ('-')を使用した35文字以内のものにしてください。
3002 行
75 KiB
3002 行
75 KiB
/* 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 tqunicode
|
|
// 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 tqunicode
|
|
// 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 tmptqlayout;
|
|
tmptqlayout.col = i;
|
|
tmptqlayout.l = new ColumnFormat( sheet, i );
|
|
tmptqlayout.l->copy( *(sheet->columnFormat( i )) );
|
|
listCol.append(tmptqlayout);
|
|
}
|
|
*/
|
|
for ( int c = range.left(); c <= right; ++c )
|
|
{
|
|
layoutColumn tmptqlayout;
|
|
tmptqlayout.col = c;
|
|
tmptqlayout.l = new ColumnFormat( sheet, c );
|
|
tmptqlayout.l->copy( *(sheet->columnFormat( c )) );
|
|
listCol.append(tmptqlayout);
|
|
|
|
cell = sheet->getFirstCellColumn( c );
|
|
while ( cell )
|
|
{
|
|
if ( cell->isPartOfMerged() )
|
|
{
|
|
cell = sheet->getNextCellDown( c, cell->row() );
|
|
continue;
|
|
}
|
|
|
|
layoutCell tmptqlayout;
|
|
tmptqlayout.col = c;
|
|
tmptqlayout.row = cell->row();
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( tmptqlayout.col, tmptqlayout.row )->format()) );
|
|
list.append(tmptqlayout);
|
|
|
|
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 tmptqlayout;
|
|
tmptqlayout.col = c->column();
|
|
tmptqlayout.row = c->row();
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( tmptqlayout.col, tmptqlayout.row )) );
|
|
list.append(tmptqlayout);
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
else if (util_isRowSelected( range ) )
|
|
{
|
|
for ( int row = range.top(); row <= bottom; ++row )
|
|
{
|
|
layoutRow tmptqlayout;
|
|
tmptqlayout.row = row;
|
|
tmptqlayout.l = new RowFormat( sheet, row );
|
|
tmptqlayout.l->copy( *(sheet->rowFormat( row )) );
|
|
listRow.append(tmptqlayout);
|
|
|
|
cell = sheet->getFirstCellRow( row );
|
|
while ( cell )
|
|
{
|
|
if ( cell->isPartOfMerged() )
|
|
{
|
|
cell = sheet->getNextCellRight( cell->column(), row );
|
|
continue;
|
|
}
|
|
layoutCell tmptqlayout;
|
|
tmptqlayout.col = cell->column();
|
|
tmptqlayout.row = row;
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( cell->column(), row )->format()) );
|
|
list.append(tmptqlayout);
|
|
|
|
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 tmptqlayout;
|
|
tmptqlayout.col = c->column();
|
|
tmptqlayout.row = c->row();
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( tmptqlayout.col, tmptqlayout.row )) );
|
|
list.append(tmptqlayout);
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
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 tmptqlayout;
|
|
tmptqlayout.col = x;
|
|
tmptqlayout.row = y;
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( x, y )->format()) );
|
|
list.append(tmptqlayout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 tmptqlayout;
|
|
tmptqlayout.col = col;
|
|
tmptqlayout.l = new ColumnFormat( sheet, col );
|
|
tmptqlayout.l->copy( *(sheet->columnFormat( col )) );
|
|
listCol.append(tmptqlayout);
|
|
|
|
c = sheet->getFirstCellColumn( col );
|
|
while ( c )
|
|
{
|
|
if ( !c->isPartOfMerged() )
|
|
{
|
|
layoutTextCell tmptqlayout;
|
|
tmptqlayout.col = col;
|
|
tmptqlayout.row = c->row();
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( tmptqlayout.col, tmptqlayout.row )->format()) );
|
|
tmptqlayout.text = c->text();
|
|
list.append(tmptqlayout);
|
|
}
|
|
|
|
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 tmptqlayout;
|
|
tmptqlayout.row = row;
|
|
tmptqlayout.l = new RowFormat( sheet, row );
|
|
tmptqlayout.l->copy( *(sheet->rowFormat( row )) );
|
|
listRow.append(tmptqlayout);
|
|
|
|
c = sheet->getFirstCellRow( row );
|
|
while ( c )
|
|
{
|
|
if ( !c->isPartOfMerged() )
|
|
{
|
|
layoutTextCell tmptqlayout;
|
|
tmptqlayout.col = c->column();
|
|
tmptqlayout.row = row;
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( tmptqlayout.col, tmptqlayout.row )->format()) );
|
|
tmptqlayout.text = c->text();
|
|
list.append(tmptqlayout);
|
|
}
|
|
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 tmptqlayout;
|
|
tmptqlayout.col = x;
|
|
tmptqlayout.row = y;
|
|
tmptqlayout.l = new Format( sheet, 0 );
|
|
tmptqlayout.l->copy( *(sheet->cellAt( x, y )->format()) );
|
|
tmptqlayout.text = cell->text();
|
|
list.append(tmptqlayout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 tqunicode
|
|
// 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 tqunicode
|
|
// 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 tqunicode
|
|
// 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 tqunicode
|
|
// 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 tqunicode
|
|
// 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 tqunicode
|
|
// 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");
|
|
}
|