summaryrefslogtreecommitdiffabout
path: root/libkcal/recurrence.cpp
authorMichael Krelin <hacker@klever.net>2007-07-04 11:23:42 (UTC)
committer Michael Krelin <hacker@klever.net>2007-07-04 11:23:42 (UTC)
commita08aff328d4393031d5ba7d622c2b05705a89d73 (patch) (side-by-side diff)
tree8ee90d686081c52e7c69b5ce946e9b1a7d690001 /libkcal/recurrence.cpp
parent11edc920afe4f274c0964436633aa632c8288a40 (diff)
downloadkdepimpi-p1.zip
kdepimpi-p1.tar.gz
kdepimpi-p1.tar.bz2
initial public commit of qt4 portp1
Diffstat (limited to 'libkcal/recurrence.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--libkcal/recurrence.cpp187
1 files changed, 95 insertions, 92 deletions
diff --git a/libkcal/recurrence.cpp b/libkcal/recurrence.cpp
index 6ee5499..9a4e540 100644
--- a/libkcal/recurrence.cpp
+++ b/libkcal/recurrence.cpp
@@ -1,3401 +1,3404 @@
/*
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"
+//Added by qt3to4:
+#include <Q3ValueList>
+#include <Q3PtrList>
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()),
+ rDays(r.rDays),
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) {
+ for (Q3PtrListIterator<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();
+ tmp->rDays = mp.current()->rDays;
rMonthPositions.append(tmp);
}
- for (QPtrListIterator<int> md(r.rMonthDays); md.current(); ++md) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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: {
- QPtrList<rMonthPos> MonthPositions = rMonthPositions;
- QPtrList<rMonthPos> MonthPositions2 = r2.rMonthPositions;
+ Q3PtrList<rMonthPos> MonthPositions = rMonthPositions;
+ Q3PtrList<rMonthPos> MonthPositions2 = r2.rMonthPositions;
if ( !MonthPositions.count() )
return false;
if ( !MonthPositions2.count() )
return false;
return MonthPositions.first()->rPos == MonthPositions2.first()->rPos;
}
case rMonthlyDay: {
- QPtrList<int> MonthDays = rMonthDays ;
- QPtrList<int> MonthDays2 = r2.rMonthDays ;
+ Q3PtrList<int> MonthDays = rMonthDays ;
+ Q3PtrList<int> MonthDays2 = r2.rMonthDays ;
if ( !MonthDays.count() )
return false;
if ( !MonthDays2.count() )
return false;
return *MonthDays.first() == *MonthDays2.first() ;
}
case rYearlyPos: {
- QPtrList<int> YearNums = rYearNums;
- QPtrList<int> YearNums2 = r2.rYearNums;
+ Q3PtrList<int> YearNums = rYearNums;
+ Q3PtrList<int> YearNums2 = r2.rYearNums;
if ( *YearNums.first() != *YearNums2.first() )
return false;
- QPtrList<rMonthPos> MonthPositions = rMonthPositions;
- QPtrList<rMonthPos> MonthPositions2 = r2.rMonthPositions;
+ Q3PtrList<rMonthPos> MonthPositions = rMonthPositions;
+ Q3PtrList<rMonthPos> MonthPositions2 = r2.rMonthPositions;
if ( !MonthPositions.count() )
return false;
if ( !MonthPositions2.count() )
return false;
return MonthPositions.first()->rPos == MonthPositions2.first()->rPos;
}
case rYearlyMonth: {
- QPtrList<int> YearNums = rYearNums;
- QPtrList<int> YearNums2 = r2.rYearNums;
+ Q3PtrList<int> YearNums = rYearNums;
+ Q3PtrList<int> YearNums2 = r2.rYearNums;
return ( *YearNums.first() == *YearNums2.first() && mFeb29YearlyType == r2.mFeb29YearlyType);
}
case rYearlyDay: {
- QPtrList<int> YearNums = rYearNums;
- QPtrList<int> YearNums2 = r2.rYearNums;
+ Q3PtrList<int> YearNums = rYearNums;
+ Q3PtrList<int> YearNums2 = r2.rYearNums;
return ( *YearNums.first() == *YearNums2.first() );
}
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;
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("monthly");
else if ( recurs == Recurrence::rYearlyMonth )
recurText = i18n("yearly");
else if ( recurs == Recurrence::rYearlyDay )
recurText = i18n("day-yearly");
else if ( recurs == Recurrence::rYearlyPos )
recurText = i18n("position-yearly");
if ( !recurText.isEmpty() ) {
if ( rFreq > 1 ){
recurText = i18n("(%1) ").arg(rFreq ) + recurText;
}
} else
recurText = i18n("No");
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);
+ return (QDateTime)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
+const Q3PtrList<Recurrence::rMonthPos> &Recurrence::monthPositions() const
{
return rMonthPositions;
}
-const QPtrList<Recurrence::rMonthPos> &Recurrence::yearMonthPositions() const
+const Q3PtrList<Recurrence::rMonthPos> &Recurrence::yearMonthPositions() const
{
return rMonthPositions;
}
-const QPtrList<int> &Recurrence::monthDays() const
+const Q3PtrList<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 && recurs != rYearlyMonth)
|| _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
+const Q3PtrList<int> &Recurrence::yearNums() const
{
return rYearNums;
}
void Recurrence::addYearlyMonth(short _rPos )
{
if (mRecurReadOnly || recurs != rYearlyMonth) // invalid day/month number
return;
rMonthPos *tmpPos = new rMonthPos;
if ( _rPos > 0) {
tmpPos->rPos = _rPos;
tmpPos->negative = false;
} else {
tmpPos->rPos = -_rPos; // take abs()
tmpPos->negative = true;
}
rMonthPositions.append(tmpPos);
}
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:
qDebug("Recurrence::getNextDate: MAY BE BROKEN ");
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)) - 1;
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;
+ Q3ValueList<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) {
+ for (Q3ValueList<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<int> qlin(rYearNums); qlin.current(); ++qlin) {
if (month == *qlin.current()) {
// The month recurs
- QValueList<int> days;
+ Q3ValueList<int> days;
getMonthlyPosDays(days, qd.daysInMonth(), QDate(year, month, 1).dayOfWeek());
- for (QValueList<int>::Iterator it = days.begin(); it != days.end(); ++it) {
+ for (Q3ValueList<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) {
+ for (Q3PtrListIterator<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(-((dStart.dayOfWeek() - rWeekStart + 7)%7)); // 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 )
weekday = getFirstDayInWeek(rWeekStart) + rFreq*7;
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() ) {
// 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(-((dStart.dayOfWeek() - rWeekStart + 7)%7)); // 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) {
if (!notThisWeek)
weeksAhead -= rFreq;
int weekEnd = (rWeekStart + 5)%7 + 1;
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();
+ endtime = QDateTime();
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];
+ Q3ValueList<int> days28, days29, days30, days31; // recurring days in months of each length
+ Q3ValueList<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 {
+ const Q3ValueList<int>* dayList() const {
if (!varies)
return &days31;
QDate startOfMonth(year, month + 1, 1);
int daysInMonth = startOfMonth.daysInMonth();
- QValueList<int>* days = recurDays[daysInMonth - 28];
+ Q3ValueList<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();
+ Q3ValueList<int>::ConstIterator it;
+ const Q3ValueList<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();
+ Q3ValueList<int>::ConstIterator it;
+ const Q3ValueList<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();
+ Q3ValueList<int>::ConstIterator it;
+ const Q3ValueList<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
+ Q3ValueList<int> months; // recurring months in non-leap years 1..12
+ Q3ValueList<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
+ const Q3ValueList<int>* monthList() const
{ return leapyear ? &leapMonths : &months; }
- const QValueList<int>* leapMonthList() const { return &leapMonths; }
+ const Q3ValueList<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
+ Q3ValueList<int>::ConstIterator it;
+ const Q3ValueList<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();
+ Q3ValueList<int>::ConstIterator it;
+ const Q3ValueList<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();
+ Q3ValueList<int>::ConstIterator it;
+ const Q3ValueList<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;
+ mutable Q3ValueList<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 {
+ const Q3ValueList<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;
+ Q3ValueList<int>::ConstIterator id;
+ const Q3ValueList<int>* days;
if (data.month > 1 || data.day > 1) {
// Check what remains of the start year
- for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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;
+ Q3ValueList<int>::ConstIterator id;
+ const Q3ValueList<int>* days;
if (data.month > 1 || data.day > 1) {
// Check what remains of the start year
- for (QPtrListIterator<int> im(rYearNums); im.current(); ++im) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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;
+ Q3ValueList<int>::ConstIterator id;
+ const Q3ValueList<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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
+void Recurrence::getMonthlyPosDays(Q3ValueList<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) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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
+bool Recurrence::getMonthlyDayDays(Q3ValueList<int> &list, int daysInMonth) const
{
list.clear();
bool variable = false;
Q_UINT32 days = 0;
- for (QPtrListIterator<int> it(rMonthDays); it.current(); ++it) {
+ for (Q3PtrListIterator<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
+bool Recurrence::getYearlyMonthMonths(int day, Q3ValueList<int> &list, Q3ValueList<int> &leaplist) const
{
list.clear();
leaplist.clear();
bool feb29 = false;
- for (QPtrListIterator<int> it(rYearNums); it.current(); ++it) {
+ for (Q3PtrListIterator<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) {
+ for (Q3PtrListIterator<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;
+ Q3ValueList<int> dayList;
getMonthlyPosDays(dayList, daysInMonth, monthBegin.dayOfWeek());
- for (QValueList<int>::ConstIterator id = dayList.begin(); id != dayList.end(); ++id) {
+ for (Q3ValueList<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) {
+ for (Q3PtrListIterator<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;
+ Q3ValueList<int> dayList;
getMonthlyPosDays(dayList, daysInMonth, monthBegin.dayOfWeek());
- for (QValueList<int>::ConstIterator id = dayList.fromLast(); id != dayList.end(); --id) {
+ for (Q3ValueList<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);
+ Q3PtrListIterator<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;
+ Q3ValueList<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) {
+ for (Q3ValueList<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);
+ Q3PtrListIterator<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;
+ Q3ValueList<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) {
+ for (Q3ValueList<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
{
;
}