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, 847 insertions, 0 deletions

diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
new file mode 100644
index 00000000..c4ee5108
--- /dev/null
+++ b/libkcal/incidence.cpp
@@ -0,0 +1,847 @@
+/*
+    This file is part of libkcal.
+
+    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
+    Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
+
+    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 <kglobal.h>
+#include <klocale.h>
+#include <kdebug.h>
+
+#include "calformat.h"
+
+#include "incidence.h"
+
+using namespace KCal;
+
+Incidence::Incidence() :
+  IncidenceBase(),
+  mRelatedTo(0), mStatus(StatusNone), mSecrecy(SecrecyPublic),
+  mPriority(0), mRecurrence(0)
+{
+  recreate();
+
+  mAlarms.setAutoDelete(true);
+  mAttachments.setAutoDelete(true);
+}
+
+Incidence::Incidence( const Incidence &i ) : IncidenceBase( i ),Recurrence::Observer()
+{
+// TODO: reenable attributes currently commented out.
+  mRevision = i.mRevision;
+  mCreated = i.mCreated;
+  mDescription = i.mDescription;
+  mSummary = i.mSummary;
+  mCategories = i.mCategories;
+//  Incidence *mRelatedTo;          Incidence *mRelatedTo;
+  mRelatedTo = 0;
+  mRelatedToUid = i.mRelatedToUid;
+//  Incidence::List mRelations;    Incidence::List mRelations;
+  mResources = i.mResources;
+  mStatusString = i.mStatusString;
+  mStatus = i.mStatus;
+  mSecrecy = i.mSecrecy;
+  mPriority = i.mPriority;
+  mLocation = i.mLocation;
+
+  // Alarms and Attachments are stored in ListBase<...>, which is a QValueList<...*>.
+  // We need to really duplicate the objects stored therein, otherwise deleting
+  // i will also delete all attachments from this object (setAutoDelete...)
+  Alarm::List::ConstIterator it;
+  for( it = i.mAlarms.begin(); it != i.mAlarms.end(); ++it ) {
+    Alarm *b = new Alarm( **it );
+    b->setParent( this );
+    mAlarms.append( b );
+  }
+  mAlarms.setAutoDelete(true);
+
+  Attachment::List::ConstIterator it1;
+  for ( it1 = i.mAttachments.begin(); it1 != i.mAttachments.end(); ++it1 ) {
+    Attachment *a = new Attachment( **it1 );
+    mAttachments.append( a );
+  }
+  mAttachments.setAutoDelete( true );
+
+  if (i.mRecurrence) {
+    mRecurrence = new Recurrence( *(i.mRecurrence) );
+    mRecurrence->addObserver( this );
+  } else
+    mRecurrence = 0;
+
+  mSchedulingID = i.mSchedulingID;
+}
+
+Incidence::~Incidence()
+{
+    Incidence::List Relations = mRelations;
+    List::ConstIterator it;
+    for ( it = Relations.begin(); it != Relations.end(); ++it ) {
+        if ( (*it)->relatedTo() == this ) (*it)->mRelatedTo = 0;
+    }
+    if ( relatedTo() ) relatedTo()->removeRelation( this );
+
+    delete mRecurrence;
+}
+
+// A string comparison that considers that null and empty are the same
+static bool stringCompare( const QString& s1, const QString& s2 )
+{
+  return ( s1.isEmpty() && s2.isEmpty() ) || (s1 == s2);
+}
+
+Incidence& Incidence::operator=( const Incidence &i )
+{
+  if ( &i == this )
+    return *this;
+  IncidenceBase::operator=( i );
+  mRevision = i.mRevision;
+  mCreated = i.mCreated;
+  mDescription = i.mDescription;
+  mSummary = i.mSummary;
+  mCategories = i.mCategories;
+  mRelatedTo = 0;
+  mRelatedToUid = i.mRelatedToUid;
+  mRelations.clear();
+  mResources = i.mResources;
+  mStatusString = i.mStatusString;
+  mStatus = i.mStatus;
+  mSecrecy = i.mSecrecy;
+  mPriority = i.mPriority;
+  mLocation = i.mLocation;
+
+  mAlarms.clearAll();
+  Alarm::List::ConstIterator it;
+  for( it = i.mAlarms.begin(); it != i.mAlarms.end(); ++it ) {
+    Alarm *b = new Alarm( **it );
+    b->setParent( this );
+    mAlarms.append( b );
+  }
+
+  mAttachments.clearAll();
+  Attachment::List::ConstIterator it1;
+  for ( it1 = i.mAttachments.begin(); it1 != i.mAttachments.end(); ++it1 ) {
+    Attachment *a = new Attachment( **it1 );
+    mAttachments.append( a );
+  }
+
+  delete mRecurrence;
+  if (i.mRecurrence) {
+    mRecurrence = new Recurrence( *(i.mRecurrence) );
+    mRecurrence->addObserver( this );
+  } else
+    mRecurrence = 0;
+
+  mSchedulingID = i.mSchedulingID;
+  return *this;
+}
+
+bool Incidence::operator==( const Incidence& i2 ) const
+{
+    if( alarms().count() != i2.alarms().count() ) {
+        return false; // no need to check further
+    }
+
+    Alarm::List::ConstIterator a1 = alarms().begin();
+    Alarm::List::ConstIterator a2 = i2.alarms().begin();
+    for( ; a1 != alarms().end() && a2 != i2.alarms().end(); ++a1, ++a2 )
+        if( **a1 == **a2 )
+            continue;
+        else {
+            return false;
+        }
+
+    if ( !IncidenceBase::operator==(i2) )
+        return false;
+
+    bool recurrenceEqual = ( mRecurrence == 0 && i2.mRecurrence == 0 );
+    if ( !recurrenceEqual )
+    {
+        recurrenceEqual = mRecurrence != 0 &&
+                          i2.mRecurrence != 0 &&
+                          *mRecurrence == *i2.mRecurrence;
+    }
+
+    return
+        recurrenceEqual &&
+        created() == i2.created() &&
+        stringCompare( description(), i2.description() ) &&
+        stringCompare( summary(), i2.summary() ) &&
+        categories() == i2.categories() &&
+        // no need to compare mRelatedTo
+        stringCompare( relatedToUid(), i2.relatedToUid() ) &&
+        relations() == i2.relations() &&
+        attachments() == i2.attachments() &&
+        resources() == i2.resources() &&
+        mStatus == i2.mStatus &&
+        ( mStatus == StatusNone || stringCompare( mStatusString, i2.mStatusString ) ) &&
+        secrecy() == i2.secrecy() &&
+        priority() == i2.priority() &&
+        stringCompare( location(), i2.location() ) &&
+        stringCompare( schedulingID(), i2.schedulingID() );
+}
+
+
+void Incidence::recreate()
+{
+  setCreated(QDateTime::currentDateTime());
+
+  setUid(CalFormat::createUniqueId());
+  setSchedulingID( QString::null );
+
+  setRevision(0);
+
+  setLastModified(QDateTime::currentDateTime());
+  setPilotId( 0 );
+  setSyncStatus( SYNCNONE );
+}
+
+void Incidence::setReadOnly( bool readOnly )
+{
+  IncidenceBase::setReadOnly( readOnly );
+  if ( mRecurrence )
+    mRecurrence->setRecurReadOnly( readOnly );
+}
+
+void Incidence::setFloats(bool f)
+{
+  if (mReadOnly) return;
+  if ( recurrence() )
+    recurrence()->setFloats( f );
+  IncidenceBase::setFloats( f );
+}
+
+void Incidence::setCreated( const QDateTime &created )
+{
+  if (mReadOnly) return;
+  mCreated = created;
+
+// FIXME: Shouldn't we call updated for the creation date, too?
+//  updated();
+}
+
+QDateTime Incidence::created() const
+{
+  return mCreated;
+}
+
+void Incidence::setRevision( int rev )
+{
+  if (mReadOnly) return;
+  mRevision = rev;
+
+  updated();
+}
+
+int Incidence::revision() const
+{
+  return mRevision;
+}
+
+void Incidence::setDtStart(const QDateTime &dtStart)
+{
+  if ( mRecurrence ) {
+    mRecurrence->setStartDateTime( dtStart );
+    mRecurrence->setFloats( doesFloat() );
+  }
+  IncidenceBase::setDtStart( dtStart );
+}
+
+void Incidence::setDescription(const QString &description)
+{
+  if (mReadOnly) return;
+  mDescription = description;
+  updated();
+}
+
+QString Incidence::description() const
+{
+  return mDescription;
+}
+
+
+void Incidence::setSummary(const QString &summary)
+{
+  if (mReadOnly) return;
+  mSummary = summary;
+  updated();
+}
+
+QString Incidence::summary() const
+{
+  return mSummary;
+}
+
+void Incidence::setCategories(const QStringList &categories)
+{
+  if (mReadOnly) return;
+  mCategories = categories;
+  updated();
+}
+
+// TODO: remove setCategories(QString) function
+void Incidence::setCategories(const QString &catStr)
+{
+  if (mReadOnly) return;
+  mCategories.clear();
+
+  if (catStr.isEmpty()) return;
+
+  mCategories = QStringList::split(",",catStr);
+
+  QStringList::Iterator it;
+  for(it = mCategories.begin();it != mCategories.end(); ++it) {
+    *it = (*it).stripWhiteSpace();
+  }
+
+  updated();
+}
+
+QStringList Incidence::categories() const
+{
+  return mCategories;
+}
+
+QString Incidence::categoriesStr() const
+{
+  return mCategories.join(",");
+}
+
+void Incidence::setRelatedToUid(const QString &relatedToUid)
+{
+  if ( mReadOnly || mRelatedToUid == relatedToUid ) return;
+  mRelatedToUid = relatedToUid;
+  updated();
+}
+
+QString Incidence::relatedToUid() const
+{
+  return mRelatedToUid;
+}
+
+void Incidence::setRelatedTo(Incidence *relatedTo)
+{
+  if (mReadOnly || mRelatedTo == relatedTo) return;
+  if(mRelatedTo)
+    mRelatedTo->removeRelation(this);
+  mRelatedTo = relatedTo;
+  if (mRelatedTo) {
+    mRelatedTo->addRelation(this);
+    if ( mRelatedTo->uid() != mRelatedToUid )
+      setRelatedToUid( mRelatedTo->uid() );
+  } else {
+    setRelatedToUid( QString::null );
+  }
+}
+
+Incidence *Incidence::relatedTo() const
+{
+  return mRelatedTo;
+}
+
+Incidence::List Incidence::relations() const
+{
+  return mRelations;
+}
+
+void Incidence::addRelation( Incidence *event )
+{
+  if ( mRelations.find( event ) == mRelations.end() ) {
+    mRelations.append( event );
+  }
+}
+
+void Incidence::removeRelation(Incidence *event)
+// Remove the relation of our incident. E.g. if you have a task t and a
+// subtask, the subtask will have its relation to the task t.
+{
+  mRelations.removeRef(event);
+//  if (event->getRelatedTo() == this) event->setRelatedTo(0);
+  mRelatedToUid=QString();
+}
+
+
+// %%%%%%%%%%%%  Recurrence-related methods %%%%%%%%%%%%%%%%%%%%
+
+
+Recurrence *Incidence::recurrence() const
+{
+  if (!mRecurrence)
+  {
+    const_cast<KCal::Incidence*>(this)->mRecurrence = new Recurrence();
+    mRecurrence->setStartDateTime( IncidenceBase::dtStart() );
+    mRecurrence->setFloats( doesFloat() );
+    mRecurrence->setRecurReadOnly( mReadOnly );
+    mRecurrence->addObserver( const_cast<KCal::Incidence*>(this) );
+  }
+
+  return mRecurrence;
+}
+
+void Incidence::clearRecurrence()
+{
+  delete mRecurrence;
+  mRecurrence = 0;
+}
+
+uint Incidence::recurrenceType() const
+{
+  if ( mRecurrence ) return mRecurrence->recurrenceType();
+  else return Recurrence::rNone;
+}
+
+bool Incidence::doesRecur() const
+{
+  if ( mRecurrence ) return mRecurrence->doesRecur();
+  else return false;
+}
+
+bool Incidence::recursOn(const QDate &qd) const
+{
+  return ( mRecurrence && mRecurrence->recursOn(qd) );
+}
+
+bool Incidence::recursAt(const QDateTime &qdt) const
+{
+  return ( mRecurrence && mRecurrence->recursAt(qdt) );
+}
+
+/**
+  Calculates the start date/time for all recurrences that happen at some time
+  on the given date (might start before that date, but end on or after the
+  given date).
+  @param date the date where the incidence should occur
+  @return the start date/time of all occurences that overlap with the given
+      date. Empty list if the incidence does not overlap with the date at all
+*/
+QValueList<QDateTime> Incidence::startDateTimesForDate( const QDate &date ) const
+{
+//kdDebug(5800) << "Incidence::startDateTimesForDate " << date << ", incidence=" << summary() << endl;
+  QDateTime start = dtStart();
+  QDateTime end = endDateRecurrenceBase();
+
+  QValueList<QDateTime> result;
+
+  // TODO_Recurrence: Also work if only due date is given...
+  if ( !start.isValid() && ! end.isValid() ) {
+    return result;
+  }
+
+  // if the incidence doesn't recur,
+  if ( !doesRecur() ) {
+    if ( !(start.date() > date || end.date() < date ) ) {
+      result << start;
+    }
+    return result;
+  }
+
+  int days = start.daysTo( end );
+  // Account for possible recurrences going over midnight, while the original event doesn't
+  QDate tmpday( date.addDays( -days - 1 ) );
+  QDateTime tmp;
+  while ( tmpday <= date ) {
+    if ( recurrence()->recursOn( tmpday ) ) {
+      QValueList<QTime> times = recurrence()->recurTimesOn( tmpday );
+      for ( QValueList<QTime>::ConstIterator it = times.begin(); it != times.end(); ++it ) {
+        tmp = QDateTime( tmpday, *it );
+        if ( endDateForStart( tmp ).date() >= date )
+          result << tmp;
+      }
+    }
+    tmpday = tmpday.addDays( 1 );
+  }
+  return result;
+}
+
+/**
+  Calculates the start date/time for all recurrences that happen at the given
+  time.
+  @param datetime the date/time where the incidence should occur
+  @return the start date/time of all occurences that overlap with the given
+      date/time. Empty list if the incidence does not happen at the given
+      time at all.
+*/
+QValueList<QDateTime> Incidence::startDateTimesForDateTime( const QDateTime &datetime ) const
+{
+// kdDebug(5800) << "Incidence::startDateTimesForDateTime " << datetime << ", incidence=" << summary() << endl;
+  QDateTime start = dtStart();
+  QDateTime end = endDateRecurrenceBase();
+
+  QValueList<QDateTime> result;
+
+  // TODO_Recurrence: Also work if only due date is given...
+  if ( !start.isValid() && ! end.isValid() ) {
+    return result;
+  }
+
+  // if the incidence doesn't recur,
+  if ( !doesRecur() ) {
+    if ( !(start > datetime || end < datetime ) ) {
+      result << start;
+    }
+    return result;
+  }
+
+  int days = start.daysTo( end );
+  // Account for possible recurrences going over midnight, while the original event doesn't
+  QDate tmpday( datetime.date().addDays( -days - 1 ) );
+  QDateTime tmp;
+  while ( tmpday <= datetime.date() ) {
+    if ( recurrence()->recursOn( tmpday ) ) {
+      QValueList<QTime> times = recurrence()->recurTimesOn( tmpday );
+      for ( QValueList<QTime>::ConstIterator it = times.begin(); it != times.end(); ++it ) {
+        tmp = QDateTime( tmpday, *it );
+        if ( !(tmp > datetime || endDateForStart( tmp ) < datetime ) )
+          result << tmp;
+      }
+    }
+    tmpday = tmpday.addDays( 1 );
+  }
+  return result;
+}
+
+/** Return the end time of the occurrence if it starts at the given date/time */
+QDateTime Incidence::endDateForStart( const QDateTime &startDt ) const
+{
+  QDateTime start = dtStart();
+  QDateTime end = endDateRecurrenceBase();
+  if ( !end.isValid() ) return start;
+  if ( !start.isValid() ) return end;
+
+  return startDt.addSecs( start.secsTo( end ) );
+}
+
+// %%%%%%%%%%%%%%%%% begin:RecurrenceRule %%%%%%%%%%%%%%%%%
+
+// Exception Dates
+/*void Incidence::setExDates(const DateList &exDates)
+{
+  if ( mReadOnly ) return;
+  recurrence()->setExDates( exDates );
+  updated();
+}
+
+void Incidence::addExDate( const QDate &date )
+{
+  if ( mReadOnly ) return;
+  recurrence()->addExDate( date );
+  updated();
+}
+
+DateList Incidence::exDates() const
+{
+  if ( mRecurrence ) return mRecurrence->exDates();
+  else return DateList();
+}
+
+
+// Exception DateTimes
+void Incidence::setExDateTimes( const DateTimeList &exDates )
+{
+  if ( mReadOnly ) return;
+  recurrence()->setExDateTimes( exDates );
+  updated();
+}
+
+void Incidence::addExDateTime( const QDateTime &date )
+{
+  if ( mReadOnly ) return;
+  recurrence()->addExDateTime( date );
+  updated();
+}
+
+DateTimeList Incidence::exDateTimes() const
+{
+  if ( mRecurrence ) return mRecurrence->exDateTimes();
+  else return DateTimeList();
+}
+
+
+// Recurrence Dates
+void Incidence::setRDates(const DateList &exDates)
+{
+  if ( mReadOnly ) return;
+  recurrence()->setRDates( exDates );
+  updated();
+}
+
+void Incidence::addRDate( const QDate &date )
+{
+  if ( mReadOnly ) return;
+  recurrence()->addRDate( date );
+  updated();
+}
+
+DateList Incidence::rDates() const
+{
+  if ( mRecurrence ) return mRecurrence->rDates();
+  else return DateList();
+}
+
+
+// Recurrence DateTimes
+void Incidence::setRDateTimes( const DateTimeList &exDates )
+{
+  if ( mReadOnly ) return;
+  recurrence()->setRDateTimes( exDates );
+  updated();
+}
+
+void Incidence::addRDateTime( const QDateTime &date )
+{
+  if ( mReadOnly ) return;
+  recurrence()->addRDateTime( date );
+  updated();
+}
+
+DateTimeList Incidence::rDateTimes() const
+{
+  if ( mRecurrence ) return mRecurrence->rDateTimes();
+  else return DateTimeList();
+}*/
+
+// %%%%%%%%%%%%%%%%% end:RecurrenceRule %%%%%%%%%%%%%%%%%
+
+void Incidence::addAttachment(Attachment *attachment)
+{
+  if (mReadOnly || !attachment) return;
+  mAttachments.append(attachment);
+  updated();
+}
+
+void Incidence::deleteAttachment(Attachment *attachment)
+{
+  mAttachments.removeRef(attachment);
+}
+
+void Incidence::deleteAttachments( const QString &mime )
+{
+  Attachment::List::Iterator it = mAttachments.begin();
+  while( it != mAttachments.end() ) {
+    if ( (*it)->mimeType() == mime ) mAttachments.remove( it );
+    else ++it;
+  }
+}
+
+Attachment::List Incidence::attachments() const
+{
+  return mAttachments;
+}
+
+Attachment::List Incidence::attachments(const QString& mime) const
+{
+  Attachment::List attachments;
+  Attachment::List::ConstIterator it;
+  for( it = mAttachments.begin(); it != mAttachments.end(); ++it ) {
+    if ( (*it)->mimeType() == mime ) attachments.append( *it );
+  }
+
+  return attachments;
+}
+
+void Incidence::clearAttachments()
+{
+  mAttachments.clearAll();
+}
+
+void Incidence::setResources(const QStringList &resources)
+{
+  if (mReadOnly) return;
+  mResources = resources;
+  updated();
+}
+
+QStringList Incidence::resources() const
+{
+  return mResources;
+}
+
+
+void Incidence::setPriority(int priority)
+{
+  if (mReadOnly) return;
+  mPriority = priority;
+  updated();
+}
+
+int Incidence::priority() const
+{
+  return mPriority;
+}
+
+void Incidence::setStatus(Incidence::Status status)
+{
+  if (mReadOnly || status == StatusX) return;
+  mStatus = status;
+  mStatusString = QString::null;
+  updated();
+}
+
+void Incidence::setCustomStatus(const QString &status)
+{
+  if (mReadOnly) return;
+  mStatus = status.isEmpty() ? StatusNone : StatusX;
+  mStatusString = status;
+  updated();
+}
+
+Incidence::Status Incidence::status() const
+{
+  return mStatus;
+}
+
+QString Incidence::statusStr() const
+{
+  if (mStatus == StatusX)
+    return mStatusString;
+  return statusName(mStatus);
+}
+
+QString Incidence::statusName(Incidence::Status status)
+{
+  switch (status) {
+    case StatusTentative:    return i18n("incidence status", "Tentative");
+    case StatusConfirmed:    return i18n("Confirmed");
+    case StatusCompleted:    return i18n("Completed");
+    case StatusNeedsAction:  return i18n("Needs-Action");
+    case StatusCanceled:     return i18n("Canceled");
+    case StatusInProcess:    return i18n("In-Process");
+    case StatusDraft:        return i18n("Draft");
+    case StatusFinal:        return i18n("Final");
+    case StatusX:
+    case StatusNone:
+    default:                 return QString::null;
+  }
+}
+
+void Incidence::setSecrecy(int sec)
+{
+  if (mReadOnly) return;
+  mSecrecy = sec;
+  updated();
+}
+
+int Incidence::secrecy() const
+{
+  return mSecrecy;
+}
+
+QString Incidence::secrecyStr() const
+{
+  return secrecyName(mSecrecy);
+}
+
+QString Incidence::secrecyName(int secrecy)
+{
+  switch (secrecy) {
+    case SecrecyPublic:
+      return i18n("Public");
+    case SecrecyPrivate:
+      return i18n("Private");
+    case SecrecyConfidential:
+      return i18n("Confidential");
+    default:
+      return i18n("Undefined");
+  }
+}
+
+QStringList Incidence::secrecyList()
+{
+  QStringList list;
+  list << secrecyName(SecrecyPublic);
+  list << secrecyName(SecrecyPrivate);
+  list << secrecyName(SecrecyConfidential);
+
+  return list;
+}
+
+
+const Alarm::List &Incidence::alarms() const
+{
+  return mAlarms;
+}
+
+Alarm* Incidence::newAlarm()
+{
+  Alarm* alarm = new Alarm(this);
+  mAlarms.append(alarm);
+//  updated();
+  return alarm;
+}
+
+void Incidence::addAlarm(Alarm *alarm)
+{
+  mAlarms.append(alarm);
+  updated();
+}
+
+void Incidence::removeAlarm(Alarm *alarm)
+{
+  mAlarms.removeRef(alarm);
+  updated();
+}
+
+void Incidence::clearAlarms()
+{
+  mAlarms.clearAll();
+  updated();
+}
+
+bool Incidence::isAlarmEnabled() const
+{
+  Alarm::List::ConstIterator it;
+  for( it = mAlarms.begin(); it != mAlarms.end(); ++it ) {
+    if ( (*it)->enabled() ) return true;
+  }
+  return false;
+}
+
+void Incidence::setLocation(const QString &location)
+{
+  if (mReadOnly) return;
+  mLocation = location;
+  updated();
+}
+
+QString Incidence::location() const
+{
+  return mLocation;
+}
+
+void Incidence::setSchedulingID( const QString& sid )
+{
+  mSchedulingID = sid;
+}
+
+QString Incidence::schedulingID() const
+{
+  if ( mSchedulingID.isNull() )
+    // Nothing set, so use the normal uid
+    return uid();
+  return mSchedulingID;
+}
+
+/** Observer interface for the recurrence class. If the recurrence is changed,
+    this method will be called for the incidence the recurrence object
+    belongs to. */
+void Incidence::recurrenceUpdated( Recurrence *recurrence )
+{
+  if ( recurrence == mRecurrence )
+    updated();
+}
+