fixx

4 files changed, 96 insertions, 29 deletions

diff --git a/libkcal/attachment.cpp b/libkcal/attachment.cpp
index 1ead923..520ac95 100644
--- a/libkcal/attachment.cpp
+++ b/libkcal/attachment.cpp
@@ -1,86 +1,120 @@
 /*
     This file is part of libkcal.
+
     Copyright (c) 2002 Michael Brade <brade@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 "attachment.h"
 
 using namespace KCal;
 
+Attachment::Attachment( const Attachment &attachment)
+{
+  mMimeType = attachment.mMimeType;
+  mData = attachment.mData;
+  mBinary = attachment.mBinary;
+        mShowInline = attachment.mShowInline;
+        mLabel = attachment.mLabel;
+}
+
 Attachment::Attachment(const QString& uri, const QString& mime)
 {
   mMimeType = mime;
   mData = uri;
   mBinary = false;
+        mShowInline = false;
+        mLabel = QString::null;
 }
 
 Attachment::Attachment(const char *base64, const QString& mime)
 {
   mMimeType = mime;
   mData = QString::fromUtf8(base64);
   mBinary = true;
+        mShowInline = false;
+        mLabel = QString::null;
 }
 
-bool Attachment::isURI() const
+bool Attachment::isUri() const
 {
   return !mBinary;
 }
 
 QString Attachment::uri() const
 {
   if (!mBinary)
     return mData;
   else
     return QString::null;
 }
 
-void Attachment::setURI(const QString& uri)
+void Attachment::setUri(const QString& uri)
 {
   mData = uri;
   mBinary = false;
 }
 
 bool Attachment::isBinary() const
 {
   return mBinary;
 }
 
 char *Attachment::data() const
 {
   if (mBinary)
     return mData.utf8().data();
   else
     return 0;
 }
 
 void Attachment::setData(const char *base64)
 {
   mData = QString::fromUtf8(base64);
   mBinary = true;
 }
 
 QString Attachment::mimeType() const
 {
   return mMimeType;
 }
 
 void Attachment::setMimeType(const QString& mime)
 {
   mMimeType = mime;
 }
 
+bool Attachment::showInline() const
+{
+  return mShowInline;
+}
+
+void Attachment::setShowInline( bool showinline )
+{
+  mShowInline = showinline;
+}
+
+QString Attachment::label() const
+{
+  return mLabel;
+}
+
+void Attachment::setLabel( const QString& label )
+{
+  mLabel = label;
+}
+
diff --git a/libkcal/attachment.h b/libkcal/attachment.h
index cdf2458..5301420 100644
--- a/libkcal/attachment.h
+++ b/libkcal/attachment.h
@@ -1,69 +1,94 @@
 /*
     This file is part of libkcal.
+
     Copyright (c) 2002 Michael Brade <brade@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.
 */
+#ifndef KCAL_ATTACHMENT_H
+#define KCAL_ATTACHMENT_H
 
-#ifndef _ATTACHMENT_H
-#define _ATTACHMENT_H
 
-#include <qstring.h>
 
+#include <qstring.h>
 
 namespace KCal {
 
 /**
- * This class represents information related to an attachment.
- */
+  This class represents information related to an attachment.
+*/
 class Attachment
 {
-public:
+  public:
+
     /**
-     * Create a Reference to some URI.
-     * @param uri the uri this attachment refers to
-     * @param mime the mime type of the resource being linked to
-     */
-    Attachment(const QString& uri, const QString& mime = QString::null);
+      Create a Reference to some URI by copying an existing Attachment.
+      
+      @param attachment the attachment to be duplicated
+    */
+    Attachment( const Attachment &attachment );
 
     /**
-     * Create a binary attachment.
-     * @param base64 the attachment in base64 format
-     * @param mime the mime type of the attachment
-     */
-    Attachment(const char *base64, const QString& mime = QString::null);
-
-    /* The VALUE parameter in Cal */
-    bool isURI() const;
+      Create a Reference to some URI.
+      
+      @param uri the uri this attachment refers to
+      @param mime the mime type of the resource being linked to
+    */
+    Attachment( const QString &uri, const QString &mime = QString::null );
+
+    /**
+      Create a binary attachment.
+     
+      @param base64 the attachment in base64 format
+      @param mime the mime type of the attachment
+    */
+    Attachment( const char *base64, const QString &mime = QString::null );
+
+    /* The VALUE parameter in iCal */
+    bool isUri() const;
     QString uri() const;
-    void setURI(const QString& uri);
+    void setUri( const QString &uri );
     
     bool isBinary() const;
     char *data() const;
-    void setData(const char *base64);
+    void setData( const char *base64 );
 
     /* The optional FMTTYPE parameter in iCal */
     QString mimeType() const;
-    void setMimeType(const QString& mime);
-private:
+    void setMimeType( const QString &mime );
+                
+                /* The custom X-CONTENT-DISPOSITION parameter, used by OGo etc. */
+                bool showInline() const;
+                void setShowInline( bool showinline );
+                
+                /* The custom X-LABEL parameter to show a human-readable title */
+                QString label() const;
+                void setLabel( const QString &label );
+
+  private:
     QString mMimeType;
     QString mData;
     bool mBinary;
+                bool mShowInline;
+                QString mLabel;
+
+    class Private;
+    Private *d;
 };
 
 }
 
 #endif
