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.
+      Create a Reference to some URI by copying an existing Attachment.
-     * @param uri the uri this attachment refers to
+      
-     * @param mime the mime type of the resource being linked to
+      @param attachment the attachment to be duplicated
-     */
+    */
-    Attachment(const QString& uri, const QString& mime = QString::null);
+    Attachment( const Attachment &attachment );
    /**
-     * Create a binary attachment.
+      Create a Reference to some URI.
-     * @param base64 the attachment in base64 format
+      
-     * @param mime the mime type of the attachment
+      @param uri the uri this attachment refers to
-     */
+      @param mime the mime type of the resource being linked to
-    Attachment(const char *base64, const QString& mime = QString::null);
+    */
+    Attachment( const QString &uri, const QString &mime = QString::null );
-    /* The VALUE parameter in Cal */
-    bool isURI() const;
+    /**
+      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);
+    void setMimeType( const QString &mime );
-private:
+                
+                /* 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,2059 +1,2059 @@
 /*
    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)
                        recur->setYearly(Recurrence::rYearlyMonth,interv,-1);
                    else
                        recur->setYearly(Recurrence::rYearlyMonth,interv,r.count);
                }
                if ( r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX ) {
                    index = 0;
                    while((day = r.by_month[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
                        recur->addYearlyNum(day);
                    }
                } else {
                    recur->addYearlyNum(incidence->dtStart().date().month());
                }
            }
        }
      break;
  default:
      ;
      break;
  }
 }
 void ICalFormatImpl::readAlarm(icalcomponent *alarm,Incidence *incidence)
 {
  //kdDebug(5800) << "Read alarm for " << incidence->summary() << endl;
  Alarm* ialarm = incidence->newAlarm();
  ialarm->setRepeatCount(0);
  ialarm->setEnabled(true);
  // Determine the alarm's action type
  icalproperty *p = icalcomponent_get_first_property(alarm,ICAL_ACTION_PROPERTY);
  if ( !p ) {
    return;
  }
  icalproperty_action action = icalproperty_get_action(p);
  Alarm::Type type = Alarm::Display;
  switch ( action ) {
    case ICAL_ACTION_DISPLAY:   type = Alarm::Display;  break;
    case ICAL_ACTION_AUDIO:     type = Alarm::Audio;  break;
    case ICAL_ACTION_PROCEDURE: type = Alarm::Procedure;  break;
    case ICAL_ACTION_EMAIL:     type = Alarm::Email;  break;
    default:
        ;
      return;
  }
  ialarm->setType(type);
  p = icalcomponent_get_first_property(alarm,ICAL_ANY_PROPERTY);
  while (p) {
    icalproperty_kind kind = icalproperty_isa(p);
    switch (kind) {
      case ICAL_TRIGGER_PROPERTY: {
        icaltriggertype trigger = icalproperty_get_trigger(p);
        if (icaltime_is_null_time(trigger.time)) {
          if (icaldurationtype_is_null_duration(trigger.duration)) {
            kdDebug(5800) << "ICalFormatImpl::readAlarm(): Trigger has no time and no duration." << endl;
          } else {
            Duration duration = icaldurationtype_as_int( trigger.duration );
            icalparameter *param = icalproperty_get_first_parameter(p,ICAL_RELATED_PARAMETER);
            if (param && icalparameter_get_related(param) == ICAL_RELATED_END)
              ialarm->setEndOffset(duration);
            else
              ialarm->setStartOffset(duration);
          }
        } else {
          ialarm->setTime(readICalDateTime(trigger.time));
        }
        break;
      }
      case ICAL_DURATION_PROPERTY: {
        icaldurationtype duration = icalproperty_get_duration(p);
        ialarm->setSnoozeTime(icaldurationtype_as_int(duration)/60);
        break;
      }
      case ICAL_REPEAT_PROPERTY:
        ialarm->setRepeatCount(icalproperty_get_repeat(p));
        break;
      // Only in DISPLAY and EMAIL and PROCEDURE alarms
      case ICAL_DESCRIPTION_PROPERTY: {
        QString description = QString::fromUtf8(icalproperty_get_description(p));
        switch ( action ) {
          case ICAL_ACTION_DISPLAY:
            ialarm->setText( description );
            break;
          case ICAL_ACTION_PROCEDURE:
            ialarm->setProgramArguments( description );
            break;
          case ICAL_ACTION_EMAIL:
            ialarm->setMailText( description );
            break;
          default:
            break;
        }
        break;
      }
      // Only in EMAIL alarm
      case ICAL_SUMMARY_PROPERTY:
        ialarm->setMailSubject(QString::fromUtf8(icalproperty_get_summary(p)));
        break;
      // Only in EMAIL alarm
      case ICAL_ATTENDEE_PROPERTY: {
        QString email = QString::fromUtf8(icalproperty_get_attendee(p));
        QString name;
        icalparameter *param = icalproperty_get_first_parameter(p,ICAL_CN_PARAMETER);
        if (param) {
          name = QString::fromUtf8(icalparameter_get_cn(param));
        }
        ialarm->addMailAddress(Person(name, email));
        break;
      }
      // Only in AUDIO and EMAIL and PROCEDURE alarms
      case ICAL_ATTACH_PROPERTY: {
        icalattach *attach = icalproperty_get_attach(p);
        QString url = QFile::decodeName(icalattach_get_url(attach));
        switch ( action ) {
          case ICAL_ACTION_AUDIO:
            ialarm->setAudioFile( url );
            break;
          case ICAL_ACTION_PROCEDURE:
            ialarm->setProgramFile( url );
            break;
          case ICAL_ACTION_EMAIL:
            ialarm->addMailAttachment( url );
            break;
          default:
            break;
        }
        break;
      }
      default:
        break;
    }
    p = icalcomponent_get_next_property(alarm,ICAL_ANY_PROPERTY);
  }
  // custom properties
  readCustomProperties(alarm, ialarm);
  // TODO: check for consistency of alarm properties
 }
 icaltimetype ICalFormatImpl::writeICalDate(const QDate &date)
 {
  icaltimetype t;
  t.year = date.year();
  t.month = date.month();
  t.day = date.day();
  t.hour = 0;
  t.minute = 0;
  t.second = 0;
  t.is_date = 1;
  t.is_utc = 0;
  t.zone = 0;
  return t;
 }
 icaltimetype ICalFormatImpl::writeICalDateTime(const QDateTime &dt )
 {
  icaltimetype t;
  t.is_date = 0;
  t.zone = 0;
  QDateTime  datetime;
  if ( mParent->utc() ) {
      int offset =  KGlobal::locale()->localTimeOffset( dt );
      datetime =  dt.addSecs ( -offset*60);
      t.is_utc = 1;
  }
  else {
      datetime = dt;
      t.is_utc = 0;
  }
  t.year = datetime.date().year();
  t.month = datetime.date().month();
  t.day = datetime.date().day();
  t.hour = datetime.time().hour();
  t.minute = datetime.time().minute();
  t.second = datetime.time().second();
  //qDebug("*** time %s   localtime %s ",dt .toString().latin1()     ,datetime .toString().latin1() );
 //   if ( mParent->utc() ) {
 //      datetime =  KGlobal::locale()->localTime( dt );
 //      qDebug("*** time %s   localtime %s ",dt .toString().latin1()     ,datetime .toString().latin1() );
 //     if (mParent->timeZoneId().isEmpty())
 //       t = icaltime_as_utc(t, 0);
 //     else
 //       t = icaltime_as_utc(t,mParent->timeZoneId().local8Bit());
 //   }
  return t;
 }
 QDateTime ICalFormatImpl::readICalDateTime(icaltimetype t)
 {
    QDateTime dt (QDate(t.year,t.month,t.day),
                  QTime(t.hour,t.minute,t.second) );
  if (t.is_utc) {
      int offset = KGlobal::locale()->localTimeOffset( dt );
       dt = dt.addSecs ( offset*60);
  }
  return dt;
 }
 QDate ICalFormatImpl::readICalDate(icaltimetype t)
 {
  return QDate(t.year,t.month,t.day);
 }
 icaldurationtype ICalFormatImpl::writeICalDuration(int seconds)
 {
  icaldurationtype d;
  d.is_neg  = (seconds<0)?1:0;
  if (seconds<0) seconds = -seconds;
  d.weeks    = seconds / gSecondsPerWeek;
  seconds   %= gSecondsPerWeek;
  d.days     = seconds / gSecondsPerDay;
  seconds   %= gSecondsPerDay;
  d.hours    = seconds / gSecondsPerHour;
  seconds   %= gSecondsPerHour;
  d.minutes  = seconds / gSecondsPerMinute;
  seconds   %= gSecondsPerMinute;
  d.seconds  = seconds;
  return d;
 }
 int ICalFormatImpl::readICalDuration(icaldurationtype d)
 {
  int result = 0;
  result += d.weeks   * gSecondsPerWeek;
  result += d.days    * gSecondsPerDay;
  result += d.hours   * gSecondsPerHour;
  result += d.minutes * gSecondsPerMinute;
  result += d.seconds;
  if (d.is_neg) result *= -1;
  return result;
 } 
 icalcomponent *ICalFormatImpl::createCalendarComponent(Calendar *cal)
 {
  icalcomponent *calendar;
  // Root component
  calendar = icalcomponent_new(ICAL_VCALENDAR_COMPONENT);
  icalproperty *p;
  // Product Identifier
  p = icalproperty_new_prodid(CalFormat::productId().utf8());
  icalcomponent_add_property(calendar,p);
  // TODO: Add time zone
  // iCalendar version (2.0)
  p = icalproperty_new_version(const_cast<char *>(_ICAL_VERSION));
  icalcomponent_add_property(calendar,p);
  // Custom properties
  if( cal != 0 )
    writeCustomProperties(calendar, cal);
  return calendar;
 }
 // take a raw vcalendar (i.e. from a file on disk, clipboard, etc. etc.
 // and break it down from its tree-like format into the dictionary format
 // that is used internally in the ICalFormatImpl.
 bool ICalFormatImpl::populate( Calendar *cal, icalcomponent *calendar)
 {
  // this function will populate the caldict dictionary and other event
  // lists. It turns vevents into Events and then inserts them.
    if (!calendar) return false;
 // TODO: check for METHOD
 #if 0
  if ((curVO = isAPropertyOf(vcal, ICMethodProp)) != 0) {
    char *methodType = 0;
    methodType = fakeCString(vObjectUStringZValue(curVO));
    if (mEnableDialogs)
      KMessageBox::information(mTopWidget,
                               i18n("This calendar is an iTIP transaction of type \"%1\".")
                               .arg(methodType),
                               i18n("%1: iTIP Transaction").arg(CalFormat::application()));
    delete methodType;
  }
 #endif
  icalproperty *p;
  p = icalcomponent_get_first_property(calendar,ICAL_PRODID_PROPERTY);
  if (!p) {
 // TODO: does no PRODID really matter?
 //    mParent->setException(new ErrorFormat(ErrorFormat::CalVersionUnknown));
 //    return false;
    mLoadedProductId = "";
    mCalendarVersion = 0;
  } else {
    mLoadedProductId = QString::fromUtf8(icalproperty_get_prodid(p));
    mCalendarVersion = CalFormat::calendarVersion(mLoadedProductId);
    delete mCompat;
    mCompat = CompatFactory::createCompat( mLoadedProductId );
  }
 // TODO: check for unknown PRODID
 #if 0
  if (!mCalendarVersion
  &&  CalFormat::productId() != mLoadedProductId) {
    // warn the user that we might have trouble reading non-known calendar.
    if (mEnableDialogs)
      KMessageBox::information(mTopWidget,
                             i18n("This vCalendar file was not created by KOrganizer "
                                     "or any other product we support. Loading anyway..."),
                             i18n("%1: Unknown vCalendar Vendor").arg(CalFormat::application()));
  }
 #endif
  p = icalcomponent_get_first_property(calendar,ICAL_VERSION_PROPERTY);
  if (!p) {
    mParent->setException(new ErrorFormat(ErrorFormat::CalVersionUnknown));
    return false;
  } else {
    const char *version = icalproperty_get_version(p);
    if (strcmp(version,"1.0") == 0) {
      mParent->setException(new ErrorFormat(ErrorFormat::CalVersion1,
                            i18n("Expected iCalendar format")));
      return false;
    } else if (strcmp(version,"2.0") != 0) {
      mParent->setException(new ErrorFormat(ErrorFormat::CalVersionUnknown));
      return false;
    }
  }
 // TODO: check for calendar format version
 #if 0
  // warn the user we might have trouble reading this unknown version.
  if ((curVO = isAPropertyOf(vcal, VCVersionProp)) != 0) {
    char *s = fakeCString(vObjectUStringZValue(curVO));
    if (strcmp(_VCAL_VERSION, s) != 0)
      if (mEnableDialogs)
        KMessageBox::sorry(mTopWidget,
                             i18n("This vCalendar file has version %1.\n"
                                  "We only support %2.")
                             .arg(s).arg(_VCAL_VERSION),
                             i18n("%1: Unknown vCalendar Version").arg(CalFormat::application()));
    deleteStr(s);
  }
 #endif
  // custom properties
  readCustomProperties(calendar, cal);
 // TODO: set time zone
 #if 0
  // set the time zone
  if ((curVO = isAPropertyOf(vcal, VCTimeZoneProp)) != 0) {
    char *s = fakeCString(vObjectUStringZValue(curVO));
    cal->setTimeZone(s);
    deleteStr(s);
  }
 #endif
  // Store all events with a relatedTo property in a list for post-processing
  mEventsRelate.clear();
  mTodosRelate.clear();
  // TODO: make sure that only actually added ecvens go to this lists.
  icalcomponent *c;
  // Iterate through all todos
  c = icalcomponent_get_first_component(calendar,ICAL_VTODO_COMPONENT);
  while (c) {
 //    kdDebug(5800) << "----Todo found" << endl;
    Todo *todo = readTodo(c);
    if (!cal->todo(todo->uid())) 
        cal->addTodo(todo);
    c = icalcomponent_get_next_component(calendar,ICAL_VTODO_COMPONENT);
  }
  // Iterate through all events
  c = icalcomponent_get_first_component(calendar,ICAL_VEVENT_COMPONENT);
  while (c) {
 //    kdDebug(5800) << "----Event found" << endl;
    Event *event = readEvent(c);
    if (!cal->event(event->uid())) 
        cal->addEvent(event);
    c = icalcomponent_get_next_component(calendar,ICAL_VEVENT_COMPONENT);
  }
  // Iterate through all journals
  c = icalcomponent_get_first_component(calendar,ICAL_VJOURNAL_COMPONENT);
  while (c) {
 //    kdDebug(5800) << "----Journal found" << endl;
    Journal *journal = readJournal(c);
    if (!cal->journal(journal->uid()))
        cal->addJournal(journal);
    c = icalcomponent_get_next_component(calendar,ICAL_VJOURNAL_COMPONENT);
  }
 #if 0
  initPropIterator(&i, vcal);
  // go through all the vobjects in the vcal
  while (moreIteration(&i)) {
    curVO = nextVObject(&i);
    /************************************************************************/
    // now, check to see that the object is an event or todo.
    if (strcmp(vObjectName(curVO), VCEventProp) == 0) {
      if ((curVOProp = isAPropertyOf(curVO, KPilotStatusProp)) != 0) {
        char *s;
        s = fakeCString(vObjectUStringZValue(curVOProp));
        // check to see if event was deleted by the kpilot conduit
        if (atoi(s) == Event::SYNCDEL) {
          deleteStr(s);
          goto SKIP;
        }
        deleteStr(s);
      }
      // this code checks to see if we are trying to read in an event
      // that we already find to be in the calendar.  If we find this
      // to be the case, we skip the event.
      if ((curVOProp = isAPropertyOf(curVO, VCUniqueStringProp)) != 0) {
        char *s = fakeCString(vObjectUStringZValue(curVOProp));
        QString tmpStr(s);
        deleteStr(s);
        if (cal->event(tmpStr)) {
          goto SKIP;
        }
        if (cal->todo(tmpStr)) {
          goto SKIP;
        }
      }
      if ((!(curVOProp = isAPropertyOf(curVO, VCDTstartProp))) &&
          (!(curVOProp = isAPropertyOf(curVO, VCDTendProp)))) {
        kdDebug(5800) << "found a VEvent with no DTSTART and no DTEND! Skipping..." << endl;
        goto SKIP;
      }
      anEvent = VEventToEvent(curVO);
      // we now use addEvent instead of insertEvent so that the
      // signal/slot get connected.
      if (anEvent)
        cal->addEvent(anEvent);
      else {
        // some sort of error must have occurred while in translation.
        goto SKIP;
      }
    } else if (strcmp(vObjectName(curVO), VCTodoProp) == 0) {
      anEvent = VTodoToEvent(curVO);
      cal->addTodo(anEvent);
    } else if ((strcmp(vObjectName(curVO), VCVersionProp) == 0) ||
               (strcmp(vObjectName(curVO), VCProdIdProp) == 0) ||
               (strcmp(vObjectName(curVO), VCTimeZoneProp) == 0)) {
      // do nothing, we know these properties and we want to skip them.
      // we have either already processed them or are ignoring them.
      ;
    } else {
        ;
    }
  SKIP:
    ;
  } // while
 #endif
  // Post-Process list of events with relations, put Event objects in relation
  Event *ev;
  for ( ev=mEventsRelate.first(); ev != 0; ev=mEventsRelate.next() ) {
      Incidence * inc = cal->event(ev->relatedToUid());
      if ( inc )
          ev->setRelatedTo( inc );
  }
  Todo *todo;
  for ( todo=mTodosRelate.first(); todo != 0; todo=mTodosRelate.next() ) {
      Incidence * inc = cal->todo(todo->relatedToUid());
      if ( inc )
          todo->setRelatedTo( inc );
  }
  return true;
 }
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;
 }