fixxx

4 files changed, 32 insertions, 4 deletions

diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
index 11f7ecc..e4bcc5e 100644
--- a/libkcal/incidence.cpp
+++ b/libkcal/incidence.cpp
@@ -188,390 +188,410 @@ bool KCal::operator==( const Incidence& i1, const Incidence& i2 )
     }
 #endif
   
     if ( i1.hasRecurrenceID() == i2.hasRecurrenceID() ) {
         if ( i1.hasRecurrenceID() ) {
             if ( i1.recurrenceID() != i2.recurrenceID() )
                 return false;
         }
 
     } else {
         return false;
     }
 
     if ( ! operator==( (const IncidenceBase&)i1, (const IncidenceBase&)i2 ) )
         return false;
     if ( i1.hasStartDate() == i2.hasStartDate() ) {
         if ( i1.hasStartDate() ) {
             if ( i1.dtStart() != i2.dtStart() )
                 return false;
         }
     } else {
         return false;
     }
     if (!( *i1.recurrence() == *i2.recurrence()) ) {
         qDebug("recurrence is NOT equal ");
         return false;
     }
     return
         //  i1.created() == i2.created() &&
         stringCompare( i1.description(), i2.description() ) &&
         stringCompare( i1.summary(), i2.summary() ) &&
         i1.categories() == i2.categories() &&
         // no need to compare mRelatedTo
         stringCompare( i1.relatedToUid(), i2.relatedToUid() ) &&
         //      i1.relations() == i2.relations() &&
         i1.exDates() == i2.exDates() &&
         i1.attachments() == i2.attachments() &&
         i1.resources() == i2.resources() &&
         i1.secrecy() == i2.secrecy() &&
         i1.priority() == i2.priority() &&
         i1.cancelled() == i2.cancelled() &&
         stringCompare( i1.location(), i2.location() );
 }
 
 Incidence* Incidence::recreateCloneException( QDate d  )
 {
     Incidence* newInc = clone();
     newInc->recreate();
     if ( doesRecur() ) {
         addExDate( d );
         newInc->recurrence()->unsetRecurs();
         if ( typeID() == eventID ) {
             int len = dtStart().secsTo( ((Event*)this)->dtEnd());
             QTime tim = dtStart().time();
             newInc->setDtStart( QDateTime(d, tim) );
             ((Event*)newInc)->setDtEnd( newInc->dtStart().addSecs( len ) );
         } else {
             int len = dtStart().secsTo( ((Todo*)this)->dtDue());
             QTime tim = ((Todo*)this)->dtDue().time();
             ((Todo*)newInc)->setDtDue( QDateTime(d, tim) );
             ((Todo*)newInc)->setDtStart( ((Todo*)newInc)->dtDue().addSecs( -len ) );
             ((Todo*)this)->setRecurDates();
         }
         newInc->setExDates( DateList () );
     }
     return newInc;
 }
 
 void Incidence::recreate()
 {
   setCreated(QDateTime::currentDateTime());
 
   setUid(CalFormat::createUniqueId());
 
   setRevision(0);
   setIDStr( ":" );
   setLastModified(QDateTime::currentDateTime());
 }
 void Incidence::cloneRelations( Incidence * newInc )
 {
     // newInc is already a clone of this incidence
     Incidence * inc;
     Incidence * cloneInc;
     QPtrList<Incidence> Relations = relations();
     for (inc=Relations.first();inc;inc=Relations.next()) {
         cloneInc = inc->clone();
         cloneInc->recreate();
         cloneInc->setRelatedTo( newInc );
         inc->cloneRelations( cloneInc );
     } 
 }
 void Incidence::setReadOnly( bool readOnly )
 {
   IncidenceBase::setReadOnly( readOnly );
   recurrence()->setRecurReadOnly( readOnly);
 }
