Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 2203 insertions, 0 deletions

diff --git a/libkcal/icalformatimpl.cpp b/libkcal/icalformatimpl.cpp
new file mode 100644
index 000000000..bd3b8e7be
--- /dev/null
+++ b/libkcal/icalformatimpl.cpp
@@ -0,0 +1,2203 @@
+/*
+    This file is part of libkcal.
+
+    Copyright (c) 2001 Cornelius Schumacher <schumacher@kde.org>
+    Copyright (C) 2003-2004 Reinhold Kainhofer <reinhold@kainhofer.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+
+#include <qdatetime.h>
+#include <qstring.h>
+#include <qptrlist.h>
+#include <qfile.h>
+#include <cstdlib>
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <kmdcodec.h>
+
+extern "C" {
+  #include <ical.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;
+
+/* Static helpers */
+static QDateTime ICalDate2QDate(const icaltimetype& t)
+{
+  // Outlook sends dates starting from 1601-01-01, but QDate()
+  // can only handle dates starting 1752-09-14.
+  const int year = (t.year>=1754) ? t.year : 1754;
+  return QDateTime(QDate(year,t.month,t.day), QTime(t.hour,t.minute,t.second));
+}
+
+static void _dumpIcaltime( const icaltimetype& t)
+{
+  kdDebug(5800) << "--- Y: " << t.year << " M: " << t.month << " D: " << t.day
+      << endl;
+  kdDebug(5800) << "--- H: " << t.hour << " M: " << t.minute << " S: " << t.second
+      << endl;
+  kdDebug(5800) << "--- isUtc: " << icaltime_is_utc( t )<< endl;
+  kdDebug(5800) << "--- zoneId: " << icaltimezone_get_tzid( const_cast<icaltimezone*>( t.zone ) )<< endl;
+}
+
+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 ), mCompat( new Compat )
+{
+}
+
+ICalFormatImpl::~ICalFormatImpl()
+{
+  delete mCompat;
+}
+
+class ICalFormatImpl::ToComponentVisitor : public IncidenceBase::Visitor
+{
+  public:
+    ToComponentVisitor( ICalFormatImpl *impl, Scheduler::Method m ) : mImpl( impl ), mComponent( 0 ), mMethod( m ) {}
+
+    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; }
+    bool visit( FreeBusy *fb ) { mComponent = mImpl->writeFreeBusy( fb, mMethod ); return true; }
+
+    icalcomponent *component() { return mComponent; }
+
+  private:
+    ICalFormatImpl *mImpl;
+    icalcomponent *mComponent;
+    Scheduler::Method mMethod;
+};
+
+icalcomponent *ICalFormatImpl::writeIncidence( IncidenceBase *incidence, Scheduler::Method method )
+{
+  ToComponentVisitor v( this, method );
+  if ( incidence->accept(v) )
+    return v.component();
+  else return 0;
+}
+
+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(true).date());
+    } else {
+      due = writeICalDateTime(todo->dtDue(true));
+    }
+    icalcomponent_add_property(vtodo,icalproperty_new_due(due));
+  }
+
+  // start time
+  if ( todo->hasStartDate() || todo->doesRecur() ) {
+    icaltimetype start;
+    if (todo->doesFloat()) {
+//      kdDebug(5800) << " Incidence " << todo->summary() << " floats." << endl;
+      start = writeICalDate(todo->dtStart(true).date());
+    } else {
+//      kdDebug(5800) << " incidence " << todo->summary() << " has time." << endl;
+      start = writeICalDateTime(todo->dtStart(true));
+    }
+    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()));
+
+  if( todo->doesRecur() ) {
+    icalcomponent_add_property(vtodo,
+        icalproperty_new_recurrenceid( writeICalDateTime( todo->dtDue())));
+  }
+
+  return vtodo;
+}
+
+icalcomponent *ICalFormatImpl::writeEvent(Event *event)
+{
+#if 0
+  kdDebug(5800) << "Write Event '" << event->summary() << "' (" << event->uid()
+                << ")" << endl;
+#endif
+
+  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.
+    // RFC2445 says that if DTEND is present, it has to be greater than DTSTART.
+    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 ) );
+      icalcomponent_add_property(vevent,icalproperty_new_dtend(end));
+    } else {
+//      kdDebug(5800) << " Event " << event->summary() << " has time." << endl;
+      if (event->dtEnd() != event->dtStart()) {
+        end = writeICalDateTime(event->dtEnd());
+        icalcomponent_add_property(vevent,icalproperty_new_dtend(end));
+      }
+    }
+  }
+
+// TODO: resources
+#if 0
+  // 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)
+{
+#if QT_VERSION >= 300
+  kdDebug(5800) << "icalformatimpl: writeFreeBusy: startDate: "
+    << freebusy->dtStart().toString("ddd MMMM d yyyy: h:m:s ap") << " End Date: "
+    << freebusy->dtEnd().toString("ddd MMMM d yyyy: h:m:s ap") << endl;
+#endif
+
+  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 = icalperiodtype_null_period();
+  for (it = list.begin(); it!= list.end(); ++it) {
+    period.start = writeICalDateTime((*it).start());
+    if ( (*it).hasDuration() ) {
+      period.duration = writeICalDuration( (*it).duration().asSeconds() );
+    } else {
+      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()) {
+    // NOTE: we can't do setNonKDECustomProperty here because this changes
+    // data and triggers an updated() event...
+    // incidence->setNonKDECustomProperty("X-PILOTSTAT", QString::number(incidence->syncStatus()));
+    // incidence->setNonKDECustomProperty("X-PILOTID", QString::number(incidence->pilotId()));
+
+    icalproperty *p = 0;
+    p = icalproperty_new_x(QString::number(incidence->syncStatus()).utf8());
+    icalproperty_set_x_name(p,"X-PILOTSTAT");
+    icalcomponent_add_property(parent,p);
+
+    p = icalproperty_new_x(QString::number(incidence->pilotId()).utf8());
+    icalproperty_set_x_name(p,"X-PILOTID");
+    icalcomponent_add_property(parent,p);
+  }
+
+  if ( incidence->schedulingID() != incidence->uid() )
+    // We need to store the UID in here. The rawSchedulingID will
+    // go into the iCal UID component
+    incidence->setCustomProperty( "LIBKCAL", "ID", incidence->uid() );
+  else
+    incidence->removeCustomProperty( "LIBKCAL", "ID" );
+
+  writeIncidenceBase(parent,incidence);
+
+  // creation date
+  icalcomponent_add_property(parent,icalproperty_new_created(
+      writeICalDateTime(incidence->created())));
+
+  // unique id
+  // If the scheduling ID is different from the real UID, the real
+  // one is stored on X-REALID above
+  if ( !incidence->schedulingID().isEmpty() ) {
+    icalcomponent_add_property(parent,icalproperty_new_uid(
+        incidence->schedulingID().utf8()));
+  }
+
+  // revision
+  if ( incidence->revision() > 0 ) { // 0 is default, so don't write that out
+    icalcomponent_add_property(parent,icalproperty_new_sequence(
+        incidence->revision()));
+  }
+
+  // last modification date
+  if ( incidence->lastModified().isValid() ) {
+   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()));
+  }
+
+  // status
+  icalproperty_status status = ICAL_STATUS_NONE;
+  switch (incidence->status()) {
+    case Incidence::StatusTentative:    status = ICAL_STATUS_TENTATIVE;  break;
+    case Incidence::StatusConfirmed:    status = ICAL_STATUS_CONFIRMED;  break;
+    case Incidence::StatusCompleted:    status = ICAL_STATUS_COMPLETED;  break;
+    case Incidence::StatusNeedsAction:  status = ICAL_STATUS_NEEDSACTION;  break;
+    case Incidence::StatusCanceled:     status = ICAL_STATUS_CANCELLED;  break;
+    case Incidence::StatusInProcess:    status = ICAL_STATUS_INPROCESS;  break;
+    case Incidence::StatusDraft:        status = ICAL_STATUS_DRAFT;  break;
+    case Incidence::StatusFinal:        status = ICAL_STATUS_FINAL;  break;
+    case Incidence::StatusX: {
+      icalproperty* p = icalproperty_new_status(ICAL_STATUS_X);
+      icalvalue_set_x(icalproperty_get_value(p), incidence->statusStr().utf8());
+      icalcomponent_add_property(parent, p);
+      break;
+    }
+    case Incidence::StatusNone:
+    default:
+      break;
+  }
+  if (status != ICAL_STATUS_NONE)
+    icalcomponent_add_property(parent, icalproperty_new_status(status));
+
+  // secrecy
+  icalproperty_class secClass;
+  switch (incidence->secrecy()) {
+    case Incidence::SecrecyPublic:
+      secClass = ICAL_CLASS_PUBLIC;
+      break;
+    case Incidence::SecrecyConfidential:
+      secClass = ICAL_CLASS_CONFIDENTIAL;
+      break;
+    case Incidence::SecrecyPrivate:
+    default:
+      secClass = ICAL_CLASS_PRIVATE;
+      break;
+  }
+  if ( secClass != ICAL_CLASS_PUBLIC ) {
+    icalcomponent_add_property(parent,icalproperty_new_class(secClass));
+  }
+
+  // priority
+  if ( incidence->priority() > 0 ) { // 0 is undefined 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()));
+  }
+
+  // related event
+  if ( !incidence->relatedToUid().isEmpty() ) {
+    icalcomponent_add_property(parent,icalproperty_new_relatedto(
+        incidence->relatedToUid().utf8()));
+  }
+
+//   kdDebug(5800) << "Write recurrence for '" << incidence->summary() << "' (" << incidence->uid()
+//             << ")" << endl;
+
+  RecurrenceRule::List rrules( incidence->recurrence()->rRules() );
+  RecurrenceRule::List::ConstIterator rit;
+  for ( rit = rrules.begin(); rit != rrules.end(); ++rit ) {
+    icalcomponent_add_property( parent, icalproperty_new_rrule(
+                                writeRecurrenceRule( (*rit) ) ) );
+  }
+
+  RecurrenceRule::List exrules( incidence->recurrence()->exRules() );
+  RecurrenceRule::List::ConstIterator exit;
+  for ( exit = exrules.begin(); exit != exrules.end(); ++exit ) {
+    icalcomponent_add_property( parent, icalproperty_new_rrule(
+                                writeRecurrenceRule( (*exit) ) ) );
+  }
+
+  DateList dateList = incidence->recurrence()->exDates();
+  DateList::ConstIterator exIt;
+  for(exIt = dateList.begin(); exIt != dateList.end(); ++exIt) {
+    icalcomponent_add_property(parent,icalproperty_new_exdate(
+        writeICalDate(*exIt)));
+  }
+  DateTimeList dateTimeList = incidence->recurrence()->exDateTimes();
+  DateTimeList::ConstIterator extIt;
+  for(extIt = dateTimeList.begin(); extIt != dateTimeList.end(); ++extIt) {
+    icalcomponent_add_property(parent,icalproperty_new_exdate(
+        writeICalDateTime(*extIt)));
+  }
+
+
+  dateList = incidence->recurrence()->rDates();
+  DateList::ConstIterator rdIt;
+  for( rdIt = dateList.begin(); rdIt != dateList.end(); ++rdIt) {
+     icalcomponent_add_property( parent, icalproperty_new_rdate(
+         writeICalDatePeriod(*rdIt) ) );
+  }
+  dateTimeList = incidence->recurrence()->rDateTimes();
+  DateTimeList::ConstIterator rdtIt;
+  for( rdtIt = dateTimeList.begin(); rdtIt != dateTimeList.end(); ++rdtIt) {
+     icalcomponent_add_property( parent, icalproperty_new_rdate(
+         writeICalDateTimePeriod(*rdtIt) ) );
+  }
+
+  // attachments
+  Attachment::List attachments = incidence->attachments();
+  Attachment::List::ConstIterator atIt;
+  for ( atIt = attachments.begin(); atIt != attachments.end(); ++atIt ) {
+    icalcomponent_add_property( parent, writeAttachment( *atIt ) );
+  }
+
+  // alarms
+  Alarm::List::ConstIterator alarmIt;
+  for ( alarmIt = incidence->alarms().begin();
+        alarmIt != incidence->alarms().end(); ++alarmIt ) {
+    if ( (*alarmIt)->enabled() ) {
+//      kdDebug(5800) << "Write alarm for " << incidence->summary() << endl;
+      icalcomponent_add_component( parent, writeAlarm( *alarmIt ) );
+    }
+  }
+
+  // duration
+  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
+  if ( !incidenceBase->organizer().isEmpty() ) {
+    icalcomponent_add_property( parent, writeOrganizer( incidenceBase->organizer() ) );
+  }
+
+  // attendees
+  if ( incidenceBase->attendeeCount() > 0 ) {
+    Attendee::List::ConstIterator it;
+    for( it = incidenceBase->attendees().begin();
+         it != incidenceBase->attendees().end(); ++it ) {
+      icalcomponent_add_property( parent, writeAttendee( *it ) );
+    }
+  }
+
+  // comments
+  QStringList comments = incidenceBase->comments();
+  for (QStringList::Iterator it=comments.begin(); it!=comments.end(); ++it) {
+    icalcomponent_add_property(parent, icalproperty_new_comment((*it).utf8()));
+  }
+
+  // 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::writeOrganizer( const Person &organizer )
+{
+  icalproperty *p = icalproperty_new_organizer("MAILTO:" + organizer.email().utf8());
+
+  if (!organizer.name().isEmpty()) {
+    icalproperty_add_parameter( p, icalparameter_new_cn(organizer.name().utf8()) );
+  }
+  // TODO: Write dir, sent-by and language
+
+  return 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);
+  }
+
+  if ( !attendee->delegate().isEmpty() ) {
+    icalparameter* icalparameter_delegate = icalparameter_new_delegatedto( attendee->delegate().utf8() );
+    icalproperty_add_parameter( p, icalparameter_delegate );
+  }
+
+  if ( !attendee->delegator().isEmpty() ) {
+    icalparameter* icalparameter_delegator = icalparameter_new_delegatedfrom( attendee->delegator().utf8() );
+    icalproperty_add_parameter( p, icalparameter_delegator );
+  }
+
+  return p;
+}
+
+icalproperty *ICalFormatImpl::writeAttachment(Attachment *att)
+{
+  icalattach *attach;
+  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 ) );
+  }
+
+  if ( att->showInline() ) {
+    icalparameter* icalparameter_inline = icalparameter_new_x( "inline" );
+    icalparameter_set_xname( icalparameter_inline, "X-CONTENT-DISPOSITION" );
+    icalproperty_add_parameter( p, icalparameter_inline );
+  }
+
+  if ( !att->label().isEmpty() ) {
+    icalparameter* icalparameter_label = icalparameter_new_x( att->label().utf8() );
+    icalparameter_set_xname( icalparameter_label, "X-LABEL" );
+    icalproperty_add_parameter( p, icalparameter_label );
+  }
+
+  return p;
+}
+
+icalrecurrencetype ICalFormatImpl::writeRecurrenceRule( RecurrenceRule *recur )
+{
+//  kdDebug(5800) << "ICalFormatImpl::writeRecurrenceRule()" << endl;
+
+  icalrecurrencetype r;
+  icalrecurrencetype_clear(&r);
+
+  switch( recur->recurrenceType() ) {
+    case RecurrenceRule::rSecondly:
+      r.freq = ICAL_SECONDLY_RECURRENCE;
+      break;
+    case RecurrenceRule::rMinutely:
+      r.freq = ICAL_MINUTELY_RECURRENCE;
+      break;
+    case RecurrenceRule::rHourly:
+      r.freq = ICAL_HOURLY_RECURRENCE;
+      break;
+    case RecurrenceRule::rDaily:
+      r.freq = ICAL_DAILY_RECURRENCE;
+      break;
+    case RecurrenceRule::rWeekly:
+      r.freq = ICAL_WEEKLY_RECURRENCE;
+      break;
+    case RecurrenceRule::rMonthly:
+      r.freq = ICAL_MONTHLY_RECURRENCE;
+      break;
+    case RecurrenceRule::rYearly:
+      r.freq = ICAL_YEARLY_RECURRENCE;
+      break;
+    default:
+      r.freq = ICAL_NO_RECURRENCE;
+      kdDebug(5800) << "ICalFormatImpl::writeRecurrence(): no recurrence" << endl;
+      break;
+  }
+
+  int index = 0;
+  QValueList<int> bys;
+  QValueList<int>::ConstIterator it;
+
+  // Now write out the BY* parts:
+  bys = recur->bySeconds();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+    r.by_second[index++] = *it;
+  }
+
+  bys = recur->byMinutes();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+    r.by_minute[index++] = *it;
+  }
+
+  bys = recur->byHours();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+    r.by_hour[index++] = *it;
+  }
+
+  bys = recur->byMonthDays();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+    r.by_month_day[index++] = icalrecurrencetype_day_position( (*it) * 8 );
+  }
+
+  bys = recur->byYearDays();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+    r.by_year_day[index++] = *it;
+  }
+
+  bys = recur->byWeekNumbers();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+     r.by_week_no[index++] = *it;
+  }
+
+  bys = recur->byMonths();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+    r.by_month[index++] = *it;
+  }
+
+  bys = recur->bySetPos();
+  index = 0;
+  for ( it = bys.begin(); it != bys.end(); ++it ) {
+     r.by_set_pos[index++] = *it;
+  }
+
+
+  QValueList<RecurrenceRule::WDayPos> byd = recur->byDays();
+  int day;
+  index = 0;
+  for ( QValueList<RecurrenceRule::WDayPos>::ConstIterator dit = byd.begin();
+        dit != byd.end(); ++dit ) {
+    day = (*dit).day() % 7 + 1;     // convert from Monday=1 to Sunday=1
+    if ( (*dit).pos() < 0 ) {
+      day += (-(*dit).pos())*8;
+      day = -day;
+    } else {
+      day += (*dit).pos()*8;
+    }
+    r.by_day[index++] = day;
+  }
+
+  r.week_start = static_cast<icalrecurrencetype_weekday>(
+                                             recur->weekStart()%7 + 1);
+
+  if ( recur->frequency() > 1 ) {
+    // Dont' write out INTERVAL=1, because that's the default anyway
+    r.interval = recur->frequency();
+  }
+
+  if ( recur->duration() > 0 ) {
+    r.count = recur->duration();
+  } else if ( recur->duration() == -1 ) {
+    r.count = 0;
+  } else {
+    if ( recur->doesFloat() )
+      r.until = writeICalDate(recur->endDt().date());
+    else
+      r.until = writeICalDateTime(recur->endDt());
+  }
+
+// 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 r;
+}
+
+
+icalcomponent *ICalFormatImpl::writeAlarm(Alarm *alarm)
+{
+// kdDebug(5800) << " ICalFormatImpl::writeAlarm" << endl;
+  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()));
+      }
+      break;
+    case Alarm::Audio:
+      action = ICAL_ACTION_AUDIO;
+// kdDebug(5800) << " It's an audio action, file: " << alarm->audioFile() << endl;
+      if (!alarm->audioFile().isEmpty()) {
+        attach = icalattach_new_from_url(QFile::encodeName( alarm->audioFile() ).data());
+        icalcomponent_add_property(a,icalproperty_new_attach(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->mailText().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));
+        }
+      }
+      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, 0, todo); // FIXME timezone
+
+  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)),true);
+        } else {
+          todo->setDtDue(readICalDateTime(icaltime),true);
+          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().
+        if ( todo->comments().grep("NoStartDate").count() )
+          todo->setHasStartDate( false );
+        else
+          todo->setHasStartDate( true );
+        break;
+      }
+
+      case ICAL_RECURRENCEID_PROPERTY:
+        icaltime = icalproperty_get_recurrenceid(p);
+        todo->setDtRecurrence( readICalDateTime(icaltime) );
+        break;
+
+      default:
+//        kdDebug(5800) << "ICALFormat::readTodo(): Unknown property: " << kind
+//                  << endl;
+        break;
+    }
+
+    p = icalcomponent_get_next_property(vtodo,ICAL_ANY_PROPERTY);
+  }
+
+  if (mCompat) mCompat->fixEmptySummary( todo );
+
+  return todo;
+}
+
+Event *ICalFormatImpl::readEvent( icalcomponent *vevent, icalcomponent *vtimezone )
+{
+  Event *event = new Event;
+
+  // FIXME where is this freed?
+  icaltimezone *tz = icaltimezone_new();
+  if ( !icaltimezone_set_component( tz, vtimezone ) ) {
+    icaltimezone_free( tz, 1 );
+    tz = 0;
+  }
+
+  readIncidence( vevent, tz, event);
+
+  icalproperty *p = icalcomponent_get_first_property(vevent,ICAL_ANY_PROPERTY);
+
+//  int intvalue;
+  icaltimetype icaltime;
+
+  QStringList categories;
+  icalproperty_transp transparency;
+
+  bool dtEndProcessed = false;
+
+  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) {
+          // End date is non-inclusive
+          QDate endDate = readICalDate( icaltime ).addDays( -1 );
+          if ( mCompat ) 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, tz));
+          event->setFloats( false );
+        }
+        dtEndProcessed = true;
+        break;
+
+      case ICAL_RELATEDTO_PROPERTY:  // related event (parent)
+        event->setRelatedToUid(QString::fromUtf8(icalproperty_get_relatedto(p)));
+        mEventsRelate.append(event);
+        break;
+
+
+      case ICAL_TRANSP_PROPERTY:  // Transparency
+        transparency = icalproperty_get_transp(p);
+        if( transparency == 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);
+  }
+
+  // according to rfc2445 the dtend shouldn't be written when it equals
+  // start date. so assign one equal to start date.
+  if ( !dtEndProcessed && !event->hasDuration() ) {
+    event->setDtEnd( event->dtStart() );
+  }
+
+  QString msade = event->nonKDECustomProperty("X-MICROSOFT-CDO-ALLDAYEVENT");
+  if (!msade.isEmpty()) {
+    bool floats = (msade == QString::fromLatin1("TRUE"));
+    event->setFloats(floats);
+  }
+
+  if ( mCompat ) mCompat->fixEmptySummary( event );
+
+  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;
+  PeriodList periods;
+
+  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:  // end Date and Time
+        icaltime = icalproperty_get_dtend(p);
+        freebusy->setDtEnd(readICalDateTime(icaltime));
+        break;
+
+      case ICAL_FREEBUSY_PROPERTY: { //Any FreeBusy Times
+        icalperiodtype icalperiod = icalproperty_get_freebusy(p);
+        QDateTime period_start = readICalDateTime(icalperiod.start);
+        Period period;
+        if ( !icaltime_is_null_time(icalperiod.end) ) {
+          QDateTime period_end = readICalDateTime(icalperiod.end);
+          period = Period(period_start, period_end);
+        } else {
+          Duration duration = readICalDuration( icalperiod.duration );
+          period = Period(period_start, duration);
+        }
+        QCString param = icalproperty_get_parameter_as_string( p, "X-SUMMARY" );
+        period.setSummary( QString::fromUtf8( KCodecs::base64Decode( param ) ) );
+        param = icalproperty_get_parameter_as_string( p, "X-LOCATION" );
+        period.setLocation( QString::fromUtf8( KCodecs::base64Decode( param ) ) );
+        periods.append( period );
+        break;}
+
+      default:
+//        kdDebug(5800) << "ICalFormatImpl::readFreeBusy(): Unknown property: "
+//                      << kind << endl;
+      break;
+    }
+    p = icalcomponent_get_next_property(vfreebusy,ICAL_ANY_PROPERTY);
+  }
+  freebusy->addPeriods( periods );
+
+  return freebusy;
+}
+
+Journal *ICalFormatImpl::readJournal(icalcomponent *vjournal)
+{
+  Journal *journal = new Journal;
+
+  readIncidence(vjournal, 0, journal); // FIXME tz?
+
+  return journal;
+}
+
+Attendee *ICalFormatImpl::readAttendee(icalproperty *attendee)
+{
+  icalparameter *p = 0;
+
+  QString email = QString::fromUtf8(icalproperty_get_attendee(attendee));
+  if ( email.startsWith( "mailto:", false ) ) {
+    email = email.mid( 7 );
+  }
+
+  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.
+  // TODO: does this work now in libical-0.24 or greater?
+  /*while (p) {
+   // if (icalparameter_get_xname(p) == "X-UID") {
+    uid = icalparameter_get_xvalue(p);
+    p = icalproperty_get_next_parameter(attendee,ICAL_X_PARAMETER);
+  } */
+
+  Attendee *a = new Attendee( name, email, rsvp, status, role, uid );
+
+  p = icalproperty_get_first_parameter( attendee, ICAL_DELEGATEDTO_PARAMETER );
+  if ( p )
+    a->setDelegate( icalparameter_get_delegatedto( p ) );
+
+  p = icalproperty_get_first_parameter( attendee, ICAL_DELEGATEDFROM_PARAMETER );
+  if ( p )
+    a->setDelegator( icalparameter_get_delegatedfrom( p ) );
+
+  return a;
+}
+
+Person ICalFormatImpl::readOrganizer( icalproperty *organizer )
+{
+  QString email = QString::fromUtf8(icalproperty_get_organizer(organizer));
+  if ( email.startsWith( "mailto:", false ) ) {
+    email = email.mid( 7 );
+  }
+  QString cn;
+
+  icalparameter *p = icalproperty_get_first_parameter(
+             organizer, ICAL_CN_PARAMETER );
+
+  if ( p ) {
+    cn = QString::fromUtf8( icalparameter_get_cn( p ) );
+  }
+  Person org( cn, email );
+  // TODO: Treat sent-by, dir and language here, too
+  return org;
+}
+
+Attachment *ICalFormatImpl::readAttachment(icalproperty *attach)
+{
+  Attachment *attachment = 0;
+
+  icalvalue_kind value_kind = icalvalue_isa(icalproperty_get_value(attach));
+
+  if ( value_kind == ICAL_ATTACH_VALUE || value_kind == ICAL_BINARY_VALUE ) {
+    icalattach *a = icalproperty_get_attach(attach);
+
+    int isurl = icalattach_get_is_url (a);
+    if (isurl == 0)
+      attachment = new Attachment((const char*)icalattach_get_data(a));
+    else {
+      attachment = new Attachment(QString::fromUtf8(icalattach_get_url(a)));
+    }
+  }
+  else if ( value_kind == ICAL_URI_VALUE ) {
+    attachment = new Attachment(QString::fromUtf8(icalvalue_get_uri(icalproperty_get_value(attach))));
+  }
+
+  icalparameter *p = icalproperty_get_first_parameter(attach, ICAL_FMTTYPE_PARAMETER);
+  if (p && attachment)
+    attachment->setMimeType(QString(icalparameter_get_fmttype(p)));
+
+  p = icalproperty_get_first_parameter(attach,ICAL_X_PARAMETER);
+  while (p) {
+   if ( strncmp (icalparameter_get_xname(p), "X-LABEL", 7) == 0 )
+     attachment->setLabel( icalparameter_get_xvalue(p) );
+    p = icalproperty_get_next_parameter(attach, ICAL_X_PARAMETER);
+  }
+
+  return attachment;
+}
+
+void ICalFormatImpl::readIncidence(icalcomponent *parent, icaltimezone *tz, Incidence *incidence)
+{
+  readIncidenceBase(parent,incidence);
+
+  icalproperty *p = icalcomponent_get_first_property(parent,ICAL_ANY_PROPERTY);
+
+  const char *text;
+  int intvalue, inttext;
+  icaltimetype icaltime;
+  icaldurationtype icalduration;
+
+  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, tz));
+        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, tz));
+        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, tz));
+          incidence->setFloats( false );
+        }
+        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_LOCATION_PROPERTY:  // location
+        text = icalproperty_get_location(p);
+        incidence->setLocation(QString::fromUtf8(text));
+        break;
+
+      case ICAL_STATUS_PROPERTY: {  // status
+        Incidence::Status stat;
+        switch (icalproperty_get_status(p)) {
+          case ICAL_STATUS_TENTATIVE:   stat = Incidence::StatusTentative; break;
+          case ICAL_STATUS_CONFIRMED:   stat = Incidence::StatusConfirmed; break;
+          case ICAL_STATUS_COMPLETED:   stat = Incidence::StatusCompleted; break;
+          case ICAL_STATUS_NEEDSACTION: stat = Incidence::StatusNeedsAction; break;
+          case ICAL_STATUS_CANCELLED:   stat = Incidence::StatusCanceled; break;
+          case ICAL_STATUS_INPROCESS:   stat = Incidence::StatusInProcess; break;
+          case ICAL_STATUS_DRAFT:       stat = Incidence::StatusDraft; break;
+          case ICAL_STATUS_FINAL:       stat = Incidence::StatusFinal; break;
+          case ICAL_STATUS_X:
+            incidence->setCustomStatus(QString::fromUtf8(icalvalue_get_x(icalproperty_get_value(p))));
+            stat = Incidence::StatusX;
+            break;
+          case ICAL_STATUS_NONE:
+          default:                      stat = Incidence::StatusNone; break;
+        }
+        if (stat != Incidence::StatusX)
+          incidence->setStatus(stat);
+        break;
+      }
+
+      case ICAL_PRIORITY_PROPERTY:  // priority
+        intvalue = icalproperty_get_priority( p );
+        if ( mCompat )
+          intvalue = mCompat->fixPriority( intvalue );
+        incidence->setPriority( intvalue );
+        break;
+
+      case ICAL_CATEGORIES_PROPERTY:  // categories
+        text = icalproperty_get_categories(p);
+        categories.append(QString::fromUtf8(text));
+        break;
+
+      case ICAL_RRULE_PROPERTY:
+        readRecurrenceRule( p, incidence );
+        break;
+
+      case ICAL_RDATE_PROPERTY: {
+        icaldatetimeperiodtype rd = icalproperty_get_rdate( p );
+        if ( icaltime_is_valid_time( rd.time ) ) {
+          if ( icaltime_is_date( rd.time ) ) {
+            incidence->recurrence()->addRDate( readICalDate( rd.time ) );
+          } else {
+            incidence->recurrence()->addRDateTime( readICalDateTime( rd.time, tz ) );
+          }
+        } else {
+          // TODO: RDates as period are not yet implemented!
+        }
+        break; }
+
+      case ICAL_EXRULE_PROPERTY:
+        readExceptionRule( p, incidence );
+        break;
+
+      case ICAL_EXDATE_PROPERTY:
+        icaltime = icalproperty_get_exdate(p);
+        if ( icaltime_is_date(icaltime) ) {
+          incidence->recurrence()->addExDate( readICalDate(icaltime) );
+        } else {
+          incidence->recurrence()->addExDateTime( readICalDateTime(icaltime, tz) );
+        }
+        break;
+
+      case ICAL_CLASS_PROPERTY:
+        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);
+  }
+
+  // Set the scheduling ID
+  const QString uid = incidence->customProperty( "LIBKCAL", "ID" );
+  if ( !uid.isNull() ) {
+    // The UID stored in incidencebase is actually the scheduling ID
+    // It has to be stored in the iCal UID component for compatibility
+    // with other iCal applications
+    incidence->setSchedulingID( incidence->uid() );
+    incidence->setUid( uid );
+  }
+
+  // Now that recurrence and exception stuff is completely set up,
+  // do any backwards compatibility adjustments.
+  if ( incidence->doesRecur() && mCompat )
+      mCompat->fixRecurrence( incidence );
+
+  // 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);
+  }
+  // Fix incorrect alarm settings by other applications (like outloook 9)
+  if ( mCompat ) mCompat->fixAlarms( 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( readOrganizer(p));
+        break;
+
+      case ICAL_ATTENDEE_PROPERTY:  // attendee
+        incidenceBase->addAttendee(readAttendee(p));
+        break;
+
+      case ICAL_COMMENT_PROPERTY:
+        incidenceBase->addComment(
+            QString::fromUtf8(icalproperty_get_comment(p)));
+        break;
+
+      default:
+        break;
+    }
+
+    p = icalcomponent_get_next_property(parent,ICAL_ANY_PROPERTY);
+  }
+
+  // kpilot stuff
+  // TODO: move this application-specific code to kpilot
+  // need to get X-PILOT* attributes out, set correct properties, and get
+  // rid of them...
+  // Pointer fun, as per libical documentation
+  // (documented in UsingLibical.txt)
+  icalproperty *next =0;
+
+  for ( p = icalcomponent_get_first_property(parent,ICAL_X_PROPERTY);
+       p != 0;
+       p = next )
+  {
+
+    next = icalcomponent_get_next_property(parent,ICAL_X_PROPERTY);
+
+    QString value = QString::fromUtf8(icalproperty_get_x(p));
+    QString name = icalproperty_get_x_name(p);
+
+    if (name == "X-PILOTID" && !value.isEmpty()) {
+      incidenceBase->setPilotId(value.toInt());
+      icalcomponent_remove_property(parent,p);
+    } else if (name == "X-PILOTSTAT" && !value.isEmpty()) {
+      incidenceBase->setSyncStatus(value.toInt());
+      icalcomponent_remove_property(parent,p);
+    }
+  }
+
+  // custom properties
+  readCustomProperties(parent, incidenceBase);
+}
+
+void ICalFormatImpl::readCustomProperties(icalcomponent *parent,CustomProperties *properties)
+{
+  QMap<QCString, QString> customProperties;
+  QString lastProperty;
+
+  icalproperty *p = icalcomponent_get_first_property(parent,ICAL_X_PROPERTY);
+
+  while (p) {
+
+    QString value = QString::fromUtf8(icalproperty_get_x(p));
+    const char *name = icalproperty_get_x_name(p);
+    if ( lastProperty != name ) {
+      customProperties[name] = value;
+    } else {
+      customProperties[name] = customProperties[name].append( "," ).append( value );
+    }
+    // kdDebug(5800) << "Set custom property [" << name << '=' << value << ']' << endl;
+    p = icalcomponent_get_next_property(parent,ICAL_X_PROPERTY);
+    lastProperty = name;
+  }
+
+  properties->setCustomProperties(customProperties);
+}
+
+
+
+void ICalFormatImpl::readRecurrenceRule(icalproperty *rrule,Incidence *incidence )
+{
+//  kdDebug(5800) << "Read recurrence for " << incidence->summary() << endl;
+
+  Recurrence *recur = incidence->recurrence();
+
+  struct icalrecurrencetype r = icalproperty_get_rrule(rrule);
+//   dumpIcalRecurrence(r);
+
+  RecurrenceRule *recurrule = new RecurrenceRule( /*incidence*/ );
+  recurrule->setStartDt( incidence->dtStart() );
+  readRecurrence( r, recurrule );
+  recur->addRRule( recurrule );
+}
+
+void ICalFormatImpl::readExceptionRule( icalproperty *rrule, Incidence *incidence )
+{
+//  kdDebug(5800) << "Read recurrence for " << incidence->summary() << endl;
+
+  struct icalrecurrencetype r = icalproperty_get_exrule(rrule);
+//   dumpIcalRecurrence(r);
+
+  RecurrenceRule *recurrule = new RecurrenceRule( /*incidence*/ );
+  recurrule->setStartDt( incidence->dtStart() );
+  readRecurrence( r, recurrule );
+
+  Recurrence *recur = incidence->recurrence();
+  recur->addExRule( recurrule );
+}
+
+void ICalFormatImpl::readRecurrence( const struct icalrecurrencetype &r, RecurrenceRule* recur )
+{
+  // Generate the RRULE string
+  recur->mRRule = QString( icalrecurrencetype_as_string( const_cast<struct icalrecurrencetype*>(&r) ) );
+  // Period
+  switch ( r.freq ) {
+    case ICAL_SECONDLY_RECURRENCE: recur->setRecurrenceType( RecurrenceRule::rSecondly ); break;
+    case ICAL_MINUTELY_RECURRENCE: recur->setRecurrenceType( RecurrenceRule::rMinutely ); break;
+    case ICAL_HOURLY_RECURRENCE: recur->setRecurrenceType( RecurrenceRule::rHourly ); break;
+    case ICAL_DAILY_RECURRENCE: recur->setRecurrenceType( RecurrenceRule::rDaily ); break;
+    case ICAL_WEEKLY_RECURRENCE: recur->setRecurrenceType( RecurrenceRule::rWeekly ); break;
+    case ICAL_MONTHLY_RECURRENCE: recur->setRecurrenceType( RecurrenceRule::rMonthly ); break;
+    case ICAL_YEARLY_RECURRENCE: recur->setRecurrenceType( RecurrenceRule::rYearly ); break;
+    case ICAL_NO_RECURRENCE:
+    default:
+        recur->setRecurrenceType( RecurrenceRule::rNone );
+  }
+  // Frequency
+  recur->setFrequency( r.interval );
+
+  // Duration & End Date
+  if ( !icaltime_is_null_time( r.until ) ) {
+    icaltimetype t;
+    t = r.until;
+    // Convert to the correct time zone! it's in UTC by specification.
+    QDateTime endDate( readICalDateTime(t) );
+    recur->setEndDt( endDate );
+  } else {
+    if (r.count == 0)
+      recur->setDuration( -1 );
+    else
+      recur->setDuration( r.count );
+  }
+
+  // Week start setting
+  int wkst = (r.week_start + 5)%7 + 1;
+  recur->setWeekStart( wkst );
+
+  // And now all BY*
+  QValueList<int> lst;
+  int i;
+  int index = 0;
+
+#define readSetByList(rrulecomp,setfunc) \
+  index = 0; \
+  lst.clear(); \
+  while ( (i = r.rrulecomp[index++] ) != ICAL_RECURRENCE_ARRAY_MAX ) \
+    lst.append( i ); \
+  if ( !lst.isEmpty() ) recur->setfunc( lst );
+
+  // BYSECOND, MINUTE and HOUR, MONTHDAY, YEARDAY, WEEKNUMBER, MONTH
+  // and SETPOS are standard int lists, so we can treat them with the
+  // same macro
+  readSetByList( by_second, setBySeconds );
+  readSetByList( by_minute, setByMinutes );
+  readSetByList( by_hour, setByHours );
+  readSetByList( by_month_day, setByMonthDays );
+  readSetByList( by_year_day, setByYearDays );
+  readSetByList( by_week_no, setByWeekNumbers );
+  readSetByList( by_month, setByMonths );
+  readSetByList( by_set_pos, setBySetPos );
+#undef readSetByList
+
+  // BYDAY is a special case, since it's not an int list
+  QValueList<RecurrenceRule::WDayPos> wdlst;
+  short day;
+  index=0;
+  while((day = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
+    RecurrenceRule::WDayPos pos;
+    pos.setDay( ( icalrecurrencetype_day_day_of_week( day ) + 5 )%7 + 1 );
+    pos.setPos( icalrecurrencetype_day_position( day ) );
+//     kdDebug(5800)<< "    o) By day, index="<<index-1<<", pos="<<pos.Pos<<", day="<<pos.Day<<endl;
+    wdlst.append( pos );
+  }
+  if ( !wdlst.isEmpty() ) recur->setByDays( wdlst );
+
+
+  // TODO Store all X- fields of the RRULE inside the recurrence (so they are
+  // preserved
+}
+
+
+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);
+  Alarm::Type type = Alarm::Display;
+  icalproperty_action action = ICAL_ACTION_DISPLAY;
+  if ( !p ) {
+    kdDebug(5800) << "Unknown type of alarm, using default" << endl;
+//    return;
+  } else {
+
+    action = icalproperty_get_action(p);
+    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:
+        kdDebug(5800) << "Unknown type of alarm: " << action << endl;
+//        type = Alarm::Invalid;
+    }
+  }
+  ialarm->setType(type);
+// kdDebug(5800) << " alarm type =" << type << endl;
+
+  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));
+        if ( email.startsWith("mailto:", false ) ) {
+          email = email.mid( 7 );
+        }
+        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: {
+        Attachment *attach = readAttachment( p );
+        if ( attach && attach->isUri() ) {
+          switch ( action ) {
+            case ICAL_ACTION_AUDIO:
+              ialarm->setAudioFile( attach->uri() );
+              break;
+            case ICAL_ACTION_PROCEDURE:
+              ialarm->setProgramFile( attach->uri() );
+              break;
+            case ICAL_ACTION_EMAIL:
+              ialarm->addMailAttachment( attach->uri() );
+              break;
+            default:
+              break;
+          }
+        } else {
+          kdDebug() << "Alarm attachments currently only support URIs, but "
+                       "no binary data" << endl;
+        }
+        delete attach;
+        break;
+      }
+      default:
+        break;
+    }
+
+    p = icalcomponent_get_next_property(alarm,ICAL_ANY_PROPERTY);
+  }
+
+  // custom properties
+  readCustomProperties(alarm, ialarm);
+
+  // TODO: check for consistency of alarm properties
+}
+
+icaldatetimeperiodtype ICalFormatImpl::writeICalDatePeriod( const QDate &date )
+{
+  icaldatetimeperiodtype t;
+  t.time = writeICalDate( date );
+  t.period = icalperiodtype_null_period();
+  return t;
+}
+
+icaldatetimeperiodtype ICalFormatImpl::writeICalDateTimePeriod( const QDateTime &date )
+{
+  icaldatetimeperiodtype t;
+  t.time = writeICalDateTime( date );
+  t.period = icalperiodtype_null_period();
+  return t;
+}
+
+icaltimetype ICalFormatImpl::writeICalDate(const QDate &date)
+{
+  icaltimetype t = icaltime_null_time();
+
+  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 &datetime)
+{
+  icaltimetype t = icaltime_null_time();
+
+  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();
+
+  t.is_date = 0;
+  t.zone = icaltimezone_get_builtin_timezone ( mParent->timeZoneId().latin1() );
+  t.is_utc = 0;
+
+ // _dumpIcaltime( t );
+  /* The QDateTime we get passed in is to be considered in the timezone of
+   * the current calendar (mParent's), or, if there is none, to be floating.
+   * In the later case store a floating time, in the former normalize to utc. */
+  if (mParent->timeZoneId().isEmpty())
+    t = icaltime_convert_to_zone( t, 0 ); //make floating timezone
+  else {
+    icaltimezone* tz = icaltimezone_get_builtin_timezone ( mParent->timeZoneId().latin1() );
+    icaltimezone* utc = icaltimezone_get_utc_timezone();
+    if ( tz != utc ) {
+      t.zone = tz;
+      t = icaltime_convert_to_zone( t, utc );
+    } else {
+      t.is_utc = 1;
+      t.zone = utc;
+    }
+  }
+//  _dumpIcaltime( t );
+
+  return t;
+}
+
+QDateTime ICalFormatImpl::readICalDateTime( icaltimetype& t, icaltimezone* tz )
+{
+//   kdDebug(5800) << "ICalFormatImpl::readICalDateTime()" << endl;
+  icaltimezone *zone = tz;
+  if ( tz && t.is_utc == 0 ) { // Only use the TZ if time is not UTC.
+    // FIXME: We'll need to make sure to apply the appropriate TZ, not just
+    //        the first one found.
+    t.zone = tz;
+    t.is_utc = (tz == icaltimezone_get_utc_timezone())?1:0;
+  } else {
+    zone = icaltimezone_get_utc_timezone();
+  }
+  //_dumpIcaltime( t );
+
+  // Convert to view time
+  if ( !mParent->timeZoneId().isEmpty() && t.zone ) {
+//    kdDebug(5800) << "--- Converting time from: " << icaltimezone_get_tzid( const_cast<icaltimezone*>( t.zone ) ) << " (" << ICalDate2QDate(t) << ")." << endl;
+    icaltimezone* viewTimeZone = icaltimezone_get_builtin_timezone ( mParent->timeZoneId().latin1() );
+    icaltimezone_convert_time(  &t, zone, viewTimeZone );
+//    kdDebug(5800) << "--- Converted to zone " << mParent->timeZoneId() << " (" << ICalDate2QDate(t) << ")." << endl;
+  }
+
+  return ICalDate2QDate(t);
+}
+
+QDate ICalFormatImpl::readICalDate(icaltimetype t)
+{
+  return ICalDate2QDate(t).date();
+}
+
+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
+
+  icalproperty *p;
+
+  p = icalcomponent_get_first_property(calendar,ICAL_PRODID_PROPERTY);
+  if (!p) {
+    kdDebug(5800) << "No PRODID property found" << endl;
+    mLoadedProductId = "";
+  } else {
+    mLoadedProductId = QString::fromUtf8(icalproperty_get_prodid(p));
+//    kdDebug(5800) << "VCALENDAR prodid: '" << mLoadedProductId << "'" << endl;
+
+    delete mCompat;
+    mCompat = CompatFactory::createCompat( mLoadedProductId );
+  }
+
+  p = icalcomponent_get_first_property(calendar,ICAL_VERSION_PROPERTY);
+  if (!p) {
+    kdDebug(5800) << "No VERSION property found" << endl;
+    mParent->setException(new ErrorFormat(ErrorFormat::CalVersionUnknown));
+    return false;
+  } else {
+    const char *version = icalproperty_get_version(p);
+//    kdDebug(5800) << "VCALENDAR version: '" << version << "'" << endl;
+
+    if (strcmp(version,"1.0") == 0) {
+      kdDebug(5800) << "Expected iCalendar, got vCalendar" << endl;
+      mParent->setException(new ErrorFormat(ErrorFormat::CalVersion1,
+                            i18n("Expected iCalendar format")));
+      return false;
+    } else if (strcmp(version,"2.0") != 0) {
+      kdDebug(5800) << "Expected iCalendar, got unknown format" << endl;
+      mParent->setException(new ErrorFormat(ErrorFormat::CalVersionUnknown));
+      return false;
+    }
+  }
+
+  // custom properties
+  readCustomProperties(calendar, cal);
+
+// TODO: set time zone
+
+  // read a VTIMEZONE if there is one
+  icalcomponent *ctz =
+    icalcomponent_get_first_component( calendar, ICAL_VTIMEZONE_COMPONENT );
+
+  // Store all events with a relatedTo property in a list for post-processing
+  mEventsRelate.clear();
+  mTodosRelate.clear();
+  // TODO: make sure that only actually added events 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 (todo) {
+      if (!cal->todo(todo->uid())) {
+        cal->addTodo(todo);
+      } else {
+        delete todo;
+        mTodosRelate.remove( 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, ctz);
+    if (event) {
+      if (!cal->event(event->uid())) {
+        cal->addEvent(event);
+      } else {
+        delete event;
+        mEventsRelate.remove( 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 (journal) {
+      if (!cal->journal(journal->uid())) {
+        cal->addJournal(journal);
+      } else {
+        delete journal;
+      }
+    }
+    c = icalcomponent_get_next_component(calendar,ICAL_VJOURNAL_COMPONENT);
+  }
+
+  // Post-Process list of events with relations, put Event objects in relation
+  Event::List::ConstIterator eIt;
+  for ( eIt = mEventsRelate.begin(); eIt != mEventsRelate.end(); ++eIt ) {
+    (*eIt)->setRelatedTo( cal->incidence( (*eIt)->relatedToUid() ) );
+  }
+  Todo::List::ConstIterator tIt;
+  for ( tIt = mTodosRelate.begin(); tIt != mTodosRelate.end(); ++tIt ) {
+    (*tIt)->setRelatedTo( cal->incidence( (*tIt)->relatedToUid() ) );
+   }
+
+  return true;
+}
+
+QString ICalFormatImpl::extractErrorProperty(icalcomponent *c)
+{
+//  kdDebug(5800) << "ICalFormatImpl:extractErrorProperty: "
+//            << icalcomponent_as_ical_string(c) << endl;
+
+  QString errorMessage;
+
+  icalproperty *error;
+  error = icalcomponent_get_first_property(c,ICAL_XLICERROR_PROPERTY);
+  while(error) {
+    errorMessage += icalproperty_get_xlicerror(error);
+    errorMessage += "\n";
+    error = icalcomponent_get_next_property(c,ICAL_XLICERROR_PROPERTY);
+  }
+
+//  kdDebug(5800) << "ICalFormatImpl:extractErrorProperty: " << errorMessage << endl;
+
+  return errorMessage;
+}
+
+void ICalFormatImpl::dumpIcalRecurrence(icalrecurrencetype r)
+{
+  int i;
+
+  kdDebug(5800) << " Freq: " << r.freq << endl;
+  kdDebug(5800) << " Until: " << icaltime_as_ical_string(r.until) << endl;
+  kdDebug(5800) << " Count: " << r.count << endl;
+  if (r.by_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
+    int index = 0;
+    QString out = " By Day: ";
+    while((i = r.by_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
+      out.append(QString::number(i) + " ");
+    }
+    kdDebug(5800) << out << endl;
+  }
+  if (r.by_month_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
+    int index = 0;
+    QString out = " By Month Day: ";
+    while((i = r.by_month_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
+      out.append(QString::number(i) + " ");
+    }
+    kdDebug(5800) << out << endl;
+  }
+  if (r.by_year_day[0] != ICAL_RECURRENCE_ARRAY_MAX) {
+    int index = 0;
+    QString out = " By Year Day: ";
+    while((i = r.by_year_day[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
+      out.append(QString::number(i) + " ");
+    }
+    kdDebug(5800) << out << endl;
+  }
+  if (r.by_month[0] != ICAL_RECURRENCE_ARRAY_MAX) {
+    int index = 0;
+    QString out = " By Month: ";
+    while((i = r.by_month[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
+      out.append(QString::number(i) + " ");
+    }
+    kdDebug(5800) << out << endl;
+  }
+  if (r.by_set_pos[0] != ICAL_RECURRENCE_ARRAY_MAX) {
+    int index = 0;
+    QString out = " By Set Pos: ";
+    while((i = r.by_set_pos[index++]) != ICAL_RECURRENCE_ARRAY_MAX) {
+      kdDebug(5800) << "========= " << i << endl;
+      out.append(QString::number(i) + " ");
+    }
+    kdDebug(5800) << out << endl;
+  }
+}
+
+icalcomponent *ICalFormatImpl::createScheduleComponent(IncidenceBase *incidence,
+                                                   Scheduler::Method method)
+{
+  icalcomponent *message = createCalendarComponent();
+
+  icalproperty_method icalmethod = ICAL_METHOD_NONE;
+
+  switch (method) {
+    case Scheduler::Publish:
+      icalmethod = ICAL_METHOD_PUBLISH;
+      break;
+    case Scheduler::Request:
+      icalmethod = ICAL_METHOD_REQUEST;
+      break;
+    case Scheduler::Refresh:
+      icalmethod = ICAL_METHOD_REFRESH;
+      break;
+    case Scheduler::Cancel:
+      icalmethod = ICAL_METHOD_CANCEL;
+      break;
+    case Scheduler::Add:
+      icalmethod = ICAL_METHOD_ADD;
+      break;
+    case Scheduler::Reply:
+      icalmethod = ICAL_METHOD_REPLY;
+      break;
+    case Scheduler::Counter:
+      icalmethod = ICAL_METHOD_COUNTER;
+      break;
+    case Scheduler::Declinecounter:
+      icalmethod = ICAL_METHOD_DECLINECOUNTER;
+      break;
+    default:
+      kdDebug(5800) << "ICalFormat::createScheduleMessage(): Unknow method" << endl;
+      return message;
+  }
+
+  icalcomponent_add_property(message,icalproperty_new_method(icalmethod));
+
+  icalcomponent *inc = writeIncidence( incidence, method );
+  /*
+   * RFC 2446 states in section 3.4.3 ( REPLY to a VTODO ), that
+   * a REQUEST-STATUS property has to be present. For the other two, event and
+   * free busy, it can be there, but is optional. Until we do more
+   * fine grained handling, assume all is well. Note that this is the
+   * status of the _request_, not the attendee. Just to avoid confusion.
+   * - till
+   */
+  if ( icalmethod == ICAL_METHOD_REPLY ) {
+    struct icalreqstattype rst;
+    rst.code = ICAL_2_0_SUCCESS_STATUS;
+    rst.desc = 0;
+    rst.debug = 0;
+    icalcomponent_add_property( inc, icalproperty_new_requeststatus( rst ) );
+  }
+  icalcomponent_add_component( message, inc );
+
+  return message;
+}