| -rw-r--r-- | libkcal/recurrence.cpp | 3360 |
1 files changed, 3360 insertions, 0 deletions
diff --git a/libkcal/recurrence.cpp b/libkcal/recurrence.cpp new file mode 100644 index 0000000..5fc5d1f --- a/dev/null +++ b/libkcal/recurrence.cpp @@ -0,0 +1,3360 @@ +/* + This file is part of libkcal. + Copyright (c) 1998 Preston Brown + Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org> + Copyright (c) 2002 David Jarvie <software@astrojar.org.uk> + + 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., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include <limits.h> + +#include <kdebug.h> +#include <kglobal.h> +#include <klocale.h> + +#include "incidence.h" + +#include "recurrence.h" + +using namespace KCal; + +Recurrence::Feb29Type Recurrence::mFeb29YearlyDefaultType = Recurrence::rMar1; + + +Recurrence::Recurrence(Incidence *parent, int compatVersion) +: recurs(rNone), // by default, it's not a recurring event + rWeekStart(1), // default is Monday + rDays(7), + mFloats(parent ? parent->doesFloat() : false), + mRecurReadOnly(false), + mRecurExDatesCount(0), + mFeb29YearlyType(mFeb29YearlyDefaultType), + mCompatVersion(compatVersion ? compatVersion : INT_MAX), + mCompatRecurs(rNone), + mCompatDuration(0), + mParent(parent) +{ + rMonthDays.setAutoDelete( true ); + rMonthPositions.setAutoDelete( true ); + rYearNums.setAutoDelete( true ); +} + +Recurrence::Recurrence(const Recurrence &r, Incidence *parent) +: recurs(r.recurs), + rWeekStart(r.rWeekStart), + rDays(r.rDays.copy()), + rFreq(r.rFreq), + rDuration(r.rDuration), + rEndDateTime(r.rEndDateTime), + mRecurStart(r.mRecurStart), + mFloats(r.mFloats), + mRecurReadOnly(r.mRecurReadOnly), + mRecurExDatesCount(r.mRecurExDatesCount), + mFeb29YearlyType(r.mFeb29YearlyType), + mCompatVersion(r.mCompatVersion), + mCompatRecurs(r.mCompatRecurs), + mCompatDuration(r.mCompatDuration), + mParent(parent) +{ + for (QPtrListIterator<rMonthPos> mp(r.rMonthPositions); mp.current(); ++mp) { + rMonthPos *tmp = new rMonthPos; + tmp->rPos = mp.current()->rPos; + tmp->negative = mp.current()->negative; + tmp->rDays = mp.current()->rDays.copy(); + rMonthPositions.append(tmp); + } + for (QPtrListIterator<int> md(r.rMonthDays); md.current(); ++md) { + int *tmp = new int; + *tmp = *md.current(); + rMonthDays.append(tmp); + } + for (QPtrListIterator<int> yn(r.rYearNums); yn.current(); ++yn) { + int *tmp = new int; + *tmp = *yn.current(); + rYearNums.append(tmp); + } + rMonthDays.setAutoDelete( true ); + rMonthPositions.setAutoDelete( true ); + rYearNums.setAutoDelete( true ); +} + +Recurrence::~Recurrence() +{ +} + + +bool Recurrence::operator==( const Recurrence& r2 ) const +{ + + // the following line is obvious + if ( recurs == rNone && r2.recurs == rNone ) + return true; + // we need the above line, because two non recurring events may + // differ in the other settings, because one (or both) + // may be not initialized properly + if ( recurs != r2.recurs + || rFreq != r2.rFreq + || rDuration != r2.rDuration + || !rDuration && rEndDateTime != r2.rEndDateTime + || mRecurStart != r2.mRecurStart + || mFloats != r2.mFloats + || mRecurReadOnly != r2.mRecurReadOnly + || mRecurExDatesCount != r2.mRecurExDatesCount ) + return false; + // no need to compare mCompat* and mParent + // OK to compare the pointers + switch ( recurs ) + { + case rWeekly: + return rDays == r2.rDays + && rWeekStart == r2.rWeekStart; + case rMonthlyPos: + return rMonthPositions.count() == r2.rMonthPositions.count(); + case rMonthlyDay: + return rMonthDays.count() == r2.rMonthDays.count(); + case rYearlyPos: + return rYearNums.count() == r2.rYearNums.count() + && rMonthPositions.count() == r2.rMonthPositions.count(); + case rYearlyMonth: + return rYearNums.count() == r2.rYearNums.count() + && mFeb29YearlyType == r2.mFeb29YearlyType; + case rYearlyDay: + return rYearNums == r2.rYearNums; + case rNone: + case rMinutely: + case rHourly: + case rDaily: + default: + return true; + } +} +/* +bool Recurrence::compareLists( const QPtrList<int> &l1 ,const QPtrList<int> &l2) +{ + if ( l1.count() != l2.count() ) + return false; + int count = l1.count(); + int i; + for ( i = 0; i < count ; ++i ) { + // if ( l1.at(i) != l2.at(i) ) + return false; + qDebug("compüare "); + } + return true; +} +*/ +QString Recurrence::recurrenceText() const +{ + QString recurText = i18n("No"); + if ( recurs == Recurrence::rMinutely ) + recurText = i18n("minutely"); + else if ( recurs == Recurrence::rHourly ) + recurText = i18n("hourly"); + else if ( recurs == Recurrence::rDaily ) + recurText = i18n("daily"); + else if ( recurs == Recurrence::rWeekly ) + recurText = i18n("weekly"); + else if ( recurs == Recurrence::rMonthlyPos ) + recurText = i18n("monthly"); + else if ( recurs == Recurrence::rMonthlyDay ) + recurText = i18n("day-monthly"); + else if ( recurs == Recurrence::rYearlyMonth ) + recurText = i18n("month-yearly"); + else if ( recurs == Recurrence::rYearlyDay ) + recurText = i18n("day-yearly"); + else if ( recurs == Recurrence::rYearlyPos ) + recurText = i18n("position-yearly"); + return recurText; +} + +void Recurrence::setCompatVersion(int version) +{ + mCompatVersion = version ? version : INT_MAX; +} + +ushort Recurrence::doesRecur() const +{ + return recurs; +} + +bool Recurrence::recursOnPure(const QDate &qd) const +{ + switch(recurs) { + case rMinutely: + return recursSecondly(qd, rFreq*60); + case rHourly: + return recursSecondly(qd, rFreq*3600); + case rDaily: + return recursDaily(qd); + case rWeekly: + return recursWeekly(qd); + case rMonthlyPos: + case rMonthlyDay: + return recursMonthly(qd); + case rYearlyMonth: + return recursYearlyByMonth(qd); + case rYearlyDay: + return recursYearlyByDay(qd); + case rYearlyPos: + return recursYearlyByPos(qd); + default: + return false; + case rNone: + return false; + } // case + return false; +} + +bool Recurrence::recursAtPure(const QDateTime &dt) const +{ + switch(recurs) { + case rMinutely: + return recursMinutelyAt(dt, rFreq); + case rHourly: + return recursMinutelyAt(dt, rFreq*60); + default: + if (dt.time() != mRecurStart.time()) + return false; + switch(recurs) { + case rDaily: + return recursDaily(dt.date()); + case rWeekly: + return recursWeekly(dt.date()); + case rMonthlyPos: + case rMonthlyDay: + return recursMonthly(dt.date()); + case rYearlyMonth: + return recursYearlyByMonth(dt.date()); + case rYearlyDay: + return recursYearlyByDay(dt.date()); + case rYearlyPos: + return recursYearlyByPos(dt.date()); + default: + return false; + case rNone: + return false; + } + } // case + return false; +} + +QDate Recurrence::endDate() const +{ + int count = 0; + QDate end; + if (recurs != rNone) { + if (rDuration < 0) + return QDate(); // infinite recurrence + if (rDuration == 0) + return rEndDateTime.date(); + + // The end date is determined by the recurrence count + QDate dStart = mRecurStart.date(); + switch (recurs) + { + case rMinutely: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*60).date(); + case rHourly: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*3600).date(); + case rDaily: + return dStart.addDays((rDuration-1+mRecurExDatesCount)*rFreq); + + case rWeekly: + count = weeklyCalc(END_DATE_AND_COUNT, end); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyMonth: + count = yearlyMonthCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyDay: + count = yearlyDayCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyPos: + count = yearlyPosCalc(END_DATE_AND_COUNT, end); + break; + default: + // catch-all. Should never get here. + kdDebug(5800) << "Control should never reach here in endDate()!" << endl; + break; + } + } + if (!count) + return QDate(); // error - there is no recurrence + return end; +} + +QDateTime Recurrence::endDateTime() const +{ + int count = 0; + QDate end; + if (recurs != rNone) { + if (rDuration < 0) + return QDateTime(); // infinite recurrence + if (rDuration == 0) + return rEndDateTime; + + // The end date is determined by the recurrence count + QDate dStart = mRecurStart.date(); + switch (recurs) + { + case rMinutely: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*60); + case rHourly: + return mRecurStart.addSecs((rDuration-1+mRecurExDatesCount)*rFreq*3600); + case rDaily: + return dStart.addDays((rDuration-1+mRecurExDatesCount)*rFreq); + + case rWeekly: + count = weeklyCalc(END_DATE_AND_COUNT, end); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyMonth: + count = yearlyMonthCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyDay: + count = yearlyDayCalc(END_DATE_AND_COUNT, end); + break; + case rYearlyPos: + count = yearlyPosCalc(END_DATE_AND_COUNT, end); + break; + default: + // catch-all. Should never get here. + kdDebug(5800) << "Control should never reach here in endDate()!" << endl; + break; + } + } + if (!count) + return QDateTime(); // error - there is no recurrence + return QDateTime(end, mRecurStart.time()); +} + +int Recurrence::durationTo(const QDate &date) const +{ + QDate d = date; + return recurCalc(COUNT_TO_DATE, d); +} + +int Recurrence::durationTo(const QDateTime &datetime) const +{ + QDateTime dt = datetime; + return recurCalc(COUNT_TO_DATE, dt); +} + +void Recurrence::unsetRecurs() +{ + if (mRecurReadOnly) return; + recurs = rNone; + rMonthPositions.clear(); + rMonthDays.clear(); + rYearNums.clear(); +} + +void Recurrence::setRecurStart(const QDateTime &start) +{ + mRecurStart = start; + mFloats = false; + switch (recurs) + { + case rMinutely: + case rHourly: + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + default: + rEndDateTime.setTime(start.time()); + break; + } +} + +void Recurrence::setRecurStart(const QDate &start) +{ + mRecurStart.setDate(start); + mRecurStart.setTime(QTime(0,0,0)); + switch (recurs) + { + case rMinutely: + case rHourly: + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + default: + mFloats = true; + break; + } +} + +void Recurrence::setFloats(bool f) +{ + switch (recurs) + { + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + break; + case rMinutely: + case rHourly: + default: + return; // can't set sub-daily to floating + } + mFloats = f; + if (f) { + mRecurStart.setTime(QTime(0,0,0)); + rEndDateTime.setTime(QTime(0,0,0)); + } +} + +int Recurrence::frequency() const +{ + return rFreq; +} + +int Recurrence::duration() const +{ + return rDuration; +} + +void Recurrence::setDuration(int _rDuration) +{ + if (mRecurReadOnly) return; + if (_rDuration > 0) { + rDuration = _rDuration; + // Compatibility mode is only needed when reading the calendar in ICalFormatImpl, + // so explicitly setting the duration means no backwards compatibility is needed. + mCompatDuration = 0; + } +} + +QString Recurrence::endDateStr(bool shortfmt) const +{ + return KGlobal::locale()->formatDate(rEndDateTime.date(),shortfmt); +} + +const QBitArray &Recurrence::days() const +{ + return rDays; +} + +const QPtrList<Recurrence::rMonthPos> &Recurrence::monthPositions() const +{ + return rMonthPositions; +} + +const QPtrList<Recurrence::rMonthPos> &Recurrence::yearMonthPositions() const +{ + return rMonthPositions; +} + +const QPtrList<int> &Recurrence::monthDays() const +{ + return rMonthDays; +} + +void Recurrence::setMinutely(int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + setDailySub(rMinutely, _rFreq, _rDuration); +} + +void Recurrence::setMinutely(int _rFreq, const QDateTime &_rEndDateTime) +{ + if (mRecurReadOnly) return; + rEndDateTime = _rEndDateTime; + setDailySub(rMinutely, _rFreq, 0); +} + +void Recurrence::setHourly(int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + setDailySub(rHourly, _rFreq, _rDuration); +} + +void Recurrence::setHourly(int _rFreq, const QDateTime &_rEndDateTime) +{ + if (mRecurReadOnly) return; + rEndDateTime = _rEndDateTime; + setDailySub(rHourly, _rFreq, 0); +} + +void Recurrence::setDaily(int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + setDailySub(rDaily, _rFreq, _rDuration); +} + +void Recurrence::setDaily(int _rFreq, const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + setDailySub(rDaily, _rFreq, 0); +} + +void Recurrence::setWeekly(int _rFreq, const QBitArray &_rDays, + int _rDuration, int _rWeekStart) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + recurs = rWeekly; + + rFreq = _rFreq; + rDays = _rDays; + rWeekStart = _rWeekStart; + rDuration = _rDuration; + if (mCompatVersion < 310 && _rDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur, + // with week start always on a Monday. + // Convert this to the number of occurrences. + mCompatDuration = _rDuration; + int weeks = ((mCompatDuration-1+mRecurExDatesCount)*7) + (7 - mRecurStart.date().dayOfWeek()); + QDate end(mRecurStart.date().addDays(weeks * rFreq)); + rDuration = INT_MAX; // ensure that weeklyCalc() does its job correctly + rDuration = weeklyCalc(COUNT_TO_DATE, end); + } else { + mCompatDuration = 0; + } + rMonthPositions.clear(); + rMonthDays.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::setWeekly(int _rFreq, const QBitArray &_rDays, + const QDate &_rEndDate, int _rWeekStart) +{ + if (mRecurReadOnly) return; + recurs = rWeekly; + + rFreq = _rFreq; + rDays = _rDays; + rWeekStart = _rWeekStart; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + rDuration = 0; // set to 0 because there is an end date + mCompatDuration = 0; + rMonthPositions.clear(); + rMonthDays.clear(); + rYearNums.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::setMonthly(short type, int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + recurs = type; + + rFreq = _rFreq; + rDuration = _rDuration; + if (mCompatVersion < 310) + mCompatDuration = (_rDuration > 0) ? _rDuration : 0; + rYearNums.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::setMonthly(short type, int _rFreq, + const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + recurs = type; + + rFreq = _rFreq; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + rDuration = 0; // set to 0 because there is an end date + mCompatDuration = 0; + rYearNums.clear(); + if (mParent) mParent->updated(); +} + +void Recurrence::addMonthlyPos(short _rPos, const QBitArray &_rDays) +{ + if (recurs == rMonthlyPos) + addMonthlyPos_(_rPos, _rDays); +} + +void Recurrence::addMonthlyPos_(short _rPos, const QBitArray &_rDays) +{ + if (mRecurReadOnly + || _rPos == 0 || _rPos > 5 || _rPos < -5) // invalid week number + return; + + for (rMonthPos* it = rMonthPositions.first(); it; it = rMonthPositions.next()) { + int itPos = it->negative ? -it->rPos : it->rPos; + if (_rPos == itPos) { + // This week is already in the list. + // Combine the specified days with those in the list. + it->rDays |= _rDays; + if (mParent) mParent->updated(); + return; + } + } + // Add the new position to the list + rMonthPos *tmpPos = new rMonthPos; + if (_rPos > 0) { + tmpPos->rPos = _rPos; + tmpPos->negative = false; + } else { + tmpPos->rPos = -_rPos; // take abs() + tmpPos->negative = true; + } + tmpPos->rDays = _rDays; + tmpPos->rDays.detach(); + rMonthPositions.append(tmpPos); + + if (mCompatVersion < 310 && mCompatDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur. + // Convert this to the number of occurrences. + int monthsAhead = (mCompatDuration-1+mRecurExDatesCount) * rFreq; + int month = mRecurStart.date().month() - 1 + monthsAhead; + QDate end(mRecurStart.date().year() + month/12, month%12 + 1, 31); + rDuration = INT_MAX; // ensure that recurCalc() does its job correctly + rDuration = recurCalc(COUNT_TO_DATE, end); + } + + if (mParent) mParent->updated(); +} + +void Recurrence::addMonthlyDay(short _rDay) +{ + if (mRecurReadOnly || recurs != rMonthlyDay + || _rDay == 0 || _rDay > 31 || _rDay < -31) // invalid day number + return; + for (int* it = rMonthDays.first(); it; it = rMonthDays.next()) { + if (_rDay == *it) + return; // this day is already in the list - avoid duplication + } + int *tmpDay = new int; + *tmpDay = _rDay; + rMonthDays.append(tmpDay); + + if (mCompatVersion < 310 && mCompatDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur. + // Convert this to the number of occurrences. + int monthsAhead = (mCompatDuration-1+mRecurExDatesCount) * rFreq; + int month = mRecurStart.date().month() - 1 + monthsAhead; + QDate end(mRecurStart.date().year() + month/12, month%12 + 1, 31); + rDuration = INT_MAX; // ensure that recurCalc() does its job correctly + rDuration = recurCalc(COUNT_TO_DATE, end); + } + + if (mParent) mParent->updated(); +} + +void Recurrence::setYearly(int type, int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + if (mCompatVersion < 310) + mCompatDuration = (_rDuration > 0) ? _rDuration : 0; + setYearly_(type, mFeb29YearlyDefaultType, _rFreq, _rDuration); +} + +void Recurrence::setYearly(int type, int _rFreq, const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + mCompatDuration = 0; + setYearly_(type, mFeb29YearlyDefaultType, _rFreq, 0); +} + +void Recurrence::setYearlyByDate(Feb29Type type, int _rFreq, int _rDuration) +{ + if (mRecurReadOnly || _rDuration == 0 || _rDuration < -1) + return; + if (mCompatVersion < 310) + mCompatDuration = (_rDuration > 0) ? _rDuration : 0; + setYearly_(rYearlyMonth, type, _rFreq, _rDuration); +} + +void Recurrence::setYearlyByDate(Feb29Type type, int _rFreq, const QDate &_rEndDate) +{ + if (mRecurReadOnly) return; + rEndDateTime.setDate(_rEndDate); + rEndDateTime.setTime(mRecurStart.time()); + mCompatDuration = 0; + setYearly_(rYearlyMonth, type, _rFreq, 0); +} + +void Recurrence::addYearlyMonthPos(short _rPos, const QBitArray &_rDays) +{ + if (recurs == rYearlyPos) + addMonthlyPos_(_rPos, _rDays); +} + +const QPtrList<int> &Recurrence::yearNums() const +{ + return rYearNums; +} + +void Recurrence::addYearlyNum(short _rNum) +{ + if (mRecurReadOnly + || (recurs != rYearlyMonth && recurs != rYearlyDay && recurs != rYearlyPos) + || _rNum <= 0) // invalid day/month number + return; + + if (mCompatVersion < 310 && mCompatRecurs == rYearlyDay) { + // Backwards compatibility for KDE < 3.1. + // Dates were stored as day numbers, with a fiddle to take account of leap years. + // Convert the day number to a month. + if (_rNum <= 0 || _rNum > 366 || (_rNum == 366 && mRecurStart.date().daysInYear() < 366)) + return; // invalid day number + _rNum = QDate(mRecurStart.date().year(), 1, 1).addDays(_rNum - 1).month(); + } else + if ((recurs == rYearlyMonth || recurs == rYearlyPos) && _rNum > 12 + || recurs == rYearlyDay && _rNum > 366) + return; // invalid day number + + uint i = 0; + for (int* it = rYearNums.first(); it && _rNum >= *it; it = rYearNums.next()) { + if (_rNum == *it) + return; // this day/month is already in the list - avoid duplication + ++i; + } + + int *tmpNum = new int; + *tmpNum = _rNum; + rYearNums.insert(i, tmpNum); // insert the day/month in a sorted position + + if (mCompatVersion < 310 && mCompatDuration > 0) { + // Backwards compatibility for KDE < 3.1. + // rDuration was set to the number of time periods to recur. + // Convert this to the number of occurrences. + QDate end(mRecurStart.date().year() + (mCompatDuration-1+mRecurExDatesCount)*rFreq, 12, 31); + rDuration = INT_MAX; // ensure that recurCalc() does its job correctly + rDuration = recurCalc(COUNT_TO_DATE, end); + } + + if (mParent) mParent->updated(); +} + + +QDateTime Recurrence::getNextDateTime(const QDateTime &preDateTime, bool *last) const +{ + if (last) + *last = false; + int freq; + switch (recurs) + { + case rMinutely: + freq = rFreq * 60; + break; + case rHourly: + freq = rFreq * 3600; + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: { + QDate preDate = preDateTime.date(); + if (!mFloats && mRecurStart.time() > preDateTime.time()) + preDate = preDate.addDays(-1); + return QDateTime(getNextDateNoTime(preDate, last), mRecurStart.time()); + } + default: + return QDateTime(); + } + + // It's a sub-daily recurrence + if (preDateTime < mRecurStart) + return mRecurStart; + int count = mRecurStart.secsTo(preDateTime) / freq + 2; + if (rDuration > 0) { + if (count > rDuration) + return QDateTime(); + if (last && count == rDuration) + *last = true; + } + QDateTime endtime = mRecurStart.addSecs((count - 1)*freq); + if (rDuration == 0) { + if (endtime > rEndDateTime) + return QDateTime(); + if (last && endtime == rEndDateTime) + *last = true; + } + return endtime; +} + +QDate Recurrence::getNextDate(const QDate &preDate, bool *last) const +{ + if (last) + *last = false; + switch (recurs) + { + case rMinutely: + case rHourly: + return getNextDateTime(QDateTime(preDate, QTime(23,59,59)), last).date(); + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + return getNextDateNoTime(preDate, last); + default: + return QDate(); + } +} + + +QDateTime Recurrence::getPreviousDateTime(const QDateTime &afterDateTime, bool *last) const +{ + if (last) + *last = false; + int freq; + switch (recurs) + { + case rMinutely: + freq = rFreq * 60; + break; + case rHourly: + freq = rFreq * 3600; + break; + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: { + QDate afterDate = afterDateTime.date(); + if (!mFloats && mRecurStart.time() < afterDateTime.time()) + afterDate = afterDate.addDays(1); + return QDateTime(getPreviousDateNoTime(afterDate, last), mRecurStart.time()); + } + default: + return QDateTime(); + } + + // It's a sub-daily recurrence + if (afterDateTime <= mRecurStart) + return QDateTime(); + int count = (mRecurStart.secsTo(afterDateTime) - 1) / freq + 1; + if (rDuration > 0) { + if (count > rDuration) + count = rDuration; + if (last && count == rDuration) + *last = true; + } + QDateTime endtime = mRecurStart.addSecs((count - 1)*freq); + if (rDuration == 0) { + if (endtime > rEndDateTime) + endtime = rEndDateTime; + if (last && endtime == rEndDateTime) + *last = true; + } + return endtime; +} + +QDate Recurrence::getPreviousDate(const QDate &afterDate, bool *last) const +{ + if (last) + *last = false; + switch (recurs) + { + case rMinutely: + case rHourly: + return getPreviousDateTime(QDateTime(afterDate, QTime(0,0,0)), last).date(); + case rDaily: + case rWeekly: + case rMonthlyPos: + case rMonthlyDay: + case rYearlyMonth: + case rYearlyDay: + case rYearlyPos: + return getPreviousDateNoTime(afterDate, last); + default: + return QDate(); + } +} + + +/***************************** PROTECTED FUNCTIONS ***************************/ + +bool Recurrence::recursSecondly(const QDate &qd, int secondFreq) const +{ + if ((qd >= mRecurStart.date()) && + ((rDuration > 0) && (qd <= endDate()) || + ((rDuration == 0) && (qd <= rEndDateTime.date())) || + (rDuration == -1))) { + // The date queried falls within the range of the event. + if (secondFreq < 24*3600) + return true; // the event recurs at least once each day + int after = mRecurStart.secsTo(QDateTime(qd)); + if (after / secondFreq != (after + 24*3600) / secondFreq) + return true; + } + return false; +} + +bool Recurrence::recursMinutelyAt(const QDateTime &dt, int minuteFreq) const +{ + if ((dt >= mRecurStart) && + ((rDuration > 0) && (dt <= endDateTime()) || + ((rDuration == 0) && (dt <= rEndDateTime)) || + (rDuration == -1))) { + // The time queried falls within the range of the event. + if (((mRecurStart.secsTo(dt) / 60) % minuteFreq) == 0) + return true; + } + return false; +} + +bool Recurrence::recursDaily(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + if ((dStart.daysTo(qd) % rFreq) == 0) { + // The date is a day which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + return true; + } + } + return false; +} + +bool Recurrence::recursWeekly(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + if ((dStart.daysTo(qd)/7) % rFreq == 0) { + // The date is in a week which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + // check if the bits set match today. + int i = qd.dayOfWeek()-1; + if (rDays.testBit((uint) i)) + return true; + } + } + return false; +} + +bool Recurrence::recursMonthly(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + int year = qd.year(); + int month = qd.month(); + int day = qd.day(); + // calculate how many months ahead this date is from the original + // event's date + int monthsAhead = (year - dStart.year()) * 12 + (month - dStart.month()); + if ((monthsAhead % rFreq) == 0) { + // The date is in a month which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + QValueList<int> days; + int daysInMonth = qd.daysInMonth(); + if (recurs == rMonthlyDay) + getMonthlyDayDays(days, daysInMonth); + else if (recurs == rMonthlyPos) + getMonthlyPosDays(days, daysInMonth, QDate(year, month, 1).dayOfWeek()); + for (QValueList<int>::Iterator it = days.begin(); it != days.end(); ++it) { + if (*it == day) + return true; + } + // no dates matched + } + } + return false; +} + +bool Recurrence::recursYearlyByMonth(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + int startDay = dStart.day(); + int qday = qd.day(); + int qmonth = qd.month(); + int qyear = qd.year(); + bool match = (qday == startDay); + if (!match && startDay == 29 && dStart.month() == 2) { + // It's a recurrence on February 29th + switch (mFeb29YearlyType) { + case rFeb28: + if (qday == 28 && qmonth == 2 && !QDate::leapYear(qyear)) + match = true; + break; + case rMar1: + if (qday == 1 && qmonth == 3 && !QDate::leapYear(qyear)) { + qmonth = 2; + match = true; + } + break; + case rFeb29: + break; + } + } + + if (match) { + // The day of the month matches. Calculate how many years ahead + // this date is from the original event's date. + int yearsAhead = (qyear - dStart.year()); + if (yearsAhead % rFreq == 0) { + // The date is in a year which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + int i = qmonth; + for (QPtrListIterator<int> qlin(rYearNums); qlin.current(); ++qlin) { + if (i == *qlin.current()) + return true; + } + } + } + } + return false; +} + +bool Recurrence::recursYearlyByPos(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + int year = qd.year(); + int month = qd.month(); + int day = qd.day(); + // calculate how many years ahead this date is from the original + // event's date + int yearsAhead = (year - dStart.year()); + if (yearsAhead % rFreq == 0) { + // The date is in a year which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + for (QPtrListIterator<int> qlin(rYearNums); qlin.current(); ++qlin) { + if (month == *qlin.current()) { + // The month recurs + QValueList<int> days; + getMonthlyPosDays(days, qd.daysInMonth(), QDate(year, month, 1).dayOfWeek()); + for (QValueList<int>::Iterator it = days.begin(); it != days.end(); ++it) { + if (*it == day) + return true; + } + } + } + } + } + return false; +} + +bool Recurrence::recursYearlyByDay(const QDate &qd) const +{ + QDate dStart = mRecurStart.date(); + // calculate how many years ahead this date is from the original + // event's date + int yearsAhead = (qd.year() - dStart.year()); + if (yearsAhead % rFreq == 0) { + // The date is in a year which recurs + if (qd >= dStart + && ((rDuration > 0 && qd <= endDate()) || + (rDuration == 0 && qd <= rEndDateTime.date()) || + rDuration == -1)) { + // The date queried falls within the range of the event. + int i = qd.dayOfYear(); + for (QPtrListIterator<int> qlin(rYearNums); qlin.current(); ++qlin) { + if (i == *qlin.current()) + return true; + } + } + } + return false; +} + +/* Get the date of the next recurrence, after the specified date. + * If 'last' is non-null, '*last' is set to true if the next recurrence is the + * last recurrence, else false. + * Reply = date of next recurrence, or invalid date if none. + */ +QDate Recurrence::getNextDateNoTime(const QDate &preDate, bool *last) const +{ + if (last) + *last = false; + QDate dStart = mRecurStart.date(); + if (preDate < dStart) + return dStart; + QDate earliestDate = preDate.addDays(1); + QDate nextDate; + + switch (recurs) { + case rDaily: + nextDate = dStart.addDays((dStart.daysTo(preDate)/rFreq + 1) * rFreq); + break; + + case rWeekly: { + QDate start = dStart.addDays(1 - dStart.dayOfWeek()); // start of week for dStart + int earliestDayOfWeek = earliestDate.dayOfWeek(); + int weeksAhead = start.daysTo(earliestDate) / 7; + int notThisWeek = weeksAhead % rFreq; // zero if this week is a recurring week + weeksAhead -= notThisWeek; // latest week which recurred + int weekday = 0; + // First check for any remaining day this week, if this week is a recurring week + if (!notThisWeek) + weekday = getFirstDayInWeek(earliestDayOfWeek); + // Check for a day in the next scheduled week + if (!weekday && earliestDayOfWeek > 1) + weekday = getFirstDayInWeek(rWeekStart) + rFreq*7; + if (weekday) + nextDate = start.addDays(weeksAhead*7 + weekday - 1); + break; + } + case rMonthlyDay: + case rMonthlyPos: { + int startYear = dStart.year(); + int startMonth = dStart.month(); // 1..12 + int earliestYear = earliestDate.year(); + int monthsAhead = (earliestYear - startYear)*12 + earliestDate.month() - startMonth; + int notThisMonth = monthsAhead % rFreq; // zero if this month is a recurring month + monthsAhead -= notThisMonth; // latest month which recurred + // Check for the first later day in the current month + if (!notThisMonth) + nextDate = getFirstDateInMonth(earliestDate); + if (!nextDate.isValid() && earliestDate.day() > 1) { + // Check for a day in the next scheduled month + int months = startMonth - 1 + monthsAhead + rFreq; + nextDate = getFirstDateInMonth(QDate(startYear + months/12, months%12 + 1, 1)); + } + break; + } + case rYearlyMonth: + case rYearlyPos: + case rYearlyDay: { + int startYear = dStart.year(); + int yearsAhead = earliestDate.year() - startYear; + int notThisYear = yearsAhead % rFreq; // zero if this year is a recurring year + yearsAhead -= notThisYear; // latest year which recurred + // Check for the first later date in the current year + if (!notThisYear) + nextDate = getFirstDateInYear(earliestDate); + // Check for a date in the next scheduled year + if (!nextDate.isValid() && earliestDate.dayOfYear() > 1) + nextDate = getFirstDateInYear(QDate(startYear + yearsAhead + rFreq, 1, 1)); + break; + } + case rNone: + default: + return QDate(); + } + + if (rDuration >= 0 && nextDate.isValid()) { + // Check that the date found is within the range of the recurrence + QDate end = endDate(); + if (nextDate > end) + return QDate(); + if (last && nextDate == end) + *last = true; + } + return nextDate; +} + +/* Get the date of the last previous recurrence, before the specified date. + * Reply = date of previous recurrence, or invalid date if none. + */ +QDate Recurrence::getPreviousDateNoTime(const QDate &afterDate, bool *last) const +{ + if (last) + *last = false; + QDate dStart = mRecurStart.date(); + QDate latestDate = afterDate.addDays(-1); + if (latestDate < dStart) + return QDate(); + QDate prevDate; + + switch (recurs) { + case rDaily: + prevDate = dStart.addDays((dStart.daysTo(latestDate) / rFreq) * rFreq); + break; + + case rWeekly: { + QDate start = dStart.addDays(1 - dStart.dayOfWeek()); // start of week for dStart + int latestDayOfWeek = latestDate.dayOfWeek(); + int weeksAhead = start.daysTo(latestDate) / 7; + int notThisWeek = weeksAhead % rFreq; // zero if this week is a recurring week + weeksAhead -= notThisWeek; // latest week which recurred + int weekday = 0; + // First check for any previous day this week, if this week is a recurring week + if (!notThisWeek) + weekday = getLastDayInWeek(latestDayOfWeek); + // Check for a day in the previous scheduled week + if (!weekday) { + int weekEnd = (rWeekStart + 5)%7 + 1; + if (latestDayOfWeek < weekEnd) { + if (!notThisWeek) + weeksAhead -= rFreq; + weekday = getLastDayInWeek(weekEnd); + } + } + if (weekday) + prevDate = start.addDays(weeksAhead*7 + weekday - 1); + break; + } + case rMonthlyDay: + case rMonthlyPos: { + int startYear = dStart.year(); + int startMonth = dStart.month(); // 1..12 + int latestYear = latestDate.year(); + int monthsAhead = (latestYear - startYear)*12 + latestDate.month() - startMonth; + int notThisMonth = monthsAhead % rFreq; // zero if this month is a recurring month + monthsAhead -= notThisMonth; // latest month which recurred + // Check for the last earlier day in the current month + if (!notThisMonth) + prevDate = getLastDateInMonth(latestDate); + if (!prevDate.isValid() && latestDate.day() < latestDate.daysInMonth()) { + // Check for a day in the previous scheduled month + if (!notThisMonth) + monthsAhead -= rFreq; + int months = startMonth + monthsAhead; // get the month after the one that recurs + prevDate = getLastDateInMonth(QDate(startYear + months/12, months%12 + 1, 1).addDays(-1)); + } + break; + } + case rYearlyMonth: + case rYearlyPos: + case rYearlyDay: { + int startYear = dStart.year(); + int yearsAhead = latestDate.year() - startYear; + int notThisYear = yearsAhead % rFreq; // zero if this year is a recurring year + yearsAhead -= notThisYear; // latest year which recurred + // Check for the first later date in the current year + if (!notThisYear) + prevDate = getLastDateInYear(latestDate); + if (!prevDate.isValid() && latestDate.dayOfYear() < latestDate.daysInYear()) { + // Check for a date in the next scheduled year + if (!notThisYear) + yearsAhead -= rFreq; + prevDate = getLastDateInYear(QDate(startYear + yearsAhead, 12, 31)); + } + break; + } + case rNone: + default: + return QDate(); + } + + if (prevDate.isValid()) { + // Check that the date found is within the range of the recurrence + if (prevDate < dStart) + return QDate(); + if (rDuration >= 0) { + QDate end = endDate(); + if (prevDate >= end) { + if (last) + *last = true; + return end; + } + } + } + return prevDate; +} + +void Recurrence::setDailySub(short type, int freq, int duration) +{ + recurs = type; + rFreq = freq; + rDuration = duration; + rMonthPositions.clear(); + rMonthDays.clear(); + rYearNums.clear(); + if (type != rDaily) + mFloats = false; // sub-daily types can't be floating + + if (mParent) mParent->updated(); +} + +void Recurrence::setYearly_(short type, Feb29Type feb29type, int freq, int duration) +{ + recurs = type; + if (mCompatVersion < 310 && type == rYearlyDay) { + mCompatRecurs = rYearlyDay; + recurs = rYearlyMonth; // convert old yearly-by-day to yearly-by-month + feb29type = rMar1; // retain the same day number in the year + } + + mFeb29YearlyType = feb29type; + rFreq = freq; + rDuration = duration; + if (type != rYearlyPos) + rMonthPositions.clear(); + rMonthDays.clear(); + if (mParent) mParent->updated(); +} + +int Recurrence::recurCalc(PeriodFunc func, QDateTime &endtime) const +{ + QDate enddate = endtime.date(); + switch (func) { + case END_DATE_AND_COUNT: + if (rDuration < 0) { + endtime = QDateTime(); + return 0; // infinite recurrence + } + if (rDuration == 0) { + endtime = rEndDateTime; + func = COUNT_TO_DATE; + } + break; + case COUNT_TO_DATE: + // Count recurrences up to and including the specified date/time. + if (endtime < mRecurStart) + return 0; + if (rDuration == 0 && endtime > rEndDateTime) + enddate = rEndDateTime.date(); + else if (!mFloats && mRecurStart.time() > endtime.time()) + enddate = enddate.addDays(-1); + break; + case NEXT_AFTER_DATE: + // Find next recurrence AFTER endtime + if (endtime < mRecurStart) { + endtime = mRecurStart; + return 1; + } + if (rDuration == 0 && endtime >= rEndDateTime) { + endtime = QDateTime(); + return 0; + } + if (!mFloats && mRecurStart.time() > endtime.time()) + enddate = enddate.addDays(-1); + break; + default: + endtime = QDateTime(); + return 0; + } + + int count = 0; // default = error + bool timed = false; + switch (recurs) { + case rMinutely: + timed = true; + count = secondlyCalc(func, endtime, rFreq*60); + break; + case rHourly: + timed = true; + count = secondlyCalc(func, endtime, rFreq*3600); + break; + case rDaily: + count = dailyCalc(func, enddate); + break; + case rWeekly: + count = weeklyCalc(func, enddate); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(func, enddate); + break; + case rYearlyMonth: + count = yearlyMonthCalc(func, enddate); + break; + case rYearlyPos: + count = yearlyPosCalc(func, enddate); + break; + case rYearlyDay: + count = yearlyDayCalc(func, enddate); + break; + default: + break; + } + + switch (func) { + case END_DATE_AND_COUNT: + case NEXT_AFTER_DATE: + if (count == 0) + endtime = QDateTime(); + else if (!timed) { + endtime.setDate(enddate); + endtime.setTime(mRecurStart.time()); + } + break; + case COUNT_TO_DATE: + break; + } + return count; +} + +int Recurrence::recurCalc(PeriodFunc func, QDate &enddate) const +{ + QDateTime endtime(enddate, QTime(23,59,59)); + switch (func) { + case END_DATE_AND_COUNT: + if (rDuration < 0) { + enddate = QDate(); + return 0; // infinite recurrence + } + if (rDuration == 0) { + enddate = rEndDateTime.date(); + func = COUNT_TO_DATE; + } + break; + case COUNT_TO_DATE: + // Count recurrences up to and including the specified date. + if (enddate < mRecurStart.date()) + return 0; + if (rDuration == 0 && enddate > rEndDateTime.date()) { + enddate = rEndDateTime.date(); + endtime.setDate(enddate); + } + break; + case NEXT_AFTER_DATE: + if (enddate < mRecurStart.date()) { + enddate = mRecurStart.date(); + return 1; + } + if (rDuration == 0 && enddate >= rEndDateTime.date()) { + enddate = QDate(); + return 0; + } + break; + default: + enddate = QDate(); + return 0; + } + + int count = 0; // default = error + bool timed = false; + switch (recurs) { + case rMinutely: + timed = true; + count = secondlyCalc(func, endtime, rFreq*60); + break; + case rHourly: + timed = true; + count = secondlyCalc(func, endtime, rFreq*3600); + break; + case rDaily: + count = dailyCalc(func, enddate); + break; + case rWeekly: + count = weeklyCalc(func, enddate); + break; + case rMonthlyPos: + case rMonthlyDay: + count = monthlyCalc(func, enddate); + break; + case rYearlyMonth: + count = yearlyMonthCalc(func, enddate); + break; + case rYearlyPos: + count = yearlyPosCalc(func, enddate); + break; + case rYearlyDay: + count = yearlyDayCalc(func, enddate); + break; + default: + break; + } + + switch (func) { + case END_DATE_AND_COUNT: + case NEXT_AFTER_DATE: + if (count == 0) + endtime = QDate(); + else if (timed) + enddate = endtime.date(); + break; + case COUNT_TO_DATE: + break; + } + return count; +} + +/* Find count and, depending on 'func', the end date/time of a secondly recurrence. + * Reply = total number of occurrences up to 'endtime', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'endtime' is updated to the + * recurrence end date/time. + */ +int Recurrence::secondlyCalc(PeriodFunc func, QDateTime &endtime, int freq) const +{ + switch (func) { + case END_DATE_AND_COUNT: + endtime = mRecurStart.addSecs((rDuration + mRecurExDatesCount - 1) * freq); + return rDuration + mRecurExDatesCount; + case COUNT_TO_DATE: { + int n = mRecurStart.secsTo(endtime)/freq + 1; + if (rDuration > 0 && n > rDuration + mRecurExDatesCount) + return rDuration + mRecurExDatesCount; + return n; + } + case NEXT_AFTER_DATE: { + int count = mRecurStart.secsTo(endtime) / freq + 2; + if (rDuration > 0 && count > rDuration) + return 0; + endtime = mRecurStart.addSecs((count - 1)*freq); + return count; + } + } + return 0; +} + +/* Find count and, depending on 'func', the end date of a daily recurrence. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +int Recurrence::dailyCalc(PeriodFunc func, QDate &enddate) const +{ + QDate dStart = mRecurStart.date(); + switch (func) { + case END_DATE_AND_COUNT: + enddate = dStart.addDays((rDuration + mRecurExDatesCount - 1) * rFreq); + return rDuration + mRecurExDatesCount; + case COUNT_TO_DATE: { + int n = dStart.daysTo(enddate)/rFreq + 1; + if (rDuration > 0 && n > rDuration + mRecurExDatesCount) + return rDuration + mRecurExDatesCount; + return n; + } + case NEXT_AFTER_DATE: { + int count = dStart.daysTo(enddate) / rFreq + 2; + if (rDuration > 0 && count > rDuration) + return 0; + enddate = dStart.addDays((count - 1)*rFreq); + return count; + } + } + return 0; +} + +/* Find count and, depending on 'func', the end date of a weekly recurrence. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +int Recurrence::weeklyCalc(PeriodFunc func, QDate &enddate) const +{ + int daysPerWeek = 0; + for (int i = 0; i < 7; ++i) { + if (rDays.testBit((uint)i)) + ++daysPerWeek; + } + if (!daysPerWeek) + return 0; // there are no days to recur on + + switch (func) { + case END_DATE_AND_COUNT: + return weeklyCalcEndDate(enddate, daysPerWeek); + case COUNT_TO_DATE: + return weeklyCalcToDate(enddate, daysPerWeek); + case NEXT_AFTER_DATE: + return weeklyCalcNextAfter(enddate, daysPerWeek); + } + return 0; +} + +int Recurrence::weeklyCalcEndDate(QDate &enddate, int daysPerWeek) const +{ + int startDayOfWeek = mRecurStart.date().dayOfWeek(); // 1..7 + int countGone = 0; + int daysGone = 0; + uint countTogo = rDuration + mRecurExDatesCount; + if (startDayOfWeek != rWeekStart) { + // Check what remains of the start week + for (int i = startDayOfWeek - 1; i != rWeekStart - 1; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (--countTogo == 0) + break; + } + } + daysGone += 7 * (rFreq - 1); + } + if (countTogo) { + // Skip the remaining whole weeks + // Leave at least 1 recurrence remaining, in order to get its date + int wholeWeeks = (countTogo - 1) / daysPerWeek; + daysGone += wholeWeeks * 7 * rFreq; + countGone += wholeWeeks * daysPerWeek; + countTogo -= wholeWeeks * daysPerWeek; + // Check the last week in the recurrence + for (int i = rWeekStart - 1; ; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (--countTogo == 0) + break; + } + } + } + enddate = mRecurStart.date().addDays(daysGone); + return countGone; +} + +int Recurrence::weeklyCalcToDate(const QDate &enddate, int daysPerWeek) const +{ + QDate dStart = mRecurStart.date(); + int startDayOfWeek = dStart.dayOfWeek(); // 1..7 + int countGone = 0; + int daysGone = 0; + int totalDays = dStart.daysTo(enddate) + 1; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + + if (startDayOfWeek != rWeekStart) { + // Check what remains of the start week + for (int i = startDayOfWeek - 1; i != rWeekStart - 1; i = (i + 1) % 7) { + if (rDays.testBit((uint)i)) { + if (++countGone >= countMax) + return countMax; + } + if (++daysGone == totalDays) + return countGone; + } + daysGone += 7 * (rFreq - 1); + if (daysGone >= totalDays) + return countGone; + } + // Skip the remaining whole weeks + int wholeWeeks = (totalDays - daysGone) / 7; + countGone += (wholeWeeks / rFreq) * daysPerWeek; + if (countGone >= countMax) + return countMax; + daysGone += wholeWeeks * 7; + if (daysGone >= totalDays // have we reached the end date? + || wholeWeeks % rFreq) // is end week a recurrence week? + return countGone; + + // Check the last week in the recurrence + for (int i = rWeekStart - 1; ; i = (i + 1) % 7) { + if (rDays.testBit((uint)i)) { + if (++countGone >= countMax) + return countMax; + } + if (++daysGone == totalDays) + return countGone; + } + return countGone; +} + +int Recurrence::weeklyCalcNextAfter(QDate &enddate, int daysPerWeek) const +{ + QDate dStart = mRecurStart.date(); + int startDayOfWeek = dStart.dayOfWeek(); // 1..7 + int totalDays = dStart.daysTo(enddate) + 1; + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int daysGone = 0; + int recurWeeks; + + if (startDayOfWeek != rWeekStart) { + // Check what remains of the start week + for (int i = startDayOfWeek - 1; i != rWeekStart - 1; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (daysGone > totalDays) + goto ex; + if (--countTogo == 0) + return 0; + } + } + daysGone += 7 * (rFreq - 1); + } + + // Skip the remaining whole weeks + recurWeeks = (totalDays - daysGone) / (7 * rFreq); + if (recurWeeks) { + int n = recurWeeks * daysPerWeek; + if (static_cast<uint>(n) > countTogo) + return 0; // reached end of recurrence + countGone += n; + countTogo -= n; + daysGone += recurWeeks * 7 * rFreq; + } + + // Check the last week or two in the recurrence + for ( ; ; ) { + for (int i = rWeekStart - 1; ; i = (i + 1) % 7) { + ++daysGone; + if (rDays.testBit((uint)i)) { + ++countGone; + if (daysGone > totalDays) + goto ex; + if (--countTogo == 0) + return 0; + } + } + daysGone += 7 * (rFreq - 1); + } +ex: + enddate = dStart.addDays(daysGone); + return countGone; +} + +/* Find count and, depending on 'func', the end date of a monthly recurrence. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::MonthlyData { + const Recurrence *recurrence; + int year; // current year + int month; // current month 0..11 + int day; // current day of month 1..31 + bool varies; // true if recurring days vary between different months + private: + QValueList<int> days28, days29, days30, days31; // recurring days in months of each length + QValueList<int> *recurDays[4]; + public: + MonthlyData(const Recurrence* r, const QDate &date) + : recurrence(r), year(date.year()), month(date.month()-1), day(date.day()) + { recurDays[0] = &days28; + recurDays[1] = &days29; + recurDays[2] = &days30; + recurDays[3] = &days31; + varies = (recurrence->recurs == rMonthlyPos) + ? true : recurrence->getMonthlyDayDays(days31, 31); + } + const QValueList<int>* dayList() const { + if (!varies) + return &days31; + QDate startOfMonth(year, month + 1, 1); + int daysInMonth = startOfMonth.daysInMonth(); + QValueList<int>* days = recurDays[daysInMonth - 28]; + if (recurrence->recurs == rMonthlyPos) + recurrence->getMonthlyPosDays(*days, daysInMonth, startOfMonth.dayOfWeek()); + else if (days->isEmpty()) + recurrence->getMonthlyDayDays(*days, daysInMonth); + return days; + } + int yearMonth() const { return year*12 + month; } + void addMonths(int diff) { month += diff; year += month / 12; month %= 12; } + QDate date() const { return QDate(year, month + 1, day); } +}; + +int Recurrence::monthlyCalc(PeriodFunc func, QDate &enddate) const +{ + if (recurs == rMonthlyPos && rMonthPositions.isEmpty() + || recurs == rMonthlyDay && rMonthDays.isEmpty()) + return 0; + + MonthlyData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return monthlyCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return monthlyCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return monthlyCalcNextAfter(enddate, data); + } + return 0; +} + +int Recurrence::monthlyCalcEndDate(QDate &enddate, MonthlyData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + QValueList<int>::ConstIterator it; + const QValueList<int>* days = data.dayList(); + + if (data.day > 1) { + // Check what remains of the start month + for (it = days->begin(); it != days->end(); ++it) { + if (*it >= data.day) { + ++countGone; + if (--countTogo == 0) { + data.day = *it; + break; + } + } + } + if (countTogo) { + data.day = 1; + data.addMonths(rFreq); + } + } + if (countTogo) { + if (data.varies) { + // The number of recurrence days varies from month to month, + // so we need to check month by month. + for ( ; ; ) { + days = data.dayList(); + uint n = days->count(); // number of recurrence days in this month + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.addMonths(rFreq); + } + } else { + // The number of recurrences is the same every month, + // so skip the month-by-month check. + // Skip the remaining whole months, but leave at least + // 1 recurrence remaining, in order to get its date. + int daysPerMonth = days->count(); + int wholeMonths = (countTogo - 1) / daysPerMonth; + data.addMonths(wholeMonths * rFreq); + countGone += wholeMonths * daysPerMonth; + countTogo -= wholeMonths * daysPerMonth; + } + if (countTogo) { + // Check the last month in the recurrence + for (it = days->begin(); it != days->end(); ++it) { + ++countGone; + if (--countTogo == 0) { + data.day = *it; + break; + } + } + } + } + enddate = data.date(); + return countGone; +} + +int Recurrence::monthlyCalcToDate(const QDate &enddate, MonthlyData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endMonth = enddate.month() - 1; // zero-based + int endDay = enddate.day(); + int endYearMonth = endYear*12 + endMonth; + QValueList<int>::ConstIterator it; + const QValueList<int>* days = data.dayList(); + + if (data.day > 1) { + // Check what remains of the start month + for (it = days->begin(); it != days->end(); ++it) { + if (*it >= data.day) { + if (data.yearMonth() == endYearMonth && *it > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + data.day = 1; + data.addMonths(rFreq); + } + + if (data.varies) { + // The number of recurrence days varies from month to month, + // so we need to check month by month. + while (data.yearMonth() < endYearMonth) { + countGone += data.dayList()->count(); + if (countGone >= countMax) + return countMax; + data.addMonths(rFreq); + } + days = data.dayList(); + } else { + // The number of recurrences is the same every month, + // so skip the month-by-month check. + // Skip the remaining whole months. + int daysPerMonth = days->count(); + int wholeMonths = endYearMonth - data.yearMonth(); + countGone += (wholeMonths / rFreq) * daysPerMonth; + if (countGone >= countMax) + return countMax; + if (wholeMonths % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + data.month = endMonth; + } + + // Check the last month in the recurrence + for (it = days->begin(); it != days->end(); ++it) { + if (*it > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + return countGone; +} + +int Recurrence::monthlyCalcNextAfter(QDate &enddate, MonthlyData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endDay = enddate.day(); + int endYearMonth = endYear*12 + enddate.month() - 1; + QValueList<int>::ConstIterator it; + const QValueList<int>* days = data.dayList(); + + if (data.day > 1) { + // Check what remains of the start month + for (it = days->begin(); it != days->end(); ++it) { + if (*it >= data.day) { + ++countGone; + if (data.yearMonth() == endYearMonth && *it > endDay) { + data.day = *it; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.day = 1; + data.addMonths(rFreq); + } + + if (data.varies) { + // The number of recurrence days varies from month to month, + // so we need to check month by month. + while (data.yearMonth() <= endYearMonth) { + days = data.dayList(); + uint n = days->count(); // number of recurrence days in this month + if (data.yearMonth() == endYearMonth && days->last() > endDay) + break; + if (n >= countTogo) + return 0; + countGone += n; + countTogo -= n; + data.addMonths(rFreq); + } + days = data.dayList(); + } else { + // The number of recurrences is the same every month, + // so skip the month-by-month check. + // Skip the remaining whole months to at least end year/month. + int daysPerMonth = days->count(); + int elapsed = endYearMonth - data.yearMonth(); + int recurMonths = (elapsed + rFreq - 1) / rFreq; + if (elapsed % rFreq == 0 && days->last() <= endDay) + ++recurMonths; // required month is after endYearMonth + if (recurMonths) { + int n = recurMonths * daysPerMonth; + if (static_cast<uint>(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.addMonths(recurMonths * rFreq); + } + } + + // Check the last month in the recurrence + for (it = days->begin(); it != days->end(); ++it) { + ++countGone; + if (data.yearMonth() > endYearMonth || *it > endDay) { + data.day = *it; + break; + } + if (--countTogo == 0) + return 0; + } +ex: + enddate = data.date(); + return countGone; +} + + +/* Find count and, depending on 'func', the end date of an annual recurrence by date. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::YearlyMonthData { + const Recurrence *recurrence; + int year; // current year + int month; // current month 1..12 + int day; // current day of month 1..31 + bool leapyear; // true if February 29th recurs and current year is a leap year + bool feb29; // true if February 29th recurs + private: + QValueList<int> months; // recurring months in non-leap years 1..12 + QValueList<int> leapMonths; // recurring months in leap years 1..12 + public: + YearlyMonthData(const Recurrence* r, const QDate &date) + : recurrence(r), year(date.year()), month(date.month()), day(date.day()) + { feb29 = recurrence->getYearlyMonthMonths(day, months, leapMonths); + leapyear = feb29 && QDate::leapYear(year); + } + const QValueList<int>* monthList() const + { return leapyear ? &leapMonths : &months; } + const QValueList<int>* leapMonthList() const { return &leapMonths; } + QDate date() const { return QDate(year, month, day); } +}; + +int Recurrence::yearlyMonthCalc(PeriodFunc func, QDate &enddate) const +{ + if (rYearNums.isEmpty()) + return 0; + YearlyMonthData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return yearlyMonthCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return yearlyMonthCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return yearlyMonthCalcNextAfter(enddate, data); + } + return 0; +} + +// Find total count and end date of an annual recurrence by date. +// Reply = total number of occurrences. +int Recurrence::yearlyMonthCalcEndDate(QDate &enddate, YearlyMonthData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + QValueList<int>::ConstIterator it; + const QValueList<int>* mons = data.monthList(); // get recurring months for this year + + if (data.month > 1) { + // Check what remains of the start year + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it >= data.month) { + ++countGone; + if (--countTogo == 0) { + data.month = *it; + if (data.month == 2 && data.feb29 && !data.leapyear) { + // The recurrence should end on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: + break; + } + } + break; + } + } + } + if (countTogo) { + data.month = 1; + data.year += rFreq; + } + } + if (countTogo) { + if (data.feb29 && mFeb29YearlyType == rFeb29) { + // The number of recurrences is different on leap years, + // so check year-by-year. + for ( ; ; ) { + mons = data.monthList(); + uint n = mons->count(); + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int monthsPerYear = mons->count(); + int wholeYears = (countTogo - 1) / monthsPerYear; + data.year += wholeYears * rFreq; + countGone += wholeYears * monthsPerYear; + countTogo -= wholeYears * monthsPerYear; + } + if (countTogo) { + // Check the last year in the recurrence + for (it = mons->begin(); it != mons->end(); ++it) { + ++countGone; + if (--countTogo == 0) { + data.month = *it; + if (data.month == 2 && data.feb29 && !QDate::leapYear(data.year)) { + // The recurrence should end on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: + break; + } + } + break; + } + } + } + } + enddate = data.date(); + return countGone; +} + +// Find count of an annual recurrence by date. +// Reply = total number of occurrences up to 'enddate'. +int Recurrence::yearlyMonthCalcToDate(const QDate &enddate, YearlyMonthData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + if (endDay < data.day) { + /* The end day of the month is earlier than the recurrence day of the month. + * If Feb 29th recurs and: + * 1) it recurs on Feb 28th in non-leap years, don't adjust the end month + * if enddate is Feb 28th on a non-leap year. + * 2) it recurs on Mar 1st in non-leap years, allow the end month to be + * adjusted to February, to simplify calculations. + */ + if (data.feb29 && !QDate::leapYear(endYear) + && mFeb29YearlyType == rFeb28 && endDay == 28 && endMonth == 2) { + } + else if (--endMonth == 0) { + endMonth = 12; + --endYear; + } + } + QValueList<int>::ConstIterator it; + const QValueList<int>* mons = data.monthList(); + + if (data.month > 1) { + // Check what remains of the start year + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it >= data.month) { + if (data.year == endYear && *it > endMonth) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + data.month = 1; + data.year += rFreq; + } + if (data.feb29 && mFeb29YearlyType == rFeb29) { + // The number of recurrences is different on leap years, + // so check year-by-year. + while (data.year < endYear) { + countGone += data.monthList()->count(); + if (countGone >= countMax) + return countMax; + data.year += rFreq; + } + mons = data.monthList(); + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years. + int monthsPerYear = mons->count(); + int wholeYears = endYear - data.year; + countGone += (wholeYears / rFreq) * monthsPerYear; + if (countGone >= countMax) + return countMax; + if (wholeYears % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + } + + // Check the last year in the recurrence + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it > endMonth) + return countGone; + if (++countGone >= countMax) + return countMax; + } + return countGone; +} + +// Find count and date of first recurrence after 'enddate' of an annual recurrence by date. +// Reply = total number of occurrences up to 'enddate'. +int Recurrence::yearlyMonthCalcNextAfter(QDate &enddate, YearlyMonthData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + bool mar1TooEarly = false; + bool feb28ok = false; + if (endDay < data.day) { + if (data.feb29 && mFeb29YearlyType == rMar1 && endMonth == 3) + mar1TooEarly = true; + if (data.feb29 && mFeb29YearlyType == rFeb28 && endMonth == 2 && endDay == 28) + feb28ok = true; + else if (--endMonth == 0) { + endMonth = 12; + --endYear; + } + } + QValueList<int>::ConstIterator it; + const QValueList<int>* mons = data.monthList(); + + if (data.month > 1) { + // Check what remains of the start year + for (it = mons->begin(); it != mons->end(); ++it) { + if (*it >= data.month) { + ++countGone; + if (data.year == endYear + && ( *it > endMonth && (*it > 3 || !mar1TooEarly) + || *it == 2 && feb28ok && data.leapyear)) { + if (*it == 2 && data.feb29 && !data.leapyear) { + // The next recurrence should be on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.month = 2; + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: // impossible in this context! + break; + } + } + else + data.month = *it; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.month = 1; + data.year += rFreq; + } + + if (data.feb29 && mFeb29YearlyType == rFeb29) { + // The number of recurrences is different on leap years, + // so check year-by-year. + while (data.year <= endYear) { + mons = data.monthList(); + if (data.year == endYear && mons->last() > endMonth) + break; + uint n = mons->count(); + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + mons = data.monthList(); + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years to at least endYear. + int monthsPerYear = mons->count(); + int recurYears = (endYear - data.year + rFreq - 1) / rFreq; + if ((endYear - data.year)%rFreq == 0 + && mons->last() <= endMonth) + ++recurYears; // required year is after endYear + if (recurYears) { + int n = recurYears * monthsPerYear; + if (static_cast<uint>(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.year += recurYears * rFreq; + } + } + + // Check the last year in the recurrence + for (it = mons->begin(); it != mons->end(); ++it) { + ++countGone; + if (data.year > endYear + || ( *it > endMonth && (*it > 3 || !mar1TooEarly) + || *it == 2 && feb28ok && QDate::leapYear(data.year))) { + if (*it == 2 && data.feb29 && !QDate::leapYear(data.year)) { + // The next recurrence should be on February 29th, but it's a non-leap year + switch (mFeb29YearlyType) { + case rFeb28: + data.month = 2; + data.day = 28; + break; + case rMar1: + data.month = 3; + data.day = 1; + break; + case rFeb29: // impossible in this context! + break; + } + } + else + data.month = *it; + break; + } + if (--countTogo == 0) + return 0; + } +ex: + enddate = data.date(); + return countGone; +} + + +/* Find count and, depending on 'func', the end date of an annual recurrence by date. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::YearlyPosData { + const Recurrence *recurrence; + int year; // current year + int month; // current month 1..12 + int day; // current day of month 1..31 + int daysPerMonth; // number of days which recur each month, or -1 if variable + int count; // number of days which recur each year, or -1 if variable + bool varies; // true if number of days varies from year to year + private: + mutable QValueList<int> days; + public: + YearlyPosData(const Recurrence* r, const QDate &date) + : recurrence(r), year(date.year()), month(date.month()), day(date.day()), count(-1) + { if ((daysPerMonth = r->countMonthlyPosDays()) > 0) + count = daysPerMonth * r->rYearNums.count(); + varies = (daysPerMonth < 0); + } + const QValueList<int>* dayList() const { + QDate startOfMonth(year, month, 1); + recurrence->getMonthlyPosDays(days, startOfMonth.daysInMonth(), startOfMonth.dayOfWeek()); + return &days; + } + int yearMonth() const { return year*12 + month - 1; } + void addMonths(int diff) { month += diff - 1; year += month / 12; month = month % 12 + 1; } + QDate date() const { return QDate(year, month, day); } +}; + +int Recurrence::yearlyPosCalc(PeriodFunc func, QDate &enddate) const +{ + if (rYearNums.isEmpty() || rMonthPositions.isEmpty()) + return 0; + YearlyPosData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return yearlyPosCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return yearlyPosCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return yearlyPosCalcNextAfter(enddate, data); + } + return 0; +} + +int Recurrence::yearlyPosCalcEndDate(QDate &enddate, YearlyPosData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + QValueList<int>::ConstIterator id; + const QValueList<int>* days; + + if (data.month > 1 || data.day > 1) { + // Check what remains of the start year + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + // Check what remains of the start month + if (data.day > 1 || data.varies + || static_cast<uint>(data.daysPerMonth) >= countTogo) { + data.month = *im.current(); + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + ++countGone; + if (--countTogo == 0) { + data.month = *im.current(); + data.day = *id; + goto ex; + } + } + } + data.day = 1; + } else { + // The number of days per month is constant, so skip + // the whole month. + countTogo -= data.daysPerMonth; + countGone += data.daysPerMonth; + } + } + } + data.month = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences varies from year to year. + for ( ; ; ) { + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + days = data.dayList(); + int n = days->count(); + if (static_cast<uint>(n) >= countTogo) { + // Check the last month in the recurrence + for (id = days->begin(); id != days->end(); ++id) { + ++countGone; + if (--countTogo == 0) { + data.day = *id; + goto ex; + } + } + } + countTogo -= n; + countGone += n; + } + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int wholeYears = (countTogo - 1) / data.count; + data.year += wholeYears * rFreq; + countGone += wholeYears * data.count; + countTogo -= wholeYears * data.count; + + // Check the last year in the recurrence. + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + if (static_cast<uint>(data.daysPerMonth) >= countTogo) { + // Check the last month in the recurrence + data.month = *im.current(); + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + ++countGone; + if (--countTogo == 0) { + data.day = *id; + goto ex; + } + } + } + countTogo -= data.daysPerMonth; + countGone += data.daysPerMonth; + } + data.year += rFreq; + } +ex: + enddate = data.date(); + return countGone; +} + +int Recurrence::yearlyPosCalcToDate(const QDate &enddate, YearlyPosData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + if (endDay < data.day && --endMonth == 0) { + endMonth = 12; + --endYear; + } + int endYearMonth = endYear*12 + endMonth; + QValueList<int>::ConstIterator id; + const QValueList<int>* days; + + if (data.month > 1 || data.day > 1) { + // Check what remains of the start year + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + data.month = *im.current(); + if (data.yearMonth() > endYearMonth) + return countGone; + // Check what remains of the start month + bool lastMonth = (data.yearMonth() == endYearMonth); + if (lastMonth || data.day > 1 || data.varies) { + days = data.dayList(); + if (lastMonth || data.day > 1) { + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + if (lastMonth && *id > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + } else { + countGone += days->count(); + if (countGone >= countMax) + return countMax; + } + data.day = 1; + } else { + // The number of days per month is constant, so skip + // the whole month. + countGone += data.daysPerMonth; + if (countGone >= countMax) + return countMax; + } + } + } + data.month = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences varies from year to year. + for ( ; ; ) { + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + days = data.dayList(); + if (data.yearMonth() >= endYearMonth) { + if (data.yearMonth() > endYearMonth) + return countGone; + // Check the last month in the recurrence + for (id = days->begin(); id != days->end(); ++id) { + if (*id > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } else { + countGone += days->count(); + if (countGone >= countMax) + return countMax; + } + } + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int wholeYears = endYear - data.year; + countGone += (wholeYears / rFreq) * data.count; + if (countGone >= countMax) + return countMax; + if (wholeYears % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + + // Check the last year in the recurrence. + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + if (data.month >= endMonth) { + if (data.month > endMonth) + return countGone; + // Check the last month in the recurrence + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + if (*id > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } else { + countGone += data.daysPerMonth; + if (countGone >= countMax) + return countMax; + } + } + } + return countGone; +} + +int Recurrence::yearlyPosCalcNextAfter(QDate &enddate, YearlyPosData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endMonth = enddate.month(); + int endDay = enddate.day(); + if (endDay < data.day && --endMonth == 0) { + endMonth = 12; + --endYear; + } + int endYearMonth = endYear*12 + endMonth; + QValueList<int>::ConstIterator id; + const QValueList<int>* days; + + if (data.varies) { + // The number of recurrences varies from year to year. + for ( ; ; ) { + // Check the next year + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + // Check the next month + data.month = *im.current(); + int ended = data.yearMonth() - endYearMonth; + days = data.dayList(); + if (ended >= 0 || data.day > 1) { + // This is the start or end month, so check each day + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + ++countGone; + if (ended > 0 || (ended == 0 && *id > endDay)) { + data.day = *id; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + } else { + // Skip the whole month + uint n = days->count(); + if (n >= countTogo) + return 0; + countGone += n; + } + data.day = 1; // we've checked the start month now + } + } + data.month = 1; // we've checked the start year now + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year. + if (data.month > 1 || data.day > 1) { + // Check what remains of the start year + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + if (*im.current() >= data.month) { + // Check what remains of the start month + data.month = *im.current(); + int ended = data.yearMonth() - endYearMonth; + if (ended >= 0 || data.day > 1) { + // This is the start or end month, so check each day + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + if (*id >= data.day) { + ++countGone; + if (ended > 0 || (ended == 0 && *id > endDay)) { + data.day = *id; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.day = 1; // we've checked the start month now + } else { + // Skip the whole month. + if (static_cast<uint>(data.daysPerMonth) >= countTogo) + return 0; + countGone += data.daysPerMonth; + } + } + } + data.year += rFreq; + } + // Skip the remaining whole years to at least endYear. + int recurYears = (endYear - data.year + rFreq - 1) / rFreq; + if ((endYear - data.year)%rFreq == 0 + && *rYearNums.getLast() <= endMonth) + ++recurYears; // required year is after endYear + if (recurYears) { + int n = recurYears * data.count; + if (static_cast<uint>(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.year += recurYears * rFreq; + } + + // Check the last year in the recurrence + for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) { + data.month = *im.current(); + int ended = data.yearMonth() - endYearMonth; + if (ended >= 0) { + // This is the end month, so check each day + days = data.dayList(); + for (id = days->begin(); id != days->end(); ++id) { + ++countGone; + if (ended > 0 || (ended == 0 && *id > endDay)) { + data.day = *id; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } else { + // Skip the whole month. + if (static_cast<uint>(data.daysPerMonth) >= countTogo) + return 0; + countGone += data.daysPerMonth; + } + } + } +ex: + enddate = data.date(); + return countGone; +} + + +/* Find count and, depending on 'func', the end date of an annual recurrence by day. + * Reply = total number of occurrences up to 'enddate', or 0 if error. + * If 'func' = END_DATE_AND_COUNT or NEXT_AFTER_DATE, 'enddate' is updated to the + * recurrence end date. + */ +struct Recurrence::YearlyDayData { + int year; // current year + int day; // current day of year 1..366 + bool varies; // true if day 366 recurs + private: + int daycount; + public: + YearlyDayData(const Recurrence* r, const QDate &date) + : year(date.year()), day(date.dayOfYear()), varies(*r->rYearNums.getLast() == 366), + daycount(r->rYearNums.count()) { } + bool leapYear() const { return QDate::leapYear(year); } + int dayCount() const { return daycount - (varies && !QDate::leapYear(year) ? 1 : 0); } + bool isMaxDayCount() const { return !varies || QDate::leapYear(year); } + QDate date() const { return QDate(year, 1, 1).addDays(day - 1); } +}; + +int Recurrence::yearlyDayCalc(PeriodFunc func, QDate &enddate) const +{ + if (rYearNums.isEmpty()) + return 0; + YearlyDayData data(this, mRecurStart.date()); + switch (func) { + case END_DATE_AND_COUNT: + return yearlyDayCalcEndDate(enddate, data); + case COUNT_TO_DATE: + return yearlyDayCalcToDate(enddate, data); + case NEXT_AFTER_DATE: + return yearlyDayCalcNextAfter(enddate, data); + } + return 0; +} + +int Recurrence::yearlyDayCalcEndDate(QDate &enddate, YearlyDayData &data) const +{ + uint countTogo = rDuration + mRecurExDatesCount; + int countGone = 0; + + if (data.day > 1) { + // Check what remains of the start year + bool leapOK = data.isMaxDayCount(); + for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) { + int d = *it.current(); + if (d >= data.day && (leapOK || d < 366)) { + ++countGone; + if (--countTogo == 0) { + data.day = d; + goto ex; + } + } + } + data.day = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences is different in leap years, + // so check year-by-year. + for ( ; ; ) { + uint n = data.dayCount(); + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years, but leave at least + // 1 recurrence remaining, in order to get its date. + int daysPerYear = rYearNums.count(); + int wholeYears = (countTogo - 1) / daysPerYear; + data.year += wholeYears * rFreq; + countGone += wholeYears * daysPerYear; + countTogo -= wholeYears * daysPerYear; + } + if (countTogo) { + // Check the last year in the recurrence + for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) { + ++countGone; + if (--countTogo == 0) { + data.day = *it.current(); + break; + } + } + } +ex: + enddate = data.date(); + return countGone; +} + +int Recurrence::yearlyDayCalcToDate(const QDate &enddate, YearlyDayData &data) const +{ + int countGone = 0; + int countMax = (rDuration > 0) ? rDuration + mRecurExDatesCount : INT_MAX; + int endYear = enddate.year(); + int endDay = enddate.dayOfYear(); + + if (data.day > 1) { + // Check what remains of the start year + bool leapOK = data.isMaxDayCount(); + for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) { + int d = *it.current(); + if (d >= data.day && (leapOK || d < 366)) { + if (data.year == endYear && d > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + data.day = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences is different in leap years, + // so check year-by-year. + while (data.year < endYear) { + uint n = data.dayCount(); + countGone += n; + if (countGone >= countMax) + return countMax; + data.year += rFreq; + } + if (data.year > endYear) + return countGone; + } else { + // The number of recurrences is the same every year. + // Skip the remaining whole years. + int wholeYears = endYear - data.year; + countGone += (wholeYears / rFreq) * rYearNums.count(); + if (countGone >= countMax) + return countMax; + if (wholeYears % rFreq) + return countGone; // end year isn't a recurrence year + data.year = endYear; + } + + if (data.year <= endYear) { + // Check the last year in the recurrence + for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) { + if (*it.current() > endDay) + return countGone; + if (++countGone >= countMax) + return countMax; + } + } + return countGone; +} + +int Recurrence::yearlyDayCalcNextAfter(QDate &enddate, YearlyDayData &data) const +{ + uint countTogo = (rDuration > 0) ? rDuration + mRecurExDatesCount : UINT_MAX; + int countGone = 0; + int endYear = enddate.year(); + int endDay = enddate.dayOfYear(); + + if (data.day > 1) { + // Check what remains of the start year + bool leapOK = data.isMaxDayCount(); + for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) { + int d = *it.current(); + if (d >= data.day && (leapOK || d < 366)) { + ++countGone; + if (data.year == endYear && d > endDay) { + data.day = d; + goto ex; + } + if (--countTogo == 0) + return 0; + } + } + data.day = 1; + data.year += rFreq; + } + + if (data.varies) { + // The number of recurrences is different in leap years, + // so check year-by-year. + while (data.year <= endYear) { + uint n = data.dayCount(); + if (data.year == endYear && *rYearNums.getLast() > endDay) + break; + if (n >= countTogo) + break; + countTogo -= n; + countGone += n; + data.year += rFreq; + } + } else { + // The number of recurrences is the same every year, + // so skip the year-by-year check. + // Skip the remaining whole years to at least endYear. + int daysPerYear = rYearNums.count(); + int recurYears = (endYear - data.year + rFreq - 1) / rFreq; + if ((endYear - data.year)%rFreq == 0 + && *rYearNums.getLast() <= endDay) + ++recurYears; // required year is after endYear + if (recurYears) { + int n = recurYears * daysPerYear; + if (static_cast<uint>(n) > countTogo) + return 0; // reached end of recurrence + countTogo -= n; + countGone += n; + data.year += recurYears * rFreq; + } + } + + // Check the last year in the recurrence + for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) { + ++countGone; + int d = *it.current(); + if (data.year > endYear || d > endDay) { + data.day = d; + break; + } + if (--countTogo == 0) + return 0; + } +ex: + enddate = data.date(); + return countGone; +} + +// Get the days in this month which recur, in numerical order. +// Parameters: daysInMonth = number of days in this month +// startDayOfWeek = day of week for first day of month. +void Recurrence::getMonthlyPosDays(QValueList<int> &list, int daysInMonth, int startDayOfWeek) const +{ + list.clear(); + int endDayOfWeek = (startDayOfWeek + daysInMonth - 2) % 7 + 1; + // Go through the list, compiling a bit list of actual day numbers + Q_UINT32 days = 0; + for (QPtrListIterator<rMonthPos> pos(rMonthPositions); pos.current(); ++pos) { + int weeknum = pos.current()->rPos - 1; // get 0-based week number + QBitArray &rdays = pos.current()->rDays; + if (pos.current()->negative) { + // nth days before the end of the month + for (uint i = 1; i <= 7; ++i) { + if (rdays.testBit(i - 1)) { + int day = daysInMonth - weeknum*7 - (endDayOfWeek - i + 7) % 7; + if (day > 0) + days |= 1 << (day - 1); + } + } + } else { + // nth days after the start of the month + for (uint i = 1; i <= 7; ++i) { + if (rdays.testBit(i - 1)) { + int day = 1 + weeknum*7 + (i - startDayOfWeek + 7) % 7; + if (day <= daysInMonth) + days |= 1 << (day - 1); + } + } + } + } + // Compile the ordered list + Q_UINT32 mask = 1; + for (int i = 0; i < daysInMonth; mask <<= 1, ++i) { + if (days & mask) + list.append(i + 1); + } +} + +// Get the number of days in the month which recur. +// Reply = -1 if the number varies from month to month. +int Recurrence::countMonthlyPosDays() const +{ + int count = 0; + Q_UINT8 positive[5] = { 0, 0, 0, 0, 0 }; + Q_UINT8 negative[4] = { 0, 0, 0, 0 }; + for (QPtrListIterator<rMonthPos> pos(rMonthPositions); pos.current(); ++pos) { + int weeknum = pos.current()->rPos; + Q_UINT8* wk; + if (pos.current()->negative) { + // nth days before the end of the month + if (weeknum > 4) + return -1; // days in 5th week are often missing + wk = &negative[4 - weeknum]; + } else { + // nth days after the start of the month + if (weeknum > 4) + return -1; // days in 5th week are often missing + wk = &positive[weeknum - 1]; + } + QBitArray &rdays = pos.current()->rDays; + for (uint i = 0; i < 7; ++i) { + if (rdays.testBit(i)) { + ++count; + *wk |= (1 << i); + } + } + } + // Check for any possible days which could be duplicated by + // a positive and a negative position. + for (int i = 0; i < 4; ++i) { + if (negative[i] & (positive[i] | positive[i+1])) + return -1; + } + return count; +} + +// Get the days in this month which recur, in numerical order. +// Reply = true if day numbers varies from month to month. +bool Recurrence::getMonthlyDayDays(QValueList<int> &list, int daysInMonth) const +{ + list.clear(); + bool variable = false; + Q_UINT32 days = 0; + for (QPtrListIterator<int> it(rMonthDays); it.current(); ++it) { + int day = *it.current(); + if (day > 0) { + // date in the month + if (day <= daysInMonth) + days |= 1 << (day - 1); + if (day > 28 && day <= 31) + variable = true; // this date does not appear in some months + } else if (day < 0) { + // days before the end of the month + variable = true; // this date varies depending on the month length + day = daysInMonth + day; // zero-based day of month + if (day >= 0) + days |= 1 << day; + } + } + // Compile the ordered list + Q_UINT32 mask = 1; + for (int i = 0; i < daysInMonth; mask <<= 1, ++i) { + if (days & mask) + list.append(i + 1); + } + return variable; +} + +// Get the months which recur, in numerical order, for both leap years and non-leap years. +// N.B. If February 29th recurs on March 1st in non-leap years, February (not March) is +// included in the non-leap year month list. +// Reply = true if February 29th also recurs. +bool Recurrence::getYearlyMonthMonths(int day, QValueList<int> &list, QValueList<int> &leaplist) const +{ + list.clear(); + leaplist.clear(); + bool feb29 = false; + for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) { + int month = *it.current(); + if (month == 2) { + if (day <= 28) { + list.append(month); // date appears in February + leaplist.append(month); + } + else if (day == 29) { + // February 29th + leaplist.append(month); + switch (mFeb29YearlyType) { + case rFeb28: + case rMar1: + list.append(2); + break; + case rFeb29: + break; + } + feb29 = true; + } + } + else if (day <= 30 || QDate(2000, month, 1).daysInMonth() == 31) { + list.append(month); // date appears in every month + leaplist.append(month); + } + } + return feb29; +} + +/* From the recurrence day of the week list, get the earliest day in the + * specified week which is >= the startDay. + * Parameters: startDay = 1..7 (Monday..Sunday) + * useWeekStart = true to end search at day before next rWeekStart + * = false to search for a full 7 days + * Reply = day of the week (1..7), or 0 if none found. + */ +int Recurrence::getFirstDayInWeek(int startDay, bool useWeekStart) const +{ + int last = ((useWeekStart ? rWeekStart : startDay) + 5)%7; + for (int i = startDay - 1; ; i = (i + 1)%7) { + if (rDays.testBit(i)) + return i + 1; + if (i == last) + return 0; + } +} + +/* From the recurrence day of the week list, get the latest day in the + * specified week which is <= the endDay. + * Parameters: endDay = 1..7 (Monday..Sunday) + * useWeekStart = true to end search at rWeekStart + * = false to search for a full 7 days + * Reply = day of the week (1..7), or 0 if none found. + */ +int Recurrence::getLastDayInWeek(int endDay, bool useWeekStart) const +{ + int last = useWeekStart ? rWeekStart - 1 : endDay%7; + for (int i = endDay - 1; ; i = (i + 6)%7) { + if (rDays.testBit(i)) + return i + 1; + if (i == last) + return 0; + } +} + +/* From the recurrence monthly day number list or monthly day of week/week of + * month list, get the earliest day in the specified month which is >= the + * earliestDate. + */ +QDate Recurrence::getFirstDateInMonth(const QDate &earliestDate) const +{ + int earliestDay = earliestDate.day(); + int daysInMonth = earliestDate.daysInMonth(); + switch (recurs) { + case rMonthlyDay: { + int minday = daysInMonth + 1; + for (QPtrListIterator<int> it(rMonthDays); it.current(); ++it) { + int day = *it.current(); + if (day < 0) + day = daysInMonth + day + 1; + if (day >= earliestDay && day < minday) + minday = day; + } + if (minday <= daysInMonth) + return earliestDate.addDays(minday - earliestDay); + break; + } + case rMonthlyPos: + case rYearlyPos: { + QDate monthBegin(earliestDate.addDays(1 - earliestDay)); + QValueList<int> dayList; + getMonthlyPosDays(dayList, daysInMonth, monthBegin.dayOfWeek()); + for (QValueList<int>::ConstIterator id = dayList.begin(); id != dayList.end(); ++id) { + if (*id >= earliestDay) + return monthBegin.addDays(*id - 1); + } + break; + } + } + return QDate(); +} + +/* From the recurrence monthly day number list or monthly day of week/week of + * month list, get the latest day in the specified month which is <= the + * latestDate. + */ +QDate Recurrence::getLastDateInMonth(const QDate &latestDate) const +{ + int latestDay = latestDate.day(); + int daysInMonth = latestDate.daysInMonth(); + switch (recurs) { + case rMonthlyDay: { + int maxday = -1; + for (QPtrListIterator<int> it(rMonthDays); it.current(); ++it) { + int day = *it.current(); + if (day < 0) + day = daysInMonth + day + 1; + if (day <= latestDay && day > maxday) + maxday = day; + } + if (maxday > 0) + return QDate(latestDate.year(), latestDate.month(), maxday); + break; + } + case rMonthlyPos: + case rYearlyPos: { + QDate monthBegin(latestDate.addDays(1 - latestDay)); + QValueList<int> dayList; + getMonthlyPosDays(dayList, daysInMonth, monthBegin.dayOfWeek()); + for (QValueList<int>::ConstIterator id = dayList.fromLast(); id != dayList.end(); --id) { + if (*id <= latestDay) + return monthBegin.addDays(*id - 1); + } + break; + } + } + return QDate(); +} + +/* From the recurrence yearly month list or yearly day list, get the earliest + * month or day in the specified year which is >= the earliestDate. + * Note that rYearNums is sorted in numerical order. + */ +QDate Recurrence::getFirstDateInYear(const QDate &earliestDate) const +{ + QPtrListIterator<int> it(rYearNums); + switch (recurs) { + case rYearlyMonth: { + int day = recurStart().date().day(); + int earliestYear = earliestDate.year(); + int earliestMonth = earliestDate.month(); + int earliestDay = earliestDate.day(); + if (earliestDay > day) { + // The earliest date is later in the month than the recurrence date, + // so skip to the next month before starting to check + if (++earliestMonth > 12) + return QDate(); + } + for ( ; it.current(); ++it) { + int month = *it.current(); + if (month >= earliestMonth) { + if (day <= 28 || QDate::isValid(earliestYear, month, day)) + return QDate(earliestYear, month, day); + if (day == 29 && month == 2) { + // It's a recurrence on February 29th, in a non-leap year + switch (mFeb29YearlyType) { + case rMar1: + return QDate(earliestYear, 3, 1); + case rFeb28: + if (earliestDay <= 28) + return QDate(earliestYear, 2, 28); + break; + case rFeb29: + break; + } + } + } + } + break; + } + case rYearlyPos: { + QValueList<int> dayList; + int earliestYear = earliestDate.year(); + int earliestMonth = earliestDate.month(); + int earliestDay = earliestDate.day(); + for ( ; it.current(); ++it) { + int month = *it.current(); + if (month >= earliestMonth) { + QDate monthBegin(earliestYear, month, 1); + getMonthlyPosDays(dayList, monthBegin.daysInMonth(), monthBegin.dayOfWeek()); + for (QValueList<int>::ConstIterator id = dayList.begin(); id != dayList.end(); ++id) { + if (*id >= earliestDay) + return monthBegin.addDays(*id - 1); + } + earliestDay = 1; + } + } + break; + } + case rYearlyDay: { + int earliestDay = earliestDate.dayOfYear(); + for ( ; it.current(); ++it) { + int day = *it.current(); + if (day >= earliestDay && (day <= 365 || day <= earliestDate.daysInYear())) + return earliestDate.addDays(day - earliestDay); + } + break; + } + } + return QDate(); +} + +/* From the recurrence yearly month list or yearly day list, get the latest + * month or day in the specified year which is <= the latestDate. + * Note that rYearNums is sorted in numerical order. + */ +QDate Recurrence::getLastDateInYear(const QDate &latestDate) const +{ + QPtrListIterator<int> it(rYearNums); + switch (recurs) { + case rYearlyMonth: { + int day = recurStart().date().day(); + int latestYear = latestDate.year(); + int latestMonth = latestDate.month(); + if (latestDate.day() > day) { + // The latest date is earlier in the month than the recurrence date, + // so skip to the previous month before starting to check + if (--latestMonth <= 0) + return QDate(); + } + for (it.toLast(); it.current(); --it) { + int month = *it.current(); + if (month <= latestMonth) { + if (day <= 28 || QDate::isValid(latestYear, month, day)) + return QDate(latestYear, month, day); + if (day == 29 && month == 2) { + // It's a recurrence on February 29th, in a non-leap year + switch (mFeb29YearlyType) { + case rMar1: + if (latestMonth >= 3) + return QDate(latestYear, 3, 1); + break; + case rFeb28: + return QDate(latestYear, 2, 28); + case rFeb29: + break; + } + } + } + } + break; + } + case rYearlyPos: { + QValueList<int> dayList; + int latestYear = latestDate.year(); + int latestMonth = latestDate.month(); + int latestDay = latestDate.day(); + for (it.toLast(); it.current(); --it) { + int month = *it.current(); + if (month <= latestMonth) { + QDate monthBegin(latestYear, month, 1); + getMonthlyPosDays(dayList, monthBegin.daysInMonth(), monthBegin.dayOfWeek()); + for (QValueList<int>::ConstIterator id = dayList.fromLast(); id != dayList.end(); --id) { + if (*id <= latestDay) + return monthBegin.addDays(*id - 1); + } + latestDay = 31; + } + } + break; + } + case rYearlyDay: { + int latestDay = latestDate.dayOfYear(); + for (it.toLast(); it.current(); --it) { + int day = *it.current(); + if (day <= latestDay) + return latestDate.addDays(day - latestDay); + } + break; + } + } + return QDate(); +} + +void Recurrence::dump() const +{ + kdDebug() << "Recurrence::dump():" << endl; + + kdDebug() << " type: " << recurs << endl; + + kdDebug() << " rDays: " << endl; + int i; + for( i = 0; i < 7; ++i ) { + kdDebug() << " " << i << ": " + << ( rDays.testBit( i ) ? "true" : "false" ) << endl; + } +} |