-
+void Incidence::setLastModifiedSubInvalid()
+{
+    mLastModifiedSub = QDateTime();
+    if ( mRelatedTo )
+        mRelatedTo->setLastModifiedSubInvalid();
+}
+QDateTime Incidence::lastModifiedSub()
+{
+    if ( !mRelations.count() )
+        return lastModified();
+    if ( mLastModifiedSub.isValid() )
+        return mLastModifiedSub;
+    mLastModifiedSub = lastModified();
+    Incidence * inc;
+    QPtrList<Incidence> Relations = relations();
+    for (inc=Relations.first();inc;inc=Relations.next()) {
+        if ( inc->lastModifiedSub() > mLastModifiedSub )
+            mLastModifiedSub = inc->lastModifiedSub();
+    }
+    return mLastModifiedSub;
+}
 void Incidence::setCreated(QDateTime created)
 {
   if (mReadOnly) return;
   mCreated = getEvenTime(created);
 }
 
 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)
 {
 
   QDateTime  dt = getEvenTime(dtStart);
   recurrence()->setRecurStart( dt);
   IncidenceBase::setDtStart( dt );
 }
 
 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::checkCategories()
 {
     mHoliday =  mCategories.contains("Holiday") || mCategories.contains(i18n("Holiday"));
     mBirthday =  mCategories.contains("Birthday") || mCategories.contains(i18n("Birthday"));
     mAnniversary =  mCategories.contains("Anniversary") || mCategories.contains(i18n("Anniversary"));
 }
 
 void Incidence::addCategories(const QStringList &categories, bool addToRelations ) //addToRelations = false
 {
     if (mReadOnly) return;
     int i;
     for( i = 0; i < categories.count(); ++i ) {
         if (  !mCategories.contains (categories[i]))
             mCategories.append( categories[i] );
     }
     checkCategories();
     updated();
     if ( addToRelations ) {
         Incidence * inc;
         QPtrList<Incidence> Relations = relations();
         for (inc=Relations.first();inc;inc=Relations.next()) {
             inc->addCategories( categories, true );
         } 
     }
 }
 
 void Incidence::setCategories(const QStringList &categories, bool setForRelations ) //setForRelations = false
 {
   if (mReadOnly) return;
   mCategories = categories;
   checkCategories();
   updated();
   if ( setForRelations ) {
       Incidence * inc;
       QPtrList<Incidence> Relations = relations();
       for (inc=Relations.first();inc;inc=Relations.next()) {
           inc->setCategories( categories, true );
       } 
   }
 }
 
 // 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();
   }
   checkCategories();
   updated();
 }
 // using this makes filtering 3 times faster
 QStringList* Incidence::categoriesP()
 {
   return &mCategories;
 }
 
 QStringList Incidence::categories() const
 {
   return mCategories;
 }
 
 QString Incidence::categoriesStr()
 {
   return mCategories.join(",");
 }
 QString Incidence::categoriesStrWithSpace()
 {
   return mCategories.join(", ");
 }
 
 void Incidence::setRelatedToUid(const QString &relatedToUid)
 {
   if (mReadOnly) return;
   mRelatedToUid = relatedToUid;
 }
 
 QString Incidence::relatedToUid() const
 {
   return mRelatedToUid;
 }
 
 void Incidence::setRelatedTo(Incidence *relatedTo)
 {
     //qDebug("Incidence::setRelatedTo %d ", relatedTo);
     //qDebug("setRelatedTo(Incidence *relatedTo) %s %s", summary().latin1(), relatedTo->summary().latin1() );
   if (mReadOnly || mRelatedTo == relatedTo) return;
   if(mRelatedTo) {
       // updated();
     mRelatedTo->removeRelation(this);
   }
   mRelatedTo = relatedTo;
   if (mRelatedTo)  {
       mRelatedTo->addRelation(this);
       mRelatedToUid = mRelatedTo->uid();
   } else {
       mRelatedToUid = "";
   }
 }
 
 Incidence *Incidence::relatedTo() const
 {
   return mRelatedTo;
 }
 
 QPtrList<Incidence> Incidence::relations() const
 {
   return mRelations;
 }
 
 void Incidence::addRelationsToList(QPtrList<Incidence> *rel)
 {
     Incidence* inc;
     QPtrList<Incidence> Relations = relations();
     for (inc=Relations.first();inc;inc=Relations.next()) {
         inc->addRelationsToList( rel );
     } 
     if ( rel->findRef( this ) == -1 ) 
         rel->append( this );
 }
 
 void Incidence::addRelation(Incidence *event)
 {
+    setLastModifiedSubInvalid();
   if( mRelations.findRef( event ) == -1 ) {
     mRelations.append(event);
     //updated();
   }
 }
 
 void Incidence::removeRelation(Incidence *event)
 {
-  
-  mRelations.removeRef(event); 
- 
+    setLastModifiedSubInvalid();
+  mRelations.removeRef(event);
 //  if (event->getRelatedTo() == this) event->setRelatedTo(0);
 }
 
 bool Incidence::recursOn(const QDate &qd) const
 {
   if (recurrence()->recursOnPure(qd) && !isException(qd)) return true;
   else return false;
 }
 
 void Incidence::setExDates(const DateList &exDates)
 {
   if (mReadOnly) return;
   mExDates = exDates;
 
   recurrence()->setRecurExDatesCount(mExDates.count());
 
   updated();
 }
 
 void Incidence::addExDate(const QDate &date)
 {
   if (mReadOnly) return;
   mExDates.append(date);
 
   recurrence()->setRecurExDatesCount(mExDates.count());
 
   updated();
 }
 
 DateList Incidence::exDates() const
 {
   return mExDates;
 }
 
 bool Incidence::isException(const QDate &date) const
 {
   DateList::ConstIterator it;
   for( it = mExDates.begin(); it != mExDates.end(); ++it ) {
     if ( (*it) == date ) {
       return true;
     }
   }
 
   return false;
 }
 
 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 *at = mAttachments.first();
   while (at) {
     if (at->mimeType() == mime)
       mAttachments.remove();
     else
       at = mAttachments.next();
   }
 }
 
 QPtrList<Attachment> Incidence::attachments() const
 {
   return mAttachments;
 }
 
 QPtrList<Attachment> Incidence::attachments(const QString& mime) const
 {
   QPtrList<Attachment> attachments;
   QPtrListIterator<Attachment> it( mAttachments );
   Attachment *at;
   while ( (at = it.current()) ) {
     if (at->mimeType() == mime)
       attachments.append(at);
     ++it;
   }
 
   return attachments;
 }
 
 void Incidence::setResources(const QStringList &resources)
 {
   if (mReadOnly) return;
   mResources = resources;
   updated();
 }
 
 QStringList Incidence::resources() const
