Skip to main content :: ::

KOffice API Docs

:: Skip to Link Menu
/ KOffice / API Docs / kspread

kspread AutoFillCommand.cpp Go to the documentation of this file. /* This file is part of the KDE project Copyright 2006-2007 Stefan Nikolaus <stefan.nikolaus@kdemail.net> 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 "AutoFillCommand.h" #include "part/Factory.h" // FIXME detach from part #include "Localization.h" #include "Map.h" #include "Sheet.h" #include "Value.h" #include "ValueConverter.h" #include <kconfig.h> #include <kconfiggroup.h> #include <kdebug.h> #include <QList> #include <QRegExp> #include <math.h> using namespace KSpread; QStringList *AutoFillCommand::month = 0; QStringList *AutoFillCommand::shortMonth = 0; QStringList *AutoFillCommand::day = 0; QStringList *AutoFillCommand::shortDay = 0; QStringList *AutoFillCommand::other = 0; /********************************************************************************** * * AutoFillSequenceItem * **********************************************************************************/ namespace KSpread { class AutoFillSequenceItem { public: enum Type { VALUE, FORMULA, DAY, SHORTDAY, MONTH, SHORTMONTH, OTHER }; explicit AutoFillSequenceItem(const Cell& cell); Value delta(AutoFillSequenceItem *_seq, bool *ok) const; Value nextValue(int _no, Value _delta) const; Value prevValue(int _no, Value _delta) const; Type type() const { return m_type; } Value value() const { return m_value; } int otherEnd() const { return m_otherEnd; } int otherBegin() const { return m_otherBegin; } protected: Value m_value; Type m_type; int m_otherBegin; int m_otherEnd; }; } AutoFillSequenceItem::AutoFillSequenceItem(const Cell& cell) : m_value() , m_type(VALUE) , m_otherBegin(0) , m_otherEnd(0) { if (cell.isFormula()) { m_value = Value(cell.encodeFormula()); m_type = FORMULA; } else if (cell.isDate()) { m_value = cell.sheet()->map()->converter()->asDate(cell.value()); m_type = VALUE; } else if (cell.isTime() || cell.value().format() == Value::fmt_DateTime) { m_value = cell.sheet()->map()->converter()->asDateTime(cell.value()); m_type = VALUE; } else if (cell.value().isNumber()) { m_value = cell.value(); m_type = VALUE; } else { m_value = cell.value(); m_type = VALUE; if (AutoFillCommand::month == 0) { AutoFillCommand::month = new QStringList(); AutoFillCommand::month->append(i18n("January")); AutoFillCommand::month->append(i18n("February")); AutoFillCommand::month->append(i18n("March")); AutoFillCommand::month->append(i18n("April")); AutoFillCommand::month->append(i18n("May")); AutoFillCommand::month->append(i18n("June")); AutoFillCommand::month->append(i18n("July")); AutoFillCommand::month->append(i18n("August")); AutoFillCommand::month->append(i18n("September")); AutoFillCommand::month->append(i18n("October")); AutoFillCommand::month->append(i18n("November")); AutoFillCommand::month->append(i18n("December")); } if (AutoFillCommand::shortMonth == 0) { AutoFillCommand::shortMonth = new QStringList(); AutoFillCommand::shortMonth->append(i18n("Jan")); AutoFillCommand::shortMonth->append(i18n("Feb")); AutoFillCommand::shortMonth->append(i18n("Mar")); AutoFillCommand::shortMonth->append(i18n("Apr")); AutoFillCommand::shortMonth->append(i18nc("May short", "May")); AutoFillCommand::shortMonth->append(i18n("Jun")); AutoFillCommand::shortMonth->append(i18n("Jul")); AutoFillCommand::shortMonth->append(i18n("Aug")); AutoFillCommand::shortMonth->append(i18n("Sep")); AutoFillCommand::shortMonth->append(i18n("Oct")); AutoFillCommand::shortMonth->append(i18n("Nov")); AutoFillCommand::shortMonth->append(i18n("Dec")); } if (AutoFillCommand::day == 0) { AutoFillCommand::day = new QStringList(); AutoFillCommand::day->append(i18n("Monday")); AutoFillCommand::day->append(i18n("Tuesday")); AutoFillCommand::day->append(i18n("Wednesday")); AutoFillCommand::day->append(i18n("Thursday")); AutoFillCommand::day->append(i18n("Friday")); AutoFillCommand::day->append(i18n("Saturday")); AutoFillCommand::day->append(i18n("Sunday")); } if (AutoFillCommand::shortDay == 0) { AutoFillCommand::shortDay = new QStringList(); AutoFillCommand::shortDay->append(i18n("Mon")); AutoFillCommand::shortDay->append(i18n("Tue")); AutoFillCommand::shortDay->append(i18n("Wed")); AutoFillCommand::shortDay->append(i18n("Thu")); AutoFillCommand::shortDay->append(i18n("Fri")); AutoFillCommand::shortDay->append(i18n("Sat")); AutoFillCommand::shortDay->append(i18n("Sun")); } if (AutoFillCommand::other == 0) { // AutoFillCommand::other = new QStringList(); KSharedConfigPtr config = Factory::global().config(); AutoFillCommand::other = new QStringList(config->group("Parameters").readEntry("Other list", QStringList())); } if (AutoFillCommand::month->contains(m_value.asString())) { m_type = MONTH; return; } if (AutoFillCommand::shortMonth->contains(m_value.asString())) { m_type = SHORTMONTH; return; } if (AutoFillCommand::day->contains(m_value.asString())) { m_type = DAY; return; } if (AutoFillCommand::shortDay->contains(m_value.asString())) { m_type = SHORTDAY; return; } if (AutoFillCommand::other->contains(m_value.asString())) { m_type = OTHER; int index = AutoFillCommand::other->indexOf(m_value.asString()); int otherBegin = AutoFillCommand::other->lastIndexOf("\\", index); // backward int otherEnd = AutoFillCommand::other->indexOf("\\", index); // forward m_otherBegin = (otherBegin != -1) ? otherBegin : 0; m_otherEnd = (otherEnd != -1) ? otherEnd : AutoFillCommand::other->count(); return; } } } Value AutoFillSequenceItem::delta(AutoFillSequenceItem *seq, bool *ok) const { if (seq->type() != m_type) { *ok = false; return Value(); } *ok = true; switch(m_type) { case VALUE: case FORMULA: { switch (m_value.type()) { case Value::Boolean: { // delta indicates a flipping of the boolean if (seq->value().type() != Value::Boolean) *ok = false; return Value(seq->value().asBoolean() != m_value.asBoolean()); } case Value::Integer: { if (seq->value().type() == Value::Empty) *ok = false; Value value(seq->value().asInteger() - m_value.asInteger()); value.setFormat(m_value.format()); // may be a date format return value; } case Value::Float: { if (seq->value().type() == Value::Empty) *ok = false; Value value(seq->value().asFloat() - m_value.asFloat()); value.setFormat(m_value.format()); // may be a time format return value; } case Value::Complex: { if (seq->value().type() == Value::Empty) *ok = false; return Value(seq->value().asComplex() - m_value.asComplex()); } case Value::Empty: case Value::String: case Value::Array: case Value::CellRange: case Value::Error: { *ok = (m_value == seq->value()); return Value(); } } } case MONTH: { const int i = AutoFillCommand::month->indexOf(m_value.asString()); const int j = AutoFillCommand::month->indexOf(seq->value().asString()); return Value(j - i); } case SHORTMONTH: { const int i = AutoFillCommand::shortMonth->indexOf(m_value.asString()); const int j = AutoFillCommand::shortMonth->indexOf(seq->value().asString()); return Value(j - i); } case DAY: { const int i = AutoFillCommand::day->indexOf(m_value.asString()); const int j = AutoFillCommand::day->indexOf(seq->value().asString()); return Value(j - i); } case SHORTDAY: { const int i = AutoFillCommand::shortDay->indexOf(m_value.asString()); const int j = AutoFillCommand::shortDay->indexOf(seq->value().asString()); return Value(j - i); } case OTHER: { *ok = (m_otherEnd != seq->otherEnd() || m_otherBegin != seq->otherBegin()); const int i = AutoFillCommand::other->indexOf(m_value.asString()); const int j = AutoFillCommand::other->indexOf(seq->value().asString()); int k = j; if (j < i) k += (m_otherEnd - m_otherBegin - 1); /* if (j + 1 == i) return -1.0; else*/ return Value(k - i); } default: *ok = false; } return Value(); } Value AutoFillSequenceItem::nextValue(int _no, Value _delta) const { switch(m_type) { case VALUE: case FORMULA: { if (m_value.isBoolean()) { if (!_delta.asBoolean() || _delta.isEmpty()) // no change? return m_value; return Value(_no % 2 ? !m_value.asBoolean() : m_value.asBoolean()); } else if (m_value.isInteger()) { Value value(m_value.asInteger() + _no * _delta.asInteger()); value.setFormat(_delta.format()); return value; } else if (m_value.isFloat()) { Value value(m_value.asFloat() + (long double)_no * _delta.asFloat()); value.setFormat(_delta.format()); return value; } else if (m_value.isComplex()) { Value value(m_value.asComplex() + (long double)_no * _delta.asComplex()); value.setFormat(_delta.format()); return value; } else // string or empty return m_value; } case MONTH: { int i = AutoFillCommand::month->indexOf(m_value.asString()); int j = i + _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::month->count(); int k = j % AutoFillCommand::month->count(); return Value(AutoFillCommand::month->at(k)); } case SHORTMONTH: { int i = AutoFillCommand::shortMonth->indexOf(m_value.asString()); int j = i + _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::shortMonth->count(); int k = j % AutoFillCommand::shortMonth->count(); return Value(AutoFillCommand::shortMonth->at(k)); } case DAY: { int i = AutoFillCommand::day->indexOf(m_value.asString()); int j = i + _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::day->count(); int k = j % AutoFillCommand::day->count(); return Value(AutoFillCommand::day->at(k)); } case SHORTDAY: { int i = AutoFillCommand::shortDay->indexOf(m_value.asString()); int j = i + _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::shortDay->count(); int k = j % AutoFillCommand::shortDay->count(); return Value(AutoFillCommand::shortDay->at(k)); } case OTHER: { int i = AutoFillCommand::other->indexOf(m_value.asString())-(m_otherBegin+1); int j = i + _no * _delta.asInteger(); int k = j % (m_otherEnd - m_otherBegin-1); return Value(AutoFillCommand::other->at((k+m_otherBegin+1))); } default: break; } return Value(); } Value AutoFillSequenceItem::prevValue(int _no, Value _delta) const { switch(m_type) { case VALUE: case FORMULA: { if (m_value.isBoolean()) { if (!_delta.asBoolean() || _delta.isEmpty()) // no change? return m_value; return Value(_no % 2 ? !m_value.asBoolean() : m_value.asBoolean()); } else if (m_value.isInteger()) { Value value(m_value.asInteger() - _no * _delta.asInteger()); value.setFormat(_delta.format()); return value; } else if (m_value.isFloat()) { Value value(m_value.asFloat() - (long double)_no * _delta.asFloat()); value.setFormat(_delta.format()); return value; } else if (m_value.isComplex()) { Value value(m_value.asComplex() - (long double)_no * _delta.asComplex()); value.setFormat(_delta.format()); return value; } else // string or empty return m_value; } case MONTH: { int i = AutoFillCommand::month->indexOf(m_value.asString()); int j = i - _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::month->count(); int k = j % AutoFillCommand::month->count(); return Value(AutoFillCommand::month->at(k)); } case SHORTMONTH: { int i = AutoFillCommand::shortMonth->indexOf(m_value.asString()); int j = i - _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::shortMonth->count(); int k = j % AutoFillCommand::shortMonth->count(); return Value(AutoFillCommand::shortMonth->at(k)); } case DAY: { int i = AutoFillCommand::day->indexOf(m_value.asString()); int j = i - _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::day->count(); int k = j % AutoFillCommand::day->count(); return Value(AutoFillCommand::day->at(k)); } case SHORTDAY: { int i = AutoFillCommand::shortDay->indexOf(m_value.asString()); int j = i - _no * _delta.asInteger(); while (j < 0) j += AutoFillCommand::shortDay->count(); int k = j % AutoFillCommand::shortDay->count(); return Value(AutoFillCommand::shortDay->at(k)); } case OTHER: { int i = AutoFillCommand::other->indexOf(m_value.asString()) - (m_otherBegin + 1); int j = i - _no * _delta.asInteger(); while (j < 0) j += (m_otherEnd - m_otherBegin - 1); int k = j % (m_otherEnd - m_otherBegin - 1); return Value(AutoFillCommand::other->at((k + m_otherBegin + 1))); } default: break; } return Value(); } /********************************************************************************** * * AutoFillSequence * **********************************************************************************/ namespace KSpread { class AutoFillSequence : public QList<AutoFillSequenceItem*> { public: AutoFillSequence(); AutoFillSequence(const QList<AutoFillSequenceItem*>&); ~AutoFillSequence(); QList<Value> createDeltaSequence(int intervalLength) const; }; } AutoFillSequence::AutoFillSequence() { } AutoFillSequence::AutoFillSequence(const QList<AutoFillSequenceItem*>& list) : QList<AutoFillSequenceItem*>(list) { } AutoFillSequence::~AutoFillSequence() { } QList<Value> AutoFillSequence::createDeltaSequence(int intervalLength) const { bool ok = true; QList<Value> deltaSequence; // Guess the delta by looking at cells 0...2*intervalLength-1 // // Since the interval may be of length 'intervalLength' we calculate the delta // between cells 0 and intervalLength, 1 and intervalLength+1, ...., intervalLength-1 and 2*intervalLength-1. for (int t = 0; t < intervalLength /*&& t + intervalLength < count()*/; ++t) { deltaSequence.append(value(t)->delta(value((t + intervalLength) % count()), &ok)); if (!ok) return QList<Value>(); } // fill to the interval length while (deltaSequence.count() < intervalLength) deltaSequence.append(Value()); return deltaSequence; } /********************************************************************************** * * File static helper functions * **********************************************************************************/ static QList<Value> findInterval(const AutoFillSequence& _seqList) { // 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] QList<Value> deltaSequence; kDebug() <<"Sequence length:" << _seqList.count(); // How big is the interval. It is in the range from [1...n]. // // We try to find the shortest interval. int intervalLength = 1; for (intervalLength = 1; intervalLength < _seqList.count(); ++intervalLength) { kDebug() <<"Checking interval of length:" << intervalLength; // Create the delta list. deltaSequence = _seqList.createDeltaSequence(intervalLength); QString str("Deltas: [ "); foreach (Value v, deltaSequence) { if (v.isBoolean()) str += v.asBoolean() ? "change " : "nochange "; else if (v.isInteger()) str += QString::number(v.asInteger()) + ' '; else if (v.isFloat()) str += QString::number((double) v.asFloat()) + ' '; else str += v.asString() + ' '; } str += ']'; kDebug() << str; // Verify the delta by looking at cells intervalLength.._seqList.count(). // We only looked at the cells 0..2*intervalLength-1. // Now test whether the cells from "(i-1) * intervalLength + s" share the same delta // with the cell "i * intervalLength + s" for all test=1..._seqList.count()/intervalLength // and for all s=0...intervalLength-1. for (int i = 1; (i+1) * intervalLength < _seqList.count(); ++i) { AutoFillSequence tail = _seqList.mid(i * intervalLength); // kDebug() <<"Verifying for sequence after" << i * intervalLength <<", length:" << tail.count(); QList<Value> otherDeltaSequence = tail.createDeltaSequence(intervalLength); if (deltaSequence != otherDeltaSequence) { kDebug() <<"Interval does not match."; deltaSequence.clear(); break; } } // Did we find a valid interval? if (!deltaSequence.isEmpty()) break; } // if the full interval has to be taken fill the delta sequence with zeros if (intervalLength == _seqList.count()) { while (intervalLength--) deltaSequence.append(Value()); QString str("Deltas: [ "); foreach (Value v, deltaSequence) { if (v.isBoolean()) str += v.asBoolean() ? "change " : "nochange "; else if (v.isInteger()) str += QString::number(v.asInteger()) + ' '; else if (v.isFloat()) str += QString::number((double) v.asFloat()) + ' '; else str += v.asString() + ' '; } str += ']'; kDebug() << str; } return deltaSequence; } static void fillSequence(const QList<Cell>& _srcList, const QList<Cell>& _destList, const AutoFillSequence& _seqList, const QList<Value>& deltaSequence, bool down) { const int intervalLength = deltaSequence.count(); // starting position depends on the sequence and interval length int s = _srcList.count() % intervalLength; // Amount of intervals (blocks) int block = _srcList.count() / intervalLength; kDebug() <<"Valid interval, number of intervals:" << block; // Start iterating with the first cell Cell cell; int destIndex = 0; if (down) cell = _destList.first(); else { cell = _destList.last(); destIndex = _destList.count() - 1; block -= (_srcList.count() - 1); } // Fill destination cells // while (!cell.isNull()) { // End of block? -> start again from beginning if (down) { if (s == intervalLength) { ++block; s = 0; } } else { if (s == -1) { s = intervalLength - 1; ++block; } } kDebug() <<"Cell:" << cell.name() <<", position:" << s <<", block:" << block; // Calculate the new value of 'cell' by adding 'block' times the delta to the // value of cell 's'. // Value value; if (down) value = _seqList.value(s)->nextValue(block, deltaSequence.value(s)); else value = _seqList.value(s)->prevValue(block, deltaSequence.value(s)); // insert the new value // if (_seqList.value(s)->type() == AutoFillSequenceItem::FORMULA) { // Special handling for formulas cell.parseUserInput(cell.decodeFormula(_seqList.value(s)->value().asString())); } else if (value.format() == Value::fmt_Time) { const Value timeValue = cell.sheet()->map()->converter()->asTime(value); cell.setValue(timeValue); cell.setUserInput(cell.sheet()->map()->converter()->asString(timeValue).asString()); } else if (value.format() == Value::fmt_Date) { const Value dateValue = cell.sheet()->map()->converter()->asDate(value); cell.setValue(dateValue); cell.setUserInput(cell.sheet()->map()->converter()->asString(dateValue).asString()); } else if (value.type() == Value::Boolean || value.type() == Value::Complex || value.type() == Value::Float || value.type() == Value::Integer) { cell.setValue(value); cell.setUserInput(cell.sheet()->map()->converter()->asString(value).asString()); } else // if (value.type() == Value::String) { QRegExp number("(\\d+)"); int pos = number.indexIn(value.asString()); if (pos!=-1) { const int num = number.cap(1).toInt() + 1; cell.parseUserInput(value.asString().replace(number, QString::number(num))); } else if (!_srcList.at(s).link().isEmpty()) { cell.parseUserInput(value.asString()); cell.setLink(_srcList.at(s).link()); } else { cell.setValue(value); cell.setUserInput(value.asString()); } } // copy the style of the source cell // cell.copyFormat(_srcList.at(s)); // next/previous cell if (down) { cell = _destList.value(++destIndex); ++s; } else { cell = _destList.value(--destIndex); --s; } } } /********************************************************************************** * * AutoFillCommand * **********************************************************************************/ AutoFillCommand::AutoFillCommand() { setText(i18n("Autofill")); } AutoFillCommand::~AutoFillCommand() { } void AutoFillCommand::setSourceRange(const QRect& range) { m_sourceRange = range; } void AutoFillCommand::setTargetRange(const QRect& range) { m_targetRange = range; } bool AutoFillCommand::mainProcessing() { if (m_sourceRange.contains(m_targetRange)) return false; if (m_reverse) { // reverse - use the stored value AbstractDataManipulator::mainProcessing(); return true; } // Fill from left to right if (m_sourceRange.left() == m_targetRange.left() && m_sourceRange.right() < m_targetRange.right()) { for (int y = m_sourceRange.top(); y <= m_sourceRange.bottom(); y++) { int x; QList<Cell> destList; for (x = m_sourceRange.right() + 1; x <= m_targetRange.right(); x++) destList.append(Cell(m_sheet, x, y)); QList<Cell> srcList; for (x = m_sourceRange.left(); x <= m_sourceRange.right(); x++) srcList.append(Cell(m_sheet, x, y)); AutoFillSequence seqList; for (x = m_sourceRange.left(); x <= m_sourceRange.right(); x++) seqList.append(new AutoFillSequenceItem(Cell(m_sheet, x, y))); fillSequence(srcList, destList, seqList); qDeleteAll(seqList); } } // Fill from top to bottom if (m_sourceRange.top() == m_targetRange.top() && m_sourceRange.bottom() < m_targetRange.bottom()) { for (int x = m_sourceRange.left(); x <= m_targetRange.right(); x++) { int y; QList<Cell> destList; for (y = m_sourceRange.bottom() + 1; y <= m_targetRange.bottom(); y++) destList.append(Cell(m_sheet, x, y)); QList<Cell> srcList; for (y = m_sourceRange.top(); y <= m_sourceRange.bottom(); y++) srcList.append(Cell(m_sheet, x, y)); AutoFillSequence seqList; for (y = m_sourceRange.top(); y <= m_sourceRange.bottom(); y++) seqList.append(new AutoFillSequenceItem(Cell(m_sheet, x, y))); fillSequence(srcList, destList, seqList); qDeleteAll(seqList); } } // Fill from right to left if (m_sourceRange.left() == m_targetRange.right() && m_sourceRange.right() >= m_targetRange.right()) { for (int y = m_targetRange.top(); y <= m_targetRange.bottom(); y++) { int x; QList<Cell> destList; for (x = m_targetRange.left(); x < m_sourceRange.left(); x++) destList.append(Cell(m_sheet, x, y)); QList<Cell> srcList; for (x = m_sourceRange.left(); x <= m_sourceRange.right(); x++) srcList.append(Cell(m_sheet, x, y)); AutoFillSequence seqList; for (x = m_sourceRange.left(); x <= m_sourceRange.right(); x++) seqList.append(new AutoFillSequenceItem(Cell(m_sheet, x, y))); fillSequence(srcList, destList, seqList, false); qDeleteAll(seqList); } } // Fill from bottom to top if (m_sourceRange.top() == m_targetRange.bottom() && m_sourceRange.bottom() >= m_targetRange.bottom()) { const int startVal = qMin(m_targetRange.left(), m_sourceRange.left()); const int endVal = qMax(m_sourceRange.right(), m_targetRange.right()); for (int x = startVal; x <= endVal; x++) { int y; QList<Cell> destList; for (y = m_targetRange.top(); y < m_sourceRange.top(); y++) destList.append(Cell(m_sheet, x, y)); QList<Cell> srcList; for (y = m_sourceRange.top(); y <= m_sourceRange.bottom(); ++y) srcList.append(Cell(m_sheet, x, y)); AutoFillSequence seqList; for (y = m_sourceRange.top(); y <= m_sourceRange.bottom(); y++) seqList.append(new AutoFillSequenceItem(Cell(m_sheet, x, y))); fillSequence(srcList, destList, seqList, false); qDeleteAll(seqList); } } return true; } void AutoFillCommand::fillSequence(const QList<Cell>& _srcList, const QList<Cell>& _destList, const AutoFillSequence& _seqList, bool down) { if (_srcList.isEmpty() || _destList.isEmpty()) return; // find an interval to use to fill the sequence QList<Value> deltaSequence; //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 (_srcList.count() == 1) { const Cell cell = _srcList.value(0); if (cell.isTime() || cell.value().format() == Value::fmt_DateTime) { // TODO Stefan: delta depending on minimum unit of format deltaSequence.append(Value(QTime(1, 0), m_sheet->map()->calculationSettings())); } else if (cell.isDate()) { // TODO Stefan: delta depending on minimum unit of format Value value(1); value.setFormat(Value::fmt_Date); deltaSequence.append(value); } else deltaSequence.append(Value()); } else deltaSequence = findInterval(_seqList); // fill the sequence ::fillSequence(_srcList, _destList, _seqList, deltaSequence, down); } kspread Skip menu "kspread" Main Page Modules Namespace List Class Hierarchy Alphabetical List Class List File List Namespace Members Class Members Related Pages API Reference Skip menu "API Reference" kdgantt Kexi   KoProperty   flake kplato krita   image   plugins       libbrush       libpaintop   ui kspread   part     scripting libs   flake   kotext   main   pigment   store   musicshape Generated for API Reference by doxygen 1.5.9-20090814 This website is maintained by Adriaan de Groot and Allen Winter. KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal