Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1079 insertions, 0 deletions

diff --git a/libkcal/recurrence.cpp b/libkcal/recurrence.cpp
new file mode 100644
index 00000000..5d1505df
--- /dev/null
+++ b/libkcal/recurrence.cpp
@@ -0,0 +1,1079 @@
+/*
+    This file is part of libkcal.
+
+    Copyright (c) 1998 Preston Brown <pbrown@kde.org>
+    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
+    Copyright (c) 2002 David Jarvie <software@astrojar.org.uk>
+    Copyright (C) 2005 Reinhold Kainhofer <kainhofer@kde.org>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include <limits.h>
+
+#include <kdebug.h>
+#include <kglobal.h>
+#include <klocale.h>
+#include <qbitarray.h>
+
+#include "recurrence.h"
+#include "recurrencerule.h"
+
+using namespace KCal;
+
+
+Recurrence::Recurrence()
+: mFloating( false ),
+  mRecurReadOnly(false),
+  mCachedType(rMax)
+{
+  mExRules.setAutoDelete( true );
+  mRRules.setAutoDelete( true );
+}
+
+Recurrence::Recurrence( const Recurrence &r )
+: RecurrenceRule::Observer(),
+  mRDateTimes( r.mRDateTimes ), mRDates( r.mRDates ),
+  mExDateTimes( r.mExDateTimes ), mExDates( r.mExDates ),
+  mStartDateTime( r.mStartDateTime ),
+  mFloating( r.mFloating ),
+  mRecurReadOnly(r.mRecurReadOnly),
+  mCachedType( r.mCachedType )
+{
+  mExRules.setAutoDelete( true );
+  mRRules.setAutoDelete( true );
+  RecurrenceRule::List::ConstIterator rr;
+  for ( rr = r.mRRules.begin(); rr != r.mRRules.end(); ++rr ) {
+    RecurrenceRule *rule = new RecurrenceRule( *(*rr) );
+    mRRules.append( rule );
+    rule->addObserver( this );
+  }
+  for ( rr = r.mExRules.begin(); rr != r.mExRules.end(); ++rr ) {
+    RecurrenceRule *rule = new RecurrenceRule( *(*rr) );
+    mExRules.append( rule );
+    rule->addObserver( this );
+  }
+}
+
+Recurrence::~Recurrence()
+{
+}
+
+
+
+bool Recurrence::operator==( const Recurrence& r2 ) const
+{
+  if ( mStartDateTime != r2.mStartDateTime
+  ||   mFloating != r2.mFloating
+  ||   mRecurReadOnly != r2.mRecurReadOnly )
+    return false;
+  if ( mExDates != r2.mExDates ) return false;
+  if ( mExDateTimes != r2.mExDateTimes ) return false;
+  if ( mRDates != r2.mRDates ) return false;
+  if ( mRDateTimes != r2.mRDateTimes ) return false;
+
+// Compare the rrules, exrules! Assume they have the same order... This only
+// matters if we have more than one rule (which shouldn't be the default anyway)
+  if ( mRRules.count() != r2.mRRules.count() ) return false;
+  RecurrenceRule::List::ConstIterator rit1 = mRRules.begin();
+  RecurrenceRule::List::ConstIterator rit2 = r2.mRRules.begin();
+
+  while ( rit1 != mRRules.end() && rit2 != r2.mRRules.end() ) {
+    // dereference the iterator to the RecurrenceRule*, and that once again
+    // to RecurrenceRule...
+    if ( *(*rit1) != *(*rit2) ) return false;
+    ++rit1;
+    ++rit2;
+  }
+  RecurrenceRule::List::ConstIterator exit1 = mExRules.begin();
+  RecurrenceRule::List::ConstIterator exit2 = r2.mExRules.begin();
+
+  while ( exit1 != mExRules.end() && exit2 != r2.mExRules.end() ) {
+    // dereference the iterator to the RecurrenceRule*, and that once again
+    // to RecurrenceRule...
+    if ( *(*exit1) != *(*exit2) ) return false;
+    ++exit1;
+    ++exit2;
+  }
+  return true;
+}
+
+void Recurrence::addObserver( Observer *observer )
+{
+  if ( !mObservers.contains( observer ) )
+    mObservers.append( observer );
+}
+
+void Recurrence::removeObserver( Observer *observer )
+{
+  if ( mObservers.contains( observer ) )
+    mObservers.remove( observer );
+}
+
+
+QDateTime Recurrence::startDateTime() const
+{
+  if ( mFloating )
+    return QDateTime( mStartDateTime.date(), QTime( 0, 0, 0 ) );
+  else return mStartDateTime;
+}
+
+void Recurrence::setFloats( bool floats )
+{
+  if ( mRecurReadOnly ) return;
+  if ( floats == mFloating ) return;
+  mFloating = floats;
+
+
+  RecurrenceRule::List::ConstIterator it;
+  for ( it = mRRules.begin(); it != mRRules.end(); ++it ) {
+    (*it)->setFloats( floats );
+  }
+
+  RecurrenceRule::List::ConstIterator it1;
+  for ( it1 = mExRules.begin(); it1 != mExRules.end(); ++it1 ) {
+    (*it1)->setFloats( floats );
+  }
+  updated();
+}
+
+RecurrenceRule *Recurrence::defaultRRule( bool create ) const
+{
+  if ( mRRules.isEmpty() ) {
+    if ( !create || mRecurReadOnly ) return 0;
+    RecurrenceRule *rrule = new RecurrenceRule();
+    rrule->setStartDt( startDateTime() );
+    const_cast<KCal::Recurrence*>(this)->addRRule( rrule );
+    return rrule;
+  } else {
+    return mRRules.first();
+  }
+}
+
+RecurrenceRule *Recurrence::defaultRRuleConst() const
+{
+  if ( mRRules.isEmpty() ) {
+    return 0;
+  } else {
+    return mRRules.first();
+  }
+}
+
+void Recurrence::updated()
+{
+  // recurrenceType() re-calculates the type if it's rMax
+  mCachedType = rMax;
+  for ( QValueList<Observer*>::ConstIterator it = mObservers.begin();
+        it != mObservers.end(); ++it ) {
+    if ( (*it) ) (*it)->recurrenceUpdated( this );
+  }
+}
+
+bool Recurrence::doesRecur() const
+{
+  return !mRRules.isEmpty() || !mRDates.isEmpty() || !mRDateTimes.isEmpty();
+}
+
+ushort Recurrence::recurrenceType() const
+{
+  if ( mCachedType == rMax ) {
+    mCachedType = recurrenceType( defaultRRuleConst() );
+  }
+  return mCachedType;
+}
+
+ushort Recurrence::recurrenceType( const RecurrenceRule *rrule )
+{
+  if ( !rrule ) return rNone;
+  RecurrenceRule::PeriodType type = rrule->recurrenceType();
+
+  // BYSETPOS, BYWEEKNUMBER and BYSECOND were not supported in old versions
+  if ( !rrule->bySetPos().isEmpty() )
+    return rOther;
+  if ( !rrule->bySeconds().isEmpty() )
+    return rOther;
+  if ( !rrule->byWeekNumbers().isEmpty() )
+    return rOther;
+
+  // It wasn't possible to set BYMINUTES, BYHOUR etc. by the old code. So if
+  // it's set, it's none of the old types
+  if ( !rrule->byMinutes().isEmpty() )
+    return rOther;
+  if ( !rrule->byHours().isEmpty() )
+    return rOther;
+
+  // Possible combinations were:
+  // BYDAY: with WEEKLY, MONTHLY, YEARLY
+  // BYMONTHDAY: with MONTHLY, YEARLY
+  // BYMONTH: with YEARLY
+  // BYYEARDAY: with YEARLY
+  if ( !rrule->byYearDays().isEmpty() && type != RecurrenceRule::rYearly )
+    return rOther;
+  if ( !rrule->byMonths().isEmpty() && type != RecurrenceRule::rYearly )
+    return rOther;
+  if ( !rrule->byDays().isEmpty() ) {
+    if ( type != RecurrenceRule::rYearly && type != RecurrenceRule::rMonthly &&
+         type != RecurrenceRule::rWeekly )
+      return rOther;
+  }
+
+  switch ( type ) {
+    case RecurrenceRule::rNone:     return rNone;
+    case RecurrenceRule::rMinutely: return rMinutely;
+    case RecurrenceRule::rHourly:   return rHourly;
+    case RecurrenceRule::rDaily:    return rDaily;
+    case RecurrenceRule::rWeekly:   return rWeekly;
+    case RecurrenceRule::rMonthly: {
+        if ( rrule->byDays().isEmpty() ) return rMonthlyDay;
+        else if ( rrule->byMonthDays().isEmpty() ) return rMonthlyPos;
+        else return rOther; // both position and date specified
+      }
+    case RecurrenceRule::rYearly: {
+        // Possible combinations:
+        //   rYearlyMonth: [BYMONTH &] BYMONTHDAY
+        //   rYearlyDay: BYYEARDAY
+        //   rYearlyPos: [BYMONTH &] BYDAY
+        if ( !rrule->byDays().isEmpty() ) {
+          // can only by rYearlyPos
+          if ( rrule->byMonthDays().isEmpty() && rrule->byYearDays().isEmpty() )
+            return rYearlyPos;
+          else return rOther;
+        } else if ( !rrule->byYearDays().isEmpty() ) {
+          // Can only be rYearlyDay
+          if ( rrule->byMonths().isEmpty() && rrule->byMonthDays().isEmpty() )
+            return rYearlyDay;
+          else return rOther;
+        } else {
+          return rYearlyMonth;
+        }
+        break;
+      }
+     default: return rOther;
+  }
+  return rOther;
+}
+
+bool Recurrence::recursOn(const QDate &qd) const
+{
+  TimeList tms;
+  // First handle dates. Exrules override
+  if ( mExDates.contains( qd ) ) return false;
+  // For all-day events a matching exrule excludes the whole day
+  // since exclusions take precedence over inclusions, we know it can't occur on that day.
+  if ( doesFloat() ) {
+    for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+      if ( (*rr)->recursOn( qd ) )
+        return false;
+    }
+  }
+
+  if ( mRDates.contains( qd ) ) return true;
+
+  // Check if it might recur today at all.
+  bool recurs = false;
+  if ( startDate() == qd ) recurs = true;
+  for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+    recurs = recurs || (*rr)->recursOn( qd );
+  }
+  // If we already know it recurs, no need to check the rdate list too.
+  if ( !recurs ) {
+    for ( DateTimeList::ConstIterator rit = mRDateTimes.begin();
+          rit != mRDateTimes.end(); ++rit ) {
+      if ( (*rit).date() == qd ) {
+        recurs = true;
+        break;
+      }
+    }
+  }
+  // If the event wouldn't recur at all, simply return false, don't check ex*
+  if ( !recurs ) return false;
+
+  // Check if there are any times for this day excluded, either by exdate or exrule:
+  bool exon = false;
+  for ( DateTimeList::ConstIterator exit = mExDateTimes.begin();
+        exit != mExDateTimes.end(); ++exit ) {
+    if ( (*exit).date() == qd ) {
+      exon = true;
+      break;
+    }
+  }
+  if ( !doesFloat() ) {     // we have already checked floating times above
+    for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+      exon = exon || (*rr)->recursOn( qd );
+    }
+  }
+
+  if ( !exon ) {
+    // Simple case, nothing on that day excluded, return the value from before
+    return recurs;
+  } else {
+    // Harder part: I don't think there is any way other than to calculate the
+    // whole list of items for that day.
+    TimeList timesForDay( recurTimesOn( qd ) );
+    return !timesForDay.isEmpty();
+  }
+}
+
+bool Recurrence::recursAt( const QDateTime &dt ) const
+{
+  // if it's excluded anyway, don't bother to check if it recurs at all.
+  if ( mExDateTimes.contains( dt )) return false;
+  if ( mExDates.contains( dt.date() )) return false;
+  for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+    if ( (*rr)->recursAt( dt ) ) return false;
+  }
+
+  // Check explicit recurrences, then rrules.
+  bool occurs = ( startDateTime() == dt ) || mRDateTimes.contains( dt );
+  if ( occurs )
+    return true;
+  for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+    if ( (*rr)->recursAt( dt ) ) return true;
+  }
+
+  return false;
+}
+
+/** Calculates the cumulative end of the whole recurrence (rdates and rrules).
+    If any rrule is infinite, or the recurrence doesn't have any rrules or
+    rdates, an invalid date is returned. */
+QDateTime Recurrence::endDateTime() const
+{
+  DateTimeList dts;
+  dts << startDateTime();
+  if ( !mRDates.isEmpty() ) dts << QDateTime( mRDates.last(), QTime( 0, 0, 0 ) );
+  if ( !mRDateTimes.isEmpty() ) dts << mRDateTimes.last();
+  for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+    QDateTime rl( (*rr)->endDt() );
+    // if any of the rules is infinite, the whole recurrence is
+    if ( !rl.isValid() ) return QDateTime();
+    dts << rl;
+  }
+  qSortUnique( dts );
+  if ( dts.isEmpty() ) return QDateTime();
+  else return dts.last();
+}
+
+/** Calculates the cumulative end of the whole recurrence (rdates and rrules).
+    If any rrule is infinite, or the recurrence doesn't have any rrules or
+    rdates, an invalid date is returned. */
+QDate Recurrence::endDate() const
+{
+  QDateTime end( endDateTime() );
+  if ( end.isValid() ) { return end.date(); }
+  else return QDate();
+}
+
+void Recurrence::setEndDate( const QDate &date )
+{
+  if ( doesFloat() )
+    setEndDateTime( QDateTime( date, QTime( 23, 59, 59 ) ) );
+  else
+    setEndDateTime( QDateTime( date, mStartDateTime.time() ) );
+}
+
+void Recurrence::setEndDateTime( const QDateTime &dateTime )
+{
+  if ( mRecurReadOnly ) return;
+  RecurrenceRule *rrule = defaultRRule( true );
+  if ( !rrule ) return;
+  rrule->setEndDt( dateTime );
+  updated();
+}
+
+int Recurrence::duration() const
+{
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) return rrule->duration();
+  else return 0;
+}
+
+// int Recurrence::durationTo( const QDate &/*date*/ ) const
+// {
+//   return 0;
+// }
+
+int Recurrence::durationTo( const QDateTime &datetime ) const
+{
+  // Emulate old behavior: This is just an interface to the first rule!
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( !rrule ) return 0;
+  else return rrule->durationTo( datetime );
+}
+
+void Recurrence::setDuration( int duration )
+{
+  if ( mRecurReadOnly ) return;
+  RecurrenceRule *rrule = defaultRRule( true );
+  if ( !rrule ) return;
+  rrule->setDuration( duration );
+  updated();
+}
+
+void Recurrence::unsetRecurs()
+{
+  if ( mRecurReadOnly ) return;
+  mRRules.clearAll();
+  updated();
+}
+
+void Recurrence::clear()
+{
+  if ( mRecurReadOnly ) return;
+  mRRules.clearAll();
+  mExRules.clearAll();
+  mRDates.clear();
+  mRDateTimes.clear();
+  mExDates.clear();
+  mExDateTimes.clear();
+  mCachedType = rMax;
+  updated();
+}
+
+void Recurrence::setStartDateTime( const QDateTime &start )
+{
+  if ( mRecurReadOnly ) return;
+  mStartDateTime = start;
+  setFloats( false );   // set all RRULEs and EXRULEs
+
+  for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+    (*rr)->setStartDt( start );
+  }
+  for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+    (*rr)->setStartDt( start );
+  }
+  updated();
+}
+
+void Recurrence::setStartDate( const QDate &start )
+{
+  setStartDateTime( QDateTime( start, QTime(0,0,0) ) );
+  setFloats( true );
+}
+
+int Recurrence::frequency() const
+{
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) return rrule->frequency();
+  else return 0;
+}
+
+// Emulate the old behaviour. Make this methods just an interface to the
+// first rrule
+void Recurrence::setFrequency( int freq )
+{
+  if ( mRecurReadOnly || freq <= 0 ) return;
+  RecurrenceRule *rrule = defaultRRule( true );
+  if ( rrule )
+    rrule->setFrequency( freq );
+  updated();
+}
+
+
+// WEEKLY
+
+int Recurrence::weekStart() const
+{
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) return rrule->weekStart();
+  else return 1;
+}
+
+// Emulate the old behavior
+QBitArray Recurrence::days() const
+{
+  QBitArray days( 7 );
+  days.fill( 0 );
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) {
+    QValueList<RecurrenceRule::WDayPos> bydays = rrule->byDays();
+    for ( QValueListConstIterator<RecurrenceRule::WDayPos> it = bydays.begin();
+          it != bydays.end(); ++it ) {
+      if ( (*it).pos() == 0 ) {
+        days.setBit( (*it).day() - 1 );
+      }
+    }
+  }
+  return days;
+}
+
+
+// MONTHLY
+
+// Emulate the old behavior
+QValueList<int> Recurrence::monthDays() const
+{
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) return rrule->byMonthDays();
+  else return QValueList<int>();
+}
+
+// Emulate the old behavior
+QValueList<RecurrenceRule::WDayPos> Recurrence::monthPositions() const
+{
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) return rrule->byDays();
+  else return QValueList<RecurrenceRule::WDayPos>();
+}
+
+
+// YEARLY
+
+QValueList<int> Recurrence::yearDays() const
+{
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) return rrule->byYearDays();
+  else return QValueList<int>();
+}
+
+QValueList<int> Recurrence::yearDates() const
+{
+  return monthDays();
+}
+
+QValueList<int> Recurrence::yearMonths() const
+{
+  RecurrenceRule *rrule = defaultRRuleConst();
+  if ( rrule ) return rrule->byMonths();
+  else return QValueList<int>();
+}
+
+QValueList<RecurrenceRule::WDayPos> Recurrence::yearPositions() const
+{
+  return monthPositions();
+}
+
+
+
+RecurrenceRule *Recurrence::setNewRecurrenceType( RecurrenceRule::PeriodType type, int freq )
+{
+  if ( mRecurReadOnly || freq <= 0 ) return 0;
+  mRRules.clearAll();
+  updated();
+  RecurrenceRule *rrule = defaultRRule( true );
+  if ( !rrule ) return 0;
+  rrule->setRecurrenceType( type );
+  rrule->setFrequency( freq );
+  rrule->setDuration( -1 );
+  return rrule;
+}
+
+void Recurrence::setMinutely( int _rFreq )
+{
+  if ( setNewRecurrenceType( RecurrenceRule::rMinutely, _rFreq ) )
+    updated();
+}
+
+void Recurrence::setHourly( int _rFreq )
+{
+  if ( setNewRecurrenceType( RecurrenceRule::rHourly, _rFreq ) )
+    updated();
+}
+
+void Recurrence::setDaily( int _rFreq )
+{
+  if ( setNewRecurrenceType( RecurrenceRule::rDaily, _rFreq ) )
+    updated();
+}
+
+void Recurrence::setWeekly( int freq, int weekStart )
+{
+  RecurrenceRule *rrule = setNewRecurrenceType( RecurrenceRule::rWeekly, freq );
+  if ( !rrule ) return;
+  rrule->setWeekStart( weekStart );
+  updated();
+}
+
+void Recurrence::setWeekly( int freq, const QBitArray &days, int weekStart )
+{
+  setWeekly( freq, weekStart );
+  addMonthlyPos( 0, days );
+}
+
+void Recurrence::addWeeklyDays( const QBitArray &days )
+{
+  addMonthlyPos( 0, days );
+}
+
+void Recurrence::setMonthly( int freq )
+{
+  if ( setNewRecurrenceType( RecurrenceRule::rMonthly, freq ) )
+    updated();
+}
+
+void Recurrence::addMonthlyPos( short pos, const QBitArray &days )
+{
+  // Allow 53 for yearly!
+  if ( mRecurReadOnly || pos > 53 || pos < -53 ) return;
+  RecurrenceRule *rrule = defaultRRule( false );
+  if ( !rrule ) return;
+  bool changed = false;
+  QValueList<RecurrenceRule::WDayPos> positions = rrule->byDays();
+
+  for ( int i = 0; i < 7; ++i ) {
+    if ( days.testBit(i) ) {
+      RecurrenceRule::WDayPos p( pos, i + 1 );
+      if ( !positions.contains( p ) ) {
+        changed = true;
+        positions.append( p );
+      }
+    }
+  }
+  if ( changed ) {
+    rrule->setByDays( positions );
+    updated();
+  }
+}
+
+
+void Recurrence::addMonthlyPos( short pos, ushort day )
+{
+  // Allow 53 for yearly!
+  if ( mRecurReadOnly || pos > 53 || pos < -53 ) return;
+  RecurrenceRule *rrule = defaultRRule( false );
+  if ( !rrule ) return;
+  QValueList<RecurrenceRule::WDayPos> positions = rrule->byDays();
+
+  RecurrenceRule::WDayPos p( pos, day );
+  if ( !positions.contains( p ) ) {
+    positions.append( p );
+    rrule->setByDays( positions );
+    updated();
+  }
+}
+
+
+void Recurrence::addMonthlyDate( short day )
+{
+  if ( mRecurReadOnly || day > 31 || day < -31 ) return;
+  RecurrenceRule *rrule = defaultRRule( true );
+  if ( !rrule ) return;
+
+  QValueList<int> monthDays = rrule->byMonthDays();
+  if ( !monthDays.contains( day ) ) {
+    monthDays.append( day );
+    rrule->setByMonthDays( monthDays );
+    updated();
+  }
+}
+
+void Recurrence::setYearly( int freq )
+{
+  if ( setNewRecurrenceType( RecurrenceRule::rYearly, freq ) )
+    updated();
+}
+
+
+// Daynumber within year
+void Recurrence::addYearlyDay( int day )
+{
+  RecurrenceRule *rrule = defaultRRule( false ); // It must already exist!
+  if ( !rrule ) return;
+
+  QValueList<int> days = rrule->byYearDays();
+  if ( !days.contains( day ) ) {
+    days << day;
+    rrule->setByYearDays( days );
+    updated();
+  }
+}
+
+// day part of date within year
+void Recurrence::addYearlyDate( int day )
+{
+  addMonthlyDate( day );
+}
+
+// day part of date within year, given as position (n-th weekday)
+void Recurrence::addYearlyPos( short pos, const QBitArray &days )
+{
+  addMonthlyPos( pos, days );
+}
+
+
+// month part of date within year
+void Recurrence::addYearlyMonth( short month )
+{
+  if ( mRecurReadOnly || month < 1 || month > 12 ) return;
+  RecurrenceRule *rrule = defaultRRule( false );
+  if ( !rrule ) return;
+
+  QValueList<int> months = rrule->byMonths();
+  if ( !months.contains(month) ) {
+    months << month;
+    rrule->setByMonths( months );
+    updated();
+  }
+}
+
+
+TimeList Recurrence::recurTimesOn( const QDate &date ) const
+{
+  TimeList times;
+  // The whole day is excepted
+  if ( mExDates.contains( date ) ) return times;
+  // EXRULE takes precedence over RDATE entries, so for floating events,
+  // a matching excule also excludes the whole day automatically
+  if ( doesFloat() ) {
+    for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+      if ( (*rr)->recursOn( date ) )
+        return times;
+    }
+  }
+
+  if ( startDate() == date ) times << startDateTime().time();
+  bool foundDate = false;
+  for ( DateTimeList::ConstIterator it = mRDateTimes.begin();
+        it != mRDateTimes.end(); ++it ) {
+    if ( (*it).date() == date ) {
+      times << (*it).time();
+      foundDate = true;
+    } else if (foundDate) break; // <= Assume that the rdatetime list is sorted
+  }
+  for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+    times += (*rr)->recurTimesOn( date );
+  }
+  qSortUnique( times );
+
+  foundDate = false;
+  TimeList extimes;
+  for ( DateTimeList::ConstIterator it = mExDateTimes.begin();
+        it != mExDateTimes.end(); ++it ) {
+    if ( (*it).date() == date ) {
+      extimes << (*it).time();
+      foundDate = true;
+    } else if (foundDate) break;
+  }
+  if ( !doesFloat() ) {     // we have already checked floating times above
+    for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+      extimes += (*rr)->recurTimesOn( date );
+    }
+  }
+  qSortUnique( extimes );
+
+  for ( TimeList::Iterator it = extimes.begin(); it != extimes.end(); ++it ) {
+    times.remove( (*it) );
+  }
+  return times;
+}
+
+
+QDateTime Recurrence::getNextDateTime( const QDateTime &preDateTime ) const
+{
+//kdDebug(5800) << " Recurrence::getNextDateTime after " << preDateTime << endl;
+  QDateTime nextDT = preDateTime;
+  // prevent infinite loops, e.g. when an exrule extinguishes an rrule (e.g.
+  // the exrule is identical to the rrule). If an occurrence is found, break
+  // out of the loop by returning that QDateTime
+// TODO_Recurrence: Is a loop counter of 1000 really okay? I mean for secondly
+// recurrence, an exdate might exclude more than 1000 intervals!
+  int loop = 0;
+  while ( loop < 1000 ) {
+    // Outline of the algo:
+    //   1) Find the next date/time after preDateTime when the event could recur
+    //     1.0) Add the start date if it's after preDateTime
+    //     1.1) Use the next occurrence from the explicit RDATE lists
+    //     1.2) Add the next recurrence for each of the RRULEs
+    //   2) Take the earliest recurrence of these = QDateTime nextDT
+    //   3) If that date/time is not excluded, either explicitly by an EXDATE or
+    //      by an EXRULE, return nextDT as the next date/time of the recurrence
+    //   4) If it's excluded, start all at 1), but starting at nextDT (instead
+    //      of preDateTime). Loop at most 1000 times.
+    ++loop;
+    // First, get the next recurrence from the RDate lists
+    DateTimeList dates;
+    if ( nextDT < startDateTime() ) dates << startDateTime();
+    DateTimeList::ConstIterator it = mRDateTimes.begin();
+    // Assume that the rdatetime list is sorted
+    while ( it != mRDateTimes.end() && (*it) <= nextDT ) ++it;
+    if ( it != mRDateTimes.end() ) dates << (*it);
+
+/*kdDebug(5800) << "    nextDT: " << nextDT << ", startDT: " << startDateTime() << endl;
+kdDebug(5800) << "   getNextDateTime: found " << dates.count() << " RDATES and DTSTART in loop " << loop << endl;*/
+    DateList::ConstIterator dit = mRDates.begin();
+    while ( dit != mRDates.end() && QDateTime( (*dit), startDateTime().time() ) <= nextDT ) ++dit;
+    if ( dit != mRDates.end() ) dates << QDateTime( (*dit), startDateTime().time() );
+
+    // Add the next occurrences from all RRULEs.
+    for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+      QDateTime dt = (*rr)->getNextDate( nextDT );
+      if ( dt.isValid() ) dates << dt;
+    }
+
+    // Take the first of these (all others can't be used later on)
+    qSortUnique( dates );
+// kdDebug(5800) << "   getNextDateTime: found " << dates.count() << " dates in loop " << loop << endl;
+
+    if ( dates.isEmpty() ) return QDateTime();
+    nextDT = dates.first();
+
+    // Check if that date/time is excluded explicitly or by an exrule:
+    if ( !mExDates.contains( nextDT.date() ) && !mExDateTimes.contains( nextDT ) ) {
+// kdDebug(5800) << "   NextDT" << nextDT << " not excluded by EXDATE " << endl;
+      bool allowed = true;
+      for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+        allowed = allowed && !( (*rr)->recursAt( nextDT ) );
+      }
+// kdDebug(5800) << "   NextDT " << nextDT << ", allowed=" << allowed << endl;
+      if ( allowed ) return nextDT;
+    }
+  }
+
+  // Couldn't find a valid occurrences in 1000 loops, something is wrong!
+  return QDateTime();
+}
+
+QDateTime Recurrence::getPreviousDateTime( const QDateTime &afterDateTime ) const
+{
+  QDateTime prevDT = afterDateTime;
+  // prevent infinite loops, e.g. when an exrule extinguishes an rrule (e.g.
+  // the exrule is identical to the rrule). If an occurrence is found, break
+  // out of the loop by returning that QDateTime
+  int loop = 0;
+  while ( loop < 1000 ) {
+    // Outline of the algo:
+    //   1) Find the next date/time after preDateTime when the event could recur
+    //     1.1) Use the next occurrence from the explicit RDATE lists
+    //     1.2) Add the next recurrence for each of the RRULEs
+    //   2) Take the earliest recurrence of these = QDateTime nextDT
+    //   3) If that date/time is not excluded, either explicitly by an EXDATE or
+    //      by an EXRULE, return nextDT as the next date/time of the recurrence
+    //   4) If it's excluded, start all at 1), but starting at nextDT (instead
+    //      of preDateTime). Loop at most 1000 times.
+    ++loop;
+    // First, get the next recurrence from the RDate lists
+    DateTimeList dates;
+    if ( prevDT > startDateTime() ) dates << startDateTime();
+
+    DateTimeList::ConstIterator dtit = mRDateTimes.end();
+    if ( dtit != mRDateTimes.begin() ) {
+      do {
+        --dtit;
+      } while ( dtit != mRDateTimes.begin() && (*dtit) >= prevDT );
+      if ( (*dtit) < prevDT ) dates << (*dtit);
+    }
+
+    DateList::ConstIterator dit = mRDates.end();
+    if ( dit != mRDates.begin() ) {
+      do {
+        --dit;
+      } while ( dit != mRDates.begin() && QDateTime((*dit), startDateTime().time()) >= prevDT );
+      if ( QDateTime((*dit), startDateTime().time()) < prevDT )
+        dates << QDateTime( (*dit), startDateTime().time() );
+    }
+
+    // Add the previous occurrences from all RRULEs.
+    for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+      QDateTime dt = (*rr)->getPreviousDate( prevDT );
+      if ( dt.isValid() ) dates << dt;
+    }
+//kdDebug(5800) << "   getPreviousDateTime: found " << dates.count() << " dates in loop " << loop << endl;
+
+    // Take the last of these (all others can't be used later on)
+    qSortUnique( dates );
+    if ( dates.isEmpty() ) return QDateTime();
+    prevDT = dates.last();
+
+    // Check if that date/time is excluded explicitly or by an exrule:
+    if ( !mExDates.contains( prevDT.date() ) && !mExDateTimes.contains( prevDT ) ) {
+      bool allowed = true;
+      for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+        allowed = allowed && !( (*rr)->recursAt( prevDT ) );
+      }
+      if ( allowed ) return prevDT;
+    }
+  }
+
+  // Couldn't find a valid occurrences in 1000 loops, something is wrong!
+  return QDateTime();
+}
+
+
+/***************************** PROTECTED FUNCTIONS ***************************/
+
+
+RecurrenceRule::List Recurrence::rRules() const
+{
+  return mRRules;
+}
+
+void Recurrence::addRRule( RecurrenceRule *rrule )
+{
+  if ( mRecurReadOnly || !rrule ) return;
+  rrule->setFloats( mFloating );
+  mRRules.append( rrule );
+  rrule->addObserver( this );
+  updated();
+}
+
+void Recurrence::removeRRule( RecurrenceRule *rrule )
+{
+  if (mRecurReadOnly) return;
+  mRRules.remove( rrule );
+  rrule->removeObserver( this );
+  updated();
+}
+
+RecurrenceRule::List Recurrence::exRules() const
+{
+  return mExRules;
+}
+
+void Recurrence::addExRule( RecurrenceRule *exrule )
+{
+  if ( mRecurReadOnly || !exrule ) return;
+  exrule->setFloats( mFloating );
+  mExRules.append( exrule );
+  exrule->addObserver( this );
+  updated();
+}
+
+void Recurrence::removeExRule( RecurrenceRule *exrule )
+{
+  if (mRecurReadOnly) return;
+  mExRules.remove( exrule );
+  exrule->removeObserver( this );
+  updated();
+}
+
+
+DateTimeList Recurrence::rDateTimes() const
+{
+  return mRDateTimes;
+}
+
+void Recurrence::setRDateTimes( const DateTimeList &rdates )
+{
+  if ( mRecurReadOnly ) return;
+  mRDateTimes = rdates;
+  qSortUnique( mRDateTimes );
+  updated();
+}
+
+void Recurrence::addRDateTime( const QDateTime &rdate )
+{
+  if ( mRecurReadOnly ) return;
+  mRDateTimes.append( rdate );
+  qSortUnique( mRDateTimes );
+  updated();
+}
+
+
+DateList Recurrence::rDates() const
+{
+  return mRDates;
+}
+
+void Recurrence::setRDates( const DateList &rdates )
+{
+  if ( mRecurReadOnly ) return;
+  mRDates = rdates;
+  qSortUnique( mRDates );
+  updated();
+}
+
+void Recurrence::addRDate( const QDate &rdate )
+{
+  if ( mRecurReadOnly ) return;
+  mRDates.append( rdate );
+  qSortUnique( mRDates );
+  updated();
+}
+
+
+DateTimeList Recurrence::exDateTimes() const
+{
+  return mExDateTimes;
+}
+
+void Recurrence::setExDateTimes( const DateTimeList &exdates )
+{
+  if ( mRecurReadOnly ) return;
+  mExDateTimes = exdates;
+  qSortUnique( mExDateTimes );
+}
+
+void Recurrence::addExDateTime( const QDateTime &exdate )
+{
+  if ( mRecurReadOnly ) return;
+  mExDateTimes.append( exdate );
+  qSortUnique( mExDateTimes );
+  updated();
+}
+
+
+DateList Recurrence::exDates() const
+{
+  return mExDates;
+}
+
+void Recurrence::setExDates( const DateList &exdates )
+{
+  if ( mRecurReadOnly ) return;
+  mExDates = exdates;
+  qSortUnique( mExDates );
+  updated();
+}
+
+void Recurrence::addExDate( const QDate &exdate )
+{
+  if ( mRecurReadOnly ) return;
+  mExDates.append( exdate );
+  qSortUnique( mExDates );
+  updated();
+}
+
+void Recurrence::recurrenceChanged( RecurrenceRule * )
+{
+  updated();
+}
+
+
+// %%%%%%%%%%%%%%%%%% end:Recurrencerule %%%%%%%%%%%%%%%%%%
+
+void Recurrence::dump() const
+{
+  kdDebug(5800) << "Recurrence::dump():" << endl;
+
+  kdDebug(5800) << "  -) " << mRRules.count() << " RRULEs: " << endl;
+  for ( RecurrenceRule::List::ConstIterator rr = mRRules.begin(); rr != mRRules.end(); ++rr ) {
+    kdDebug(5800) << "    -) RecurrenceRule : " << endl;
+    (*rr)->dump();
+  }
+  kdDebug(5800) << "  -) " << mExRules.count() << " EXRULEs: " << endl;
+  for ( RecurrenceRule::List::ConstIterator rr = mExRules.begin(); rr != mExRules.end(); ++rr ) {
+    kdDebug(5800) << "    -) ExceptionRule : " << endl;
+    (*rr)->dump();
+  }
+
+
+  kdDebug(5800) << endl << "  -) " << mRDates.count() << " Recurrence Dates: " << endl;
+  for ( DateList::ConstIterator it = mRDates.begin(); it != mRDates.end(); ++it ) {
+    kdDebug(5800) << "     " << (*it) << endl;
+  }
+  kdDebug(5800) << endl << "  -) " << mRDateTimes.count() << " Recurrence Date/Times: " << endl;
+  for ( DateTimeList::ConstIterator it = mRDateTimes.begin(); it != mRDateTimes.end(); ++it ) {
+    kdDebug(5800) << "     " << (*it) << endl;
+  }
+  kdDebug(5800) << endl << "  -) " << mExDates.count() << " Exceptions Dates: " << endl;
+  for ( DateList::ConstIterator it = mExDates.begin(); it != mExDates.end(); ++it ) {
+    kdDebug(5800) << "     " << (*it) << endl;
+  }
+  kdDebug(5800) << endl << "  -) " << mExDateTimes.count() << " Exception Date/Times: " << endl;
+  for ( DateTimeList::ConstIterator it = mExDateTimes.begin(); it != mExDateTimes.end(); ++it ) {
+    kdDebug(5800) << "     " << (*it) << endl;
+  }
+}