diff --git a/libkcal/incidence.h b/libkcal/incidence.h
index c88ba2f..d4af9f0 100644
--- a/libkcal/incidence.h
+++ b/libkcal/incidence.h
@@ -184,135 +184,138 @@ class Incidence : public IncidenceBase
     /** returns the list of dates which are exceptions to the recurrence rule */
     DateList exDates() const;
     /** sets the list of dates which are exceptions to the recurrence rule */
     void setExDates(const DateList &_exDates);
     void setExDates(const char *dates);
     /** Add a date to the list of exceptions of the recurrence rule. */
     void addExDate(const QDate &date);
 
     /** returns true if there is an exception for this date in the recurrence
      rule set, or false otherwise. */
     bool isException(const QDate &qd) const;
 
     /** add attachment to this event */
     void addAttachment(Attachment *attachment);
     /** remove and delete a specific attachment */
     void deleteAttachment(Attachment *attachment);
     /** remove and delete all attachments with this mime type */
     void deleteAttachments(const QString& mime);
     /** return list of all associated attachments */
     QPtrList<Attachment> attachments() const;
     /** find a list of attachments with this mime type */
     QPtrList<Attachment> attachments(const QString& mime) const;
 
     /** sets the event's status the value specified.  See the enumeration
      * above for possible values. */
     void setSecrecy(int);
     /** return the event's secrecy. */
     int secrecy() const;
     /** return the event's secrecy in string format. */
     QString secrecyStr() const;
     /** return list of all availbale secrecy classes */
     static QStringList secrecyList();
     /** return human-readable name of secrecy class */
     static QString secrecyName(int);
 
     /** returns TRUE if the date specified is one on which the event will
      * recur. */
     bool recursOn(const QDate &qd) const;
 
     // VEVENT and VTODO, but not VJOURNAL (move to EventBase class?):
 
     /** set resources used, such as Office, Car, etc. */
     void setResources(const QStringList &resources);
     /** return list of current resources */
     QStringList resources() const;
 
     /** set the event's priority, 0 is undefined, 1 highest (decreasing order) */
     void setPriority(int priority);
     /** get the event's priority */
     int priority() const;
 
     /** All alarms that are associated with this incidence */
     QPtrList<Alarm> alarms() const;
     /** Create a new alarm which is associated with this incidence */
     Alarm* newAlarm();
     /** Add an alarm which is associated with this incidence */
     void addAlarm(Alarm*);
     /** Remove an alarm that is associated with this incidence */
     void removeAlarm(Alarm*);
     /** Remove all alarms that are associated with this incidence */
     void clearAlarms();
     /** return whether any alarm associated with this incidence is enabled */
     bool isAlarmEnabled() const;
 
     /**
       Return the recurrence rule associated with this incidence. If there is
       none, returns an appropriate (non-0) object.
     */
     Recurrence *recurrence() const;
     void setRecurrence(Recurrence * r);
     /**
       Forward to Recurrence::doesRecur().
     */
     ushort doesRecur() const;
 
     /** set the event's/todo's location. Do _not_ use it with journal */
     void setLocation(const QString &location);
     /** return the event's/todo's location. Do _not_ use it with journal */
     QString location() const;  
    /** returns TRUE or FALSE depending on whether the todo has a start date */
     bool hasStartDate() const;
     /** sets the event's hasStartDate value. */
     void setHasStartDate(bool f);
     QDateTime getNextOccurence( const QDateTime& dt, bool* yes ) const;
     bool cancelled() const;
     void setCancelled( bool b );
     
     bool hasRecurrenceID() const;
     void setHasRecurrenceID( bool b );
     
     void setRecurrenceID(QDateTime);
     QDateTime recurrenceID () const;
     QDateTime dtStart() const;
     bool isHoliday() const;
     bool isBirthday() const;
     bool isAnniversary() const;
