summaryrefslogtreecommitdiffstats
path: root/kspread/kspread_autofill.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kspread/kspread_autofill.cpp')
-rw-r--r--kspread/kspread_autofill.cpp1217
1 files changed, 1217 insertions, 0 deletions
diff --git a/kspread/kspread_autofill.cpp b/kspread/kspread_autofill.cpp
new file mode 100644
index 00000000..e110e1ad
--- /dev/null
+++ b/kspread/kspread_autofill.cpp
@@ -0,0 +1,1217 @@
+/* This file is part of the KDE project
+
+ Copyright 2005 Raphael Langerhorst <raphael.langerhorst@kdemail.net>
+ Copyright 2002-2004 Ariya Hidayat <ariya@kde.org>
+ Copyright 2002-2003 Norbert Andres <nandres@web.de>
+ Copyright 2002 John Dailey <dailey@vt.edu>
+ Copyright 2001-2002 Philipp Mueller <philipp.mueller@gmx.de>
+ Copyright 2000-2002 Laurent Montel <montel@kde.org>
+ Copyright 2000-2001 Werner Trobin <trobin@kde.org>
+ Copyright 1999-2001 David Faure <faure@kde.org>
+ Copyright 1998-2000 Torben Weis <weis@kde.org>
+ Copyright 1998-1999 Stephan Kulow <coolo@kde.org>
+ Copyright 1998 Reginald Stadlbauer <reggie@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 <math.h>
+
+#include <tqregexp.h>
+
+#include <tdeconfig.h>
+#include <kdebug.h>
+
+#include "kspread_doc.h"
+#include "kspread_locale.h"
+#include "kspread_sheet.h"
+#include "kspread_undo.h"
+#include "kspread_value.h"
+#include "valueconverter.h"
+#include "kspread_autofill.h"
+
+using namespace KSpread;
+
+TQStringList *AutoFillSequenceItem::month = 0L;
+TQStringList *AutoFillSequenceItem::shortMonth = 0L;
+TQStringList *AutoFillSequenceItem::day = 0L;
+TQStringList *AutoFillSequenceItem::shortDay = 0L;
+TQStringList *AutoFillSequenceItem::other = 0L;
+/**********************************************************************************
+ *
+ * AutoFillDeltaSequence
+ *
+ **********************************************************************************/
+
+AutoFillDeltaSequence::AutoFillDeltaSequence( AutoFillSequence *_first, AutoFillSequence *_next )
+ : m_ok(true),
+ m_sequence(0L)
+{
+ if ( _first->count() != _next->count() )
+ {
+ m_ok = false;
+ return;
+ }
+
+ m_sequence = new TQMemArray<double> ( _first->count() );
+
+ AutoFillSequenceItem *item = _first->getFirst();
+ AutoFillSequenceItem *item2 = _next->getFirst();
+ int i = 0;
+ // for( item = _first->getFirst(); item != 0L && item2 != 0L; item = _first->getNext() );
+ for ( i = 0; i < _first->count(); i++ )
+ {
+ double d;
+ if ( !item->getDelta( item2, d ) )
+ {
+ m_ok = false;
+ return;
+ }
+ m_sequence->at( i++ ) = d;
+ item2 = _next->getNext();
+ item = _first->getNext();
+ }
+}
+
+AutoFillDeltaSequence::~AutoFillDeltaSequence()
+{
+ delete m_sequence;
+}
+
+bool AutoFillDeltaSequence::equals( AutoFillDeltaSequence *_delta )
+{
+ if ( m_sequence == 0L )
+ return false;
+ if ( _delta->getSequence() == 0L )
+ return false;
+ if ( m_sequence->size() != _delta->getSequence()->size() )
+ return false;
+
+ for ( unsigned int i = 0; i < m_sequence->size(); i++ )
+ {
+ if ( m_sequence->at( i ) != _delta->getSequence()->at( i ) )
+ return false;
+ }
+
+ return true;
+}
+
+double AutoFillDeltaSequence::getItemDelta( int _pos )
+{
+ if ( m_sequence == 0L )
+ return 0.0;
+
+ return m_sequence->at( _pos );
+}
+
+/**********************************************************************************
+ *
+ * AutoFillSequenceItem
+ *
+ **********************************************************************************/
+
+AutoFillSequenceItem::AutoFillSequenceItem( int _i )
+{
+ m_IValue = _i;
+ m_Type = INTEGER;
+}
+
+AutoFillSequenceItem::AutoFillSequenceItem( double _d )
+{
+ m_DValue = _d;
+ m_Type = FLOAT;
+}
+
+AutoFillSequenceItem::AutoFillSequenceItem( const TQString &_str )
+{
+ m_String = _str;
+ m_Type = STRING;
+
+ if ( month == 0L )
+ {
+ month = new TQStringList();
+ month->append( i18n("January") );
+ month->append( i18n("February") );
+ month->append( i18n("March") );
+ month->append( i18n("April") );
+ month->append( i18n("May") );
+ month->append( i18n("June") );
+ month->append( i18n("July") );
+ month->append( i18n("August") );
+ month->append( i18n("September") );
+ month->append( i18n("October") );
+ month->append( i18n("November") );
+ month->append( i18n("December") );
+ }
+
+ if ( shortMonth == 0L )
+ {
+ shortMonth = new TQStringList();
+ shortMonth->append( i18n("Jan") );
+ shortMonth->append( i18n("Feb") );
+ shortMonth->append( i18n("Mar") );
+ shortMonth->append( i18n("Apr") );
+ shortMonth->append( i18n("May short", "May") );
+ shortMonth->append( i18n("Jun") );
+ shortMonth->append( i18n("Jul") );
+ shortMonth->append( i18n("Aug") );
+ shortMonth->append( i18n("Sep") );
+ shortMonth->append( i18n("Oct") );
+ shortMonth->append( i18n("Nov") );
+ shortMonth->append( i18n("Dec") );
+ }
+
+ if ( day == 0L )
+ {
+ day = new TQStringList();
+ day->append( i18n("Monday") );
+ day->append( i18n("Tuesday") );
+ day->append( i18n("Wednesday") );
+ day->append( i18n("Thursday") );
+ day->append( i18n("Friday") );
+ day->append( i18n("Saturday") );
+ day->append( i18n("Sunday") );
+ }
+
+ if ( shortDay == 0L )
+ {
+ shortDay = new TQStringList();
+ shortDay->append( i18n("Mon") );
+ shortDay->append( i18n("Tue") );
+ shortDay->append( i18n("Wed") );
+ shortDay->append( i18n("Thu") );
+ shortDay->append( i18n("Fri") );
+ shortDay->append( i18n("Sat") );
+ shortDay->append( i18n("Sun") );
+ }
+
+ if( other==0L)
+ {
+ // other=new TQStringList();
+ TDEConfig *config = Factory::global()->config();
+ config->setGroup( "Parameters" );
+ other=new TQStringList(config->readListEntry("Other list"));
+ }
+
+ if ( month->find( _str ) != month->end() )
+ {
+ m_Type = MONTH;
+ return;
+ }
+
+ if ( shortMonth->find( _str ) != shortMonth->end() )
+ {
+ m_Type = SHORTMONTH;
+ return;
+ }
+
+ if ( day->find( _str ) != day->end() )
+ {
+ m_Type = DAY;
+ return;
+ }
+
+ if ( shortDay->find( _str ) != shortDay->end() )
+ {
+ m_Type = SHORTDAY;
+ return;
+ }
+
+ if( other->find(_str)!=other->end())
+ {
+ m_Type = OTHER;
+ m_OtherBegin=0;
+ m_OtherEnd=other->count();
+ int index= other->findIndex(_str);
+ //find end and begin of qstringlist of other.
+ for ( TQStringList::Iterator it = other->find(_str); it != other->end();++it )
+ {
+ if((*it)=="\\")
+ {
+ m_OtherEnd=index;
+ break;
+ }
+ index++;
+ }
+ index= other->findIndex(_str);
+ for ( TQStringList::Iterator it = other->find(_str); it != other->begin();--it )
+ {
+ if((*it)=="\\")
+ {
+ m_OtherBegin=index;
+ break;
+ }
+ index--;
+ }
+ return;
+ }
+
+ if ( m_String[0] == '=' )
+ m_Type = FORMULA;
+}
+
+bool AutoFillSequenceItem::getDelta( AutoFillSequenceItem *seq, double &_delta )
+{
+ if ( seq->getType() != m_Type )
+ return false;
+
+ switch( m_Type )
+ {
+ case INTEGER:
+ _delta = (double)( seq->getIValue() - m_IValue );
+ return true;
+ case FLOAT:
+ _delta = seq->getDValue() - m_DValue;
+ return true;
+ case FORMULA:
+ case STRING:
+ if ( m_String == seq->getString() )
+ {
+ _delta = 0.0;
+ return true;
+ }
+ return false;
+ case MONTH:
+ {
+ int i = month->findIndex( m_String );
+ int j = month->findIndex( seq->getString() );
+ int k = j;
+
+ if ( j + 1 == i )
+ _delta = -1.0;
+ else
+ _delta = ( double )( k - i );
+ return true;
+ }
+
+ case SHORTMONTH:
+ {
+ int i = shortMonth->findIndex( m_String );
+ int j = shortMonth->findIndex( seq->getString() );
+ int k = j;
+
+ if ( j + 1 == i )
+ _delta = -1.0;
+ else
+ _delta = ( double )( k - i );
+ return true;
+ }
+
+ case DAY:
+ {
+ int i = day->findIndex( m_String );
+ int j = day->findIndex( seq->getString() );
+ int k = j;
+
+ if ( j + 1 == i )
+ _delta = -1.0;
+ else
+ _delta = ( double )( k - i );
+ kdDebug() << m_String << " i: " << i << " j: " << j << " k: " << k << " delta: " << _delta << endl;
+ return true;
+ }
+
+ case SHORTDAY:
+ {
+ int i = shortDay->findIndex( m_String );
+ int j = shortDay->findIndex( seq->getString() );
+ int k = j;
+
+ if ( j + 1 == i )
+ _delta = -1.0;
+ else
+ _delta = ( double )( k - i );
+ return true;
+ }
+ case OTHER:
+ {
+ if( m_OtherEnd!= seq->getIOtherEnd() || m_OtherBegin!= seq->getIOtherBegin())
+ return false;
+ int i = other->findIndex( m_String );
+ int j = other->findIndex( seq->getString() );
+ int k = j;
+ if ( j < i )
+ k += (m_OtherEnd - m_OtherBegin - 1);
+ /*if ( j + 1 == i )
+ _delta = -1.0;
+ else*/
+ _delta = ( double )( k - i );
+ return true;
+ }
+ default:
+ return false;
+ }
+}
+
+TQString AutoFillSequenceItem::getSuccessor( int _no, double _delta )
+{
+ TQString erg;
+ switch( m_Type )
+ {
+ case INTEGER:
+ erg.sprintf("%i", m_IValue + _no * (int)_delta );
+ break;
+ case FLOAT:
+ erg.sprintf("%f", m_DValue + (double)_no * _delta );
+ break;
+ case FORMULA:
+ case STRING:
+ erg = m_String;
+ break;
+ case MONTH:
+ {
+ int i = month->findIndex( m_String );
+ int j = i + _no * (int) _delta;
+ while (j < 0)
+ j += month->count();
+ int k = j % month->count();
+ erg = (*month->at( k ));
+ }
+ break;
+ case SHORTMONTH:
+ {
+ int i = shortMonth->findIndex( m_String );
+ int j = i + _no * (int) _delta;
+ while (j < 0)
+ j += shortMonth->count();
+ int k = j % shortMonth->count();
+ erg = (*shortMonth->at( k ));
+ }
+ break;
+ case DAY:
+ {
+ int i = day->findIndex( m_String );
+ int j = i + _no * (int) _delta;
+ while (j < 0)
+ j += day->count();
+ int k = j % day->count();
+ erg = (*day->at( k ));
+ }
+ break;
+ case SHORTDAY:
+ {
+ int i = shortDay->findIndex( m_String );
+ int j = i + _no * (int) _delta;
+ while (j < 0)
+ j += shortDay->count();
+ int k = j % shortDay->count();
+ erg = (*shortDay->at( k ));
+ }
+ break;
+ case OTHER:
+ {
+ int i = other->findIndex( m_String )-(m_OtherBegin+1);
+ int j = i + _no * (int) _delta;
+ int k = j % (m_OtherEnd - m_OtherBegin-1);
+ erg = (*other->at( (k+m_OtherBegin+1) ));
+ }
+ case TIME:
+ case DATE:
+ // gets never called but fixes a warning while compiling
+ break;
+ }
+
+ return TQString( erg );
+}
+
+TQString AutoFillSequenceItem::getPredecessor( int _no, double _delta )
+{
+ TQString erg;
+ switch( m_Type )
+ {
+ case INTEGER:
+ erg.sprintf("%i", m_IValue - _no * (int)_delta );
+ break;
+ case FLOAT:
+ erg.sprintf("%f", m_DValue - (double)_no * _delta );
+ break;
+ case FORMULA:
+ case STRING:
+ erg = m_String;
+ break;
+ case MONTH:
+ {
+ int i = month->findIndex( m_String );
+ int j = i - _no * (int) _delta;
+ while ( j < 0 )
+ j += month->count();
+ int k = j % month->count();
+ erg = (*month->at( k ));
+ }
+ break;
+ case SHORTMONTH:
+ {
+ int i = shortMonth->findIndex( m_String );
+ int j = i - _no * (int) _delta;
+ while ( j < 0 )
+ j += shortMonth->count();
+ int k = j % shortMonth->count();
+ erg = (*shortMonth->at( k ));
+ }
+ break;
+ case DAY:
+ {
+ int i = day->findIndex( m_String );
+ int j = i - _no * (int) _delta;
+ while ( j < 0 )
+ j += day->count();
+ int k = j % day->count();
+ erg = (*day->at( k ));
+ }
+ break;
+ case SHORTDAY:
+ {
+ int i = shortDay->findIndex( m_String );
+ int j = i - _no * (int) _delta;
+ while ( j < 0 )
+ j += shortDay->count();
+ int k = j % shortDay->count();
+ erg = (*shortDay->at( k ));
+ }
+ break;
+ case OTHER:
+ {
+ int i = other->findIndex( m_String ) - (m_OtherBegin + 1);
+ int j = i - _no * (int) _delta;
+ while ( j < 0 )
+ j += (m_OtherEnd - m_OtherBegin - 1);
+ int k = j % (m_OtherEnd - m_OtherBegin - 1);
+ erg = (*other->at( (k + m_OtherBegin + 1) ));
+ }
+ case TIME:
+ case DATE:
+ // gets never called but fixes a warning while compiling
+ break;
+ }
+
+ return TQString( erg );
+}
+
+/**********************************************************************************
+ *
+ * AutoFillSequence
+ *
+ **********************************************************************************/
+
+AutoFillSequence::AutoFillSequence( Cell *_cell )
+{
+ sequence.setAutoDelete( true );
+
+ if ( _cell->isFormula() )
+ {
+ TQString d = _cell->encodeFormula();
+ sequence.append( new AutoFillSequenceItem( d ) );
+ }
+ else if ( _cell->value().isNumber() )
+ {
+ if ( floor( _cell->value().asFloat() ) == _cell->value().asFloat() )
+ {
+ sequence.append( new AutoFillSequenceItem( (int)_cell->value().asFloat()) );
+ }
+ else
+ sequence.append( new AutoFillSequenceItem(_cell->value().asFloat() ) );
+ }
+ else if ( !_cell->text().isEmpty() )
+ sequence.append( new AutoFillSequenceItem( _cell->text() ) );
+}
+
+bool AutoFillSequence::matches( AutoFillSequence* _seq, AutoFillDeltaSequence *_delta )
+{
+ AutoFillDeltaSequence delta( this, _seq );
+ if ( !delta.isOk() )
+ return false;
+
+ if ( delta.equals( _delta ) )
+ return true;
+
+ return false;
+}
+
+void AutoFillSequence::fillCell( Cell *src, Cell *dest, AutoFillDeltaSequence *delta, int _block, bool down )
+{
+ TQString erg = "";
+
+ // Special handling for formulas
+ if ( sequence.first() != 0L && sequence.first()->getType() == AutoFillSequenceItem::FORMULA )
+ {
+ TQString f = dest->decodeFormula( sequence.first()->getString() );
+ dest->setCellText( f );
+ dest->copyFormat( src );
+ return;
+ }
+
+ AutoFillSequenceItem *item;
+ int i = 0;
+ if (down)
+ {
+ for ( item = sequence.first(); item != 0L; item = sequence.next() )
+ erg += item->getSuccessor( _block, delta->getItemDelta( i++ ) );
+ }
+ else
+ {
+ for ( item = sequence.first(); item != 0L; item = sequence.next() )
+ erg += item->getPredecessor( _block, delta->getItemDelta( i++ ) );
+ }
+
+ dest->setCellText( erg );
+ dest->copyFormat( src );
+}
+
+/**********************************************************************************
+ *
+ * Sheet
+ *
+ **********************************************************************************/
+
+void Sheet::autofill( TQRect &src, TQRect &dest )
+{
+ if (src == dest)
+ {
+ return;
+ }
+
+ setRegionPaintDirty( dest );
+
+ doc()->emitBeginOperation();
+
+ if ( !doc()->undoLocked() )
+ {
+ UndoAutofill *undo = new UndoAutofill( doc(), this, dest );
+ doc()->addCommand( undo );
+ }
+
+ // disable the update of the max sroll range on each cell insertion
+ // Bug 124806: creating series takes extremely long time
+ enableScrollBarUpdates(false);
+
+ // Fill from left to right
+ if ( src.left() == dest.left() && src.right() < dest.right() )
+ {
+ for ( int y = src.top(); y <= src.bottom(); y++ )
+ {
+ int x;
+ TQPtrList<Cell> destList;
+ for ( x = src.right() + 1; x <= dest.right(); x++ )
+ destList.append( nonDefaultCell( x, y ) );
+ TQPtrList<Cell> srcList;
+ for ( x = src.left(); x <= src.right(); x++ )
+ srcList.append( cellAt( x, y ) );
+ TQPtrList<AutoFillSequence> seqList;
+ seqList.setAutoDelete( true );
+ for ( x = src.left(); x <= src.right(); x++ )
+ seqList.append( new AutoFillSequence( cellAt( x, y ) ) );
+ fillSequence( srcList, destList, seqList );
+ }
+ }
+
+ // Fill from top to bottom
+ if ( src.top() == dest.top() && src.bottom() < dest.bottom() )
+ {
+ for ( int x = src.left(); x <= dest.right(); x++ )
+ {
+ int y;
+ TQPtrList<Cell> destList;
+ for ( y = src.bottom() + 1; y <= dest.bottom(); y++ )
+ destList.append( nonDefaultCell( x, y ) );
+ TQPtrList<Cell> srcList;
+ for ( y = src.top(); y <= src.bottom(); y++ )
+ {
+ srcList.append( cellAt( x, y ) );
+ }
+ TQPtrList<AutoFillSequence> seqList;
+ seqList.setAutoDelete( true );
+ for ( y = src.top(); y <= src.bottom(); y++ )
+ seqList.append( new AutoFillSequence( cellAt( x, y ) ) );
+ fillSequence( srcList, destList, seqList );
+ }
+ }
+
+ // Fill from right to left
+ if ( ( src.left() == dest.right() || src.left() == dest.right() - 1) && src.right() >= dest.right() )
+ {
+ if ( src.left() != dest.right() )
+ dest.setRight( dest.right() - 1 );
+
+ for ( int y = dest.top(); y <= dest.bottom(); y++ )
+ {
+ int x;
+ TQPtrList<Cell> destList;
+
+ for ( x = dest.left(); x < src.left(); x++ )
+ {
+ destList.append( nonDefaultCell( x, y ) );
+ }
+ TQPtrList<Cell> srcList;
+ for ( x = src.left(); x <= src.right(); x++ )
+ {
+ srcList.append( cellAt( x, y ) );
+ }
+ TQPtrList<AutoFillSequence> seqList;
+ seqList.setAutoDelete( true );
+ for ( x = src.left(); x <= src.right(); x++ )
+ seqList.append( new AutoFillSequence( cellAt( x, y ) ) );
+ fillSequence( srcList, destList, seqList, false );
+ }
+ }
+
+ // Fill from bottom to top
+ if ( (src.top() == dest.bottom() || src.top() == (dest.bottom() - 1) ) && src.bottom() >= dest.bottom() )
+ {
+ if (src.top() != dest.bottom() )
+ dest.setBottom(dest.bottom() - 1);
+ int startVal = TQMIN( dest.left(), src.left());
+ int endVal = TQMAX(src.right(), dest.right());
+ for ( int x = startVal; x <= endVal; x++ )
+ {
+ int y;
+ TQPtrList<Cell> destList;
+ for ( y = dest.top(); y < src.top(); y++ )
+ destList.append( nonDefaultCell( x, y ) );
+ TQPtrList<Cell> srcList;
+ for ( y = src.top(); y <= src.bottom(); ++y )
+ {
+ srcList.append( cellAt( x, y ) );
+ }
+ TQPtrList<AutoFillSequence> seqList;
+ seqList.setAutoDelete( true );
+ for ( y = src.top(); y <= src.bottom(); y++ )
+ seqList.append( new AutoFillSequence( cellAt( x, y ) ) );
+ fillSequence( srcList, destList, seqList, false );
+ }
+ }
+
+ // update the max sroll range ONCE here
+ enableScrollBarUpdates(true);
+ checkRangeHBorder(dest.right());
+ checkRangeVBorder(dest.bottom());
+
+ emit sig_updateView( this );
+ // doc()->emitEndOperation();
+}
+
+
+void Sheet::fillSequence( TQPtrList<Cell>& _srcList,
+ TQPtrList<Cell>& _destList,
+ TQPtrList<AutoFillSequence>& _seqList,
+ bool down)
+{
+ doc()->emitBeginOperation(true);
+
+ /* try finding an interval to use to fill the sequence */
+ if (!FillSequenceWithInterval(_srcList, _destList, _seqList, down))
+ {
+ /* if no interval was found, just copy down through */
+ FillSequenceWithCopy(_srcList, _destList, down);
+ }
+
+ doc()->emitEndOperation();
+
+}
+
+TQVariant getDiff( const Value& value1, const Value& value2 , AutoFillSequenceItem::Type type )
+{
+ if ( type == AutoFillSequenceItem::FLOAT )
+ return TQVariant( value2.asFloat() - value1.asFloat() );
+ if ( type == AutoFillSequenceItem::TIME || type == AutoFillSequenceItem::DATE )
+ return TQVariant( (int)( value2.asInteger() - value1.asInteger() ) );
+
+ return TQVariant( (int)0 );
+ // note: date and time difference can be calculated as
+ // the difference of the serial number
+ /* if( (type == AutoFillSequenceItem::FLOAT) ||
+ (type == AutoFillSequenceItem::DATE) ||
+ (type == AutoFillSequenceItem::TIME) )
+ return ( value2.asFloat() - value1.asFloat() );
+ else
+ return 0.0;*/
+}
+
+bool Sheet::FillSequenceWithInterval(TQPtrList<Cell>& _srcList,
+ TQPtrList<Cell>& _destList,
+ TQPtrList<AutoFillSequence>& _seqList,
+ bool down)
+{
+ if (_srcList.first()->isFormula())
+ return false;
+
+ TQPtrList<AutoFillDeltaSequence> deltaList;
+ deltaList.setAutoDelete( true );
+ bool ok = false;
+
+ if ( _srcList.first()->value().isNumber() || _srcList.first()->isDate() || _srcList.first()->isTime() )
+ {
+ AutoFillSequenceItem::Type type;
+
+ TQValueVector< TQVariant > tmp( _seqList.count() ); /*= new TQValueList< TQVariant > ( _seqList.count() )*/;
+ TQValueVector< TQVariant > diff( _seqList.count() ); /*= new TQValueList< TQVariant > ( _seqList.count() )*/;
+ int p = -1;
+ int count = 0;
+ int tmpcount = 0;
+
+ Cell * cell = _srcList.first();
+ Cell * cell2 = _srcList.next();
+
+ bool singleCellOnly = (cell2 == 0);
+
+ if ( cell->isDate() )
+ type = AutoFillSequenceItem::DATE;
+ else if ( cell->isTime() )
+ type = AutoFillSequenceItem::TIME;
+ else if ( cell->value().isNumber() )
+ type = AutoFillSequenceItem::FLOAT;
+ else
+ return false; // Cannot happen due to if condition
+
+ while ( cell && (cell2 || singleCellOnly) )
+ {
+
+ Value cellValue = cell->value();
+ Value cell2Value;
+
+ //If we only have a single cell, the interval will depend upon the data type.
+ //- For numeric values, set the interval to 0 as we don't know what might be useful as a sequence
+ //- For time values, set the interval to one hour, as this will probably be the most useful setting
+ //- For date values, set the interval to one day, as this will probably be the most useful setting
+ //
+ //Note that the above options were chosen for consistency with Excel. Gnumeric (1.59) sets
+ //the interval to 0 for all types, OpenOffice.org (2.00) uses increments of 1.00, 1 hour and 1 day
+ //respectively
+ if (singleCellOnly)
+ {
+ if (type == AutoFillSequenceItem::FLOAT)
+ cell2Value = cellValue;
+ else if ( type == AutoFillSequenceItem::TIME)
+ cell2Value = Value( cellValue.asTime().addSecs( 60*60 ) );
+ else if ( type == AutoFillSequenceItem::DATE)
+ cell2Value = Value ( cellValue.asDate().addDays( 1 ) );
+ }
+ else
+ {
+ cell2Value = cell2->value();
+
+ // check if both cells contain the same type
+ if ( ( !cellValue.isNumber() )
+ || ( cell2->isDate() && type != AutoFillSequenceItem::DATE )
+ || ( cell2->isTime() && type != AutoFillSequenceItem::TIME ) )
+ {
+ count = 0;
+ ok = false;
+ break;
+ }
+ }
+
+ TQVariant delta = getDiff(cellValue , cell2Value , type );
+
+ if (count < 1)
+ {
+ p = count;
+ diff[ count++ ] = delta;
+ }
+ else
+ {
+ // same value again?
+ if (diff[ p ] == delta)
+ {
+ // store it somewhere else for the case we need it later
+ ++p;
+ tmp[ tmpcount++ ] = delta;
+ }
+ else
+ {
+ // if we have saved values in another buffer we have to insert them first
+ if ( tmpcount > 0 )
+ {
+ for ( int i = 0; i < tmpcount; ++i )
+ {
+ diff[ count++ ] = tmp.at( i );
+ }
+
+ tmpcount = 0;
+ }
+
+ // insert the value
+ p = 0;
+ diff[ count++ ] = delta;
+ }
+ }
+
+ // check next cell pair
+ cell = cell2;
+ cell2 = _srcList.next();
+ }
+
+ // we have found something:
+ if (count > 0 && (tmpcount > 0 || count == 1))
+ {
+ TQVariant cellValue( (int) 0 );
+
+ Cell * dest;
+ Cell * src;
+
+ int i = tmpcount;
+ if (down)
+ {
+ dest = _destList.first();
+ src = _srcList.last();
+ }
+ else
+ {
+ dest = _destList.last();
+ src = _srcList.first();
+
+ i *= -1;
+ }
+
+ if ( type == AutoFillSequenceItem::FLOAT )
+ cellValue = src->value().asFloat();
+ else
+ cellValue = (int)src->value().asInteger();
+
+ TQString res;
+ // copy all the data
+ while (dest)
+ {
+ if (down)
+ {
+ while ( i >= count )
+ i -= count;
+ }
+ else
+ {
+ while ( i < 0)
+ i += count;
+ }
+
+ TQVariant currentDiff = diff.at( i );
+
+ if (cellValue.type() == TQVariant::Double)
+ if (down)
+ cellValue = cellValue.asDouble() + currentDiff.asDouble();
+ else
+ cellValue = cellValue.asDouble() - currentDiff.asDouble();
+ else
+ if (down)
+ cellValue = cellValue.asInt() + currentDiff.asInt();
+ else
+ cellValue = cellValue.asInt() - currentDiff.asInt();
+
+ if ( type == AutoFillSequenceItem::TIME)
+ {
+ Value timeValue = doc()->converter()->asTime( Value(cellValue.asInt()) );
+ Value stringValue = doc()->converter()->asString( timeValue );
+ dest->setCellText( stringValue.asString() );
+ }
+ else if ( type == AutoFillSequenceItem::DATE)
+ {
+ Value dateValue = doc()->converter()->asDate( Value(cellValue.asInt()) );
+ Value stringValue = doc()->converter()->asString( dateValue );
+ dest->setCellText( stringValue.asString() );
+ }
+ else
+ dest->setCellText( cellValue.asString() );
+
+ dest->copyFormat( src );
+
+ if (down)
+ {
+ ++i;
+ dest = _destList.next();
+ src = _srcList.next();
+ }
+ else
+ {
+ --i;
+ dest = _destList.prev();
+ src = _srcList.prev();
+ }
+
+ if (!src)
+ src = _srcList.last();
+ }
+
+ ok = true;
+ }
+ else
+ {
+ ok = false;
+ }
+
+ // delete tmp;
+ // delete diff;
+
+ return ok;
+ }
+
+ // What is the interval (block)? If your sheet looks like this:
+ // 1 3 5 7 9
+ // then the interval has the length 1 and the delta list is [2].
+ // 2 200 3 300 4 400
+ // Here the interval has length 2 and the delta list is [1,100]
+
+
+ // How big is the interval. It is in the range from [2...n/2].
+ // The case of an interval of length n is handled below.
+ //
+ // We try to find the shortest interval.
+ for ( unsigned int step = 1; step <= _seqList.count() / 2; step++ )
+ {
+ kdDebug() << "Looking for interval: " << step << " seqList count: " << _seqList.count() << endl;
+ // If the interval is of length 'step' then the _seqList size must
+ // be a multiple of 'step'
+ if ( _seqList.count() % step == 0 )
+ {
+ // Be optimistic
+ ok = true;
+
+ deltaList.clear();
+
+ // Guess the delta by looking at cells 0...2*step-1
+ //
+ // Since the interval may be of length 'step' we calculate the delta
+ // between cells 0 and step, 1 and step+1, ...., step-1 and 2*step-1
+ for ( unsigned int t = 0; t < step; t++ )
+ {
+ deltaList.append( new AutoFillDeltaSequence( _seqList.at(t),
+ _seqList.at(t+step) ) );
+ ok = deltaList.getLast()->isOk();
+ }
+
+ /* Verify the delta by looking at cells step..._seqList.count()
+ We only looked at the cells 0 ... '2*step-1'.
+ Now test wether the cells from "(tst-1) * step + s" share the same delta
+ with the cell "tst * step + s" for all test=1..._seqList.count()/step
+ and for all s=0...step-1.
+ */
+ for ( unsigned int tst = 1; ok && ( tst * step < _seqList.count() );
+ tst++ )
+ {
+ for ( unsigned int s = 0; ok && ( s < step ); s++ )
+ {
+ if ( !_seqList.at( (tst-1) * step + s )->
+ matches( _seqList.at( tst * step + s ), deltaList.at( s ) ) )
+ ok = false;
+ }
+ }
+ // Did we find a valid interval ?
+ if ( ok )
+ {
+ unsigned int s = 0;
+ // Amount of intervals (blocks)
+ int block = _seqList.count() / step;
+
+ // Start iterating with the first cell
+ Cell * cell;
+ if (down)
+ cell = _destList.first();
+ else
+ {
+ cell = _destList.last();
+ block -= (_seqList.count() - 1);
+ }
+
+
+ // Loop over all destination cells
+ while ( cell )
+ {
+ kdDebug() << "Valid interval, cell: " << cell->row() << " block: " << block << endl;
+
+ // End of block? -> start again from beginning
+ if (down)
+ {
+ if ( s == step )
+ {
+ ++block;
+ s = 0;
+ }
+ }
+ else
+ {
+ if ( s >= step )
+ {
+ s = step - 1;
+ ++block;
+ }
+ }
+
+ kdDebug() << "Step: " << step << " S: " << s << " Block " << block
+ << " SeqList: " << _seqList.count()
+ << " SrcList: " << _srcList.count() << " DeltaList: " << deltaList.count()
+ << endl;
+
+ // Set the value of 'cell' by adding 'block' times the delta tp the
+ // value of cell 's'.
+ _seqList.at( s )->fillCell( _srcList.at( s ), cell,
+ deltaList.at( s ), block, down );
+
+ if (down)
+ {
+ // Next cell
+ cell = _destList.next();
+ ++s;
+ }
+ else
+ {
+ // Previous cell
+ cell = _destList.prev();
+ --s;
+ }
+ }
+ }
+ }
+ }
+ return ok;
+}
+
+void Sheet::FillSequenceWithCopy(TQPtrList<Cell>& _srcList,
+ TQPtrList<Cell>& _destList,
+ bool down)
+{
+ // We did not find any valid interval. So just copy over the marked
+ // area.
+ Cell * cell;
+
+ if (down)
+ cell = _destList.first();
+ else
+ cell = _destList.last();
+ int incr = 1;
+ unsigned int s = 0;
+ double factor = 1;
+
+ if (!down)
+ s = _srcList.count() - 1;
+
+ if ( _srcList.at( s )->value().isNumber() &&
+ !(_srcList.at( s )->isDate() || _srcList.at( s )->isTime() ) )
+ factor = _srcList.at( s )->value().asFloat();
+
+ while ( cell )
+ {
+ if (down)
+ {
+ if ( s == _srcList.count() )
+ s = 0;
+ }
+ else
+ {
+ if ( s >= _srcList.count() )
+ s = _srcList.count() - 1;
+ }
+
+ if ( !_srcList.at( s )->text().isEmpty() )
+ {
+ if ( _srcList.at( s )->isFormula() )
+ {
+ TQString d = _srcList.at( s )->encodeFormula();
+ cell->setCellText( cell->decodeFormula( d ) );
+ }
+ else if(_srcList.at( s )->value().isNumber() && _srcList.count()==1)
+ {
+ double val;
+ int format_type = _srcList.at( s )->formatType();
+ if ( format_type == Percentage_format )
+ {
+ factor = 0.01; // one percent
+ }
+ else if ( _srcList.at( s )->isTime() )
+ {
+ // FIXME this is a workaround to avoid those nasty one minute off
+ // "dragging down" time is inaccurate overa large lists!
+ // This is the best approximation I could find (raphael)
+ if (down)
+ {
+// factor = 1.000002/24. + 0.000000001;
+ factor = 0.041666751;
+ }
+ else
+ { //when dragging "up" the error must of course be the other way round
+ factor = 0.0416665;
+ }
+ }
+
+ if (!down)
+ val = (_srcList.at( s )->value().asFloat() - (incr * factor));
+ else
+ val = (_srcList.at( s )->value().asFloat() + (incr * factor));
+
+ TQString tmp;
+ tmp = tmp.setNum(val);
+ cell->setCellText( tmp );
+ ++incr;
+ }
+ else if((AutoFillSequenceItem::month != 0L)
+ && AutoFillSequenceItem::month->find( _srcList.at( s )->text()) != 0L
+ && AutoFillSequenceItem::month->find( _srcList.at( s )->text()) != AutoFillSequenceItem::month->end()
+ && _srcList.count() == 1)
+ {
+ TQString strMonth=_srcList.at( s )->text();
+ int i = AutoFillSequenceItem::month->findIndex( strMonth )+incr;
+ int k = (i) % AutoFillSequenceItem::month->count();
+ cell->setCellText((*AutoFillSequenceItem::month->at( k )));
+ incr++;
+ }
+ else if(AutoFillSequenceItem::day != 0L
+ && AutoFillSequenceItem::day->find( _srcList.at( s )->text()) != 0L
+ && AutoFillSequenceItem::day->find( _srcList.at( s )->text())
+ != AutoFillSequenceItem::day->end()
+ && _srcList.count()==1)
+ {
+ TQString strDay=_srcList.at( s )->text();
+ int i = AutoFillSequenceItem::day->findIndex( strDay )+incr;
+ int k = (i) % AutoFillSequenceItem::day->count();
+ cell->setCellText((*AutoFillSequenceItem::day->at( k )));
+ incr++;
+ }
+ else
+ {
+ TQRegExp number("(\\d+)");
+ int pos =number.search(_srcList.at( s )->text());
+ if( pos!=-1 )
+ {
+ TQString tmp=number.cap(1);
+ int num=tmp.toInt()+incr;
+ cell->setCellText(_srcList.at( s )->text().replace(number,TQString::number(num)));
+ ++incr;
+ }
+ else if ( !_srcList.at( s )->link().isEmpty() )
+ {
+ cell->setCellText( _srcList.at( s )->text() );
+ cell->setLink( _srcList.at( s )->link() );
+ }
+ else
+ {
+ cell->setCellText( _srcList.at( s )->text() );
+ }
+ }
+ }
+ else
+ cell->setCellText( "" );
+
+ cell->copyFormat( _srcList.at( s ) );
+
+ if (down)
+ {
+ cell = _destList.next();
+ ++s;
+ }
+ else
+ {
+ cell = _destList.prev();
+ --s;
+ }
+ }
+ return;
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-14 04:49:21 +0000