rec fix

1 files changed, 7 insertions, 19 deletions

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