+    QDateTime lastModifiedSub();
+    void setLastModifiedSubInvalid();
     
 
 protected:
     QPtrList<Alarm> mAlarms;
     QPtrList<Incidence> mRelations;
     QDateTime mRecurrenceID;
     bool mHasRecurrenceID;
   private:
     void checkCategories();
     bool mHoliday, mBirthday, mAnniversary;
     int mRevision;
     bool mCancelled;
 
     // base components of jounal, event and todo
     QDateTime mCreated;
+    QDateTime mLastModifiedSub;
     QString mDescription;
     QString mSummary;
     QStringList mCategories;
     Incidence *mRelatedTo;
     QString mRelatedToUid;
     DateList mExDates;
     QPtrList<Attachment> mAttachments;
     QStringList mResources;
     bool mHasStartDate;                  // if todo has associated start date
 
     int mSecrecy;
     int mPriority;                        // 1 = highest, 2 = less, etc.
 
     //QPtrList<Alarm> mAlarms;
     Recurrence *mRecurrence;
     
     QString mLocation;
 };
 
 bool operator==( const Incidence&, const Incidence& );
 
 }
 
 #endif
diff --git a/libkcal/incidencebase.cpp b/libkcal/incidencebase.cpp
index 1a19f3e..022dead 100644
--- a/libkcal/incidencebase.cpp
+++ b/libkcal/incidencebase.cpp
@@ -98,199 +98,203 @@ bool KCal::operator==( const IncidenceBase& i1, const IncidenceBase& i2 )
             if ( !( (*a1) == (*a2)) ) 
                 {
                     //qDebug("Attendee not equal ");
                     return false;
                 }
             a1 = i1.attendees().next();
             a2 = i2.attendees().next();
         }
     }
     //if ( i1.dtStart() != i2.dtStart() )
     //  return false;
 #if 0
     qDebug("1 %d ",i1.doesFloat() == i2.doesFloat() );
     qDebug("1 %d ",i1.duration() == i2.duration() );
     qDebug("3 %d ",i1.hasDuration() == i2.hasDuration() );
     qDebug("1 %d ",i1.pilotId() == i2.pilotId() );
     qDebug("1 %d %d %d",i1.syncStatus() == i2.syncStatus() , i1.syncStatus(),i2.syncStatus() );
     qDebug("6 %d ",i1.organizer() == i2.organizer() );
   
 #endif
     if ( i1.hasDuration() == i2.hasDuration() ) {
         if ( i1.hasDuration() ) {
             if ( i1.duration() != i2.duration() )
                 return false;
         }
     } else {
         return false;
     }
 
     return ( i1.organizer() == i2.organizer() &&
              // i1.uid() == i2.uid() &&
              // Don't compare lastModified, otherwise the operator is not
              // of much use. We are not comparing for identity, after all.
              i1.doesFloat() == i2.doesFloat() &&
              i1.pilotId() == i2.pilotId() );// &&  i1.syncStatus() == i2.syncStatus() );
     // no need to compare mObserver
 }
 
   
 QDateTime IncidenceBase::getEvenTime( QDateTime dt )
 {
     QTime t =  dt.time();
     dt.setTime( QTime (t.hour (), t.minute (), t.second () )  );
     return dt;
 }     
 
 bool IncidenceBase::isTagged() const
 {
     return mIsTagged;
 }
 void IncidenceBase::setTagged( bool b)
 {
     mIsTagged = b;
 }
 void IncidenceBase::setCalID( int id )
 {
     if ( mCalID > 0 ) {
         blockLastModified = true;
         updated();
         blockLastModified = false;
     }
     mCalID = id;
 }
 int IncidenceBase::calID() const
 {
     return mCalID;
 }
 void IncidenceBase::setCalEnabled( bool b )
 {
     mCalEnabled = b;
 }
 bool IncidenceBase::calEnabled() const
 {
     return mCalEnabled;
 }
 
 void IncidenceBase::setAlarmEnabled( bool b )
 {
     mAlarmEnabled = b;
 }
 bool IncidenceBase::alarmEnabled() const
 {
     return mAlarmEnabled;
 }
 
 
 void IncidenceBase::setUid(const QString &uid)
 {
   mUid = uid;
   updated();
 }
 
 QString IncidenceBase::uid() const
 {
   return mUid;
 }
