rec changes

7 files changed, 67 insertions, 36 deletions

diff --git a/libkcal/event.cpp b/libkcal/event.cpp
index ad66639..0766fd9 100644
--- a/libkcal/event.cpp
+++ b/libkcal/event.cpp
@@ -112,128 +112,129 @@ void Event::setDtEnd(const QDateTime &dtEnd)
   setHasEndDate(true);
   setHasDuration(false);
 
   updated();
 }
 
 QDateTime Event::dtEnd() const
 {
   if (hasEndDate()) return mDtEnd;
   if (hasDuration()) return dtStart().addSecs(duration());
 
   return dtStart();
 }
 
 QString Event::dtEndTimeStr() const
 {
   return KGlobal::locale()->formatTime(mDtEnd.time());
 }
 
 QString Event::dtEndDateStr(bool shortfmt) const
 {
   return KGlobal::locale()->formatDate(mDtEnd.date(),shortfmt);
 }
 
 QString Event::dtEndStr(bool shortfmt) const
 {
   return KGlobal::locale()->formatDateTime(mDtEnd, shortfmt);
 }
 
 void Event::setHasEndDate(bool b)
 {
   mHasEndDate = b;
 }
 
 bool Event::hasEndDate() const
 {
   return mHasEndDate;
 }
 
 bool Event::isMultiDay() const
 {
   bool multi = !(dtStart().date() == dtEnd().date());
   return multi;
 }
 
 void Event::setTransparency(Event::Transparency transparency)
 {
   if (mReadOnly) return;
   mTransparency = transparency;
   updated();
 }
 
 Event::Transparency Event::transparency() const
 {
   return mTransparency;
 }
 
 void Event::setDuration(int seconds)
 {
   setHasEndDate(false);
   Incidence::setDuration(seconds);
 }
 bool Event::matchTime(QDateTime*startDT, QDateTime* endDT)
 {
+    if ( cancelled() ) return false;
     if ( ! doesRecur() ) {
         if ( doesFloat() ) {
             if ( mDtEnd.addDays( 1 ) < *startDT)
                 return false;
             if ( endDT && mDtStart > * endDT)
                 return false;
         } else {
             if ( mDtEnd < *startDT )
                 return false;
             if ( endDT && mDtStart > * endDT)
                 return false;
         }
     } else {
         if ( endDT && mDtStart > * endDT)
             return false;
     }
     return true;
 }
 bool Event::isOverlapping (  Event* testEvent,  QDateTime* overlapDT, QDateTime* startDT )
 {
     if ( testEvent == this )
         return false;
     if ( ! doesRecur() && !testEvent->doesRecur() ) {
         QDateTime te;
         if ( testEvent->doesFloat() )
             te = testEvent->mDtEnd.addDays( 1 );
         else
             te = testEvent->mDtEnd;
         QDateTime e; 
         if ( doesFloat() )
             e = mDtEnd.addDays( 1 );
         else
             e = mDtEnd;
         if ( mDtStart < te && testEvent->mDtStart < e ) {
             if ( mDtStart < testEvent->mDtStart )
                 *overlapDT =  testEvent->mDtStart;
             else
                 *overlapDT =  mDtStart;
             if ( startDT )
                 return (*overlapDT >= *startDT );
             return true;
         }
         return false;
     }
     if ( !doesFloat() && !testEvent->doesFloat() && !isMultiDay() && !testEvent->isMultiDay() ) {
         if ( mDtStart.time() >=  testEvent->mDtEnd.time() || testEvent->mDtStart.time() >=  mDtEnd.time() ) {
             // no need to test. times mismatch
             //fprintf(stderr,"timi ");
             return false;
         }
     }
     Event *nonRecur = 0;
     Event *recurEvent = 0;
     if ( ! doesRecur() ) {
         nonRecur = this;
         recurEvent = testEvent;
     }
     else if ( !testEvent->doesRecur() ) {
         nonRecur = testEvent;
         recurEvent = this;
     }
     if ( nonRecur ) {
         QDateTime enr; 
         if ( nonRecur->doesFloat() )
diff --git a/libkcal/icalformatimpl.cpp b/libkcal/icalformatimpl.cpp
index 4794bc9..f349681 100644
--- a/libkcal/icalformatimpl.cpp
+++ b/libkcal/icalformatimpl.cpp
@@ -311,140 +311,137 @@ void ICalFormatImpl::writeIncidence(icalcomponent *parent,Incidence *incidence)
   // status
 //  addPropValue(parent, VCStatusProp, incidence->getStatusStr().utf8());
 
   // secrecy
   enum icalproperty_class classInt;
   switch (incidence->secrecy()) {
     case Incidence::SecrecyPublic:
       classInt = ICAL_CLASS_PUBLIC;
       break;
     case Incidence::SecrecyConfidential:
       classInt = ICAL_CLASS_CONFIDENTIAL;
       break;
     case Incidence::SecrecyPrivate:
       classInt =ICAL_CLASS_PRIVATE ;
     default:
       classInt =ICAL_CLASS_PRIVATE ;
       break;
   }
   icalcomponent_add_property(parent,icalproperty_new_class(classInt));
 
   // priority
   icalcomponent_add_property(parent,icalproperty_new_priority(
       incidence->priority()));
 
   // categories
   QStringList categories = incidence->categories();
   QStringList::Iterator it;
   for(it = categories.begin(); it != categories.end(); ++it ) {
     icalcomponent_add_property(parent,icalproperty_new_categories((*it).utf8()));
   }
 // TODO: Ensure correct concatenation of categories properties.
 
 /*
   // categories
   tmpStrList = incidence->getCategories();
   tmpStr = "";
   QString catStr;
   for ( QStringList::Iterator it = tmpStrList.begin();
         it != tmpStrList.end();
         ++it ) {
     catStr = *it;
     if (catStr[0] == ' ')
       tmpStr += catStr.mid(1);
     else
       tmpStr += catStr;
     // this must be a ';' character as the vCalendar specification requires!
     // vcc.y has been hacked to translate the ';' to a ',' when the vcal is
     // read in.
     tmpStr += ";";
   }
   if (!tmpStr.isEmpty()) {
     tmpStr.truncate(tmpStr.length()-1);
     icalcomponent_add_property(parent,icalproperty_new_categories(
         writeText(incidence->getCategories().join(";"))));
   }
 */
 
   // related event
   if (!incidence->relatedToUid().isEmpty()) {
     icalcomponent_add_property(parent,icalproperty_new_relatedto(
         incidence->relatedToUid().utf8()));
   }
 
   // recurrence rule stuff
-  Recurrence *recur = incidence->recurrence();
-  if (recur->doesRecur()) {
-    
-    icalcomponent_add_property(parent,writeRecurrenceRule(recur));
-  }
-
-  // recurrence excpetion dates
-  DateList dateList = incidence->exDates();
-  DateList::ConstIterator exIt;
-  for(exIt = dateList.begin(); exIt != dateList.end(); ++exIt) {
-    icalcomponent_add_property(parent,icalproperty_new_exdate(
-        writeICalDate(*exIt)));
+  if (incidence->doesRecur()) {
+      icalcomponent_add_property(parent,writeRecurrenceRule(incidence->recurrence()));
+      // recurrence excpetion dates
+      DateList dateList = incidence->exDates();
+      DateList::ConstIterator exIt;
+      for(exIt = dateList.begin(); exIt != dateList.end(); ++exIt) {
+          icalcomponent_add_property(parent,icalproperty_new_exdate(
+                                                                    writeICalDate(*exIt)));
+      }
   }
   
   // attachments
   QPtrList<Attachment> attachments = incidence->attachments();
   for (Attachment *at = attachments.first(); at; at = attachments.next())
     icalcomponent_add_property(parent,writeAttachment(at));
 
   // alarms
   QPtrList<Alarm> alarms = incidence->alarms();
   Alarm* alarm;
   for (alarm = alarms.first(); alarm; alarm = alarms.next()) {
     if (alarm->enabled()) {
       kdDebug(5800) << "Write alarm for " << incidence->summary() << endl;
       icalcomponent_add_component(parent,writeAlarm(alarm));
     }
   }
   if( incidence->hasRecurrenceID() ) {
       icalcomponent_add_property(parent,
                                  icalproperty_new_recurrenceid( writeICalDateTime( incidence->recurrenceID())));
   }
   // duration
 
 // turned off as it always is set to PTS0 (and must not occur together with DTEND
 
   if (incidence->hasDuration()) {
       icaldurationtype duration;
       duration = writeICalDuration(incidence->duration());
       icalcomponent_add_property(parent,icalproperty_new_duration(duration));
   }
 }
 
 void ICalFormatImpl::writeIncidenceBase(icalcomponent *parent,IncidenceBase *incidenceBase)
 {
   icalcomponent_add_property(parent,icalproperty_new_dtstamp(
       writeICalDateTime(QDateTime::currentDateTime())));
 
   // organizer stuff
   icalcomponent_add_property(parent,icalproperty_new_organizer(
       ("MAILTO:" + incidenceBase->organizer()).utf8()));
 
   // attendees
   if (incidenceBase->attendeeCount() != 0) {
     QPtrList<Attendee> al = incidenceBase->attendees();
     QPtrListIterator<Attendee> ai(al);
     for (; ai.current(); ++ai) {
       icalcomponent_add_property(parent,writeAttendee(ai.current()));
     }
   }
 
   // custom properties
   writeCustomProperties(parent, incidenceBase);
 }
 
 void ICalFormatImpl::writeCustomProperties(icalcomponent *parent,CustomProperties *properties)
 {
   QMap<QCString, QString> custom = properties->customProperties();
   for (QMap<QCString, QString>::Iterator c = custom.begin();  c != custom.end();  ++c) {
     icalproperty *p = icalproperty_new_x(c.data().utf8());
     icalproperty_set_x_name(p,c.key());
     icalcomponent_add_property(parent,p);
   }
 }
 
 icalproperty *ICalFormatImpl::writeAttendee(Attendee *attendee)
@@ -1234,129 +1231,130 @@ void ICalFormatImpl::readIncidence(icalcomponent *parent,Incidence *incidence)
         break;
 
       case ICAL_CATEGORIES_PROPERTY:  // categories
         text = icalproperty_get_categories(p);
         categories.append(QString::fromUtf8(text));
         break;
         //*******************************************
       case ICAL_RRULE_PROPERTY:
           // we do need (maybe )start datetime of incidence for recurrence
           // such that we can read recurrence only after we read incidence completely
           readrec = true;
           rectype = icalproperty_get_rrule(p);
         break;
 
       case ICAL_EXDATE_PROPERTY:
         icaltime = icalproperty_get_exdate(p);
         incidence->addExDate(readICalDate(icaltime));
         break;
 
     case ICAL_CLASS_PROPERTY: {
         int inttext = icalproperty_get_class(p);
         if (inttext == ICAL_CLASS_PUBLIC ) {
           incidence->setSecrecy(Incidence::SecrecyPublic);
         } else if (inttext == ICAL_CLASS_CONFIDENTIAL ) {
           incidence->setSecrecy(Incidence::SecrecyConfidential);
         } else {
           incidence->setSecrecy(Incidence::SecrecyPrivate);
         }
     }
         break;
 
       case ICAL_ATTACH_PROPERTY:  // attachments
         incidence->addAttachment(readAttachment(p));
         break;
  
       default:
 //        kdDebug(5800) << "ICALFormat::readIncidence(): Unknown property: " << kind
 //                  << endl;
         break;
     }
 
     p = icalcomponent_get_next_property(parent,ICAL_ANY_PROPERTY);
   }
   if ( readrec ) {
       readRecurrenceRule(rectype,incidence);
   }
   // kpilot stuff
 // TODO: move this application-specific code to kpilot
   QString kp = incidence->nonKDECustomProperty("X-PILOTID");
   if (!kp.isNull()) {
     incidence->setPilotId(kp.toInt());
   }
   kp = incidence->nonKDECustomProperty("X-PILOTSTAT");
   if (!kp.isNull()) {
     incidence->setSyncStatus(kp.toInt());
   }
 
 
   kp = incidence->nonKDECustomProperty("X-KOPIEXTID");
   if (!kp.isNull()) {
     incidence->setIDStr(kp);
   }
 
   // Cancel backwards compatibility mode for subsequent changes by the application