diff --git a/libkcal/icalformatimpl.cpp b/libkcal/icalformatimpl.cpp
index 53aa039..65eabc8 100644
--- a/libkcal/icalformatimpl.cpp
+++ b/libkcal/icalformatimpl.cpp
@@ -1,1547 +1,1547 @@
 /*
     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 <qdatetime.h>
 #include <qstring.h>
 #include <qptrlist.h>
 #include <qfile.h>
 
 #include <kdebug.h>
 #include <klocale.h>
 #include <kglobal.h>
 
 extern "C" {
   #include <ical.h>
   #include <icalss.h>
   #include <icalparser.h>
   #include <icalrestriction.h>
 }
 
 #include "calendar.h"
 #include "journal.h"
 #include "icalformat.h"
 #include "icalformatimpl.h"
 #include "compat.h"
 
 #define _ICAL_VERSION "2.0"
 
 using namespace KCal;
 
 const int gSecondsPerMinute = 60;
 const int gSecondsPerHour   = gSecondsPerMinute * 60;
 const int gSecondsPerDay    = gSecondsPerHour   * 24;
 const int gSecondsPerWeek   = gSecondsPerDay    * 7;
 
 ICalFormatImpl::ICalFormatImpl( ICalFormat *parent ) :
   mParent( parent ), mCalendarVersion( 0 )
 {
   mCompat = new Compat;
 }
 
 ICalFormatImpl::~ICalFormatImpl()
 {
   delete mCompat;
 }
 
 class ToStringVisitor : public Incidence::Visitor
 {
   public:
     ToStringVisitor( ICalFormatImpl *impl ) : mImpl( impl ), mComponent( 0 ) {}
 
     bool visit( Event *e ) { mComponent = mImpl->writeEvent( e ); return true; }
     bool visit( Todo *e ) { mComponent = mImpl->writeTodo( e ); return true; }
     bool visit( Journal *e ) { mComponent = mImpl->writeJournal( e ); return true; }
 
     icalcomponent *component() { return mComponent; }
 
   private:
     ICalFormatImpl *mImpl;
     icalcomponent *mComponent;
 };
 
 icalcomponent *ICalFormatImpl::writeIncidence(Incidence *incidence)
 {
   ToStringVisitor v( this );
   incidence->accept(v);
   return v.component();
 }
 
 icalcomponent *ICalFormatImpl::writeTodo(Todo *todo)
 {
   QString tmpStr;
   QStringList tmpStrList;
 
   icalcomponent *vtodo = icalcomponent_new(ICAL_VTODO_COMPONENT);
 
   writeIncidence(vtodo,todo);
 
   // due date
   if (todo->hasDueDate()) {
     icaltimetype due;
     if (todo->doesFloat()) {
       due = writeICalDate(todo->dtDue().date());
     } else {
       due = writeICalDateTime(todo->dtDue());
     }
     icalcomponent_add_property(vtodo,icalproperty_new_due(due));
   }
 
   // start time
   if (todo->hasStartDate()) {
     icaltimetype start;
     if (todo->doesFloat()) {
 //      kdDebug(5800) << "§§ Incidence " << todo->summary() << " floats." << endl;
       start = writeICalDate(todo->dtStart().date());
     } else {
 //      kdDebug(5800) << "§§ incidence " << todo->summary() << " has time." << endl;
       start = writeICalDateTime(todo->dtStart());
     }
     icalcomponent_add_property(vtodo,icalproperty_new_dtstart(start));
   }
 
   // completion date
   if (todo->isCompleted()) {
     if (!todo->hasCompletedDate()) {
       // If todo was created by KOrganizer <2.2 it has no correct completion
       // date. Set it to now.
       todo->setCompleted(QDateTime::currentDateTime());
     }
     icaltimetype completed = writeICalDateTime(todo->completed());
     icalcomponent_add_property(vtodo,icalproperty_new_completed(completed));
   }
 
   icalcomponent_add_property(vtodo,
       icalproperty_new_percentcomplete(todo->percentComplete()));
 
   return vtodo;
 }
 
 icalcomponent *ICalFormatImpl::writeEvent(Event *event)
 {
   kdDebug(5800) << "Write Event '" << event->summary() << "' (" << event->uid()
               << ")" << endl;
 
   QString tmpStr;
   QStringList tmpStrList;
 
   icalcomponent *vevent = icalcomponent_new(ICAL_VEVENT_COMPONENT);
 
   writeIncidence(vevent,event);
 
   // start time
   icaltimetype start;
   if (event->doesFloat()) {
 //    kdDebug(5800) << "§§ Incidence " << event->summary() << " floats." << endl;
     start = writeICalDate(event->dtStart().date());
   } else {
 //    kdDebug(5800) << "§§ incidence " << event->summary() << " has time." << endl;
     start = writeICalDateTime(event->dtStart());
   }
   icalcomponent_add_property(vevent,icalproperty_new_dtstart(start));
 
   if (event->hasEndDate()) {
     // end time
     icaltimetype end;
     if (event->doesFloat()) {
 //      kdDebug(5800) << "§§ Event " << event->summary() << " floats." << endl;
       // +1 day because end date is non-inclusive.
       end = writeICalDate( event->dtEnd().date().addDays( 1 ) );
     } else {
 //      kdDebug(5800) << "§§ Event " << event->summary() << " has time." << endl;
       end = writeICalDateTime(event->dtEnd());
     }
     icalcomponent_add_property(vevent,icalproperty_new_dtend(end));
   }
 
 // TODO: attachments, resources
 #if 0
   // attachments
   tmpStrList = anEvent->attachments();
   for ( QStringList::Iterator it = tmpStrList.begin();
         it != tmpStrList.end();
         ++it )
     addPropValue(vevent, VCAttachProp, (*it).utf8());
 
   // resources
   tmpStrList = anEvent->resources();
   tmpStr = tmpStrList.join(";");
   if (!tmpStr.isEmpty())
     addPropValue(vevent, VCResourcesProp, tmpStr.utf8());
 
 #endif
 
   // Transparency
   switch( event->transparency() ) {
   case Event::Transparent:
       icalcomponent_add_property(vevent, icalproperty_new_transp(ICAL_TRANSP_TRANSPARENT));
     break;
   case Event::Opaque:
     icalcomponent_add_property(vevent, icalproperty_new_transp(ICAL_TRANSP_OPAQUE));
     break;
   }
 
   return vevent;
 }
 
 icalcomponent *ICalFormatImpl::writeFreeBusy(FreeBusy *freebusy,
                                              Scheduler::Method method)
 {
 
 
   icalcomponent *vfreebusy = icalcomponent_new(ICAL_VFREEBUSY_COMPONENT);
 
   writeIncidenceBase(vfreebusy,freebusy);
 
   icalcomponent_add_property(vfreebusy, icalproperty_new_dtstart(
       writeICalDateTime(freebusy->dtStart())));
 
   icalcomponent_add_property(vfreebusy, icalproperty_new_dtend(
       writeICalDateTime(freebusy->dtEnd())));
 
   if (method == Scheduler::Request) {
     icalcomponent_add_property(vfreebusy,icalproperty_new_uid(
        freebusy->uid().utf8()));
   }
 
   //Loops through all the periods in the freebusy object
   QValueList<Period> list = freebusy->busyPeriods();
   QValueList<Period>::Iterator it;
   icalperiodtype period;
   for (it = list.begin(); it!= list.end(); ++it) {
     period.start = writeICalDateTime((*it).start());
     period.end = writeICalDateTime((*it).end());
     icalcomponent_add_property(vfreebusy, icalproperty_new_freebusy(period) );
   }
 
   return vfreebusy;
 }
 
 icalcomponent *ICalFormatImpl::writeJournal(Journal *journal)
 {
   icalcomponent *vjournal = icalcomponent_new(ICAL_VJOURNAL_COMPONENT);
 
   writeIncidence(vjournal,journal);
   
   // start time
   if (journal->dtStart().isValid()) {
     icaltimetype start;
     if (journal->doesFloat()) {
 //      kdDebug(5800) << "§§ Incidence " << event->summary() << " floats." << endl;
       start = writeICalDate(journal->dtStart().date());
     } else {
 //      kdDebug(5800) << "§§ incidence " << event->summary() << " has time." << endl;
       start = writeICalDateTime(journal->dtStart());
     }
     icalcomponent_add_property(vjournal,icalproperty_new_dtstart(start));
   }
 
   return vjournal;
 }
 
 void ICalFormatImpl::writeIncidence(icalcomponent *parent,Incidence *incidence)
 {
   // pilot sync stuff
 // TODO: move this application-specific code to kpilot
   if (incidence->pilotId()) {
     incidence->setNonKDECustomProperty("X-PILOTID", QString::number(incidence->pilotId()));
     incidence->setNonKDECustomProperty("X-PILOTSTAT", QString::number(incidence->syncStatus()));
   }
   if ( !incidence->IDStr().isEmpty()) {
       incidence->setNonKDECustomProperty("X-KOPIEXTID",incidence->IDStr() );
   }
 
 
   writeIncidenceBase(parent,incidence);
   if (incidence->cancelled()) {
       icalcomponent_add_property(parent,icalproperty_new_status(ICAL_STATUS_CANCELLED));
   }
 
   // creation date
   icalcomponent_add_property(parent,icalproperty_new_created(
       writeICalDateTime(incidence->created())));
 
   // unique id
   icalcomponent_add_property(parent,icalproperty_new_uid(
       incidence->uid().utf8()));
 
   // revision
   icalcomponent_add_property(parent,icalproperty_new_sequence(
       incidence->revision()));
 
   // last modification date
   icalcomponent_add_property(parent,icalproperty_new_lastmodified(
       writeICalDateTime(incidence->lastModified())));
 
   // description
   if (!incidence->description().isEmpty()) {
     icalcomponent_add_property(parent,icalproperty_new_description(
         incidence->description().utf8()));
   }
 
   // summary
   if (!incidence->summary().isEmpty()) {
     icalcomponent_add_property(parent,icalproperty_new_summary(
         incidence->summary().utf8()));
   }
 
   // location
   if (!incidence->location().isEmpty()) {
     icalcomponent_add_property(parent,icalproperty_new_location(
         incidence->location().utf8()));
   }
 
 // TODO:
   // 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
   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)
 {
   icalproperty *p = icalproperty_new_attendee("mailto:" + attendee->email().utf8());
 
   if (!attendee->name().isEmpty()) {
     icalproperty_add_parameter(p,icalparameter_new_cn(attendee->name().utf8()));
   }
 
 
   icalproperty_add_parameter(p,icalparameter_new_rsvp(
           attendee->RSVP() ? ICAL_RSVP_TRUE : ICAL_RSVP_FALSE ));
 
   icalparameter_partstat status = ICAL_PARTSTAT_NEEDSACTION;
   switch (attendee->status()) {
     default:
     case Attendee::NeedsAction:
       status = ICAL_PARTSTAT_NEEDSACTION;
       break;
     case Attendee::Accepted:
       status = ICAL_PARTSTAT_ACCEPTED;
       break;
     case Attendee::Declined:
       status = ICAL_PARTSTAT_DECLINED;
       break;
     case Attendee::Tentative:
       status = ICAL_PARTSTAT_TENTATIVE;
       break;
     case Attendee::Delegated:
       status = ICAL_PARTSTAT_DELEGATED;
       break;
     case Attendee::Completed:
       status = ICAL_PARTSTAT_COMPLETED;
       break;
     case Attendee::InProcess:
       status = ICAL_PARTSTAT_INPROCESS;
       break;
   }
   icalproperty_add_parameter(p,icalparameter_new_partstat(status));
 
   icalparameter_role role = ICAL_ROLE_REQPARTICIPANT;
   switch (attendee->role()) {
     case Attendee::Chair:
       role = ICAL_ROLE_CHAIR;
       break;
     default:
     case Attendee::ReqParticipant:
       role = ICAL_ROLE_REQPARTICIPANT;
       break;
     case Attendee::OptParticipant:
       role = ICAL_ROLE_OPTPARTICIPANT;
       break;
     case Attendee::NonParticipant:
       role = ICAL_ROLE_NONPARTICIPANT;
       break;
   }
   icalproperty_add_parameter(p,icalparameter_new_role(role));
 
   if (!attendee->uid().isEmpty()) {
     icalparameter* icalparameter_uid = icalparameter_new_x(attendee->uid().utf8());
     icalparameter_set_xname(icalparameter_uid,"X-UID");
     icalproperty_add_parameter(p,icalparameter_uid);
   }
 
   return p;
 }
 
 icalproperty *ICalFormatImpl::writeAttachment(Attachment *att)
 {
 #if 0
    icalattachtype* attach = icalattachtype_new();
-  if (att->isURI())
+  if (att->isUri())
     icalattachtype_set_url(attach, att->uri().utf8().data());
   else
     icalattachtype_set_base64(attach, att->data(), 0);
 #endif
   icalattach *attach;
-  if (att->isURI())
+  if (att->isUri())
       attach = icalattach_new_from_url( att->uri().utf8().data());
   else
       attach = icalattach_new_from_data ( (unsigned char *)att->data(), 0, 0);
   icalproperty *p = icalproperty_new_attach(attach);
   if (!att->mimeType().isEmpty())
     icalproperty_add_parameter(p,icalparameter_new_fmttype(att->mimeType().utf8().data()));
 
   if (att->isBinary()) {
     icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY));
     icalproperty_add_parameter(p,icalparameter_new_encoding(ICAL_ENCODING_BASE64));
   }
   return p;
 }
 
 icalproperty *ICalFormatImpl::writeRecurrenceRule(Recurrence *recur)
 {
 //  kdDebug(5800) << "ICalFormatImpl::writeRecurrenceRule()" << endl;
 
   icalrecurrencetype r;
 
   icalrecurrencetype_clear(&r);
 
   int index = 0;
   int index2 = 0;
 
   QPtrList<Recurrence::rMonthPos> tmpPositions;
   QPtrList<int> tmpDays;
   int *tmpDay;
   Recurrence::rMonthPos *tmpPos;
   bool datetime = false;
   int day;
   int i;
 
   switch(recur->doesRecur()) {
     case Recurrence::rMinutely:
       r.freq = ICAL_MINUTELY_RECURRENCE;
       datetime = true;
       break;
     case Recurrence::rHourly:
       r.freq = ICAL_HOURLY_RECURRENCE;
       datetime = true;
       break;
     case Recurrence::rDaily:
       r.freq = ICAL_DAILY_RECURRENCE;
       break;
     case Recurrence::rWeekly:
       r.freq = ICAL_WEEKLY_RECURRENCE;
       r.week_start = static_cast<icalrecurrencetype_weekday>(recur->weekStart()%7 + 1);
       for (i = 0; i < 7; i++) {
         if (recur->days().testBit(i)) {
           day = (i + 1)%7 + 1;     // convert from Monday=0 to Sunday=1
           r.by_day[index++] = icalrecurrencetype_day_day_of_week(day);
         }
       }
 //      r.by_day[index] = ICAL_RECURRENCE_ARRAY_MAX;
       break;
     case Recurrence::rMonthlyPos:
       r.freq = ICAL_MONTHLY_RECURRENCE;
 
       tmpPositions = recur->monthPositions();
       for (tmpPos = tmpPositions.first();
            tmpPos;
            tmpPos = tmpPositions.next()) {
         for (i = 0; i < 7; i++) {
           if (tmpPos->rDays.testBit(i)) {
             day = (i + 1)%7 + 1;     // convert from Monday=0 to Sunday=1
             day += tmpPos->rPos*8;
             if (tmpPos->negative) day = -day;
             r.by_day[index++] = day;
           }
         }
       }
 //      r.by_day[index] = ICAL_RECURRENCE_ARRAY_MAX;
       break;
     case Recurrence::rMonthlyDay:
       r.freq = ICAL_MONTHLY_RECURRENCE;
 
       tmpDays = recur->monthDays();
       for (tmpDay = tmpDays.first();
            tmpDay;
            tmpDay = tmpDays.next()) {
         r.by_month_day[index++] = icalrecurrencetype_day_position(*tmpDay*8);//*tmpDay);
       }
 //      r.by_day[index] = ICAL_RECURRENCE_ARRAY_MAX;
       break;
     case Recurrence::rYearlyMonth:
     case Recurrence::rYearlyPos:
       r.freq = ICAL_YEARLY_RECURRENCE;
 
       tmpDays = recur->yearNums();
       for (tmpDay = tmpDays.first();
            tmpDay;
            tmpDay = tmpDays.next()) {
         r.by_month[index++] = *tmpDay;
       }
 //      r.by_set_pos[index] = ICAL_RECURRENCE_ARRAY_MAX;
       if (recur->doesRecur() == Recurrence::rYearlyPos) {
         tmpPositions = recur->monthPositions();
         for (tmpPos = tmpPositions.first();
              tmpPos;
              tmpPos = tmpPositions.next()) {
           for (i = 0; i < 7; i++) {
             if (tmpPos->rDays.testBit(i)) {
               day = (i + 1)%7 + 1;     // convert from Monday=0 to Sunday=1
               day += tmpPos->rPos*8;
               if (tmpPos->negative) day = -day;
               r.by_day[index2++] = day;
             }
           }
         }
 //        r.by_day[index2] = ICAL_RECURRENCE_ARRAY_MAX;
       }
       break;
     case Recurrence::rYearlyDay:
       r.freq = ICAL_YEARLY_RECURRENCE;
 
       tmpDays = recur->yearNums();
       for (tmpDay = tmpDays.first();
            tmpDay;
            tmpDay = tmpDays.next()) {
         r.by_year_day[index++] = *tmpDay;
       }
 //      r.by_year_day[index] = ICAL_RECURRENCE_ARRAY_MAX;
       break;
     default:
       r.freq = ICAL_NO_RECURRENCE;
       kdDebug(5800) << "ICalFormatImpl::writeRecurrence(): no recurrence" << endl;
       break;
   }
 
   r.interval = recur->frequency();
 
   if (recur->duration() > 0) {
     r.count = recur->duration();
   } else if (recur->duration() == -1) {
     r.count = 0;
   } else {
     if (datetime)
       r.until = writeICalDateTime(recur->endDateTime());
     else
       r.until = writeICalDate(recur->endDate());
   }
 
 // Debug output
 #if 0
   const char *str = icalrecurrencetype_as_string(&r);
   if (str) {
     kdDebug(5800) << " String: " << str << endl;
   } else {
     kdDebug(5800) << " No String" << endl;
   }
 #endif
 
   return icalproperty_new_rrule(r);
 }
 
 icalcomponent *ICalFormatImpl::writeAlarm(Alarm *alarm)
 {
   icalcomponent *a = icalcomponent_new(ICAL_VALARM_COMPONENT);
 
   icalproperty_action action;
   icalattach *attach = 0;
 
   switch (alarm->type()) {
     case Alarm::Procedure:
       action = ICAL_ACTION_PROCEDURE;
       attach = icalattach_new_from_url( QFile::encodeName(alarm->programFile()).data() );
       icalcomponent_add_property(a,icalproperty_new_attach(attach));
       if (!alarm->programArguments().isEmpty()) {
         icalcomponent_add_property(a,icalproperty_new_description(alarm->programArguments().utf8()));
       }
       icalattach_unref( attach );
       break;
     case Alarm::Audio:
       action = ICAL_ACTION_AUDIO;
       if (!alarm->audioFile().isEmpty()) {
           attach = icalattach_new_from_url(QFile::encodeName( alarm->audioFile() ).data());
           icalcomponent_add_property(a,icalproperty_new_attach(attach));
           icalattach_unref( attach );
       }
       break;
     case Alarm::Email: {
       action = ICAL_ACTION_EMAIL;
       QValueList<Person> addresses = alarm->mailAddresses();
       for (QValueList<Person>::Iterator ad = addresses.begin();  ad != addresses.end();  ++ad) {
         icalproperty *p = icalproperty_new_attendee("MAILTO:" + (*ad).email().utf8());
         if (!(*ad).name().isEmpty()) {
           icalproperty_add_parameter(p,icalparameter_new_cn((*ad).name().utf8()));
         }
         icalcomponent_add_property(a,p);
       }
       icalcomponent_add_property(a,icalproperty_new_summary(alarm->mailSubject().utf8()));
       icalcomponent_add_property(a,icalproperty_new_description(alarm->text().utf8()));
       QStringList attachments = alarm->mailAttachments();
       if (attachments.count() > 0) {
         for (QStringList::Iterator at = attachments.begin();  at != attachments.end();  ++at) {
             attach = icalattach_new_from_url(QFile::encodeName( *at ).data());
             icalcomponent_add_property(a,icalproperty_new_attach(attach));
             icalattach_unref( attach );
         }
       }
       break;
     }
     case Alarm::Display:
       action = ICAL_ACTION_DISPLAY;
       icalcomponent_add_property(a,icalproperty_new_description(alarm->text().utf8()));
       break;
     case Alarm::Invalid:
     default:
       kdDebug(5800) << "Unknown type of alarm" << endl;
       action = ICAL_ACTION_NONE;
       break;
   }
   icalcomponent_add_property(a,icalproperty_new_action(action));
 
   // Trigger time
   icaltriggertype trigger;
   if ( alarm->hasTime() ) {
     trigger.time = writeICalDateTime(alarm->time());
     trigger.duration = icaldurationtype_null_duration();
   } else {
     trigger.time = icaltime_null_time();
     Duration offset;
     if ( alarm->hasStartOffset() )
       offset = alarm->startOffset();
     else
       offset = alarm->endOffset();
     trigger.duration = icaldurationtype_from_int( offset.asSeconds() );
   }
   icalproperty *p = icalproperty_new_trigger(trigger);
   if ( alarm->hasEndOffset() )
     icalproperty_add_parameter(p,icalparameter_new_related(ICAL_RELATED_END));
   icalcomponent_add_property(a,p);
 
   // Repeat count and duration
   if (alarm->repeatCount()) {
     icalcomponent_add_property(a,icalproperty_new_repeat(alarm->repeatCount()));
     icalcomponent_add_property(a,icalproperty_new_duration(
                              icaldurationtype_from_int(alarm->snoozeTime()*60)));
   }
 
   // Custom properties
   QMap<QCString, QString> custom = alarm->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(a,p);
   }
 
   return a;
 }
 
 Todo *ICalFormatImpl::readTodo(icalcomponent *vtodo)
 {
   Todo *todo = new Todo;
 
   readIncidence(vtodo,todo);
 
   icalproperty *p = icalcomponent_get_first_property(vtodo,ICAL_ANY_PROPERTY);
 
 //  int intvalue;
   icaltimetype icaltime;
 
   QStringList categories;
 
   while (p) {
     icalproperty_kind kind = icalproperty_isa(p);
     switch (kind) {
 
       case ICAL_DUE_PROPERTY:  // due date
         icaltime = icalproperty_get_due(p);
         if (icaltime.is_date) {
           todo->setDtDue(QDateTime(readICalDate(icaltime),QTime(0,0,0)));
           todo->setFloats(true);
 
         } else {
           todo->setDtDue(readICalDateTime(icaltime));
           todo->setFloats(false);
         }
         todo->setHasDueDate(true);
         break;
 
       case ICAL_COMPLETED_PROPERTY:  // completion date
         icaltime = icalproperty_get_completed(p);
         todo->setCompleted(readICalDateTime(icaltime));
         break;
 
       case ICAL_PERCENTCOMPLETE_PROPERTY:  // Percent completed
         todo->setPercentComplete(icalproperty_get_percentcomplete(p));
         break;
 
       case ICAL_RELATEDTO_PROPERTY:  // related todo (parent)
         todo->setRelatedToUid(QString::fromUtf8(icalproperty_get_relatedto(p)));
         mTodosRelate.append(todo);
         break;
 
       case ICAL_DTSTART_PROPERTY:
         // Flag that todo has start date. Value is read in by readIncidence().
         todo->setHasStartDate(true);
         break;
 
       default:
 //        kdDebug(5800) << "ICALFormat::readTodo(): Unknown property: " << kind
 //                  << endl;
         break;
     }
 
     p = icalcomponent_get_next_property(vtodo,ICAL_ANY_PROPERTY);
   }
 
   return todo;
 }
 
 Event *ICalFormatImpl::readEvent(icalcomponent *vevent)
 {
   Event *event = new Event;
   event->setFloats(false);
 
   readIncidence(vevent,event);
 
   icalproperty *p = icalcomponent_get_first_property(vevent,ICAL_ANY_PROPERTY);
 
 //  int intvalue;
   icaltimetype icaltime;
 
   QStringList categories;
   QString transparency;
 
   while (p) {
     icalproperty_kind kind = icalproperty_isa(p);
     switch (kind) {
 
       case ICAL_DTEND_PROPERTY:  // start date and time
         icaltime = icalproperty_get_dtend(p);
         if (icaltime.is_date) {
           event->setFloats( true );
           // End date is non-inclusive
           QDate endDate = readICalDate( icaltime ).addDays( -1 );
           mCompat->fixFloatingEnd( endDate );
           if ( endDate < event->dtStart().date() ) {
             endDate = event->dtStart().date();
           }
           event->setDtEnd( QDateTime( endDate, QTime( 0, 0, 0 ) ) );
         } else {
           event->setDtEnd(readICalDateTime(icaltime));
         }
         break;
 
 // TODO:
   // at this point, there should be at least a start or end time.
   // fix up for events that take up no time but have a time associated
 #if 0
   if (!(vo = isAPropertyOf(vevent, VCDTstartProp)))
     anEvent->setDtStart(anEvent->dtEnd());
   if (!(vo = isAPropertyOf(vevent, VCDTendProp)))
     anEvent->setDtEnd(anEvent->dtStart());
 #endif
 
 // TODO: exdates
 #if 0
   // recurrence exceptions
   if ((vo = isAPropertyOf(vevent, VCExDateProp)) != 0) {
     anEvent->setExDates(s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
   }
 #endif
 
 #if 0
   // secrecy
   if ((vo = isAPropertyOf(vevent, VCClassProp)) != 0) {
     anEvent->setSecrecy(s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
   }
   else
     anEvent->setSecrecy("PUBLIC");
 
   // attachments
   tmpStrList.clear();
   initPropIterator(&voi, vevent);
   while (moreIteration(&voi)) {
     vo = nextVObject(&voi);
     if (strcmp(vObjectName(vo), VCAttachProp) == 0) {
       tmpStrList.append(s = fakeCString(vObjectUStringZValue(vo)));
       deleteStr(s);
     }
   }
   anEvent->setAttachments(tmpStrList);
 
   // resources
   if ((vo = isAPropertyOf(vevent, VCResourcesProp)) != 0) {
     QString resources = (s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
     tmpStrList.clear();
     index1 = 0;
     index2 = 0;
     QString resource;
     while ((index2 = resources.find(';', index1)) != -1) {
       resource = resources.mid(index1, (index2 - index1));
       tmpStrList.append(resource);
       index1 = index2;
     }
     anEvent->setResources(tmpStrList);
   }
 #endif
 
       case ICAL_RELATEDTO_PROPERTY:  // releated event (parent)
         event->setRelatedToUid(QString::fromUtf8(icalproperty_get_relatedto(p)));
         mEventsRelate.append(event);
         break;
 
       case ICAL_TRANSP_PROPERTY:  // Transparency
         if(icalproperty_get_transp(p) == ICAL_TRANSP_TRANSPARENT )
           event->setTransparency( Event::Transparent );
         else
           event->setTransparency( Event::Opaque );
         break;
 
       default:
 //        kdDebug(5800) << "ICALFormat::readEvent(): Unknown property: " << kind
 //                  << endl;
         break;
     }
 
     p = icalcomponent_get_next_property(vevent,ICAL_ANY_PROPERTY);
   }
 
   QString msade = event->nonKDECustomProperty("X-MICROSOFT-CDO-ALLDAYEVENT");
   if (!msade.isNull()) {
     bool floats = (msade == QString::fromLatin1("TRUE"));
     kdDebug(5800) << "ICALFormat::readEvent(): all day event: " << floats << endl;
     event->setFloats(floats);
     if (floats) {
       QDateTime endDate = event->dtEnd();
       event->setDtEnd(endDate.addDays(-1));
     }
   }
 
   // some stupid vCal exporters ignore the standard and use Description
   // instead of Summary for the default field.  Correct for this.
   if (event->summary().isEmpty() &&
       !(event->description().isEmpty())) {
     QString tmpStr = event->description().simplifyWhiteSpace();
     event->setDescription("");
     event->setSummary(tmpStr);
   }
 
   return event;
 }
 
 FreeBusy *ICalFormatImpl::readFreeBusy(icalcomponent *vfreebusy)
 {
   FreeBusy *freebusy = new FreeBusy;
 
   readIncidenceBase(vfreebusy,freebusy);
 
   icalproperty *p = icalcomponent_get_first_property(vfreebusy,ICAL_ANY_PROPERTY);
 
   icaltimetype icaltime;
   icalperiodtype icalperiod;
   QDateTime period_start, period_end;
 
   while (p) {
     icalproperty_kind kind = icalproperty_isa(p);
     switch (kind) {
 
       case ICAL_DTSTART_PROPERTY:  // start date and time
         icaltime = icalproperty_get_dtstart(p);
         freebusy->setDtStart(readICalDateTime(icaltime));
         break;
 
       case ICAL_DTEND_PROPERTY:  // start End Date and Time
         icaltime = icalproperty_get_dtend(p);
         freebusy->setDtEnd(readICalDateTime(icaltime));
         break;
 
       case ICAL_FREEBUSY_PROPERTY:  //Any FreeBusy Times
         icalperiod = icalproperty_get_freebusy(p);
         period_start = readICalDateTime(icalperiod.start);
         period_end = readICalDateTime(icalperiod.end);
         freebusy->addPeriod(period_start, period_end);
         break;
         
       default:
         kdDebug(5800) << "ICALFormat::readIncidence(): Unknown property: " << kind
                   << endl;
       break;
     }
     p = icalcomponent_get_next_property(vfreebusy,ICAL_ANY_PROPERTY);
   }
 
   return freebusy;
 }
 
 Journal *ICalFormatImpl::readJournal(icalcomponent *vjournal)
 {
   Journal *journal = new Journal;
 
   readIncidence(vjournal,journal);
 
   if ( !journal->dtStart().isValid() && journal->created().isValid() ) {
       journal->setDtStart( journal->created() );
   }
   return journal;
 }
 
 Attendee *ICalFormatImpl::readAttendee(icalproperty *attendee)
 {
   icalparameter *p = 0;
 
   QString email = QString::fromUtf8(icalproperty_get_attendee(attendee));
 
   QString name;
   QString uid = QString::null;
   p = icalproperty_get_first_parameter(attendee,ICAL_CN_PARAMETER);
   if (p) {
     name = QString::fromUtf8(icalparameter_get_cn(p));
   } else {
   }
 
   bool rsvp=false;
   p = icalproperty_get_first_parameter(attendee,ICAL_RSVP_PARAMETER);
   if (p) {
     icalparameter_rsvp rsvpParameter = icalparameter_get_rsvp(p);
     if (rsvpParameter == ICAL_RSVP_TRUE) rsvp = true;
   }
 
   Attendee::PartStat status = Attendee::NeedsAction;
   p = icalproperty_get_first_parameter(attendee,ICAL_PARTSTAT_PARAMETER);
   if (p) {
     icalparameter_partstat partStatParameter = icalparameter_get_partstat(p);
     switch(partStatParameter) {
       default:
       case ICAL_PARTSTAT_NEEDSACTION:
         status = Attendee::NeedsAction;
         break;
       case ICAL_PARTSTAT_ACCEPTED:
         status = Attendee::Accepted;
         break;
       case ICAL_PARTSTAT_DECLINED:
         status = Attendee::Declined;
         break;
       case ICAL_PARTSTAT_TENTATIVE:
         status = Attendee::Tentative;
         break;
       case ICAL_PARTSTAT_DELEGATED:
         status = Attendee::Delegated;
         break;
       case ICAL_PARTSTAT_COMPLETED:
         status = Attendee::Completed;
         break;
       case ICAL_PARTSTAT_INPROCESS:
         status = Attendee::InProcess;
         break;
     }
   }
 
   Attendee::Role role = Attendee::ReqParticipant;
   p = icalproperty_get_first_parameter(attendee,ICAL_ROLE_PARAMETER);
   if (p) {
     icalparameter_role roleParameter = icalparameter_get_role(p);
     switch(roleParameter) {
       case ICAL_ROLE_CHAIR:
         role = Attendee::Chair;
         break;
       default:
       case ICAL_ROLE_REQPARTICIPANT:
         role = Attendee::ReqParticipant;
         break;
       case ICAL_ROLE_OPTPARTICIPANT:
         role = Attendee::OptParticipant;
         break;
       case ICAL_ROLE_NONPARTICIPANT:
         role = Attendee::NonParticipant;
         break;
     }
   }
 
   p = icalproperty_get_first_parameter(attendee,ICAL_X_PARAMETER);
   uid = icalparameter_get_xvalue(p);
   // This should be added, but there seems to be a libical bug here.
   /*while (p) {
    // if (icalparameter_get_xname(p) == "X-UID") {
     uid = icalparameter_get_xvalue(p);
     p = icalproperty_get_next_parameter(attendee,ICAL_X_PARAMETER);
   } */
 
   return new Attendee( name, email, rsvp, status, role, uid );
 }
 
 Attachment *ICalFormatImpl::readAttachment(icalproperty *attach)
 {
   icalattach *a = icalproperty_get_attach(attach);
   icalparameter_value v = ICAL_VALUE_NONE;
   icalparameter_encoding e = ICAL_ENCODING_NONE;
  
   Attachment *attachment = 0;
   /*
   icalparameter *vp = icalproperty_get_first_parameter(attach, ICAL_VALUE_PARAMETER);
   if (vp)
     v = icalparameter_get_value(vp);
 
   icalparameter *ep = icalproperty_get_first_parameter(attach, ICAL_ENCODING_PARAMETER);
   if (ep)
     e = icalparameter_get_encoding(ep);
   */
   int isurl = icalattach_get_is_url (a);
   if (isurl == 0)
       attachment = new Attachment((const char*)icalattach_get_data(a));
   else {
     attachment = new Attachment(QString(icalattach_get_url(a)));
   }
 
   icalparameter *p = icalproperty_get_first_parameter(attach, ICAL_FMTTYPE_PARAMETER);
   if (p)
     attachment->setMimeType(QString(icalparameter_get_fmttype(p)));
 
   return attachment;
 }
 #include <qtextcodec.h> 
 void ICalFormatImpl::readIncidence(icalcomponent *parent,Incidence *incidence)
 {
   readIncidenceBase(parent,incidence);
 
   icalproperty *p = icalcomponent_get_first_property(parent,ICAL_ANY_PROPERTY);
   bool readrec = false;
   const char *text;
   int intvalue;
   icaltimetype icaltime;
   icaldurationtype icalduration;
   struct icalrecurrencetype rectype;
   QStringList categories;
 
   while (p) {
     icalproperty_kind kind = icalproperty_isa(p);
     switch (kind) {
 
       case ICAL_CREATED_PROPERTY:
         icaltime = icalproperty_get_created(p);
         incidence->setCreated(readICalDateTime(icaltime));
         break;
 
       case ICAL_SEQUENCE_PROPERTY:  // sequence
         intvalue = icalproperty_get_sequence(p);
         incidence->setRevision(intvalue);
         break;
 
       case ICAL_LASTMODIFIED_PROPERTY:  // last modification date
         icaltime = icalproperty_get_lastmodified(p);
         incidence->setLastModified(readICalDateTime(icaltime));
         break;
 
       case ICAL_DTSTART_PROPERTY:  // start date and time
         icaltime = icalproperty_get_dtstart(p);
         if (icaltime.is_date) {
           incidence->setDtStart(QDateTime(readICalDate(icaltime),QTime(0,0,0)));
           incidence->setFloats(true);
         } else {
           incidence->setDtStart(readICalDateTime(icaltime));
         }
         break;
 
       case ICAL_DURATION_PROPERTY:  // start date and time
         icalduration = icalproperty_get_duration(p);
         incidence->setDuration(readICalDuration(icalduration));
         break;
 
       case ICAL_DESCRIPTION_PROPERTY:  // description
         text = icalproperty_get_description(p);
         incidence->setDescription(QString::fromUtf8(text));
         break;
 
       case ICAL_SUMMARY_PROPERTY:  // summary
           {
               text = icalproperty_get_summary(p);
               incidence->setSummary(QString::fromUtf8(text));
           }
         break;
        case ICAL_STATUS_PROPERTY:  // summary
         {
             if ( ICAL_STATUS_CANCELLED == icalproperty_get_status(p) )
                 incidence->setCancelled( true );
         }
         break;
 
       case ICAL_LOCATION_PROPERTY:  // location
         text = icalproperty_get_location(p);
         incidence->setLocation(QString::fromUtf8(text));
         break;
 
       case ICAL_RECURRENCEID_PROPERTY:
         icaltime = icalproperty_get_recurrenceid(p);
         incidence->setRecurrenceID( readICalDateTime(icaltime) );
         //qDebug(" RecurrenceID %s",incidence->recurrenceID().toString().latin1() );
         break;
 #if 0
   // status
   if ((vo = isAPropertyOf(vincidence, VCStatusProp)) != 0) {
     incidence->setStatus(s = fakeCString(vObjectUStringZValue(vo)));
     deleteStr(s);
   }
   else
     incidence->setStatus("NEEDS ACTION");
 #endif
 
       case ICAL_PRIORITY_PROPERTY:  // priority
         intvalue = icalproperty_get_priority(p);
         incidence->setPriority(intvalue);
         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
   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;
 
   Recurrence *recur = incidence->recurrence();
   recur->setCompatVersion(mCalendarVersion);
   recur->unsetRecurs();
 
   struct icalrecurrencetype r = rrule;
 
   dumpIcalRecurrence(r);
   readRecurrence( r, recur, incidence);
 }
 
 void ICalFormatImpl::readRecurrence( const struct icalrecurrencetype &r, Recurrence* recur, Incidence *incidence)
 {
     int wkst;
     int index = 0;
     short day = 0;
     QBitArray qba(7);
     int frequ = r.freq;
     int interv = r.interval;
     // preprocessing for odd recurrence definitions
     
     if ( r.freq == ICAL_MONTHLY_RECURRENCE ) {
         if ( r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX) {
             interv = 12;
         }
     }
     if ( r.freq == ICAL_YEARLY_RECURRENCE ) {
         if ( r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX && r.by_day[0] != ICAL_RECURRENCE_ARRAY_MAX ) {
             frequ = ICAL_MONTHLY_RECURRENCE;
             interv = 12* r.interval;
         }
     }
   
     switch (frequ) {
     case ICAL_MINUTELY_RECURRENCE:
         if (!icaltime_is_null_time(r.until)) {
             recur->setMinutely(interv,readICalDateTime(r.until));
         } else {
             if (r.count == 0)
                 recur->setMinutely(interv,-1);
             else
                 recur->setMinutely(interv,r.count);
         }
         break;
     case ICAL_HOURLY_RECURRENCE:
         if (!icaltime_is_null_time(r.until)) {
             recur->setHourly(interv,readICalDateTime(r.until));
         } else {
             if (r.count == 0)
                 recur->setHourly(interv,-1);
             else
                 recur->setHourly(interv,r.count);
         }
         break;
     case ICAL_DAILY_RECURRENCE:
         if (!icaltime_is_null_time(r.until)) {
             recur->setDaily(interv,readICalDate(r.until));
         } else {
             if (r.count == 0)
                 recur->setDaily(interv,-1);
             else
                 recur->setDaily(interv,r.count);
         }
         break;
     case ICAL_WEEKLY_RECURRENCE:
         //      kdDebug(5800) << "WEEKLY_RECURRENCE" << endl;
         wkst = (r.week_start + 5)%7 + 1;
         if (!icaltime_is_null_time(r.until)) {
             recur->setWeekly(interv,qba,readICalDate(r.until),wkst);
         } else {
             if (r.count == 0)
                 recur->setWeekly(interv,qba,-1,wkst);
             else
                 recur->setWeekly(interv,qba,r.count,wkst);
         } 
         if ( r.by_day[0] == ICAL_RECURRENCE_ARRAY_MAX) {
             int wday = incidence->dtStart().date().dayOfWeek ()-1;
             //qDebug("weekly error found ");
             qba.setBit(wday);  
         } else {
             while((day = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 //        kdDebug(5800) << " " << day << endl;
                 qba.setBit((day+5)%7);    // convert from Sunday=1 to Monday=0
             }
         }
         break;
     case ICAL_MONTHLY_RECURRENCE:
        
         if (r.by_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
             if (!icaltime_is_null_time(r.until)) {
                 recur->setMonthly(Recurrence::rMonthlyPos,interv,
                                   readICalDate(r.until));
             } else {
                 if (r.count == 0)
                     recur->setMonthly(Recurrence::rMonthlyPos,interv,-1);
                 else
                     recur->setMonthly(Recurrence::rMonthlyPos,interv,r.count);
             }
             bool useSetPos = false;
             short pos = 0;
             while((day = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 //          kdDebug(5800) << "----a " << index << ": " << day << endl;
                 pos = icalrecurrencetype_day_position(day);
                 if (pos) {
                     day = icalrecurrencetype_day_day_of_week(day);
                     QBitArray ba(7);          // don't wipe qba
                     ba.setBit((day+5)%7);     // convert from Sunday=1 to Monday=0
                     recur->addMonthlyPos(pos,ba);
                 } else {
                     qba.setBit((day+5)%7);    // convert from Sunday=1 to Monday=0
                     useSetPos = true;
                 }
             }
             if (useSetPos) {
                 if (r.by_set_pos[0] != ICAL_RECURRENCE_ARRAY_MAX) {
                     recur->addMonthlyPos(r.by_set_pos[0],qba);
                 }
             }
         } else if (r.by_month_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
             if (!icaltime_is_null_time(r.until)) {
                 recur->setMonthly(Recurrence::rMonthlyDay,interv,
                                   readICalDate(r.until));
             } else {
                 if (r.count == 0)
                     recur->setMonthly(Recurrence::rMonthlyDay,interv,-1);
                 else
                     recur->setMonthly(Recurrence::rMonthlyDay,interv,r.count);
             }
             while((day = r.by_month_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 //          kdDebug(5800) << "----b " << day << endl;
                 recur->addMonthlyDay(day);
             }
         }
         break;
     case ICAL_YEARLY_RECURRENCE:
         if (r.by_year_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
             //qDebug(" YEARLY  DAY OF YEAR");
             if (!icaltime_is_null_time(r.until)) {
                 recur->setYearly(Recurrence::rYearlyDay,interv,
                                  readICalDate(r.until));
             } else {
                 if (r.count == 0)
                     recur->setYearly(Recurrence::rYearlyDay,interv,-1);
                 else
                     recur->setYearly(Recurrence::rYearlyDay,interv,r.count);
             }
             while((day = r.by_year_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                 recur->addYearlyNum(day);
             }
         } else if ( true /*r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX*/) {
             if (r.by_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
                 qDebug("YEARLY POS NOT SUPPORTED BY GUI");
                 if (!icaltime_is_null_time(r.until)) {
                     recur->setYearly(Recurrence::rYearlyPos,interv,
                                      readICalDate(r.until));
                 } else {
                     if (r.count == 0)
                         recur->setYearly(Recurrence::rYearlyPos,interv,-1);
                     else
                         recur->setYearly(Recurrence::rYearlyPos,interv,r.count);
                 }
                 bool useSetPos = false;
                 short pos = 0;
                 while((day = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                     //            kdDebug(5800) << "----a " << index << ": " << day << endl;
                     pos = icalrecurrencetype_day_position(day);
                     if (pos) {
                         day = icalrecurrencetype_day_day_of_week(day);
                         QBitArray ba(7);          // don't wipe qba
                         ba.setBit((day+5)%7);     // convert from Sunday=1 to Monday=0
                         recur->addYearlyMonthPos(pos,ba);
                     } else {
                         qba.setBit((day+5)%7);    // convert from Sunday=1 to Monday=0
                         useSetPos = true;
                     }
                 }
                 if (useSetPos) {
                     if (r.by_set_pos[0] != ICAL_RECURRENCE_ARRAY_MAX) {
                         recur->addYearlyMonthPos(r.by_set_pos[0],qba);
                     }
                 }
             } else { 
                 //qDebug("YEARLY MONTH ");
                 if (!icaltime_is_null_time(r.until)) {
                     recur->setYearly(Recurrence::rYearlyMonth,interv,
                                      readICalDate(r.until));
                 } else {
                     if (r.count == 0)
diff --git a/libkcal/incidence.cpp b/libkcal/incidence.cpp
index 549014e..39c14f5 100644
--- a/libkcal/incidence.cpp
+++ b/libkcal/incidence.cpp
@@ -1,845 +1,853 @@
 /*
     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 = 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;
+  mRelatedToUid = i.mRelatedToUid; 
 //  QPtrList<Incidence> mRelations;    QPtrList<Incidence> mRelations;
   mExDates = i.mExDates;
-  mAttachments = i.mAttachments;
+  QPtrListIterator<Attachment> itat( i.mAttachments );
+  Attachment *at;
+  while( (at = itat.current()) ) {
+      Attachment *a = new Attachment( *at );
+      mAttachments.append( a );
+      ++itat;
+  }
+  mAttachments.setAutoDelete( true );
   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;
   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);
   if ( mRecurrence ) 
       delete mRecurrence; 
  
 }
 QString Incidence::durationText()
 {
     return "---";
 }
 QString Incidence::durationText4Time( int offset )
 {
     int min = offset/60;
     int hours = min /60;
     min = min % 60;
     int days = hours /24;
     hours = hours % 24;
 
     if ( doesFloat() || ( min == 0 && hours == 0 )  ) {
         if ( days == 1 )
             return "1" + i18n(" day");
         else
             return QString::number( days )+   i18n(" days");
 
     }
     QString message = QString::number ( hours ) +":";
     if ( min < 10 ) message += "0";
     message += QString::number ( min );
     if ( days > 0 ) { 
         if ( days == 1 )
             message =  "1" + i18n(" day") + " "+message;
         else
             message =  QString::number( days )+   i18n(" days") + " "+message;
     }
     return message; 
 }
 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.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 );
   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);
 
   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 );
       } 
   }
 }
 
 // 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;
 }
 void Incidence::clearRelations()
 {
     mRelatedTo = 0;
     mRelations.clear();
 }
 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 (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 );
   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
 {
   return mResources;
 }
 
 
 void Incidence::setPriority(int priority)
 {
   if (mReadOnly) return;
   mPriority = priority;
   updated();
 }
 
 int Incidence::priority() const
 {
   return mPriority;
 }
 
 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");
       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;
 }
 #include <stdlib.h>
 Recurrence *Incidence::recurrence()
 {
     if ( ! mRecurrence ) {
         mRecurrence = new Recurrence(this);
         mRecurrence->setRecurStart( dtStart() );
+        mRecurrence->setRecurReadOnly( isReadOnly());
         //qDebug("creating new recurence ");
         //abort();
     }
   return mRecurrence;
 }
 void Incidence::setRecurrence( Recurrence * 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;
          mRecurrence->getPreviousDateTime( incidenceStart , &last );
          int count = 0;
          if ( !last ) {
              while ( !last ) {
                  ++count;
                  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;
 }