+void IncidenceBase::setLastModifiedSubInvalid()
+{
 
+}
 void IncidenceBase::setLastModified(const QDateTime &lm)
 {
     if ( blockLastModified ) return;
   // DON'T! updated() because we call this from
   // Calendar::updateEvent().
   mLastModified = getEvenTime(lm);
+  setLastModifiedSubInvalid();
   //qDebug("IncidenceBase::setLastModified %s ",lm.toString().latin1());
 }
 
 QDateTime IncidenceBase::lastModified() const
 {
   return mLastModified;
 }
 
 void IncidenceBase::setOrganizer(const QString &o)
 {
   // we don't check for readonly here, because it is
   // possible that by setting the organizer we are changing
   // the event's readonly status...
   mOrganizer = o;
   if (mOrganizer.left(7).upper() == "MAILTO:")
     mOrganizer = mOrganizer.remove(0,7);
 
   updated();
 }
 
 QString IncidenceBase::organizer() const
 {
   return mOrganizer;
 }
 
 void IncidenceBase::setReadOnly( bool readOnly )
 {
   mReadOnly = readOnly;
 }
 
 void IncidenceBase::setDtStart(const QDateTime &dtStart)
 {
 //  if (mReadOnly) return;
   mDtStart = getEvenTime(dtStart);
   updated();
 }
 
 
 QDateTime IncidenceBase::dtStart() const
 {
   return mDtStart;
 }
 
 QString IncidenceBase::dtStartTimeStr() const
 {
   return KGlobal::locale()->formatTime(dtStart().time());
 }
 
 QString IncidenceBase::dtStartDateStr(bool shortfmt) const
 {
   return KGlobal::locale()->formatDate(dtStart().date(),shortfmt);
 }
 
 QString IncidenceBase::dtStartStr(bool shortfmt) const
 {
     if ( doesFloat() )
         return KGlobal::locale()->formatDate(dtStart().date(),shortfmt);
     return KGlobal::locale()->formatDateTime(dtStart(), shortfmt);
 }
 
 
 bool IncidenceBase::doesFloat() const
 {
   return mFloats;
 }
 
 void IncidenceBase::setFloats(bool f)
 {
   if (mReadOnly) return;
   mFloats = f;
   updated();
 }
 
 
 bool IncidenceBase::addAttendee(Attendee *a, bool doupdate)
 {
   if (mReadOnly) return false;
   if (a->name().left(7).upper() == "MAILTO:")
     a->setName(a->name().remove(0,7));
 
   QPtrListIterator<Attendee> qli(mAttendees);
   
   qli.toFirst();
   while (qli) {
       if (*qli.current() == *a)
           return false;
       ++qli;
   }
   mAttendees.append(a);
   if (doupdate) updated();
   return true;
 }
 
 #if 0
 void IncidenceBase::removeAttendee(Attendee *a)
 {
diff --git a/libkcal/incidencebase.h b/libkcal/incidencebase.h
index bed73db..665c1f6 100644
--- a/libkcal/incidencebase.h
+++ b/libkcal/incidencebase.h
@@ -56,131 +56,132 @@ class IncidenceBase : public CustomProperties
 
     /** Set the unique id for the event */
     void setUid(const QString &);
     /** Return the unique id for the event */
     QString uid() const;
 
     /** Sets the time the incidence was last modified. */
     void setLastModified(const QDateTime &lm);
     /** Return the time the incidence was last modified. */
     QDateTime lastModified() const;
 
     /** sets the organizer for the event */
     void setOrganizer(const QString &o);
     QString organizer() const;
 
     /** Set readonly status. */
     virtual void setReadOnly( bool );
     /** Return if the object is read-only. */
     bool isReadOnly() const { return mReadOnly; }
 
     /** for setting the event's starting date/time with a QDateTime. */
     virtual void setDtStart(const QDateTime &dtStart);
     /** returns an event's starting date/time as a QDateTime. */
     virtual QDateTime dtStart() const;
     /** returns an event's starting time as a string formatted according to the
      users locale settings */
     QString dtStartTimeStr() const;
     /** returns an event's starting date as a string formatted according to the
      users locale settings */
     QString dtStartDateStr(bool shortfmt=true) const;
     /** returns an event's starting date and time as a string formatted according
      to the users locale settings */
     QString dtStartStr(bool shortfmt=true) const;
 
     virtual void setDuration(int seconds);
     int duration() const;
     void setHasDuration(bool);
     bool hasDuration() const;
 
     /** Return true or false depending on whether the incidence "floats,"
      * i.e. has a date but no time attached to it. */
     bool doesFloat() const;
     /** Set whether the incidence floats, i.e. has a date but no time attached to it. */
     void setFloats(bool f);
 
     /**
       Add Attendee to this incidence. IncidenceBase takes ownership of the
       Attendee object.
     */
     bool addAttendee(Attendee *a, bool doupdate=true );
 //    void removeAttendee(Attendee *a);
 //    void removeAttendee(const char *n);
     /** Remove all Attendees. */
     void clearAttendees();
     /** Return list of attendees. */
     QPtrList<Attendee> attendees() const { return mAttendees; };
     /** Return number of attendees. */
     int attendeeCount() const { return mAttendees.count(); };
     /** Return the Attendee with this email */
     Attendee* attendeeByMail(const QString &);
     /** Return first Attendee with one of this emails */
     Attendee* attendeeByMails(const QStringList &, const QString& email = QString::null);
 
     /** pilot syncronization states */
     enum { SYNCNONE = 0, SYNCMOD = 1, SYNCDEL = 3 };
     /** Set synchronisation satus. */
     void setSyncStatus(int stat);
     /** Return synchronisation status. */
     int syncStatus() const;
 
     /** Set Pilot Id. */
     void setPilotId(int id);
     /** Return Pilot Id. */
     int pilotId() const;
 
     void setTempSyncStat(int id);
     int tempSyncStat() const;
     void setIDStr( const QString & );
     QString IDStr() const;
     void setID( const QString &, const QString & );
     QString  getID( const QString & );
     void setCsum( const QString &, const QString & );
     QString getCsum( const QString & );
     void removeID(const QString &);
 
     void registerObserver( Observer * );
     void unRegisterObserver( Observer * );
     void updated();
     void setCalID( int id );
     int calID() const;
     void setCalEnabled( bool );
     bool calEnabled() const; 
     void setAlarmEnabled( bool );
     bool alarmEnabled() const;
     bool isTagged() const;
     void setTagged( bool );
+    virtual void setLastModifiedSubInvalid();
   protected:
     bool blockLastModified;
     bool mIsTagged;
     QDateTime mDtStart;
     bool mReadOnly;
     QDateTime getEvenTime( QDateTime );
 
   private:
     // base components
     QString mOrganizer;
     QString mUid;
     int mCalID;
     bool mCalEnabled;
     bool mAlarmEnabled;
     QDateTime mLastModified;
     QPtrList<Attendee> mAttendees;
 
     bool mFloats;
 
     int mDuration;
     bool mHasDuration;
     QString  mExternalId;
     int mTempSyncStat;
 
     // PILOT SYNCHRONIZATION STUFF
     int mPilotId;                         // unique id for pilot sync
     int mSyncStatus;                      // status (for sync)
 
     QPtrList<Observer> mObservers;
 };
 
 bool operator==( const IncidenceBase&, const IncidenceBase& );
 }
 
 #endif