-  incidence->recurrence()->setCompatVersion();
+  if ( readrec )
+      incidence->recurrence()->setCompatVersion();
 
   // add categories
   incidence->setCategories(categories);
 
   // iterate through all alarms
   for (icalcomponent *alarm = icalcomponent_get_first_component(parent,ICAL_VALARM_COMPONENT);
        alarm;
        alarm = icalcomponent_get_next_component(parent,ICAL_VALARM_COMPONENT)) {
     readAlarm(alarm,incidence);
   }
 }
 
 void ICalFormatImpl::readIncidenceBase(icalcomponent *parent,IncidenceBase *incidenceBase)
 {
   icalproperty *p = icalcomponent_get_first_property(parent,ICAL_ANY_PROPERTY);
 
   while (p) {
     icalproperty_kind kind = icalproperty_isa(p);
     switch (kind) {
 
       case ICAL_UID_PROPERTY:  // unique id
         incidenceBase->setUid(QString::fromUtf8(icalproperty_get_uid(p)));
         break;
 
       case ICAL_ORGANIZER_PROPERTY:  // organizer
         incidenceBase->setOrganizer(QString::fromUtf8(icalproperty_get_organizer(p)));
         break;
 
       case ICAL_ATTENDEE_PROPERTY:  // attendee
         incidenceBase->addAttendee(readAttendee(p));
         break;
 
       default:
         break;
     }
 
     p = icalcomponent_get_next_property(parent,ICAL_ANY_PROPERTY);
   }
 
   // custom properties
   readCustomProperties(parent, incidenceBase);
 }
 
 void ICalFormatImpl::readCustomProperties(icalcomponent *parent,CustomProperties *properties)
 {
   QMap<QCString, QString> customProperties;
 
   icalproperty *p = icalcomponent_get_first_property(parent,ICAL_X_PROPERTY);
 
   while (p) {
     QString value = QString::fromUtf8(icalproperty_get_x(p));
     customProperties[icalproperty_get_x_name(p)] = value;
     //qDebug("ICalFormatImpl::readCustomProperties %s %s",value.latin1(), icalproperty_get_x_name(p) );
 
     p = icalcomponent_get_next_property(parent,ICAL_X_PROPERTY);
   }
 
   properties->setCustomProperties(customProperties);
 }
 
 void ICalFormatImpl::readRecurrenceRule(struct icalrecurrencetype rrule,Incidence *incidence)
 {
 //  kdDebug(5800) << "Read recurrence for " << incidence->summary() << endl;
 
diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
index e4bcc5e..4643a3a 100644
--- a/libkcal/incidence.cpp
+++ b/libkcal/incidence.cpp
@@ -1,397 +1,418 @@
 /*
     This file is part of libkcal.
     Copyright (c) 2001 Cornelius Schumacher <schumacher@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., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 
 #include "calformat.h"
 
 #include "incidence.h"
 #include "todo.h"
 
 using namespace KCal;
 
 Incidence::Incidence() :
   IncidenceBase(),
   mRelatedTo(0), mSecrecy(SecrecyPublic), mPriority(3)
 {
-  mRecurrence = new Recurrence(this);
+    mRecurrence = 0;//new Recurrence(this);
   mCancelled = false;
   recreate();
   mHasStartDate = true;
   mAlarms.setAutoDelete(true);
   mAttachments.setAutoDelete(true);
   mHasRecurrenceID = false;
   mHoliday = false;
   mBirthday = false;
   mAnniversary = false;
 
 }
 
 Incidence::Incidence( const Incidence &i ) : IncidenceBase( i )
 {
 // 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;
 //  QPtrList<Incidence> mRelations;    QPtrList<Incidence> mRelations;
   mExDates = i.mExDates;
   mAttachments = i.mAttachments;
   mResources = i.mResources;
   mSecrecy = i.mSecrecy;
   mPriority = i.mPriority;
   mLocation = i.mLocation;
   mCancelled = i.mCancelled;
   mHasStartDate = i.mHasStartDate;
   QPtrListIterator<Alarm> it( i.mAlarms );
   const Alarm *a;
   while( (a = it.current()) ) {
     Alarm *b = new Alarm( *a );
     b->setParent( this );
     mAlarms.append( b );
 
     ++it;
   }
   mAlarms.setAutoDelete(true);
   mHasRecurrenceID = i.mHasRecurrenceID;
   mRecurrenceID = i.mRecurrenceID;
-  mRecurrence = new Recurrence( *(i.mRecurrence), this );
+  if ( i.mRecurrence )
+      mRecurrence = new Recurrence( *(i.mRecurrence), this );
+  else
+      mRecurrence = 0;
   mHoliday = i.mHoliday ;
   mBirthday = i.mBirthday;
   mAnniversary = i.mAnniversary;
 }
 
 Incidence::~Incidence()
 {
    
   Incidence *ev;
    QPtrList<Incidence> Relations = relations();
   for (ev=Relations.first();ev;ev=Relations.next()) {
     if (ev->relatedTo() == this) ev->setRelatedTo(0);
   } 
   if (relatedTo()) relatedTo()->removeRelation(this);
-  delete mRecurrence; 
+  if ( mRecurrence ) 
+      delete mRecurrence; 
  
 }
 
 bool Incidence::isHoliday() const
 {
     return mHoliday;
 }
 bool Incidence::isBirthday() const
 {
 
     return mBirthday ;
 }
 bool Incidence::isAnniversary() const
 {
     return mAnniversary ;
 
 }
 
 bool Incidence::hasRecurrenceID() const
 {
     return mHasRecurrenceID;
 }
 
 void Incidence::setHasRecurrenceID( bool b )
 {
     mHasRecurrenceID = b;
 }
    
 void Incidence::setRecurrenceID(QDateTime d)
 {
     mRecurrenceID = d;
     mHasRecurrenceID = true;
     updated(); 
 }
 QDateTime Incidence::recurrenceID () const
 {
     return mRecurrenceID;
 }
 
 bool Incidence::cancelled() const
 {
     return mCancelled;
 }
 void Incidence::setCancelled( bool b )
 {
     mCancelled = b;
     updated();
 }
 bool Incidence::hasStartDate() const
 {
   return mHasStartDate;
 }
 
 void Incidence::setHasStartDate(bool f)
 {
   if (mReadOnly) return;
   mHasStartDate = f;
   updated();
 }
 
 // A string comparison that considers that null and empty are the same
 static bool stringCompare( const QString& s1, const QString& s2 )
 {
     if ( s1.isEmpty() && s2.isEmpty() )
         return true;
     return s1 == s2;
 }
 
 bool KCal::operator==( const Incidence& i1, const Incidence& i2 )
 {
   
     if( i1.alarms().count() != i2.alarms().count() ) {
         return false; // no need to check further
     }
     if ( i1.alarms().count() > 0 ) {
         if ( !( *(i1.alarms().first()) == *(i2.alarms().first())) ) 
             {
             qDebug("alarm not equal ");
             return false;
         }
     }
 #if 0
     QPtrListIterator<Alarm> a1( i1.alarms() );
     QPtrListIterator<Alarm> a2( i2.alarms() );
     for( ; a1.current() && a2.current(); ++a1, ++a2 ) {
         if( *a1.current() == *a2.current() ) {
             continue;
         }
         else {
             return false;
         }
     }
 #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;
+    if ( i1.mRecurrence != 0 && i2.mRecurrence != 0 ) {
+        if (!( *i1.mRecurrence == *i2.mRecurrence) ) {
+            //qDebug("recurrence is NOT equal ");
+            return false;
+        }
+    } else {
+        // one ( or both ) recurrence is 0
+        if ( i1.mRecurrence == 0 ) {
+            if ( i2.mRecurrence != 0 && i2.mRecurrence->doesRecur() != Recurrence::rNone )
+                return false;
+        } else {
+            // i1.mRecurrence != 0
+            // i2.mRecurrence == 0
+            if ( i1.mRecurrence->doesRecur() != Recurrence::rNone )
+                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);
+  if ( mRecurrence )
+      mRecurrence->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);
+
+  if ( mRecurrence )
+      mRecurrence->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 );
@@ -443,137 +464,136 @@ void Incidence::setRelatedToUid(const QString &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)
 {
     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;
+  if (mRecurrence && mRecurrence->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 );
@@ -637,144 +657,155 @@ QString Incidence::secrecyName(int secrecy)
       break;
     case SecrecyPrivate:
       return i18n("Private");
       break;
     case SecrecyConfidential:
       return i18n("Confidential");
       break;
     default:
       return i18n("Undefined");
       break;
   }
 }
 
 QStringList Incidence::secrecyList()
 {
   QStringList list;
   list << secrecyName(SecrecyPublic);
   list << secrecyName(SecrecyPrivate);
   list << secrecyName(SecrecyConfidential);
 
   return list;
 }
 
 
 QPtrList<Alarm> 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.clear();
   updated();
 }
 
 bool Incidence::isAlarmEnabled() const
 {
   Alarm* alarm;
   for (QPtrListIterator<Alarm> it(mAlarms); (alarm = it.current()) != 0; ++it) {
     if (alarm->enabled())
       return true;
   }
   return false;
 }
-
-Recurrence *Incidence::recurrence() const
+#include <stdlib.h>
+Recurrence *Incidence::recurrence()
 {
+    if ( ! mRecurrence ) {
+        mRecurrence = new Recurrence(this);
+        qDebug("creating new recurence ");
+        //abort();
+    }
   return mRecurrence;
 }
 void Incidence::setRecurrence( Recurrence * r) 
 {
-  delete mRecurrence;
-  mRecurrence = r;
+    if ( mRecurrence )
+        delete mRecurrence;
+    mRecurrence = r;
 }
 
 void Incidence::setLocation(const QString &location)
 {
   if (mReadOnly) return;
   mLocation = location;
   updated();
 }
 
 QString Incidence::location() const
 {
   return mLocation;
 }
+QString Incidence::recurrenceText() const
+{
+    if ( mRecurrence ) return mRecurrence->recurrenceText();
+    return i18n("No");
+}
 
 ushort Incidence::doesRecur() const
 {
   if ( mRecurrence ) return mRecurrence->doesRecur();
   else return Recurrence::rNone;
 }
 
 QDateTime Incidence::getNextOccurence( const QDateTime& dt, bool* ok ) const
 {
     QDateTime incidenceStart = dt;
     *ok = false;
     if ( doesRecur() ) {
         bool last;
-         recurrence()->getPreviousDateTime( incidenceStart , &last );
+         mRecurrence->getPreviousDateTime( incidenceStart , &last );
          int count = 0;
          if ( !last ) {
              while ( !last ) {
                  ++count;
-                 incidenceStart = recurrence()->getNextDateTime( incidenceStart, &last );
+                 incidenceStart = mRecurrence->getNextDateTime( incidenceStart, &last );
                  if ( recursOn( incidenceStart.date() ) ) {
                      last = true; // exit while llop
                  } else {
                      if ( last ) { // no alarm on last recurrence
                          return QDateTime ();
                      }
                      int year = incidenceStart.date().year();
                      // workaround for bug in recurrence
                      if ( count == 100 || year < 1000 || year > 5000 ) {
                          return QDateTime ();
                      }
                      incidenceStart = incidenceStart.addSecs( 1 );
                  }
              }
          } else {
              return QDateTime ();
          }
     } else {
         if ( hasStartDate () ) {
             incidenceStart = dtStart(); 
         }
         if ( typeID() == todoID ) {
             if ( ((Todo*)this)->hasDueDate() )
                 incidenceStart = ((Todo*)this)->dtDue();
         }
     }
     if ( incidenceStart > dt )
         *ok = true;
     return incidenceStart;
 }
 QDateTime Incidence::dtStart() const
 {
     if ( doesRecur() ) {
         if ( typeID() == todoID ) {
             ((Todo*)this)->checkSetCompletedFalse();
         }
     }
     return mDtStart;
 }
diff --git a/libkcal/incidence.h b/libkcal/incidence.h
index d4af9f0..8519f01 100644
--- a/libkcal/incidence.h
+++ b/libkcal/incidence.h
@@ -188,134 +188,135 @@ class Incidence : public IncidenceBase
     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;
+    Recurrence *recurrence();
     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();
+    QString recurrenceText() const;
     void setLastModifiedSubInvalid();
     
 
+    Recurrence *mRecurrence;
 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/kincidenceformatter.cpp b/libkcal/kincidenceformatter.cpp
index 9359fad..f8f40f1 100644
--- a/libkcal/kincidenceformatter.cpp
+++ b/libkcal/kincidenceformatter.cpp
@@ -44,240 +44,240 @@ KIncidenceFormatter::~KIncidenceFormatter()
 KIncidenceFormatter::KIncidenceFormatter()
 {
     mColorMode = 0;
 }
 void KIncidenceFormatter::setEvent(Event *event)
 {
     int mode = 0;
     mCurrentIncidence = event;
     bool shortDate = true;
     if ( mode == 0 ) {
         addTag("h3",deTag(event->summary()));
         formatReadOnly(event);
     }
     else {
         if ( mColorMode == 1 ) {
             mText +="<font color=\"#00A000\">";
         }
         if ( mColorMode == 2 ) {
             mText +="<font color=\"#C00000\">";
         }
         // mText +="<font color=\"#F00000\">" + i18n("O-due!") + "</font>";
         if ( mode == 1 ) {
             addTag("h2",i18n( "Local: " ) +deTag(event->summary()));
         } else {
             addTag("h2",i18n( "Remote: " ) +deTag(event->summary()));
         } 
         formatReadOnly(event);
         addTag("h3",i18n( "Last modified: " ) + KGlobal::locale()->formatDateTime(event->lastModified(),shortDate, true ) );
         if ( mColorMode )
             mText += "</font>";
     } 
     if (event->cancelled ()) {
         mText +="<font color=\"#B00000\">";
         addTag("i",i18n("This event has been cancelled!"));
         mText.append("<br>");
         mText += "</font>";
     }
     if (event->doesFloat()) {
         if (event->isMultiDay()) {
             mText.append(i18n("<p><b>From:</b> %1 </p><p><b>To:</b> %2</p>")
                          .arg(event->dtStartDateStr(shortDate))
                          .arg(event->dtEndDateStr(shortDate)));
         } else {
             mText.append(i18n("<p><b>On:</b> %1</p>").arg(event->dtStartDateStr( shortDate )));
         }
     } else {
         if (event->isMultiDay()) {
             mText.append(i18n("<p><b>From:</b> %1</p> ")
                          .arg(event->dtStartStr( shortDate)));
             mText.append(i18n("<p><b>To:</b> %1</p>")
                          .arg(event->dtEndStr(shortDate)));
         } else {
             mText.append(i18n("<p><b>From:</b> %1 <b>To:</b> %2</p>")
                          .arg(event->dtStartTimeStr())
                          .arg(event->dtEndTimeStr()));
             mText.append(i18n("<p><b>On:</b> %1</p> ")
                          .arg(event->dtStartDateStr( shortDate )));
         }
     }
     if (!event->location().isEmpty()) {
         addTag("b",i18n("Location: "));
         mText.append(deTag(event->location())+"<br>");
     }
 
-    if (event->recurrence()->doesRecur()) {
+    if (event->doesRecur()) {
 
         QString recurText = event->recurrence()->recurrenceText();
         addTag("p","<em>" + i18n("This is a %1 recurring event.").arg(recurText ) + "</em>");
 
  bool ok;
         QDate start = QDate::currentDate();
         QDateTime next;
         next = event->getNextOccurence( QDateTime::currentDateTime() , &ok );
         if ( ok ) {
             addTag("p",i18n("<b>Next recurrence is on:</b>")  );
             addTag("p", KGlobal::locale()->formatDate( next.date(), shortDate ));
 
         } else {
             bool last;
             QDate nextd;
             nextd = event->recurrence()->getPreviousDate( QDate::currentDate() , &last );
             if ( last ) {
                 addTag("p",i18n("<b>Last recurrence was on:</b>")  );
                 addTag("p", KGlobal::locale()->formatDate( nextd, shortDate ));
             }
         }
     }
 
 
     if (event->isAlarmEnabled()) {
         Alarm *alarm =event->alarms().first() ;
         QDateTime t = alarm->time();
         QString s =i18n("( %1 before )").arg( alarm->offsetText() );
         addTag("p",i18n("<b>Alarm on:  </b>")  + s  + ": "+KGlobal::locale()->formatDateTime( t, shortDate ));
         //addTag("p", KGlobal::locale()->formatDateTime( t, shortDate ));
         //addTag("p",s);
     }
 
 
 
     addTag("p",i18n("<b>Access: </b>") +event->secrecyStr() );
     // mText.append(event->secrecyStr()+"<br>");
     formatCategories(event);
 
     formatAttendees(event);
 
     if ( mCreated ) {
 #ifdef DESKTOP_VERSION
         addTag("p",i18n("<b>Created: ")  +" </b>"+KGlobal::locale()->formatDateTime( event->created(), shortDate ));
 #else
         addTag("p",i18n("<b>Created: ")  +" </b>");
         addTag("p", KGlobal::locale()->formatDateTime( event->created(), shortDate ));
 #endif
         
     }
     if ( mModified ) {
 #ifdef DESKTOP_VERSION
         addTag("p",i18n("<b>Last modified: ")  +" </b>"+KGlobal::locale()->formatDateTime( event->lastModified(), shortDate ));
 #else
         addTag("p",i18n("<b>Last modified: ")  +" </b>");
         addTag("p", KGlobal::locale()->formatDateTime( event->lastModified(), shortDate ));
 #endif
         
     }
     if ( mDetails  ) {
         if (!event->description().isEmpty()) {
             addTag("p",i18n("<b>Details: </b>"));
             addTag("p",deTag(event->description()));
         }
     }
  
 }
 
 void KIncidenceFormatter::setTodo(Todo *event )
 {
     int mode = 0;
     mCurrentIncidence = event;
     bool shortDate = true;
     if (mode == 0 ) {
         addTag("h3",deTag(event->summary()));
         formatReadOnly(event);
     }
     else { 
         if ( mColorMode == 1 ) {
             mText +="<font color=\"#00A000\">";
         }
         if ( mColorMode == 2 ) {
             mText +="<font color=\"#B00000\">";
         }
         if ( mode == 1 ) {
             addTag("h2",i18n( "Local: " ) +deTag(event->summary()));
         } else {
             addTag("h2",i18n( "Remote: " ) +deTag(event->summary()));
         }
         formatReadOnly(event);
         addTag("h3",i18n( "Last modified: " ) + KGlobal::locale()->formatDateTime(event->lastModified(),shortDate, true ) );
         if ( mColorMode )
             mText += "</font>";
     } 
     if ( event->percentComplete() == 100 && event->hasCompletedDate() ) {
         mText +="<font color=\"#B00000\">";
         addTag("i",  i18n("<p><i>Completed on %1</i></p>").arg( event->completedStr(shortDate) ) );
         mText += "</font>";
     } else {
         mText.append(i18n("<p><i>%1 % completed</i></p>")
                      .arg(event->percentComplete()));
     }
     if (event->cancelled ()) {
         mText +="<font color=\"#B00000\">";
         addTag("i",i18n("This todo has been cancelled!"));
         mText.append("<br>");
         mText += "</font>";
     }
    
    
-    if (event->recurrence()->doesRecur()) {
+    if (event->doesRecur()) {
 
         QString recurText = event->recurrence()->recurrenceText();
         addTag("p","<em>" + i18n("This is a %1 recurring todo.").arg(recurText ) + "</em>");
     } 
         
     if (event->hasStartDate()) {
         mText.append(i18n("<p><b>Start on:</b> %1</p>").arg(event->dtStartStr(shortDate)));
     }
         
 
     if (event->hasDueDate()) {
         mText.append(i18n("<p><b>Due on:</b> %1</p>").arg(event->dtDueStr(shortDate)));
     }
 
     if (!event->location().isEmpty()) {
         addTag("b",i18n("Location: "));
         mText.append(deTag(event->location())+"<br>");
     }
 
     mText.append(i18n("<p><b>Priority:</b> %2</p>")
                  .arg(QString::number(event->priority())));
   
    if (event->isAlarmEnabled()) {
         Alarm *alarm =event->alarms().first() ;
         QDateTime t = alarm->time();
         QString s =i18n("( %1 before )").arg( alarm->offsetText() );
         addTag("p",i18n("<b>Alarm on: ") + s  +" </b>");
         addTag("p", KGlobal::locale()->formatDateTime( t, shortDate ));
         //addTag("p",s);
     }
 
     addTag("p",i18n("<b>Access: </b>") +event->secrecyStr() );
     formatCategories(event);
    
     formatAttendees(event);
     if ( mCreated ) {
 #ifdef DESKTOP_VERSION
         addTag("p",i18n("<b>Created: ")  +" </b>"+KGlobal::locale()->formatDateTime( event->created(), shortDate ));
 #else
         addTag("p",i18n("<b>Created: ")  +" </b>");
         addTag("p", KGlobal::locale()->formatDateTime( event->created(), shortDate ));
 #endif
         
     }
     if ( mModified ) {
 #ifdef DESKTOP_VERSION
         addTag("p",i18n("<b>Last modified: ")  +" </b>"+KGlobal::locale()->formatDateTime( event->lastModified(), shortDate ));
 #else
         addTag("p",i18n("<b>Last modified: ")  +" </b>");
         addTag("p", KGlobal::locale()->formatDateTime( event->lastModified(), shortDate ));
 #endif
         
     }
     if ( mDetails  ) {
         if (!event->description().isEmpty()) {
             addTag("p",i18n("<b>Details: </b>"));
             addTag("p",deTag(event->description()));
         }
     }
 }
 
 void KIncidenceFormatter::setJournal(Journal*  )
 {
 
diff --git a/libkcal/vcalformat.cpp b/libkcal/vcalformat.cpp
index 8efc1ea..2e19740 100644
--- a/libkcal/vcalformat.cpp
+++ b/libkcal/vcalformat.cpp
@@ -331,196 +331,196 @@ VObject *VCalFormat::eventToVTodo(const Todo *anEvent)
                  anEvent->relatedToUid().local8Bit());
   }
 
   // categories
   QStringList tmpStrList = anEvent->categories();
   tmpStr = "";
   QString catStr;
   for ( QStringList::Iterator it = tmpStrList.begin();
         it != tmpStrList.end();
         ++it ) {
     catStr = *it;
     if (catStr[0] == ' ')
       tmpStr += catStr.mid(1);
     else
       tmpStr += catStr;
     // this must be a ';' character as the vCalendar specification requires!
     // vcc.y has been hacked to translate the ';' to a ',' when the vcal is
     // read in.
     tmpStr += ";";
   }
   if (!tmpStr.isEmpty()) {
     tmpStr.truncate(tmpStr.length()-1);
     addPropValue(vtodo, VCCategoriesProp, tmpStr.local8Bit());
   }
 
   // alarm stuff
   kdDebug(5800) << "vcalformat::eventToVTodo was called" << endl;
   QPtrList<Alarm> alarms = anEvent->alarms();
   Alarm* alarm;
   for (alarm = alarms.first(); alarm; alarm = alarms.next()) {
     if (alarm->enabled()) {
         VObject *a;
             tmpStr = qDateTimeToISO(alarm->time());
         if (alarm->type() == Alarm::Audio) {
             a = addProp(vtodo, VCAAlarmProp);
             addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
             addPropValue(a, VCRepeatCountProp, "1");
             addPropValue(a, VCAudioContentProp, QFile::encodeName(alarm->audioFile()));
         }
         else if (alarm->type() == Alarm::Procedure) {
             a = addProp(vtodo, VCPAlarmProp);
             addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
             addPropValue(a, VCRepeatCountProp, "1");
             addPropValue(a, VCProcedureNameProp, QFile::encodeName(alarm->programFile()));
         } else {
             a = addProp(vtodo, VCDAlarmProp);
             addPropValue(a, VCRunTimeProp, tmpStr.local8Bit());
             addPropValue(a, VCRepeatCountProp, "1");
             addPropValue(a, VCDisplayStringProp, "beep!");
       }
     }
   }
 
   if (anEvent->pilotId()) {
     // pilot sync stuff
     tmpStr.sprintf("%i",anEvent->pilotId());
     addPropValue(vtodo, XPilotIdProp, tmpStr.local8Bit());
     tmpStr.sprintf("%i",anEvent->syncStatus());
     addPropValue(vtodo, XPilotStatusProp, tmpStr.local8Bit());
   }
 
   return vtodo;
 }
 
-VObject* VCalFormat::eventToVEvent(const Event *anEvent)
+VObject* VCalFormat::eventToVEvent(Event *anEvent)
 {
   VObject *vevent;
   QString tmpStr;
  
   vevent = newVObject(VCEventProp);
 
   // start and end time
   tmpStr = qDateTimeToISO(anEvent->dtStart(),
                           !anEvent->doesFloat());
   addPropValue(vevent, VCDTstartProp, tmpStr.local8Bit());
 
   // events that have time associated but take up no time should
   // not have both DTSTART and DTEND.
   if (anEvent->dtStart() != anEvent->dtEnd()) {
     tmpStr = qDateTimeToISO(anEvent->dtEnd(),
                             !anEvent->doesFloat());
     addPropValue(vevent, VCDTendProp, tmpStr.local8Bit());
   }
 
   // creation date
   tmpStr = qDateTimeToISO(anEvent->created());
   addPropValue(vevent, VCDCreatedProp, tmpStr.local8Bit());
 
   // unique id
   addPropValue(vevent, VCUniqueStringProp,
                anEvent->uid().local8Bit());
 
   // revision
   tmpStr.sprintf("%i", anEvent->revision());
   addPropValue(vevent, VCSequenceProp, tmpStr.local8Bit());
 
   // last modification date
   tmpStr = qDateTimeToISO(anEvent->lastModified());
   addPropValue(vevent, VCLastModifiedProp, tmpStr.local8Bit());
 
   // attendee and organizer stuff
   tmpStr = "MAILTO:" + anEvent->organizer();
   addPropValue(vevent, ICOrganizerProp, tmpStr.local8Bit());
 
   if (anEvent->attendeeCount() != 0) {
     QPtrList<Attendee> al = anEvent->attendees();
     QPtrListIterator<Attendee> ai(al);
     Attendee *curAttendee;
 
     // TODO: Put this functionality into Attendee class
     for (; ai.current(); ++ai) {
       curAttendee = ai.current();
       if (!curAttendee->email().isEmpty() &&
           !curAttendee->name().isEmpty())
         tmpStr = "MAILTO:" + curAttendee->name() + " <" +
                  curAttendee->email() + ">";
       else if (curAttendee->name().isEmpty())
         tmpStr = "MAILTO: " + curAttendee->email();
       else if (curAttendee->email().isEmpty())
         tmpStr = "MAILTO: " + curAttendee->name();
       else if (curAttendee->name().isEmpty() &&
                curAttendee->email().isEmpty())
         kdDebug(5800) << "warning! this Event has an attendee w/o name or email!" << endl;
       VObject *aProp = addPropValue(vevent, VCAttendeeProp, tmpStr.local8Bit());
       addPropValue(aProp, VCRoleProp, writeRole(curAttendee->role()));
       addPropValue(aProp, VCRSVPProp, curAttendee->RSVP() ? "TRUE" : "FALSE");
       addPropValue(aProp, VCStatusProp, writeStatus(curAttendee->status()));
     }
   }
 
   // recurrence rule stuff
-  if (anEvent->recurrence()->doesRecur()) {
+  if (anEvent->doesRecur()) {
     // some more variables
     QPtrList<Recurrence::rMonthPos> tmpPositions;
     QPtrList<int> tmpDays;
     int *tmpDay;
     Recurrence::rMonthPos *tmpPos;
     QString tmpStr2;
     int i;
 
     switch(anEvent->recurrence()->doesRecur()) {
     case Recurrence::rDaily:
       tmpStr.sprintf("D%i ",anEvent->recurrence()->frequency());
 //      if (anEvent->rDuration > 0)
         //tmpStr += "#";
       break;
     case Recurrence::rWeekly:
       tmpStr.sprintf("W%i ",anEvent->recurrence()->frequency());
       for (i = 0; i < 7; i++) {
         if (anEvent->recurrence()->days().testBit(i))
           tmpStr += dayFromNum(i);
       }
       break;
     case Recurrence::rMonthlyPos:
       tmpStr.sprintf("MP%i ", anEvent->recurrence()->frequency());
       // write out all rMonthPos's
       tmpPositions = anEvent->recurrence()->monthPositions();
       for (tmpPos = tmpPositions.first();
            tmpPos;
            tmpPos = tmpPositions.next()) {
 
         tmpStr2.sprintf("%i", tmpPos->rPos);
         if (tmpPos->negative)
           tmpStr2 += "- ";
         else
           tmpStr2 += "+ ";
         tmpStr += tmpStr2;
         for (i = 0; i < 7; i++) {
           if (tmpPos->rDays.testBit(i))
             tmpStr += dayFromNum(i);
         }
       } // loop for all rMonthPos's
       break;
     case Recurrence::rMonthlyDay:
       tmpStr.sprintf("MD%i ", anEvent->recurrence()->frequency());
       // write out all rMonthDays;
       tmpDays = anEvent->recurrence()->monthDays();
       for (tmpDay = tmpDays.first();
            tmpDay;
            tmpDay = tmpDays.next()) {
         tmpStr2.sprintf("%i ", *tmpDay);
         tmpStr += tmpStr2;
       }
       break;
     case Recurrence::rYearlyMonth:
       tmpStr.sprintf("YM%i ", anEvent->recurrence()->frequency());
       // write out all the rYearNums;
       tmpDays = anEvent->recurrence()->yearNums();
       for (tmpDay = tmpDays.first();
            tmpDay;
            tmpDay = tmpDays.next()) {
         tmpStr2.sprintf("%i ", *tmpDay);
         tmpStr += tmpStr2;
       }
       break;
     case Recurrence::rYearlyDay:
diff --git a/libkcal/vcalformat.h b/libkcal/vcalformat.h
index c7df017..6dae3d2 100644
--- a/libkcal/vcalformat.h
+++ b/libkcal/vcalformat.h
@@ -13,101 +13,101 @@
     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.
 */
 
 #ifndef _VCALFORMAT_H
 #define _VCALFORMAT_H
 
 #include "calformat.h"
 
 #define _VCAL_VERSION "1.0"
 
 class VObject;
 
 namespace KCal {
 
 /**
   This class implements the vCalendar format. It provides methods for
   loading/saving/converting vCalendar format data into the internal KOrganizer
   representation as Calendar and Events.
 
   @short vCalendar format implementation
 */
 class VCalFormat : public CalFormat {
   public:
     VCalFormat();
     virtual ~VCalFormat();
 
    /** loads a calendar on disk in vCalendar format into the current calendar.
      * any information already present is lost. Returns TRUE if successful,
      * else returns FALSE.
      * @param fileName the name of the calendar on disk.
      */
     bool load(Calendar *,const QString &fileName );
     /** writes out the calendar to disk in vCalendar format. Returns true if
      * successful and false on error.
      * @param fileName the name of the file
      */
     bool save(Calendar *,const QString &fileName );
   
     /**
       Parse string and populate calendar with that information.
     */
     bool fromString( Calendar *, const QString & );  
     /**
       Return calendar information as string.
     */
     void setLocalTime ( bool );
     QString toString( Calendar * );
     QString eventToString( Event *, Calendar *calendar, bool useLocalTime = true );
     QString todoToString( Todo * ,Calendar *calendar, bool useLocalTime = true );
     
   protected:
     /** translates a VObject of the TODO type into a Event */
     Todo *VTodoToEvent(VObject *vtodo);
     /** translates a VObject into a Event and returns a pointer to it. */
     Event *VEventToEvent(VObject *vevent);
     /** translate a Event into a VTodo-type VObject and return pointer */
     VObject *eventToVTodo(const Todo *anEvent);
     /** translate a Event into a VObject and returns a pointer to it. */
-    VObject* eventToVEvent(const Event *anEvent);
+    VObject* eventToVEvent(Event *anEvent);
 
     /** takes a QDate and returns a string in the format YYYYMMDDTHHMMSS */
     QString qDateToISO(const QDate &);
     /** takes a QDateTime and returns a string in format YYYYMMDDTHHMMSS */
     QString qDateTimeToISO(const QDateTime &, bool zulu=TRUE);
     /** takes a string in the format YYYYMMDDTHHMMSS and returns a 
      * valid QDateTime. */
     QDateTime ISOToQDateTime(const QString & dtStr);
     /** takes a string in the format YYYYMMDD and returns a 
      * valid QDate. */
     QDate ISOToQDate(const QString & dtStr);
     /** takes a vCalendar tree of VObjects, and puts all of them that have
      * the "event" property into the dictionary, todos in the todo-list, etc. */
     void populate(VObject *vcal);
   
     /** takes a number 0 - 6 and returns the two letter string of that day,
       * i.e. MO, TU, WE, etc. */
     const char *dayFromNum(int day);
     /** the reverse of the above function. */
     int numFromDay(const QString &day);
     Attendee::Role VCalFormat::readRole(const char *s) const;
     QCString writeRole(Attendee::Role role) const;
     Attendee::PartStat readStatus(const char *s) const;
     QCString writeStatus(Attendee::PartStat status) const;
   
   private:
     Calendar *mCalendar;
     bool useLocalTime;
   
     QPtrList<Event> mEventsRelate;           // events with relations
     QPtrList<Todo> mTodosRelate;             // todos with relations
 };
 
 }
 
 #endif